From Jason Turner

[algorithms.results]

C++17 → C++20 4.5 KB 148 lines
Current Draft | LaTeX Source
Archived: C++17 | C++20
Markdown: C++17 | C++20
Explore in Adventure Game

Diff to HTML by rtfpessoa

Files changed (1) hide show
  1. tmp/tmp_3n10lkq/{from.md → to.md} +145 -0
tmp/tmp_3n10lkq/{from.md → to.md} RENAMED
@@ -0,0 +1,145 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ ## Algorithm result types <a id="algorithms.results">[[algorithms.results]]</a>
2
+
3
+ Each of the class templates specified in this subclause has the template
4
+ parameters, data members, and special members specified below, and has
5
+ no base classes or members other than those specified.
6
+
7
+ ``` cpp
8
+ namespace std::ranges {
9
+ template<class I, class F>
10
+ struct in_fun_result {
11
+ [[no_unique_address]] I in;
12
+ [[no_unique_address]] F fun;
13
+
14
+ template<class I2, class F2>
15
+ requires convertible_to<const I&, I2> && convertible_to<const F&, F2>
16
+ constexpr operator in_fun_result<I2, F2>() const & {
17
+ return {in, fun};
18
+ }
19
+
20
+ template<class I2, class F2>
21
+ requires convertible_to<I, I2> && convertible_to<F, F2>
22
+ constexpr operator in_fun_result<I2, F2>() && {
23
+ return {std::move(in), std::move(fun)};
24
+ }
25
+ };
26
+
27
+ template<class I1, class I2>
28
+ struct in_in_result {
29
+ [[no_unique_address]] I1 in1;
30
+ [[no_unique_address]] I2 in2;
31
+
32
+ template<class II1, class II2>
33
+ requires convertible_to<const I1&, II1> && convertible_to<const I2&, II2>
34
+ constexpr operator in_in_result<II1, II2>() const & {
35
+ return {in1, in2};
36
+ }
37
+
38
+ template<class II1, class II2>
39
+ requires convertible_to<I1, II1> && convertible_to<I2, II2>
40
+ constexpr operator in_in_result<II1, II2>() && {
41
+ return {std::move(in1), std::move(in2)};
42
+ }
43
+ };
44
+
45
+ template<class I, class O>
46
+ struct in_out_result {
47
+ [[no_unique_address]] I in;
48
+ [[no_unique_address]] O out;
49
+
50
+ template<class I2, class O2>
51
+ requires convertible_to<const I&, I2> && convertible_to<const O&, O2>
52
+ constexpr operator in_out_result<I2, O2>() const & {
53
+ return {in, out};
54
+ }
55
+
56
+ template<class I2, class O2>
57
+ requires convertible_to<I, I2> && convertible_to<O, O2>
58
+ constexpr operator in_out_result<I2, O2>() && {
59
+ return {std::move(in), std::move(out)};
60
+ }
61
+ };
62
+
63
+ template<class I1, class I2, class O>
64
+ struct in_in_out_result {
65
+ [[no_unique_address]] I1 in1;
66
+ [[no_unique_address]] I2 in2;
67
+ [[no_unique_address]] O out;
68
+
69
+ template<class II1, class II2, class OO>
70
+ requires convertible_to<const I1&, II1> &&
71
+ convertible_to<const I2&, II2> &&
72
+ convertible_to<const O&, OO>
73
+ constexpr operator in_in_out_result<II1, II2, OO>() const & {
74
+ return {in1, in2, out};
75
+ }
76
+
77
+ template<class II1, class II2, class OO>
78
+ requires convertible_to<I1, II1> &&
79
+ convertible_to<I2, II2> &&
80
+ convertible_to<O, OO>
81
+ constexpr operator in_in_out_result<II1, II2, OO>() && {
82
+ return {std::move(in1), std::move(in2), std::move(out)};
83
+ }
84
+ };
85
+
86
+ template<class I, class O1, class O2>
87
+ struct in_out_out_result {
88
+ [[no_unique_address]] I in;
89
+ [[no_unique_address]] O1 out1;
90
+ [[no_unique_address]] O2 out2;
91
+
92
+ template<class II, class OO1, class OO2>
93
+ requires convertible_to<const I&, II> &&
94
+ convertible_to<const O1&, OO1> &&
95
+ convertible_to<const O2&, OO2>
96
+ constexpr operator in_out_out_result<II, OO1, OO2>() const & {
97
+ return {in, out1, out2};
98
+ }
99
+
100
+ template<class II, class OO1, class OO2>
101
+ requires convertible_to<I, II> &&
102
+ convertible_to<O1, OO1> &&
103
+ convertible_to<O2, OO2>
104
+ constexpr operator in_out_out_result<II, OO1, OO2>() && {
105
+ return {std::move(in), std::move(out1), std::move(out2)};
106
+ }
107
+ };
108
+
109
+ template<class T>
110
+ struct min_max_result {
111
+ [[no_unique_address]] T min;
112
+ [[no_unique_address]] T max;
113
+
114
+ template<class T2>
115
+ requires convertible_to<const T&, T2>
116
+ constexpr operator min_max_result<T2>() const & {
117
+ return {min, max};
118
+ }
119
+
120
+ template<class T2>
121
+ requires convertible_to<T, T2>
122
+ constexpr operator min_max_result<T2>() && {
123
+ return {std::move(min), std::move(max)};
124
+ }
125
+ };
126
+
127
+ template<class I>
128
+ struct in_found_result {
129
+ [[no_unique_address]] I in;
130
+ bool found;
131
+
132
+ template<class I2>
133
+ requires convertible_to<const I&, I2>
134
+ constexpr operator in_found_result<I2>() const & {
135
+ return {in, found};
136
+ }
137
+ template<class I2>
138
+ requires convertible_to<I, I2>
139
+ constexpr operator in_found_result<I2>() && {
140
+ return {std::move(in), found};
141
+ }
142
+ };
143
+ }
144
+ ```
145
+