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

Files changed (1) hide show

tmp/tmpgdotz56m/{from.md → to.md} +383 -175

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

@@ -26,44 +26,64 @@ namespace std {
   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> struct plus;
-  template <class T> struct minus;
-  template <class T> struct multiplies;
-  template <class T> struct divides;
-  template <class T> struct modulus;
-  template <class T> struct negate;
   // [comparisons], comparisons:
-  template <class T> struct equal_to;
-  template <class T> struct not_equal_to;
-  template <class T> struct greater;
-  template <class T> struct less;
-  template <class T> struct greater_equal;
-  template <class T> struct less_equal;
   // [logical.operations], logical operations:
-  template <class T> struct logical_and;
-  template <class T> struct logical_or;
-  template <class T> struct logical_not;
   // [bitwise.operations], bitwise operations:
-  template <class T> struct bit_and;
-  template <class T> struct bit_or;
-  template <class T> struct bit_xor;
   // [negators], negators:
   template <class Predicate> class unary_negate;
   template <class Predicate>
-    unary_negate<Predicate> not1(const Predicate&);
   template <class Predicate> class binary_negate;
   template <class Predicate>
-    binary_negate<Predicate> not2(const Predicate&);
-  // [bind], bind:
   template<class T> struct is_bind_expression;
   template<class T> struct is_placeholder;
   template<class F, class... BoundArgs>
     unspecified bind(F&&, BoundArgs&&...);
@@ -125,34 +145,10 @@ namespace std {
   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::*);
-  template<class R, class T, class... Args>
-    unspecified mem_fn(R (T::*)(Args...));
-  template<class R, class T, class... Args>
-    unspecified mem_fn(R (T::*)(Args...) const);
-  template<class R, class T, class... Args>
-    unspecified mem_fn(R (T::*)(Args...) volatile);
-  template<class R, class T, class... Args>
-    unspecified mem_fn(R (T::*)(Args...) const volatile);
-  template<class R, class T, class... Args>
-    unspecified mem_fn(R (T::*)(Args...) &);
-  template<class R, class T, class... Args>
-    unspecified mem_fn(R (T::*)(Args...) const &);
-  template<class R, class T, class... Args>
-    unspecified mem_fn(R (T::*)(Args...) volatile &);
-  template<class R, class T, class... Args>
-    unspecified mem_fn(R (T::*)(Args...) const volatile &);
-  template<class R, class T, class... Args>
-    unspecified mem_fn(R (T::*)(Args...) &&);
-  template<class R, class T, class... Args>
-    unspecified mem_fn(R (T::*)(Args...) const &&);
-  template<class R, class T, class... Args>
-    unspecified mem_fn(R (T::*)(Args...) volatile &&);
-  template<class R, class T, class... Args>
-    unspecified mem_fn(R (T::*)(Args...) const volatile &&);
   // [func.wrap] polymorphic function wrappers:
   class bad_function_call;
   template<class> class function; // undefined
@@ -168,11 +164,11 @@ namespace std {
   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 base template:
   template <class T> struct hash;
   // Hash function specializations
   template <> struct hash<bool>;
   template <> struct hash<char>;
@@ -210,15 +206,15 @@ 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 it is required that the function objects
-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:
@@ -301,22 +297,22 @@ namespace std {
     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<T>& x) noexcept;
     // assignment
-    reference_wrapper& operator=(const reference_wrapper<T>& x) noexcept;
     // access
     operator T& () const noexcept;
     T& get() const noexcept;
     // invocation
     template <class... ArgTypes>
- typename result_of<T&(ArgTypes&&...)>::type
     operator() (ArgTypes&&...) const;
   };
 }
 ```
@@ -325,11 +321,11 @@ 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 instantiation `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`
@@ -346,11 +342,11 @@ 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
@@ -359,20 +355,20 @@ reference_wrapper(T& t) noexcept;
 *Effects:* Constructs a `reference_wrapper` object that stores a
 reference to `t`.
 ``` cpp
