From Jason Turner

[meta.type.synop]

C++20 → C++23 18.1 KB 202 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/tmp4ev105rn/{from.md → to.md} +102 -92
tmp/tmp4ev105rn/{from.md → to.md} RENAMED
@@ -1,8 +1,9 @@
1
  ### Header `<type_traits>` synopsis <a id="meta.type.synop">[[meta.type.synop]]</a>
2
 
3
  ``` cpp
 
4
  namespace std {
5
  // [meta.help], helper class
6
  template<class T, T v> struct integral_constant;
7
 
8
  template<bool B>
@@ -49,10 +50,11 @@ namespace std {
49
 
50
  template<class T> struct is_signed;
51
  template<class T> struct is_unsigned;
52
  template<class T> struct is_bounded_array;
53
  template<class T> struct is_unbounded_array;
 
54
 
55
  template<class T, class... Args> struct is_constructible;
56
  template<class T> struct is_default_constructible;
57
  template<class T> struct is_copy_constructible;
58
  template<class T> struct is_move_constructible;
@@ -88,14 +90,19 @@ namespace std {
88
  template<class T, class U> struct is_nothrow_swappable_with;
89
  template<class T> struct is_nothrow_swappable;
90
 
91
  template<class T> struct is_nothrow_destructible;
92
 
 
 
93
  template<class T> struct has_virtual_destructor;
94
 
95
  template<class T> struct has_unique_object_representations;
96
 
 
 
 
97
  // [meta.unary.prop.query], type property queries
98
  template<class T> struct alignment_of;
99
  template<class T> struct rank;
100
  template<class T, unsigned I = 0> struct extent;
101
 
@@ -173,13 +180,10 @@ namespace std {
173
  template<class T>
174
  using add_pointer_t = typename add_pointer<T>::type;
175
 
176
  // [meta.trans.other], other transformations
177
  template<class T> struct type_identity;
178
- template<size_t Len, size_t Align = default-alignment> // see [meta.trans.other]
179
- struct aligned_storage;
180
- template<size_t Len, class... Types> struct aligned_union;
181
  template<class T> struct remove_cvref;
182
  template<class T> struct decay;
183
  template<bool, class T = void> struct enable_if;
184
  template<bool, class T, class F> struct conditional;
185
  template<class... T> struct common_type;
@@ -191,22 +195,18 @@ namespace std {
191
  template<class T> struct unwrap_reference;
192
  template<class T> struct unwrap_ref_decay;
193
 
194
  template<class T>
195
  using type_identity_t = typename type_identity<T>::type;
196
- template<size_t Len, size_t Align = default-alignment> // see [meta.trans.other]
197
- using aligned_storage_t = typename aligned_storage<Len, Align>::type;
198
- template<size_t Len, class... Types>
199
- using aligned_union_t = typename aligned_union<Len, Types...>::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>
@@ -225,194 +225,204 @@ namespace std {
225
  template<class... B> struct disjunction;
226
  template<class B> struct negation;
227
 
228
  // [meta.unary.cat], primary type categories
229
  template<class T>
230
- inline constexpr bool is_void_v = is_void<T>::value;
231
  template<class T>
232
- inline constexpr bool is_null_pointer_v = is_null_pointer<T>::value;
233
  template<class T>
234
- inline constexpr bool is_integral_v = is_integral<T>::value;
235
  template<class T>
236
- inline constexpr bool is_floating_point_v = is_floating_point<T>::value;
237
  template<class T>
238
- inline constexpr bool is_array_v = is_array<T>::value;
239
  template<class T>
240
- inline constexpr bool is_pointer_v = is_pointer<T>::value;
241
  template<class T>
242
- inline constexpr bool is_lvalue_reference_v = is_lvalue_reference<T>::value;
243
  template<class T>
244
- inline constexpr bool is_rvalue_reference_v = is_rvalue_reference<T>::value;
245
  template<class T>
246
- inline constexpr bool is_member_object_pointer_v = is_member_object_pointer<T>::value;
247
  template<class T>
248
- inline constexpr bool is_member_function_pointer_v = is_member_function_pointer<T>::value;
249
  template<class T>
250
- inline constexpr bool is_enum_v = is_enum<T>::value;
251
  template<class T>
252
- inline constexpr bool is_union_v = is_union<T>::value;
253
  template<class T>
254
- inline constexpr bool is_class_v = is_class<T>::value;
255
  template<class T>
256
- inline constexpr bool is_function_v = is_function<T>::value;
257
 
258
  // [meta.unary.comp], composite type categories
259
  template<class T>
260
- inline constexpr bool is_reference_v = is_reference<T>::value;
261
  template<class T>
262
- inline constexpr bool is_arithmetic_v = is_arithmetic<T>::value;
263
  template<class T>
264
- inline constexpr bool is_fundamental_v = is_fundamental<T>::value;
265
  template<class T>
266
- inline constexpr bool is_object_v = is_object<T>::value;
267
  template<class T>
268
- inline constexpr bool is_scalar_v = is_scalar<T>::value;
269
  template<class T>
270
- inline constexpr bool is_compound_v = is_compound<T>::value;
271
  template<class T>
272
- inline constexpr bool is_member_pointer_v = is_member_pointer<T>::value;
273
 
274
  // [meta.unary.prop], type properties
275
  template<class T>
276
- inline constexpr bool is_const_v = is_const<T>::value;
277
  template<class T>
278
- inline constexpr bool is_volatile_v = is_volatile<T>::value;
279
  template<class T>
280
- inline constexpr bool is_trivial_v = is_trivial<T>::value;
281
  template<class T>
282
- inline constexpr bool is_trivially_copyable_v = is_trivially_copyable<T>::value;
283
  template<class T>
284
- inline constexpr bool is_standard_layout_v = is_standard_layout<T>::value;
285
  template<class T>
286
- inline constexpr bool is_empty_v = is_empty<T>::value;
287
  template<class T>
288
- inline constexpr bool is_polymorphic_v = is_polymorphic<T>::value;
289
  template<class T>
290
- inline constexpr bool is_abstract_v = is_abstract<T>::value;
291
  template<class T>
292
- inline constexpr bool is_final_v = is_final<T>::value;
293
  template<class T>
294
- inline constexpr bool is_aggregate_v = is_aggregate<T>::value;
295
  template<class T>
296
- inline constexpr bool is_signed_v = is_signed<T>::value;
297
  template<class T>
298
- inline constexpr bool is_unsigned_v = is_unsigned<T>::value;
299
  template<class T>
300
- inline constexpr bool is_bounded_array_v = is_bounded_array<T>::value;
301
  template<class T>
302
- inline constexpr bool is_unbounded_array_v = is_unbounded_array<T>::value;
 
 
303
  template<class T, class... Args>
304
- inline constexpr bool is_constructible_v = is_constructible<T, Args...>::value;
305
  template<class T>
306
- inline constexpr bool is_default_constructible_v = is_default_constructible<T>::value;
307
  template<class T>
308
- inline constexpr bool is_copy_constructible_v = is_copy_constructible<T>::value;
309
  template<class T>
310
- inline constexpr bool is_move_constructible_v = is_move_constructible<T>::value;
311
  template<class T, class U>
312
- inline constexpr bool is_assignable_v = is_assignable<T, U>::value;
313
  template<class T>
314
- inline constexpr bool is_copy_assignable_v = is_copy_assignable<T>::value;
315
  template<class T>
316
- inline constexpr bool is_move_assignable_v = is_move_assignable<T>::value;
317
  template<class T, class U>
318
- inline constexpr bool is_swappable_with_v = is_swappable_with<T, U>::value;
319
  template<class T>
320
- inline constexpr bool is_swappable_v = is_swappable<T>::value;
321
  template<class T>
322
- inline constexpr bool is_destructible_v = is_destructible<T>::value;
323
  template<class T, class... Args>
324
- inline constexpr bool is_trivially_constructible_v
325
  = is_trivially_constructible<T, Args...>::value;
326
  template<class T>
327
- inline constexpr bool is_trivially_default_constructible_v
328
  = is_trivially_default_constructible<T>::value;
329
  template<class T>
330
- inline constexpr bool is_trivially_copy_constructible_v
331
  = is_trivially_copy_constructible<T>::value;
332
  template<class T>
333
- inline constexpr bool is_trivially_move_constructible_v
334
  = is_trivially_move_constructible<T>::value;
335
  template<class T, class U>
336
- inline constexpr bool is_trivially_assignable_v = is_trivially_assignable<T, U>::value;
337
  template<class T>
338
- inline constexpr bool is_trivially_copy_assignable_v
339
  = is_trivially_copy_assignable<T>::value;
340
  template<class T>
341
- inline constexpr bool is_trivially_move_assignable_v
342
  = is_trivially_move_assignable<T>::value;
343
  template<class T>
344
- inline constexpr bool is_trivially_destructible_v = is_trivially_destructible<T>::value;
345
  template<class T, class... Args>
346
- inline constexpr bool is_nothrow_constructible_v
347
  = is_nothrow_constructible<T, Args...>::value;
348
  template<class T>
349
- inline constexpr bool is_nothrow_default_constructible_v
350
  = is_nothrow_default_constructible<T>::value;
351
  template<class T>
352
- inline constexpr bool is_nothrow_copy_constructible_v
353
  = is_nothrow_copy_constructible<T>::value;
354
  template<class T>
355
- inline constexpr bool is_nothrow_move_constructible_v
356
  = is_nothrow_move_constructible<T>::value;
357
  template<class T, class U>
358
- inline constexpr bool is_nothrow_assignable_v = is_nothrow_assignable<T, U>::value;
359
  template<class T>
360
- inline constexpr bool is_nothrow_copy_assignable_v = is_nothrow_copy_assignable<T>::value;
361
  template<class T>
362
- inline constexpr bool is_nothrow_move_assignable_v = is_nothrow_move_assignable<T>::value;
363
  template<class T, class U>
364
- inline constexpr bool is_nothrow_swappable_with_v = is_nothrow_swappable_with<T, U>::value;
365
  template<class T>
366
- inline constexpr bool is_nothrow_swappable_v = is_nothrow_swappable<T>::value;
367
  template<class T>
368
- inline constexpr bool is_nothrow_destructible_v = is_nothrow_destructible<T>::value;
369
  template<class T>
370
- inline constexpr bool has_virtual_destructor_v = has_virtual_destructor<T>::value;
371
  template<class T>
372
- inline constexpr bool has_unique_object_representations_v
 
 
373
  = has_unique_object_representations<T>::value;
 
 
 
 
 
 
374
 
375
  // [meta.unary.prop.query], type property queries
376
  template<class T>
377
- inline constexpr size_t alignment_of_v = alignment_of<T>::value;
378
  template<class T>
379
- inline constexpr size_t rank_v = rank<T>::value;
380
  template<class T, unsigned I = 0>
381
- inline constexpr size_t extent_v = extent<T, I>::value;
382
 
383
  // [meta.rel], type relations
384
  template<class T, class U>
385
- inline constexpr bool is_same_v = is_same<T, U>::value;
386
  template<class Base, class Derived>
387
- inline constexpr bool is_base_of_v = is_base_of<Base, Derived>::value;
388
  template<class From, class To>
389
- inline constexpr bool is_convertible_v = is_convertible<From, To>::value;
390
  template<class From, class To>
391
- inline constexpr bool is_nothrow_convertible_v = is_nothrow_convertible<From, To>::value;
392
  template<class T, class U>
393
- inline constexpr bool is_layout_compatible_v = is_layout_compatible<T, U>::value;
394
  template<class Base, class Derived>
395
- inline constexpr bool is_pointer_interconvertible_base_of_v
396
  = is_pointer_interconvertible_base_of<Base, Derived>::value;
397
  template<class Fn, class... ArgTypes>
398
- inline constexpr bool is_invocable_v = is_invocable<Fn, ArgTypes...>::value;
399
  template<class R, class Fn, class... ArgTypes>
400
- inline constexpr bool is_invocable_r_v = is_invocable_r<R, Fn, ArgTypes...>::value;
401
  template<class Fn, class... ArgTypes>
402
- inline constexpr bool is_nothrow_invocable_v = is_nothrow_invocable<Fn, ArgTypes...>::value;
403
  template<class R, class Fn, class... ArgTypes>
404
- inline constexpr bool is_nothrow_invocable_r_v
405
  = is_nothrow_invocable_r<R, Fn, ArgTypes...>::value;
406
 
407
  // [meta.logical], logical operator traits
408
  template<class... B>
409
- inline constexpr bool conjunction_v = conjunction<B...>::value;
410
  template<class... B>
411
- inline constexpr bool disjunction_v = disjunction<B...>::value;
412
  template<class B>
413
- inline constexpr bool negation_v = negation<B>::value;
414
 
415
  // [meta.member], member relationships
416
  template<class S, class M>
417
  constexpr bool is_pointer_interconvertible_with_class(M S::*m) noexcept;
418
  template<class S1, class S2, class M1, class M2>
 
1
  ### Header `<type_traits>` synopsis <a id="meta.type.synop">[[meta.type.synop]]</a>
2
 
3
  ``` cpp
