From Jason Turner

[stdbit.h.syn]

Diff to HTML by rtfpessoa

Files changed (1) hide show
  1. tmp/tmpndlis_86/{from.md → to.md} +432 -0
tmp/tmpndlis_86/{from.md → to.md} RENAMED
@@ -0,0 +1,432 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ ## Header `<stdbit.h>` synopsis <a id="stdbit.h.syn">[[stdbit.h.syn]]</a>
2
+
3
+ ``` cpp
4
+ // all freestanding
5
+
6
+ #define __STDC_VERSION_STDBIT_H__ 202311L
7
+
8
+ #define __STDC_ENDIAN_BIG__ see below
9
+ #define __STDC_ENDIAN_LITTLE__ see below
10
+ #define __STDC_ENDIAN_NATIVE__ see below
11
+
12
+ unsigned int stdc_leading_zeros_uc(unsigned char value);
13
+ unsigned int stdc_leading_zeros_us(unsigned short value);
14
+ unsigned int stdc_leading_zeros_ui(unsigned int value);
15
+ unsigned int stdc_leading_zeros_ul(unsigned long int value);
16
+ unsigned int stdc_leading_zeros_ull(unsigned long long int value);
17
+ template<class T> see below stdc_leading_zeros(T value);
18
+
19
+ unsigned int stdc_leading_ones_uc(unsigned char value);
20
+ unsigned int stdc_leading_ones_us(unsigned short value);
21
+ unsigned int stdc_leading_ones_ui(unsigned int value);
22
+ unsigned int stdc_leading_ones_ul(unsigned long int value);
23
+ unsigned int stdc_leading_ones_ull(unsigned long long int value);
24
+ template<class T> see below stdc_leading_ones(T value);
25
+
26
+ unsigned int stdc_trailing_zeros_uc(unsigned char value);
27
+ unsigned int stdc_trailing_zeros_us(unsigned short value);
28
+ unsigned int stdc_trailing_zeros_ui(unsigned int value);
29
+ unsigned int stdc_trailing_zeros_ul(unsigned long int value);
30
+ unsigned int stdc_trailing_zeros_ull(unsigned long long int value);
31
+ template<class T> see below stdc_trailing_zeros(T value);
32
+
33
+ unsigned int stdc_trailing_ones_uc(unsigned char value);
34
+ unsigned int stdc_trailing_ones_us(unsigned short value);
35
+ unsigned int stdc_trailing_ones_ui(unsigned int value);
36
+ unsigned int stdc_trailing_ones_ul(unsigned long int value);
37
+ unsigned int stdc_trailing_ones_ull(unsigned long long int value);
38
+ template<class T> see below stdc_trailing_ones(T value);
39
+
40
+ unsigned int stdc_first_leading_zero_uc(unsigned char value);
41
+ unsigned int stdc_first_leading_zero_us(unsigned short value);
42
+ unsigned int stdc_first_leading_zero_ui(unsigned int value);
43
+ unsigned int stdc_first_leading_zero_ul(unsigned long int value);
44
+ unsigned int stdc_first_leading_zero_ull(unsigned long long int value);
45
+ template<class T> see below stdc_first_leading_zero(T value);
46
+
47
+ unsigned int stdc_first_leading_one_uc(unsigned char value);
48
+ unsigned int stdc_first_leading_one_us(unsigned short value);
49
+ unsigned int stdc_first_leading_one_ui(unsigned int value);
50
+ unsigned int stdc_first_leading_one_ul(unsigned long int value);
51
+ unsigned int stdc_first_leading_one_ull(unsigned long long int value);
52
+ template<class T> see below stdc_first_leading_one(T value);
53
+
54
+ unsigned int stdc_first_trailing_zero_uc(unsigned char value);
55
+ unsigned int stdc_first_trailing_zero_us(unsigned short value);
56
+ unsigned int stdc_first_trailing_zero_ui(unsigned int value);
57
+ unsigned int stdc_first_trailing_zero_ul(unsigned long int value);
58
+ unsigned int stdc_first_trailing_zero_ull(unsigned long long int value);
59
+ template<class T> see below stdc_first_trailing_zero(T value);
60
+
61
+ unsigned int stdc_first_trailing_one_uc(unsigned char value);
62
+ unsigned int stdc_first_trailing_one_us(unsigned short value);
63
+ unsigned int stdc_first_trailing_one_ui(unsigned int value);
64
+ unsigned int stdc_first_trailing_one_ul(unsigned long int value);
65
+ unsigned int stdc_first_trailing_one_ull(unsigned long long int value);
66
+ template<class T> see below stdc_first_trailing_one(T value);
67
+
68
+ unsigned int stdc_count_zeros_uc(unsigned char value);
69
+ unsigned int stdc_count_zeros_us(unsigned short value);
70
+ unsigned int stdc_count_zeros_ui(unsigned int value);
71
+ unsigned int stdc_count_zeros_ul(unsigned long int value);
72
+ unsigned int stdc_count_zeros_ull(unsigned long long int value);
73
+ template<class T> see below stdc_count_zeros(T value);
74
+
75
+ unsigned int stdc_count_ones_uc(unsigned char value);
76
+ unsigned int stdc_count_ones_us(unsigned short value);
77
+ unsigned int stdc_count_ones_ui(unsigned int value);
78
+ unsigned int stdc_count_ones_ul(unsigned long int value);
79
+ unsigned int stdc_count_ones_ull(unsigned long long int value);
80
+ template<class T> see below stdc_count_ones(T value);
81
+
82
+ bool stdc_has_single_bit_uc(unsigned char value);
83
+ bool stdc_has_single_bit_us(unsigned short value);
84
+ bool stdc_has_single_bit_ui(unsigned int value);
85
+ bool stdc_has_single_bit_ul(unsigned long int value);
86
+ bool stdc_has_single_bit_ull(unsigned long long int value);
87
+ template<class T> bool stdc_has_single_bit(T value);
88
+
89
+ unsigned int stdc_bit_width_uc(unsigned char value);
90
+ unsigned int stdc_bit_width_us(unsigned short value);
91
+ unsigned int stdc_bit_width_ui(unsigned int value);
92
+ unsigned int stdc_bit_width_ul(unsigned long int value);
93
+ unsigned int stdc_bit_width_ull(unsigned long long int value);
94
+ template<class T> see below stdc_bit_width(T value);
95
+
96
+ unsigned char stdc_bit_floor_uc(unsigned char value);
97
+ unsigned short stdc_bit_floor_us(unsigned short value);
98
+ unsigned int stdc_bit_floor_ui(unsigned int value);
99
+ unsigned long int stdc_bit_floor_ul(unsigned long int value);
100
+ unsigned long long int stdc_bit_floor_ull(unsigned long long int value);
101
+ template<class T> T stdc_bit_floor(T value);
102
+
103
+ unsigned char stdc_bit_ceil_uc(unsigned char value);
104
+ unsigned short stdc_bit_ceil_us(unsigned short value);
105
+ unsigned int stdc_bit_ceil_ui(unsigned int value);
106
+ unsigned long int stdc_bit_ceil_ul(unsigned long int value);
107
+ unsigned long long int stdc_bit_ceil_ull(unsigned long long int value);
108
+ template<class T> T stdc_bit_ceil(T value);
109
+ ```
110
+
111
+ For a function template whose return type is not specified above, the
112
+ return type is an *implementation-defined* unsigned integer type large
113
+ enough to represent all possible result values. Each function template
114
+ has the same semantics as the corresponding type-generic function with
115
+ the same name specified in See also: ISO C 7.18.
116
+
117
+ *Mandates:* `T` is an unsigned integer type.
118
+
119
+ Otherwise, the contents and meaning of the header `<stdbit.h>` are the
120
+ same as the C standard library header `<stdbit.h>`.
121
+
122
+ See also: ISO C 7.18
123
+
124
+ <!-- Link reference definitions -->
125
+ [algorithms]: algorithms.md#algorithms
126
+ [algorithms.general]: algorithms.md#algorithms.general
127
+ [allocator.requirements.general]: library.md#allocator.requirements.general
128
+ [allocator.uses.construction]: mem.md#allocator.uses.construction
129
+ [any]: #any
130
+ [any.assign]: #any.assign
131
+ [any.bad.any.cast]: #any.bad.any.cast
132
+ [any.class]: #any.class
133
+ [any.class.general]: #any.class.general
134
+ [any.cons]: #any.cons
135
+ [any.general]: #any.general
136
+ [any.modifiers]: #any.modifiers
137
+ [any.nonmembers]: #any.nonmembers
138
+ [any.observers]: #any.observers
139
+ [any.synop]: #any.synop
140
+ [arithmetic.operations]: #arithmetic.operations
141
+ [arithmetic.operations.divides]: #arithmetic.operations.divides
142
+ [arithmetic.operations.general]: #arithmetic.operations.general
143
+ [arithmetic.operations.minus]: #arithmetic.operations.minus
144
+ [arithmetic.operations.modulus]: #arithmetic.operations.modulus
145
+ [arithmetic.operations.multiplies]: #arithmetic.operations.multiplies
146
+ [arithmetic.operations.negate]: #arithmetic.operations.negate
147
+ [arithmetic.operations.plus]: #arithmetic.operations.plus
148
+ [basic.fundamental]: basic.md#basic.fundamental
149
+ [basic.indet]: basic.md#basic.indet
150
+ [basic.lookup.argdep]: basic.md#basic.lookup.argdep
151
+ [basic.types.general]: basic.md#basic.types.general
152
+ [bit]: #bit
153
+ [bit.byteswap]: #bit.byteswap
154
+ [bit.cast]: #bit.cast
155
+ [bit.count]: #bit.count
156
+ [bit.endian]: #bit.endian
157
+ [bit.general]: #bit.general
158
+ [bit.pow.two]: #bit.pow.two
159
+ [bit.rotate]: #bit.rotate
160
+ [bit.syn]: #bit.syn
161
+ [bitset]: #bitset
162
+ [bitset.cons]: #bitset.cons
163
+ [bitset.hash]: #bitset.hash
164
+ [bitset.members]: #bitset.members
165
+ [bitset.operators]: #bitset.operators
166
+ [bitset.syn]: #bitset.syn
167
+ [bitwise.operations]: #bitwise.operations
168
+ [bitwise.operations.and]: #bitwise.operations.and
169
+ [bitwise.operations.general]: #bitwise.operations.general
170
+ [bitwise.operations.not]: #bitwise.operations.not
171
+ [bitwise.operations.or]: #bitwise.operations.or
172
+ [bitwise.operations.xor]: #bitwise.operations.xor
173
+ [class.base.init]: class.md#class.base.init
174
+ [class.copy.ctor]: class.md#class.copy.ctor
175
+ [comparisons]: #comparisons
176
+ [comparisons.equal.to]: #comparisons.equal.to
177
+ [comparisons.general]: #comparisons.general
178
+ [comparisons.greater]: #comparisons.greater
179
+ [comparisons.greater.equal]: #comparisons.greater.equal
180
+ [comparisons.less]: #comparisons.less
181
+ [comparisons.less.equal]: #comparisons.less.equal
182
+ [comparisons.not.equal.to]: #comparisons.not.equal.to
183
+ [comparisons.three.way]: #comparisons.three.way
184
+ [concepts.equality]: concepts.md#concepts.equality
185
+ [container.reqmts]: containers.md#container.reqmts
186
+ [cpp17.copyassignable]: #cpp17.copyassignable
187
+ [cpp17.defaultconstructible]: #cpp17.defaultconstructible
188
+ [cpp17.destructible]: #cpp17.destructible
189
+ [cpp17.hash]: #cpp17.hash
190
+ [cpp17.moveassignable]: #cpp17.moveassignable
191
+ [cpp17.moveconstructible]: #cpp17.moveconstructible
192
+ [dcl.constexpr]: dcl.md#dcl.constexpr
193
+ [dcl.init.general]: dcl.md#dcl.init.general
194
+ [declval]: #declval
195
+ [defns.expression.equivalent]: intro.md#defns.expression.equivalent
196
+ [defns.order.ptr]: #defns.order.ptr
197
+ [defns.referenceable]: intro.md#defns.referenceable
198
+ [expected]: #expected
199
+ [expected.bad]: #expected.bad
200
+ [expected.bad.void]: #expected.bad.void
201
+ [expected.expected]: #expected.expected
202
+ [expected.general]: #expected.general
203
+ [expected.object.assign]: #expected.object.assign
204
+ [expected.object.cons]: #expected.object.cons
205
+ [expected.object.dtor]: #expected.object.dtor
206
+ [expected.object.eq]: #expected.object.eq
207
+ [expected.object.general]: #expected.object.general
208
+ [expected.object.monadic]: #expected.object.monadic
209
+ [expected.object.obs]: #expected.object.obs
210
+ [expected.object.swap]: #expected.object.swap
211
+ [expected.syn]: #expected.syn
212
+ [expected.un.cons]: #expected.un.cons
213
+ [expected.un.eq]: #expected.un.eq
214
+ [expected.un.general]: #expected.un.general
215
+ [expected.un.obs]: #expected.un.obs
216
+ [expected.un.swap]: #expected.un.swap
217
+ [expected.unexpected]: #expected.unexpected
218
+ [expected.void]: #expected.void
219
+ [expected.void.assign]: #expected.void.assign
220
+ [expected.void.cons]: #expected.void.cons
221
+ [expected.void.dtor]: #expected.void.dtor
222
+ [expected.void.eq]: #expected.void.eq
223
+ [expected.void.general]: #expected.void.general
224
+ [expected.void.monadic]: #expected.void.monadic
225
+ [expected.void.obs]: #expected.void.obs
226
+ [expected.void.swap]: #expected.void.swap
227
+ [expr.add]: expr.md#expr.add
228
+ [expr.bit.and]: expr.md#expr.bit.and
229
+ [expr.call]: expr.md#expr.call
230
+ [expr.const]: expr.md#expr.const
231
+ [expr.eq]: expr.md#expr.eq
232
+ [expr.log.and]: expr.md#expr.log.and
233
+ [expr.log.or]: expr.md#expr.log.or
234
+ [expr.mul]: expr.md#expr.mul
235
+ [expr.or]: expr.md#expr.or
236
+ [expr.rel]: expr.md#expr.rel
237
+ [expr.unary.op]: expr.md#expr.unary.op
238
+ [expr.xor]: expr.md#expr.xor
239
+ [forward]: #forward
240
+ [freestanding.item]: library.md#freestanding.item
241
+ [func.bind]: #func.bind
242
+ [func.bind.bind]: #func.bind.bind
243
+ [func.bind.general]: #func.bind.general
244
+ [func.bind.isbind]: #func.bind.isbind
245
+ [func.bind.isplace]: #func.bind.isplace
246
+ [func.bind.partial]: #func.bind.partial
247
+ [func.bind.place]: #func.bind.place
248
+ [func.def]: #func.def
249
+ [func.identity]: #func.identity
250
+ [func.invoke]: #func.invoke
251
+ [func.memfn]: #func.memfn
252
+ [func.not.fn]: #func.not.fn
253
+ [func.require]: #func.require
254
+ [func.search]: #func.search
255
+ [func.search.bm]: #func.search.bm
256
+ [func.search.bmh]: #func.search.bmh
257
+ [func.search.default]: #func.search.default
258
+ [func.search.general]: #func.search.general
259
+ [func.wrap]: #func.wrap
260
+ [func.wrap.badcall]: #func.wrap.badcall
261
+ [func.wrap.copy]: #func.wrap.copy
262
+ [func.wrap.copy.class]: #func.wrap.copy.class
263
+ [func.wrap.copy.ctor]: #func.wrap.copy.ctor
264
+ [func.wrap.copy.general]: #func.wrap.copy.general
265
+ [func.wrap.copy.inv]: #func.wrap.copy.inv
266
+ [func.wrap.copy.util]: #func.wrap.copy.util
267
+ [func.wrap.func]: #func.wrap.func
268
+ [func.wrap.func.alg]: #func.wrap.func.alg
269
+ [func.wrap.func.cap]: #func.wrap.func.cap
270
+ [func.wrap.func.con]: #func.wrap.func.con
271
+ [func.wrap.func.general]: #func.wrap.func.general
272
+ [func.wrap.func.inv]: #func.wrap.func.inv
273
+ [func.wrap.func.mod]: #func.wrap.func.mod
274
+ [func.wrap.func.nullptr]: #func.wrap.func.nullptr
275
+ [func.wrap.func.targ]: #func.wrap.func.targ
276
+ [func.wrap.general]: #func.wrap.general
277
+ [func.wrap.move]: #func.wrap.move
278
+ [func.wrap.move.class]: #func.wrap.move.class
279
+ [func.wrap.move.ctor]: #func.wrap.move.ctor
280
+ [func.wrap.move.general]: #func.wrap.move.general
281
+ [func.wrap.move.inv]: #func.wrap.move.inv
282
+ [func.wrap.move.util]: #func.wrap.move.util
283
+ [func.wrap.ref]: #func.wrap.ref
284
+ [func.wrap.ref.class]: #func.wrap.ref.class
285
+ [func.wrap.ref.ctor]: #func.wrap.ref.ctor
286
+ [func.wrap.ref.deduct]: #func.wrap.ref.deduct
287
+ [func.wrap.ref.general]: #func.wrap.ref.general
288
+ [func.wrap.ref.inv]: #func.wrap.ref.inv
289
+ [function.objects]: #function.objects
290
+ [function.objects.general]: #function.objects.general
291
+ [functional.syn]: #functional.syn
292
+ [intro.abstract]: intro.md#intro.abstract
293
+ [intro.multithread]: basic.md#intro.multithread
294
+ [intro.object]: basic.md#intro.object
295
+ [invalid.argument]: diagnostics.md#invalid.argument
296
+ [istream.formatted]: input.md#istream.formatted
297
+ [iterator.concept.contiguous]: iterators.md#iterator.concept.contiguous
298
+ [iterator.requirements.general]: iterators.md#iterator.requirements.general
299
+ [lex.ccon]: lex.md#lex.ccon
300
+ [logical.operations]: #logical.operations
301
+ [logical.operations.and]: #logical.operations.and
302
+ [logical.operations.general]: #logical.operations.general
303
+ [logical.operations.not]: #logical.operations.not
304
+ [logical.operations.or]: #logical.operations.or
305
+ [meta.rqmts]: meta.md#meta.rqmts
306
+ [meta.trans.other]: meta.md#meta.trans.other
307
+ [optional]: #optional
308
+ [optional.assign]: #optional.assign
309
+ [optional.assign.copy]: #optional.assign.copy
310
+ [optional.assign.copy.templ]: #optional.assign.copy.templ
311
+ [optional.assign.move]: #optional.assign.move
312
+ [optional.assign.move.templ]: #optional.assign.move.templ
313
+ [optional.bad.access]: #optional.bad.access
314
+ [optional.comp.with.t]: #optional.comp.with.t
315
+ [optional.ctor]: #optional.ctor
316
+ [optional.dtor]: #optional.dtor
317
+ [optional.general]: #optional.general
318
+ [optional.hash]: #optional.hash
319
+ [optional.iterators]: #optional.iterators
320
+ [optional.mod]: #optional.mod
321
+ [optional.monadic]: #optional.monadic
322
+ [optional.nullops]: #optional.nullops
323
+ [optional.nullopt]: #optional.nullopt
324
+ [optional.observe]: #optional.observe
325
+ [optional.optional]: #optional.optional
326
+ [optional.optional.general]: #optional.optional.general
327
+ [optional.optional.ref]: #optional.optional.ref
328
+ [optional.optional.ref.general]: #optional.optional.ref.general
329
+ [optional.ref.assign]: #optional.ref.assign
330
+ [optional.ref.ctor]: #optional.ref.ctor
331
+ [optional.ref.expos]: #optional.ref.expos
332
+ [optional.ref.iterators]: #optional.ref.iterators
333
+ [optional.ref.mod]: #optional.ref.mod
334
+ [optional.ref.monadic]: #optional.ref.monadic
335
+ [optional.ref.observe]: #optional.ref.observe
336
+ [optional.ref.swap]: #optional.ref.swap
337
+ [optional.relops]: #optional.relops
338
+ [optional.specalg]: #optional.specalg
339
+ [optional.swap]: #optional.swap
340
+ [optional.syn]: #optional.syn
341
+ [ostream.formatted]: input.md#ostream.formatted
342
+ [out.of.range]: diagnostics.md#out.of.range
343
+ [over.match.call]: over.md#over.match.call
344
+ [overflow.error]: diagnostics.md#overflow.error
345
+ [pair.astuple]: #pair.astuple
346
+ [pair.piecewise]: #pair.piecewise
347
+ [pairs]: #pairs
348
+ [pairs.general]: #pairs.general
349
+ [pairs.pair]: #pairs.pair
350
+ [pairs.spec]: #pairs.spec
351
+ [random.access.iterators]: iterators.md#random.access.iterators
352
+ [range.cmp]: #range.cmp
353
+ [range.utility.helpers]: ranges.md#range.utility.helpers
354
+ [refwrap]: #refwrap
355
+ [refwrap.access]: #refwrap.access
356
+ [refwrap.assign]: #refwrap.assign
357
+ [refwrap.common.ref]: #refwrap.common.ref
358
+ [refwrap.comparisons]: #refwrap.comparisons
359
+ [refwrap.const]: #refwrap.const
360
+ [refwrap.general]: #refwrap.general
361
+ [refwrap.helpers]: #refwrap.helpers
362
+ [refwrap.invoke]: #refwrap.invoke
363
+ [stdbit.h.syn]: #stdbit.h.syn
364
+ [support.signal]: support.md#support.signal
365
+ [swappable.requirements]: library.md#swappable.requirements
366
+ [temp.constr.atomic]: temp.md#temp.constr.atomic
367
+ [temp.point]: temp.md#temp.point
368
+ [temp.type]: temp.md#temp.type
369
+ [template.bitset]: #template.bitset
370
+ [template.bitset.general]: #template.bitset.general
371
+ [term.object.representation]: basic.md#term.object.representation
372
+ [term.object.type]: basic.md#term.object.type
373
+ [term.odr.use]: basic.md#term.odr.use
374
+ [term.perfect.forwarding.call.wrapper]: #term.perfect.forwarding.call.wrapper
375
+ [term.simple.call.wrapper]: #term.simple.call.wrapper
376
+ [term.structural.type]: temp.md#term.structural.type
377
+ [term.trivially.copyable.type]: basic.md#term.trivially.copyable.type
378
+ [term.unevaluated.operand]: expr.md#term.unevaluated.operand
379
+ [tuple]: #tuple
380
+ [tuple.apply]: #tuple.apply
381
+ [tuple.assign]: #tuple.assign
382
+ [tuple.cnstr]: #tuple.cnstr
383
+ [tuple.common.ref]: #tuple.common.ref
384
+ [tuple.creation]: #tuple.creation
385
+ [tuple.elem]: #tuple.elem
386
+ [tuple.general]: #tuple.general
387
+ [tuple.helper]: #tuple.helper
388
+ [tuple.like]: #tuple.like
389
+ [tuple.rel]: #tuple.rel
390
+ [tuple.special]: #tuple.special
391
+ [tuple.swap]: #tuple.swap
392
+ [tuple.syn]: #tuple.syn
393
+ [tuple.traits]: #tuple.traits
394
+ [tuple.tuple]: #tuple.tuple
395
+ [tuple.tuple.general]: #tuple.tuple.general
396
+ [unord]: containers.md#unord
397
+ [unord.hash]: #unord.hash
398
+ [utilities]: #utilities
399
+ [utilities.general]: #utilities.general
400
+ [utilities.summary]: #utilities.summary
401
+ [utility]: #utility
402
+ [utility.as.const]: #utility.as.const
403
+ [utility.exchange]: #utility.exchange
404
+ [utility.intcmp]: #utility.intcmp
405
+ [utility.swap]: #utility.swap
406
+ [utility.syn]: #utility.syn
407
+ [utility.undefined]: #utility.undefined
408
+ [utility.underlying]: #utility.underlying
409
+ [variant]: #variant
410
+ [variant.assign]: #variant.assign
411
+ [variant.bad.access]: #variant.bad.access
412
+ [variant.ctor]: #variant.ctor
413
+ [variant.dtor]: #variant.dtor
414
+ [variant.general]: #variant.general
415
+ [variant.get]: #variant.get
416
+ [variant.hash]: #variant.hash
417
+ [variant.helper]: #variant.helper
418
+ [variant.mod]: #variant.mod
419
+ [variant.monostate]: #variant.monostate
420
+ [variant.monostate.relops]: #variant.monostate.relops
421
+ [variant.relops]: #variant.relops
422
+ [variant.specalg]: #variant.specalg
423
+ [variant.status]: #variant.status
424
+ [variant.swap]: #variant.swap
425
+ [variant.syn]: #variant.syn
426
+ [variant.variant]: #variant.variant
427
+ [variant.variant.general]: #variant.variant.general
428
+ [variant.visit]: #variant.visit
429
+
430
+ [^1]: Such a type is a function pointer or a class type which has a
431
+ member `operator()` or a class type which has a conversion to a
432
+ pointer to function.