-reference_wrapper(const reference_wrapper<T>& x) noexcept;
 ```
 *Effects:* Constructs a `reference_wrapper` object that stores a
 reference to `x.get()`.
 #### `reference_wrapper` assignment <a id="refwrap.assign">[[refwrap.assign]]</a>
 ``` cpp
-reference_wrapper& operator=(const reference_wrapper<T>& x) noexcept;
 ```
 *Postconditions:* `*this` stores a reference to `x.get()`.
 #### `reference_wrapper` access <a id="refwrap.access">[[refwrap.access]]</a>
@@ -391,11 +387,11 @@ T& get() const noexcept;
 #### reference_wrapper invocation <a id="refwrap.invoke">[[refwrap.invoke]]</a>
 ``` cpp
 template <class... ArgTypes>
- typename result_of<T&(ArgTypes&&... )>::type
     operator()(ArgTypes&&... args) const;
 ```
 *Returns:*
 *`INVOKE`*`(get(), std::forward<ArgTypes>(args)...)`. ([[func.require]])
@@ -435,145 +431,277 @@ template <class T> reference_wrapper<const T> cref(reference_wrapper<T> t) noexc
 The library provides basic function object classes for all of the
 arithmetic operators in the language ([[expr.mul]], [[expr.add]]).
 ``` cpp
