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

Files changed (1) hide show

tmp/tmp0oxzndr8/{from.md → to.md} +1014 -648

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

@@ -8,28 +8,31 @@ 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.
 ``` cpp
 namespace std {
-  // [depr.base], base (deprecated):
-  template <class Arg, class Result> struct unary_function;
-  template <class Arg1, class Arg2, class Result> struct binary_function;
-  // [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;
   template <class T = void> struct divides;
   template <class T = void> struct modulus;
@@ -39,11 +42,11 @@ namespace std {
   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;
@@ -53,168 +56,119 @@ 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>;
   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>;
-  // [negators], negators:
-  template <class Predicate> class unary_negate;
-  template <class Predicate>
-    constexpr unary_negate<Predicate> not1(const Predicate&);
-  template <class Predicate> class binary_negate;
-  template <class Predicate>
-    constexpr binary_negate<Predicate> not2(const Predicate&);
-  // [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
- extern unspecified _1;
- extern unspecified _2;
                .
                .
                .
- extern unspecified _M;
   }
-  // [depr.lib.binders], binders (deprecated):
-  template <class Fn> class binder1st;
-  template <class Fn, class T>
-    binder1st<Fn> bind1st(const Fn&, const T&);
-  template <class Fn> class binder2nd;
-  template <class Fn, class T>
-    binder2nd<Fn> bind2nd(const Fn&, const T&);
-  // [depr.function.pointer.adaptors], adaptors (deprecated):
-  template <class Arg, class Result> class pointer_to_unary_function;
-  template <class Arg, class Result>
-    pointer_to_unary_function<Arg,Result> ptr_fun(Result (*)(Arg));
-  template <class Arg1, class Arg2, class Result>
-    class pointer_to_binary_function;
-  template <class Arg1, class Arg2, class Result>
-    pointer_to_binary_function<Arg1,Arg2,Result>
-      ptr_fun(Result (*)(Arg1,Arg2));
-  // [depr.member.pointer.adaptors], adaptors (deprecated):
-  template<class S, class T> class mem_fun_t;
-  template<class S, class T, class A> class mem_fun1_t;
-  template<class S, class T>
-      mem_fun_t<S,T> mem_fun(S (T::*f)());
-  template<class S, class T, class A>
-      mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A));
-  template<class S, class T> class mem_fun_ref_t;
-  template<class S, class T, class A> class mem_fun1_ref_t;
-  template<class S, class T>
-      mem_fun_ref_t<S,T> mem_fun_ref(S (T::*f)());
-  template<class S, class T, class A>
-      mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A));
-  template <class S, class T> class const_mem_fun_t;
-  template <class S, class T, class A> class const_mem_fun1_t;
-  template <class S, class T>
-    const_mem_fun_t<S,T> mem_fun(S (T::*f)() const);
-  template <class S, class T, class A>
-    const_mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A) const);
-  template <class S, class T> class const_mem_fun_ref_t;
-  template <class S, class T, class A> class const_mem_fun1_ref_t;
-  template <class S, class T>
-    const_mem_fun_ref_t<S,T> mem_fun_ref(S (T::*f)() const);
-  template <class S, class T, class A>
-    const_mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A) const);
-  // [func.memfn], member function adaptors:
-  template<class R, class T> unspecified mem_fn(R T::*);
-  // [func.wrap] polymorphic function wrappers:
   class bad_function_call;
-  template<class> class function; // undefined
   template<class R, class... ArgTypes> class function<R(ArgTypes...)>;
   template<class R, class... ArgTypes>
-    void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)>&);
   template<class R, class... ArgTypes>
-    bool operator==(const function<R(ArgTypes...)>&, nullptr_t);
   template<class R, class... ArgTypes>
-    bool operator==(nullptr_t, const function<R(ArgTypes...)>&);
   template<class R, class... ArgTypes>
-    bool operator!=(const function<R(ArgTypes...)>&, nullptr_t);
   template<class R, class... ArgTypes>
-    bool operator!=(nullptr_t, const function<R(ArgTypes...)>&);
-  // [unord.hash], hash function primary template:
-  template <class T> struct hash;
- // Hash function specializations
-  template <> struct hash<bool>;
-  template <> struct hash<char>;
-  template <> struct hash<signed char>;
-  template <> struct hash<unsigned char>;
-  template <> struct hash<char16_t>;
-  template <> struct hash<char32_t>;
-  template <> struct hash<wchar_t>;
-  template <> struct hash<short>;
-  template <> struct hash<unsigned short>;
-  template <> struct hash<int>;
-  template <> struct hash<unsigned int>;
-  template <> struct hash<long>;
-  template <> struct hash<long long>;
-  template <> struct hash<unsigned long>;
-  template <> struct hash<unsigned long long>;
-  template <> struct hash<float>;
-  template <> struct hash<double>;
-  template <> struct hash<long double>;
- template<class T> struct hash<T*>;
 }
 ```
 If a C++program wants to have a by-element addition of two vectors `a`
 and `b` containing `double` and put the result into `a`, it can do:
 ``` cpp
 transform(a.begin(), a.end(), b.begin(), a.begin(), plus<double>());
 ```
 To negate every element of `a`:
 ``` cpp
 transform(a.begin(), a.end(), a.begin(), negate<double>());
 ```
-To enable adaptors and other components to manipulate function objects
-that take one or two arguments many of the function objects in this
-clause correspondingly provide typedefs `argument_type` and
-`result_type` for function objects that take one argument and
-`first_argument_type`, `second_argument_type`, and `result_type` for
-function objects that take two arguments.
 ### Definitions <a id="func.def">[[func.def]]</a>
 The following definitions apply to this Clause:
@@ -236,67 +190,70 @@ 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 `t1` is an object of type `T` or a reference to an
-  object of type `T` or a reference to an object of a type derived from
-  `T`;
 - `((*t1).*f)(t2, ..., tN)` when `f` is a pointer to a member function
-  of a class `T` and `t1` is not one of the types described in the
-  previous item;
-- `t1.*f` when `N == 1` and `f` is a pointer to member data of a class
-  `T` and `t1` is an object of type `T` or a reference to an object of
- type `T` or a reference to an object of a type derived from `T`;
-- `(*t1).*f` when `N == 1` and `f` is a pointer to member data of a
-  class `T` and `t1` is not one of the types described in the previous
- item;
 - `f(t1, t2, ..., tN)` in all other cases.
-Define `INVOKE(f, t1, t2, ..., tN, R)` as `INVOKE(f, t1, t2, ..., tN)`
-implicitly converted to `R`.
-If a call wrapper ([[func.def]]) has a *weak result type* the type of
-its member type `result_type` is based on the type `T` of the wrapper’s
-target object ([[func.def]]):
-- if `T` is a pointer to function type, `result_type` shall be a synonym
-  for the return type of `T`;
-- if `T` is a pointer to member function, `result_type` shall be a
-  synonym for the return type of `T`;
-- if `T` is a class type with a member type `result_type`, then
-  `result_type` shall be a synonym for `T::result_type`;
-- otherwise `result_type` shall not be defined.
 Every call wrapper ([[func.def]]) shall be `MoveConstructible`. A