4
+ // all freestanding
5
  namespace std {
6
  // [meta.help], helper class
7
  template<class T, T v> struct integral_constant;
8
 
9
  template<bool B>
 
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;
55
+ template<class T> struct is_scoped_enum;
56
 
57
  template<class T, class... Args> struct is_constructible;
58
  template<class T> struct is_default_constructible;
59
  template<class T> struct is_copy_constructible;
60
  template<class T> struct is_move_constructible;
 
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
 
99
  template<class T> struct has_unique_object_representations;
100
 
101
+ template<class T, class U> struct reference_constructs_from_temporary;
102
+ template<class T, class U> struct reference_converts_from_temporary;
103
+
104
  // [meta.unary.prop.query], type property queries
105
  template<class T> struct alignment_of;
106
  template<class T> struct rank;
107
  template<class T, unsigned I = 0> struct extent;
108
 
 
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;
187
  template<bool, class T = void> struct enable_if;
188
  template<bool, class T, class F> struct conditional;
189
  template<class... T> struct common_type;
 
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>
 
225
  template<class... B> struct disjunction;
226
  template<class B> struct negation;
227
 
228
  // [meta.unary.cat], primary type categories
229
  template<class T>
230
+ constexpr bool is_void_v = is_void<T>::value;
231
  template<class T>
232
+ constexpr bool is_null_pointer_v = is_null_pointer<T>::value;
233
  template<class T>
234
+ constexpr bool is_integral_v = is_integral<T>::value;
235
  template<class T>
236
+ constexpr bool is_floating_point_v = is_floating_point<T>::value;
237
  template<class T>
238
+ constexpr bool is_array_v = is_array<T>::value;
239
  template<class T>
240
+ constexpr bool is_pointer_v = is_pointer<T>::value;
241
  template<class T>
242
+ constexpr bool is_lvalue_reference_v = is_lvalue_reference<T>::value;
243
  template<class T>
244
+ constexpr bool is_rvalue_reference_v = is_rvalue_reference<T>::value;
245
  template<class T>
246
+ constexpr bool is_member_object_pointer_v = is_member_object_pointer<T>::value;
247
  template<class T>
248
+ constexpr bool is_member_function_pointer_v = is_member_function_pointer<T>::value;
249
  template<class T>
250
+ constexpr bool is_enum_v = is_enum<T>::value;
251
  template<class T>
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>
262
+ constexpr bool is_arithmetic_v = is_arithmetic<T>::value;
263
  template<class T>
264
+ constexpr bool is_fundamental_v = is_fundamental<T>::value;
265
  template<class T>
266
+ constexpr bool is_object_v = is_object<T>::value;
267
  template<class T>
268
+ constexpr bool is_scalar_v = is_scalar<T>::value;
269
  template<class T>
270
+ constexpr bool is_compound_v = is_compound<T>::value;
271
  template<class T>
272
+ constexpr bool is_member_pointer_v = is_member_pointer<T>::value;
273
 
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>
288
+ constexpr bool is_polymorphic_v = is_polymorphic<T>::value;
289
  template<class T>
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>
300
+ constexpr bool is_bounded_array_v = is_bounded_array<T>::value;
301
  template<class T>
302
+ constexpr bool is_unbounded_array_v = is_unbounded_array<T>::value;
303
+ template<class T>
304
+ constexpr bool is_scoped_enum_v = is_scoped_enum<T>::value;
305
  template<class T, class... Args>
306
+ constexpr bool is_constructible_v = is_constructible<T, Args...>::value;
307
  template<class T>
308
+ constexpr bool is_default_constructible_v = is_default_constructible<T>::value;
309
  template<class T>
310
+ constexpr bool is_copy_constructible_v = is_copy_constructible<T>::value;
311
  template<class T>
312
+ constexpr bool is_move_constructible_v = is_move_constructible<T>::value;
313
  template<class T, class U>
314
+ constexpr bool is_assignable_v = is_assignable<T, U>::value;
315
  template<class T>
316
+ constexpr bool is_copy_assignable_v = is_copy_assignable<T>::value;
317
  template<class T>
318
+ constexpr bool is_move_assignable_v = is_move_assignable<T>::value;
319
  template<class T, class U>
320
+ constexpr bool is_swappable_with_v = is_swappable_with<T, U>::value;
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>
364
+ constexpr bool is_nothrow_move_assignable_v = is_nothrow_move_assignable<T>::value;
365
  template<class T, class U>
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;
378
+ template<class T, class U>
379
+ constexpr bool reference_constructs_from_temporary_v
380
+ = reference_constructs_from_temporary<T, U>::value;
381
+ template<class T, class U>
382
+ constexpr bool reference_converts_from_temporary_v
383
+ = reference_converts_from_temporary<T, U>::value;
384
 
385
  // [meta.unary.prop.query], type property queries
386
  template<class T>
387
+ constexpr size_t alignment_of_v = alignment_of<T>::value;
388
  template<class T>
389
+ constexpr size_t rank_v = rank<T>::value;
390
  template<class T, unsigned I = 0>
391
+ constexpr size_t extent_v = extent<T, I>::value;
392
 
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>
403
+ constexpr bool is_layout_compatible_v = is_layout_compatible<T, U>::value;
404
  template<class Base, class Derived>
405
+ constexpr bool is_pointer_interconvertible_base_of_v
406
  = is_pointer_interconvertible_base_of<Base, Derived>::value;
407
  template<class Fn, class... ArgTypes>
408
+ constexpr bool is_invocable_v = is_invocable<Fn, ArgTypes...>::value;
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>
421
+ constexpr bool disjunction_v = disjunction<B...>::value;
422
  template<class B>
423
+ constexpr bool negation_v = negation<B>::value;
424
 
425
  // [meta.member], member relationships
426
  template<class S, class M>
427
  constexpr bool is_pointer_interconvertible_with_class(M S::*m) noexcept;
428
  template<class S1, class S2, class M1, class M2>