[depr.func.adaptor.typedefs]

Files changed (1) hide show

tmp/tmpw0hniolk/{from.md → to.md} +242 -0

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

	@@ -0,0 +1,242 @@

+### Typedefs to support function binders <a id="depr.func.adaptor.typedefs">[[depr.func.adaptor.typedefs]]</a>
+To enable old function adaptors to manipulate function objects that take
+one or two arguments, many of the function objects in this International
+Standard correspondingly provide *typedef-name*s `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.
+The following member names are defined in addition to names specified in
+Clause  [[function.objects]]:
+``` cpp
+namespace std {
+  template<class T> struct owner_less<shared_ptr<T>> {
+    using result_type          = bool;
+    using first_argument_type  = shared_ptr<T>;
+    using second_argument_type = shared_ptr<T>;
+  };
+  template<class T> struct owner_less<weak_ptr<T>> {
+    using result_type          = bool;
+    using first_argument_type  = weak_ptr<T>;
+    using second_argument_type = weak_ptr<T>;
+  };
+  template <class T> class reference_wrapper {
+  public :
+    using result_type          = see below; // not always defined
+    using argument_type        = see below; // not always defined
+    using first_argument_type  = see below; // not always defined
+    using second_argument_type = see below; // not always defined
+  };
+  template <class T> struct plus {
+    using first_argument_type  = T;
+    using second_argument_type = T;
+    using result_type          = T;
+  };
+  template <class T> struct minus {
+    using first_argument_type  = T;
+    using second_argument_type = T;
+    using result_type          = T;
+  };
+  template <class T> struct multiplies {
+    using first_argument_type  = T;
+    using second_argument_type = T;
+    using result_type          = T;
+  };
+  template <class T> struct divides {
+    using first_argument_type  = T;
+    using second_argument_type = T;
+    using result_type          = T;
+  };
+  template <class T> struct modulus {
+    using first_argument_type  = T;
+    using second_argument_type = T;
+    using result_type          = T;
+  };
+  template <class T> struct negate {
+    using argument_type = T;
+    using result_type   = T;
+  };
+  template <class T> struct equal_to {
+    using first_argument_type  = T;
+    using second_argument_type = T;
+    using result_type          = bool;
+  };
+  template <class T> struct not_equal_to {
+    using first_argument_type  = T;
+    using second_argument_type = T;
+    using result_type          = bool;
+  };
+  template <class T> struct greater {
+    using first_argument_type  = T;
+    using second_argument_type = T;
+    using result_type          = bool;
+  };
+  template <class T> struct less {
+    using first_argument_type  = T;
+    using second_argument_type = T;
+    using result_type          = bool;
+  };
+  template <class T> struct greater_equal {
+    using first_argument_type  = T;
+    using second_argument_type = T;
+    using result_type          = bool;
+  };
+  template <class T> struct less_equal {
+    using first_argument_type  = T;
+    using second_argument_type = T;
+    using result_type          = bool;
+  };
+  template <class T> struct logical_and {
+    using first_argument_type  = T;
+    using second_argument_type = T;
+    using result_type          = bool;
+  };
+  template <class T> struct logical_or {
+    using first_argument_type  = T;
+    using second_argument_type = T;
+    using result_type          = bool;
+  };
+  template <class T> struct logical_not {
+    using argument_type = T;
+    using result_type   = bool;
+  };
+  template <class T> struct bit_and {
+    using first_argument_type  = T;
+    using second_argument_type = T;
+    using result_type          = T;
+  };
+  template <class T> struct bit_or {
+    using first_argument_type  = T;
+    using second_argument_type = T;
+    using result_type          = T;
+  };
+  template <class T> struct bit_xor {
+    using first_argument_type  = T;
+    using second_argument_type = T;
+    using result_type          = T;
+  };
+  template <class T> struct bit_not {
+    using argument_type = T;
+    using result_type   = T;
+  };
+  template<class R, class T1>
+  class function<R(T1)> {
+  public:
+    using argument_type = T1;
+  };
+  template<class R, class T1, class T2>
+  class function<R(T1, T2)> {
+  public:
+    using first_argument_type  = T1;
+    using second_argument_type = T2;
+  };
+}
+```
+`reference_wrapper<T>` has a weak result type (
+[[depr.weak.result_type]]). 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 where the *qualified-id* `T::argument_type` is valid and
+  denotes a type ([[temp.deduct]]); 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 where the *qualified-id*s `T::first_argument_type` and
+  `T::second_argument_type` are both valid and both denote types (
+  [[temp.deduct]]); the type `T1` is `T::first_argument_type` and the
+  type `T2` is `T::second_argument_type`.
+All enabled specializations `hash<Key>` of `hash` ([[unord.hash]])
+provide two nested types, `result_type` and `argument_type`, which shall
+be synonyms for `size_t` and `Key`, respectively.
+The forwarding call wrapper `g` returned by a call to
+`bind(f, bound_args...)` ([[func.bind.bind]]) shall have a weak result
+type ([[depr.weak.result_type]]).
+The forwarding call wrapper `g` returned by a call to
+`bind<R>(f, bound_args...)` ([[func.bind.bind]]) shall have a nested
+type `result_type` defined as a synonym for `R`.
+The simple call wrapper returned from a call to `mem_fn(pm)` 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 returned from a call to `mem_fn(pm)` 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 returned from a call to `mem_fn(pm)` 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.
+The following member names are defined in addition to names specified in
+Clause  [[containers]]:
+``` cpp
+namespace std {
+  template <class Key, class T, class Compare, class Allocator>
+  class map<Key, T, Compare, Allocator>::value_compare {
+  public:
+    using result_type          = bool;
+    using first_argument_type  = value_type;
+    using second_argument_type = value_type;
+  };
+  template <class Key, class T, class Compare, class Allocator>
+  class multimap<Key, T, Compare, Allocator>::value_compare {
+  public:
+    using result_type          = bool;
+    using first_argument_type  = value_type;
+    using second_argument_type = value_type;
+  };
+}
+```

Diff to HTML by rtfpessoa