-*simple call wrapper* is a call wrapper that is `CopyConstructible` and
-`CopyAssignable` and whose copy constructor, move constructor, and
-assignment operator do not throw exceptions. 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. 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;
 ```
 ### Class template `reference_wrapper` <a id="refwrap">[[refwrap]]</a>
 ``` cpp
 namespace std {
   template <class T> class reference_wrapper {
   public :
     // types
- typedef T type;
-    typedef see below result_type;               // not always defined
-    typedef see below argument_type;             // not always defined
-    typedef see below first_argument_type;       // not always defined
-    typedef see below second_argument_type;      // not always defined
     // construct/copy/destroy
     reference_wrapper(T&) noexcept;
     reference_wrapper(T&&) = delete;     // do not bind to temporary objects
     reference_wrapper(const reference_wrapper& x) noexcept;
@@ -308,46 +265,24 @@ namespace std {
     operator T& () const noexcept;
     T& get() const noexcept;
     // invocation
     template <class... ArgTypes>
-    result_of_t<T&(ArgTypes&&...)>
       operator() (ArgTypes&&...) const;
   };
 }
 ```
 `reference_wrapper<T>` is a `CopyConstructible` and `CopyAssignable`
 wrapper around a reference to an object or function of type `T`.
-`reference_wrapper<T>` has a weak result type ([[func.require]]). If
-`T` is a function type, `result_type` shall be a synonym for the return
-type of `T`.
-The template specialization `reference_wrapper<T>` shall define a nested
-type named `argument_type` as a synonym for `T1` only if the type `T` is
-any of the following:
-- a function type or a pointer to function type taking one argument of
-  type `T1`
-- a pointer to member function `R T0::f` *cv* (where *cv* represents the
-  member function’s cv-qualifiers); the type `T1` is *cv* `T0*`
-- a class type with a member type `argument_type`; the type `T1` is
-  `T::argument_type`.
-The template instantiation `reference_wrapper<T>` shall define two
-nested types named `first_argument_type` and `second_argument_type` as
-synonyms for `T1` and `T2`, respectively, only if the type `T` is any of
-the following:
-- a function type or a pointer to function type taking two arguments of
-  types `T1` and `T2`
-- a pointer to member function `R T0::f(T2)` *cv* (where *cv* represents
-  the member function’s cv-qualifiers); the type `T1` is *cv* `T0*`
-- a class type with member types `first_argument_type` and
-  `second_argument_type`; the type `T1` is `T::first_argument_type` and
-  the type `T2` is `T::second_argument_type`.
 #### `reference_wrapper` construct/copy/destroy <a id="refwrap.const">[[refwrap.const]]</a>
 ``` cpp
 reference_wrapper(T& t) noexcept;
@@ -383,539 +318,735 @@ operator T& () const noexcept;
 T& get() const noexcept;
 ```
 *Returns:* The stored reference.
-#### reference_wrapper invocation <a id="refwrap.invoke">[[refwrap.invoke]]</a>
 ``` cpp
 template <class... ArgTypes>
- result_of_t<T&(ArgTypes&&... )>
     operator()(ArgTypes&&... args) const;
 ```
-*Returns:*
-*`INVOKE`*`(get(), std::forward<ArgTypes>(args)...)`. ([[func.require]])
-`operator()` is described for exposition only. Implementations are not
-required to provide an actual `reference_wrapper::operator()`.
-Implementations are permitted to support `reference_wrapper` function
-invocation through multiple overloaded operators or through other means.
-#### 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>
 The library provides basic function object classes for all of the
 arithmetic operators in the language ([[expr.mul]], [[expr.add]]).
 ``` cpp
 template <class T = void> struct plus {
   constexpr T operator()(const T& x, const T& y) const;
-  typedef T first_argument_type;
-  typedef T second_argument_type;
-  typedef T result_type;
 };
 ```
-`operator()` returns `x + y`.
-``` cpp
-template <class T = void> struct minus {
-  constexpr T operator()(const T& x, const T& y) const;
-  typedef T first_argument_type;
-  typedef T second_argument_type;
-  typedef T result_type;
-};
-```
-`operator()` returns `x - y`.
-``` cpp
-template <class T = void> struct multiplies {
-  constexpr T operator()(const T& x, const T& y) const;
-  typedef T first_argument_type;
-  typedef T second_argument_type;
-  typedef T result_type;
-};
-```
-`operator()` returns `x * y`.
 ``` cpp
-template <class T = void> struct divides {
 constexpr T operator()(const T& x, const T& y) const;
-  typedef T first_argument_type;
-  typedef T second_argument_type;
-  typedef T result_type;
-};
-```
-`operator()` returns `x / y`.
-``` cpp
-template <class T = void> struct modulus {
-  constexpr T operator()(const T& x, const T& y) const;
-  typedef T first_argument_type;
-  typedef T second_argument_type;
-  typedef T result_type;
-};
-```
-`operator()` returns `x % y`.
-``` cpp
-template <class T = void> struct negate {
-  constexpr T operator()(const T& x) const;
-  typedef T argument_type;
-  typedef T result_type;
-};
 ```
-`operator()` returns `-x`.
 ``` cpp
 template <> struct plus<void> {
   template <class T, class U> constexpr auto operator()(T&& t, U&& u) const
     -> decltype(std::forward<T>(t) + std::forward<U>(u));
- typedef unspecified is_transparent;
 };
 ```
-`operator()` returns `std::forward<T>(t) + std::forward<U>(u)`.
 ``` cpp
 template <> struct minus<void> {
   template <class T, class U> constexpr auto operator()(T&& t, U&& u) const
     -> decltype(std::forward<T>(t) - std::forward<U>(u));
- typedef unspecified is_transparent;
 };
 ```
-`operator()` returns `std::forward<T>(t) - std::forward<U>(u)`.
 ``` cpp
 template <> struct multiplies<void> {
   template <class T, class U> constexpr auto operator()(T&& t, U&& u) const
     -> decltype(std::forward<T>(t) * std::forward<U>(u));
- typedef unspecified is_transparent;
 };
 ```
-`operator()` returns `std::forward<T>(t) * std::forward<U>(u)`.
 ``` cpp
 template <> struct divides<void> {
   template <class T, class U> constexpr auto operator()(T&& t, U&& u) const
     -> decltype(std::forward<T>(t) / std::forward<U>(u));
- typedef unspecified is_transparent;
 };
 ```
-`operator()` returns `std::forward<T>(t) / std::forward<U>(u)`.
 ``` cpp
 template <> struct modulus<void> {
   template <class T, class U> constexpr auto operator()(T&& t, U&& u) const
     -> decltype(std::forward<T>(t) % std::forward<U>(u));
- typedef unspecified is_transparent;
 };
 ```
-`operator()` returns `std::forward<T>(t) % std::forward<U>(u)`.
 ``` cpp
 template <> struct negate<void> {
   template <class T> constexpr auto operator()(T&& t) const
     -> decltype(-std::forward<T>(t));
- typedef unspecified is_transparent;
 };
 ```
-`operator()` 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]]).
 ``` cpp
 template <class T = void> struct equal_to {
   constexpr bool operator()(const T& x, const T& y) const;
-  typedef T first_argument_type;
-  typedef T second_argument_type;
-  typedef bool result_type;
 };
 ```
-`operator()` returns `x == y`.
-``` cpp
-template <class T = void> struct not_equal_to {
-  constexpr bool operator()(const T& x, const T& y) const;
-  typedef T first_argument_type;
-  typedef T second_argument_type;
-  typedef bool result_type;
-};
-```
-`operator()` returns `x != y`.
-``` cpp
-template <class T = void> struct greater {
-  constexpr bool operator()(const T& x, const T& y) const;
-  typedef T first_argument_type;
-  typedef T second_argument_type;
-  typedef bool result_type;
-};
-```
-`operator()` returns `x > y`.
 ``` cpp
-template <class T = void> struct less {
 constexpr bool operator()(const T& x, const T& y) const;
-  typedef T first_argument_type;
-  typedef T second_argument_type;
-  typedef bool result_type;
-};
-```
-`operator()` returns `x < y`.
-``` cpp
-template <class T = void> struct greater_equal {
-  constexpr bool operator()(const T& x, const T& y) const;
-  typedef T first_argument_type;
-  typedef T second_argument_type;
-  typedef bool result_type;
-};
-```
-`operator()` returns `x >= y`.
-``` cpp
-template <class T = void> struct less_equal {
-  constexpr bool operator()(const T& x, const T& y) const;
-  typedef T first_argument_type;
-  typedef T second_argument_type;
-  typedef bool result_type;
-};
 ```
-`operator()` returns `x <= y`.
 ``` cpp
 template <> struct equal_to<void> {
   template <class T, class U> constexpr auto operator()(T&& t, U&& u) const
     -> decltype(std::forward<T>(t) == std::forward<U>(u));
- typedef unspecified is_transparent;
 };
 ```
-`operator()` returns `std::forward<T>(t) == std::forward<U>(u)`.
 ``` cpp
 template <> struct not_equal_to<void> {
   template <class T, class U> constexpr auto operator()(T&& t, U&& u) const
     -> decltype(std::forward<T>(t) != std::forward<U>(u));
- typedef unspecified is_transparent;
 };
 ```
-`operator()` returns `std::forward<T>(t) != std::forward<U>(u)`.
 ``` cpp
 template <> struct greater<void> {
   template <class T, class U> constexpr auto operator()(T&& t, U&& u) const
     -> decltype(std::forward<T>(t) > std::forward<U>(u));
- typedef unspecified is_transparent;
 };
 ```
-`operator()` returns `std::forward<T>(t) > std::forward<U>(u)`.
 ``` cpp
 template <> struct less<void> {
   template <class T, class U> constexpr auto operator()(T&& t, U&& u) const
     -> decltype(std::forward<T>(t) < std::forward<U>(u));
- typedef unspecified is_transparent;
 };
 ```
-`operator()` returns `std::forward<T>(t) < std::forward<U>(u)`.
 ``` cpp
 template <> struct greater_equal<void> {
   template <class T, class U> constexpr auto operator()(T&& t, U&& u) const
     -> decltype(std::forward<T>(t) >= std::forward<U>(u));
- typedef unspecified is_transparent;
 };
 ```
-`operator()` returns `std::forward<T>(t) >= std::forward<U>(u)`.
 ``` cpp
 template <> struct less_equal<void> {
   template <class T, class U> constexpr auto operator()(T&& t, U&& u) const
     -> decltype(std::forward<T>(t) <= std::forward<U>(u));
- typedef unspecified is_transparent;
 };
 ```
-`operator()` returns `std::forward<T>(t) <= std::forward<U>(u)`.
-For templates `greater`, `less`, `greater_equal`, and `less_equal`, the
-specializations for any pointer type yield a total order, even if the
-built-in operators `<`, `>`, `<=`, `>=` do not.
 ### 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]]).
 ``` cpp
 template <class T = void> struct logical_and {
   constexpr bool operator()(const T& x, const T& y) const;
-  typedef T first_argument_type;
-  typedef T second_argument_type;
-  typedef bool result_type;
 };
 ```
-`operator()` returns `x && y`.
 ``` cpp
-template <class T = void> struct logical_or {
 constexpr bool operator()(const T& x, const T& y) const;
-  typedef T first_argument_type;
-  typedef T second_argument_type;
-  typedef bool result_type;
-};
 ```
-`operator()` returns `x || y`.
-``` cpp
-template <class T = void> struct logical_not {
-  constexpr bool operator()(const T& x) const;
-  typedef T argument_type;
-  typedef bool result_type;
-};
-```
-`operator()` returns `!x`.
 ``` cpp
 template <> struct logical_and<void> {
   template <class T, class U> constexpr auto operator()(T&& t, U&& u) const
     -> decltype(std::forward<T>(t) && std::forward<U>(u));
- typedef unspecified is_transparent;
 };
 ```
-`operator()` returns `std::forward<T>(t) && std::forward<U>(u)`.
 ``` cpp
 template <> struct logical_or<void> {
   template <class T, class U> constexpr auto operator()(T&& t, U&& u) const
     -> decltype(std::forward<T>(t) || std::forward<U>(u));
- typedef unspecified is_transparent;
 };
 ```
-`operator()` returns `std::forward<T>(t) || std::forward<U>(u)`.
 ``` cpp
 template <> struct logical_not<void> {
   template <class T> constexpr auto operator()(T&& t) const
     -> decltype(!std::forward<T>(t));
- typedef unspecified is_transparent;
 };
 ```
-`operator()` 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]]).
 ``` cpp
 template <class T = void> struct bit_and {
   constexpr T operator()(const T& x, const T& y) const;
-  typedef T first_argument_type;
-  typedef T second_argument_type;
-  typedef T result_type;
 };
 ```
-`operator()` returns `x & y`.
-``` cpp
-template <class T = void> struct bit_or {
-  constexpr T operator()(const T& x, const T& y) const;
-  typedef T first_argument_type;
-  typedef T second_argument_type;
-  typedef T result_type;
-};
-```
-`operator()` returns `x | y`.
 ``` cpp
-template <class T = void> struct bit_xor {
 constexpr T operator()(const T& x, const T& y) const;
-  typedef T first_argument_type;
-  typedef T second_argument_type;
-  typedef T result_type;
-};
-```
-`operator()` returns `x ^ y`.
-``` cpp
-template <class T = void> struct bit_not {
-  constexpr T operator()(const T& x) const;
-  typedef T argument_type;
-  typedef T result_type;
-};
 ```
-`operator()` returns `~x`.
 ``` cpp
 template <> struct bit_and<void> {
   template <class T, class U> constexpr auto operator()(T&& t, U&& u) const
     -> decltype(std::forward<T>(t) & std::forward<U>(u));
- typedef unspecified is_transparent;
 };
 ```
-`operator()` returns `std::forward<T>(t) & std::forward<U>(u)`.
 ``` cpp
 template <> struct bit_or<void> {
   template <class T, class U> constexpr auto operator()(T&& t, U&& u) const
     -> decltype(std::forward<T>(t) | std::forward<U>(u));
- typedef unspecified is_transparent;
 };
 ```
-`operator()` returns `std::forward<T>(t) | std::forward<U>(u)`.
 ``` cpp
 template <> struct bit_xor<void> {
   template <class T, class U> constexpr auto operator()(T&& t, U&& u) const
     -> decltype(std::forward<T>(t) ^ std::forward<U>(u));
- typedef unspecified is_transparent;
 };
 ```
-`operator()` returns `std::forward<T>(t) ^ std::forward<U>(u)`.
 ``` cpp
 template <> struct bit_not<void> {
   template <class T> constexpr auto operator()(T&& t) const
     -> decltype(~std::forward<T>(t));
- typedef unspecified is_transparent;
 };
 ```
-`operator()` returns `~std::forward<T>(t)`.
-### Negators <a id="negators">[[negators]]</a>
-Negators `not1` and `not2` take a unary and a binary predicate,
-respectively, and return their complements ([[expr.unary.op]]).
 ``` cpp
-template <class Predicate>
- class unary_negate {
 public:
- constexpr explicit unary_negate(const Predicate& pred);
- constexpr bool operator()(const typename Predicate::argument_type& x) const;
-  typedef typename Predicate::argument_type argument_type;
- typedef bool result_type;
 };
 ```
-`operator()` returns `!pred(x)`.
 ``` cpp
-template <class Predicate>
-  constexpr unary_negate<Predicate> not1(const Predicate& pred);
 ```
-*Returns:* `unary_negate<Predicate>(pred)`.
 ``` cpp
-template <class Predicate>
- class binary_negate {
-  public:
-    constexpr explicit binary_negate(const Predicate& pred);
-    constexpr bool operator()(const typename Predicate::first_argument_type& x,
- const typename Predicate::second_argument_type& y) const;
-  typedef typename Predicate::first_argument_type first_argument_type;
-  typedef typename Predicate::second_argument_type second_argument_type;
-  typedef bool result_type;
-  };
 ```
-`operator()` returns `!pred(x,y)`.
 ``` cpp
-template <class Predicate>
-  constexpr binary_negate<Predicate> not2(const Predicate& pred);
 ```
-*Returns:* `binary_negate<Predicate>(pred)`.
 ### Function object binders <a id="func.bind">[[func.bind]]</a>
 This subclause describes a uniform mechanism for binding arguments of
 callable objects.
@@ -926,179 +1057,187 @@ callable objects.
 namespace std {
   template<class T> struct is_bind_expression;  // see below
 }
 ```
-`is_bind_expression` can be used to detect function objects generated by
-`bind`. `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 BaseCharacteristic of `true_type` if `T`
-is a type returned from `bind`, otherwise it shall have a
-BaseCharacteristic of `false_type`. A program may specialize this
-template for a user-defined type `T` to have a BaseCharacteristic 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 {
   template<class T> struct is_placeholder;      // see below
 }
 ```
-`is_placeholder` can be used to detect the standard placeholders `_1`,
-`_2`, and so on. `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 BaseCharacteristic of
 `integral_constant<int, J>` if `T` is the type of
-`std::placeholders::_J`, otherwise it shall have a BaseCharacteristic of
-`integral_constant<int, 0>`. A program may specialize this template for
-a user-defined type `T` to have a BaseCharacteristic 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, the following names have the following
-meanings:
 - `FD` is the type `decay_t<F>`,
 - `fd` is an lvalue of type `FD` constructed from `std::forward<F>(f)`,
-- `Ti` is the iᵗʰ type in the template parameter pack `BoundArgs`,
-- `TiD` is the type `decay_t<Ti>`,
-- `ti` is the iᵗʰ argument in the function parameter pack `bound_args`,
-- `tid` is an lvalue of type `TiD` constructed from
-  `std::forward<Ti>(ti)`,
-- `Uj` is the jᵗʰ deduced type of the `UnBoundArgs&&...` parameter of
   the forwarding call wrapper, and
-- `uj` is the jᵗʰ argument associated with `Uj`.
 ``` cpp
 template<class F, class... BoundArgs>
   unspecified bind(F&& f, BoundArgs&&... bound_args);
 ```
-*Requires:* `is_constructible<FD, F>::value` shall be `true`. For each
-`Ti` in `BoundArgs`, `is_constructible<TiD, Ti>::value` shall be `true`.
-*`INVOKE`*` (fd, w1, w2, ..., wN)` ([[func.require]]) shall be a valid
-expression for some values *w1, w2, ..., wN*, where
-`N == sizeof...(bound_args)`.
-*Returns:* A forwarding call wrapper `g` with a weak result
-type ([[func.require]]). The effect of `g(u1, u2, ..., uM)` shall be
-*`INVOKE`*`(fd, std::forward<V1>(v1), std::forward<V2>(v2), ..., std::forward<VN>(vN), result_of_t<FD `*`cv`*` & (V1, V2, ..., VN)>)`,
-where *`cv`* represents the *cv*-qualifiers of `g` and the values and
-types of the bound arguments `v1, v2, ..., vN` 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 `TiD` throws an
-exception.
 *Throws:* Nothing unless the construction of `fd` or of one of the
-values `tid` throws an exception.
 *Remarks:* The return type shall satisfy the requirements of
-`MoveConstructible`. If all of `FD` and `TiD` satisfy the requirements
 of `CopyConstructible`, then the return type shall satisfy the
-requirements of `CopyConstructible`. This implies that all of `FD` and
-`TiD` are `MoveConstructible`.
 ``` cpp
 template<class R, class F, class... BoundArgs>
   unspecified bind(F&& f, BoundArgs&&... bound_args);
 ```
-*Requires:* `is_constructible<FD, F>::value` shall be `true`. For each
-`Ti` in `BoundArgs`, `is_constructible<TiD, Ti>::value` shall be `true`.
-*`INVOKE`*`(fd, w1, w2, ..., wN)` shall be a valid expression for some
-values *w1, w2, ..., wN*, where `N == sizeof...(bound_args)`.
-*Returns:* A forwarding call wrapper `g` with a nested type
-`result_type` defined as a synonym for `R`. The effect of
-`g(u1, u2, ..., uM)` shall be
-*`INVOKE`*`(fd, std::forward<V1>(v1), std::forward<V2>(v2), ..., std::forward<VN>(vN), R)`,
-where the values and types of the bound arguments `v1, v2, ..., vN` 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 `TiD`
-throws an exception.
 *Throws:* Nothing unless the construction of `fd` or of one of the
-values `tid` throws an exception.
 *Remarks:* The return type shall satisfy the requirements of
-`MoveConstructible`. If all of `FD` and `TiD` satisfy the requirements
 of `CopyConstructible`, then the return type shall satisfy the
-requirements of `CopyConstructible`. This implies that all of `FD` and
-`TiD` are `MoveConstructible`.
-The values of the *bound arguments* `v1, v2, ..., vN` and their
-corresponding types `V1, V2, ..., VN` depend on the types `TiD` derived
-from the call to `bind` and the *cv*-qualifiers *cv* of the call wrapper
-`g` as follows:
-- if `TiD` is `reference_wrapper<T>`, the argument is `tid.get()` and
-  its type `Vi` is `T&`;
-- if the value of `is_bind_expression<TiD>::value` is `true`, the
-  argument is `tid(std::forward<Uj>({}uj)...)` and its type `Vi` is
-  `result_of_t<TiD cv & (Uj&&...)>&&`;
-- if the value `j` of `is_placeholder<TiD>::value` is not zero, the
- argument is `std::forward<Uj>(uj)` and its type `Vi` is `Uj&&`;
-- otherwise, the value is `tid` and its type `Vi` is `TiD cv &`.
 #### Placeholders <a id="func.bind.place">[[func.bind.place]]</a>
 ``` cpp
-namespace std {
-  namespace placeholders {
   // M is the implementation-defined number of placeholders
-    extern unspecified _1;
-    extern unspecified _2;
               .
               .
               .
-    extern unspecified _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.
 ### Function template `mem_fn` <a id="func.memfn">[[func.memfn]]</a>
 ``` cpp
-template<class R, class T> unspecified mem_fn(R T::* pm);
 ```
 *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]]). `fn` shall have a
