From Jason Turner

[indirectcallable]

C++20 → C++23 5.4 KB 47 lines
Current Draft | LaTeX Source
Archived: C++20 | C++23
Markdown: C++20 | C++23
Explore in Adventure Game

Diff to HTML by rtfpessoa

Files changed (1) hide show
  1. tmp/tmpkpkrr738/{from.md → to.md} +27 -17
tmp/tmpkpkrr738/{from.md → to.md} RENAMED
@@ -1,85 +1,95 @@
1
  ### Indirect callable requirements <a id="indirectcallable">[[indirectcallable]]</a>
2
 
3
  #### General <a id="indirectcallable.general">[[indirectcallable.general]]</a>
4
 
5
  There are several concepts that group requirements of algorithms that
6
- take callable objects ([[func.def]]) as arguments.
 
 
 
 
 
 
 
 
 
 
7
 
8
  #### Indirect callables <a id="indirectcallable.indirectinvocable">[[indirectcallable.indirectinvocable]]</a>
9
 
10
  The indirect callable concepts are used to constrain those algorithms
11
- that accept callable objects ([[func.def]]) as arguments.
12
 
13
  ``` cpp
14
  namespace std {
15
  template<class F, class I>
16
  concept indirectly_unary_invocable =
17
  indirectly_readable<I> &&
18
  copy_constructible<F> &&
19
- invocable<F&, iter_value_t<I>&> &&
20
  invocable<F&, iter_reference_t<I>> &&
21
  invocable<F&, iter_common_reference_t<I>> &&
22
  common_reference_with<
23
- invoke_result_t<F&, iter_value_t<I>&>,
24
  invoke_result_t<F&, iter_reference_t<I>>>;
25
 
26
  template<class F, class I>
27
  concept indirectly_regular_unary_invocable =
28
  indirectly_readable<I> &&
29
  copy_constructible<F> &&
30
- regular_invocable<F&, iter_value_t<I>&> &&
31
  regular_invocable<F&, iter_reference_t<I>> &&
32
  regular_invocable<F&, iter_common_reference_t<I>> &&
33
  common_reference_with<
34
- invoke_result_t<F&, iter_value_t<I>&>,
35
  invoke_result_t<F&, iter_reference_t<I>>>;
36
 
37
  template<class F, class I>
38
  concept indirect_unary_predicate =
39
  indirectly_readable<I> &&
40
  copy_constructible<F> &&
41
- predicate<F&, iter_value_t<I>&> &&
42
  predicate<F&, iter_reference_t<I>> &&
43
  predicate<F&, iter_common_reference_t<I>>;
44
 
45
  template<class F, class I1, class I2>
46
  concept indirect_binary_predicate =
47
  indirectly_readable<I1> && indirectly_readable<I2> &&
48
  copy_constructible<F> &&
49
- predicate<F&, iter_value_t<I1>&, iter_value_t<I2>&> &&
50
- predicate<F&, iter_value_t<I1>&, iter_reference_t<I2>> &&
51
- predicate<F&, iter_reference_t<I1>, iter_value_t<I2>&> &&
52
  predicate<F&, iter_reference_t<I1>, iter_reference_t<I2>> &&
53
  predicate<F&, iter_common_reference_t<I1>, iter_common_reference_t<I2>>;
54
 
55
  template<class F, class I1, class I2 = I1>
56
  concept indirect_equivalence_relation =
57
  indirectly_readable<I1> && indirectly_readable<I2> &&
58
  copy_constructible<F> &&
59
- equivalence_relation<F&, iter_value_t<I1>&, iter_value_t<I2>&> &&
60
- equivalence_relation<F&, iter_value_t<I1>&, iter_reference_t<I2>> &&
61
- equivalence_relation<F&, iter_reference_t<I1>, iter_value_t<I2>&> &&
62
  equivalence_relation<F&, iter_reference_t<I1>, iter_reference_t<I2>> &&
63
  equivalence_relation<F&, iter_common_reference_t<I1>, iter_common_reference_t<I2>>;
64
 
65
  template<class F, class I1, class I2 = I1>
66
  concept indirect_strict_weak_order =
67
  indirectly_readable<I1> && indirectly_readable<I2> &&
68
  copy_constructible<F> &&
69
- strict_weak_order<F&, iter_value_t<I1>&, iter_value_t<I2>&> &&
70
- strict_weak_order<F&, iter_value_t<I1>&, iter_reference_t<I2>> &&
71
- strict_weak_order<F&, iter_reference_t<I1>, iter_value_t<I2>&> &&
72
  strict_weak_order<F&, iter_reference_t<I1>, iter_reference_t<I2>> &&
73
  strict_weak_order<F&, iter_common_reference_t<I1>, iter_common_reference_t<I2>>;
74
  }
75
  ```
76
 
77
  #### Class template `projected` <a id="projected">[[projected]]</a>
78
 
79
  Class template `projected` is used to constrain algorithms that accept
80
- callable objects and projections [[defns.projection]]. It combines a
81
  `indirectly_readable` type `I` and a callable object type `Proj` into a
82
  new `indirectly_readable` type whose `reference` type is the result of
83
  applying `Proj` to the `iter_reference_t` of `I`.
84
 
