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

Files changed (1) hide show

tmp/tmpnetxtfsh/{from.md → to.md} +593 -401

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

@@ -1,36 +1,35 @@
 ## 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 (Clause
-[[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>
-    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> reference_wrapper<T> ref(T&) noexcept;
-  template <class T> 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> reference_wrapper<T> ref(reference_wrapper<T>) noexcept;
-  template <class T> 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;
@@ -56,10 +55,13 @@ namespace std {
   template<> struct greater<void>;
   template<> struct less<void>;
   template<> struct greater_equal<void>;
   template<> struct less_equal<void>;
   // [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>;
@@ -74,22 +76,31 @@ namespace std {
   template<> struct bit_and<void>;
   template<> struct bit_or<void>;
   template<> struct bit_xor<void>;
   template<> struct bit_not<void>;
-  // [func.not_fn], function template not_fn
- template <class F>
-    unspecified not_fn(F&& f);
   // [func.bind], bind
   template<class T> struct is_bind_expression;
   template<class T> struct is_placeholder;
   template<class F, class... BoundArgs>
-    unspecified bind(F&&, BoundArgs&&...);
   template<class R, class F, class... BoundArgs>
-    unspecified bind(F&&, BoundArgs&&...);
   namespace placeholders {
     // M is the implementation-defined number of placeholders
     see belownc _1;
     see belownc _2;
@@ -99,11 +110,11 @@ namespace std {
     see belownc _M;
   }
   // [func.memfn], member function adaptors
   template<class R, class T>
-    unspecified mem_fn(R T::*) noexcept;
   // [func.wrap], polymorphic function wrappers
   class bad_function_call;
   template<class> class function;       // not defined
@@ -112,16 +123,10 @@ namespace std {
   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;
-  template<class R, class... ArgTypes>
-    bool operator==(nullptr_t, const function<R(ArgTypes...)>&) noexcept;
-  template<class R, class... ArgTypes>
-    bool operator!=(const function<R(ArgTypes...)>&, nullptr_t) noexcept;
-  template<class R, class... ArgTypes>
-    bool operator!=(nullptr_t, const function<R(ArgTypes...)>&) noexcept;
   // [func.search], searchers
   template<class ForwardIterator, class BinaryPredicate = equal_to<>>
     class default_searcher;
@@ -133,19 +138,23 @@ namespace std {
   template<class RandomAccessIterator,
            class Hash = hash<typename iterator_traits<RandomAccessIterator>::value_type>,
            class BinaryPredicate = equal_to<>>
     class boyer_moore_horspool_searcher;
-  // [unord.hash], hash function primary template
   template<class T>
     struct hash;
- // [func.bind], function object binders
-  template <class T>
- inline constexpr bool is_bind_expression_v = is_bind_expression<T>::value;
-  template <class T>
- inline constexpr int is_placeholder_v = is_placeholder<T>::value;
 }
 ```
 [*Example 1*:
@@ -173,11 +182,11 @@ transform(a.begin(), a.end(), a.begin(), negate<double>());
 The following definitions apply to this Clause:
 A *call signature* is the name of a return type followed by a
 parenthesized comma-separated list of zero or more argument types.
-A *callable type* is a function object type ([[function.objects]]) or a
 pointer to member.
 A *callable object* is an object of a callable type.
 A *call wrapper type* is a type that holds a callable object and
@@ -185,66 +194,104 @@ supports a call operation that forwards to that object.
 A *call wrapper* is an object of a call wrapper type.
 A *target object* is the callable object held by a call wrapper.
 ### Requirements <a id="func.require">[[func.require]]</a>
-Define `INVOKE(f, t1, t2, ..., tN)` as follows:
-- `(t1.*f)(t2, ..., tN)` when `f` is a pointer to a member function of a
-  class `T` and `is_base_of_v<T, decay_t<decltype(t1)>>` is `true`;
-- `(t1.get().*f)(t2, ..., tN)` when `f` is a pointer to a member
-  function of a class `T` and `decay_t<decltype(t1)>` is a
- specialization of `reference_wrapper`;
-- `((*t1).*f)(t2, ..., tN)` when `f` is a pointer to a member function
-  of a class `T` and `t1` does not satisfy the previous two items;
-- `t1.*f` when `N == 1` and `f` is a pointer to data member of a class
- `T` and `is_base_of_v<T, decay_t<decltype(t1)>>` is `true`;
-- `t1.get().*f` when `N == 1` and `f` is a pointer to data member of a
-  class `T` and `decay_t<decltype(t1)>` is a specialization of
   `reference_wrapper`;
-- `(*t1).*f` when `N == 1` and `f` is a pointer to data member of a
-  class `T` and `t1` does not satisfy the previous two items;
-- `f(t1, t2, ..., tN)` in all other cases.
-Define `INVOKE<R>(f, t1, t2, ..., tN)` as
-`static_cast<void>(INVOKE(f, t1, t2, ..., tN))` if `R` is cv `void`,
-otherwise `INVOKE(f, t1, t2, ..., tN)` implicitly converted to `R`.
-Every call wrapper ([[func.def]]) shall be `MoveConstructible`. A
-*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 shall ensure that
-rvalue arguments are delivered as rvalue references and lvalue arguments
-are delivered as lvalue references. A *simple call wrapper* is a
-forwarding call wrapper that is `CopyConstructible` and `CopyAssignable`
-and whose copy constructor, move constructor, and assignment operator do
-not throw exceptions.
 [*Note 1*:
-In a typical implementation forwarding call wrappers have an overloaded
-function call operator of the form
 ``` cpp
 template<class... UnBoundArgs>
-R operator()(UnBoundArgs&&... unbound_args) cv-qual;
 ```
 — *end note*]
 ### Function template `invoke` <a id="func.invoke">[[func.invoke]]</a>
 ``` cpp
 template<class F, class... Args>
-  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 {
@@ -252,109 +299,130 @@ namespace std {
   public:
     // types
     using type = T;
     // construct/copy/destroy
- reference_wrapper(T&) noexcept;
- reference_wrapper(T&&) = delete;     // do not bind to temporary objects
-    reference_wrapper(const reference_wrapper& x) noexcept;
     // assignment
-    reference_wrapper& operator=(const reference_wrapper& x) noexcept;
     // access
-    operator T& () const noexcept;
-    T& get() const noexcept;
     // invocation
     template<class... ArgTypes>
-      invoke_result_t<T&, ArgTypes...>
-      operator() (ArgTypes&&...) const;
   };
   template<class T>
-    reference_wrapper(reference_wrapper<T>) -> reference_wrapper<T>;
 }
 ```
-`reference_wrapper<T>` is a `CopyConstructible` and `CopyAssignable`
-wrapper around a reference to an object or function of type `T`.
-`reference_wrapper<T>` shall be a trivially copyable type (
-[[basic.types]]).
-#### `reference_wrapper` construct/copy/destroy <a id="refwrap.const">[[refwrap.const]]</a>
 ``` cpp
-reference_wrapper(T& t) noexcept;
 ```
-*Effects:* Constructs a `reference_wrapper` object that stores a
-reference to `t`.
 ``` cpp
-reference_wrapper(const reference_wrapper& x) noexcept;
 ```
 *Effects:* Constructs a `reference_wrapper` object that stores a
 reference to `x.get()`.
-#### `reference_wrapper` assignment <a id="refwrap.assign">[[refwrap.assign]]</a>
 ``` cpp
-reference_wrapper& operator=(const reference_wrapper& x) noexcept;
 ```
-*Postconditions:* `*this` stores a reference to `x.get()`.
-#### `reference_wrapper` access <a id="refwrap.access">[[refwrap.access]]</a>
 ``` cpp
-operator T& () const noexcept;
 ```
 *Returns:* The stored reference.
 ``` cpp
-T& get() const noexcept;
 ```
 *Returns:* The stored reference.
-#### `reference_wrapper` invocation <a id="refwrap.invoke">[[refwrap.invoke]]</a>
 ``` cpp
 template<class... ArgTypes>
-  invoke_result_t<T&, ArgTypes...>
     operator()(ArgTypes&&... args) const;
 ```
 *Returns:* *INVOKE*(get(),
-std::forward\<ArgTypes\>(args)...). ([[func.require]])
-#### `reference_wrapper` helper functions <a id="refwrap.helpers">[[refwrap.helpers]]</a>
 ``` cpp
-template <class T> reference_wrapper<T> ref(T& t) noexcept;
 ```
 *Returns:* `reference_wrapper<T>(t)`.
 ``` cpp
-template <class T> reference_wrapper<T> ref(reference_wrapper<T> t) noexcept;
 ```
 *Returns:* `ref(t.get())`.
 ``` cpp
-template <class T> reference_wrapper<const T> cref(const T& t) noexcept;
 ```
 *Returns:* `reference_wrapper <const T>(t)`.
 ``` cpp
-template <class T> reference_wrapper<const T> cref(reference_wrapper<T> t) noexcept;
 ```
 *Returns:* `cref(t.get())`.
 ### Arithmetic operations <a id="arithmetic.operations">[[arithmetic.operations]]</a>
@@ -546,26 +614,25 @@ template <class T> constexpr auto operator()(T&& t) const
 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 strict total order that is
-consistent among those specializations and is also consistent with the
-partial order imposed by the built-in operators `<`, `>`, `<=`, `>=`.
-[*Note 1*: When `a < b` is well-defined for pointers `a` and `b` of
-type `P`, this implies `(a < b) == less<P>(a, b)`,
-`(a > b) == greater<P>(a, b)`, and so forth. — *end note*]
 For template specializations `less<void>`, `greater<void>`,
 `less_equal<void>`, and `greater_equal<void>`, if the call operator
 calls a built-in operator comparing pointers, the call operator yields a
-strict total order that is consistent among those specializations and is
-also consistent with the partial order imposed by those built-in
-operators.
-#### Class template `equal_to` <a id="comparisons.equal_to">[[comparisons.equal_to]]</a>
 ``` cpp
 template<class T = void> struct equal_to {
   constexpr bool operator()(const T& x, const T& y) const;
 };
@@ -591,11 +658,11 @@ template <class T, class U> constexpr auto operator()(T&& t, U&& u) const
     -> decltype(std::forward<T>(t) == std::forward<U>(u));
 ```
 *Returns:* `std::forward<T>(t) == std::forward<U>(u)`.
-#### Class template `not_equal_to` <a id="comparisons.not_equal_to">[[comparisons.not_equal_to]]</a>
 ``` cpp
 template<class T = void> struct not_equal_to {
   constexpr bool operator()(const T& x, const T& y) const;
 };
@@ -681,11 +748,11 @@ template <class T, class U> constexpr auto operator()(T&& t, U&& u) const
     -> decltype(std::forward<T>(t) < std::forward<U>(u));
 ```
 *Returns:* `std::forward<T>(t) < std::forward<U>(u)`.
-#### Class template `greater_equal` <a id="comparisons.greater_equal">[[comparisons.greater_equal]]</a>
 ``` cpp
 template<class T = void> struct greater_equal {
   constexpr bool operator()(const T& x, const T& y) const;
 };
@@ -711,11 +778,11 @@ template <class T, class U> constexpr auto operator()(T&& t, U&& u) const
     -> decltype(std::forward<T>(t) >= std::forward<U>(u));
 ```
 *Returns:* `std::forward<T>(t) >= std::forward<U>(u)`.
-#### Class template `less_equal` <a id="comparisons.less_equal">[[comparisons.less_equal]]</a>
 ``` cpp
 template<class T = void> struct less_equal {
   constexpr bool operator()(const T& x, const T& y) const;
 };
@@ -741,10 +808,182 @@ template <class T, class U> constexpr auto operator()(T&& t, U&& u) const
     -> decltype(std::forward<T>(t) <= std::forward<U>(u));
 ```
 *Returns:* `std::forward<T>(t) <= std::forward<U>(u)`.
 ### 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]]).
@@ -963,91 +1202,92 @@ template <class T> constexpr auto operator()(T&&) const
     -> decltype(~std::forward<T>(t));
 ```
 *Returns:* `~std::forward<T>(t)`.
-### Function template `not_fn` <a id="func.not_fn">[[func.not_fn]]</a>
 ``` cpp
-template <class F> unspecified not_fn(F&& f);
-```
-*Effects:* Equivalent to
-`return `*`call_wrapper`*`(std::forward<F>(f));` where *`call_wrapper`*
-is an exposition only class defined as follows:
-``` cpp
-class call_wrapper {
-  using FD = decay_t<F>;
-  FD fd;
-  explicit call_wrapper(F&& f);
-public:
-  call_wrapper(call_wrapper&&) = default;
-  call_wrapper(const call_wrapper&) = default;
-  template<class... Args>
-    auto operator()(Args&&...) &
-      -> decltype(!declval<invoke_result_t<FD&, Args...>>());
-  template<class... Args>
-    auto operator()(Args&&...) const&
-      -> decltype(!declval<invoke_result_t<const FD&, Args...>>());
-  template<class... Args>
-    auto operator()(Args&&...) &&
-      -> decltype(!declval<invoke_result_t<FD, Args...>>());
-  template<class... Args>
-    auto operator()(Args&&...) const&&
-      -> decltype(!declval<invoke_result_t<const FD, Args...>>());
 };
 ```
 ``` cpp
-explicit call_wrapper(F&& f);
 ```
-*Requires:* `FD` shall satisfy the requirements of `MoveConstructible`.
-`is_constructible_v<FD, F>` shall be `true`. `fd` shall be a callable
-object ([[func.def]]).
-*Effects:* Initializes `fd` from `std::forward<F>(f)`.
-*Throws:* Any exception thrown by construction of `fd`.
-``` cpp
-template<class... Args>
-  auto operator()(Args&&... args) &
-    -> decltype(!declval<invoke_result_t<FD&, Args...>>());
-template<class... Args>
-  auto operator()(Args&&... args) const&
-    -> decltype(!declval<invoke_result_t<const FD&, Args...>>());
-```
-*Effects:* Equivalent to:
-``` cpp
-return !INVOKE(fd, std::forward<Args>(args)...);              // see [func.require]
-```
 ``` cpp
-template<class... Args>
- auto operator()(Args&&... args) &&
-    -> decltype(!declval<invoke_result_t<FD, Args...>>());
-template<class... Args>
-  auto operator()(Args&&... args) const&&
-    -> decltype(!declval<invoke_result_t<const FD, Args...>>());
 ```
-*Effects:* Equivalent to:
 ``` cpp
-return !INVOKE(std::move(fd), std::forward<Args>(args)...);   // see [func.require]
 ```
 ### Function object binders <a id="func.bind">[[func.bind]]</a>
 This subclause describes a uniform mechanism for binding arguments of
 callable objects.
@@ -1061,18 +1301,18 @@ namespace std {
 The class template `is_bind_expression` can be used to detect function
 objects generated by `bind`. The function template `bind` uses
 `is_bind_expression` to detect subexpressions.
-Instantiations of the `is_bind_expression` template shall meet the
-`UnaryTypeTrait` requirements ([[meta.rqmts]]). The implementation
-shall provide a definition that has a base characteristic of `true_type`
-if `T` is a type returned from `bind`, otherwise it shall have a base
 characteristic of `false_type`. A program may specialize this template
-for a user-defined type `T` to have a base characteristic of `true_type`
-to indicate that `T` should be treated as a subexpression in a `bind`
-call.
 #### Class template `is_placeholder` <a id="func.bind.isplace">[[func.bind.isplace]]</a>
 ``` cpp
 namespace std {
@@ -1082,120 +1322,100 @@ namespace std {
 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.
-Instantiations of the `is_placeholder` template shall meet the
-`UnaryTypeTrait` requirements ([[meta.rqmts]]). The implementation
-shall provide a definition that has the base characteristic of
 `integral_constant<int, J>` if `T` is the type of
-`std::placeholders::_J`, otherwise it shall have a base characteristic
-of `integral_constant<int, 0>`. A program may specialize this template
-for a user-defined type `T` to have a base characteristic of
 `integral_constant<int, N>` with `N > 0` to indicate that `T` should be
 treated as a placeholder type.
 #### Function template `bind` <a id="func.bind.bind">[[func.bind.bind]]</a>
 In the text that follows:
 - `FD` is the type `decay_t<F>`,
-- `fd` is an lvalue of type `FD` constructed from `std::forward<F>(f)`,
 - `Tᵢ` is the iᵗʰ type in the template parameter pack `BoundArgs`,
 - `TDᵢ` is the type `decay_t<Tᵢ>`,
 - `tᵢ` is the iᵗʰ argument in the function parameter pack `bound_args`,
-- `tdᵢ` is an lvalue of type `TDᵢ` constructed from
-  `std::forward<Tᵢ>(tᵢ)`,
 - `Uⱼ` is the jᵗʰ deduced type of the `UnBoundArgs&&...` parameter of
-  the forwarding call wrapper, and
 - `uⱼ` is the jᵗʰ argument associated with `Uⱼ`.
 ``` cpp
 template<class F, class... BoundArgs>
-  unspecified bind(F&& f, BoundArgs&&... bound_args);
-```
-*Requires:* `is_constructible_v<FD, F>` shall be `true`. For each `Tᵢ`
-in `BoundArgs`, `is_constructible_v<``TDᵢ``, ``Tᵢ``>` shall be `true`.
-*INVOKE*(fd, w₁, w₂, …, $w_N$) ([[func.require]]) shall be a valid
-expression for some values `w₁`, `w₂`, …, `w_N`, where N has the value
-`sizeof...(bound_args)`. The cv-qualifiers cv of the call wrapper `g`,
-as specified below, shall be neither `volatile` nor `const volatile`.
-*Returns:* A forwarding call wrapper `g` ([[func.require]]). The effect
-of `g(``u₁``, ``u₂``, …, ``u_M``)` shall be
-``` cpp
-INVOKE(fd, std::forward<$V_1$>($v_1$), std::forward<$V_2$>($v_2$), … , std::forward<$V_N$>($v_N$))
-```
-where the values and types of the bound arguments `v₁`, `v₂`, …, `v_N`
-are determined as specified below. The copy constructor and move
-constructor of the forwarding call wrapper shall throw an exception if
-and only if the corresponding constructor of `FD` or of any of the types
-`TDᵢ` throws an exception.
-*Throws:* Nothing unless the construction of `fd` or of one of the
-values `tdᵢ` throws an exception.
-*Remarks:* The return type shall satisfy the requirements of
-`MoveConstructible`. If all of `FD` and `TDᵢ` satisfy the requirements
-of `CopyConstructible`, then the return type shall satisfy the
-requirements of `CopyConstructible`.
-[*Note 1*: This implies that all of `FD` and `TDᵢ` are
-`MoveConstructible`. — *end note*]
-``` cpp
 template<class R, class F, class... BoundArgs>
-  unspecified bind(F&& f, BoundArgs&&... bound_args);
 ```
-*Requires:* `is_constructible_v<FD, F>` shall be `true`. For each `Tᵢ`
-in `BoundArgs`, `is_constructible_v<``TDᵢ``, ``Tᵢ``>` shall be `true`.
-*INVOKE*(fd, w₁, w₂, …, $w_N$) shall be a valid expression for some
-values `w₁`, `w₂`, …, `w_N`, where N has the value
-`sizeof...(bound_args)`. The cv-qualifiers cv of the call wrapper `g`,
-as specified below, shall be neither `volatile` nor `const volatile`.
-*Returns:* A forwarding call wrapper `g` ([[func.require]]). The effect
-of `g(``u₁``, ``u₂``, …, ``u_M``)` shall be
 ``` cpp
-INVOKE<R>(fd, std::forward<$V_1$>($v_1$), std::forward<$V_2$>($v_2$), … , std::forward<$V_N$>($v_N$))
 ```
-where the values and types of the bound arguments `v₁`, `v₂`, …, `v_N`
-are determined as specified below. The copy constructor and move
-constructor of the forwarding call wrapper shall throw an exception if
-and only if the corresponding constructor of `FD` or of any of the types
-`TDᵢ` throws an exception.
-*Throws:* Nothing unless the construction of `fd` or of one of the
-values `tdᵢ` throws an exception.
-*Remarks:* The return type shall satisfy the requirements of
-`MoveConstructible`. If all of `FD` and `TDᵢ` satisfy the requirements
-of `CopyConstructible`, then the return type shall satisfy the
-requirements of `CopyConstructible`.
-[*Note 2*: This implies that all of `FD` and `TDᵢ` are
-`MoveConstructible`. — *end note*]
 The values of the *bound arguments* `v₁`, `v₂`, …, `v_N` and their
 corresponding types `V₁`, `V₂`, …, `V_N` depend on the types `TDᵢ`
 derived from the call to `bind` and the cv-qualifiers cv of the call
 wrapper `g` as follows:
 - if `TDᵢ` is `reference_wrapper<T>`, the argument is `tdᵢ.get()` and
   its type `Vᵢ` is `T&`;
 - if the value of `is_bind_expression_v<TDᵢ>` is `true`, the argument is
-  `tdᵢ(std::forward<Uⱼ>(uⱼ)...)` and its type `Vᵢ` is
- `invoke_result_t<TDᵢ cv &, Uⱼ...>&&`;
 - if the value `j` of `is_placeholder_v<TDᵢ>` is not zero, the argument
   is `std::forward<Uⱼ>(uⱼ)` and its type `Vᵢ` is `Uⱼ&&`;
-- otherwise, the value is `tdᵢ` and its type `Vᵢ` is `TDᵢ cv &`.
 #### Placeholders <a id="func.bind.place">[[func.bind.place]]</a>
 ``` cpp
 namespace std::placeholders {
@@ -1207,68 +1427,68 @@ namespace std::placeholders {
               .
   see below _M;
 }
 ```
-All placeholder types shall be `DefaultConstructible` and
-`CopyConstructible`, and their default constructors and copy/move
-constructors shall not throw exceptions. It is *implementation-defined*
-whether placeholder types are `CopyAssignable`. `CopyAssignable`
-placeholders’ copy assignment operators shall not throw exceptions.
 Placeholders should be defined as:
 ``` cpp
 inline constexpr unspecified _1{};
 ```
-If they are not, they shall be declared as:
 ``` cpp
 extern unspecified _1;
 ```
 ### Function template `mem_fn` <a id="func.memfn">[[func.memfn]]</a>
 ``` cpp
-template<class R, class T> unspecified mem_fn(R T::* pm) noexcept;
 ```
-*Returns:* A simple call wrapper ([[func.def]]) `fn` such that the
-expression `fn(t, a2, ..., aN)` is equivalent to *INVOKE*(pm, t, a2,
-..., aN) ([[func.require]]).
 ### 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 object has no target.
 ``` cpp
 namespace std {
   class bad_function_call : public exception {
   public:
-    // [func.wrap.badcall.const], constructor
- bad_function_call() noexcept;
   };
 }
 ```
-##### `bad_function_call` constructor <a id="func.wrap.badcall.const">[[func.wrap.badcall.const]]</a>
 ``` cpp
-bad_function_call() noexcept;
 ```
-*Effects:* Constructs a `bad_function_call` object.
-*Postconditions:* `what()` returns an *implementation-defined* NTBS.
 #### Class template `function` <a id="func.wrap.func">[[func.wrap.func]]</a>
 ``` cpp
 namespace std {
@@ -1281,11 +1501,11 @@ namespace std {
     // [func.wrap.func.con], construct/copy/destroy
     function() noexcept;
     function(nullptr_t) noexcept;
     function(const function&);
-    function(function&&);
     template<class F> function(F);
     function& operator=(const function&);
     function& operator=(function&&);
     function& operator=(nullptr_t) noexcept;
@@ -1312,132 +1532,116 @@ 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 comparisons
   template<class R, class... ArgTypes>
     bool operator==(const function<R(ArgTypes...)>&, nullptr_t) noexcept;
-  template <class R, class... ArgTypes>
-    bool operator==(nullptr_t, const function<R(ArgTypes...)>&) noexcept;
-  template <class R, class... ArgTypes>
-    bool operator!=(const function<R(ArgTypes...)>&, nullptr_t) noexcept;
-  template <class R, class... ArgTypes>
-    bool operator!=(nullptr_t, const function<R(ArgTypes...)>&) 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 (Clause  [[expr]]), 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*]
-##### `function` construct/copy/destroy <a id="func.wrap.func.con">[[func.wrap.func.con]]</a>
 ``` cpp
 function() noexcept;
 ```
-*Postconditions:* `!*this`.
 ``` cpp
 function(nullptr_t) noexcept;
 ```
-*Postconditions:* `!*this`.
 ``` cpp
 function(const function& f);
 ```
-*Postconditions:* `!*this` if `!f`; otherwise, `*this` targets a copy of
 `f.target()`.
-*Throws:* shall not throw exceptions 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 are encouraged to 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);
 ```
-*Postconditions:* 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.
-*Throws:* shall not throw exceptions 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 or move constructor of
-the stored callable object.
-[*Note 2*: Implementations are encouraged to 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);
 ```
-*Requires:* `F` shall be `CopyConstructible`.
-*Remarks:* This constructor template shall not participate in overload
-resolution unless `F` is Lvalue-Callable ([[func.wrap.func]]) for
-argument types `ArgTypes...` and return type `R`.
-*Postconditions:* `!*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 are encouraged to 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:* shall not throw exceptions when `f` is a function pointer or a
-`reference_wrapper<T>` for some `T`. 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>;
 ```
-*Remarks:* This deduction guide participates in overload resolution only
-if `&F::operator()` is well-formed when treated as an unevaluated
-operand. In that case, if `decltype(&F::operator())` is of the form
-`R(G::*)(A...)` cv `&`ₒₚₜ ` noexcept` for a class type `G`, then the
-deduced type is `function<R(A...)>`.
 [*Example 1*:
 ``` cpp
 void f() {
@@ -1468,26 +1672,25 @@ function& operator=(function&& f);
 function& operator=(nullptr_t) noexcept;
 ```
 *Effects:* If `*this != nullptr`, destroys the target of `this`.
-*Postconditions:* `!(*this)`.
 *Returns:* `*this`.
 ``` cpp
 template<class F> function& operator=(F&& f);
 ```
 *Effects:* As if by: `function(std::forward<F>(f)).swap(*this);`
 *Returns:* `*this`.
-*Remarks:* This assignment operator shall not participate in overload
-resolution unless `decay_t<F>` is Lvalue-Callable ([[func.wrap.func]])
-for argument types `ArgTypes...` and return type `R`.
 ``` cpp
 template<class F> function& operator=(reference_wrapper<F> f) noexcept;
 ```
 *Effects:* As if by: `function(f).swap(*this);`
@@ -1498,40 +1701,40 @@ template<class F> function& operator=(reference_wrapper<F> f) noexcept;
 ~function();
 ```
 *Effects:* If `*this != nullptr`, destroys the target of `this`.
-##### `function` modifiers <a id="func.wrap.func.mod">[[func.wrap.func.mod]]</a>
 ``` cpp
 void swap(function& other) noexcept;
 ```
-*Effects:* interchanges the targets of `*this` and `other`.
-##### `function` capacity <a id="func.wrap.func.cap">[[func.wrap.func.cap]]</a>
 ``` cpp
 explicit operator bool() const noexcept;
 ```
 *Returns:* `true` if `*this` has a target, otherwise `false`.
-##### `function` invocation <a id="func.wrap.func.inv">[[func.wrap.func.inv]]</a>
 ``` cpp
 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.
-##### `function` target access <a id="func.wrap.func.targ">[[func.wrap.func.targ]]</a>
 ``` cpp
 const type_info& target_type() const noexcept;
 ```
@@ -1544,51 +1747,40 @@ 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;
-template <class R, class... ArgTypes>
-  bool operator==(nullptr_t, const function<R(ArgTypes...)>& f) noexcept;
 ```
 *Returns:* `!f`.
-``` cpp
-template <class R, class... ArgTypes>
-  bool operator!=(const function<R(ArgTypes...)>& f, nullptr_t) noexcept;
-template <class R, class... ArgTypes>
-  bool operator!=(nullptr_t, const function<R(ArgTypes...)>& f) noexcept;
-```
-*Returns:* `(bool)f`.
-##### specialized algorithms <a id="func.wrap.func.alg">[[func.wrap.func.alg]]</a>
 ``` cpp
 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 `CopyConstructible` and `CopyAssignable`
-requirements. Template parameters named
 - `ForwardIterator`,
 - `ForwardIterator1`,
 - `ForwardIterator2`,
 - `RandomAccessIterator`,
@@ -1596,12 +1788,12 @@ requirements. Template parameters named
 - `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 requirements as
-specified in [[hash.requirements]].
 The Boyer-Moore searcher implements the Boyer-Moore search algorithm.
 The Boyer-Moore-Horspool searcher implements the Boyer-Moore-Horspool
 search algorithm. In general, the Boyer-Moore searcher will use more
 memory and give better runtime performance than Boyer-Moore-Horspool.
@@ -1610,26 +1802,26 @@ memory and give better runtime performance than Boyer-Moore-Horspool.
 ``` cpp
 template<class ForwardIterator1, class BinaryPredicate = equal_to<>>
   class default_searcher {
   public:
-    default_searcher(ForwardIterator1 pat_first, ForwardIterator1 pat_last,
                                BinaryPredicate pred = BinaryPredicate());
     template<class ForwardIterator2>
-      pair<ForwardIterator2, ForwardIterator2>
         operator()(ForwardIterator2 first, ForwardIterator2 last) const;
   private:
     ForwardIterator1 pat_first_;        // exposition only
     ForwardIterator1 pat_last_;         // exposition only
     BinaryPredicate pred_;              // exposition only
   };
 ```
 ``` cpp
-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
@@ -1638,11 +1830,11 @@ default_searcher(ForwardIterator pat_first, ForwardIterator pat_last,
 *Throws:* Any exception thrown by the copy constructor of
 `BinaryPredicate` or `ForwardIterator1`.
 ``` cpp
 template<class ForwardIterator2>
-  pair<ForwardIterator2, ForwardIterator2>
     operator()(ForwardIterator2 first, ForwardIterator2 last) const;
 ```
 *Effects:* Returns a pair of iterators `i` and `j` such that
@@ -1680,21 +1872,21 @@ boyer_moore_searcher(RandomAccessIterator1 pat_first,
                      RandomAccessIterator1 pat_last,
                      Hash hf = Hash(),
                      BinaryPredicate pred = BinaryPredicate());
 ```
-*Requires:* The value type of `RandomAccessIterator1` shall meet the
-`DefaultConstructible` requirements, the `CopyConstructible`
-requirements, and the `CopyAssignable` requirements.
-*Requires:* For any two values `A` and `B` of the type
-`iterator_traits<RandomAccessIterator1>::value_type`, if
-`pred(A, B) == true`, then `hf(A) == hf(B)` shall be `true`.
-*Effects:* Constructs a `boyer_moore_searcher` object, initializing
-`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
@@ -1705,12 +1897,12 @@ needed for internal data structures cannot be allocated.
 template<class RandomAccessIterator2>
   pair<RandomAccessIterator2, RandomAccessIterator2>
     operator()(RandomAccessIterator2 first, RandomAccessIterator2 last) const;
 ```
-*Requires:* `RandomAccessIterator1` and `RandomAccessIterator2` shall
-have the same value type.
 *Effects:* Finds a subsequence of equal values in a sequence.
 *Returns:* A pair of iterators `i` and `j` such that
@@ -1757,21 +1949,21 @@ boyer_moore_horspool_searcher(RandomAccessIterator1 pat_first,
                               RandomAccessIterator1 pat_last,
                               Hash hf = Hash(),
                               BinaryPredicate pred = BinaryPredicate());
 ```
-*Requires:* The value type of `RandomAccessIterator1` shall meet the
-`DefaultConstructible`, `CopyConstructible`, and `CopyAssignable`
-requirements.
-*Requires:* For any two values `A` and `B` of the type
-`iterator_traits<RandomAccessIterator1>::value_type`, if
-`pred(A, B) == true`, then `hf(A) == hf(B)` shall be `true`.
-*Effects:* Constructs a `boyer_moore_horspool_searcher` object,
-initializing `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
@@ -1782,12 +1974,12 @@ needed for internal data structures cannot be allocated.
 template<class RandomAccessIterator2>
   pair<RandomAccessIterator2, RandomAccessIterator2>
     operator()(RandomAccessIterator2 first, RandomAccessIterator2 last) const;
 ```
-*Requires:* `RandomAccessIterator1` and `RandomAccessIterator2` shall
-have the same value type.
 *Effects:* Finds a subsequence of equal values in a sequence.
 *Returns:* A pair of iterators `i` and `j` such that
@@ -1805,18 +1997,18 @@ found.
 applications of the predicate.
 ### Class template `hash` <a id="unord.hash">[[unord.hash]]</a>
 The unordered associative containers defined in [[unord]] use
-specializations of the class template `hash` ([[functional.syn]]) as
-the default hash function.
 Each specialization of `hash` is either enabled or disabled, as
 described below.
-[*Note 1*: Enabled specializations meet the requirements of `Hash`, and
-disabled specializations do not. — *end note*]
 Each header that declares the template `hash` provides enabled
 specializations of `hash` for `nullptr_t` and all cv-unqualified
 arithmetic, enumeration, and pointer types. For any type `Key` for which
 neither the library nor the user provides an explicit or partial
@@ -1828,25 +2020,25 @@ and its member functions are `noexcept` except as noted otherwise.
 If `H` is a disabled specialization of `hash`, these values are `false`:
 `is_default_constructible_v<H>`, `is_copy_constructible_v<H>`,
 `is_move_constructible_v<H>`, `is_copy_assignable_v<H>`, and
 `is_move_assignable_v<H>`. Disabled specializations of `hash` are not
-function object types ([[function.objects]]).
 [*Note 2*: This means that the specialization of `hash` exists, but any
-attempts to use it as a `Hash` will be ill-formed. — *end note*]
 An enabled specialization `hash<Key>` will:
-- satisfy the `Hash` requirements ([[hash.requirements]]), with `Key`
- as the function call argument type, the `DefaultConstructible`
-  requirements (Table  [[tab:defaultconstructible]]), the
- `CopyAssignable` requirements (Table  [[tab:copyassignable]]),
-- be swappable ([[swappable.requirements]]) for lvalues,
-- satisfy 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`;
-- satisfy 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 user-defined
-  specialization that depends on at least one user-defined type.

 ## 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<> 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 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>
     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_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*:
 The following definitions apply to this Clause:
 A *call signature* is the name of a return type followed by a
 parenthesized comma-separated list of zero or more argument types.
+A *callable type* is a function object type [[function.objects]] or a
 pointer to member.
 A *callable object* is an object of a callable type.
 A *call wrapper type* is a type that holds a callable object and
 A *call wrapper* is an object of a call wrapper type.
 A *target object* is the callable object held by a call wrapper.
+A call wrapper type may additionally hold a sequence of objects and
+references that may be passed as arguments to the target object. These
+entities are collectively referred to as *bound argument entities*.
+The target object and bound argument entities of the call wrapper are
+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
+overloaded function call operator of the form
 ``` cpp
 template<class... UnBoundArgs>
+  constexpr R operator()(UnBoundArgs&&... unbound_args) cv-qual;
 ```
 — *end note*]
+A *perfect forwarding call wrapper* is an argument forwarding call
+wrapper that forwards its state entities to the underlying call
+expression. This forwarding step delivers a state entity of type `T` as
+cv `T&` when the call is performed on an lvalue of the call wrapper type
+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
+the *Cpp17CopyConstructible* and *Cpp17CopyAssignable* requirements and
+whose copy constructor, move constructor, and assignment operators are
+constexpr functions that do not throw exceptions.
+The copy/move constructor of an argument forwarding call wrapper has the
+same apparent semantics as if memberwise copy/move of its state entities
+were performed [[class.copy.ctor]].
+[*Note 2*: This implies that each of the copy/move constructors has the
+same exception-specification as the corresponding implicit definition
+and is declared as `constexpr` if the corresponding implicit definition
+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 {
   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);
 ```
+Let *FUN* denote the exposition-only functions
+``` cpp
+void FUN(T&) noexcept;
+void FUN(T&&) = delete;
+```
+*Constraints:* The expression *FUN*(declval\<U\>()) is well-formed and
+`is_same_v<remove_cvref_t<U>, reference_wrapper>` is `false`.
+*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;
 ```
 *Effects:* Constructs a `reference_wrapper` object that stores a
 reference to `x.get()`.
+#### Assignment <a id="refwrap.assign">[[refwrap.assign]]</a>
 ``` cpp
+constexpr reference_wrapper& operator=(const reference_wrapper& x) noexcept;
 ```
+*Ensures:* `*this` stores a reference to `x.get()`.
+#### Access <a id="refwrap.access">[[refwrap.access]]</a>
 ``` cpp
+constexpr operator T& () const noexcept;
 ```
 *Returns:* The stored reference.
 ``` cpp
+constexpr T& get() const noexcept;
 ```
 *Returns:* The stored reference.
+#### 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(),
+std::forward\<ArgTypes\>(args)...). [[func.require]]
+#### Helper functions <a id="refwrap.helpers">[[refwrap.helpers]]</a>
+The template parameter `T` of the following `ref` and `cref` function
+templates may be an incomplete type.
 ``` cpp
+template<class T> constexpr reference_wrapper<T> ref(T& t) noexcept;
 ```
 *Returns:* `reference_wrapper<T>(t)`.
 ``` 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;
 ```
 *Returns:* `reference_wrapper <const T>(t)`.
 ``` 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
 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]].
+[*Note 1*: If `a < b` is well-defined for pointers `a` and `b` of type
+`P`, then `(a < b) == less<P>()(a, b)`, `(a > b) == greater<P>()(a, b)`,
+and so forth. — *end note*]
 For template specializations `less<void>`, `greater<void>`,
 `less_equal<void>`, and `greater_equal<void>`, if the call operator
 calls a built-in operator comparing pointers, the call operator yields a
+result consistent with the implementation-defined strict total order
+over pointers.
+#### Class template `equal_to` <a id="comparisons.equal.to">[[comparisons.equal.to]]</a>
 ``` cpp
 template<class T = void> struct equal_to {
   constexpr bool operator()(const T& x, const T& y) const;
 };
     -> decltype(std::forward<T>(t) == std::forward<U>(u));
 ```
 *Returns:* `std::forward<T>(t) == std::forward<U>(u)`.
+#### Class template `not_equal_to` <a id="comparisons.not.equal.to">[[comparisons.not.equal.to]]</a>
 ``` cpp
 template<class T = void> struct not_equal_to {
   constexpr bool operator()(const T& x, const T& y) const;
 };
     -> decltype(std::forward<T>(t) < std::forward<U>(u));
 ```
 *Returns:* `std::forward<T>(t) < std::forward<U>(u)`.
+#### Class template `greater_equal` <a id="comparisons.greater.equal">[[comparisons.greater.equal]]</a>
 ``` cpp
 template<class T = void> struct greater_equal {
   constexpr bool operator()(const T& x, const T& y) const;
 };
     -> decltype(std::forward<T>(t) >= std::forward<U>(u));
 ```
 *Returns:* `std::forward<T>(t) >= std::forward<U>(u)`.
+#### Class template `less_equal` <a id="comparisons.less.equal">[[comparisons.less.equal]]</a>
 ``` cpp
 template<class T = void> struct less_equal {
   constexpr bool operator()(const T& x, const T& y) const;
 };
     -> decltype(std::forward<T>(t) <= std::forward<U>(u));
 ```
 *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`,
+  returns `strong_ordering::less` if (the converted value of) `t`
+  precedes `u` in the implementation-defined strict total order over
+  pointers [[defns.order.ptr]], `strong_ordering::greater` if `u`
+  precedes `t`, and otherwise `strong_ordering::equal`.
+- 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
+  `false` if either (the converted value of) `t` precedes `u` or `u`
+  precedes `t` in the implementation-defined strict total order over
+  pointers [[defns.order.ptr]] and otherwise `true`.
+- Otherwise, equivalent to:
+  `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
+  a call to a built-in operator `<` comparing pointers: returns `true`
+  if (the converted value of) `t` precedes `u` in the
+  implementation-defined strict total order over
+  pointers [[defns.order.ptr]] and otherwise `false`.
+- Otherwise, equivalent to:
+  `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]]).
     -> decltype(~std::forward<T>(t));
 ```
 *Returns:* `~std::forward<T>(t)`.
+### Class `identity` <a id="func.identity">[[func.identity]]</a>
 ``` cpp
+struct identity {
+  template<class T>
+    constexpr T&& operator()(T&& t) const noexcept;
+  using is_transparent = unspecified;
 };
+template<class T>
+  constexpr T&& operator()(T&& t) const noexcept;
 ```
+*Effects:* Equivalent to: `return std::forward<T>(t);`
+### Function template `not_fn` <a id="func.not.fn">[[func.not.fn]]</a>
 ``` cpp
+template<class F> constexpr unspecified not_fn(F&& f);
 ```
+In the text that follows:
+- `g` is a value of the result of a `not_fn` 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)`,
+- `call_args` is an argument pack used in a function call
+  expression [[expr.call]] of `g`.
+*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]]
+  of types `BoundArgs...`, direct-non-list-initialized with
+  `std::forward<Args>(args)...`, respectively, and
+- `call_args` is an argument pack used in a function call
+  expression [[expr.call]] of `g`.
+*Mandates:*
 ``` cpp
+is_constructible_v<FD, F> &&
+is_move_constructible_v<FD> &&
+(is_constructible_v<BoundArgs, Args> && ...) &&
+(is_move_constructible_v<BoundArgs> && ...)
 ```
+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.
 The class template `is_bind_expression` can be used to detect function
 objects generated by `bind`. The function template `bind` uses
 `is_bind_expression` to detect subexpressions.
+Specializations of the `is_bind_expression` template shall meet the
+*Cpp17UnaryTypeTrait* requirements [[meta.rqmts]]. The implementation
+provides a definition that has a base characteristic of `true_type` if
+`T` is a type returned from `bind`, otherwise it has a base
 characteristic of `false_type`. A program may specialize this template
+for a program-defined type `T` to have a base characteristic of
+`true_type` to indicate that `T` should be treated as a subexpression in
+a `bind` call.
 #### Class template `is_placeholder` <a id="func.bind.isplace">[[func.bind.isplace]]</a>
 ``` cpp
 namespace std {
 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
+`std::placeholders::_J`, otherwise it has a base characteristic of
+`integral_constant<int, 0>`. A program may specialize this template for
+a program-defined type `T` to have a base characteristic of
 `integral_constant<int, N>` with `N > 0` to indicate that `T` should be
 treated as a placeholder type.
 #### Function template `bind` <a id="func.bind.bind">[[func.bind.bind]]</a>
 In the text that follows:
+- `g` is a value of the result of a `bind` invocation,
 - `FD` is the type `decay_t<F>`,
+- `fd` is an lvalue that is a target object of `g` [[func.def]] of type
+  `FD` direct-non-list-initialized with `std::forward<F>(f)`,
 - `Tᵢ` is the iᵗʰ type in the template parameter pack `BoundArgs`,
 - `TDᵢ` is the type `decay_t<Tᵢ>`,
 - `tᵢ` is the iᵗʰ argument in the function parameter pack `bound_args`,
+- `tdᵢ` is a bound argument entity of `g` [[func.def]] of type `TDᵢ`
+ direct-non-list-initialized with `std::forward<{}Tᵢ>(tᵢ)`,
 - `Uⱼ` is the jᵗʰ deduced type of the `UnBoundArgs&&...` parameter of
+  the argument forwarding call wrapper, and
 - `uⱼ` is the jᵗʰ argument associated with `Uⱼ`.
 ``` cpp
 template<class F, class... BoundArgs>
+ constexpr unspecified bind(F&& f, BoundArgs&&... bound_args);
 template<class R, class F, class... BoundArgs>
+ constexpr unspecified bind(F&& f, BoundArgs&&... bound_args);
 ```
+*Mandates:* `is_constructible_v<FD, F>` is `true`. For each `Tᵢ` in
+`BoundArgs`, `is_constructible_v<``TDᵢ``, ``Tᵢ``>` is `true`.
+*Preconditions:* `FD` and each `TDᵢ` meet the *Cpp17MoveConstructible*
+and *Cpp17Destructible* requirements. *INVOKE*(fd, w₁, w₂, …,
+$w_N$) [[func.require]] is a valid expression for some values `w₁`,
+`w₂`, …, `w_N`, where N has the value `sizeof...(bound_args)`.
+*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$))
 ```
+for the first overload, and
+``` cpp
+INVOKE<R>(static_cast<$V_fd$>($v_fd$),
+          static_cast<$V_1$>($v_1$), static_cast<$V_2$>($v_2$), …, static_cast<$V_N$>($v_N$))
+```
+for the second overload, where the values and types of the target
+argument `v`_`fd` and of the bound arguments `v₁`, `v₂`, …, `v_N` are
+determined as specified below.
+*Throws:* Any exception thrown by the initialization of the state
+entities of `g`.
+[*Note 1*: If all of `FD` and `TDᵢ` meet the requirements of
+*Cpp17CopyConstructible*, then the return type meets the requirements of
+*Cpp17CopyConstructible*. — *end note*]
 The values of the *bound arguments* `v₁`, `v₂`, …, `v_N` and their
 corresponding types `V₁`, `V₂`, …, `V_N` depend on the types `TDᵢ`
 derived from the call to `bind` and the cv-qualifiers cv of the call
 wrapper `g` as follows:
 - if `TDᵢ` is `reference_wrapper<T>`, the argument is `tdᵢ.get()` and
   its type `Vᵢ` is `T&`;
 - if the value of `is_bind_expression_v<TDᵢ>` is `true`, the argument is
+  ``` cpp
+ static_cast<cv `TD`_i&>(td_i)(std::forward<U_j>(u_j)...)
+  ```
+  and its type `Vᵢ` is `invoke_result_t<cv TDᵢ&, Uⱼ...>&&`;
 - if the value `j` of `is_placeholder_v<TDᵢ>` is not zero, the argument
   is `std::forward<Uⱼ>(uⱼ)` and its type `Vᵢ` is `Uⱼ&&`;
+- otherwise, the value is `tdᵢ` and its type `Vᵢ` is `cv TDᵢ&`.
+The value of the target argument `v`_`fd` is `fd` and its corresponding
+type `V`_`fd` is `cv FD&`.
 #### Placeholders <a id="func.bind.place">[[func.bind.place]]</a>
 ``` cpp
 namespace std::placeholders {
               .
   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
+assignment operators are constexpr functions that do not throw
+exceptions.
 Placeholders should be defined as:
 ``` cpp
 inline constexpr unspecified _1{};
 ```
+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
+object has no target.
 ``` cpp
 namespace std {
   class bad_function_call : public exception {
   public:
+    // see [exception] for the specification of the special member functions
+ const char* what() const noexcept override;
   };
 }
 ```
 ``` cpp
+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 {
     // [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 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;
 ```
+*Ensures:* `!*this`.
 ``` cpp
 function(nullptr_t) noexcept;
 ```
+*Ensures:* `!*this`.
 ``` 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*:
 ``` cpp
 void f() {
 function& operator=(nullptr_t) noexcept;
 ```
 *Effects:* If `*this != nullptr`, destroys the target of `this`.
+*Ensures:* `!(*this)`.
 *Returns:* `*this`.
 ``` cpp
 template<class F> function& operator=(F&& f);
 ```
+*Constraints:* `decay_t<F>` is Lvalue-Callable [[func.wrap.func]] for
+argument types `ArgTypes...` and return type `R`.
 *Effects:* As if by: `function(std::forward<F>(f)).swap(*this);`
 *Returns:* `*this`.
 ``` cpp
 template<class F> function& operator=(reference_wrapper<F> f) noexcept;
 ```
 *Effects:* As if by: `function(f).swap(*this);`
 ~function();
 ```
 *Effects:* If `*this != nullptr`, destroys the target of `this`.
+##### Modifiers <a id="func.wrap.func.mod">[[func.wrap.func.mod]]</a>
 ``` 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;
 ```
 *Returns:* `true` if `*this` has a target, otherwise `false`.
+##### Invocation <a id="func.wrap.func.inv">[[func.wrap.func.inv]]</a>
 ``` cpp
 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;
 ```
 ```
 *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;
 ```
 *Returns:* `!f`.
+##### Specialized algorithms <a id="func.wrap.func.alg">[[func.wrap.func.alg]]</a>
 ``` cpp
 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`,
 - `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
 search algorithm. In general, the Boyer-Moore searcher will use more
 memory and give better runtime performance than Boyer-Moore-Horspool.
 ``` cpp
 template<class ForwardIterator1, class BinaryPredicate = equal_to<>>
   class default_searcher {
   public:
+ constexpr default_searcher(ForwardIterator1 pat_first, ForwardIterator1 pat_last,
                                BinaryPredicate pred = BinaryPredicate());
     template<class ForwardIterator2>
+ constexpr pair<ForwardIterator2, ForwardIterator2>
         operator()(ForwardIterator2 first, ForwardIterator2 last) const;
   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
 *Throws:* Any exception thrown by the copy constructor of
 `BinaryPredicate` or `ForwardIterator1`.
 ``` cpp
 template<class ForwardIterator2>
+ constexpr pair<ForwardIterator2, ForwardIterator2>
     operator()(ForwardIterator2 first, ForwardIterator2 last) const;
 ```
 *Effects:* Returns a pair of iterators `i` and `j` such that
                      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
 template<class RandomAccessIterator2>
   pair<RandomAccessIterator2, RandomAccessIterator2>
     operator()(RandomAccessIterator2 first, RandomAccessIterator2 last) const;
 ```
+*Mandates:* `RandomAccessIterator1` and `RandomAccessIterator2` have the
+same value type.
 *Effects:* Finds a subsequence of equal values in a sequence.
 *Returns:* A pair of iterators `i` and `j` such that
                               RandomAccessIterator1 pat_last,
                               Hash hf = Hash(),
                               BinaryPredicate pred = BinaryPredicate());
 ```
+*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
 template<class RandomAccessIterator2>
   pair<RandomAccessIterator2, RandomAccessIterator2>
     operator()(RandomAccessIterator2 first, RandomAccessIterator2 last) const;
 ```
+*Mandates:* `RandomAccessIterator1` and `RandomAccessIterator2` have the
+same value type.
 *Effects:* Finds a subsequence of equal values in a sequence.
 *Returns:* A pair of iterators `i` and `j` such that
 applications of the predicate.
 ### Class template `hash` <a id="unord.hash">[[unord.hash]]</a>
 The unordered associative containers defined in [[unord]] use
+specializations of the class template `hash` [[functional.syn]] as the
+default hash function.
 Each specialization of `hash` is either enabled or disabled, as
 described below.
+[*Note 1*: Enabled specializations meet the *Cpp17Hash* requirements,
+and disabled specializations do not. — *end note*]
 Each header that declares the template `hash` provides enabled
 specializations of `hash` for `nullptr_t` and all cv-unqualified
 arithmetic, enumeration, and pointer types. For any type `Key` for which
 neither the library nor the user provides an explicit or partial
 If `H` is a disabled specialization of `hash`, these values are `false`:
 `is_default_constructible_v<H>`, `is_copy_constructible_v<H>`,
 `is_move_constructible_v<H>`, `is_copy_assignable_v<H>`, and
 `is_move_assignable_v<H>`. Disabled specializations of `hash` are not
+function object types [[function.objects]].
 [*Note 2*: This means that the specialization of `hash` exists, but any
+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.

Diff to HTML by rtfpessoa