-nested type `result_type` that is a synonym for the return type of `pm`
-when `pm` is a pointer to member function.
-The simple call wrapper shall define two nested types named
-`argument_type` and `result_type` as synonyms for `cv T*` and `Ret`,
-respectively, when `pm` is a pointer to member function with
-cv-qualifier *cv* and taking no arguments, where *Ret* is `pm`’s return
-type.
-The simple call wrapper shall define three nested types named
-`first_argument_type`, `second_argument_type`, and `result_type` as
-synonyms for `cv T*`, `T1`, and `Ret`, respectively, when `pm` is a
-pointer to member function with cv-qualifier *cv* and taking one
-argument of type `T1`, where *Ret* is `pm`’s return type.
-*Throws:* Nothing.
 ### Polymorphic function wrappers <a id="func.wrap">[[func.wrap]]</a>
 This subclause describes a polymorphic wrapper class that encapsulates
 arbitrary callable objects.
@@ -1109,84 +1248,75 @@ 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 std::exception {
   public:
-    // [func.wrap.badcall.const], constructor:
     bad_function_call() noexcept;
   };
-} // namespace std
 ```
 ##### `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.
 #### Class template `function` <a id="func.wrap.func">[[func.wrap.func]]</a>
 ``` cpp
 namespace std {
-  template<class> class function; // undefined
   template<class R, class... ArgTypes>
   class function<R(ArgTypes...)> {
   public:
- typedef R result_type;
-    typedef T1 argument_type;           // only if sizeof...(ArgTypes) == 1 and
-                                        // the type in ArgTypes is T1
-    typedef T1 first_argument_type;     // only if sizeof...(ArgTypes) == 2 and
-                                        // ArgTypes contains T1 and T2
-    typedef T2 second_argument_type;    // only if sizeof...(ArgTypes) == 2 and
-                                        // ArgTypes contains T1 and T2
-    // [func.wrap.func.con], construct/copy/destroy:
     function() noexcept;
     function(nullptr_t) noexcept;
     function(const function&);
     function(function&&);
     template<class F> function(F);
-    template<class A> function(allocator_arg_t, const A&) noexcept;
-    template<class A> function(allocator_arg_t, const A&,
-      nullptr_t) noexcept;
-    template<class A> function(allocator_arg_t, const A&,
-      const function&);
-    template<class A> function(allocator_arg_t, const A&,
-      function&&);
-    template<class F, class A> function(allocator_arg_t, const A&, F);
     function& operator=(const function&);
     function& operator=(function&&);
-    function& operator=(nullptr_t);
     template<class F> function& operator=(F&&);
     template<class F> function& operator=(reference_wrapper<F>) noexcept;
     ~function();
-    // [func.wrap.func.mod], function modifiers:
     void swap(function&) noexcept;
-    template<class F, class A> void assign(F&&, const A&);
-    // [func.wrap.func.cap], function capacity:
     explicit operator bool() const noexcept;
-    // [func.wrap.func.inv], function invocation:
     R operator()(ArgTypes...) const;
-    // [func.wrap.func.targ], function target access:
-    const std::type_info& target_type() const noexcept;
     template<class T>       T* target() noexcept;
     template<class T> const T* target() const noexcept;
   };
- // [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;
@@ -1195,154 +1325,176 @@ namespace std {
     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...)>&);
-  template<class R, class... ArgTypes, class Alloc>
-    struct uses_allocator<function<R(ArgTypes...)>, Alloc>
-      : true_type { };
 }
 ```
 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 object `f` of type `F` is *Callable* for argument types