85
  ``` cpp
 
1
  ### Indirect callable requirements <a id="indirectcallable">[[indirectcallable]]</a>
2
 
3
  #### General <a id="indirectcallable.general">[[indirectcallable.general]]</a>
4
 
5
  There are several concepts that group requirements of algorithms that
6
+ take callable objects [[func.def]] as arguments.
7
+
8
+ #### Indirect callable traits <a id="indirectcallable.traits">[[indirectcallable.traits]]</a>
9
+
10
+ To implement algorithms taking projections, it is necessary to determine
11
+ the projected type of an iterator’s value type. For the exposition-only
12
+ alias template *`indirect-value-t`*, `indirect-value-t<T>` denotes
13
+
14
+ - `invoke_result_t<Proj&, indirect-value-t<I>>` if `T` names
15
+ `projected<I, Proj>`, and
16
+ - `iter_value_t<T>&` otherwise.
17
 
18
  #### Indirect callables <a id="indirectcallable.indirectinvocable">[[indirectcallable.indirectinvocable]]</a>
19
 
20
  The indirect callable concepts are used to constrain those algorithms
21
+ that accept callable objects [[func.def]] as arguments.
22
 
23
  ``` cpp
24
  namespace std {
25
  template<class F, class I>
26
  concept indirectly_unary_invocable =
27
  indirectly_readable<I> &&
28
  copy_constructible<F> &&
29
+ invocable<F&, indirect-value-t<I>> &&
30
  invocable<F&, iter_reference_t<I>> &&
31
  invocable<F&, iter_common_reference_t<I>> &&
32
  common_reference_with<
33
+ invoke_result_t<F&, indirect-value-t<I>>,
34
  invoke_result_t<F&, iter_reference_t<I>>>;
35
 
36
  template<class F, class I>
37
  concept indirectly_regular_unary_invocable =
38
  indirectly_readable<I> &&
39
  copy_constructible<F> &&
40
+ regular_invocable<F&, indirect-value-t<I>> &&
41
  regular_invocable<F&, iter_reference_t<I>> &&
42
  regular_invocable<F&, iter_common_reference_t<I>> &&
43
  common_reference_with<
44
+ invoke_result_t<F&, indirect-value-t<I>>,
45
  invoke_result_t<F&, iter_reference_t<I>>>;
46
 
47
  template<class F, class I>
48
  concept indirect_unary_predicate =
49
  indirectly_readable<I> &&
50
  copy_constructible<F> &&
51
+ predicate<F&, indirect-value-t<I>> &&
52
  predicate<F&, iter_reference_t<I>> &&
53
  predicate<F&, iter_common_reference_t<I>>;
54
 
55
  template<class F, class I1, class I2>
56
  concept indirect_binary_predicate =
57
  indirectly_readable<I1> && indirectly_readable<I2> &&
58
  copy_constructible<F> &&
59
+ predicate<F&, indirect-value-t<I1>, indirect-value-t<I2>> &&
60
+ predicate<F&, indirect-value-t<I1>, iter_reference_t<I2>> &&
61
+ predicate<F&, iter_reference_t<I1>, indirect-value-t<I2>> &&
62
  predicate<F&, iter_reference_t<I1>, iter_reference_t<I2>> &&
63
  predicate<F&, iter_common_reference_t<I1>, iter_common_reference_t<I2>>;
64
 
65
  template<class F, class I1, class I2 = I1>
66
  concept indirect_equivalence_relation =
67
  indirectly_readable<I1> && indirectly_readable<I2> &&
68
  copy_constructible<F> &&
69
+ equivalence_relation<F&, indirect-value-t<I1>, indirect-value-t<I2>> &&
70
+ equivalence_relation<F&, indirect-value-t<I1>, iter_reference_t<I2>> &&
71
+ equivalence_relation<F&, iter_reference_t<I1>, indirect-value-t<I2>> &&
72
  equivalence_relation<F&, iter_reference_t<I1>, iter_reference_t<I2>> &&
73
  equivalence_relation<F&, iter_common_reference_t<I1>, iter_common_reference_t<I2>>;
74
 
75
  template<class F, class I1, class I2 = I1>
76
  concept indirect_strict_weak_order =
77
  indirectly_readable<I1> && indirectly_readable<I2> &&
78
  copy_constructible<F> &&
79
+ strict_weak_order<F&, indirect-value-t<I1>, indirect-value-t<I2>> &&
80
+ strict_weak_order<F&, indirect-value-t<I1>, iter_reference_t<I2>> &&
81
+ strict_weak_order<F&, iter_reference_t<I1>, indirect-value-t<I2>> &&
82
  strict_weak_order<F&, iter_reference_t<I1>, iter_reference_t<I2>> &&
83
  strict_weak_order<F&, iter_common_reference_t<I1>, iter_common_reference_t<I2>>;
84
  }
85
  ```
86
 
87
  #### Class template `projected` <a id="projected">[[projected]]</a>
88
 
89
  Class template `projected` is used to constrain algorithms that accept
90
+ callable objects and projections [[defns.projection]]. It combines an
91
  `indirectly_readable` type `I` and a callable object type `Proj` into a
92
  new `indirectly_readable` type whose `reference` type is the result of
93
  applying `Proj` to the `iter_reference_t` of `I`.
94
 
95
  ``` cpp