[#BloombergLP-bslmf]
= xref:BloombergLP.adoc[BloombergLP]::bslmf
:relfileprefix: ../
:mrdocs:

Bloomberg meta&hyphen;function implementations used by `bsl&colon;&colon;is&lowbar;same`&period;

== Types

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bslmf/AddPointer_Compute.adoc[`AddPointer&lowbar;Compute`] 
| Private utility that SFINAE&hyphen;tests whether a pointer to `t&lowbar;TYPE` is valid&period;
| xref:BloombergLP/bslmf/AddReference.adoc[`AddReference`] 
| Meta&hyphen;function for forming a reference to a type&period;
| xref:BloombergLP/bslmf/ArrayToConstPointer-0f2.adoc[`ArrayToConstPointer`] 
| Meta&hyphen;function that converts an array type to a `const` pointer type&period;
| xref:BloombergLP/bslmf/ArrayToPointer-0e.adoc[`ArrayToPointer`] 
| Meta&hyphen;function that converts an array type to a pointer type&period;
| xref:BloombergLP/bslmf/ConstForwardingType.adoc[`ConstForwardingType`] 
| DEPRECATED&colon; Use `ForwardingType` instead&period;
| xref:BloombergLP/bslmf/DetectNestedTrait-00.adoc[`DetectNestedTrait`] 
| Meta&hyphen;function for detecting nested traits&period;
| xref:BloombergLP/bslmf/EnableIf-0e4.adoc[`EnableIf`] 
| Meta&hyphen;function that conditionally provides a typedef `type`&period;
| xref:BloombergLP/bslmf/FloatingTypeStructuralTraits-03.adoc[`FloatingTypeStructuralTraits`] 
| This is the primary template declaration for `bslmf&colon;&colon;FloatingTypeStructuralTraits`, which is never defined&period;
| xref:BloombergLP/bslmf/ForwardingRefType.adoc[`ForwardingRefType`] 
| Metafunction that computes an efficient forwarding parameter type for `t&lowbar;TYPE`&period;
| xref:BloombergLP/bslmf/ForwardingRefTypeUtil.adoc[`ForwardingRefTypeUtil`] 
| Provide a namespace for the `forwardToTarget` function&period;
| xref:BloombergLP/bslmf/ForwardingRefType_Category.adoc[`ForwardingRefType&lowbar;Category`] 
| This component&hyphen;private struct provides a namespace for the type dispatch category enumeration values&period;
| xref:BloombergLP/bslmf/ForwardingRefType_Dispatch.adoc[`ForwardingRefType&lowbar;Dispatch`] 
| This component&hyphen;private class template is a metafunction whose `value` member is the forwarding category for the specified `t&lowbar;TYPE`&period;
| xref:BloombergLP/bslmf/ForwardingType-07.adoc[`ForwardingType`] 
| Metafunction that computes an efficient argument type for forwarding `t&lowbar;TYPE`&period;
| xref:BloombergLP/bslmf/ForwardingTypeUtil.adoc[`ForwardingTypeUtil`] 
| Provide a namespace for the `forwardToTarget` function&period;
| xref:BloombergLP/bslmf/ForwardingType_Category.adoc[`ForwardingType&lowbar;Category`] 
| This component&hyphen;private struct provides a namespace for thpe type dispatch category enumeration values&period;
| xref:BloombergLP/bslmf/ForwardingType_Dispatch.adoc[`ForwardingType&lowbar;Dispatch`] 
| This component&hyphen;private class template is a metafunction whose `value` member is the forwarding category for the specified `t&lowbar;TYPE`&period;
| xref:BloombergLP/bslmf/FunctionPointerCLinkage.adoc[`FunctionPointerCLinkage`] 
| C function pointer linkage tag&period;
| xref:BloombergLP/bslmf/FunctionPointerCPlusPlusLinkage.adoc[`FunctionPointerCPlusPlusLinkage`] 
| C&plus;&plus; function pointer linkage tag&period;
| xref:BloombergLP/bslmf/FunctionPointerTraits-04.adoc[`FunctionPointerTraits`] 
| Meta&hyphen;function for detecting traits of free function pointer types&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/bslmf/If.adoc[`If`] 
| This meta&hyphen;function selects `t&lowbar;IF&lowbar;TRUE&lowbar;TYPE` if `t&lowbar;CONDITION` is non&hyphen;zero&period; and `t&lowbar;IF&lowbar;FALSE&lowbar;TYPE` otherwise&period;
| xref:BloombergLP/bslmf/IntegerSequence.adoc[`IntegerSequence`] 
| This class template represents a compile&hyphen;time sequence of integers&period;
| xref:BloombergLP/bslmf/InvokeResultDeductionFailed.adoc[`InvokeResultDeductionFailed`] 
| Placeholder type used when `invoke&lowbar;result` cannot deduce a return type&period;
| xref:BloombergLP/bslmf/InvokeResult_AddCVRef.adoc[`InvokeResult&lowbar;AddCVRef`] 
| Starting with type, `t&lowbar;UNQUAL&lowbar;TYPE`, generate a new type by applying the following steps in order&colon;
| xref:BloombergLP/bslmf/InvokeResult_BaseCalcUtil.adoc[`InvokeResult&lowbar;BaseCalcUtil`] 
| Forward declaration
| xref:BloombergLP/bslmf/InvokeResult_FuncPtrImp-0d.adoc[`InvokeResult&lowbar;FuncPtrImp`] 
| Forward declaration
| xref:BloombergLP/bslmf/InvokeResult_FunctorImp-0e.adoc[`InvokeResult&lowbar;FunctorImp`] 
| Forward declaration
| xref:BloombergLP/bslmf/InvokeResult_Index.adoc[`InvokeResult&lowbar;Index`] 
| Metafunction helpers for deducing the return type of an expression&period;
| xref:BloombergLP/bslmf/InvokeResult_MemFuncPtrImp-0cf.adoc[`InvokeResult&lowbar;MemFuncPtrImp`] 
| Forward declaration
| xref:BloombergLP/bslmf/InvokeResult_MemFuncPtrImpDispatch-076.adoc[`InvokeResult&lowbar;MemFuncPtrImpDispatch`] 
| Forward declaration&period;
| xref:BloombergLP/bslmf/InvokeResult_MemObjPtrImp-0d.adoc[`InvokeResult&lowbar;MemObjPtrImp`] 
| Forward declaration
| xref:BloombergLP/bslmf/InvokeResult_MemObjPtrImpDispatch-0d.adoc[`InvokeResult&lowbar;MemObjPtrImpDispatch`] 
| Forward declaration&period;
| xref:BloombergLP/bslmf/InvokeResult_MemPtrArgQualifiers-0c.adoc[`InvokeResult&lowbar;MemPtrArgQualifiers`] 
| Propagate cv and reference qualifiers from an `invoke` class argument&period;
| xref:BloombergLP/bslmf/InvokeResult_Type-04e.adoc[`InvokeResult&lowbar;Type`] 
| Map a type&hyphen;index enumerator to its corresponding C&plus;&plus; type&period;
| xref:BloombergLP/bslmf/InvokeResult_VoidChecker.adoc[`InvokeResult&lowbar;VoidChecker`] 
| Empty type used to detect void expressions&period; The size of this type is the same as `bslmf&colon;&colon;Tag&lt;1&gt;`&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/IsArray.adoc[`IsArray`] 
| Non&hyphen;standard meta&hyphen;function for detecting array types&period;
| xref:BloombergLP/bslmf/IsBitwiseCopyable-026.adoc[`IsBitwiseCopyable`] 
| This `struct` template provides a meta&hyphen;function to determine whether the (template parameter) `t&lowbar;TYPE` is bitwise copyable&period;
| xref:BloombergLP/bslmf/IsBitwiseEqualityComparable-018.adoc[`IsBitwiseEqualityComparable`] 
| This `struct` template implements a meta&hyphen;function to determine whether the (template parameter) `t&lowbar;TYPE` is bitwise EqualityComparable&period;
| xref:BloombergLP/bslmf/IsBitwiseMoveable-0fb.adoc[`IsBitwiseMoveable`] 
| This `struct` template implements a meta&hyphen;function to determine whether the (template parameter) `t&lowbar;TYPE` is bitwise moveable&period;
| xref:BloombergLP/bslmf/IsClass.adoc[`IsClass`] 
| Non&hyphen;standard meta&hyphen;function for detecting class types&period;
| xref:BloombergLP/bslmf/IsConvertible.adoc[`IsConvertible`] 
| Non&hyphen;standard meta&hyphen;function for detecting type convertibility&period;
| xref:BloombergLP/bslmf/IsConvertibleToAny.adoc[`IsConvertibleToAny`] 
| Meta&hyphen;function for detecting types convertible to any other type&period;
| xref:BloombergLP/bslmf/IsConvertible_CheckComplete-01b.adoc[`IsConvertible&lowbar;CheckComplete`] 
| Private helper for `IsConvertible` complete&hyphen;type checks&period;
| xref:BloombergLP/bslmf/IsEnum.adoc[`IsEnum`] 
| Non&hyphen;standard meta&hyphen;function for detecting enumerated types&period;
| xref:BloombergLP/bslmf/IsFunctionPointer.adoc[`IsFunctionPointer`] 
| Meta&hyphen;function to determine if a type is a free function pointer&period;
| xref:BloombergLP/bslmf/IsFundamental-04.adoc[`IsFundamental`] 
| Meta&hyphen;function for detecting fundamental types&period;
| xref:BloombergLP/bslmf/IsFundamental_Imp-0d6.adoc[`IsFundamental&lowbar;Imp&lt;bsl::nullptr&lowbar;t&gt;`] 
| This partial specialization of `IsFundamental&lowbar;Imp` derives from `bsl&colon;&colon;true&lowbar;type` for when the (template parameter) `t&lowbar;TYPE` is `void`&period;
| xref:BloombergLP/bslmf/IsMemberFunctionPointer.adoc[`IsMemberFunctionPointer`] 
| Meta&hyphen;function to determine if a type is a member function pointer&period;
| xref:BloombergLP/bslmf/IsNil-04.adoc[`IsNil`] 
| Metafunction that is `true` for `Nil` and `false` for all other types&period;
| xref:BloombergLP/bslmf/IsPair-08.adoc[`IsPair`] 
| Metafunction that is `false` for all types except `bsl&colon;&colon;pair` specializations&period;
| xref:BloombergLP/bslmf/IsPointer.adoc[`IsPointer`] 
| Non&hyphen;standard meta&hyphen;function for detecting pointer types&period;
| xref:BloombergLP/bslmf/IsPolymorphic.adoc[`IsPolymorphic`] 
| Non&hyphen;standard meta&hyphen;function for detecting polymorphic types&period;
| xref:BloombergLP/bslmf/IsReferenceWrapper-0e.adoc[`IsReferenceWrapper`] 
| Metafunction for detecting reference wrappers&period;
| xref:BloombergLP/bslmf/IsSame.adoc[`IsSame`] 
| Non&hyphen;standard meta&hyphen;function for detecting whether two types are the same&period;
| xref:BloombergLP/bslmf/IsTransparentPredicate-0f.adoc[`IsTransparentPredicate`] 
| Meta&hyphen;function for detecting whether a comparator is transparent&period;
| xref:BloombergLP/bslmf/IsTriviallyCopyableCheck.adoc[`IsTriviallyCopyableCheck`] 
| Returns the same value as `is&lowbar;trivially&lowbar;copyable` for checking&period;
| xref:BloombergLP/bslmf/IsTriviallyCopyable_DetectTrait-09.adoc[`IsTriviallyCopyable&lowbar;DetectTrait`] 
| This `struct` template detects whether `t&lowbar;TYPE` is tagged as trivially copyable&period;
| xref:BloombergLP/bslmf/IsTriviallyCopyable_Intrinsic.adoc[`IsTriviallyCopyable&lowbar;Intrinsic`] 
| This `struct` template implements a meta&hyphen;function to determine whether the (non&hyphen;cv&hyphen;qualified) (template parameter) `t&lowbar;TYPE` is trivially copyable&period;
| xref:BloombergLP/bslmf/IsTriviallyDefaultConstructible_DetectTrait-0b.adoc[`IsTriviallyDefaultConstructible&lowbar;DetectTrait`] 
| This `struct` template detects whether `t&lowbar;TYPE` is tagged as trivially default&hyphen;constructible&period;
| xref:BloombergLP/bslmf/IsVoid.adoc[`IsVoid`] 
| Non&hyphen;standard meta&hyphen;function for detecting `void` types&period;
| xref:BloombergLP/bslmf/MakeIntegerSequence_ConcatUtil-0e.adoc[`MakeIntegerSequence&lowbar;ConcatUtil`] 
| Component&hyphen;private metafunction that concatenates two integer sequences&period;
| xref:BloombergLP/bslmf/MakeIntegerSequence_Impl-0ff.adoc[`MakeIntegerSequence&lowbar;Impl&lt;t&lowbar;T, bsl::integral&lowbar;constant&lt;std::size&lowbar;t, 0&gt;&gt;`] 
| This partial specialization of the `bslmf&colon;&colon;MakeIntegerSequence&lowbar;Impl` meta&hyphen;function is a recursion break condition for an empty integer sequence&period;
| xref:BloombergLP/bslmf/MakeIntegerSequence_Impl-02.adoc[`MakeIntegerSequence&lowbar;Impl&lt;t&lowbar;T, bsl::integral&lowbar;constant&lt;std::size&lowbar;t, 1&gt;&gt;`] 
| This partial specialization of the `bslmf&colon;&colon;MakeIntegerSequence&lowbar;Impl` meta&hyphen;function is a recursion break condition for an integer sequence having the length 1&period;
| xref:BloombergLP/bslmf/MakeIntegerSequence_Impl-03.adoc[`MakeIntegerSequence&lowbar;Impl&lt;t&lowbar;T, bsl::integral&lowbar;constant&lt;std::size&lowbar;t, 2&gt;&gt;`] 
| This partial specialization of the `bslmf&colon;&colon;MakeIntegerSequence&lowbar;Impl` meta&hyphen;function is a recursion break condition for an integer sequence having the length 2&period;
| xref:BloombergLP/bslmf/MakeIntegerSequence_Impl-04.adoc[`MakeIntegerSequence&lowbar;Impl&lt;t&lowbar;T, bsl::integral&lowbar;constant&lt;std::size&lowbar;t, 3&gt;&gt;`] 
| This partial specialization of the `bslmf&colon;&colon;MakeIntegerSequence&lowbar;Impl` meta&hyphen;function is a recursion break condition for an integer sequence having the length 3&period;
| xref:BloombergLP/bslmf/MakeIntegerSequence_Impl-07.adoc[`MakeIntegerSequence&lowbar;Impl&lt;t&lowbar;T, bsl::integral&lowbar;constant&lt;std::size&lowbar;t, 4&gt;&gt;`] 
| This partial specialization of the `bslmf&colon;&colon;MakeIntegerSequence&lowbar;Impl` meta&hyphen;function is a recursion break condition for an integer sequence having the length 4&period;
| xref:BloombergLP/bslmf/MakeIntegerSequence_Impl-09.adoc[`MakeIntegerSequence&lowbar;Impl&lt;t&lowbar;T, bsl::integral&lowbar;constant&lt;std::size&lowbar;t, 5&gt;&gt;`] 
| This partial specialization of the `bslmf&colon;&colon;MakeIntegerSequence&lowbar;Impl` meta&hyphen;function is a recursion break condition for an integer sequence having the length 5&period;
| xref:BloombergLP/bslmf/MakeIntegerSequence_Impl-06.adoc[`MakeIntegerSequence&lowbar;Impl&lt;t&lowbar;T, bsl::integral&lowbar;constant&lt;std::size&lowbar;t, 6&gt;&gt;`] 
| This partial specialization of the `bslmf&colon;&colon;MakeIntegerSequence&lowbar;Impl` meta&hyphen;function is a recursion break condition for an integer sequence having the length 6&period;
| xref:BloombergLP/bslmf/MakeIntegerSequence_Impl-0b.adoc[`MakeIntegerSequence&lowbar;Impl&lt;t&lowbar;T, bsl::integral&lowbar;constant&lt;std::size&lowbar;t, 7&gt;&gt;`] 
| This partial specialization of the `bslmf&colon;&colon;MakeIntegerSequence&lowbar;Impl` meta&hyphen;function is a recursion break condition for an integer sequence having the length 7&period;
| xref:BloombergLP/bslmf/MakeIntegerSequence_Impl-00.adoc[`MakeIntegerSequence&lowbar;Impl&lt;t&lowbar;T, bsl::integral&lowbar;constant&lt;std::size&lowbar;t, 8&gt;&gt;`] 
| This partial specialization of the `bslmf&colon;&colon;MakeIntegerSequence&lowbar;Impl` meta&hyphen;function is a recursion break condition for an integer sequence having the length 8&period;
| xref:BloombergLP/bslmf/MatchAnyType.adoc[`MatchAnyType`] 
| Any type can be converted into this type&period;
| xref:BloombergLP/bslmf/MatchArithmeticType.adoc[`MatchArithmeticType`] 
| Type to which any arithmetic or enumeration type can be converted&period;
| xref:BloombergLP/bslmf/MemberFunctionPointerTraits.adoc[`MemberFunctionPointerTraits`] 
| Meta&hyphen;function for detecting traits of member function pointer types&period;
| xref:BloombergLP/bslmf/MemberFunctionPointerTraits_ClassType.adoc[`MemberFunctionPointerTraits&lowbar;ClassType`] 
| Metafunction to deduce the cv&hyphen;qualified class type of a member function&period;
| xref:BloombergLP/bslmf/MemberFunctionPointerTraits_Imp-09.adoc[`MemberFunctionPointerTraits&lowbar;Imp&lt;t&lowbar;PROTOTYPE, t&lowbar;BSLMF&lowbar;RETURN const volatile(t&lowbar;TYPE::*)(t&lowbar;ARGS&period;&period;&period;) noexcept&gt;`] 
| Partial specialization for non&hyphen;cv&hyphen;qualified member function pointers&period;
| xref:BloombergLP/bslmf/MemberPointerTraits.adoc[`MemberPointerTraits`] 
| Meta&hyphen;function for detecting traits of pointer&hyphen;to&hyphen;member types&period;
| xref:BloombergLP/bslmf/MemberPointerTraits_Imp-0d.adoc[`MemberPointerTraits&lowbar;Imp&lt;t&lowbar;MEMBER&lowbar;TYPEt&lowbar;CLASS&lowbar;TYPE::*&gt;`] 
| Specialization providing traits for pointer&hyphen;to&hyphen;member&hyphen;object types&period;
| xref:BloombergLP/bslmf/MetaInt-07.adoc[`MetaInt`] 
| Distinct type representing a non&hyphen;negative compile&hyphen;time integer value&period;
| xref:BloombergLP/bslmf/MovableRefUtil.adoc[`MovableRefUtil`] 
| Utility functions for operating on `MovableRef` objects&period;
| xref:BloombergLP/bslmf/MovableRefUtil_AddLvalueReference.adoc[`MovableRefUtil&lowbar;AddLvalueReference`] 
| forward declaration
| xref:BloombergLP/bslmf/MovableRefUtil_AddMovableReference.adoc[`MovableRefUtil&lowbar;AddMovableReference`] 
| forward declaration
| xref:BloombergLP/bslmf/MovableRefUtil_Decay.adoc[`MovableRefUtil&lowbar;Decay`] 
| forward declaration
| xref:BloombergLP/bslmf/MovableRefUtil_PropertyTraits.adoc[`MovableRefUtil&lowbar;PropertyTraits`] 
| forward declaration
| xref:BloombergLP/bslmf/MovableRefUtil_RemoveReference.adoc[`MovableRefUtil&lowbar;RemoveReference`] 
| forward declaration
| xref:BloombergLP/bslmf/MovableRef_Helper.adoc[`MovableRef&lowbar;Helper`] 
| forward declaration
| xref:BloombergLP/bslmf/NestedTraitDeclaration.adoc[`NestedTraitDeclaration`] 
| Empty type used as the conversion target for nested trait declarations&period;
| xref:BloombergLP/bslmf/Nil.adoc[`Nil`] 
| This struct is empty and represents a nil type&period;
| xref:BloombergLP/bslmf/NthParameter-06.adoc[`NthParameter`] 
| Metafunction to return the Nth type from a parameter pack&period;
| xref:BloombergLP/bslmf/NthParameter_Sentinel.adoc[`NthParameter&lowbar;Sentinel`] 
| Sentinel type used internally by `NthParameter` (declared but not defined)&period;
| xref:BloombergLP/bslmf/RemoveCvq.adoc[`RemoveCvq`] 
| This class implements a meta&hyphen;function for stripping top&hyphen;level const&sol;volatile qualifiers from it&apos;s parameter type&period;
| xref:BloombergLP/bslmf/RemoveReference.adoc[`RemoveReference`] 
| Meta&hyphen;function that removes reference&hyphen;ness from a type&period;
| xref:BloombergLP/bslmf/ResultType-01.adoc[`ResultType`] 
| Metafunction to return the result type of a functor type&period;
| xref:BloombergLP/bslmf/ResultType_BdeIdiom-0d.adoc[`ResultType&lowbar;BdeIdiom`] 
| Metafunction to detect the BDE `ResultType` idiom&period;
| xref:BloombergLP/bslmf/ResultType_Fallback-0b.adoc[`ResultType&lowbar;Fallback`] 
| Metafunction that defines `type` to be the specified `t&lowbar;FALLBACK` type unless `t&lowbar;FALLBACK` is `bslmf&colon;&colon;Nil`&period;
| xref:BloombergLP/bslmf/SelectTrait.adoc[`SelectTrait`] 
| Metafunction that selects the first matching trait for a type&period;
| xref:BloombergLP/bslmf/SelectTraitCase.adoc[`SelectTraitCase`] 
| Unique type identifying a selected trait metafunction&period;
| xref:BloombergLP/bslmf/SelectTrait_False.adoc[`SelectTrait&lowbar;False`] 
| Metafunction that always returns false&period;
| xref:BloombergLP/bslmf/Switch-07a1.adoc[`Switch`] 
| Compile&hyphen;time type switch among a variable number of types&period;
| xref:BloombergLP/bslmf/Tag-0b.adoc[`Tag`] 
| Map an unsigned integral constant to a distinct C&plus;&plus; type&period;
| xref:BloombergLP/bslmf/TypeList-00d.adoc[`TypeList`] 
| Compile&hyphen;time list of zero or more types&period;
| xref:BloombergLP/bslmf/TypeListTypeAt-03f.adoc[`TypeListTypeAt`] 
| Meta&hyphen;function to retrieve a type from a typelist by zero&hyphen;based index&period;
| xref:BloombergLP/bslmf/TypeRep.adoc[`TypeRep`] 
| Generate a reference to `t&lowbar;TYPE` for use in meta&hyphen;functions&period;
| xref:BloombergLP/bslmf/UsesAllocatorArgT-0a.adoc[`UsesAllocatorArgT`] 
| Metafunction that is `true&lowbar;type` if `t&lowbar;TYPE` uses `allocator&lowbar;arg&lowbar;t` construction&period;
| xref:BloombergLP/bslmf/Util.adoc[`Util`] 
| Namespace for portable forwarding and move helpers from `&lt;utility&gt;`&period;
| xref:BloombergLP/bslmf/VoidType.adoc[`VoidType`] 
| Metafunction that always yields `type` `void` for any well&hyphen;formed list of type parameters&period;
|===


== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bslmf/MakeIntegerSequence.adoc[`MakeIntegerSequence`] 
| Alias for an increasing integer sequence of type `t&lowbar;T` and length `t&lowbar;N`&period;
| xref:BloombergLP/bslmf/MakeIntegerSequence_ConcatUtil_t.adoc[`MakeIntegerSequence&lowbar;ConcatUtil&lowbar;t`] 
| `bslmf&colon;&colon;MakeIntegerSequence&lowbar;ConcatUtil&lowbar;t` is an alias to the result type of the `bslmf&colon;&colon;MakeIntegerSequence&lowbar;ConcatUtil` meta&hyphen;function&period;
| xref:BloombergLP/bslmf/MovableRef.adoc[`MovableRef`] 
| The alias template `MovableRef&lt;t&lowbar;TYPE&gt;` yields an r&hyphen;value reference of type `t&lowbar;TYPE&amp;&amp;`&period;
| xref:BloombergLP/bslmf/MovableRef_Deduced.adoc[`MovableRef&lowbar;Deduced`] 
| This component&hyphen;private alias template names the type `t&lowbar;TYPE&amp;&amp;` if and only if the specified `t&lowbar;TYPE` is not an lvalue reference&period;
| xref:BloombergLP/bslmf/Switch2.adoc[`Switch2`] 
| `switch` meta&hyphen;function among two types&period;
| xref:BloombergLP/bslmf/Switch3.adoc[`Switch3`] 
| `switch` meta&hyphen;function among three types&period;
| xref:BloombergLP/bslmf/Switch4.adoc[`Switch4`] 
| `switch` meta&hyphen;function among four types&period;
| xref:BloombergLP/bslmf/Switch5.adoc[`Switch5`] 
| `switch` meta&hyphen;function among five types&period;
| xref:BloombergLP/bslmf/Switch6.adoc[`Switch6`] 
| Select the type associated with selector value 6&period;
| xref:BloombergLP/bslmf/Switch7.adoc[`Switch7`] 
| Select the type associated with selector value 7&period;
| xref:BloombergLP/bslmf/Switch8.adoc[`Switch8`] 
| Select the type associated with selector value 8&period;
| xref:BloombergLP/bslmf/Switch9.adoc[`Switch9`] 
| Alias for a nine&hyphen;way `Switch` metafunction&period;
| xref:BloombergLP/bslmf/TypeList0.adoc[`TypeList0`] 
| Typelist of zero type parameters&period;
| xref:BloombergLP/bslmf/TypeList1.adoc[`TypeList1`] 
| Typelist of one type parameter&period;
| xref:BloombergLP/bslmf/TypeList10.adoc[`TypeList10`] 
| Typelist of ten type parameters&period;
| xref:BloombergLP/bslmf/TypeList11.adoc[`TypeList11`] 
| Typelist of eleven type parameters&period;
| xref:BloombergLP/bslmf/TypeList12.adoc[`TypeList12`] 
| Typelist of twelve type parameters&period;
| xref:BloombergLP/bslmf/TypeList13.adoc[`TypeList13`] 
| Typelist of thirteen type parameters&period;
| xref:BloombergLP/bslmf/TypeList14.adoc[`TypeList14`] 
| Typelist of fourteen type parameters&period;
| xref:BloombergLP/bslmf/TypeList15.adoc[`TypeList15`] 
| Typelist of fifteen type parameters&period;
| xref:BloombergLP/bslmf/TypeList16.adoc[`TypeList16`] 
| Typelist of sixteen type parameters&period;
| xref:BloombergLP/bslmf/TypeList17.adoc[`TypeList17`] 
| Typelist of seventeen type parameters&period;
| xref:BloombergLP/bslmf/TypeList18.adoc[`TypeList18`] 
| Typelist of eighteen type parameters&period;
| xref:BloombergLP/bslmf/TypeList19.adoc[`TypeList19`] 
| Typelist of nineteen type parameters&period;
| xref:BloombergLP/bslmf/TypeList2.adoc[`TypeList2`] 
| Typelist of two type parameters&period;
| xref:BloombergLP/bslmf/TypeList20.adoc[`TypeList20`] 
| Typelist of twenty type parameters&period;
| xref:BloombergLP/bslmf/TypeList3.adoc[`TypeList3`] 
| Typelist of three type parameters&period;
| xref:BloombergLP/bslmf/TypeList4.adoc[`TypeList4`] 
| Typelist of four type parameters&period;
| xref:BloombergLP/bslmf/TypeList5.adoc[`TypeList5`] 
| Typelist of five type parameters&period;
| xref:BloombergLP/bslmf/TypeList6.adoc[`TypeList6`] 
| Typelist of six type parameters&period;
| xref:BloombergLP/bslmf/TypeList7.adoc[`TypeList7`] 
| Typelist of seven type parameters&period;
| xref:BloombergLP/bslmf/TypeList8.adoc[`TypeList8`] 
| Typelist of eight type parameters&period;
| xref:BloombergLP/bslmf/TypeList9.adoc[`TypeList9`] 
| Typelist of nine type parameters&period;
| xref:BloombergLP/bslmf/TypeListNil.adoc[`TypeListNil`] 
| Sentinel type representing an empty typelist element&period;
| xref:BloombergLP/bslmf/TypeListTypeOf.adoc[`TypeListTypeOf`] 
| Classic Bloomberg code uses a 1&hyphen;based index into the type list&period;
|===


== Functions

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bslmf/operator_comma.adoc[`operator,`] 
| Detect non&hyphen;void expressions via an overloaded comma operator&period;
|===


== Variables

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bslmf/IsBitwiseCopyable_v.adoc[`IsBitwiseCopyable&lowbar;v`] 
| This template variable represents the result value of the `bslmf&colon;&colon;IsBitwiseCopyable` meta&hyphen;function&period;
| xref:BloombergLP/bslmf/IsBitwiseMoveable_v.adoc[`IsBitwiseMoveable&lowbar;v`] 
| This template variable represents the result value of the `bslmf&colon;&colon;IsBitwiseMoveable` meta&hyphen;function&period;
|===


== Concepts

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bslmf/BooleanTestable.adoc[`BooleanTestable`] 
| Concept that a type supports boolean testing and logical negation with the conventional semantics defined by the C&plus;&plus;20 standard &lsqb;concept&period;booleantestable&rsqb;&period;
| xref:BloombergLP/bslmf/ContainerCompatibleRange.adoc[`ContainerCompatibleRange`] 
| Concept that `t&lowbar;RANGE` is an input range of values convertible to `t&lowbar;TYPE`&period;
|===



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