-`ArgTypes` and return type `R` if the expression
-`INVOKE(f, declval<ArgTypes>()..., R)`, 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...)`.
 ##### `function` construct/copy/destroy <a id="func.wrap.func.con">[[func.wrap.func.con]]</a>
-When any `function` constructor that takes a first argument of type
-`allocator_arg_t` is invoked, the second argument shall have a type that
-conforms to the requirements for Allocator (Table
-[[allocator.requirements]]). A copy of the allocator argument is used to
-allocate memory, if necessary, for the internal data structures of the
-constructed `function` object.
 ``` cpp
 function() noexcept;
-template <class A> function(allocator_arg_t, const A& a) noexcept;
 ```
 *Postconditions:* `!*this`.
 ``` cpp
 function(nullptr_t) noexcept;
-template <class A> function(allocator_arg_t, const A& a, nullptr_t) noexcept;
 ```
 *Postconditions:* `!*this`.
 ``` cpp
 function(const function& f);
-template <class A> function(allocator_arg_t, const A& a, 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 callable
-object passed via `reference_wrapper` or a function pointer. Otherwise,
-may throw `bad_alloc` or any exception thrown by the copy constructor of
-the stored callable object. 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.
 ``` cpp
 function(function&& f);
-template <class A> function(allocator_arg_t, const A& a, function&& f);
 ```
-*Effects:* If `!f`, `*this` has no target; otherwise, move-constructs
-the target of `f` into the target of `*this`, leaving `f` in a valid
-state with an unspecified value.
 ``` cpp
 template<class F> function(F f);
-template <class F, class A> function(allocator_arg_t, const A& a, F f);
 ```
 *Requires:* `F` shall be `CopyConstructible`.
-*Remarks:* These constructors shall not participate in overload
-resolution unless `f` is 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)`. 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.
 *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
 function& operator=(const function& f);
 ```
