[#bsl-integral_constant-02]
= xref:bsl.adoc[bsl]::integral&lowbar;constant
:relfileprefix: ../
:mrdocs:

Metafunction representing a compile&hyphen;time constant of the specified (template parameter) `t&lowbar;TYPE` with the specified (template parameter) `t&lowbar;VALUE`&period;

== Synopsis

Declared in `&lt;bslmf&lowbar;integralconstant&period;h&gt;`

[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class t&lowbar;TYPE,
    t&lowbar;TYPE t&lowbar;VALUE&gt;
struct integral&lowbar;constant
    : std::integral&lowbar;constant&lt;t&lowbar;TYPE, t&lowbar;VALUE&gt;
----

== Base Classes

[cols="1,4"]
|===
| Name| Description
| `std::integral&lowbar;constant&lt;t&lowbar;TYPE, t&lowbar;VALUE&gt;`
| 
|===

== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:bsl/integral_constant-02/type.adoc[`type`] 
| Alias for this `integral&lowbar;constant` specialization&period;
| xref:bsl/integral_constant-02/value_type.adoc[`value&lowbar;type`] 
| Alias for the (template parameter) `t&lowbar;TYPE`&period;
|===


== Member Functions

[cols="1,4"]
|===
| Name| Description
| xref:bsl/integral_constant-02/operator_call.adoc[`operator()`] 
| Return a copy of the template argument `t&lowbar;VALUE`&period;
| xref:bsl/integral_constant-02/2conversion.adoc[`operator t&lowbar;TYPE`] 
| Return a copy of the template argument `t&lowbar;VALUE`&period;
|===


== Static Data Members

[cols="1,4"]
|===
| Name| Description
| xref:bsl/integral_constant-02/value.adoc[`value`] 
| The compile&hyphen;time constant value of this metafunction&period;
|===


== Derived Classes

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bslma/AAModelBsl.adoc[`AAModelBsl`] 
| Model tag for bsl&hyphen;AA types&period;
| xref:BloombergLP/bslma/AAModelIsSupported-00.adoc[`AAModelIsSupported&lt;TYPE, AAModelLegacy&gt;`] 
| Specialization of `AAModelIsSupported` for the legacy&hyphen;AA model&period;
| xref:BloombergLP/bslma/AAModelIsSupported-01a.adoc[`AAModelIsSupported&lt;TYPE, AAModelBsl&gt;`] 
| Specialization of `AAModelIsSupported` for `MODEL &equals;&equals; AAModelBsl`, yielding `true&lowbar;type` if `TYPE&colon;&colon;allocator&lowbar;type` exists and is convertible from `bsl&colon;&colon;allocator&lt;char&gt;`&period;
| xref:BloombergLP/bslma/AAModelIsSupported-01d.adoc[`AAModelIsSupported&lt;TYPE, AAModelStl&gt;`] 
| Specialization of `AAModelIsSupported` for the stl&hyphen;AA model&period;
| xref:BloombergLP/bslma/AAModelIsSupported-0c.adoc[`AAModelIsSupported&lt;TYPE, AAModelPmr&gt;`] 
| Specialization of `AAModelIsSupported` for the pmr&hyphen;AA model&period;
| xref:BloombergLP/bslma/AAModelLegacy.adoc[`AAModelLegacy`] 
| Model tag for legacy&hyphen;AA types&period;
| xref:BloombergLP/bslma/AAModelNone.adoc[`AAModelNone`] 
| Model tag for non&hyphen;AA types&period;
| xref:BloombergLP/bslma/AAModelPmr.adoc[`AAModelPmr`] 
| Model tag for pmr&hyphen;AA types&period;
| xref:BloombergLP/bslma/AAModelStl.adoc[`AAModelStl`] 
| Model tag for stl&hyphen;AA types&period;
| xref:BloombergLP/bslalg/ArrayPrimitives_CanBitwiseCopy.adoc[`ArrayPrimitives&lowbar;CanBitwiseCopy`] 
| Metafunction that is `true` when `FROM&lowbar;TYPE` and `TO&lowbar;TYPE` are the same type (ignoring top&hyphen;level `const`) and that type is bit&hyphen;wise copyable&period;
| xref:BloombergLP/bdlat_EnumFunctions/HasFallbackEnumerator-00.adoc[`HasFallbackEnumerator`] 
| Meta&hyphen;function that detects whether `TYPE` has a fallback enumerator&period;
| xref:BloombergLP/bslmf/HasPointerSemantics-064.adoc[`HasPointerSemantics`] 
| Metafunction indicating whether the (template parameter) `t&lowbar;TYPE` has pointer&hyphen;like semantics&period;
| xref:BloombergLP/bslalg/HasTrait.adoc[`HasTrait`] 
| This meta&hyphen;function evaluates to `bsl&colon;&colon;true&lowbar;type` if the (template parameter) `TYPE` has the (template parameter) `TRAIT`, and to `bsl&colon;&colon;false&lowbar;type` otherwise&period;
| xref:BloombergLP/bslmf/IsAccessibleBaseOf.adoc[`IsAccessibleBaseOf`] 
| Meta&hyphen;function for detecting if one class is an accessible base of another&period;
| xref:BloombergLP/bslmf/IsBitwiseCopyable-08a.adoc[`IsBitwiseCopyable&lt;bsl::pair&lt;T1, T2&gt;&gt;`] 
| Trait indicating `pair` is bitwise&hyphen;copyable when both elements are&period;
| xref:BloombergLP/bslmf/IsBitwiseEqualityComparable-009.adoc[`IsBitwiseEqualityComparable&lt;bsl::pair&lt;T1, T2&gt;&gt;`] 
| Trait indicating `pair` is bitwise equality&hyphen;comparable when both elements are and the pair has no padding&period;
| xref:BloombergLP/bslmf/IsBitwiseMoveable-01d.adoc[`IsBitwiseMoveable&lt;bsl::pair&lt;T1, T2&gt;&gt;`] 
| Trait indicating `pair` is bitwise&hyphen;moveable when both elements are&period;
| xref:BloombergLP/bslmf/IsBitwiseMoveable-07e.adoc[`IsBitwiseMoveable&lt;bslma::ManagedPtrDeleter&gt;`] 
| Specialize `IsBitwiseMoveable` to indicate that `ManagedPtrDeleter` is bitwise moveable&period;
| xref:BloombergLP/bslmf/IsBitwiseMoveable-09dc.adoc[`IsBitwiseMoveable&lt;bslstl::HashTable&lt;KEY&lowbar;CONFIG, HASHER, COMPARATOR, ALLOCATOR&gt;&gt;`] 
| Trait indicating `HashTable` is bitwise&hyphen;movable when its parts are&period;
| xref:BloombergLP/bslmf/IsBitwiseMoveable-0fd8.adoc[`IsBitwiseMoveable&lt;bslstl::BidirectionalNodePool&lt;VALUE, ALLOCATOR&gt;&gt;`] 
| Trait indicating `BidirectionalNodePool` is bitwise moveable when its allocator is&period;
| xref:BloombergLP/bdlat_ChoiceFunctions/IsChoice-04.adoc[`IsChoice`] 
| This `struct` should be specialized for third&hyphen;party types that need to expose &quot;choice&quot; behavior&period; See the component&hyphen;level documentation for further information&period;
| xref:BloombergLP/bdlat_CustomizedTypeFunctions/IsCustomizedType-04.adoc[`IsCustomizedType`] 
| Meta&hyphen;function that detects whether `TYPE` exposes customized&hyphen;type behavior&period;
| xref:BloombergLP/bdlar/IsDynamic.adoc[`IsDynamic`] 
| Meta&hyphen;function indicating whether the specified `t&lowbar;TYPE` is in the `bdlat` dynamic&hyphen;type category&period;
| xref:BloombergLP/bdlat_EnumFunctions/IsEnumeration-0c.adoc[`IsEnumeration`] 
| Meta&hyphen;function that detects whether `TYPE` exposes enumeration behavior&period;
| xref:BloombergLP/bslmf/IsFunctionPointer.adoc[`IsFunctionPointer`] 
| Meta&hyphen;function to determine if a type is a free function pointer&period;
| xref:BloombergLP/bslstl/Function_SmallObjectOptimization/IsInplaceFunc.adoc[`IsInplaceFunc`] 
| Boolean metafunction reporting whether `FN` uses the inplace buffer&period;
| xref:BloombergLP/bslmf/IsMemberFunctionPointer.adoc[`IsMemberFunctionPointer`] 
| Meta&hyphen;function to determine if a type is a member function pointer&period;
| xref:BloombergLP/bdlat_SequenceFunctions/IsSequence-0a.adoc[`IsSequence`] 
| This `struct` should be specialized for third&hyphen;party types that need to expose &quot;sequence&quot; behavior&period; See the component&hyphen;level documentation for further information&period;
| xref:BloombergLP/bdlar/IsSimple-0c.adoc[`IsSimple`] 
| Meta&hyphen;function indicating whether the specified `TYPE` is in the `bdlat` simple&hyphen;type category&period;
| xref:BloombergLP/bslmf/MetaInt-07.adoc[`MetaInt`] 
| Distinct type representing a non&hyphen;negative compile&hyphen;time integer value&period;
| xref:BloombergLP/bdljsn/NumberUtil_IsSigned.adoc[`NumberUtil&lowbar;IsSigned`] 
| Metafunction yielding whether integral `t&lowbar;TYPE` is signed&period;
| xref:BloombergLP/bslstl/Optional_ConstructsFromType.adoc[`Optional&lowbar;ConstructsFromType`] 
| Metafunction detecting constructibility from a non&hyphen;optional type&period;
| xref:BloombergLP/bslstl/Optional_PropagatesAllocator.adoc[`Optional&lowbar;PropagatesAllocator`] 
| Metafunction detecting allocator propagation for const value types&period;
| xref:bsl/Pair_ConstructionParametersPackLength.adoc[`Pair&lowbar;ConstructionParametersPackLength`] 
| Metafunction giving the piecewise&hyphen;construction argument&hyphen;pack length&period;
| xref:BloombergLP/bslstl/Pair_IndexOfType-006.adoc[`Pair&lowbar;IndexOfType&lt;T2, T1, T2&gt;`] 
| This partial specialization of `Pair&lowbar;IndexOfType` returns the index of second element of pair&period;
| xref:BloombergLP/bslstl/Pair_IndexOfType-00c.adoc[`Pair&lowbar;IndexOfType&lt;T1, T1, T2&gt;`] 
| This partial specialization of `Pair&lowbar;IndexOfType` returns the index of first element of pair&period;
| xref:BloombergLP/bdlar/SimpleTypeIdOf-002.adoc[`SimpleTypeIdOf&lt;bdlt::TimeTz&gt;`] 
| Specialization of `SimpleTypeIdOf` for `bdlt&colon;&colon;TimeTz`&period;
| xref:BloombergLP/bdlar/SimpleTypeIdOf-003.adoc[`SimpleTypeIdOf&lt;long long&gt;`] 
| Specialization of `SimpleTypeIdOf` for `long long`&period;
| xref:BloombergLP/bdlar/SimpleTypeIdOf-00d.adoc[`SimpleTypeIdOf&lt;bdlt::DateTz&gt;`] 
| Specialization of `SimpleTypeIdOf` for `bdlt&colon;&colon;DateTz`&period;
| xref:BloombergLP/bdlar/SimpleTypeIdOf-010.adoc[`SimpleTypeIdOf&lt;bdlt::Date&gt;`] 
| Specialization of `SimpleTypeIdOf` for `bdlt&colon;&colon;Date`&period;
| xref:BloombergLP/bdlar/SimpleTypeIdOf-01d.adoc[`SimpleTypeIdOf&lt;unsigned short&gt;`] 
| Specialization of `SimpleTypeIdOf` for `unsigned short`&period;
| xref:BloombergLP/bdlar/SimpleTypeIdOf-01f.adoc[`SimpleTypeIdOf&lt;bdldfp::Decimal64&gt;`] 
| Specialization of `SimpleTypeIdOf` for `bdldfp&colon;&colon;Decimal64`&period;
| xref:BloombergLP/bdlar/SimpleTypeIdOf-02.adoc[`SimpleTypeIdOf&lt;bsl::vector&lt;char&gt;&gt;`] 
| Specialization of `SimpleTypeIdOf` for `bsl&colon;&colon;vector&lt;char&gt;`&period;
| xref:BloombergLP/bdlar/SimpleTypeIdOf-032.adoc[`SimpleTypeIdOf&lt;unsigned long&gt;`] 
| Specialization of `SimpleTypeIdOf` for `unsigned long`&period;
| xref:BloombergLP/bdlar/SimpleTypeIdOf-0386d.adoc[`SimpleTypeIdOf&lt;short&gt;`] 
| Specialization of `SimpleTypeIdOf` for `short`&period;
| xref:BloombergLP/bdlar/SimpleTypeIdOf-0386f.adoc[`SimpleTypeIdOf&lt;signed char&gt;`] 
| Specialization of `SimpleTypeIdOf` for `signed char`&period;
| xref:BloombergLP/bdlar/SimpleTypeIdOf-03b.adoc[`SimpleTypeIdOf&lt;char&gt;`] 
| Specialization of `SimpleTypeIdOf` for `char`&period;
| xref:BloombergLP/bdlar/SimpleTypeIdOf-068.adoc[`SimpleTypeIdOf&lt;float&gt;`] 
| Specialization of `SimpleTypeIdOf` for `float`&period;
| xref:BloombergLP/bdlar/SimpleTypeIdOf-06a.adoc[`SimpleTypeIdOf&lt;bdlt::Time&gt;`] 
| Specialization of `SimpleTypeIdOf` for `bdlt&colon;&colon;Time`&period;
| xref:BloombergLP/bdlar/SimpleTypeIdOf-08.adoc[`SimpleTypeIdOf&lt;bsl::string&gt;`] 
| Specialization of `SimpleTypeIdOf` for `bsl&colon;&colon;string`&period;
| xref:BloombergLP/bdlar/SimpleTypeIdOf-0902.adoc[`SimpleTypeIdOf&lt;bool&gt;`] 
| Specialization of `SimpleTypeIdOf` for `bool`&period;
| xref:BloombergLP/bdlar/SimpleTypeIdOf-090c.adoc[`SimpleTypeIdOf&lt;unsigned char&gt;`] 
| Specialization of `SimpleTypeIdOf` for `unsigned char`&period;
| xref:BloombergLP/bdlar/SimpleTypeIdOf-0a.adoc[`SimpleTypeIdOf&lt;int&gt;`] 
| Specialization of `SimpleTypeIdOf` for `int`&period;
| xref:BloombergLP/bdlar/SimpleTypeIdOf-0b6.adoc[`SimpleTypeIdOf&lt;unsigned long long&gt;`] 
| Specialization of `SimpleTypeIdOf` for `unsigned long long`&period;
| xref:BloombergLP/bdlar/SimpleTypeIdOf-0bb.adoc[`SimpleTypeIdOf&lt;double&gt;`] 
| Specialization of `SimpleTypeIdOf` for `double`&period;
| xref:BloombergLP/bdlar/SimpleTypeIdOf-0d4.adoc[`SimpleTypeIdOf&lt;long&gt;`] 
| Specialization of `SimpleTypeIdOf` for `long`&period;
| xref:BloombergLP/bdlar/SimpleTypeIdOf-0dc.adoc[`SimpleTypeIdOf&lt;unsigned int&gt;`] 
| Specialization of `SimpleTypeIdOf` for `unsigned int`&period;
| xref:BloombergLP/bdlar/SimpleTypeIdOf-0e.adoc[`SimpleTypeIdOf&lt;bdlt::Datetime&gt;`] 
| Specialization of `SimpleTypeIdOf` for `bdlt&colon;&colon;Datetime`&period;
| xref:BloombergLP/bdlar/SimpleTypeIdOf-0f.adoc[`SimpleTypeIdOf&lt;bdlt::DatetimeTz&gt;`] 
| Specialization of `SimpleTypeIdOf` for `bdlt&colon;&colon;DatetimeTz`&period;
| xref:BloombergLP/bslma/UsesBslmaAllocator-01f.adoc[`UsesBslmaAllocator&lt;bsl::pair&lt;T1, T2&gt;&gt;`] 
| Trait indicating `pair` uses `bslma` allocators when either element does&period;
| xref:BloombergLP/bslma/UsesBslmaAllocator-020.adoc[`UsesBslmaAllocator`] 
| Metafunction that is `true&lowbar;type` if `TYPE` uses the `bslma` allocator idiom&period;
| xref:BloombergLP/bslstl/Variant_AssignsFromType.adoc[`Variant&lowbar;AssignsFromType`] 
| Determine whether `t&lowbar;TYPE` assigns to a unique alternative of `t&lowbar;VARIANT`&period;
| xref:BloombergLP/bslstl/Variant_ConstructsFromType.adoc[`Variant&lowbar;ConstructsFromType`] 
| Determine whether `t&lowbar;TYPE` constructs a unique alternative of `t&lowbar;VARIANT`&period;
| xref:BloombergLP/bslstl/Variant_ConvertsWithoutNarrowing-0a.adoc[`Variant&lowbar;ConvertsWithoutNarrowing&lt;t&lowbar;DEST, t&lowbar;SOURCE, bsl::void&lowbar;t&lt;decltype(Variant&lowbar;ArrayHelper&lt;t&lowbar;DEST&gt;&lcub;&lcub;std&colon;&colon;declval&lt;t&lowbar;SOURCE&gt;()&rcub;&rcub;)&gt;&gt;`] 
| Determine whether `t&lowbar;SOURCE` converts to `t&lowbar;DEST` without narrowing&period;
| xref:BloombergLP/bslstl/Variant_CountCVType-03.adoc[`Variant&lowbar;CountCVType`] 
| Count occurrences of `t&lowbar;TYPE` in `t&lowbar;HEAD, t&lowbar;TAIL&period;&period;&period;`, ignoring cv&hyphen;quals&period;
| xref:BloombergLP/bslstl/Variant_CountCVType-09.adoc[`Variant&lowbar;CountCVType&lt;t&lowbar;TYPE, BSLSTL&lowbar;VARIANT&lowbar;NOT&lowbar;A&lowbar;TYPE&gt;`] 
| Specialization for purposes of the sim&lowbar;cpp11&lowbar;features&period;pl script&period;
| xref:BloombergLP/bslstl/Variant_CountType-0c.adoc[`Variant&lowbar;CountType&lt;t&lowbar;TYPE, BSLSTL&lowbar;VARIANT&lowbar;NOT&lowbar;A&lowbar;TYPE&gt;`] 
| Specialization for purposes of the sim&lowbar;cpp11&lowbar;features&period;pl script&period;
| xref:BloombergLP/bslstl/Variant_CountType-0d.adoc[`Variant&lowbar;CountType`] 
| Count how many times `t&lowbar;TYPE` occurs among the listed alternatives&period;
| xref:BloombergLP/bslstl/Variant_HasUniqueCVType-0f.adoc[`Variant&lowbar;HasUniqueCVType&lt;t&lowbar;TYPE, bsl::variant&lt;t&lowbar;HEAD, t&lowbar;TAIL&period;&period;&period;&gt;&gt;`] 
| Determine whether `t&lowbar;TYPE` occurs exactly once, ignoring cv&hyphen;quals&period;
| xref:BloombergLP/bslstl/Variant_HasUniqueType-02.adoc[`Variant&lowbar;HasUniqueType&lt;t&lowbar;TYPE, bsl::variant&lt;t&lowbar;HEAD, t&lowbar;TAIL&period;&period;&period;&gt;&gt;`] 
| Determine whether `t&lowbar;TYPE` occurs exactly once in a `bsl&colon;&colon;variant`&period;
| xref:BloombergLP/bslstl/Variant_IsAlternativeConstructibleFrom-0e.adoc[`Variant&lowbar;IsAlternativeConstructibleFrom`] 
| Determine whether the unique best&hyphen;match alternative is constructible&period;
| xref:BloombergLP/bslstl/Variant_IsBitwiseMoveableAll-0c.adoc[`Variant&lowbar;IsBitwiseMoveableAll`] 
| This component&hyphen;private metafunction is derived from `bsl&colon;&colon;true&lowbar;type` if all template arguments are bitwise moveable, and from `bsl&colon;&colon;false&lowbar;type` otherwise&period;
| xref:BloombergLP/bslstl/Variant_IsCopyAssignableAll-0d.adoc[`Variant&lowbar;IsCopyAssignableAll`] 
| This component&hyphen;private metafunction is derived from `bsl&colon;&colon;true&lowbar;type` if all template parameters are copy assignable, and `bsl&colon;&colon;false&lowbar;type` otherwise&period;
| xref:BloombergLP/bslstl/Variant_IsCopyConstructibleAll-03.adoc[`Variant&lowbar;IsCopyConstructibleAll`] 
| This component&hyphen;private metafunction is derived from `bsl&colon;&colon;true&lowbar;type` if all template parameters are copy constructible, and `bsl&colon;&colon;false&lowbar;type` otherwise&period;
| xref:BloombergLP/bslstl/Variant_IsMoveAssignableAll-0e.adoc[`Variant&lowbar;IsMoveAssignableAll`] 
| This component&hyphen;private metafunction is derived from `bsl&colon;&colon;true&lowbar;type` if all template parameters are move assignable, and `bsl&colon;&colon;false&lowbar;type` otherwise&period;
| xref:BloombergLP/bslstl/Variant_IsMoveConstructibleAll-05.adoc[`Variant&lowbar;IsMoveConstructibleAll`] 
| This component&hyphen;private metafunction is derived from `bsl&colon;&colon;true&lowbar;type` if all template parameters are move constructible, and `bsl&colon;&colon;false&lowbar;type` otherwise&period;
| xref:BloombergLP/bslstl/Variant_IsSameReturnType-02.adoc[`Variant&lowbar;IsSameReturnType`] 
| Determine whether `t&lowbar;VISITOR` yields `t&lowbar;RET` for every alternative&period;
| xref:BloombergLP/bdlb/Variant_ReturnValueHelper.adoc[`Variant&lowbar;ReturnValueHelper`] 
| Component&hyphen;private helper that detects a visitor `ResultType`&period;
| xref:BloombergLP/bslstl/Variant_TypeToIndexImpl-07.adoc[`Variant&lowbar;TypeToIndexImpl&lt;t&lowbar;INDEX, t&lowbar;TYPE, BSLSTL&lowbar;VARIANT&lowbar;NOT&lowbar;A&lowbar;TYPE&gt;`] 
| Handle the case where `t&lowbar;TYPE` was not found in the alternative list&period;
| xref:BloombergLP/bslstl/Variant_UsesBslmaAllocatorAny-0e.adoc[`Variant&lowbar;UsesBslmaAllocatorAny`] 
| This component&hyphen;private metafunction is derived from `bsl&colon;&colon;true&lowbar;type` if at least one template argument uses an allocator, and from `bsl&colon;&colon;false&lowbar;type` otherwise&period;
| xref:BloombergLP/bslstl/Variant_isAlternativeAssignableFrom-07.adoc[`Variant&lowbar;isAlternativeAssignableFrom`] 
| Determine whether the unique best&hyphen;match alternative is assignable&period;
| xref:bsl/is_arithmetic.adoc[`is&lowbar;arithmetic`] 
| Standard meta&hyphen;function for determining arithmetic types&period;
| xref:bsl/is_convertible.adoc[`is&lowbar;convertible`] 
| Meta&hyphen;function for detecting implicit convertibility between types&period;
| xref:bsl/is_copy_constructible.adoc[`is&lowbar;copy&lowbar;constructible`] 
| Meta&hyphen;function for detecting copy&hyphen;constructible types&period;
| xref:bsl/is_empty.adoc[`is&lowbar;empty`] 
| Meta&hyphen;function for detecting empty class types&period;
| xref:bsl/is_enum.adoc[`is&lowbar;enum`] 
| Meta&hyphen;function for detecting enumerated types&period;
| xref:bsl/is_floating_point.adoc[`is&lowbar;floating&lowbar;point`] 
| Meta&hyphen;function for determining floating&hyphen;point types&period;
| xref:bsl/is_function-05.adoc[`is&lowbar;function`] 
| Meta&hyphen;function for detecting function types&period;
| xref:bsl/is_fundamental-09.adoc[`is&lowbar;fundamental`] 
| Standard meta&hyphen;function for detecting fundamental types&period;
| xref:bsl/is_integral.adoc[`is&lowbar;integral`] 
| This `struct` template implements the `is&lowbar;integral` meta&hyphen;function defined in the C&plus;&plus;11 standard to determine if the (template parameter) `t&lowbar;TYPE` is an integral type&period;
| xref:bsl/is_lvalue_reference.adoc[`is&lowbar;lvalue&lowbar;reference`] 
| Metafunction that is `true` if the (template parameter) `t&lowbar;TYPE` is an lvalue reference type&period;
| xref:bsl/is_polymorphic.adoc[`is&lowbar;polymorphic`] 
| Meta&hyphen;function for detecting polymorphic types&period;
| xref:bsl/variant_size-09.adoc[`variant&lowbar;size&lt;variant&lt;t&lowbar;HEAD, t&lowbar;TAIL&period;&period;&period;&gt;&gt;`] 
| Provide the number of alternatives of a `bsl&colon;&colon;variant` specialization&period;
|===


[.small]#Created with https://www.mrdocs.com[MrDocs]#
