From Jason Turner

[meta.type.synop]

C++23 → Trunk 16.3 KB 144 lines
Current Draft | LaTeX Source
Archived: C++23
Markdown: C++23 | Trunk
Explore in Adventure Game

Diff to HTML by rtfpessoa

Files changed (1) hide show
  1. tmp/tmp_uregduh/{from.md → to.md} +80 -47
tmp/tmp_uregduh/{from.md → to.md} RENAMED
@@ -9,10 +9,26 @@ namespace std {
9
  template<bool B>
10
  using bool_constant = integral_constant<bool, B>;
11
  using true_type = bool_constant<true>;
12
  using false_type = bool_constant<false>;
13
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
14
  // [meta.unary.cat], primary type categories
15
  template<class T> struct is_void;
16
  template<class T> struct is_null_pointer;
17
  template<class T> struct is_integral;
18
  template<class T> struct is_floating_point;
@@ -24,10 +40,11 @@ namespace std {
24
  template<class T> struct is_member_function_pointer;
25
  template<class T> struct is_enum;
26
  template<class T> struct is_union;
27
  template<class T> struct is_class;
28
  template<class T> struct is_function;
 
29
 
30
  // [meta.unary.comp], composite type categories
31
  template<class T> struct is_reference;
32
  template<class T> struct is_arithmetic;
33
  template<class T> struct is_fundamental;
@@ -37,18 +54,20 @@ namespace std {
37
  template<class T> struct is_member_pointer;
38
 
39
  // [meta.unary.prop], type properties
40
  template<class T> struct is_const;
41
  template<class T> struct is_volatile;
42
- template<class T> struct is_trivial;
43
  template<class T> struct is_trivially_copyable;
 
 
44
  template<class T> struct is_standard_layout;
45
  template<class T> struct is_empty;
46
  template<class T> struct is_polymorphic;
47
  template<class T> struct is_abstract;
48
  template<class T> struct is_final;
49
  template<class T> struct is_aggregate;
 
50
 
51
  template<class T> struct is_signed;
52
  template<class T> struct is_unsigned;
53
  template<class T> struct is_bounded_array;
54
  template<class T> struct is_unbounded_array;
@@ -89,10 +108,11 @@ namespace std {
89
 
90
  template<class T, class U> struct is_nothrow_swappable_with;
91
  template<class T> struct is_nothrow_swappable;
92
 
93
  template<class T> struct is_nothrow_destructible;
 
94
 
95
  template<class T> struct is_implicit_lifetime;
96
 
97
  template<class T> struct has_virtual_destructor;
98
 
@@ -107,10 +127,11 @@ namespace std {
107
  template<class T, unsigned I = 0> struct extent;
108
 
109
  // [meta.rel], type relations
110
  template<class T, class U> struct is_same;
111
  template<class Base, class Derived> struct is_base_of;
 
112
  template<class From, class To> struct is_convertible;
113
  template<class From, class To> struct is_nothrow_convertible;
114
  template<class T, class U> struct is_layout_compatible;
115
  template<class Base, class Derived> struct is_pointer_interconvertible_base_of;
116
 
@@ -118,69 +139,72 @@ namespace std {
118
  template<class R, class Fn, class... ArgTypes> struct is_invocable_r;
119
 
120
  template<class Fn, class... ArgTypes> struct is_nothrow_invocable;
121
  template<class R, class Fn, class... ArgTypes> struct is_nothrow_invocable_r;
122
 
 
 
 
123
  // [meta.trans.cv], const-volatile modifications
124
  template<class T> struct remove_const;
125
  template<class T> struct remove_volatile;
126
  template<class T> struct remove_cv;
127
  template<class T> struct add_const;
128
  template<class T> struct add_volatile;
129
  template<class T> struct add_cv;
130
 
131
  template<class T>
132
- using remove_const_t = typename remove_const<T>::type;
133
  template<class T>
134
- using remove_volatile_t = typename remove_volatile<T>::type;
135
  template<class T>
136
- using remove_cv_t = typename remove_cv<T>::type;
137
  template<class T>
138
- using add_const_t = typename add_const<T>::type;
139
  template<class T>
140
- using add_volatile_t = typename add_volatile<T>::type;
141
  template<class T>
142
- using add_cv_t = typename add_cv<T>::type;
143
 
144
  // [meta.trans.ref], reference modifications
145
  template<class T> struct remove_reference;
146
  template<class T> struct add_lvalue_reference;
147
  template<class T> struct add_rvalue_reference;
148
 
149
  template<class T>
150
- using remove_reference_t = typename remove_reference<T>::type;
151
  template<class T>
152
- using add_lvalue_reference_t = typename add_lvalue_reference<T>::type;
153
  template<class T>
154
- using add_rvalue_reference_t = typename add_rvalue_reference<T>::type;
155
 
156
  // [meta.trans.sign], sign modifications
157
  template<class T> struct make_signed;
158
  template<class T> struct make_unsigned;
159
 
160
  template<class T>
161
- using make_signed_t = typename make_signed<T>::type;
162
  template<class T>
163
- using make_unsigned_t = typename make_unsigned<T>::type;
164
 
165
  // [meta.trans.arr], array modifications
166
  template<class T> struct remove_extent;
167
  template<class T> struct remove_all_extents;
168
 
169
  template<class T>
170
- using remove_extent_t = typename remove_extent<T>::type;
171
  template<class T>
172
- using remove_all_extents_t = typename remove_all_extents<T>::type;
173
 
174
  // [meta.trans.ptr], pointer modifications
175
  template<class T> struct remove_pointer;
176
  template<class T> struct add_pointer;
177
 
178
  template<class T>
179
- using remove_pointer_t = typename remove_pointer<T>::type;
180
  template<class T>
181
- using add_pointer_t = typename add_pointer<T>::type;
182
 
183
  // [meta.trans.other], other transformations
184
  template<class T> struct type_identity;
185
  template<class T> struct remove_cvref;
186
  template<class T> struct decay;
@@ -190,35 +214,38 @@ namespace std {
190
  template<class T, class U, template<class> class TQual, template<class> class UQual>
191
  struct basic_common_reference { };
192
  template<class... T> struct common_reference;
193
  template<class T> struct underlying_type;
194
  template<class Fn, class... ArgTypes> struct invoke_result;
 
195
  template<class T> struct unwrap_reference;
196
  template<class T> struct unwrap_ref_decay;
197
 
198
  template<class T>
199
- using type_identity_t = typename type_identity<T>::type;
200
  template<class T>
201
- using remove_cvref_t = typename remove_cvref<T>::type;
202
  template<class T>
203
- using decay_t = typename decay<T>::type;
204
  template<bool B, class T = void>
205
- using enable_if_t = typename enable_if<B, T>::type;
206
  template<bool B, class T, class F>
207
- using conditional_t = typename conditional<B, T, F>::type;
208
  template<class... T>
209
- using common_type_t = typename common_type<T...>::type;
210
  template<class... T>
211
- using common_reference_t = typename common_reference<T...>::type;
212
  template<class T>
213
- using underlying_type_t = typename underlying_type<T>::type;
214
  template<class Fn, class... ArgTypes>
215
- using invoke_result_t = typename invoke_result<Fn, ArgTypes...>::type;
 
 
216
  template<class T>
217
- using unwrap_reference_t = typename unwrap_reference<T>::type;
218
  template<class T>
219
- using unwrap_ref_decay_t = typename unwrap_ref_decay<T>::type;
220
  template<class...>
221
  using void_t = void;
222
 
223
  // [meta.logical], logical operator traits
224
  template<class... B> struct conjunction;
@@ -252,10 +279,12 @@ namespace std {
252
  constexpr bool is_union_v = is_union<T>::value;
253
  template<class T>
254
  constexpr bool is_class_v = is_class<T>::value;
255
  template<class T>
256
  constexpr bool is_function_v = is_function<T>::value;
 
 
257
 
258
  // [meta.unary.comp], composite type categories
259
  template<class T>
260
  constexpr bool is_reference_v = is_reference<T>::value;
261
  template<class T>
@@ -274,14 +303,14 @@ namespace std {
274
  // [meta.unary.prop], type properties
275
  template<class T>
276
  constexpr bool is_const_v = is_const<T>::value;
277
  template<class T>
278
  constexpr bool is_volatile_v = is_volatile<T>::value;
279
- template<class T>
280
- constexpr bool is_trivial_v = is_trivial<T>::value;
281
  template<class T>
282
  constexpr bool is_trivially_copyable_v = is_trivially_copyable<T>::value;
 
 
283
  template<class T>
284
  constexpr bool is_standard_layout_v = is_standard_layout<T>::value;
285
  template<class T>
286
  constexpr bool is_empty_v = is_empty<T>::value;
287
  template<class T>
@@ -290,10 +319,12 @@ namespace std {
290
  constexpr bool is_abstract_v = is_abstract<T>::value;
291
  template<class T>
292
  constexpr bool is_final_v = is_final<T>::value;
293
  template<class T>
294
  constexpr bool is_aggregate_v = is_aggregate<T>::value;
 
 
295
  template<class T>
296
  constexpr bool is_signed_v = is_signed<T>::value;
297
  template<class T>
298
  constexpr bool is_unsigned_v = is_unsigned<T>::value;
299
  template<class T>
@@ -321,43 +352,35 @@ namespace std {
321
  template<class T>
322
  constexpr bool is_swappable_v = is_swappable<T>::value;
323
  template<class T>
324
  constexpr bool is_destructible_v = is_destructible<T>::value;
325
  template<class T, class... Args>
326
- constexpr bool is_trivially_constructible_v
327
- = is_trivially_constructible<T, Args...>::value;
328
  template<class T>
329
  constexpr bool is_trivially_default_constructible_v
330
  = is_trivially_default_constructible<T>::value;
331
  template<class T>
332
- constexpr bool is_trivially_copy_constructible_v
333
- = is_trivially_copy_constructible<T>::value;
334
  template<class T>
335
- constexpr bool is_trivially_move_constructible_v
336
- = is_trivially_move_constructible<T>::value;
337
  template<class T, class U>
338
  constexpr bool is_trivially_assignable_v = is_trivially_assignable<T, U>::value;
339
  template<class T>
340
- constexpr bool is_trivially_copy_assignable_v
341
- = is_trivially_copy_assignable<T>::value;
342
  template<class T>
343
- constexpr bool is_trivially_move_assignable_v
344
- = is_trivially_move_assignable<T>::value;
345
  template<class T>
346
  constexpr bool is_trivially_destructible_v = is_trivially_destructible<T>::value;
347
  template<class T, class... Args>
348
- constexpr bool is_nothrow_constructible_v
349
- = is_nothrow_constructible<T, Args...>::value;
350
  template<class T>
351
  constexpr bool is_nothrow_default_constructible_v
352
  = is_nothrow_default_constructible<T>::value;
353
  template<class T>
354
- constexpr bool is_nothrow_copy_constructible_v
355
- = is_nothrow_copy_constructible<T>::value;
356
  template<class T>
357
- constexpr bool is_nothrow_move_constructible_v
358
- = is_nothrow_move_constructible<T>::value;
359
  template<class T, class U>
360
  constexpr bool is_nothrow_assignable_v = is_nothrow_assignable<T, U>::value;
361
  template<class T>
362
  constexpr bool is_nothrow_copy_assignable_v = is_nothrow_copy_assignable<T>::value;
363
  template<class T>
@@ -366,12 +389,16 @@ namespace std {
366
  constexpr bool is_nothrow_swappable_with_v = is_nothrow_swappable_with<T, U>::value;
367
  template<class T>
368
  constexpr bool is_nothrow_swappable_v = is_nothrow_swappable<T>::value;
369
  template<class T>
370
  constexpr bool is_nothrow_destructible_v = is_nothrow_destructible<T>::value;
 
 
371
  template<class T>
372
  constexpr bool is_implicit_lifetime_v = is_implicit_lifetime<T>::value;
 
 
373
  template<class T>
374
  constexpr bool has_virtual_destructor_v = has_virtual_destructor<T>::value;
375
  template<class T>
376
  constexpr bool has_unique_object_representations_v
377
  = has_unique_object_representations<T>::value;
@@ -393,10 +420,12 @@ namespace std {
393
  // [meta.rel], type relations
394
  template<class T, class U>
395
  constexpr bool is_same_v = is_same<T, U>::value;
396
  template<class Base, class Derived>
397
  constexpr bool is_base_of_v = is_base_of<Base, Derived>::value;
 
 
398
  template<class From, class To>
399
  constexpr bool is_convertible_v = is_convertible<From, To>::value;
400
  template<class From, class To>
401
  constexpr bool is_nothrow_convertible_v = is_nothrow_convertible<From, To>::value;
402
  template<class T, class U>
@@ -409,12 +438,15 @@ namespace std {
409
  template<class R, class Fn, class... ArgTypes>
410
  constexpr bool is_invocable_r_v = is_invocable_r<R, Fn, ArgTypes...>::value;
411
  template<class Fn, class... ArgTypes>
412
  constexpr bool is_nothrow_invocable_v = is_nothrow_invocable<Fn, ArgTypes...>::value;
413
  template<class R, class Fn, class... ArgTypes>
414
- constexpr bool is_nothrow_invocable_r_v
415
- = is_nothrow_invocable_r<R, Fn, ArgTypes...>::value;
 
 
 
416
 
417
  // [meta.logical], logical operator traits
418
  template<class... B>
419
  constexpr bool conjunction_v = conjunction<B...>::value;
420
  template<class... B>
@@ -428,8 +460,9 @@ namespace std {
428
  template<class S1, class S2, class M1, class M2>
429
  constexpr bool is_corresponding_member(M1 S1::*m1, M2 S2::*m2) noexcept;
430
 
431
  // [meta.const.eval], constant evaluation context
432
  constexpr bool is_constant_evaluated() noexcept;
 
433
  }
434
  ```
435
 
 
9
  template<bool B>
10
  using bool_constant = integral_constant<bool, B>;
11
  using true_type = bool_constant<true>;
12
  using false_type = bool_constant<false>;
13
 
14
+ // [const.wrap.class], class template constant_wrapper
15
+ template<class T>
16
+ struct cw-fixed-value; // exposition only
17
+
18
+ template<cw-fixed-value X, class = typename decltype(X)::type>
19
+ struct constant_wrapper;
20
+
21
+ template<class T>
22
+ concept constexpr-param = // exposition only
23
+ requires { typename constant_wrapper<T::value>; };
24
+
25
+ struct cw-operators; // exposition only
26
+
27
+ template<cw-fixed-value X>
28
+ constexpr auto cw = constant_wrapper<X>{};
29
+
30
  // [meta.unary.cat], primary type categories
31
  template<class T> struct is_void;
32
  template<class T> struct is_null_pointer;
33
  template<class T> struct is_integral;
34
  template<class T> struct is_floating_point;
 
40
  template<class T> struct is_member_function_pointer;
41
  template<class T> struct is_enum;
42
  template<class T> struct is_union;
43
  template<class T> struct is_class;
44
  template<class T> struct is_function;
45
+ template<class T> struct is_reflection;
46
 
47
  // [meta.unary.comp], composite type categories
48
  template<class T> struct is_reference;
49
  template<class T> struct is_arithmetic;
50
  template<class T> struct is_fundamental;
 
54
  template<class T> struct is_member_pointer;
55
 
56
  // [meta.unary.prop], type properties
57
  template<class T> struct is_const;
58
  template<class T> struct is_volatile;
 
59
  template<class T> struct is_trivially_copyable;
60
+ template<class T> struct is_trivially_relocatable;
61
+ template<class T> struct is_replaceable;
62
  template<class T> struct is_standard_layout;
63
  template<class T> struct is_empty;
64
  template<class T> struct is_polymorphic;
65
  template<class T> struct is_abstract;
66
  template<class T> struct is_final;
67
  template<class T> struct is_aggregate;
68
+ template<class T> struct is_consteval_only;
69
 
70
  template<class T> struct is_signed;
71
  template<class T> struct is_unsigned;
72
  template<class T> struct is_bounded_array;
73
  template<class T> struct is_unbounded_array;
 
108
 
109
  template<class T, class U> struct is_nothrow_swappable_with;
110
  template<class T> struct is_nothrow_swappable;
111
 
112
  template<class T> struct is_nothrow_destructible;
113
+ template<class T> struct is_nothrow_relocatable;
114
 
115
  template<class T> struct is_implicit_lifetime;
116
 
117
  template<class T> struct has_virtual_destructor;
118
 
 
127
  template<class T, unsigned I = 0> struct extent;
128
 
129
  // [meta.rel], type relations
130
  template<class T, class U> struct is_same;
131
  template<class Base, class Derived> struct is_base_of;
132
+ template<class Base, class Derived> struct is_virtual_base_of;
133
  template<class From, class To> struct is_convertible;
134
  template<class From, class To> struct is_nothrow_convertible;
135
  template<class T, class U> struct is_layout_compatible;
136
  template<class Base, class Derived> struct is_pointer_interconvertible_base_of;
137
 
 
139
  template<class R, class Fn, class... ArgTypes> struct is_invocable_r;
140
 
141
  template<class Fn, class... ArgTypes> struct is_nothrow_invocable;
142
  template<class R, class Fn, class... ArgTypes> struct is_nothrow_invocable_r;
143
 
144
+ template<class Fn, class Tuple> struct is_applicable;
145
+ template<class Fn, class Tuple> struct is_nothrow_applicable;
146
+
147
  // [meta.trans.cv], const-volatile modifications
148
  template<class T> struct remove_const;
149
  template<class T> struct remove_volatile;
150
  template<class T> struct remove_cv;
151
  template<class T> struct add_const;
152
  template<class T> struct add_volatile;
153
  template<class T> struct add_cv;
154
 
155
  template<class T>
156
+ using remove_const_t = remove_const<T>::type;
157
  template<class T>
158
+ using remove_volatile_t = remove_volatile<T>::type;
159
  template<class T>
160
+ using remove_cv_t = remove_cv<T>::type;
161
  template<class T>
162
+ using add_const_t = add_const<T>::type;
163
  template<class T>
164
+ using add_volatile_t = add_volatile<T>::type;
165
  template<class T>
166
+ using add_cv_t = add_cv<T>::type;
167
 
168
  // [meta.trans.ref], reference modifications
169
  template<class T> struct remove_reference;
170
  template<class T> struct add_lvalue_reference;
171
  template<class T> struct add_rvalue_reference;
172
 
173
  template<class T>
174
+ using remove_reference_t = remove_reference<T>::type;
175
  template<class T>
176
+ using add_lvalue_reference_t = add_lvalue_reference<T>::type;
177
  template<class T>
178
+ using add_rvalue_reference_t = add_rvalue_reference<T>::type;
179
 
180
  // [meta.trans.sign], sign modifications
181
  template<class T> struct make_signed;
182
  template<class T> struct make_unsigned;
183
 
184
  template<class T>
185
+ using make_signed_t = make_signed<T>::type;
186
  template<class T>
187
+ using make_unsigned_t = make_unsigned<T>::type;
188
 
189
  // [meta.trans.arr], array modifications
190
  template<class T> struct remove_extent;
191
  template<class T> struct remove_all_extents;
192
 
193
  template<class T>
194
+ using remove_extent_t = remove_extent<T>::type;
195
  template<class T>
196
+ using remove_all_extents_t = remove_all_extents<T>::type;
197
 
198
  // [meta.trans.ptr], pointer modifications
199
  template<class T> struct remove_pointer;
200
  template<class T> struct add_pointer;
201
 
202
  template<class T>
203
+ using remove_pointer_t = remove_pointer<T>::type;
204
  template<class T>
205
+ using add_pointer_t = add_pointer<T>::type;
206
 
207
  // [meta.trans.other], other transformations
208
  template<class T> struct type_identity;
209
  template<class T> struct remove_cvref;
210
  template<class T> struct decay;
 
214
  template<class T, class U, template<class> class TQual, template<class> class UQual>
215
  struct basic_common_reference { };
216
  template<class... T> struct common_reference;
217
  template<class T> struct underlying_type;
218
  template<class Fn, class... ArgTypes> struct invoke_result;
219
+ template<class Fn, class Tuple> struct apply_result;
220
  template<class T> struct unwrap_reference;
221
  template<class T> struct unwrap_ref_decay;
222
 
223
  template<class T>
224
+ using type_identity_t = type_identity<T>::type;
225
  template<class T>
226
+ using remove_cvref_t = remove_cvref<T>::type;
227
  template<class T>
228
+ using decay_t = decay<T>::type;
229
  template<bool B, class T = void>
230
+ using enable_if_t = enable_if<B, T>::type;
231
  template<bool B, class T, class F>
232
+ using conditional_t = conditional<B, T, F>::type;
233
  template<class... T>
234
+ using common_type_t = common_type<T...>::type;
235
  template<class... T>
236
+ using common_reference_t = common_reference<T...>::type;
237
  template<class T>
238
+ using underlying_type_t = underlying_type<T>::type;
239
  template<class Fn, class... ArgTypes>
240
+ using invoke_result_t = invoke_result<Fn, ArgTypes...>::type;
241
+ template<class Fn, class Tuple>
242
+ using apply_result_t = apply_result<Fn, Tuple>::type;
243
  template<class T>
244
+ using unwrap_reference_t = unwrap_reference<T>::type;
245
  template<class T>
246
+ using unwrap_ref_decay_t = unwrap_ref_decay<T>::type;
247
  template<class...>
248
  using void_t = void;
249
 
250
  // [meta.logical], logical operator traits
251
  template<class... B> struct conjunction;
 
279
  constexpr bool is_union_v = is_union<T>::value;
280
  template<class T>
281
  constexpr bool is_class_v = is_class<T>::value;
282
  template<class T>
283
  constexpr bool is_function_v = is_function<T>::value;
284
+ template<class T>
285
+ constexpr bool is_reflection_v = is_reflection<T>::value;
286
 
287
  // [meta.unary.comp], composite type categories
288
  template<class T>
289
  constexpr bool is_reference_v = is_reference<T>::value;
290
  template<class T>
 
303
  // [meta.unary.prop], type properties
304
  template<class T>
305
  constexpr bool is_const_v = is_const<T>::value;
306
  template<class T>
307
  constexpr bool is_volatile_v = is_volatile<T>::value;
 
 
308
  template<class T>
309
  constexpr bool is_trivially_copyable_v = is_trivially_copyable<T>::value;
310
+ template<class T>
311
+ constexpr bool is_trivially_relocatable_v = is_trivially_relocatable<T>::value;
312
  template<class T>
313
  constexpr bool is_standard_layout_v = is_standard_layout<T>::value;
314
  template<class T>
315
  constexpr bool is_empty_v = is_empty<T>::value;
316
  template<class T>
 
319
  constexpr bool is_abstract_v = is_abstract<T>::value;
320
  template<class T>
321
  constexpr bool is_final_v = is_final<T>::value;
322
  template<class T>
323
  constexpr bool is_aggregate_v = is_aggregate<T>::value;
324
+ template<class T>
325
+ constexpr bool is_consteval_only_v = is_consteval_only<T>::value;
326
  template<class T>
327
  constexpr bool is_signed_v = is_signed<T>::value;
328
  template<class T>
329
  constexpr bool is_unsigned_v = is_unsigned<T>::value;
330
  template<class T>
 
352
  template<class T>
353
  constexpr bool is_swappable_v = is_swappable<T>::value;
354
  template<class T>
355
  constexpr bool is_destructible_v = is_destructible<T>::value;
356
  template<class T, class... Args>
357
+ constexpr bool is_trivially_constructible_v = is_trivially_constructible<T, Args...>::value;
 
358
  template<class T>
359
  constexpr bool is_trivially_default_constructible_v
360
  = is_trivially_default_constructible<T>::value;
361
  template<class T>
362
+ constexpr bool is_trivially_copy_constructible_v = is_trivially_copy_constructible<T>::value;
 
363
  template<class T>
364
+ constexpr bool is_trivially_move_constructible_v = is_trivially_move_constructible<T>::value;
 
365
  template<class T, class U>
366
  constexpr bool is_trivially_assignable_v = is_trivially_assignable<T, U>::value;
367
  template<class T>
368
+ constexpr bool is_trivially_copy_assignable_v = is_trivially_copy_assignable<T>::value;
 
369
  template<class T>
370
+ constexpr bool is_trivially_move_assignable_v = is_trivially_move_assignable<T>::value;
 
371
  template<class T>
372
  constexpr bool is_trivially_destructible_v = is_trivially_destructible<T>::value;
373
  template<class T, class... Args>
374
+ constexpr bool is_nothrow_constructible_v = is_nothrow_constructible<T, Args...>::value;
 
375
  template<class T>
376
  constexpr bool is_nothrow_default_constructible_v
377
  = is_nothrow_default_constructible<T>::value;
378
  template<class T>
379
+ constexpr bool is_nothrow_copy_constructible_v = is_nothrow_copy_constructible<T>::value;
 
380
  template<class T>
381
+ constexpr bool is_nothrow_move_constructible_v = is_nothrow_move_constructible<T>::value;
 
382
  template<class T, class U>
383
  constexpr bool is_nothrow_assignable_v = is_nothrow_assignable<T, U>::value;
384
  template<class T>
385
  constexpr bool is_nothrow_copy_assignable_v = is_nothrow_copy_assignable<T>::value;
386
  template<class T>
 
389
  constexpr bool is_nothrow_swappable_with_v = is_nothrow_swappable_with<T, U>::value;
390
  template<class T>
391
  constexpr bool is_nothrow_swappable_v = is_nothrow_swappable<T>::value;
392
  template<class T>
393
  constexpr bool is_nothrow_destructible_v = is_nothrow_destructible<T>::value;
394
+ template<class T>
395
+ constexpr bool is_nothrow_relocatable_v = is_nothrow_relocatable<T>::value;
396
  template<class T>
397
  constexpr bool is_implicit_lifetime_v = is_implicit_lifetime<T>::value;
398
+ template<class T>
399
+ constexpr bool is_replaceable_v = is_replaceable<T>::value;
400
  template<class T>
401
  constexpr bool has_virtual_destructor_v = has_virtual_destructor<T>::value;
402
  template<class T>
403
  constexpr bool has_unique_object_representations_v
404
  = has_unique_object_representations<T>::value;
 
420
  // [meta.rel], type relations
421
  template<class T, class U>
422
  constexpr bool is_same_v = is_same<T, U>::value;
423
  template<class Base, class Derived>
424
  constexpr bool is_base_of_v = is_base_of<Base, Derived>::value;
425
+ template<class Base, class Derived>
426
+ constexpr bool is_virtual_base_of_v = is_virtual_base_of<Base, Derived>::value;
427
  template<class From, class To>
428
  constexpr bool is_convertible_v = is_convertible<From, To>::value;
429
  template<class From, class To>
430
  constexpr bool is_nothrow_convertible_v = is_nothrow_convertible<From, To>::value;
431
  template<class T, class U>
 
438
  template<class R, class Fn, class... ArgTypes>
439
  constexpr bool is_invocable_r_v = is_invocable_r<R, Fn, ArgTypes...>::value;
440
  template<class Fn, class... ArgTypes>
441
  constexpr bool is_nothrow_invocable_v = is_nothrow_invocable<Fn, ArgTypes...>::value;
442
  template<class R, class Fn, class... ArgTypes>
443
+ constexpr bool is_nothrow_invocable_r_v = is_nothrow_invocable_r<R, Fn, ArgTypes...>::value;
444
+ template<class Fn, class Tuple>
445
+ constexpr bool is_applicable_v = is_applicable<Fn, Tuple>::value;
446
+ template<class Fn, class Tuple>
447
+ constexpr bool is_nothrow_applicable_v = is_nothrow_applicable<Fn, Tuple>::value;
448
 
449
  // [meta.logical], logical operator traits
450
  template<class... B>
451
  constexpr bool conjunction_v = conjunction<B...>::value;
452
  template<class... B>
 
460
  template<class S1, class S2, class M1, class M2>
461
  constexpr bool is_corresponding_member(M1 S1::*m1, M2 S2::*m2) noexcept;
462
 
463
  // [meta.const.eval], constant evaluation context
464
  constexpr bool is_constant_evaluated() noexcept;
465
+ consteval bool is_within_lifetime(const auto*) noexcept;
466
  }
467
  ```
468