-*Effects:* `function(f).swap(*this);`
-*Returns:* `*this`
 ``` cpp
 function& operator=(function&& f);
 ```
 *Effects:* Replaces the target of `*this` with the target of `f`.
-*Returns:* `*this`
 ``` cpp
-function& operator=(nullptr_t);
 ```
 *Effects:* If `*this != nullptr`, destroys the target of `this`.
 *Postconditions:* `!(*this)`.
-*Returns:* `*this`
 ``` cpp
 template<class F> function& operator=(F&& f);
 ```
-*Effects:* `function(std::forward<F>(f)).swap(*this);`
-*Returns:* `*this`
 *Remarks:* This assignment operator shall not participate in overload
-resolution unless `declval<typename decay<F>::type&>()` is
-Callable ([[func.wrap.func]]) for argument types `ArgTypes...` and
-return type `R`.
 ``` cpp
 template<class F> function& operator=(reference_wrapper<F> f) noexcept;
 ```
-*Effects:* `function(f).swap(*this);`
-*Returns:* `*this`
 ``` cpp
 ~function();
 ```
@@ -1354,17 +1506,10 @@ template<class F> function& operator=(reference_wrapper<F> f) noexcept;
 void swap(function& other) noexcept;
 ```
 *Effects:* interchanges the targets of `*this` and `other`.
-``` cpp
-template<class F, class A>
-  void assign(F&& f, const A& a);
-```
-*Effects:* `function(allocator_arg, a, std::forward<F>(f)).swap(*this)`
 ##### `function` capacity <a id="func.wrap.func.cap">[[func.wrap.func.cap]]</a>
 ``` cpp
 explicit operator bool() const noexcept;
 ```
@@ -1372,44 +1517,38 @@ 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
 ```
