[function.objects] - C++20 → C++23

Files changed (1) hide show

tmp/tmps52ajdpa/{from.md → to.md} +651 -232

tmp/tmps52ajdpa/{from.md → to.md} RENAMED Viewed

@@ -1,136 +1,167 @@
 ## Function objects <a id="function.objects">[[function.objects]]</a>
-A *function object type* is an object type [[basic.types]] that can be
-the type of the *postfix-expression* in a function call ([[expr.call]],
-[[over.match.call]]).[^2] A *function object* is an object of a function
-object type. In the places where one would expect to pass a pointer to a
-function to an algorithmic template [[algorithms]], the interface is
-specified to accept a function object. This not only makes algorithmic
-templates work with pointers to functions, but also enables them to work
-with arbitrary function objects.
 ### Header `<functional>` synopsis <a id="functional.syn">[[functional.syn]]</a>
 ``` cpp
 namespace std {
   // [func.invoke], invoke
   template<class F, class... Args>
-    constexpr invoke_result_t<F, Args...> invoke(F&& f, Args&&... args)
       noexcept(is_nothrow_invocable_v<F, Args...>);
   // [refwrap], reference_wrapper
-  template<class T> class reference_wrapper;
-  template<class T> constexpr reference_wrapper<T> ref(T&) noexcept;
-  template<class T> constexpr reference_wrapper<const T> cref(const T&) noexcept;
-  template<class T> void ref(const T&&) = delete;
-  template<class T> void cref(const T&&) = delete;
-  template<class T> constexpr reference_wrapper<T> ref(reference_wrapper<T>) noexcept;
-  template<class T> constexpr reference_wrapper<const T> cref(reference_wrapper<T>) noexcept;
   // [arithmetic.operations], arithmetic operations
-  template<class T = void> struct plus;
-  template<class T = void> struct minus;
-  template<class T = void> struct multiplies;
-  template<class T = void> struct divides;
-  template<class T = void> struct modulus;
-  template<class T = void> struct negate;
-  template<> struct plus<void>;
-  template<> struct minus<void>;
-  template<> struct multiplies<void>;
-  template<> struct divides<void>;
-  template<> struct modulus<void>;
-  template<> struct negate<void>;
   // [comparisons], comparisons
-  template<class T = void> struct equal_to;
-  template<class T = void> struct not_equal_to;
-  template<class T = void> struct greater;
-  template<class T = void> struct less;
-  template<class T = void> struct greater_equal;
-  template<class T = void> struct less_equal;
-  template<> struct equal_to<void>;
-  template<> struct not_equal_to<void>;
-  template<> struct greater<void>;
-  template<> struct less<void>;
-  template<> struct greater_equal<void>;
-  template<> struct less_equal<void>;
   // [comparisons.three.way], class compare_three_way
-  struct compare_three_way;
   // [logical.operations], logical operations
-  template<class T = void> struct logical_and;
-  template<class T = void> struct logical_or;
-  template<class T = void> struct logical_not;
-  template<> struct logical_and<void>;
-  template<> struct logical_or<void>;
-  template<> struct logical_not<void>;
   // [bitwise.operations], bitwise operations
-  template<class T = void> struct bit_and;
-  template<class T = void> struct bit_or;
-  template<class T = void> struct bit_xor;
-  template<class T = void> struct bit_not;
-  template<> struct bit_and<void>;
-  template<> struct bit_or<void>;
-  template<> struct bit_xor<void>;
-  template<> struct bit_not<void>;
   // [func.identity], identity
-  struct identity;
   // [func.not.fn], function template not_fn
-  template<class F> constexpr unspecified not_fn(F&& f);
-  // [func.bind.front], function template bind_front
-  template<class F, class... Args> constexpr unspecified bind_front(F&&, Args&&...);
   // [func.bind], bind
-  template<class T> struct is_bind_expression;
   template<class T>
- inline constexpr bool is_bind_expression_v = is_bind_expression<T>::value;
-  template<class T> struct is_placeholder;
   template<class T>
- inline constexpr int is_placeholder_v = is_placeholder<T>::value;
   template<class F, class... BoundArgs>
-    constexpr unspecified bind(F&&, BoundArgs&&...);
   template<class R, class F, class... BoundArgs>
-    constexpr unspecified bind(F&&, BoundArgs&&...);
   namespace placeholders {
     // M is the implementation-defined number of placeholders
-    see belownc _1;
-    see belownc _2;
                .
                .
                .
-    see belownc _M;
   }
   // [func.memfn], member function adaptors
   template<class R, class T>
-    constexpr unspecified mem_fn(R T::*) noexcept;
   // [func.wrap], polymorphic function wrappers
   class bad_function_call;
   template<class> class function;       // not defined
   template<class R, class... ArgTypes> class function<R(ArgTypes...)>;
   template<class R, class... ArgTypes>
     void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)>&) noexcept;
   template<class R, class... ArgTypes>
     bool operator==(const function<R(ArgTypes...)>&, nullptr_t) noexcept;
   // [func.search], searchers
-  template<class ForwardIterator, class BinaryPredicate = equal_to<>>
-    class default_searcher;
   template<class RandomAccessIterator,
            class Hash = hash<typename iterator_traits<RandomAccessIterator>::value_type>,
            class BinaryPredicate = equal_to<>>
     class boyer_moore_searcher;
@@ -140,20 +171,20 @@ namespace std {
            class BinaryPredicate = equal_to<>>
     class boyer_moore_horspool_searcher;
   // [unord.hash], class template hash
   template<class T>
-    struct hash;
   namespace ranges {
     // [range.cmp], concept-constrained comparisons
-    struct equal_to;
-    struct not_equal_to;
-    struct greater;
-    struct less;
-    struct greater_equal;
-    struct less_equal;
   }
 }
 ```
 [*Example 1*:
@@ -206,35 +237,38 @@ collectively referred to as *state entities*.
 ### Requirements <a id="func.require">[[func.require]]</a>
 Define `INVOKE(f, t₁, t₂, …, t_N)` as follows:
 - `(t₁.*f)(t₂, …, t_N)` when `f` is a pointer to a member function of a
-  class `T` and `is_base_of_v<T, remove_reference_t<decltype(t₁)>>` is
-  `true`;
 - `(t₁.get().*f)(t₂, …, t_N)` when `f` is a pointer to a member function
   of a class `T` and `remove_cvref_t<decltype(t₁)>` is a specialization
   of `reference_wrapper`;
 - `((*t₁).*f)(t₂, …, t_N)` when `f` is a pointer to a member function of
   a class `T` and `t₁` does not satisfy the previous two items;
-- `t₁.*f` when `N == 1` and `f` is a pointer to data member of a class
- `T` and `is_base_of_v<T, remove_reference_t<decltype(t₁)>>` is `true`;
-- `t₁.get().*f` when `N == 1` and `f` is a pointer to data member of a
   class `T` and `remove_cvref_t<decltype(t₁)>` is a specialization of
   `reference_wrapper`;
-- `(*t₁).*f` when `N == 1` and `f` is a pointer to data member of a
- class `T` and `t₁` does not satisfy the previous two items;
 - `f(t₁, t₂, …, t_N)` in all other cases.
 Define `INVOKE<R>(f, t₁, t₂, …, t_N)` as
 `static_cast<void>(INVOKE(f, t₁, t₂, …, t_N))` if `R` is cv `void`,
-otherwise `INVOKE(f, t₁, t₂, …, t_N)` implicitly converted to `R`.
 Every call wrapper [[func.def]] meets the *Cpp17MoveConstructible* and
 *Cpp17Destructible* requirements. An *argument forwarding call wrapper*
 is a call wrapper that can be called with an arbitrary argument list and
-delivers the arguments to the wrapped callable object as references.
-This forwarding step delivers rvalue arguments as rvalue references and
 lvalue arguments as lvalue references.
 [*Note 1*:
 In a typical implementation, argument forwarding call wrappers have an
@@ -255,11 +289,11 @@ and as cv `T&&` otherwise, where cv represents the cv-qualifiers of the
 call wrapper and where cv shall be neither `volatile` nor
 `const volatile`.
 A *call pattern* defines the semantics of invoking a perfect forwarding
 call wrapper. A postfix call performed on a perfect forwarding call
-wrapper is expression-equivalent [[defns.expression-equivalent]] to an
 expression `e` determined from its call pattern `cp` by replacing all
 occurrences of the arguments of the call wrapper and its state entities
 with references as described in the corresponding forwarding steps.
 A *simple call wrapper* is a perfect forwarding call wrapper that meets
@@ -278,61 +312,79 @@ would be considered to be constexpr. — *end note*]
 Argument forwarding call wrappers returned by a given standard library
 function template have the same type if the types of their corresponding
 state entities are the same.
-### Function template `invoke` <a id="func.invoke">[[func.invoke]]</a>
 ``` cpp
 template<class F, class... Args>
   constexpr invoke_result_t<F, Args...> invoke(F&& f, Args&&... args)
     noexcept(is_nothrow_invocable_v<F, Args...>);
 ```
 *Returns:* *INVOKE*(std::forward\<F\>(f),
 std::forward\<Args\>(args)...) [[func.require]].
 ### Class template `reference_wrapper` <a id="refwrap">[[refwrap]]</a>
 ``` cpp
 namespace std {
   template<class T> class reference_wrapper {
   public:
     // types
     using type = T;
-    // construct/copy/destroy
     template<class U>
       constexpr reference_wrapper(U&&) noexcept(see below);
     constexpr reference_wrapper(const reference_wrapper& x) noexcept;
-    // assignment
     constexpr reference_wrapper& operator=(const reference_wrapper& x) noexcept;
-    // access
     constexpr operator T& () const noexcept;
     constexpr T& get() const noexcept;
-    // invocation
     template<class... ArgTypes>
-      constexpr invoke_result_t<T&, ArgTypes...> operator()(ArgTypes&&...) const;
   };
   template<class T>
     reference_wrapper(T&) -> reference_wrapper<T>;
 }
 ```
 `reference_wrapper<T>` is a *Cpp17CopyConstructible* and
 *Cpp17CopyAssignable* wrapper around a reference to an object or
 function of type `T`.
-`reference_wrapper<T>` is a trivially copyable type [[basic.types]].
 The template parameter `T` of `reference_wrapper` may be an incomplete
 type.
-#### Constructors and destructor <a id="refwrap.const">[[refwrap.const]]</a>
 ``` cpp
 template<class U>
   constexpr reference_wrapper(U&& u) noexcept(see below);
 ```
@@ -349,11 +401,11 @@ void FUN(T&&) = delete;
 *Effects:* Creates a variable `r` as if by `T& r = std::forward<U>(u)`,
 then constructs a `reference_wrapper` object that stores a reference to
 `r`.
-*Remarks:* The expression inside `noexcept` is equivalent to
 `noexcept(`*`FUN`*`(declval<U>()))`.
 ``` cpp
 constexpr reference_wrapper(const reference_wrapper& x) noexcept;
 ```
@@ -386,11 +438,11 @@ constexpr T& get() const noexcept;
 #### Invocation <a id="refwrap.invoke">[[refwrap.invoke]]</a>
 ``` cpp
 template<class... ArgTypes>
   constexpr invoke_result_t<T&, ArgTypes...>
-    operator()(ArgTypes&&... args) const;
 ```
 *Mandates:* `T` is a complete type.
 *Returns:* *INVOKE*(get(),
@@ -409,11 +461,11 @@ template<class T> constexpr reference_wrapper<T> ref(T& t) noexcept;
 ``` cpp
 template<class T> constexpr reference_wrapper<T> ref(reference_wrapper<T> t) noexcept;
 ```
-*Returns:* `ref(t.get())`.
 ``` cpp
 template<class T> constexpr reference_wrapper<const T> cref(const T& t) noexcept;
 ```
@@ -421,16 +473,50 @@ template<class T> constexpr reference_wrapper<const T> cref(const T& t) noexcept
 ``` cpp
 template<class T> constexpr reference_wrapper<const T> cref(reference_wrapper<T> t) noexcept;
 ```
-*Returns:* `cref(t.get())`.
 ### Arithmetic operations <a id="arithmetic.operations">[[arithmetic.operations]]</a>
 The library provides basic function object classes for all of the
-arithmetic operators in the language ([[expr.mul]], [[expr.add]]).
 #### Class template `plus` <a id="arithmetic.operations.plus">[[arithmetic.operations.plus]]</a>
 ``` cpp
 template<class T = void> struct plus {
@@ -610,12 +696,14 @@ template<class T> constexpr auto operator()(T&& t) const
 *Returns:* `-std::forward<T>(t)`.
 ### Comparisons <a id="comparisons">[[comparisons]]</a>
 The library provides basic function object classes for all of the
-comparison operators in the language ([[expr.rel]], [[expr.eq]]).
 For templates `less`, `greater`, `less_equal`, and `greater_equal`, the
 specializations for any pointer type yield a result consistent with the
 implementation-defined strict total order over pointers
 [[defns.order.ptr]].
@@ -810,41 +898,34 @@ template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
 *Returns:* `std::forward<T>(t) <= std::forward<U>(u)`.
 #### Class `compare_three_way` <a id="comparisons.three.way">[[comparisons.three.way]]</a>
-In this subclause, `BUILTIN-PTR-THREE-WAY(T, U)` for types `T` and `U`
-is a boolean constant expression. `BUILTIN-PTR-THREE-WAY(T, U)` is
-`true` if and only if `<=>` in the expression
-``` cpp
-declval<T>() <=> declval<U>()
-```
-resolves to a built-in operator comparing pointers.
 ``` cpp
   struct compare_three_way {
     template<class T, class U>
-    requires three_way_comparable_with<T, U> || BUILTIN-PTR-THREE-WAY(T, U)
       constexpr auto operator()(T&& t, U&& u) const;
     using is_transparent = unspecified;
   };
 ```
 ``` cpp
 template<class T, class U>
-  requires three_way_comparable_with<T, U> || BUILTIN-PTR-THREE-WAY(T, U)
   constexpr auto operator()(T&& t, U&& u) const;
 ```
 *Preconditions:* If the expression
 `std::forward<T>(t) <=> std::forward<U>(u)` results in a call to a
 built-in operator `<=>` comparing pointers of type `P`, the conversion
 sequences from both `T` and `U` to `P` are
-equality-preserving [[concepts.equality]].
 *Effects:*
 - If the expression `std::forward<T>(t) <=> std::forward<U>(u)` results
   in a call to a built-in operator `<=>` comparing pointers of type `P`,
@@ -855,31 +936,32 @@ equality-preserving [[concepts.equality]].
 - Otherwise, equivalent to:
   `return std::forward<T>(t) <=> std::forward<U>(u);`
 ### Concept-constrained comparisons <a id="range.cmp">[[range.cmp]]</a>
-In this subclause, `BUILTIN-PTR-CMP(T, op, U)` for types `T` and `U` and
-where op is an equality [[expr.eq]] or relational operator [[expr.rel]]
-is a boolean constant expression. `BUILTIN-PTR-CMP(T, op, U)` is `true`
-if and only if op in the expression `declval<T>() op declval<U>()`
-resolves to a built-in operator comparing pointers.
 ``` cpp
 struct ranges::equal_to {
   template<class T, class U>
-    requires equality_comparable_with<T, U> || BUILTIN-PTR-CMP(T, ==, U)
     constexpr bool operator()(T&& t, U&& u) const;
   using is_transparent = unspecified;
 };
 ```
 *Preconditions:* If the expression
 `std::forward<T>(t) == std::forward<U>(u)` results in a call to a
 built-in operator `==` comparing pointers of type `P`, the conversion
 sequences from both `T` and `U` to `P` are
-equality-preserving [[concepts.equality]].
 *Effects:*
 - If the expression `std::forward<T>(t) == std::forward<U>(u)` results
   in a call to a built-in operator `==` comparing pointers: returns
@@ -890,56 +972,75 @@ equality-preserving [[concepts.equality]].
   `return std::forward<T>(t) == std::forward<U>(u);`
 ``` cpp
 struct ranges::not_equal_to {
   template<class T, class U>
-    requires equality_comparable_with<T, U> || BUILTIN-PTR-CMP(T, ==, U)
     constexpr bool operator()(T&& t, U&& u) const;
   using is_transparent = unspecified;
 };
 ```
-`operator()` has effects equivalent to:
 ``` cpp
 return !ranges::equal_to{}(std::forward<T>(t), std::forward<U>(u));
 ```
 ``` cpp
 struct ranges::greater {
   template<class T, class U>
-    requires totally_ordered_with<T, U> || BUILTIN-PTR-CMP(U, <, T)
   constexpr bool operator()(T&& t, U&& u) const;
   using is_transparent = unspecified;
 };
 ```
-`operator()` has effects equivalent to:
 ``` cpp
 return ranges::less{}(std::forward<U>(u), std::forward<T>(t));
 ```
 ``` cpp
 struct ranges::less {
   template<class T, class U>
-    requires totally_ordered_with<T, U> || BUILTIN-PTR-CMP(T, <, U)
     constexpr bool operator()(T&& t, U&& u) const;
   using is_transparent = unspecified;
 };
 ```
 *Preconditions:* If the expression
 `std::forward<T>(t) < std::forward<U>(u)` results in a call to a
 built-in operator `<` comparing pointers of type `P`, the conversion
 sequences from both `T` and `U` to `P` are
-equality-preserving [[concepts.equality]]. For any expressions `ET` and
-`EU` such that `decltype((ET))` is `T` and `decltype((EU))` is `U`,
-exactly one of `ranges::less{}(ET, EU)`, `ranges::less{}(EU, ET)`, or
 `ranges::equal_to{}(ET, EU)` is `true`.
 *Effects:*
 - If the expression `std::forward<T>(t) < std::forward<U>(u)` results in
@@ -951,44 +1052,58 @@ exactly one of `ranges::less{}(ET, EU)`, `ranges::less{}(EU, ET)`, or
   `return std::forward<T>(t) < std::forward<U>(u);`
 ``` cpp
 struct ranges::greater_equal {
   template<class T, class U>
-    requires totally_ordered_with<T, U> || BUILTIN-PTR-CMP(T, <, U)
     constexpr bool operator()(T&& t, U&& u) const;
   using is_transparent = unspecified;
 };
 ```
-`operator()` has effects equivalent to:
 ``` cpp
 return !ranges::less{}(std::forward<T>(t), std::forward<U>(u));
 ```
 ``` cpp
 struct ranges::less_equal {
   template<class T, class U>
-    requires totally_ordered_with<T, U> || BUILTIN-PTR-CMP(U, <, T)
     constexpr bool operator()(T&& t, U&& u) const;
   using is_transparent = unspecified;
 };
 ```
-`operator()` has effects equivalent to:
 ``` cpp
 return !ranges::less{}(std::forward<U>(u), std::forward<T>(t));
 ```
 ### Logical operations <a id="logical.operations">[[logical.operations]]</a>
 The library provides basic function object classes for all of the
-logical operators in the language ([[expr.log.and]], [[expr.log.or]],
-[[expr.unary.op]]).
 #### Class template `logical_and` <a id="logical.operations.and">[[logical.operations.and]]</a>
 ``` cpp
 template<class T = void> struct logical_and {
@@ -1078,13 +1193,15 @@ template<class T> constexpr auto operator()(T&& t) const
 *Returns:* `!std::forward<T>(t)`.
 ### Bitwise operations <a id="bitwise.operations">[[bitwise.operations]]</a>
 The library provides basic function object classes for all of the
-bitwise operators in the language ([[expr.bit.and]], [[expr.or]],
-[[expr.xor]], [[expr.unary.op]]).
 #### Class template `bit_and` <a id="bitwise.operations.and">[[bitwise.operations.and]]</a>
 ``` cpp
 template<class T = void> struct bit_and {
@@ -1196,11 +1313,11 @@ template<> struct bit_not<void> {
   using is_transparent = unspecified;
 };
 ```
 ``` cpp
-template<class T> constexpr auto operator()(T&&) const
     -> decltype(~std::forward<T>(t));
 ```
 *Returns:* `~std::forward<T>(t)`.
@@ -1238,25 +1355,29 @@ In the text that follows:
 *Mandates:* `is_constructible_v<FD, F> && is_move_constructible_v<FD>`
 is `true`.
 *Preconditions:* `FD` meets the *Cpp17MoveConstructible* requirements.
-*Returns:* A perfect forwarding call wrapper `g` with call pattern
 `!invoke(fd, call_args...)`.
 *Throws:* Any exception thrown by the initialization of `fd`.
-### Function template `bind_front` <a id="func.bind.front">[[func.bind.front]]</a>
 ``` cpp
 template<class F, class... Args>
   constexpr unspecified bind_front(F&& f, Args&&... args);
 ```
-In the text that follows:
-- `g` is a value of the result of a `bind_front` invocation,
 - `FD` is the type `decay_t<F>`,
 - `fd` is the target object of `g` [[func.def]] of type `FD`,
   direct-non-list-initialized with `std::forward<F>(f)`,
 - `BoundArgs` is a pack that denotes `decay_t<Args>...`,
 - `bound_args` is a pack of bound argument entities of `g` [[func.def]]
@@ -1278,20 +1399,27 @@ is `true`.
 *Preconditions:* `FD` meets the *Cpp17MoveConstructible* requirements.
 For each `Tᵢ` in `BoundArgs`, if `Tᵢ` is an object type, `Tᵢ` meets the
 *Cpp17MoveConstructible* requirements.
-*Returns:* A perfect forwarding call wrapper `g` with call pattern
-`invoke(fd, bound_args..., call_args...)`.
 *Throws:* Any exception thrown by the initialization of the state
 entities of `g` [[func.def]].
 ### Function object binders <a id="func.bind">[[func.bind]]</a>
-This subclause describes a uniform mechanism for binding arguments of
-callable objects.
 #### Class template `is_bind_expression` <a id="func.bind.isbind">[[func.bind.isbind]]</a>
 ``` cpp
 namespace std {
@@ -1319,12 +1447,12 @@ namespace std {
   template<class T> struct is_placeholder;      // see below
 }
 ```
 The class template `is_placeholder` can be used to detect the standard
-placeholders `_1`, `_2`, and so on. The function template `bind` uses
-`is_placeholder` to detect placeholders.
 Specializations of the `is_placeholder` template shall meet the
 *Cpp17UnaryTypeTrait* requirements [[meta.rqmts]]. The implementation
 provides a definition that has the base characteristic of
 `integral_constant<int, J>` if `T` is the type of
@@ -1368,11 +1496,11 @@ $w_N$) [[func.require]] is a valid expression for some values `w₁`,
 *Returns:* An argument forwarding call wrapper `g` [[func.require]]. A
 program that attempts to invoke a volatile-qualified `g` is ill-formed.
 When `g` is not volatile-qualified, invocation of
 `g(``u₁``, ``u₂``, `…`, ``u_M``)` is
-expression-equivalent [[defns.expression-equivalent]] to
 ``` cpp
 INVOKE(static_cast<$V_fd$>($v_fd$),
        static_cast<$V_1$>($v_1$), static_cast<$V_2$>($v_2$), …, static_cast<$V_N$>($v_N$))
 ```
@@ -1417,20 +1545,22 @@ type `V`_`fd` is `cv FD&`.
 #### Placeholders <a id="func.bind.place">[[func.bind.place]]</a>
 ``` cpp
 namespace std::placeholders {
-  // M is the implementation-defined number of placeholders
   see below _1;
   see below _2;
               .
               .
               .
   see below _M;
 }
 ```
 All placeholder types meet the *Cpp17DefaultConstructible* and
 *Cpp17CopyConstructible* requirements, and their default constructors
 and copy/move constructors are constexpr functions that do not throw
 exceptions. It is *implementation-defined* whether placeholder types
 meet the *Cpp17CopyAssignable* requirements, but if so, their copy
@@ -1447,26 +1577,30 @@ If they are not, they are declared as:
 ``` cpp
 extern unspecified _1;
 ```
 ### Function template `mem_fn` <a id="func.memfn">[[func.memfn]]</a>
 ``` cpp
 template<class R, class T> constexpr unspecified mem_fn(R T::* pm) noexcept;
 ```
-*Returns:* A simple call wrapper [[func.def]] `fn` with call pattern
-`invoke(pmd, call_args...)`, where `pmd` is the target object of `fn` of
-type `R T::*` direct-non-list-initialized with `pm`, and `call_args` is
-an argument pack used in a function call expression [[expr.call]] of
-`pm`.
 ### Polymorphic function wrappers <a id="func.wrap">[[func.wrap]]</a>
-This subclause describes a polymorphic wrapper class that encapsulates
-arbitrary callable objects.
 #### Class `bad_function_call` <a id="func.wrap.badcall">[[func.wrap.badcall]]</a>
 An exception of type `bad_function_call` is thrown by
 `function::operator()` [[func.wrap.func.inv]] when the function wrapper
@@ -1488,10 +1622,12 @@ const char* what() const noexcept override;
 *Returns:* An *implementation-defined* NTBS.
 #### Class template `function` <a id="func.wrap.func">[[func.wrap.func]]</a>
 ``` cpp
 namespace std {
   template<class> class function;       // not defined
   template<class R, class... ArgTypes>
@@ -1502,11 +1638,11 @@ namespace std {
     // [func.wrap.func.con], construct/copy/destroy
     function() noexcept;
     function(nullptr_t) noexcept;
     function(const function&);
     function(function&&) noexcept;
-    template<class F> function(F);
     function& operator=(const function&);
     function& operator=(function&&);
     function& operator=(nullptr_t) noexcept;
     template<class F> function& operator=(F&&);
@@ -1531,36 +1667,29 @@ namespace std {
   template<class R, class... ArgTypes>
     function(R(*)(ArgTypes...)) -> function<R(ArgTypes...)>;
   template<class F> function(F) -> function<see below>;
-  // [func.wrap.func.nullptr], null pointer comparison functions
-  template<class R, class... ArgTypes>
-    bool operator==(const function<R(ArgTypes...)>&, nullptr_t) noexcept;
-  // [func.wrap.func.alg], specialized algorithms
-  template<class R, class... ArgTypes>
-    void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)>&) noexcept;
 }
 ```
 The `function` class template provides polymorphic wrappers that
 generalize the notion of a function pointer. Wrappers can store, copy,
 and call arbitrary callable objects [[func.def]], given a call signature
-[[func.def]], allowing functions to be first-class objects.
 A callable type [[func.def]] `F` is *Lvalue-Callable* for argument types
 `ArgTypes` and return type `R` if the expression
 `INVOKE<R>(declval<F&>(), declval<ArgTypes>()...)`, considered as an
-unevaluated operand [[expr.prop]], is well-formed [[func.require]].
 The `function` class template is a call wrapper [[func.def]] whose call
 signature [[func.def]] is `R(ArgTypes...)`.
-[*Note 1*: The types deduced by the deduction guides for `function` may
-change in future versions of this International Standard. — *end note*]
 ##### Constructors and destructor <a id="func.wrap.func.con">[[func.wrap.func.con]]</a>
 ``` cpp
 function() noexcept;
@@ -1576,70 +1705,87 @@ function(nullptr_t) noexcept;
 ``` cpp
 function(const function& f);
 ```
-*Ensures:* `!*this` if `!f`; otherwise, `*this` targets a copy of
-`f.target()`.
 *Throws:* Nothing if `f`’s target is a specialization of
 `reference_wrapper` or a function pointer. Otherwise, may throw
 `bad_alloc` or any exception thrown by the copy constructor of the
 stored callable object.
-[*Note 1*: Implementations should avoid the use of dynamically
-allocated memory for small callable objects, for example, where `f`’s
-target is an object holding only a pointer or reference to an object and
-a member function pointer. — *end note*]
 ``` cpp
 function(function&& f) noexcept;
 ```
 *Ensures:* If `!f`, `*this` has no target; otherwise, the target of
 `*this` is equivalent to the target of `f` before the construction, and
 `f` is in a valid state with an unspecified value.
-[*Note 2*: Implementations should avoid the use of dynamically
-allocated memory for small callable objects, for example, where `f`’s
-target is an object holding only a pointer or reference to an object and
-a member function pointer. — *end note*]
 ``` cpp
-template<class F> function(F f);
 ```
-*Constraints:* `F` is Lvalue-Callable [[func.wrap.func]] for argument
-types `ArgTypes...` and return type `R`.
-*Preconditions:* `F` meets the *Cpp17CopyConstructible* requirements.
-*Ensures:* `!*this` if any of the following hold:
 - `f` is a null function pointer value.
 - `f` is a null member pointer value.
-- `F` is an instance of the `function` class template, and `!f`.
-Otherwise, `*this` targets a copy of `f` initialized with
-`std::move(f)`.
-[*Note 3*: Implementations should avoid the use of dynamically
-allocated memory for small callable objects, for example, where `f` is
-an object holding only a pointer or reference to an object and a member
-function pointer. — *end note*]
-*Throws:* Nothing if `f` is a specialization of `reference_wrapper` or a
-function pointer. Otherwise, may throw `bad_alloc` or any exception
-thrown by `F`’s copy or move constructor.
 ``` cpp
 template<class F> function(F) -> function<see below>;
 ```
 *Constraints:* `&F::operator()` is well-formed when treated as an
-unevaluated operand and `decltype(&F::operator())` is of the form
-`R(G::*)(A...)` cv \\ₒₚₜ ` `noexceptₒₚₜ  for a class type `G`.
 *Remarks:* The deduced type is `function<R(A...)>`.
 [*Example 1*:
@@ -1707,11 +1853,11 @@ template<class F> function& operator=(reference_wrapper<F> f) noexcept;
 ``` cpp
 void swap(function& other) noexcept;
 ```
-*Effects:* Interchanges the targets of `*this` and `other`.
 ##### Capacity <a id="func.wrap.func.cap">[[func.wrap.func.cap]]</a>
 ``` cpp
 explicit operator bool() const noexcept;
@@ -1728,11 +1874,11 @@ R operator()(ArgTypes... args) const;
 *Returns:* *INVOKE*\<R\>(f,
 std::forward\<ArgTypes\>(args)...) [[func.require]], where `f` is the
 target object [[func.def]] of `*this`.
 *Throws:* `bad_function_call` if `!*this`; otherwise, any exception
-thrown by the wrapped callable object.
 ##### Target access <a id="func.wrap.func.targ">[[func.wrap.func.targ]]</a>
 ``` cpp
 const type_info& target_type() const noexcept;
@@ -1747,11 +1893,11 @@ template<class T> const T* target() const noexcept;
 ```
 *Returns:* If `target_type() == typeid(T)` a pointer to the stored
 function target; otherwise a null pointer.
-##### Null pointer comparison functions <a id="func.wrap.func.nullptr">[[func.wrap.func.nullptr]]</a>
 ``` cpp
 template<class R, class... ArgTypes>
   bool operator==(const function<R(ArgTypes...)>& f, nullptr_t) noexcept;
 ```
@@ -1765,33 +1911,302 @@ template<class R, class... ArgTypes>
   void swap(function<R(ArgTypes...)>& f1, function<R(ArgTypes...)>& f2) noexcept;
 ```
 *Effects:* As if by: `f1.swap(f2);`
 ### Searchers <a id="func.search">[[func.search]]</a>
-This subclause provides function object types [[function.objects]] for
-operations that search for a sequence \[`pat``first`, `pat_last`) in
-another sequence \[`first`, `last`) that is provided to the object’s
-function call operator. The first sequence (the pattern to be searched
-for) is provided to the object’s constructor, and the second (the
-sequence to be searched) is provided to the function call operator.
-Each specialization of a class template specified in this subclause
-[[func.search]] shall meet the *Cpp17CopyConstructible* and
-*Cpp17CopyAssignable* requirements. Template parameters named
 - `ForwardIterator`,
 - `ForwardIterator1`,
 - `ForwardIterator2`,
 - `RandomAccessIterator`,
 - `RandomAccessIterator1`,
 - `RandomAccessIterator2`, and
 - `BinaryPredicate`
-of templates specified in this subclause [[func.search]] shall meet the
-same requirements and semantics as specified in [[algorithms.general]].
 Template parameters named `Hash` shall meet the *Cpp17Hash* requirements
 ([[cpp17.hash]]).
 The Boyer-Moore searcher implements the Boyer-Moore search algorithm.
 The Boyer-Moore-Horspool searcher implements the Boyer-Moore-Horspool
@@ -1799,10 +2214,11 @@ search algorithm. In general, the Boyer-Moore searcher will use more
 memory and give better runtime performance than Boyer-Moore-Horspool.
 #### Class template `default_searcher` <a id="func.search.default">[[func.search.default]]</a>
 ``` cpp
   template<class ForwardIterator1, class BinaryPredicate = equal_to<>>
   class default_searcher {
   public:
     constexpr default_searcher(ForwardIterator1 pat_first, ForwardIterator1 pat_last,
                                BinaryPredicate pred = BinaryPredicate());
@@ -1814,14 +2230,15 @@ template<class ForwardIterator1, class BinaryPredicate = equal_to<>>
   private:
     ForwardIterator1 pat_first_;        // exposition only
     ForwardIterator1 pat_last_;         // exposition only
     BinaryPredicate pred_;              // exposition only
   };
 ```
 ``` cpp
-constexpr default_searcher(ForwardIterator pat_first, ForwardIterator pat_last,
                            BinaryPredicate pred = BinaryPredicate());
 ```
 *Effects:* Constructs a `default_searcher` object, initializing
 `pat_first_` with `pat_first`, \texttt{pat_last\_} with `pat_last`, and
@@ -1843,10 +2260,11 @@ template<class ForwardIterator2>
   `j == next(i, distance(pat_first_, pat_last_))`.
 #### Class template `boyer_moore_searcher` <a id="func.search.bm">[[func.search.bm]]</a>
 ``` cpp
   template<class RandomAccessIterator1,
            class Hash = hash<typename iterator_traits<RandomAccessIterator1>::value_type>,
            class BinaryPredicate = equal_to<>>
   class boyer_moore_searcher {
   public:
@@ -1863,30 +2281,30 @@ template<class RandomAccessIterator1,
     RandomAccessIterator1 pat_first_;   // exposition only
     RandomAccessIterator1 pat_last_;    // exposition only
     Hash hash_;                         // exposition only
     BinaryPredicate pred_;              // exposition only
   };
 ```
 ``` cpp
 boyer_moore_searcher(RandomAccessIterator1 pat_first,
                      RandomAccessIterator1 pat_last,
                      Hash hf = Hash(),
                      BinaryPredicate pred = BinaryPredicate());
 ```
 *Preconditions:* The value type of `RandomAccessIterator1` meets the
-*Cpp17DefaultConstructible* requirements, the *Cpp17CopyConstructible*
-requirements, and the *Cpp17CopyAssignable* requirements.
-*Preconditions:* Let `V` be
-`iterator_traits<RandomAccessIterator1>::value_type`. For any two values
-`A` and `B` of type `V`, if `pred(A, B) == true`, then `hf(A) == hf(B)`
-is `true`.
 *Effects:* Initializes `pat_first_` with `pat_first`, `pat_last_` with
-`pat_last`, `hash_` with `hf`, and `pred_` with `pred`.
 *Throws:* Any exception thrown by the copy constructor of
 `RandomAccessIterator1`, or by the default constructor, copy
 constructor, or the copy assignment operator of the value type of
 `RandomAccessIterator1`, or the copy constructor or `operator()` of
@@ -1920,10 +2338,11 @@ found.
 applications of the predicate.
 #### Class template `boyer_moore_horspool_searcher` <a id="func.search.bmh">[[func.search.bmh]]</a>
 ``` cpp
   template<class RandomAccessIterator1,
            class Hash = hash<typename iterator_traits<RandomAccessIterator1>::value_type>,
            class BinaryPredicate = equal_to<>>
   class boyer_moore_horspool_searcher {
   public:
@@ -1940,10 +2359,11 @@ template<class RandomAccessIterator1,
     RandomAccessIterator1 pat_first_;   // exposition only
     RandomAccessIterator1 pat_last_;    // exposition only
     Hash hash_;                         // exposition only
     BinaryPredicate pred_;              // exposition only
   };
 ```
 ``` cpp
 boyer_moore_horspool_searcher(RandomAccessIterator1 pat_first,
                               RandomAccessIterator1 pat_last,
@@ -1953,22 +2373,21 @@ boyer_moore_horspool_searcher(RandomAccessIterator1 pat_first,
 *Preconditions:* The value type of `RandomAccessIterator1` meets the
 *Cpp17DefaultConstructible*, *Cpp17CopyConstructible*, and
 *Cpp17CopyAssignable* requirements.
-*Preconditions:* Let `V` be
-`iterator_traits<RandomAccessIterator1>::value_type`. For any two values
-`A` and `B` of type `V`, if `pred(A, B) == true`, then `hf(A) == hf(B)`
-is `true`.
 *Effects:* Initializes `pat_first_` with `pat_first`, `pat_last_` with
-`pat_last`, `hash_` with `hf`, and `pred_` with `pred`.
 *Throws:* Any exception thrown by the copy constructor of
 `RandomAccessIterator1`, or by the default constructor, copy
 constructor, or the copy assignment operator of the value type of
-`RandomAccessIterator1` or the copy constructor or `operator()` of
 `BinaryPredicate` or `Hash`. May throw `bad_alloc` if additional memory
 needed for internal data structures cannot be allocated.
 ``` cpp
 template<class RandomAccessIterator2>
@@ -1981,11 +2400,11 @@ same value type.
 *Effects:* Finds a subsequence of equal values in a sequence.
 *Returns:* A pair of iterators `i` and `j` such that
-- `i` is the first iterator `i` in the range \[`first`,
   `last - (pat_last_ - pat_first_)`) such that for every non-negative
   integer `n` less than `pat_last_ - pat_first_` the following condition
   holds: `pred(*(i + n), *(pat_first_ + n)) != false`, and
 - `j == next(i, distance(pat_first_, pat_last_))`.
@@ -2030,15 +2449,15 @@ attempts to use it as a *Cpp17Hash* will be ill-formed. — *end note*]
 An enabled specialization `hash<Key>` will:
 - meet the *Cpp17Hash* requirements ([[cpp17.hash]]), with `Key` as the
   function call argument type, the *Cpp17DefaultConstructible*
   requirements ([[cpp17.defaultconstructible]]), the
-  *Cpp17CopyAssignable* requirements ([[cpp17.copyassignable]]),
-- be swappable [[swappable.requirements]] for lvalues,
 - meet the requirement that if `k1 == k2` is `true`, `h(k1) == h(k2)` is
   also `true`, where `h` is an object of type `hash<Key>` and `k1` and
   `k2` are objects of type `Key`;
 - meet the requirement that the expression `h(k)`, where `h` is an
   object of type `hash<Key>` and `k` is an object of type `Key`, shall
   not throw an exception unless `hash<Key>` is a program-defined
-  specialization that depends on at least one program-defined type.

 ## Function objects <a id="function.objects">[[function.objects]]</a>
+### General <a id="function.objects.general">[[function.objects.general]]</a>
+A *function object type* is an object type [[term.object.type]] that can
+be the type of the *postfix-expression* in a function call
+[[expr.call]], [[over.match.call]].[^1]
+A *function object* is an object of a function object type. In the
+places where one would expect to pass a pointer to a function to an
+algorithmic template [[algorithms]], the interface is specified to
+accept a function object. This not only makes algorithmic templates work
+with pointers to functions, but also enables them to work with arbitrary
+function objects.
 ### Header `<functional>` synopsis <a id="functional.syn">[[functional.syn]]</a>
 ``` cpp
 namespace std {
   // [func.invoke], invoke
   template<class F, class... Args>
+    constexpr invoke_result_t<F, Args...> invoke(F&& f, Args&&... args)             // freestanding
       noexcept(is_nothrow_invocable_v<F, Args...>);
+  template<class R, class F, class... Args>
+    constexpr R invoke_r(F&& f, Args&&... args)                                     // freestanding
+      noexcept(is_nothrow_invocable_r_v<R, F, Args...>);
   // [refwrap], reference_wrapper
+  template<class T> class reference_wrapper;                                        // freestanding
+  template<class T> constexpr reference_wrapper<T> ref(T&) noexcept;                // freestanding
+  template<class T> constexpr reference_wrapper<const T> cref(const T&) noexcept;   // freestanding
+  template<class T> void ref(const T&&) = delete;                                   // freestanding
+  template<class T> void cref(const T&&) = delete;                                  // freestanding
+  template<class T>
+ constexpr reference_wrapper<T> ref(reference_wrapper<T>) noexcept;              // freestanding
+  template<class T>
+    constexpr reference_wrapper<const T> cref(reference_wrapper<T>) noexcept;       // freestanding
+  // [refwrap.common.ref], common_reference related specializations
+  template<class R, class T, template<class> class RQual, template<class> class TQual>
+    requires see below
+  struct basic_common_reference<R, T, RQual, TQual>;
+  template<class T, class R, template<class> class TQual, template<class> class RQual>
+    requires see below
+  struct basic_common_reference<T, R, TQual, RQual>;
   // [arithmetic.operations], arithmetic operations
+  template<class T = void> struct plus;                                             // freestanding
+  template<class T = void> struct minus;                                            // freestanding
+  template<class T = void> struct multiplies;                                       // freestanding
+  template<class T = void> struct divides;                                          // freestanding
+  template<class T = void> struct modulus;                                          // freestanding
+  template<class T = void> struct negate;                                           // freestanding
+  template<> struct plus<void>;                                                     // freestanding
+  template<> struct minus<void>;                                                    // freestanding
+  template<> struct multiplies<void>;                                               // freestanding
+  template<> struct divides<void>;                                                  // freestanding
+  template<> struct modulus<void>;                                                  // freestanding
+  template<> struct negate<void>;                                                   // freestanding
   // [comparisons], comparisons
+  template<class T = void> struct equal_to;                                         // freestanding
+  template<class T = void> struct not_equal_to;                                     // freestanding
+  template<class T = void> struct greater;                                          // freestanding
+  template<class T = void> struct less;                                             // freestanding
+  template<class T = void> struct greater_equal;                                    // freestanding
+  template<class T = void> struct less_equal;                                       // freestanding
+  template<> struct equal_to<void>;                                                 // freestanding
+  template<> struct not_equal_to<void>;                                             // freestanding
+  template<> struct greater<void>;                                                  // freestanding
+  template<> struct less<void>;                                                     // freestanding
+  template<> struct greater_equal<void>;                                            // freestanding
+  template<> struct less_equal<void>;                                               // freestanding
   // [comparisons.three.way], class compare_three_way
+  struct compare_three_way;                                                         // freestanding
   // [logical.operations], logical operations
+  template<class T = void> struct logical_and;                                      // freestanding
+  template<class T = void> struct logical_or;                                       // freestanding
+  template<class T = void> struct logical_not;                                      // freestanding
+  template<> struct logical_and<void>;                                              // freestanding
+  template<> struct logical_or<void>;                                               // freestanding
+  template<> struct logical_not<void>;                                              // freestanding
   // [bitwise.operations], bitwise operations
+  template<class T = void> struct bit_and;                                          // freestanding
+  template<class T = void> struct bit_or;                                           // freestanding
+  template<class T = void> struct bit_xor;                                          // freestanding
+  template<class T = void> struct bit_not;                                          // freestanding
+  template<> struct bit_and<void>;                                                  // freestanding
+  template<> struct bit_or<void>;                                                   // freestanding
+  template<> struct bit_xor<void>;                                                  // freestanding
+  template<> struct bit_not<void>;                                                  // freestanding
   // [func.identity], identity
+  struct identity;                                                                  // freestanding
   // [func.not.fn], function template not_fn
+  template<class F> constexpr unspecified not_fn(F&& f);                            // freestanding
+  // [func.bind.partial], function templates bind_front and bind_back
+  template<class F, class... Args>
+    constexpr unspecified bind_front(F&&, Args&&...);                               // freestanding
+  template<class F, class... Args>
+    constexpr unspecified bind_back(F&&, Args&&...);                                // freestanding
   // [func.bind], bind
+  template<class T> struct is_bind_expression;                                      // freestanding
   template<class T>
+    constexpr bool is_bind_expression_v =                                           // freestanding
+      is_bind_expression<T>::value;
+  template<class T> struct is_placeholder;                                          // freestanding
   template<class T>
+    constexpr int is_placeholder_v =                                                // freestanding
+      is_placeholder<T>::value;
   template<class F, class... BoundArgs>
+    constexpr unspecified bind(F&&, BoundArgs&&...);                                // freestanding
   template<class R, class F, class... BoundArgs>
+    constexpr unspecified bind(F&&, BoundArgs&&...);                                // freestanding
   namespace placeholders {
     // M is the implementation-defined number of placeholders
+    see belownc _1;                                                                   // freestanding
+    see belownc _2;                                                                   // freestanding
                .
                .
                .
+    see belownc _M;                                                                   // freestanding
   }
   // [func.memfn], member function adaptors
   template<class R, class T>
+    constexpr unspecified mem_fn(R T::*) noexcept;                                  // freestanding
   // [func.wrap], polymorphic function wrappers
   class bad_function_call;
   template<class> class function;       // not defined
   template<class R, class... ArgTypes> class function<R(ArgTypes...)>;
+  // [func.wrap.func.alg], specialized algorithms
   template<class R, class... ArgTypes>
     void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)>&) noexcept;
+  // [func.wrap.func.nullptr], null pointer comparison operator functions
   template<class R, class... ArgTypes>
     bool operator==(const function<R(ArgTypes...)>&, nullptr_t) noexcept;
+  // [func.wrap.move], move only wrapper
+  template<class... S> class move_only_function;        // not defined
+  template<class R, class... ArgTypes>
+    class move_only_function<R(ArgTypes...) cv ref noexcept(noex)>; // see below
   // [func.search], searchers
+  template<class ForwardIterator1, class BinaryPredicate = equal_to<>>
+    class default_searcher;                                                         // freestanding
   template<class RandomAccessIterator,
            class Hash = hash<typename iterator_traits<RandomAccessIterator>::value_type>,
            class BinaryPredicate = equal_to<>>
     class boyer_moore_searcher;
            class BinaryPredicate = equal_to<>>
     class boyer_moore_horspool_searcher;
   // [unord.hash], class template hash
   template<class T>
+    struct hash;                                                                    // freestanding
   namespace ranges {
     // [range.cmp], concept-constrained comparisons
+    struct equal_to;                                                                // freestanding
+    struct not_equal_to;                                                            // freestanding
+    struct greater;                                                                 // freestanding
+    struct less;                                                                    // freestanding
+    struct greater_equal;                                                           // freestanding
+    struct less_equal;                                                              // freestanding
   }
 }
 ```
 [*Example 1*:
 ### Requirements <a id="func.require">[[func.require]]</a>
 Define `INVOKE(f, t₁, t₂, …, t_N)` as follows:
 - `(t₁.*f)(t₂, …, t_N)` when `f` is a pointer to a member function of a
+  class `T` and `is_same_v<T, remove_cvref_t<decltype(t1)>> ||`
+  `is_base_of_v<T, remove_cvref_t<decltype(t₁)>>` is `true`;
 - `(t₁.get().*f)(t₂, …, t_N)` when `f` is a pointer to a member function
   of a class `T` and `remove_cvref_t<decltype(t₁)>` is a specialization
   of `reference_wrapper`;
 - `((*t₁).*f)(t₂, …, t_N)` when `f` is a pointer to a member function of
   a class `T` and `t₁` does not satisfy the previous two items;
+- `t₁.*f` when N = 1 and `f` is a pointer to data member of a class `T`
+  and `is_same_v<T, remove_cvref_t<decltype(t1)>> ||`
+ `is_base_of_v<T, remove_cvref_t<decltype(t₁)>>` is `true`;
+- `t₁.get().*f` when N = 1 and `f` is a pointer to data member of a
   class `T` and `remove_cvref_t<decltype(t₁)>` is a specialization of
   `reference_wrapper`;
+- `(*t₁).*f` when N = 1 and `f` is a pointer to data member of a class
+  `T` and `t₁` does not satisfy the previous two items;
 - `f(t₁, t₂, …, t_N)` in all other cases.
 Define `INVOKE<R>(f, t₁, t₂, …, t_N)` as
 `static_cast<void>(INVOKE(f, t₁, t₂, …, t_N))` if `R` is cv `void`,
+otherwise `INVOKE(f, t₁, t₂, …, t_N)` implicitly converted to `R`. If
+`reference_converts_from_temporary_v<R, decltype(INVOKE(f, t₁, t₂, …, t_N))>`
+is `true`, `INVOKE<R>(f, t₁, t₂, …, t_N)` is ill-formed.
 Every call wrapper [[func.def]] meets the *Cpp17MoveConstructible* and
 *Cpp17Destructible* requirements. An *argument forwarding call wrapper*
 is a call wrapper that can be called with an arbitrary argument list and
+delivers the arguments to the target object as references. This
+forwarding step delivers rvalue arguments as rvalue references and
 lvalue arguments as lvalue references.
 [*Note 1*:
 In a typical implementation, argument forwarding call wrappers have an
 call wrapper and where cv shall be neither `volatile` nor
 `const volatile`.
 A *call pattern* defines the semantics of invoking a perfect forwarding
 call wrapper. A postfix call performed on a perfect forwarding call
+wrapper is expression-equivalent [[defns.expression.equivalent]] to an
 expression `e` determined from its call pattern `cp` by replacing all
 occurrences of the arguments of the call wrapper and its state entities
 with references as described in the corresponding forwarding steps.
 A *simple call wrapper* is a perfect forwarding call wrapper that meets
 Argument forwarding call wrappers returned by a given standard library
 function template have the same type if the types of their corresponding
 state entities are the same.
+### `invoke` functions <a id="func.invoke">[[func.invoke]]</a>
 ``` cpp
 template<class F, class... Args>
   constexpr invoke_result_t<F, Args...> invoke(F&& f, Args&&... args)
     noexcept(is_nothrow_invocable_v<F, Args...>);
 ```
+*Constraints:* `is_invocable_v<F, Args...>` is `true`.
 *Returns:* *INVOKE*(std::forward\<F\>(f),
 std::forward\<Args\>(args)...) [[func.require]].
+``` cpp
+template<class R, class F, class... Args>
+  constexpr R invoke_r(F&& f, Args&&... args)
+    noexcept(is_nothrow_invocable_r_v<R, F, Args...>);
+```
+*Constraints:* `is_invocable_r_v<R, F, Args...>` is `true`.
+*Returns:* *INVOKE*\<R\>(std::forward\<F\>(f),
+std::forward\<Args\>(args)...) [[func.require]].
 ### Class template `reference_wrapper` <a id="refwrap">[[refwrap]]</a>
+#### General <a id="refwrap.general">[[refwrap.general]]</a>
 ``` cpp
 namespace std {
   template<class T> class reference_wrapper {
   public:
     // types
     using type = T;
+    // [refwrap.const], constructors
     template<class U>
       constexpr reference_wrapper(U&&) noexcept(see below);
     constexpr reference_wrapper(const reference_wrapper& x) noexcept;
+    // [refwrap.assign], assignment
     constexpr reference_wrapper& operator=(const reference_wrapper& x) noexcept;
+    // [refwrap.access], access
     constexpr operator T& () const noexcept;
     constexpr T& get() const noexcept;
+    // [refwrap.invoke], invocation
     template<class... ArgTypes>
+      constexpr invoke_result_t<T&, ArgTypes...> operator()(ArgTypes&&...) const
+        noexcept(is_nothrow_invocable_v<T&, ArgTypes...>);
   };
   template<class T>
     reference_wrapper(T&) -> reference_wrapper<T>;
 }
 ```
 `reference_wrapper<T>` is a *Cpp17CopyConstructible* and
 *Cpp17CopyAssignable* wrapper around a reference to an object or
 function of type `T`.
+`reference_wrapper<T>` is a trivially copyable type
+[[term.trivially.copyable.type]].
 The template parameter `T` of `reference_wrapper` may be an incomplete
 type.
+#### Constructors <a id="refwrap.const">[[refwrap.const]]</a>
 ``` cpp
 template<class U>
   constexpr reference_wrapper(U&& u) noexcept(see below);
 ```
 *Effects:* Creates a variable `r` as if by `T& r = std::forward<U>(u)`,
 then constructs a `reference_wrapper` object that stores a reference to
 `r`.
+*Remarks:* The exception specification is equivalent to
 `noexcept(`*`FUN`*`(declval<U>()))`.
 ``` cpp
 constexpr reference_wrapper(const reference_wrapper& x) noexcept;
 ```
 #### Invocation <a id="refwrap.invoke">[[refwrap.invoke]]</a>
 ``` cpp
 template<class... ArgTypes>
   constexpr invoke_result_t<T&, ArgTypes...>
+    operator()(ArgTypes&&... args) const noexcept(is_nothrow_invocable_v<T&, ArgTypes...>);
 ```
 *Mandates:* `T` is a complete type.
 *Returns:* *INVOKE*(get(),
 ``` cpp
 template<class T> constexpr reference_wrapper<T> ref(reference_wrapper<T> t) noexcept;
 ```
+*Returns:* `t`.
 ``` cpp
 template<class T> constexpr reference_wrapper<const T> cref(const T& t) noexcept;
 ```
 ``` cpp
 template<class T> constexpr reference_wrapper<const T> cref(reference_wrapper<T> t) noexcept;
 ```
+*Returns:* `t`.
+#### `common_reference` related specializations <a id="refwrap.common.ref">[[refwrap.common.ref]]</a>
+``` cpp
+namespace std {
+  template<class T>
+    constexpr bool is-ref-wrapper = false;                              // exposition only
+  template<class T>
+    constexpr bool is-ref-wrapper<reference_wrapper<T>> = true;
+  template<class R, class T, class RQ, class TQ>
+    concept ref-wrap-common-reference-exists-with =                     // exposition only
+      is-ref-wrapper<R> &&
+      requires { typename common_reference_t<typename R::type&, TQ>; } &&
+      convertible_to<RQ, common_reference_t<typename R::type&, TQ>>;
+  template<class R, class T, template<class> class RQual, template<class> class TQual>
+    requires (ref-wrap-common-reference-exists-with<R, T, RQual<R>, TQual<T>> &&
+              !ref-wrap-common-reference-exists-with<T, R, TQual<T>, RQual<R>>)
+  struct basic_common_reference<R, T, RQual, TQual> {
+    using type = common_reference_t<typename R::type&, TQual<T>>;
+  };
+  template<class T, class R, template<class> class TQual, template<class> class RQual>
+    requires (ref-wrap-common-reference-exists-with<R, T, RQual<R>, TQual<T>> &&
+              !ref-wrap-common-reference-exists-with<T, R, TQual<T>, RQual<R>>)
+  struct basic_common_reference<T, R, TQual, RQual> {
+    using type = common_reference_t<typename R::type&, TQual<T>>;
+  };
+}
+```
 ### Arithmetic operations <a id="arithmetic.operations">[[arithmetic.operations]]</a>
+#### General <a id="arithmetic.operations.general">[[arithmetic.operations.general]]</a>
 The library provides basic function object classes for all of the
+arithmetic operators in the language [[expr.mul]], [[expr.add]].
 #### Class template `plus` <a id="arithmetic.operations.plus">[[arithmetic.operations.plus]]</a>
 ``` cpp
 template<class T = void> struct plus {
 *Returns:* `-std::forward<T>(t)`.
 ### Comparisons <a id="comparisons">[[comparisons]]</a>
+#### General <a id="comparisons.general">[[comparisons.general]]</a>
 The library provides basic function object classes for all of the
+comparison operators in the language [[expr.rel]], [[expr.eq]].
 For templates `less`, `greater`, `less_equal`, and `greater_equal`, the
 specializations for any pointer type yield a result consistent with the
 implementation-defined strict total order over pointers
 [[defns.order.ptr]].
 *Returns:* `std::forward<T>(t) <= std::forward<U>(u)`.
 #### Class `compare_three_way` <a id="comparisons.three.way">[[comparisons.three.way]]</a>
 ``` cpp
+namespace std {
   struct compare_three_way {
     template<class T, class U>
       constexpr auto operator()(T&& t, U&& u) const;
     using is_transparent = unspecified;
   };
+}
 ```
 ``` cpp
 template<class T, class U>
   constexpr auto operator()(T&& t, U&& u) const;
 ```
+*Constraints:* `T` and `U` satisfy `three_way_comparable_with`.
 *Preconditions:* If the expression
 `std::forward<T>(t) <=> std::forward<U>(u)` results in a call to a
 built-in operator `<=>` comparing pointers of type `P`, the conversion
 sequences from both `T` and `U` to `P` are
+equality-preserving [[concepts.equality]]; otherwise, `T` and `U` model
+`three_way_comparable_with`.
 *Effects:*
 - If the expression `std::forward<T>(t) <=> std::forward<U>(u)` results
   in a call to a built-in operator `<=>` comparing pointers of type `P`,
 - Otherwise, equivalent to:
   `return std::forward<T>(t) <=> std::forward<U>(u);`
 ### Concept-constrained comparisons <a id="range.cmp">[[range.cmp]]</a>
 ``` cpp
 struct ranges::equal_to {
   template<class T, class U>
     constexpr bool operator()(T&& t, U&& u) const;
   using is_transparent = unspecified;
 };
 ```
+``` cpp
+template<class T, class U>
+  constexpr bool operator()(T&& t, U&& u) const;
+```
+*Constraints:* `T` and `U` satisfy `equality_comparable_with`.
 *Preconditions:* If the expression
 `std::forward<T>(t) == std::forward<U>(u)` results in a call to a
 built-in operator `==` comparing pointers of type `P`, the conversion
 sequences from both `T` and `U` to `P` are
+equality-preserving [[concepts.equality]]; otherwise, `T` and `U` model
+`equality_comparable_with`.
 *Effects:*
 - If the expression `std::forward<T>(t) == std::forward<U>(u)` results
   in a call to a built-in operator `==` comparing pointers: returns
   `return std::forward<T>(t) == std::forward<U>(u);`
 ``` cpp
 struct ranges::not_equal_to {
   template<class T, class U>
     constexpr bool operator()(T&& t, U&& u) const;
   using is_transparent = unspecified;
 };
 ```
+``` cpp
+template<class T, class U>
+  constexpr bool operator()(T&& t, U&& u) const;
+```
+*Constraints:* `T` and `U` satisfy `equality_comparable_with`.
+*Effects:* Equivalent to:
 ``` cpp
 return !ranges::equal_to{}(std::forward<T>(t), std::forward<U>(u));
 ```
 ``` cpp
 struct ranges::greater {
   template<class T, class U>
   constexpr bool operator()(T&& t, U&& u) const;
   using is_transparent = unspecified;
 };
 ```
+``` cpp
+template<class T, class U>
+  constexpr bool operator()(T&& t, U&& u) const;
+```
+*Constraints:* `T` and `U` satisfy `totally_ordered_with`.
+*Effects:* Equivalent to:
 ``` cpp
 return ranges::less{}(std::forward<U>(u), std::forward<T>(t));
 ```
 ``` cpp
 struct ranges::less {
   template<class T, class U>
     constexpr bool operator()(T&& t, U&& u) const;
   using is_transparent = unspecified;
 };
 ```
+``` cpp
+template<class T, class U>
+  constexpr bool operator()(T&& t, U&& u) const;
+```
+*Constraints:* `T` and `U` satisfy `totally_ordered_with`.
 *Preconditions:* If the expression
 `std::forward<T>(t) < std::forward<U>(u)` results in a call to a
 built-in operator `<` comparing pointers of type `P`, the conversion
 sequences from both `T` and `U` to `P` are
+equality-preserving [[concepts.equality]]; otherwise, `T` and `U` model
+`totally_ordered_with`. For any expressions `ET` and `EU` such that
+`decltype((ET))` is `T` and `decltype((EU))` is `U`, exactly one of
+`ranges::less{}(ET, EU)`, `ranges::less{}(EU, ET)`, or
 `ranges::equal_to{}(ET, EU)` is `true`.
 *Effects:*
 - If the expression `std::forward<T>(t) < std::forward<U>(u)` results in
   `return std::forward<T>(t) < std::forward<U>(u);`
 ``` cpp
 struct ranges::greater_equal {
   template<class T, class U>
     constexpr bool operator()(T&& t, U&& u) const;
   using is_transparent = unspecified;
 };
 ```
+``` cpp
+template<class T, class U>
+  constexpr bool operator()(T&& t, U&& u) const;
+```
+*Constraints:* `T` and `U` satisfy `totally_ordered_with`.
+*Effects:* Equivalent to:
 ``` cpp
 return !ranges::less{}(std::forward<T>(t), std::forward<U>(u));
 ```
 ``` cpp
 struct ranges::less_equal {
   template<class T, class U>
     constexpr bool operator()(T&& t, U&& u) const;
   using is_transparent = unspecified;
 };
 ```
+``` cpp
+template<class T, class U>
+  constexpr bool operator()(T&& t, U&& u) const;
+```
+*Constraints:* `T` and `U` satisfy `totally_ordered_with`.
+*Effects:* Equivalent to:
 ``` cpp
 return !ranges::less{}(std::forward<U>(u), std::forward<T>(t));
 ```
 ### Logical operations <a id="logical.operations">[[logical.operations]]</a>
+#### General <a id="logical.operations.general">[[logical.operations.general]]</a>
 The library provides basic function object classes for all of the
+logical operators in the language
+[[expr.log.and]], [[expr.log.or]], [[expr.unary.op]].
 #### Class template `logical_and` <a id="logical.operations.and">[[logical.operations.and]]</a>
 ``` cpp
 template<class T = void> struct logical_and {
 *Returns:* `!std::forward<T>(t)`.
 ### Bitwise operations <a id="bitwise.operations">[[bitwise.operations]]</a>
+#### General <a id="bitwise.operations.general">[[bitwise.operations.general]]</a>
 The library provides basic function object classes for all of the
+bitwise operators in the language
+[[expr.bit.and]], [[expr.or]], [[expr.xor]], [[expr.unary.op]].
 #### Class template `bit_and` <a id="bitwise.operations.and">[[bitwise.operations.and]]</a>
 ``` cpp
 template<class T = void> struct bit_and {
   using is_transparent = unspecified;
 };
 ```
 ``` cpp
+template<class T> constexpr auto operator()(T&& t) const
     -> decltype(~std::forward<T>(t));
 ```
 *Returns:* `~std::forward<T>(t)`.
 *Mandates:* `is_constructible_v<FD, F> && is_move_constructible_v<FD>`
 is `true`.
 *Preconditions:* `FD` meets the *Cpp17MoveConstructible* requirements.
+*Returns:* A perfect forwarding call
+wrapper [[term.perfect.forwarding.call.wrapper]] `g` with call pattern
 `!invoke(fd, call_args...)`.
 *Throws:* Any exception thrown by the initialization of `fd`.
+### Function templates `bind_front` and `bind_back` <a id="func.bind.partial">[[func.bind.partial]]</a>
 ``` cpp
 template<class F, class... Args>
   constexpr unspecified bind_front(F&& f, Args&&... args);
+template<class F, class... Args>
+  constexpr unspecified bind_back(F&& f, Args&&... args);
 ```
+Within this subclause:
+- `g` is a value of the result of a `bind_front` or `bind_back`
+  invocation,
 - `FD` is the type `decay_t<F>`,
 - `fd` is the target object of `g` [[func.def]] of type `FD`,
   direct-non-list-initialized with `std::forward<F>(f)`,
 - `BoundArgs` is a pack that denotes `decay_t<Args>...`,
 - `bound_args` is a pack of bound argument entities of `g` [[func.def]]
 *Preconditions:* `FD` meets the *Cpp17MoveConstructible* requirements.
 For each `Tᵢ` in `BoundArgs`, if `Tᵢ` is an object type, `Tᵢ` meets the
 *Cpp17MoveConstructible* requirements.
+*Returns:* A perfect forwarding call
+wrapper [[term.perfect.forwarding.call.wrapper]] `g` with call pattern:
+- `invoke(fd, bound_args..., call_args...)` for a `bind_front`
+  invocation, or
+- `invoke(fd, call_args..., bound_args...)` for a `bind_back`
+  invocation.
 *Throws:* Any exception thrown by the initialization of the state
 entities of `g` [[func.def]].
 ### Function object binders <a id="func.bind">[[func.bind]]</a>
+#### General <a id="func.bind.general">[[func.bind.general]]</a>
+Subclause [[func.bind]] describes a uniform mechanism for binding
+arguments of callable objects.
 #### Class template `is_bind_expression` <a id="func.bind.isbind">[[func.bind.isbind]]</a>
 ``` cpp
 namespace std {
   template<class T> struct is_placeholder;      // see below
 }
 ```
 The class template `is_placeholder` can be used to detect the standard
+placeholders `_1`, `_2`, and so on [[func.bind.place]]. The function
+template `bind` uses `is_placeholder` to detect placeholders.
 Specializations of the `is_placeholder` template shall meet the
 *Cpp17UnaryTypeTrait* requirements [[meta.rqmts]]. The implementation
 provides a definition that has the base characteristic of
 `integral_constant<int, J>` if `T` is the type of
 *Returns:* An argument forwarding call wrapper `g` [[func.require]]. A
 program that attempts to invoke a volatile-qualified `g` is ill-formed.
 When `g` is not volatile-qualified, invocation of
 `g(``u₁``, ``u₂``, `…`, ``u_M``)` is
+expression-equivalent [[defns.expression.equivalent]] to
 ``` cpp
 INVOKE(static_cast<$V_fd$>($v_fd$),
        static_cast<$V_1$>($v_1$), static_cast<$V_2$>($v_2$), …, static_cast<$V_N$>($v_N$))
 ```
 #### Placeholders <a id="func.bind.place">[[func.bind.place]]</a>
 ``` cpp
 namespace std::placeholders {
+  // M is the number of placeholders
   see below _1;
   see below _2;
               .
               .
               .
   see below _M;
 }
 ```
+The number `M` of placeholders is *implementation-defined*.
 All placeholder types meet the *Cpp17DefaultConstructible* and
 *Cpp17CopyConstructible* requirements, and their default constructors
 and copy/move constructors are constexpr functions that do not throw
 exceptions. It is *implementation-defined* whether placeholder types
 meet the *Cpp17CopyAssignable* requirements, but if so, their copy
 ``` cpp
 extern unspecified _1;
 ```
+Placeholders are freestanding items [[freestanding.item]].
 ### Function template `mem_fn` <a id="func.memfn">[[func.memfn]]</a>
 ``` cpp
 template<class R, class T> constexpr unspecified mem_fn(R T::* pm) noexcept;
 ```
+*Returns:* A simple call wrapper [[term.simple.call.wrapper]] `fn` with
+call pattern `invoke(pmd, call_args...)`, where `pmd` is the target
+object of `fn` of type `R T::*` direct-non-list-initialized with `pm`,
+and `call_args` is an argument pack used in a function call
+expression [[expr.call]] of `fn`.
 ### Polymorphic function wrappers <a id="func.wrap">[[func.wrap]]</a>
+#### General <a id="func.wrap.general">[[func.wrap.general]]</a>
+Subclause [[func.wrap]] describes polymorphic wrapper classes that
+encapsulate arbitrary callable objects.
 #### Class `bad_function_call` <a id="func.wrap.badcall">[[func.wrap.badcall]]</a>
 An exception of type `bad_function_call` is thrown by
 `function::operator()` [[func.wrap.func.inv]] when the function wrapper
 *Returns:* An *implementation-defined* NTBS.
 #### Class template `function` <a id="func.wrap.func">[[func.wrap.func]]</a>
+##### General <a id="func.wrap.func.general">[[func.wrap.func.general]]</a>
 ``` cpp
 namespace std {
   template<class> class function;       // not defined
   template<class R, class... ArgTypes>
     // [func.wrap.func.con], construct/copy/destroy
     function() noexcept;
     function(nullptr_t) noexcept;
     function(const function&);
     function(function&&) noexcept;
+    template<class F> function(F&&);
     function& operator=(const function&);
     function& operator=(function&&);
     function& operator=(nullptr_t) noexcept;
     template<class F> function& operator=(F&&);
   template<class R, class... ArgTypes>
     function(R(*)(ArgTypes...)) -> function<R(ArgTypes...)>;
   template<class F> function(F) -> function<see below>;
 }
 ```
 The `function` class template provides polymorphic wrappers that
 generalize the notion of a function pointer. Wrappers can store, copy,
 and call arbitrary callable objects [[func.def]], given a call signature
+[[func.def]].
 A callable type [[func.def]] `F` is *Lvalue-Callable* for argument types
 `ArgTypes` and return type `R` if the expression
 `INVOKE<R>(declval<F&>(), declval<ArgTypes>()...)`, considered as an
+unevaluated operand [[term.unevaluated.operand]], is well-formed
+[[func.require]].
 The `function` class template is a call wrapper [[func.def]] whose call
 signature [[func.def]] is `R(ArgTypes...)`.
+[*Note 1*: The types deduced by the deduction guides for `function`
+might change in future revisions of C++. — *end note*]
 ##### Constructors and destructor <a id="func.wrap.func.con">[[func.wrap.func.con]]</a>
 ``` cpp
 function() noexcept;
 ``` cpp
 function(const function& f);
 ```
+*Ensures:* `!*this` if `!f`; otherwise, the target object of `*this` is
+a copy of `f.target()`.
 *Throws:* Nothing if `f`’s target is a specialization of
 `reference_wrapper` or a function pointer. Otherwise, may throw
 `bad_alloc` or any exception thrown by the copy constructor of the
 stored callable object.
+*Recommended practice:* Implementations should avoid the use of
+dynamically allocated memory for small callable objects, for example,
+where `f`’s target is an object holding only a pointer or reference to
+an object and a member function pointer.
 ``` cpp
 function(function&& f) noexcept;
 ```
 *Ensures:* If `!f`, `*this` has no target; otherwise, the target of
 `*this` is equivalent to the target of `f` before the construction, and
 `f` is in a valid state with an unspecified value.
+*Recommended practice:* Implementations should avoid the use of
+dynamically allocated memory for small callable objects, for example,
+where `f`’s target is an object holding only a pointer or reference to
+an object and a member function pointer.
 ``` cpp
+template<class F> function(F&& f);
 ```
+Let `FD` be `decay_t<F>`.
+*Constraints:*
+- `is_same_v<remove_cvref_t<F>, function>` is `false`, and
+- `FD` is Lvalue-Callable [[func.wrap.func]] for argument types
+  `ArgTypes...` and return type `R`.
+*Mandates:*
+- `is_copy_constructible_v<FD>` is `true`, and
+- `is_constructible_v<FD, F>` is `true`.
+*Preconditions:* `FD` meets the *Cpp17CopyConstructible* requirements.
+*Ensures:* `!*this` is `true` if any of the following hold:
 - `f` is a null function pointer value.
 - `f` is a null member pointer value.
+- `remove_cvref_t<F>` is a specialization of the `function` class
+  template, and `!f` is `true`.
+Otherwise, `*this` has a target object of type `FD`
+direct-non-list-initialized with `std::forward<F>(f)`.
+*Throws:* Nothing if `FD` is a specialization of `reference_wrapper` or
+a function pointer type. Otherwise, may throw `bad_alloc` or any
+exception thrown by the initialization of the target object.
+*Recommended practice:* Implementations should avoid the use of
+dynamically allocated memory for small callable objects, for example,
+where `f` refers to an object holding only a pointer or reference to an
+object and a member function pointer.
 ``` cpp
 template<class F> function(F) -> function<see below>;
 ```
 *Constraints:* `&F::operator()` is well-formed when treated as an
+unevaluated operand and either
+- `F::operator()` is a non-static member function and
+  `decltype(&F::operator())` is either of the form
+  `R(G::*)(A...)` cv \\ₒₚₜ ` `noexceptₒₚₜ  or of the form
+  `R(*)(G, A...) `noexceptₒₚₜ  for a type `G`, or
+- `F::operator()` is a static member function and
+  `decltype(&F::operator())` is of the form `R(*)(A...) `noexceptₒₚₜ .
 *Remarks:* The deduced type is `function<R(A...)>`.
 [*Example 1*:
 ``` cpp
 void swap(function& other) noexcept;
 ```
+*Effects:* Interchanges the target objects of `*this` and `other`.
 ##### Capacity <a id="func.wrap.func.cap">[[func.wrap.func.cap]]</a>
 ``` cpp
 explicit operator bool() const noexcept;
 *Returns:* *INVOKE*\<R\>(f,
 std::forward\<ArgTypes\>(args)...) [[func.require]], where `f` is the
 target object [[func.def]] of `*this`.
 *Throws:* `bad_function_call` if `!*this`; otherwise, any exception
+thrown by the target object.
 ##### Target access <a id="func.wrap.func.targ">[[func.wrap.func.targ]]</a>
 ``` cpp
 const type_info& target_type() const noexcept;
 ```
 *Returns:* If `target_type() == typeid(T)` a pointer to the stored
 function target; otherwise a null pointer.
+##### Null pointer comparison operator functions <a id="func.wrap.func.nullptr">[[func.wrap.func.nullptr]]</a>
 ``` cpp
 template<class R, class... ArgTypes>
   bool operator==(const function<R(ArgTypes...)>& f, nullptr_t) noexcept;
 ```
   void swap(function<R(ArgTypes...)>& f1, function<R(ArgTypes...)>& f2) noexcept;
 ```
 *Effects:* As if by: `f1.swap(f2);`
+#### Move only wrapper <a id="func.wrap.move">[[func.wrap.move]]</a>
+##### General <a id="func.wrap.move.general">[[func.wrap.move.general]]</a>
+The header provides partial specializations of `move_only_function` for
+each combination of the possible replacements of the placeholders cv,
+*ref*, and *noex* where
+- cv is either const or empty,
+- *ref* is either `&`, `&&`, or empty, and
+- *noex* is either `true` or `false`.
+For each of the possible combinations of the placeholders mentioned
+above, there is a placeholder *inv-quals* defined as follows:
+- If *ref* is empty, let *inv-quals* be cv`&`,
+- otherwise, let *inv-quals* be cv *ref*.
+##### Class template `move_only_function` <a id="func.wrap.move.class">[[func.wrap.move.class]]</a>
+``` cpp
+namespace std {
+  template<class... S> class move_only_function;                // not defined
+  template<class R, class... ArgTypes>
+  class move_only_function<R(ArgTypes...) cv ref noexcept(noex)> {
+  public:
+    using result_type = R;
+    // [func.wrap.move.ctor], constructors, assignment, and destructor
+    move_only_function() noexcept;
+    move_only_function(nullptr_t) noexcept;
+    move_only_function(move_only_function&&) noexcept;
+    template<class F> move_only_function(F&&);
+    template<class T, class... Args>
+      explicit move_only_function(in_place_type_t<T>, Args&&...);
+    template<class T, class U, class... Args>
+      explicit move_only_function(in_place_type_t<T>, initializer_list<U>, Args&&...);
+    move_only_function& operator=(move_only_function&&);
+    move_only_function& operator=(nullptr_t) noexcept;
+    template<class F> move_only_function& operator=(F&&);
+    ~move_only_function();
+    // [func.wrap.move.inv], invocation
+    explicit operator bool() const noexcept;
+    R operator()(ArgTypes...) cv ref noexcept(noex);
+    // [func.wrap.move.util], utility
+    void swap(move_only_function&) noexcept;
+    friend void swap(move_only_function&, move_only_function&) noexcept;
+    friend bool operator==(const move_only_function&, nullptr_t) noexcept;
+  private:
+    template<class VT>
+      static constexpr bool is-callable-from = see below;       // exposition only
+  };
+}
+```
+The `move_only_function` class template provides polymorphic wrappers
+that generalize the notion of a callable object [[func.def]]. These
+wrappers can store, move, and call arbitrary callable objects, given a
+call signature.
+*Recommended practice:* Implementations should avoid the use of
+dynamically allocated memory for a small contained value.
+[*Note 1*: Such small-object optimization can only be applied to a type
+`T` for which `is_nothrow_move_constructible_v<T>` is
+`true`. — *end note*]
+##### Constructors, assignment, and destructor <a id="func.wrap.move.ctor">[[func.wrap.move.ctor]]</a>
+``` cpp
+template<class VT>
+  static constexpr bool is-callable-from = see below;
+```
+If *noex* is `true`, *`is-callable-from`*`<VT>` is equal to:
+``` cpp
+is_nothrow_invocable_r_v<R, VT cv ref, ArgTypes...> &&
+is_nothrow_invocable_r_v<R, VT inv-quals, ArgTypes...>
+```
+Otherwise, *`is-callable-from`*`<VT>` is equal to:
+``` cpp
+is_invocable_r_v<R, VT cv ref, ArgTypes...> &&
+is_invocable_r_v<R, VT inv-quals, ArgTypes...>
+```
+``` cpp
+move_only_function() noexcept;
+move_only_function(nullptr_t) noexcept;
+```
+*Ensures:* `*this` has no target object.
+``` cpp
+move_only_function(move_only_function&& f) noexcept;
+```
+*Ensures:* The target object of `*this` is the target object `f` had
+before construction, and `f` is in a valid state with an unspecified
+value.
+``` cpp
+template<class F> move_only_function(F&& f);
+```
+Let `VT` be `decay_t<F>`.
+*Constraints:*
+- `remove_cvref_t<F>` is not the same type as `move_only_function`, and
+- `remove_cvref_t<F>` is not a specialization of `in_place_type_t`, and
+- *`is-callable-from`*`<VT>` is `true`.
+*Mandates:* `is_constructible_v<VT, F>` is `true`.
+*Preconditions:* `VT` meets the *Cpp17Destructible* requirements, and if
+`is_move_constructible_v<VT>` is `true`, `VT` meets the
+*Cpp17MoveConstructible* requirements.
+*Ensures:* `*this` has no target object if any of the following hold:
+- `f` is a null function pointer value, or
+- `f` is a null member pointer value, or
+- `remove_cvref_t<F>` is a specialization of the `move_only_function`
+  class template, and `f` has no target object.
+Otherwise, `*this` has a target object of type `VT`
+direct-non-list-initialized with `std::forward<F>(f)`.
+*Throws:* Any exception thrown by the initialization of the target
+object. May throw `bad_alloc` unless `VT` is a function pointer or a
+specialization of `reference_wrapper`.
+``` cpp
+template<class T, class... Args>
+  explicit move_only_function(in_place_type_t<T>, Args&&... args);
+```
+Let `VT` be `decay_t<T>`.
+*Constraints:*
+- `is_constructible_v<VT, Args...>` is `true`, and
+- *`is-callable-from`*`<VT>` is `true`.
+*Mandates:* `VT` is the same type as `T`.
+*Preconditions:* `VT` meets the *Cpp17Destructible* requirements, and if
+`is_move_constructible_v<VT>` is `true`, `VT` meets the
+*Cpp17MoveConstructible* requirements.
+*Ensures:* `*this` has a target object of type `VT`
+direct-non-list-initialized with `std::forward<Args>(args)...`.
+*Throws:* Any exception thrown by the initialization of the target
+object. May throw `bad_alloc` unless `VT` is a function pointer or a
+specialization of `reference_wrapper`.
+``` cpp
+template<class T, class U, class... Args>
+  explicit move_only_function(in_place_type_t<T>, initializer_list<U> ilist, Args&&... args);
+```
+Let `VT` be `decay_t<T>`.
+*Constraints:*
+- `is_constructible_v<VT, initializer_list<U>&, Args...>` is `true`, and
+- *`is-callable-from`*`<VT>` is `true`.
+*Mandates:* `VT` is the same type as `T`.
+*Preconditions:* `VT` meets the *Cpp17Destructible* requirements, and if
+`is_move_constructible_v<VT>` is `true`, `VT` meets the
+*Cpp17MoveConstructible* requirements.
+*Ensures:* `*this` has a target object of type `VT`
+direct-non-list-initialized with `ilist, std::forward<Args>(args)...`.
+*Throws:* Any exception thrown by the initialization of the target
+object. May throw `bad_alloc` unless `VT` is a function pointer or a
+specialization of `reference_wrapper`.
+``` cpp
+move_only_function& operator=(move_only_function&& f);
+```
+*Effects:* Equivalent to:
+`move_only_function(std::move(f)).swap(*this);`
+*Returns:* `*this`.
+``` cpp
+move_only_function& operator=(nullptr_t) noexcept;
+```
+*Effects:* Destroys the target object of `*this`, if any.
+*Returns:* `*this`.
+``` cpp
+template<class F> move_only_function& operator=(F&& f);
+```
+*Effects:* Equivalent to:
+`move_only_function(std::forward<F>(f)).swap(*this);`
+*Returns:* `*this`.
+``` cpp
+~move_only_function();
+```
+*Effects:* Destroys the target object of `*this`, if any.
+##### Invocation <a id="func.wrap.move.inv">[[func.wrap.move.inv]]</a>
+``` cpp
+explicit operator bool() const noexcept;
+```
+*Returns:* `true` if `*this` has a target object, otherwise `false`.
+``` cpp
+R operator()(ArgTypes... args) cv ref noexcept(noex);
+```
+*Preconditions:* `*this` has a target object.
+*Effects:* Equivalent to:
+``` cpp
+return INVOKE<R>(static_cast<F inv-quals>(f), std::forward<ArgTypes>(args)...);
+```
+where `f` is an lvalue designating the target object of `*this` and `F`
+is the type of `f`.
+##### Utility <a id="func.wrap.move.util">[[func.wrap.move.util]]</a>
+``` cpp
+void swap(move_only_function& other) noexcept;
+```
+*Effects:* Exchanges the target objects of `*this` and `other`.
+``` cpp
+friend void swap(move_only_function& f1, move_only_function& f2) noexcept;
+```
+*Effects:* Equivalent to `f1.swap(f2)`.
+``` cpp
+friend bool operator==(const move_only_function& f, nullptr_t) noexcept;
+```
+*Returns:* `true` if `f` has no target object, otherwise `false`.
 ### Searchers <a id="func.search">[[func.search]]</a>
+#### General <a id="func.search.general">[[func.search.general]]</a>
+Subclause [[func.search]] provides function object types
+[[function.objects]] for operations that search for a sequence
+\[`pat``first`, `pat_last`) in another sequence \[`first`, `last`) that
+is provided to the object’s function call operator. The first sequence
+(the pattern to be searched for) is provided to the object’s
+constructor, and the second (the sequence to be searched) is provided to
+the function call operator.
+Each specialization of a class template specified in [[func.search]]
+shall meet the *Cpp17CopyConstructible* and *Cpp17CopyAssignable*
+requirements. Template parameters named
 - `ForwardIterator`,
 - `ForwardIterator1`,
 - `ForwardIterator2`,
 - `RandomAccessIterator`,
 - `RandomAccessIterator1`,
 - `RandomAccessIterator2`, and
 - `BinaryPredicate`
+of templates specified in [[func.search]] shall meet the same
+requirements and semantics as specified in [[algorithms.general]].
 Template parameters named `Hash` shall meet the *Cpp17Hash* requirements
 ([[cpp17.hash]]).
 The Boyer-Moore searcher implements the Boyer-Moore search algorithm.
 The Boyer-Moore-Horspool searcher implements the Boyer-Moore-Horspool
 memory and give better runtime performance than Boyer-Moore-Horspool.
 #### Class template `default_searcher` <a id="func.search.default">[[func.search.default]]</a>
 ``` cpp
+namespace std {
   template<class ForwardIterator1, class BinaryPredicate = equal_to<>>
   class default_searcher {
   public:
     constexpr default_searcher(ForwardIterator1 pat_first, ForwardIterator1 pat_last,
                                BinaryPredicate pred = BinaryPredicate());
   private:
     ForwardIterator1 pat_first_;        // exposition only
     ForwardIterator1 pat_last_;         // exposition only
     BinaryPredicate pred_;              // exposition only
   };
+}
 ```
 ``` cpp
+constexpr default_searcher(ForwardIterator1 pat_first, ForwardIterator1 pat_last,
                            BinaryPredicate pred = BinaryPredicate());
 ```
 *Effects:* Constructs a `default_searcher` object, initializing
 `pat_first_` with `pat_first`, \texttt{pat_last\_} with `pat_last`, and
   `j == next(i, distance(pat_first_, pat_last_))`.
 #### Class template `boyer_moore_searcher` <a id="func.search.bm">[[func.search.bm]]</a>
 ``` cpp
+namespace std {
   template<class RandomAccessIterator1,
            class Hash = hash<typename iterator_traits<RandomAccessIterator1>::value_type>,
            class BinaryPredicate = equal_to<>>
   class boyer_moore_searcher {
   public:
     RandomAccessIterator1 pat_first_;   // exposition only
     RandomAccessIterator1 pat_last_;    // exposition only
     Hash hash_;                         // exposition only
     BinaryPredicate pred_;              // exposition only
   };
+}
 ```
 ``` cpp
 boyer_moore_searcher(RandomAccessIterator1 pat_first,
                      RandomAccessIterator1 pat_last,
                      Hash hf = Hash(),
                      BinaryPredicate pred = BinaryPredicate());
 ```
 *Preconditions:* The value type of `RandomAccessIterator1` meets the
+*Cpp17DefaultConstructible*, the *Cpp17CopyConstructible*, and the
+*Cpp17CopyAssignable* requirements.
+Let `V` be `iterator_traits<RandomAccessIterator1>::value_type`. For any
+two values `A` and `B` of type `V`, if `pred(A, B) == true`, then
+`hf(A) == hf(B)` is `true`.
 *Effects:* Initializes `pat_first_` with `pat_first`, `pat_last_` with
+`pat_last`, `hash_` with `hf`, and \texttt{pred\_} with `pred`.
 *Throws:* Any exception thrown by the copy constructor of
 `RandomAccessIterator1`, or by the default constructor, copy
 constructor, or the copy assignment operator of the value type of
 `RandomAccessIterator1`, or the copy constructor or `operator()` of
 applications of the predicate.
 #### Class template `boyer_moore_horspool_searcher` <a id="func.search.bmh">[[func.search.bmh]]</a>
 ``` cpp
+namespace std {
   template<class RandomAccessIterator1,
            class Hash = hash<typename iterator_traits<RandomAccessIterator1>::value_type>,
            class BinaryPredicate = equal_to<>>
   class boyer_moore_horspool_searcher {
   public:
     RandomAccessIterator1 pat_first_;   // exposition only
     RandomAccessIterator1 pat_last_;    // exposition only
     Hash hash_;                         // exposition only
     BinaryPredicate pred_;              // exposition only
   };
+}
 ```
 ``` cpp
 boyer_moore_horspool_searcher(RandomAccessIterator1 pat_first,
                               RandomAccessIterator1 pat_last,
 *Preconditions:* The value type of `RandomAccessIterator1` meets the
 *Cpp17DefaultConstructible*, *Cpp17CopyConstructible*, and
 *Cpp17CopyAssignable* requirements.
+Let `V` be `iterator_traits<RandomAccessIterator1>::value_type`. For any
+two values `A` and `B` of type `V`, if `pred(A, B) == true`, then
+`hf(A) == hf(B)` is `true`.
 *Effects:* Initializes `pat_first_` with `pat_first`, `pat_last_` with
+`pat_last`, `hash_` with `hf`, and \texttt{pred\_} with `pred`.
 *Throws:* Any exception thrown by the copy constructor of
 `RandomAccessIterator1`, or by the default constructor, copy
 constructor, or the copy assignment operator of the value type of
+`RandomAccessIterator1`, or the copy constructor or `operator()` of
 `BinaryPredicate` or `Hash`. May throw `bad_alloc` if additional memory
 needed for internal data structures cannot be allocated.
 ``` cpp
 template<class RandomAccessIterator2>
 *Effects:* Finds a subsequence of equal values in a sequence.
 *Returns:* A pair of iterators `i` and `j` such that
+- `i` is the first iterator in the range \[`first`,
   `last - (pat_last_ - pat_first_)`) such that for every non-negative
   integer `n` less than `pat_last_ - pat_first_` the following condition
   holds: `pred(*(i + n), *(pat_first_ + n)) != false`, and
 - `j == next(i, distance(pat_first_, pat_last_))`.
 An enabled specialization `hash<Key>` will:
 - meet the *Cpp17Hash* requirements ([[cpp17.hash]]), with `Key` as the
   function call argument type, the *Cpp17DefaultConstructible*
   requirements ([[cpp17.defaultconstructible]]), the
+  *Cpp17CopyAssignable* requirements ([[cpp17.copyassignable]]), the
+  *Cpp17Swappable* requirements [[swappable.requirements]],
 - meet the requirement that if `k1 == k2` is `true`, `h(k1) == h(k2)` is
   also `true`, where `h` is an object of type `hash<Key>` and `k1` and
   `k2` are objects of type `Key`;
 - meet the requirement that the expression `h(k)`, where `h` is an
   object of type `hash<Key>` and `k` is an object of type `Key`, shall
   not throw an exception unless `hash<Key>` is a program-defined
+  specialization.

Diff to HTML by rtfpessoa