-template <class T> struct plus {
-  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> struct minus {
-  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> struct multiplies {
-  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> struct divides {
-  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> struct modulus {
-  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> struct negate {
-  T operator()(const T& x) const;
   typedef T argument_type;
   typedef T result_type;
 };
 ```
 `operator()` returns `-x`.
 ### 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> struct equal_to {
-  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> struct not_equal_to {
-  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> struct greater {
-  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> struct less {
-  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> struct greater_equal {
-  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> struct less_equal {
-  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`.
 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>
@@ -581,111 +709,198 @@ built-in operators `<`, `>`, `<=`, `>=` do not.
 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> struct logical_and {
-  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> struct logical_or {
-  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> struct logical_not {
-  bool operator()(const T& x) const;
   typedef T argument_type;
   typedef bool result_type;
 };
 ```
 `operator()` returns `!x`.
 ### 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]]).
 ``` cpp
-template <class T> struct bit_and {
-  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> struct bit_or {
-  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> struct bit_xor {
-  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`.
 ### 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:
-  explicit unary_negate(const Predicate& pred);
-  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>
-  unary_negate<Predicate> not1(const Predicate& pred);
 ```
 *Returns:* `unary_negate<Predicate>(pred)`.
 ``` cpp
 template <class Predicate>
   class binary_negate {
   public:
-    explicit binary_negate(const Predicate& pred);
-    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;
   };
@@ -693,60 +908,70 @@ template <class Predicate>
 `operator()` returns `!pred(x,y)`.
 ``` cpp
 template <class Predicate>
-  binary_negate<Predicate> not2(const Predicate& pred);
 ```
 *Returns:* `binary_negate<Predicate>(pred)`.
-### Function template `bind` <a id="bind">[[bind]]</a>
-The function template `bind` returns an object that binds a callable
-object passed as an argument to additional arguments.
-#### Function object binders <a id="func.bind">[[func.bind]]</a>
 This subclause describes a uniform mechanism for binding arguments of
 callable objects.
-##### Class template `is_bind_expression` <a id="func.bind.isbind">[[func.bind.isbind]]</a>
 ``` cpp
 namespace std {
-  template<class T> struct is_bind_expression
-    : integral_constant<bool, see below> { };
 }
 ```
 `is_bind_expression` can be used to detect function objects generated by
-`bind`. `bind` uses `is_bind_expression` to detect subexpressions. Users
-may specialize this template to indicate that a type should be treated
-as a subexpression in a `bind` call.
-If `T` is a type returned from `bind`, `is_bind_expression<T>` shall be
-publicly derived from `integral_constant<bool, true>`, otherwise from
-`integral_constant<bool, false>`.
 `is_placeholder` can be used to detect the standard placeholders `_1`,
 `_2`, and so on. `bind` uses `is_placeholder` to detect placeholders.
-Users may specialize this template to indicate a placeholder type.
-If `T` is the type of `std::placeholders::_J`, `is_placeholder<T>` shall
-be publicly derived from `integral_constant<int, J>`, otherwise from
-`integral_constant<int, 0>`.
-##### 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<F>::type`,
 - `fd` is an lvalue of type `FD` constructed from `std::forward<F>(f)`,
-- `Ti` is the iᵗʰ type in the template parameter back `BoundArgs`,
-- `TiD` is the type `decay<Ti>::type`,
 - `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
@@ -763,11 +988,11 @@ template<class F, class... BoundArgs>
 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, v1, v2, ..., vN, result_of<FD `*`cv`*` (V1, V2, ..., VN)>::type)`,
 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
@@ -792,11 +1017,12 @@ template<class R, class F, class... BoundArgs>
 *`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, v1, v2, ..., 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.
@@ -817,16 +1043,16 @@ from the call to `bind` and the *cv*-qualifiers *cv* of the call wrapper
 - 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<TiD cv (Uj...)>::type`;
 - 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
@@ -847,36 +1073,11 @@ 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);
-template<class R, class T, class... Args>
-  unspecified mem_fn(R (T::* pm)(Args...));
-template<class R, class T, class... Args>
-  unspecified mem_fn(R (T::* pm)(Args...) const);
-template<class R, class T, class... Args>
-  unspecified mem_fn(R (T::* pm)(Args...) volatile);
-template<class R, class T, class... Args>
-  unspecified mem_fn(R (T::* pm)(Args...) const volatile);
-template<class R, class T, class... Args>
-  unspecified mem_fn(R (T::* pm)(Args...) &);
-template<class R, class T, class... Args>
-  unspecified mem_fn(R (T::* pm)(Args...) const &);
-template<class R, class T, class... Args>
-  unspecified mem_fn(R (T::* pm)(Args...) volatile &);
-template<class R, class T, class... Args>
-  unspecified mem_fn(R (T::* pm)(Args...) const volatile &);
-template<class R, class T, class... Args>
-  unspecified mem_fn(R (T::* pm)(Args...) &&);
-template<class R, class T, class... Args>
-  unspecified mem_fn(R (T::* pm)(Args...) const &&);
-template<class R, class T, class... Args>
-  unspecified mem_fn(R (T::* pm)(Args...) volatile &&);
-template<class R, class T, class... Args>
-  unspecified mem_fn(R (T::* pm)(Args...) const volatile &&);
 ```
 *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
@@ -934,15 +1135,15 @@ namespace std {
   template<class R, class... ArgTypes>
   class function<R(ArgTypes...)> {
   public:
     typedef R result_type;
-    typedef T1 argument_type;           // iff sizeof...(ArgTypes) == 1 and
                                         // the type in ArgTypes is T1
-    typedef T1 first_argument_type;     // iff sizeof...(ArgTypes) == 2 and
                                         // ArgTypes contains T1 and T2
-    typedef T2 second_argument_type;    // iff sizeof...(ArgTypes) == 2 and
                                         // ArgTypes contains T1 and T2
     // [func.wrap.func.con], construct/copy/destroy:
     function() noexcept;
     function(nullptr_t) noexcept;
@@ -976,12 +1177,12 @@ namespace std {
     // [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 <typename T>       T* target() noexcept;
-    template <typename T> const T* target() const noexcept;
   };
   // [func.wrap.func.nullptr], Null pointer comparisons:
   template <class R, class... ArgTypes>
@@ -1070,20 +1271,21 @@ 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`. `f` shall be
-Callable ([[func.wrap.func]]) for argument types `ArgTypes` and return
-type `R`. The copy constructor and destructor of `A` shall not throw
-exceptions.
 *Postconditions:* `!*this` if any of the following hold:
-- `f` is a NULL function pointer.
-- `f` is a NULL pointer to member.
-- `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
@@ -1111,11 +1313,11 @@ function& operator=(function&& f);
 ``` cpp
 function& operator=(nullptr_t);
 ```
-*Effects:* If `*this != NULL`, destroys the target of `this`.
 *Postconditions:* `!(*this)`.
 *Returns:* `*this`
@@ -1125,10 +1327,15 @@ template<class F> function& operator=(F&& f);
 *Effects:* `function(std::forward<F>(f)).swap(*this);`
 *Returns:* `*this`
 ``` cpp
 template<class F> function& operator=(reference_wrapper<F> f) noexcept;
 ```
 *Effects:* `function(f).swap(*this);`
@@ -1137,11 +1344,11 @@ template<class F> function& operator=(reference_wrapper<F> f) noexcept;
 ``` cpp
 ~function();
 ```
-*Effects:* If `*this != NULL`, destroys the target of `this`.
 ##### `function` modifiers <a id="func.wrap.func.mod">[[func.wrap.func.mod]]</a>
 ``` cpp
 void swap(function& other) noexcept;
@@ -1188,18 +1395,18 @@ const std::type_info& target_type() const noexcept;
 *Returns:* If `*this` has a target of type `T`, `typeid(T)`; otherwise,
 `typeid(void)`.
 ``` cpp
-template<typename T>       T* target() noexcept;
-template<typename 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
@@ -1232,11 +1439,12 @@ template<class R, class... ArgTypes>
 ### 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>`, 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]]),
@@ -1271,8 +1479,8 @@ template <> struct hash<float>;
 template <> struct hash<double>;
 template <> struct hash<long double>;
 template <class T> struct hash<T*>;
 ```
-*Requires:* the template specializations shall meet the requirements of
-class template `hash` ([[unord.hash]]).

   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 <class T = void> struct negate;
+  template <> struct plus<void>;
+  template <> struct minus<void>;
+  template <> struct multiplies<void>;
+  template <> struct divides<void>;
+  template <> struct modulus<void>;
+  template <> struct negate<void>;
   // [comparisons], comparisons:
+  template <class T = void> struct equal_to;
+  template <class T = void> struct not_equal_to;
+  template <class T = void> struct greater;
+  template <class T = void> struct less;
+  template <class T = void> struct greater_equal;
+  template <class T = void> struct less_equal;
+  template <> struct equal_to<void>;
+  template <> struct not_equal_to<void>;
+  template <> struct greater<void>;
+  template <> struct less<void>;
+  template <> struct greater_equal<void>;
+  template <> struct less_equal<void>;
   // [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 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>
     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>;
 ``` 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:
     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;
     // assignment
+    reference_wrapper& operator=(const reference_wrapper& x) noexcept;
     // access
     operator T& () const noexcept;
     T& get() const noexcept;
     // invocation
     template <class... ArgTypes>
+ result_of_t<T&(ArgTypes&&...)>
     operator() (ArgTypes&&...) const;
   };
 }
 ```
 `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 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
 *Effects:* Constructs a `reference_wrapper` object that stores a
 reference to `t`.
 ``` cpp
+reference_wrapper(const reference_wrapper& x) noexcept;
 ```
 *Effects:* Constructs a `reference_wrapper` object that stores a
 reference to `x.get()`.
 #### `reference_wrapper` assignment <a id="refwrap.assign">[[refwrap.assign]]</a>
 ``` cpp
+reference_wrapper& operator=(const reference_wrapper& x) noexcept;
 ```
 *Postconditions:* `*this` stores a reference to `x.get()`.
 #### `reference_wrapper` access <a id="refwrap.access">[[refwrap.access]]</a>
 #### 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]])
 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.
+#### Class template `is_bind_expression` <a id="func.bind.isbind">[[func.bind.isbind]]</a>
 ``` cpp
 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
 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
 *`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.
 - 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
 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
   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;
     // [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>
 ``` 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
 ``` cpp
 function& operator=(nullptr_t);
 ```
+*Effects:* If `*this != nullptr`, destroys the target of `this`.
 *Postconditions:* `!(*this)`.
 *Returns:* `*this`
 *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);`
 ``` cpp
 ~function();
 ```
+*Effects:* If `*this != nullptr`, destroys the target of `this`.
 ##### `function` modifiers <a id="func.wrap.func.mod">[[func.wrap.func.mod]]</a>
 ``` cpp
 void swap(function& other) noexcept;
 *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
 ### 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]]),
 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]]).

Diff to HTML by rtfpessoa