-*Effects:*
-*`INVOKE`*`(f, std::forward<ArgTypes>(args)..., R)` ([[func.require]]),
-where `f` is the target object ([[func.def]]) of `*this`.
-*Returns:* Nothing if `R` is `void`, otherwise the return value of
-*`INVOKE`*`(f, std::forward<ArgTypes>(args)..., R)`.
 *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 std::type_info& target_type() const noexcept;
 ```
 *Returns:* If `*this` has a target of type `T`, `typeid(T)`; otherwise,
 `typeid(void)`.
 ``` cpp
 template<class T>       T* target() noexcept;
 template<class T> const T* target() const noexcept;
 ```
-*Requires:* `T` shall be a type that is Callable ([[func.wrap.func]])
-for parameter types `ArgTypes` and return type `R`.
 *Returns:* If `target_type() == typeid(T)` a pointer to the stored
 function target; otherwise a null pointer.
-##### null pointer comparison operators <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>
@@ -1429,58 +1568,285 @@ template <class R, class... ArgTypes>
 ##### 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);
 ```
-*Effects:* `f1.swap(f2);`
 ### Class template `hash` <a id="unord.hash">[[unord.hash]]</a>
 The unordered associative containers defined in [[unord]] use
-specializations of the class template `hash` as the default hash
-function. For all object types `Key` for which there exists a
-specialization `hash<Key>`, and for all enumeration types (
-[[dcl.enum]]) `Key`, the instantiation `hash<Key>` shall:
 - satisfy the `Hash` requirements ([[hash.requirements]]), with `Key`
   as the function call argument type, the `DefaultConstructible`
-  requirements (Table  [[defaultconstructible]]), the `CopyAssignable`
-  requirements (Table  [[copyassignable]]),
 - be swappable ([[swappable.requirements]]) for lvalues,
