[depr.func.adaptor.typedefs]

Files changed (1) hide show

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

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

@@ -1,242 +0,0 @@
-### 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