From Jason Turner

[meta.type.synop]

C++17 → C++20 21.0 KB 352 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/tmpv4xy6qm0/{from.md → to.md} +196 -151
tmp/tmpv4xy6qm0/{from.md → to.md} RENAMED
@@ -39,19 +39,20 @@ namespace std {
39
  template<class T> struct is_const;
40
  template<class T> struct is_volatile;
41
  template<class T> struct is_trivial;
42
  template<class T> struct is_trivially_copyable;
43
  template<class T> struct is_standard_layout;
44
- template <class T> struct is_pod;
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
 
54
  template<class T, class... Args> struct is_constructible;
55
  template<class T> struct is_default_constructible;
56
  template<class T> struct is_copy_constructible;
57
  template<class T> struct is_move_constructible;
@@ -100,10 +101,13 @@ namespace std {
100
 
101
  // [meta.rel], type relations
102
  template<class T, class U> struct is_same;
103
  template<class Base, class Derived> struct is_base_of;
104
  template<class From, class To> struct is_convertible;
 
 
 
105
 
106
  template<class Fn, class... ArgTypes> struct is_invocable;
107
  template<class R, class Fn, class... ArgTypes> struct is_invocable_r;
108
 
109
  template<class Fn, class... ArgTypes> struct is_nothrow_invocable;
@@ -168,213 +172,254 @@ namespace std {
168
  using remove_pointer_t = typename remove_pointer<T>::type;
169
  template<class T>
170
  using add_pointer_t = typename add_pointer<T>::type;
171
 
172
  // [meta.trans.other], other transformations
173
- template <size_t Len,
174
- size_t Align = default-alignment> // see [meta.trans.other]
175
  struct aligned_storage;
176
  template<size_t Len, class... Types> struct aligned_union;
 
177
  template<class T> struct decay;
178
  template<bool, class T = void> struct enable_if;
179
  template<bool, class T, class F> struct conditional;
180
  template<class... T> struct common_type;
 
 
 
181
  template<class T> struct underlying_type;
182
  template<class Fn, class... ArgTypes> struct invoke_result;
 
 
183
 
184
- template <size_t Len,
185
- size_t Align = default-alignment> // see [meta.trans.other]
 
186
  using aligned_storage_t = typename aligned_storage<Len, Align>::type;
187
  template<size_t Len, class... Types>
188
  using aligned_union_t = typename aligned_union<Len, Types...>::type;
 
 
189
  template<class T>
190
  using decay_t = typename decay<T>::type;
191
  template<bool b, class T = void>
192
  using enable_if_t = typename enable_if<b, T>::type;
193
  template<bool b, class T, class F>
194
  using conditional_t = typename conditional<b, T, F>::type;
195
  template<class... T>
196
  using common_type_t = typename common_type<T...>::type;
 
 
197
  template<class T>
198
  using underlying_type_t = typename underlying_type<T>::type;
199
  template<class Fn, class... ArgTypes>
200
  using invoke_result_t = typename invoke_result<Fn, ArgTypes...>::type;
 
 
 
 
201
  template<class...>
202
  using void_t = void;
203
 
204
  // [meta.logical], logical operator traits
205
  template<class... B> struct conjunction;
206
  template<class... B> struct disjunction;
207
  template<class B> struct negation;
208
 
209
  // [meta.unary.cat], primary type categories
210
- template <class T> inline constexpr bool is_void_v
211
- = is_void<T>::value;
212
- template <class T> inline constexpr bool is_null_pointer_v
213
- = is_null_pointer<T>::value;
214
- template <class T> inline constexpr bool is_integral_v
215
- = is_integral<T>::value;
216
- template <class T> inline constexpr bool is_floating_point_v
217
- = is_floating_point<T>::value;
218
- template <class T> inline constexpr bool is_array_v
219
- = is_array<T>::value;
220
- template <class T> inline constexpr bool is_pointer_v
221
- = is_pointer<T>::value;
222
- template <class T> inline constexpr bool is_lvalue_reference_v
223
- = is_lvalue_reference<T>::value;
224
- template <class T> inline constexpr bool is_rvalue_reference_v
225
- = is_rvalue_reference<T>::value;
226
- template <class T> inline constexpr bool is_member_object_pointer_v
227
- = is_member_object_pointer<T>::value;
228
- template <class T> inline constexpr bool is_member_function_pointer_v
229
- = is_member_function_pointer<T>::value;
230
- template <class T> inline constexpr bool is_enum_v
231
- = is_enum<T>::value;
232
- template <class T> inline constexpr bool is_union_v
233
- = is_union<T>::value;
234
- template <class T> inline constexpr bool is_class_v
235
- = is_class<T>::value;
236
- template <class T> inline constexpr bool is_function_v
237
- = is_function<T>::value;
238
 
239
  // [meta.unary.comp], composite type categories
240
- template <class T> inline constexpr bool is_reference_v
241
- = is_reference<T>::value;
242
- template <class T> inline constexpr bool is_arithmetic_v
243
- = is_arithmetic<T>::value;
244
- template <class T> inline constexpr bool is_fundamental_v
245
- = is_fundamental<T>::value;
246
- template <class T> inline constexpr bool is_object_v
247
- = is_object<T>::value;
248
- template <class T> inline constexpr bool is_scalar_v
249
- = is_scalar<T>::value;
250
- template <class T> inline constexpr bool is_compound_v
251
- = is_compound<T>::value;
252
- template <class T> inline constexpr bool is_member_pointer_v
253
- = is_member_pointer<T>::value;
254
 
255
  // [meta.unary.prop], type properties
256
- template <class T> inline constexpr bool is_const_v
257
- = is_const<T>::value;
258
- template <class T> inline constexpr bool is_volatile_v
259
- = is_volatile<T>::value;
260
- template <class T> inline constexpr bool is_trivial_v
261
- = is_trivial<T>::value;
262
- template <class T> inline constexpr bool is_trivially_copyable_v
263
- = is_trivially_copyable<T>::value;
264
- template <class T> inline constexpr bool is_standard_layout_v
265
- = is_standard_layout<T>::value;
266
- template <class T> inline constexpr bool is_pod_v
267
- = is_pod<T>::value;
268
- template <class T> inline constexpr bool is_empty_v
269
- = is_empty<T>::value;
270
- template <class T> inline constexpr bool is_polymorphic_v
271
- = is_polymorphic<T>::value;
272
- template <class T> inline constexpr bool is_abstract_v
273
- = is_abstract<T>::value;
274
- template <class T> inline constexpr bool is_final_v
275
- = is_final<T>::value;
276
- template <class T> inline constexpr bool is_aggregate_v
277
- = is_aggregate<T>::value;
278
- template <class T> inline constexpr bool is_signed_v
279
- = is_signed<T>::value;
280
- template <class T> inline constexpr bool is_unsigned_v
281
- = is_unsigned<T>::value;
282
- template <class T, class... Args> inline constexpr bool is_constructible_v
283
- = is_constructible<T, Args...>::value;
284
- template <class T> inline constexpr bool is_default_constructible_v
285
- = is_default_constructible<T>::value;
286
- template <class T> inline constexpr bool is_copy_constructible_v
287
- = is_copy_constructible<T>::value;
288
- template <class T> inline constexpr bool is_move_constructible_v
289
- = is_move_constructible<T>::value;
290
- template <class T, class U> inline constexpr bool is_assignable_v
291
- = is_assignable<T, U>::value;
292
- template <class T> inline constexpr bool is_copy_assignable_v
293
- = is_copy_assignable<T>::value;
294
- template <class T> inline constexpr bool is_move_assignable_v
295
- = is_move_assignable<T>::value;
296
- template <class T, class U> inline constexpr bool is_swappable_with_v
297
- = is_swappable_with<T, U>::value;
298
- template <class T> inline constexpr bool is_swappable_v
299
- = is_swappable<T>::value;
300
- template <class T> inline constexpr bool is_destructible_v
301
- = is_destructible<T>::value;
302
- template <class T, class... Args> inline constexpr bool is_trivially_constructible_v
 
 
 
303
  = is_trivially_constructible<T, Args...>::value;
304
- template <class T> inline constexpr bool is_trivially_default_constructible_v
 
305
  = is_trivially_default_constructible<T>::value;
306
- template <class T> inline constexpr bool is_trivially_copy_constructible_v
 
307
  = is_trivially_copy_constructible<T>::value;
308
- template <class T> inline constexpr bool is_trivially_move_constructible_v
 
309
  = is_trivially_move_constructible<T>::value;
310
- template <class T, class U> inline constexpr bool is_trivially_assignable_v
311
- = is_trivially_assignable<T, U>::value;
312
- template <class T> inline constexpr bool is_trivially_copy_assignable_v
 
313
  = is_trivially_copy_assignable<T>::value;
314
- template <class T> inline constexpr bool is_trivially_move_assignable_v
 
315
  = is_trivially_move_assignable<T>::value;
316
- template <class T> inline constexpr bool is_trivially_destructible_v
317
- = is_trivially_destructible<T>::value;
318
- template <class T, class... Args> inline constexpr bool is_nothrow_constructible_v
 
319
  = is_nothrow_constructible<T, Args...>::value;
320
- template <class T> inline constexpr bool is_nothrow_default_constructible_v
 
321
  = is_nothrow_default_constructible<T>::value;
322
- template <class T> inline constexpr bool is_nothrow_copy_constructible_v
 
323
  = is_nothrow_copy_constructible<T>::value;
324
- template <class T> inline constexpr bool is_nothrow_move_constructible_v
 
325
  = is_nothrow_move_constructible<T>::value;
326
- template <class T, class U> inline constexpr bool is_nothrow_assignable_v
327
- = is_nothrow_assignable<T, U>::value;
328
- template <class T> inline constexpr bool is_nothrow_copy_assignable_v
329
- = is_nothrow_copy_assignable<T>::value;
330
- template <class T> inline constexpr bool is_nothrow_move_assignable_v
331
- = is_nothrow_move_assignable<T>::value;
332
- template <class T, class U> inline constexpr bool is_nothrow_swappable_with_v
333
- = is_nothrow_swappable_with<T, U>::value;
334
- template <class T> inline constexpr bool is_nothrow_swappable_v
335
- = is_nothrow_swappable<T>::value;
336
- template <class T> inline constexpr bool is_nothrow_destructible_v
337
- = is_nothrow_destructible<T>::value;
338
- template <class T> inline constexpr bool has_virtual_destructor_v
339
- = has_virtual_destructor<T>::value;
340
- template <class T> inline constexpr bool has_unique_object_representations_v
 
341
  = has_unique_object_representations<T>::value;
342
 
343
  // [meta.unary.prop.query], type property queries
344
- template <class T> inline constexpr size_t alignment_of_v
345
- = alignment_of<T>::value;
346
- template <class T> inline constexpr size_t rank_v
347
- = rank<T>::value;
348
- template <class T, unsigned I = 0> inline constexpr size_t extent_v
349
- = extent<T, I>::value;
350
 
351
  // [meta.rel], type relations
352
- template <class T, class U> inline constexpr bool is_same_v
353
- = is_same<T, U>::value;
354
- template <class Base, class Derived> inline constexpr bool is_base_of_v
355
- = is_base_of<Base, Derived>::value;
356
- template <class From, class To> inline constexpr bool is_convertible_v
357
- = is_convertible<From, To>::value;
358
- template <class Fn, class... ArgTypes> inline constexpr bool is_invocable_v
359
- = is_invocable<Fn, ArgTypes...>::value;
360
- template <class R, class Fn, class... ArgTypes> inline constexpr bool is_invocable_r_v
361
- = is_invocable_r<R, Fn, ArgTypes...>::value;
362
- template <class Fn, class... ArgTypes> inline constexpr bool is_nothrow_invocable_v
363
- = is_nothrow_invocable<Fn, ArgTypes...>::value;
364
- template <class R, class Fn, class... ArgTypes> inline constexpr bool is_nothrow_invocable_r_v
 
 
 
 
 
 
 
 
365
  = is_nothrow_invocable_r<R, Fn, ArgTypes...>::value;
366
 
367
  // [meta.logical], logical operator traits
368
- template<class... B> inline constexpr bool conjunction_v = conjunction<B...>::value;
369
- template<class... B> inline constexpr bool disjunction_v = disjunction<B...>::value;
370
- template<class B> inline constexpr bool negation_v = negation<B>::value;
 
 
 
 
 
 
 
 
 
 
 
 
371
  }
372
  ```
373
 
374
- The behavior of a program that adds specializations for any of the
375
- templates defined in this subclause is undefined unless otherwise
376
- specified.
377
-
378
- Unless otherwise specified, an incomplete type may be used to
379
- instantiate a template in this subclause.
380
-
 
39
  template<class T> struct is_const;
40
  template<class T> struct is_volatile;
41
  template<class T> struct is_trivial;
42
  template<class T> struct is_trivially_copyable;
43
  template<class T> struct is_standard_layout;
 
44
  template<class T> struct is_empty;
45
  template<class T> struct is_polymorphic;
46
  template<class T> struct is_abstract;
47
  template<class T> struct is_final;
48
  template<class T> struct is_aggregate;
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;
 
101
 
102
  // [meta.rel], type relations
103
  template<class T, class U> struct is_same;
104
  template<class Base, class Derived> struct is_base_of;
105
  template<class From, class To> struct is_convertible;
106
+ template<class From, class To> struct is_nothrow_convertible;
107
+ template<class T, class U> struct is_layout_compatible;
108
+ template<class Base, class Derived> struct is_pointer_interconvertible_base_of;
109
 
110
  template<class Fn, class... ArgTypes> struct is_invocable;
111
  template<class R, class Fn, class... ArgTypes> struct is_invocable_r;
112
 
113
  template<class Fn, class... ArgTypes> struct is_nothrow_invocable;
 
172
  using remove_pointer_t = typename remove_pointer<T>::type;
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;
186
+ template<class T, class U, template<class> class TQual, template<class> class UQual>
187
+ struct basic_common_reference { };
188
+ template<class... T> struct common_reference;
189
  template<class T> struct underlying_type;
190
  template<class Fn, class... ArgTypes> struct invoke_result;
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>
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;
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>
419
+ constexpr bool is_corresponding_member(M1 S1::*m1, M2 S2::*m2) noexcept;
420
+
421
+ // [meta.const.eval], constant evaluation context
422
+ constexpr bool is_constant_evaluated() noexcept;
423
  }
424
  ```
425