-- provide two nested types `result_type` and `argument_type` which shall
- be synonyms for `size_t` and `Key`, respectively,
-- 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.
-``` cpp
-template <> struct hash<bool>;
-template <> struct hash<char>;
-template <> struct hash<signed char>;
-template <> struct hash<unsigned char>;
-template <> struct hash<char16_t>;
-template <> struct hash<char32_t>;
-template <> struct hash<wchar_t>;
-template <> struct hash<short>;
-template <> struct hash<unsigned short>;
-template <> struct hash<int>;
-template <> struct hash<unsigned int>;
-template <> struct hash<long>;
-template <> struct hash<unsigned long>;
-template <> struct hash<long long>;
-template <> struct hash<unsigned long long>;
-template <> struct hash<float>;
-template <> struct hash<double>;
-template <> struct hash<long double>;
-template <class T> struct hash<T*>;
-```
-The template specializations shall meet the requirements of class
-template `hash` ([[unord.hash]]).

 [[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;
   template <class T = void> struct divides;
   template <class T = void> struct modulus;
   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 <> 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>;
   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.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;
                .
                .
                .
+ 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
   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;
   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;
+ template<class RandomAccessIterator,
+           class Hash = hash<typename iterator_traits<RandomAccessIterator>::value_type>,
+           class BinaryPredicate = equal_to<>>
+    class boyer_moore_searcher;
+  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*:
 If a C++program wants to have a by-element addition of two vectors `a`
 and `b` containing `double` and put the result into `a`, it can do:
 ``` cpp
 transform(a.begin(), a.end(), b.begin(), a.begin(), plus<double>());
 ```
+— *end example*]
+[*Example 2*:
 To negate every element of `a`:
 ``` cpp
 transform(a.begin(), a.end(), a.begin(), negate<double>());
 ```
+— *end example*]
 ### Definitions <a id="func.def">[[func.def]]</a>
 The following definitions apply to this Clause:
 ### 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 {
   template <class T> class reference_wrapper {
   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;
     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;
 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>
 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 {
   constexpr T operator()(const T& x, const T& y) const;
 };
 ```
 ``` cpp
 constexpr T operator()(const T& x, const T& y) const;
 ```
+*Returns:* `x + y`.
 ``` cpp
 template <> struct plus<void> {
   template <class T, class U> constexpr auto operator()(T&& t, U&& u) const
     -> decltype(std::forward<T>(t) + std::forward<U>(u));
+ using is_transparent = unspecified;
 };
 ```
+``` cpp
+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 `minus` <a id="arithmetic.operations.minus">[[arithmetic.operations.minus]]</a>
+``` cpp
+template <class T = void> struct minus {
+  constexpr T operator()(const T& x, const T& y) const;
+};
+```
+``` cpp
+constexpr T operator()(const T& x, const T& y) const;
+```
+*Returns:* `x - y`.
 ``` cpp
 template <> struct minus<void> {
   template <class T, class U> constexpr auto operator()(T&& t, U&& u) const
     -> decltype(std::forward<T>(t) - std::forward<U>(u));
+ using is_transparent = unspecified;
 };
 ```
+``` cpp
+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 `multiplies` <a id="arithmetic.operations.multiplies">[[arithmetic.operations.multiplies]]</a>
+``` cpp
+template <class T = void> struct multiplies {
+  constexpr T operator()(const T& x, const T& y) const;
+};
+```
+``` cpp
+constexpr T operator()(const T& x, const T& y) const;
+```
+*Returns:* `x * y`.
 ``` cpp
 template <> struct multiplies<void> {
   template <class T, class U> constexpr auto operator()(T&& t, U&& u) const
     -> decltype(std::forward<T>(t) * std::forward<U>(u));
+ using is_transparent = unspecified;
 };
 ```
+``` cpp
+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 `divides` <a id="arithmetic.operations.divides">[[arithmetic.operations.divides]]</a>
+``` cpp
+template <class T = void> struct divides {
+  constexpr T operator()(const T& x, const T& y) const;
+};
+```
+``` cpp
+constexpr T operator()(const T& x, const T& y) const;
+```
+*Returns:* `x / y`.
 ``` cpp
 template <> struct divides<void> {
   template <class T, class U> constexpr auto operator()(T&& t, U&& u) const
     -> decltype(std::forward<T>(t) / std::forward<U>(u));
+ using is_transparent = unspecified;
 };
 ```
+``` cpp
+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 `modulus` <a id="arithmetic.operations.modulus">[[arithmetic.operations.modulus]]</a>
+``` cpp
+template <class T = void> struct modulus {
+  constexpr T operator()(const T& x, const T& y) const;
+};
+```
+``` cpp
+constexpr T operator()(const T& x, const T& y) const;
+```
+*Returns:* `x % y`.
 ``` cpp
 template <> struct modulus<void> {
   template <class T, class U> constexpr auto operator()(T&& t, U&& u) const
     -> decltype(std::forward<T>(t) % std::forward<U>(u));
+ using is_transparent = unspecified;
 };
 ```
+``` cpp
+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 `negate` <a id="arithmetic.operations.negate">[[arithmetic.operations.negate]]</a>
+``` cpp
+template <class T = void> struct negate {
+  constexpr T operator()(const T& x) const;
+};
+```
+``` cpp
+constexpr T operator()(const T& x) const;
+```
+*Returns:* `-x`.
 ``` cpp
 template <> struct negate<void> {
   template <class T> constexpr auto operator()(T&& t) const
     -> decltype(-std::forward<T>(t));
+ using is_transparent = unspecified;
 };
 ```
+``` cpp
+template <class T> constexpr auto operator()(T&& t) const
+    -> decltype(-std::forward<T>(t));
+```
+*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 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;
 };
 ```
 ``` cpp
 constexpr bool operator()(const T& x, const T& y) const;
 ```
+*Returns:* `x == y`.
 ``` cpp
 template <> struct equal_to<void> {
   template <class T, class U> constexpr auto operator()(T&& t, U&& u) const
     -> decltype(std::forward<T>(t) == std::forward<U>(u));
+ using is_transparent = unspecified;
 };
 ```
+``` cpp
+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;
+};
+```
+``` cpp
+constexpr bool operator()(const T& x, const T& y) const;
+```
+*Returns:* `x != y`.
 ``` cpp
 template <> struct not_equal_to<void> {
   template <class T, class U> constexpr auto operator()(T&& t, U&& u) const
     -> decltype(std::forward<T>(t) != std::forward<U>(u));
+ using is_transparent = unspecified;
 };
 ```
+``` cpp
+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` <a id="comparisons.greater">[[comparisons.greater]]</a>
+``` cpp
+template <class T = void> struct greater {
+  constexpr bool operator()(const T& x, const T& y) const;
+};
+```
+``` cpp
+constexpr bool operator()(const T& x, const T& y) const;
+```
+*Returns:* `x > y`.
 ``` cpp
 template <> struct greater<void> {
   template <class T, class U> constexpr auto operator()(T&& t, U&& u) const
     -> decltype(std::forward<T>(t) > std::forward<U>(u));
+ using is_transparent = unspecified;
 };
 ```
+``` cpp
+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` <a id="comparisons.less">[[comparisons.less]]</a>
+``` cpp
+template <class T = void> struct less {
+  constexpr bool operator()(const T& x, const T& y) const;
+};
+```
+``` cpp
+constexpr bool operator()(const T& x, const T& y) const;
+```
+*Returns:* `x < y`.
 ``` cpp
 template <> struct less<void> {
   template <class T, class U> constexpr auto operator()(T&& t, U&& u) const
     -> decltype(std::forward<T>(t) < std::forward<U>(u));
+ using is_transparent = unspecified;
 };
 ```
+``` cpp
+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;
+};
+```
+``` cpp
+constexpr bool operator()(const T& x, const T& y) const;
+```
+*Returns:* `x >= y`.
 ``` cpp
 template <> struct greater_equal<void> {
   template <class T, class U> constexpr auto operator()(T&& t, U&& u) const
     -> decltype(std::forward<T>(t) >= std::forward<U>(u));
+ using is_transparent = unspecified;
 };
 ```
+``` cpp
+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;
+};
+```
+``` cpp
+constexpr bool operator()(const T& x, const T& y) const;
+```
+*Returns:* `x <= y`.
 ``` cpp
 template <> struct less_equal<void> {
   template <class T, class U> constexpr auto operator()(T&& t, U&& u) const
     -> decltype(std::forward<T>(t) <= std::forward<U>(u));
+ using is_transparent = unspecified;
 };
 ```
+``` cpp
+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]]).
+#### Class template `logical_and` <a id="logical.operations.and">[[logical.operations.and]]</a>
 ``` cpp
 template <class T = void> struct logical_and {
   constexpr bool operator()(const T& x, const T& y) const;
 };
 ```
 ``` cpp
 constexpr bool operator()(const T& x, const T& y) const;
 ```
+*Returns:* `x && y`.
 ``` cpp
 template <> struct logical_and<void> {
   template <class T, class U> constexpr auto operator()(T&& t, U&& u) const
     -> decltype(std::forward<T>(t) && std::forward<U>(u));
+ using is_transparent = unspecified;
 };
 ```
+``` cpp
+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 `logical_or` <a id="logical.operations.or">[[logical.operations.or]]</a>
+``` cpp
+template <class T = void> struct logical_or {
+  constexpr bool operator()(const T& x, const T& y) const;
+};
+```
+``` cpp
+constexpr bool operator()(const T& x, const T& y) const;
+```
+*Returns:* `x || y`.
 ``` cpp
 template <> struct logical_or<void> {
   template <class T, class U> constexpr auto operator()(T&& t, U&& u) const
     -> decltype(std::forward<T>(t) || std::forward<U>(u));
+ using is_transparent = unspecified;
 };
 ```
+``` cpp
+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 `logical_not` <a id="logical.operations.not">[[logical.operations.not]]</a>
+``` cpp
+template <class T = void> struct logical_not {
+  constexpr bool operator()(const T& x) const;
+};
+```
+``` cpp
+constexpr bool operator()(const T& x) const;
+```
+*Returns:* `!x`.
 ``` cpp
 template <> struct logical_not<void> {
   template <class T> constexpr auto operator()(T&& t) const
     -> decltype(!std::forward<T>(t));
+ using is_transparent = unspecified;
 };
 ```
+``` cpp
+template <class T> constexpr auto operator()(T&& t) const
+    -> decltype(!std::forward<T>(t));
+```
+*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 {
   constexpr T operator()(const T& x, const T& y) const;
 };
 ```
 ``` cpp
 constexpr T operator()(const T& x, const T& y) const;
 ```
+*Returns:* `x & y`.
 ``` cpp
 template <> struct bit_and<void> {
   template <class T, class U> constexpr auto operator()(T&& t, U&& u) const
     -> decltype(std::forward<T>(t) & std::forward<U>(u));
+ using is_transparent = unspecified;
 };
 ```
+``` cpp
+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 `bit_or` <a id="bitwise.operations.or">[[bitwise.operations.or]]</a>
+``` cpp
+template <class T = void> struct bit_or {
+  constexpr T operator()(const T& x, const T& y) const;
+};
+```
+``` cpp
+constexpr T operator()(const T& x, const T& y) const;
+```
+*Returns:* `x | y`.
 ``` cpp
 template <> struct bit_or<void> {
   template <class T, class U> constexpr auto operator()(T&& t, U&& u) const
     -> decltype(std::forward<T>(t) | std::forward<U>(u));
+ using is_transparent = unspecified;
 };
 ```
+``` cpp
+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 `bit_xor` <a id="bitwise.operations.xor">[[bitwise.operations.xor]]</a>
+``` cpp
+template <class T = void> struct bit_xor {
+  constexpr T operator()(const T& x, const T& y) const;
+};
+```
+``` cpp
+constexpr T operator()(const T& x, const T& y) const;
+```
+*Returns:* `x ^ y`.
 ``` cpp
 template <> struct bit_xor<void> {
   template <class T, class U> constexpr auto operator()(T&& t, U&& u) const
     -> decltype(std::forward<T>(t) ^ std::forward<U>(u));
+ using is_transparent = unspecified;
 };
 ```
+``` cpp
+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 `bit_not` <a id="bitwise.operations.not">[[bitwise.operations.not]]</a>
+``` cpp
+template <class T = void> struct bit_not {
+  constexpr T operator()(const T& x) const;
+};
+```
+``` cpp
+constexpr T operator()(const T& x) const;
+```
+*Returns:* `~x`.
 ``` cpp
 template <> struct bit_not<void> {
   template <class T> constexpr auto operator()(T&& t) const
     -> decltype(~std::forward<T>(t));
+ using is_transparent = unspecified;
 };
 ```
+``` cpp
+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.
 namespace std {
   template<class T> struct is_bind_expression;  // see below
 }
 ```
+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 {
   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.
 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 {
   // M is the implementation-defined number of placeholders
+  see below _1;
+  see below _2;
               .
               .
               .
+  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.
 `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 {
+  template<class> class function; // not defined
   template<class R, class... ArgTypes>
   class function<R(ArgTypes...)> {
   public:
+ using result_type = R;
+    // [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;
     template<class F> function& operator=(F&&);
     template<class F> function& operator=(reference_wrapper<F>) noexcept;
     ~function();
+    // [func.wrap.func.mod], function modifiers
     void swap(function&) noexcept;
+    // [func.wrap.func.cap], function capacity
     explicit operator bool() const noexcept;
+    // [func.wrap.func.inv], function invocation
     R operator()(ArgTypes...) const;
+    // [func.wrap.func.targ], function target access
+    const type_info& target_type() const noexcept;
     template<class T>       T* target() noexcept;
     template<class T> const T* target() const 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 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;
     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() {
+  int i{5};
+  function g = [&](double) { return i; }; // deduces function<int(double)>
+}
+```
+— *end example*]
 ``` cpp
 function& operator=(const function& f);
 ```
+*Effects:* As if by `function(f).swap(*this);`
+*Returns:* `*this`.
 ``` cpp
 function& operator=(function&& f);
 ```
 *Effects:* Replaces the target of `*this` with the target of `f`.
+*Returns:* `*this`.
 ``` cpp
+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);`
+*Returns:* `*this`.
 ``` cpp
 ~function();
 ```
 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;
 ```
 *Returns:* If `*this` has a target of type `T`, `typeid(T)`; otherwise,
 `typeid(void)`.
 ``` cpp
 template<class T>       T* target() noexcept;
 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>
 ##### 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`,
+- `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 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.
+#### 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:
+    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
+`pred_` with `pred`.
+*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
+- `i == search(first, last, pat_first_, pat_last_, pred_)`, and
+- if `i == last`, then `j == last`, otherwise
+  `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:
+    boyer_moore_searcher(RandomAccessIterator1 pat_first,
+                         RandomAccessIterator1 pat_last,
+                         Hash hf = Hash(),
+                         BinaryPredicate pred = BinaryPredicate());
+    template <class RandomAccessIterator2>
+      pair<RandomAccessIterator2, RandomAccessIterator2>
+        operator()(RandomAccessIterator2 first, RandomAccessIterator2 last) const;
+  private:
+    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());
+```
+*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
+`BinaryPredicate` or `Hash`. May throw `bad_alloc` if additional memory
+needed for internal data structures cannot be allocated.
+``` cpp
+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
+- `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_))`.
+Returns `make_pair(first, first)` if \[`pat_first_`, `pat_last_`) is
+empty, otherwise returns `make_pair(last, last)` if no such iterator is
+found.
+*Complexity:* At most `(last - first) * (pat_last_ - pat_first_)`
+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:
+    boyer_moore_horspool_searcher(RandomAccessIterator1 pat_first,
+                                  RandomAccessIterator1 pat_last,
+                                  Hash hf = Hash(),
+                                  BinaryPredicate pred = BinaryPredicate());
+    template <class RandomAccessIterator2>
+      pair<RandomAccessIterator2, RandomAccessIterator2>
+        operator()(RandomAccessIterator2 first, RandomAccessIterator2 last) const;
+  private:
+    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,
+                              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
+`BinaryPredicate` or `Hash`. May throw `bad_alloc` if additional memory
+needed for internal data structures cannot be allocated.
+``` cpp
+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
+- `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_))`.
+Returns `make_pair(first, first)` if \[`pat_first_`, `pat_last_`) is
+empty, otherwise returns `make_pair(last, last)` if no such iterator is
+found.
+*Complexity:* At most `(last - first) * (pat_last_ - pat_first_)`
+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
+specialization of the class template `hash`, `hash<Key>` is disabled.
+If the library provides an explicit or partial specialization of
+`hash<Key>`, that specialization is enabled except as noted otherwise,
+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.

Diff to HTML by rtfpessoa