[#bsl]
= bsl
:mrdocs:

Namespace containing forward declarations for standard stream classes&period;

== Namespaces

[cols="1,4"]
|===
| Name| Description
| xref:bsl/chrono.adoc[`chrono`] 
| Namespace for C&plus;&plus;11 `chrono` facilities in the `bsl` package&period;
| xref:bsl/filesystem.adoc[`filesystem`] 
| Namespace for filesystem facilities equivalent to `std&colon;&colon;filesystem`&period;
| xref:bsl/ranges.adoc[`ranges`] 
| Namespace for C&plus;&plus;20 range access functions&period;
| xref:bsl/regex_constants.adoc[`regex&lowbar;constants`] 
| Namespace for `std&colon;&colon;regex&lowbar;constants` symbols in the `bsl` namespace&period;
| xref:bsl/this_thread.adoc[`this&lowbar;thread`] 
| Namespace for `std&colon;&colon;this&lowbar;thread` functionality in the `bsl` namespace&period;
|===


== Namespace Aliases

[cols="1,4"]
|===
| Name| Description
| xref:bsl/numbers.adoc[`numbers`] 
| Alias for the `std&colon;&colon;numbers` namespace in the `bsl` namespace&period;
| xref:bsl/placeholders.adoc[`placeholders`] 
| Namespace alias for `std&colon;&colon;placeholders` in the `bsl` namespace&period;
| xref:bsl/rel_ops.adoc[`rel&lowbar;ops`] 
| Namespace alias for `std&colon;&colon;rel&lowbar;ops` in the `bsl` namespace&period;
| xref:bsl/views.adoc[`views`] 
| Alias for `std&colon;&colon;ranges&colon;&colon;views` in the `bsl` namespace&period;
|===


== Types

[cols="1,4"]
|===
| Name| Description
| xref:bsl/ComparatorSelector-061.adoc[`ComparatorSelector`] 
| This meta&hyphen;function selects the appropriate implementation for comparing the parameterized `TYPE`&period; This generic template uses the `std&colon;&colon;equal&lowbar;to` functor&period;
| xref:bsl/Deque_Base.adoc[`Deque&lowbar;Base`] 
| This class describes the basic layout for a deque class&period; It is important that this class has the same layout as the deque class implementation&period; It is parameterized by `VALUE&lowbar;TYPE` only and implements the portion of `bsl&colon;&colon;deque` that does not need to know about its (template parameter) type `ALLOCATOR` (in order to generate shorter debug strings)&period; Note that this class must have the same layout as `Deque&lowbar;Imp` (see implementation file)&period;
| xref:bsl/Deque_BlockCreator.adoc[`Deque&lowbar;BlockCreator`] 
| This class allocates blocks at the front or back of a deque and tentatively adds them to the deque&period; It also keeps track of how many of the newly allocated blocks have actually been used by the deque&period; The destructor automatically frees any unused blocks (e&period;g&period;, in case an exception is thrown)&period;
| xref:bsl/Deque_BlockLengthCalcUtil.adoc[`Deque&lowbar;BlockLengthCalcUtil`] 
| This `struct` provides a namespace for the calculation of block length (the number of elements per block within a `deque`)&period; This ensures that each block in the deque can hold at least 16 elements&period;
| xref:bsl/Deque_BlockProctor.adoc[`Deque&lowbar;BlockProctor`] 
| This class implements a proctor that, upon destruction and unless its `release` method has previously been invoked, deallocates empty blocks at one end (i&period;e&period;, front or back) of a proctored deque&period; The end at which empty blocks are to be proctored is indicated by a flag supplied at construction&period; See `emplace` for a use case&period;
| xref:bsl/Deque_ClearGuard.adoc[`Deque&lowbar;ClearGuard`] 
| This class provides a proctor which, at destruction, calls `clear` on the deque supplied at construction, unless the guard has been released prior&period;
| xref:bsl/Deque_Guard.adoc[`Deque&lowbar;Guard`] 
| This class provides a proctor that maintains a count of the number of elements constructed at the front or back of a deque, but not yet committed to the deque&apos;s range of valid elements&semi; if the count is non&hyphen;zero at destruction, the destructor destroys the elements in the range `&lsqb;d&lowbar;deque&lowbar;p&hyphen;&gt;end() &period;&period; d&lowbar;deque&lowbar;p&hyphen;&gt;end() &plus; d&lowbar;count)&rsqb;`, or the range `&lsqb;d&lowbar;deque&lowbar;p&hyphen;&gt;begin() &hyphen; d&lowbar;count &period;&period; d&lowbar;deque&lowbar;p&hyphen;&gt;begin())&rsqb;`, depending on whether this proctor guards the back or front&period; This guard is used to undo element constructors in the event of an exception&period; It is up to the client code to increment the count whenever a new element is constructed and to decrement the count whenever `d&lowbar;start` or `d&lowbar;finish` of the guarded deque is moved to incorporate more elements&period;
| xref:bsl/Deque_Util.adoc[`Deque&lowbar;Util`] 
| This `struct` provides a namespace to implement the `swap` member function of `deque&lt;VALUE&lowbar;TYPE, ALLOCATOR&gt;`&period; This function can be implemented irrespective of the `VALUE&lowbar;TYPE` or `ALLOCATOR` template parameters, which is why we implement it in this non&hyphen;parameterized, non&hyphen;inlined utility&period;
| xref:bsl/FunctionDeductionHelper.adoc[`FunctionDeductionHelper`] 
| This struct provides a set of template `meta&hyphen;functions` that extract the signature of a class member function, stripping any qualifiers such as `const`, `noexcept` or `&amp;`&period;
| xref:bsl/List_AllocAndSizeWrapper.adoc[`List&lowbar;AllocAndSizeWrapper`] 
| This struct is a wrapper around the allocator and size data members of a `list`&period; It takes advantage of the empty&hyphen;base optimization (EBO) so that if the allocator is stateless, it takes up no space&period;
| xref:bsl/List_DefaultLessThan.adoc[`List&lowbar;DefaultLessThan`] 
| Binary predicate type for comparing two `VALUE` objects using `operator&lt;`&period; This operation is usually, but not always, the same as that provided by `std&colon;&colon;less&lt;VALUE&gt;`&period; The standard requires that certain functions use `operator&lt;`, which means that divergent specializations of `std&colon;&colon;less` are to be ignored&period;
| xref:bsl/List_Iterator.adoc[`List&lowbar;Iterator`] 
| 
| xref:bsl/List_Node.adoc[`List&lowbar;Node`] 
| PRIVATE CLASS TEMPLATE&period; For use only by `bsl&colon;&colon;list` implementation&period; An instance of `List&lowbar;Node&lt;T&gt;` is a single node in a doubly&hyphen;linked list used to implement `bsl&colon;&colon;list&lt;T,A&gt;`, for a given element type `T` and allocator type `A`&period; Note that an instantiation of this `class` for a given `bsl&colon;&colon;list` is independent of the allocator type&period;
| xref:bsl/List_NodeProctor.adoc[`List&lowbar;NodeProctor`] 
| This class provides a proctor to free a node containing an uninitialized `VALUE` object in the event that an exception is thrown&period;
| xref:bsl/Pair_BslmaIdiom.adoc[`Pair&lowbar;BslmaIdiom`] 
| This component&hyphen;private meta&hyphen;function determines whether the specified `TYPE` template parameter takes a `bslma&colon;&colon;Allocator&ast;` constructor argument and, if so, whether that argument is at the end of the argument list or at the beginning of the argument list following an argument of type `bsl&colon;&colon;allocator&lowbar;arg&lowbar;t`&period; This type derived from `bsl&colon;&colon;integral&lowbar;constant&lt;int, N&gt;` where `N` is the number of additional parameters required to pass an allocator to a constructor using the chosen idiom&period;
| xref:bsl/Pair_ConstructionParametersPackLength.adoc[`Pair&lowbar;ConstructionParametersPackLength`] 
| This component&hyphen;private component&hyphen;private meta&hyphen;function determines the number of elements in a tuple containing parameters for piecewise construction of a `bsl&colon;&colon;pair` member having the specified `TYPE`&period; Result value depends on the `TYPE`, whether it takes a `bslma&colon;&colon;Allocator&ast;` constructor argument and, if so, whether that argument follows an argument of type `bsl&colon;&colon;allocator&lowbar;arg&lowbar;t`&period;
| xref:bsl/Pair_First-00.adoc[`Pair&lowbar;First`] 
| This component&hyphen;private `class` holds the `first` data member of a `pair` and constructs it appropriately&period; Note the partial specializations below for the cases that (template parameter) &apos;TYPE&apos; is a reference&period;
| xref:bsl/Pair_Second-05e.adoc[`Pair&lowbar;Second`] 
| This component&hyphen;private `class` holds the `second` data member of a `pair` and constructs it appropriately&period; Note the partial specializations below for the cases that (template parameter) &apos;TYPE&apos; is a reference&period;
| xref:bsl/StringBufContainer.adoc[`StringBufContainer`] 
| This class enables the implementation of string&hyphen;stream types by providing a trivial type containing a `basic&lowbar;stringbuf` that is suitable as a (`private`) base class for a string&hyphen;stream&period; Inheriting from `StringBufContainer` allows the string&hyphen;stream to ensure that the contained `basic&lowbar;stringbuf` is initialized before initializing other base classes or data members without potentially overriding `virtual` methods in the `basic&lowbar;stringbuf` type&period; Note that implementations of string&hyphen;stream types must pass the address of a string&hyphen;buffer to their `public` base class (e&period;g&period;, `basic&lowbar;stream`), so the string&hyphen;stream must ensure (using `private` inheritance) that the string&hyphen;buffer is initialized before constructing the `public` base class&period; If a string&hyphen;stream implementation were to directly inherit from `basic&lowbar;streambuf`, then `virtual` methods defined in that string&hyphen;stream (e&period;g&period;, `underflow`) might incorrectly override those in the `basic&lowbar;stringbuf` implementation&period;
| xref:bsl/StringComparator.adoc[`StringComparator`] 
| This class is a functor that provides comparison between two `const char &ast;` strings&period;
| xref:bsl/String_ClearProctor.adoc[`String&lowbar;ClearProctor`] 
| This component private `class` implements a proctor that sets the length of a string to zero, and, if `release` is not called, will restore that string upon it&apos;s destruction&period; The intended usage is to implement `assign` methods in terms of `append` (by clearing the string before appending to it), while maintaining the strong exceptions guarantee&period; Note that after constructing this proctor for a string `s`, the invariant `s&lsqb;s&period;length()&rsqb;&equals;&equals; CHAR&lowbar;TYPE()` is violated for non&hyphen;empty `s`&period; This invariant will be restored by either a successful `append` or by the proctor&apos;s destructor if an exception is thrown&period; Note that the template parameter was renamed from STRING&lowbar;TYPE to FULL&lowbar;STRING&lowbar;TYPE due to a name clash with a define elsewhere in the code base (see DRQS 112049582)&period;
| xref:bsl/String_ComparisonCategory-07.adoc[`String&lowbar;ComparisonCategory`] 
| This meta&hyphen;function selects the comparison category type for `basic&lowbar;string` with the specified `CHAR&lowbar;TRAITS`&period;
| xref:bsl/SyncBuf_MutexUtil.adoc[`SyncBuf&lowbar;MutexUtil`] 
| Internal mutex&hyphen;related utils&period;
| xref:bsl/Variant_VariantAlternativeImpl-06e.adoc[`Variant&lowbar;VariantAlternativeImpl`] 
| This component&hyphen;private metafunction provides the implementation of `bsl&colon;&colon;variant&lowbar;alternative`&period;
| xref:bsl/Vector_DeduceIteratorCategory-0d.adoc[`Vector&lowbar;DeduceIteratorCategory`] 
| This `struct` provides a primitive means to distinguish between iterator types and fundamental types, in order to dispatch to the correct implementation of a function template (or constructor template) passed two arguments of identical type&period; By default, it is assumed that any type that is not a fundamental type, as determined by the type trait `bsl&colon;&colon;is&lowbar;fundamental`, must be an iterator type&period; `std&colon;&colon;iterator&lowbar;traits` is updated in C&plus;&plus;17 to provide a SFINAE&hyphen;friendly instantiation of the primary&hyphen;template for types that do not provide all of the nested typedef names, but we cannot portably rely on such a scheme yet&period;
| xref:bsl/Vector_PushProctor.adoc[`Vector&lowbar;PushProctor`] 
| This class template provides a proctor for a newly created object that is managed by an allocator&period; The object will be constructed through a call to `allocator&lowbar;traits&lt;ALLOCATOR&gt;&colon;&colon;construct`, and it should be destroyed by a call to `allocator&lowbar;traits&lt;ALLOCATOR&gt;&colon;&colon;destroy`&period; Note that this proctor takes no responsibility for the allocated memory that the supplied value is constructed in&period;
| xref:bsl/Vector_RangeIteratorCategory-09.adoc[`Vector&lowbar;RangeIteratorCategory`] 
| This `struct` provides a primitive means to determine the iterator category for an iterator&sol;sentinel pair where there is a preference to treat any iterator where the `insertDistance` can be computed as a forward iterator, even if it does not meet the ranges concepts needed to be treated as one&period;
| xref:bsl/Vector_Util.adoc[`Vector&lowbar;Util`] 
| This `struct` provides a namespace for implementing the `swap` member function of `vector&lt;VALUE&lowbar;TYPE, ALLOCATOR&gt;`&period; `swap` can be implemented irrespective of the `VALUE&lowbar;TYPE` or `ALLOCATOR` template parameters, which is why we implement it in this non&hyphen;parameterized, non&hyphen;inlined utility&period;
| xref:bsl/_Alloc_traits.adoc[`&lowbar;Alloc&lowbar;traits`] 
| Traits for rebinding STLPort allocators to a different value type&period;
| xref:bsl/_Const_traits.adoc[`&lowbar;Const&lowbar;traits`] 
| Iterator traits for `const` access to objects of type `&lowbar;Tp`&period;
| xref:bsl/_Hashtable_iterator.adoc[`&lowbar;Hashtable&lowbar;iterator`] 
| 
| xref:bsl/_Hashtable_node.adoc[`&lowbar;Hashtable&lowbar;node`] 
| Internal hashtable node holding a value and a next&hyphen;node pointer&period;
| xref:bsl/_Ht_iterator.adoc[`&lowbar;Ht&lowbar;iterator`] 
| 
| xref:bsl/_Nonconst_traits.adoc[`&lowbar;Nonconst&lowbar;traits`] 
| Iterator traits for modifiable access to objects of type `&lowbar;Tp`&period;
| xref:bsl/_STLP_alloc_proxy.adoc[`&lowbar;STLP&lowbar;alloc&lowbar;proxy`] 
| Proxy combining an allocator with a stored value for STLPort containers&period;
| xref:bsl/_Sl_global.adoc[`&lowbar;Sl&lowbar;global`] 
| Shared algorithms for intrusive singly&hyphen;linked list node manipulation&period;
| xref:bsl/_Slist_base.adoc[`&lowbar;Slist&lowbar;base`] 
| Allocator&hyphen;aware base that owns the sentinel head node of an `slist`&period;
| xref:bsl/_Slist_iterator.adoc[`&lowbar;Slist&lowbar;iterator`] 
| Forward iterator over an `slist` of `&lowbar;Tp` with constness from `&lowbar;Traits`&period;
| xref:bsl/_Slist_iterator_base.adoc[`&lowbar;Slist&lowbar;iterator&lowbar;base`] 
| Non&hyphen;templated base for forward iterators over an slist&period;
| xref:bsl/_Slist_node.adoc[`&lowbar;Slist&lowbar;node`] 
| Singly&hyphen;linked list node storing a value of type `&lowbar;Tp`&period;
| xref:bsl/_Slist_node_base.adoc[`&lowbar;Slist&lowbar;node&lowbar;base`] 
| Intrusive singly&hyphen;linked list node base holding a next pointer&period;
| xref:bsl/_Stl_prime.adoc[`&lowbar;Stl&lowbar;prime`] 
| Table of prime bucket counts used for hash table sizing&period;
| xref:bsl/add_const.adoc[`add&lowbar;const`] 
| This `struct` template implements the `add&lowbar;const` meta&hyphen;function defined in the C&plus;&plus;11 standard &lsqb;meta&period;trans&period;cv&rsqb;, providing an alias, `type`, that returns the result&period; If the (template parameter) `t&lowbar;TYPE` is not a reference type, nor a function type, nor already `const`&hyphen;qualified at the top&hyphen;level, then `type` is an alias to `t&lowbar;TYPE` with a top&hyphen;level `const`&hyphen;qualifier added&semi; otherwise, `type` is an alias to `t&lowbar;TYPE`&period;
| xref:bsl/add_cv.adoc[`add&lowbar;cv`] 
| This `struct` template implements the `add&lowbar;cv` meta&hyphen;function defined in the C&plus;&plus;11 standard &lsqb;meta&period;trans&period;cv&rsqb;, providing an alias, `type`, that returns the result&period; If the (template parameter) `t&lowbar;TYPE` is not a reference type, nor a function type, nor already `const`&hyphen;qualified and `volatile`&hyphen;qualified at the top&hyphen;level, then `type` is an alias to `t&lowbar;TYPE` with a top&hyphen;level `const`&hyphen;qualifier and a `volatile`&hyphen;qualifier added&semi; otherwise, `type` is an alias to `t&lowbar;TYPE`&period;
| xref:bsl/add_lvalue_reference-0e2.adoc[`add&lowbar;lvalue&lowbar;reference`] 
| This `struct` template implements a meta&hyphen;function to transform the (template parameter) `t&lowbar;TYPE` to its lvalue reference type&period;
| xref:bsl/add_pointer-080.adoc[`add&lowbar;pointer`] 
| This `struct` template implements the `add&lowbar;pointer` meta&hyphen;function defined in the C&plus;&plus;11 standard &lsqb;meta&period;trans&period;ptr&rsqb;, providing an alias, `type`, that returns the result&period; If the (template parameter) `t&lowbar;TYPE` is not a reference type, then `type` is an alias to a pointer type that points to `t&lowbar;TYPE`&semi; otherwise, `type` is an alias to a pointer type that points to the type referred to by the reference `t&lowbar;TYPE`, unless it is not legal to form such a pointer type, in which case `type` is an alias for `t&lowbar;TYPE`&period;
| xref:bsl/add_rvalue_reference-00.adoc[`add&lowbar;rvalue&lowbar;reference`] 
| This `struct` template implements a meta&hyphen;function to transform the (template parameter) `t&lowbar;TYPE` to its rvalue reference type&period;
| xref:bsl/add_volatile.adoc[`add&lowbar;volatile`] 
| This `struct` template implements the `add&lowbar;volatile` meta&hyphen;function defined in the C&plus;&plus;11 standard &lsqb;meta&period;trans&period;cv&rsqb;, providing an alias, `type`, that returns the result&period; If the (template parameter) `t&lowbar;TYPE` is not a reference type, nor a function type, nor already `volatile`&hyphen;qualified at the top&hyphen;level, then `type` is an alias to `t&lowbar;TYPE` with a top&hyphen;level `volatile`&hyphen;qualifier added&semi; otherwise, `type` is an alias to `t&lowbar;TYPE`&period;
| xref:bsl/allocator-0df.adoc[`allocator`] 
| An STL&hyphen;compatible allocator that forwards allocation calls to an underlying mechanism object of a type derived from `bslma&colon;&colon;Allocator`&period; This class template adheres to the allocator requirements defined in section &lsqb;allocator&period;requirements&rsqb;and implements a superset of the `std&colon;&colon;pmr&colon;&colon;polymorphic&lowbar;allocator` class template described in section &lsqb;mem&period;poly&period;allocator&period;class&rsqb;of the C&plus;&plus; standard and may be used to instantiate any &lsqb;container&rsqb;class template that follows the STL allocator protocol&period; The allocation mechanism is chosen at run&hyphen;time, giving the programmer run&hyphen;time control over how a container allocates and frees memory&period;
| xref:bsl/allocator_arg_t-0b.adoc[`allocator&lowbar;arg&lowbar;t`] 
| Tag type indicating that next argument is an allocator&period; TBD&colon; If native library declares `std&colon;&colon;allocator&lowbar;arg&lowbar;t`, then this struct should be an replaced by an alias for `std&colon;&colon;allocator&lowbar;arg&lowbar;t`&period;
| xref:bsl/allocator_traits-0108.adoc[`allocator&lowbar;traits`] 
| This class supports the complete interface of the C&plus;&plus;11 `allocator&lowbar;traits` class template, which provides a uniform mechanism for accessing nested types within, and operations on, any standard&hyphen;conforming allocator&period; A specialization of this class template for `bsl&colon;&colon;allocator` provides support for Bloomberg&apos;s `bslma` allocator model (see the `bslma&lowbar;bslallocator` component for more details)&period; In C&plus;&plus;11 compilation environments, the `construct` methods forward to the allocator&apos;s `construct` method if such a method matching the (variable number of) specified constructor arguments exists&semi; otherwise, the `construct` method falls back to invoking the constructor of the element type directly&period; In C&plus;&plus;03 compilation environments, there is no reliable way to detect if the type provide a method that matches a (variable number of) specified arguments&semi; therefore, we require that standard allocator types define `construct` methods taking a variable number of arguments in those environments&period; This implementation is not fully&hyphen;standard&hyphen;conforming in that it does not support deduce data types that are not specified in the allocator&period;
| xref:bsl/basic_istringstream.adoc[`basic&lowbar;istringstream`] 
| This class implements a standard input stream that provides a constructor and manipulator for setting the sequence of characters from which input is streamed to a supplied `bsl&colon;&colon;basic&lowbar;string`&period;
| xref:bsl/basic_ostringstream.adoc[`basic&lowbar;ostringstream`] 
| This class implements a standard output stream that provides an accessor for obtaining a `bsl&colon;&colon;basic&lowbar;string` containing the sequence of characters that have been written to the stream&period;
| xref:bsl/basic_osyncstream.adoc[`basic&lowbar;osyncstream`] 
| Forward declaration of `basic&lowbar;osyncstream`&period;
| xref:bsl/basic_string-0faf.adoc[`basic&lowbar;string`] 
| This class template provides an STL&hyphen;compliant `string` that conforms to the `bslma&colon;&colon;Allocator` model&period; For the requirements of a string class, consult the second revision of the ISO&sol;IEC 14882 Programming Language C&plus;&plus; (2003)&period; Note that the (template parameter) `CHAR&lowbar;TYPE` must be _equal_ to `ALLOCATOR&colon;&colon;value&lowbar;type`&period; In addition, this implementation offers strong exception guarantees (see below), with the general rules that&colon;
| xref:bsl/basic_stringbuf.adoc[`basic&lowbar;stringbuf`] 
| This class implements a standard stream buffer providing an unformatted character input sequence and an unformatted character output sequence that may be initialized or accessed using a string value&period;
| xref:bsl/basic_stringstream.adoc[`basic&lowbar;stringstream`] 
| This class implements a standard stream providing operations using `bsl&colon;&colon;basic&lowbar;string` for modifying or accessing the sequence of characters read from, or written to, the stream&period;
| xref:bsl/basic_syncbuf.adoc[`basic&lowbar;syncbuf`] 
| Forward declaration of `basic&lowbar;syncbuf`&period;
| xref:bsl/binary_compose.adoc[`binary&lowbar;compose`] 
| This class provides a function object adaptor for three other functors&period; When given two adaptable unary functions `g1` and `g2`, and a third adaptable binary function `f`, and if `g1` and `g2`s argument type is convertible to `f`s argument type, this class can be used to create a function object `h` that is equivalent to `f(g1(x), g2(x))`&period;
| xref:bsl/bitset.adoc[`bitset`] 
| This class template provides an STL&hyphen;compliant `bitset`&period; For the requirements of a `bitset` class, consult the second revision of the ISO&sol;IEC 14882 Programming Language c&plus;&plus; (2011)&period;
| xref:bsl/conditional-0c.adoc[`conditional`] 
| This `struct` template implements the `conditional` meta&hyphen;function defined in the C&plus;&plus; standard &lsqb;meta&period;trans&period;other&rsqb;, providing an alias, `type`, that returns the result&period; If the (template parameter) value `t&lowbar;COND` is `true`, then `type` has the same type as the (template parameter) type `t&lowbar;TRUE&lowbar;TYPE`&semi; otherwise, `type` has the same type as the (template parameter) type `t&lowbar;FALSE&lowbar;TYPE`&period; Note that this generic default template defines `type` to be an alias to `t&lowbar;TRUE&lowbar;TYPE` for when `t&lowbar;COND` is `true`&period; A template specialization is provided (below) handles the case for when `t&lowbar;COND` is `false`&period;
| xref:bsl/decay.adoc[`decay`] 
| Metafunction to return the variant of the specified parameter `t&lowbar;TYPE` used for pass&hyphen;by&hyphen;reference, e&period;g&period;, by applying array&hyphen;to&hyphen;pointer and function&hyphen;to&hyphen;pointer conversion&period;
| xref:bsl/decay_imp-03.adoc[`decay&lowbar;imp`] 
| Component&hyphen;private implementation of `decay`&period; Do not use&period;
| xref:bsl/deque-0c.adoc[`deque`] 
| This class template provides an STL&hyphen;compliant `deque` that conforms to the `bslma&colon;&colon;Allocator` model&period; For the requirements of a deque class, consult the C&plus;&plus;11 standard&period; In particular, this implementation offers the general rules that&colon; 1&period; A call to any method that would result in a deque having a size greater than the value returned by `max&lowbar;size` triggers a call to `bslstl&colon;&colon;StdExceptUtil&colon;&colon;throwLengthError`&period; 2&period; A call to an `at` method that attempts to access a position outside of the valid range of a deque triggers a call to `bslstl&colon;&colon;StdExceptUtil&colon;&colon;throwOutOfRange`&period;
| xref:bsl/enable_if-07.adoc[`enable&lowbar;if`] 
| This `struct` template implements the `enable&lowbar;if` meta&hyphen;function defined in the C&plus;&plus;11 standard &lsqb;meta&period;trans&period;ptr&rsqb;&period; This `struct` template provides a `typedef` `type` that is an alias to the (template parameter) `t&lowbar;TYPE` if the (template parameter) `t&lowbar;COND` is `true`&semi; otherwise, `type` is not provided&period; If `t&lowbar;TYPE` is not specified, it is set to `void`&period; Note that this generic default template provides `type` for when `t&lowbar;COND` is `true`&semi; a template specialization is provided (below) that omits `type` for when `t&lowbar;COND` is `false`&period;
| xref:bsl/enable_shared_from_this.adoc[`enable&lowbar;shared&lowbar;from&lowbar;this`] 
| This class allows an object that is currently managed by a `shared&lowbar;ptr` to safely generate a copy of the managing `shared&lowbar;ptr` object&period; Inheriting from `enable&lowbar;shared&lowbar;from&lowbar;this&lt;ELEMENT&lowbar;TYPE&gt;` provides the (template parameter) `ELEMENT&lowbar;TYPE` type with a member function `shared&lowbar;from&lowbar;this`&period; If an object of type `ELEMENT&lowbar;TYPE` is managed by a `shared&lowbar;ptr` then calling `shared&lowbar;from&lowbar;this` will return a `shared&lowbar;ptr&lt;ELEMENT&lowbar;TYPE&gt;` that shares ownership of that object&period; It is undefined behavior to call `shared&lowbar;from&lowbar;this` on an object unless that object is managed by a `shared&lowbar;ptr`&period;
| xref:bsl/equal_to-0d.adoc[`equal&lowbar;to`] 
| This `struct` defines a binary comparison functor applying `operator&equals;&equals;` to two `VALUE&lowbar;TYPE` objects&period; This class conforms to the C&plus;&plus;11 standard specification of `std&colon;&colon;equal&lowbar;to` that does not require inheriting from `std&colon;&colon;binary&lowbar;function`&period; Note that this class is an empty POD type&period;
| xref:bsl/formatter.adoc[`formatter`] 
| This is the base template for the `bsl&colon;&colon;formatter` class&period; Its members are deleted to ensure attempts to format a type without a partial specialization of `formatter` for that type will result in a compile time error&period;
| xref:bsl/function-0a.adoc[`function`] 
| Forward declaration&period;
| xref:bsl/hash-06.adoc[`hash`] 
| Empty base class for hashing&period; This class, and all explicit and partial specializations of this class, shall conform to the C&plus;&plus;11 Hash Requirements (C&plus;&plus;11 17&period;6&period;3&period;4, &lsqb;hash&period;requirements&rsqb;)&period; Unless this template is explicitly specialized, it will use the default hash algorithm provided by `bslh&colon;&colon;Hash&lt;&gt;` to supply hash values&period; In order to hash a user&hyphen;defined type using `bsl&colon;&colon;hash`, `bsl&colon;&colon;hash` must be explicitly specialized for the type, or, preferably, `hashAppend` must be implemented for the type&period; For more details on `hashAppend` and `bslh&colon;&colon;Hash` see the component `bslh&lowbar;hash`&period;
| xref:bsl/hash_map.adoc[`hash&lowbar;map`] 
| Legacy STLPort hash container mapping unique keys to values&period;
| xref:bsl/hash_multimap.adoc[`hash&lowbar;multimap`] 
| Legacy STLPort hash container mapping keys to possibly duplicate values&period;
| xref:bsl/hash_multiset.adoc[`hash&lowbar;multiset`] 
| Legacy STLPort hash container storing possibly duplicate values&period;
| xref:bsl/hash_set.adoc[`hash&lowbar;set`] 
| Legacy STLPort hash container storing unique values&period;
| xref:bsl/hashtable.adoc[`hashtable`] 
| Internal STLPort hash table used to implement legacy hash containers&period;
| xref:bsl/integral_constant-02.adoc[`integral&lowbar;constant`] 
| Metafunction representing a compile&hyphen;time constant of the specified (template parameter) `t&lowbar;TYPE` with the specified (template parameter) `t&lowbar;VALUE`&period;
| xref:bsl/invoke_result.adoc[`invoke&lowbar;result`] 
| This class is a metafunction that conditionally provides a `type` member that is the type resulting from invoking an object of the specified `t&lowbar;FN` template parameter with arguments of the specified `t&lowbar;ARGTYPES` template parameters&period; More precisely, given types `F`, `T1`, `T2`, &period;&period;&period;, `TN` corresponding to expressions `f`, `t1`, `t2`, &period;&period;&period;, `tN`, `bslmf&colon;&colon;ResultType&lt;F, T1, T2, &period;&period;&period;, TN&gt;&colon;&colon;type` is usually the type of the psuedo&hyphen;expression `(f, t1, t2, &period;&period;&period;, tN)`, as defined in section &lsqb;func&period;rquire&rsqb;of the C&plus;&plus;11 standard&period; If the compiler supports C&plus;&plus;11 `decltype` and the psuedo&hyphen;expression `(f, t1, t2, &period;&period;&period;, tN)` is not well&hyphen;formed, this class provides no `type` member&period; If `t&lowbar;FN` is a class (functor) type and the compiler doesn&apos;t support C&plus;&plus;11 `decltype`, the return type is automatically deduced for fundamental types, `void`, pointers or references to those, or `bsl&colon;&colon;nullptr&lowbar;t` and is deduced by `bslmf&colon;&colon;ResultType&lt;t&lowbar;FN&gt;&colon;&colon;type` otherwise&period; If deduction fails, this metafunction yields `bslmf&colon;&colon;InvokeResultDeductionFailed`&period; See component&hyphen;level documentation for more detail&period;
| xref:bsl/is_arithmetic.adoc[`is&lowbar;arithmetic`] 
| This `struct` template implements the `is&lowbar;arithmetic` meta&hyphen;function defined in the C&plus;&plus;11 standard &lsqb;meta&period;unary&period;comp&rsqb;to determine if the (template parameter) `t&lowbar;TYPE` is an arithmetic type&period; This `struct` derives from `bsl&colon;&colon;true&lowbar;type` if the `t&lowbar;TYPE` is an arithmetic type, and from `bsl&colon;&colon;false&lowbar;type` otherwise&period;
| xref:bsl/is_array-06.adoc[`is&lowbar;array`] 
| This `struct` template implements the `is&lowbar;array` meta&hyphen;function defined in the C&plus;&plus;11 standard &lsqb;meta&period;unary&period;cat&rsqb;to determine if the (template parameter) `t&lowbar;TYPE` is an array type&period; This `struct` derives from `bsl&colon;&colon;true&lowbar;type` if the `t&lowbar;TYPE` is an array type, and `bsl&colon;&colon;false&lowbar;type` otherwise&period;
| xref:bsl/is_bounded_array-0c.adoc[`is&lowbar;bounded&lowbar;array`] 
| This `struct` template implements the `is&lowbar;bounded&lowbar;array` meta&hyphen;function defined in the C&plus;&plus;20 standard &lsqb;meta&period;unary&period;cat&rsqb;to determine if the (template parameter) `t&lowbar;TYPE` is an array type of known bound&period; This `struct` derives from `bsl&colon;&colon;true&lowbar;type` if the `t&lowbar;TYPE` is an array type of known bound, and `bsl&colon;&colon;false&lowbar;type` otherwise&period;
| xref:bsl/is_class.adoc[`is&lowbar;class`] 
| This `struct` template implements the `is&lowbar;class` meta&hyphen;function defined in the C&plus;&plus;11 standard &lsqb;meta&period;unary&period;cat&rsqb;to determine if the (template parameter) `t&lowbar;TYPE` is a class&period; Note that for implementations without native library support, this component will mis&hyphen;diagnose `union` types as classes&period; This would be correct according to the core language definition of a class type, but is an error according to the standard library definition of this type trait&period;
| xref:bsl/is_const-00.adoc[`is&lowbar;const`] 
| This `struct` template implements the `is&lowbar;const` meta&hyphen;function defined in the C&plus;&plus;11 standard &lsqb;meta&period;unary&period;cat&rsqb;to determine if the (template parameter) `t&lowbar;TYPE` is `const`&hyphen;qualified&period; This `struct` derives from `bsl&colon;&colon;true&lowbar;type` if the `t&lowbar;TYPE` is `const`&hyphen;qualified, and `bsl&colon;&colon;false&lowbar;type` otherwise&period; Note that this generic default template derives from `bsl&colon;&colon;false&lowbar;type`&period; A template specialization is provided (below) that derives from `bsl&colon;&colon;true&lowbar;type`&period;
| xref:bsl/is_convertible.adoc[`is&lowbar;convertible`] 
| This `struct` template implements the `is&lowbar;convertible` meta&hyphen;function defined in the C&plus;&plus;11 standard to determine whether the (template parameter) `t&lowbar;FROM&lowbar;TYPE` is implicitly convertible to the (template parameter) `t&lowbar;TO&lowbar;TYPE`&period;
| xref:bsl/is_copy_constructible.adoc[`is&lowbar;copy&lowbar;constructible`] 
| This `struct` template implements a meta&hyphen;function to determine whether the (template parameter) `t&lowbar;TYPE` is copy constructible&period; This `struct` derives from `bsl&colon;&colon;true&lowbar;type` if the `t&lowbar;TYPE` is copy constructible, and from `bsl&colon;&colon;false&lowbar;type` otherwise&period; This meta&hyphen;function has the same syntax as the `is&lowbar;copy&lowbar;constructible` meta&hyphen;function defined in the C&plus;&plus;11 standard &lsqb;meta&period;unary&period;prop&rsqb;&semi; on C&plus;&plus;03 platforms, however, this meta&hyphen;function defaults to `true&lowbar;type` for all types that are not explicitly declared to have the `bslmf&colon;&colon;IsNonCopyable` trait using the `BSLMF&lowbar;NESTED&lowbar;TRAIT&lowbar;DECLARATION` macro&period; To mark a type as non&hyphen;copyable, `bslmf&colon;&colon;IsNonCopyable` must be specialized (for that type) to inherit from `bsl&colon;&colon;true&lowbar;type`&period;
| xref:bsl/is_empty.adoc[`is&lowbar;empty`] 
| This `struct` is a meta&hyphen;function to determine whether the (template parameter) `t&lowbar;TYPE` is an empty class type&period; This `struct` derives from `bsl&colon;&colon;true&lowbar;type` if the `t&lowbar;TYPE` is empty, and from `bsl&colon;&colon;false&lowbar;type` otherwise&period; This meta&hyphen;function has the same syntax as the `is&lowbar;empty` meta&hyphen;function defined in the C&plus;&plus;11 standard &lsqb;meta&period;unary&period;prop&rsqb;&semi; on C&plus;&plus;03 platforms, however, this meta&hyphen;function defaults to `true&lowbar;type` if `t&lowbar;TYPE` is a `class` or `struct` with no non&hyphen;static data members other than bit&hyphen;fields of length 0, no virtual member functions, no virtual base classes, and no base class `B` for which `is&lowbar;empty&lt;B&gt;&colon;&colon;value` is `false`&semi; otherwise `is&lowbar;empty` defaults to `false&lowbar;type`&period; Note that this meta&hyphen;function will fail to compile for a union that is the same size as an empty class in C&plus;&plus;03&period;
| xref:bsl/is_enum.adoc[`is&lowbar;enum`] 
| This `struct` template implements the `is&lowbar;enum` meta&hyphen;function defined in the C&plus;&plus;11 standard &lsqb;meta&period;unary&period;cat&rsqb;to determine if the (template parameter) `t&lowbar;TYPE` is an enumerated type&period; This `struct` derives from `bsl&colon;&colon;true&lowbar;type` if the `t&lowbar;TYPE` is an enumerated type, and from `bsl&colon;&colon;false&lowbar;type` otherwise&period;
| xref:bsl/is_floating_point.adoc[`is&lowbar;floating&lowbar;point`] 
| This `struct` template implements the `is&lowbar;floating&lowbar;point` meta&hyphen;function defined in the C&plus;&plus;11 standard &lsqb;meta&period;unary&period;cat&rsqb;to determine if the (template parameter) `t&lowbar;TYPE` is a floating&hyphen;point type&period;
| xref:bsl/is_function-05.adoc[`is&lowbar;function`] 
| This `struct` template implements the `is&lowbar;function` meta&hyphen;function defined in the C&plus;&plus;11 standard &lsqb;meta&period;unary&period;cat&rsqb;to determine if the (template parameter) `t&lowbar;TYPE` is a function type&period; This `struct` derives from `bsl&colon;&colon;true&lowbar;type` if the `t&lowbar;TYPE` is a function type, and from `bsl&colon;&colon;false&lowbar;type` otherwise&period; This implementation relies on the fact that neither function types nor reference types can be cv&hyphen;qualified so that `is&lowbar;const&lt;const t&lowbar;TYPE&gt;` will actually yield `false`&period;
| xref:bsl/is_fundamental-09.adoc[`is&lowbar;fundamental`] 
| This `struct` template implements a meta&hyphen;function for checking if a type is fundamental as defined in the C&plus;&plus;11 standard &lsqb;basic&period;fundamental&rsqb;&period; Note that this is subtly differemt from `bslmf&colon;&colon;IsFundamental`, which also returns `true&lowbar;type` for references to 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_member_function_pointer-081.adoc[`is&lowbar;member&lowbar;function&lowbar;pointer`] 
| This `struct` template implements the `is&lowbar;member&lowbar;function&lowbar;pointer` meta&hyphen;function defined in the C&plus;&plus;11 standard &lsqb;meta&period;unary&period;cat&rsqb;to determine if the (template parameter) `t&lowbar;TYPE` is a pointer to non&hyphen;static member function type&period; This `struct` derives from `bsl&colon;&colon;true&lowbar;type` if the `t&lowbar;TYPE` is a pointer to non&hyphen;static member function type, and from `bsl&colon;&colon;false&lowbar;type` otherwise&period; Additional specializations are provided below to give the correct answer in all cases&period;
| xref:bsl/is_member_object_pointer-0b.adoc[`is&lowbar;member&lowbar;object&lowbar;pointer`] 
| This `struct` template implements the `is&lowbar;member&lowbar;object&lowbar;pointer` meta&hyphen;function defined in the C&plus;&plus;11 standard &lsqb;meta&period;unary&period;cat&rsqb;to determine if the (template parameter) `t&lowbar;TYPE` is a pointer to non&hyphen;static data member type&period; This `struct` derives from `bsl&colon;&colon;true&lowbar;type` if the `t&lowbar;TYPE` is a pointer to non&hyphen;static data member type, and from `bsl&colon;&colon;false&lowbar;type` otherwise&period;
| xref:bsl/is_member_pointer-0e.adoc[`is&lowbar;member&lowbar;pointer`] 
| This `struct` template implements the `is&lowbar;member&lowbar;pointer` meta&hyphen;function defined in the C&plus;&plus;11 standard &lsqb;meta&period;unary&period;comp&rsqb;to determine if the (template parameter) `t&lowbar;TYPE` is a member pointer type&period; This `struct` derives from `bsl&colon;&colon;true&lowbar;type` if the `t&lowbar;TYPE` is a member pointer type, and from `bsl&colon;&colon;false&lowbar;type` otherwise&period; Additional specializations are provided below to give the correct answer in all cases&period;
| xref:bsl/is_nothrow_move_constructible.adoc[`is&lowbar;nothrow&lowbar;move&lowbar;constructible`] 
| This `struct` template implements a metafunction to determine whether the (template parameter) `t&lowbar;TYPE` has a no&hyphen;throw move constructor&period; This `struct` derives from `bsl&colon;&colon;true&lowbar;type` if the `t&lowbar;TYPE` has a no&hyphen;throw move constructor, and from `bsl&colon;&colon;false&lowbar;type` otherwise&period; This metafunction has the same syntax as the `is&lowbar;nothrow&lowbar;move&lowbar;constructible` metafunction defined in the C&plus;&plus;11 standard &lsqb;meta&period;unary&period;prop&rsqb;&semi; on C&plus;&plus;03 platforms, however, this metafunction can automatically determine the value for trivially copyable types (including scalar types), for reference types, and for class types associating with the `bsl&colon;&colon;is&lowbar;nothrow&lowbar;move&lowbar;constructible` trait using the `BSLMF&lowbar;NESTED&lowbar;TRAIT&lowbar;DECLARATION` macro&period; To support other no&hyphen;throw move constructible types, this template should be specialized to inherit from `bsl&colon;&colon;true&lowbar;type`&period; Note that cv&hyphen;qualified user defined types are rarely no&hyphen;throw move constructible unless they are also trivially copyable, so there are no cv&hyphen;qualified partial specializations of this trait&period;
| xref:bsl/is_pointer-0c.adoc[`is&lowbar;pointer`] 
| This `struct` template implements the `is&lowbar;pointer` meta&hyphen;function defined in the C&plus;&plus;11 standard &lsqb;meta&period;unary&period;cat&rsqb;to determine if the (template parameter) `t&lowbar;TYPE` is a pointer&period; This `struct` derives from `bsl&colon;&colon;true&lowbar;type` if the `t&lowbar;TYPE` is a pointer type (but not a pointer&hyphen;to&hyphen;non&hyphen;static&hyphen;member type), and `bsl&colon;&colon;false&lowbar;type` otherwise&period;
| xref:bsl/is_polymorphic.adoc[`is&lowbar;polymorphic`] 
| This `struct` template implements the `is&lowbar;polymorphic` meta&hyphen;function defined in the C&plus;&plus;11 standard &lsqb;meta&period;unary&period;prop&rsqb;to determine if the (template parameter) `t&lowbar;TYPE` is a (possibly cv&hyphen;qualified) polymorphic type&period; This `struct` derives from `bsl&colon;&colon;true&lowbar;type` if the `t&lowbar;TYPE` is a polymorphic type, and `bsl&colon;&colon;false&lowbar;type` otherwise&period;
| xref:bsl/is_reference-05.adoc[`is&lowbar;reference`] 
| This `struct` template implements the `is&lowbar;reference` meta&hyphen;function defined in the C&plus;&plus;11 standard &lsqb;meta&period;unary&period;comp&rsqb;to determine if the (template parameter) `t&lowbar;TYPE` is a (lvalue or rvalue) reference type&period;
| xref:bsl/is_rvalue_reference-00.adoc[`is&lowbar;rvalue&lowbar;reference`] 
| This `struct` template provides a meta&hyphen;function to determine whether the (template parameter) `t&lowbar;TYPE` is a (possibly cv&hyphen;qualified) rvalue reference type&period; This generic default template derives from `bsl&colon;&colon;false&lowbar;type`&period; A template specialization is provided (below) that derives from `bsl&colon;&colon;true&lowbar;type`&period;
| xref:bsl/is_same-051.adoc[`is&lowbar;same`] 
| This `struct` template provides a meta&hyphen;function to determine whether the (template parameter) `t&lowbar;TYPE1` and the (template parameter) `t&lowbar;TYPE2` are the same&period; This generic default template derives from `bsl&colon;&colon;false&lowbar;type`&period; A template specialization is provided (below) that derives from `bsl&colon;&colon;true&lowbar;type`&period;
| xref:bsl/is_trivially_copyable-044.adoc[`is&lowbar;trivially&lowbar;copyable`] 
| This `struct` template implements a meta&hyphen;function to determine whether the (template parameter) `t&lowbar;TYPE` is trivially copyable&period; This `struct` derives from `bsl&colon;&colon;true&lowbar;type` if the `t&lowbar;TYPE` is trivially copyable, and from `bsl&colon;&colon;false&lowbar;type` otherwise&period; This meta&hyphen;function has the same syntax as the `is&lowbar;trivially&lowbar;copyable` meta&hyphen;function defined in the C&plus;&plus;11 standard &lsqb;meta&period;unary&period;prop&rsqb;&semi; however, this meta&hyphen;function can automatically determine the value for the following types only&colon; reference types, fundamental types, enumerated types, pointers to members, and types declared to have the `bsl&colon;&colon;is&lowbar;trivially&lowbar;copyable` trait using the `BSLMF&lowbar;NESTED&lowbar;TRAIT&lowbar;DECLARATION` macro (the value for other types defaults to `false`)&period; To support other trivially copyable types, this template must be specialized to inherit from `bsl&colon;&colon;true&lowbar;type` for them&period;
| xref:bsl/is_trivially_default_constructible-09c.adoc[`is&lowbar;trivially&lowbar;default&lowbar;constructible`] 
| This `struct` template implements a meta&hyphen;function to determine whether the (template parameter) `t&lowbar;TYPE` is trivially default&hyphen;constructible&period; This `struct` derives from `bsl&colon;&colon;true&lowbar;type` if the `t&lowbar;TYPE` is trivially default&hyphen;constructible, and from `bsl&colon;&colon;false&lowbar;type` otherwise&period; This meta&hyphen;function has the same syntax as the `is&lowbar;trivially&lowbar;default&lowbar;constructible` meta&hyphen;function defined in the C&plus;&plus;11 standard &lsqb;meta&period;unary&period;prop&rsqb;&semi; however, this meta&hyphen;function can automatically determine the value for the following types only&colon; reference types, fundamental types, enums, pointers to members, and types declared to have the `bsl&colon;&colon;is&lowbar;trivially&lowbar;default&lowbar;constructible` trait using the `BSLMF&lowbar;NESTED&lowbar;TRAIT&lowbar;DECLARATION` macro (and the value for other types defaults to `false`)&period; To support other trivially default&hyphen;constructible types, this template must be specialized to inherit from `bsl&colon;&colon;true&lowbar;type` for them&period;
| xref:bsl/is_unbounded_array-00.adoc[`is&lowbar;unbounded&lowbar;array`] 
| This `struct` template implements the `is&lowbar;unbounded&lowbar;array` meta&hyphen;function defined in the C&plus;&plus;20 standard &lsqb;meta&period;unary&period;cat&rsqb;to determine if the (template parameter) `t&lowbar;TYPE` is an array type of unknown bound&period; This `struct` derives from `bsl&colon;&colon;true&lowbar;type` if the `t&lowbar;TYPE` is an array type of unknown bound, and `bsl&colon;&colon;false&lowbar;type` otherwise&period;
| xref:bsl/is_void-06.adoc[`is&lowbar;void`] 
| This `struct` template implements the `is&lowbar;void` meta&hyphen;function defined in the C&plus;&plus;11 standard &lsqb;meta&period;unary&period;cat&rsqb;to determine if the (template parameter) `t&lowbar;TYPE` is the (possibly cv&hyphen;qualified) `void` type&period; This `struct` derives from `bsl&colon;&colon;true&lowbar;type` if `t&lowbar;TYPE` is the `void` type, and `bsl&colon;&colon;false&lowbar;type` otherwise&period;
| xref:bsl/is_volatile-02.adoc[`is&lowbar;volatile`] 
| This `struct` template implements the `is&lowbar;volatile` meta&hyphen;function defined in the C&plus;&plus;11 standard &lsqb;meta&period;unary&period;cat&rsqb;to determine if the (template parameter) `t&lowbar;TYPE` is `volatile`&hyphen;qualified&period; This `struct` derives from `bsl&colon;&colon;true&lowbar;type` if the `t&lowbar;TYPE` is `volatile`&hyphen;qualified, and `bsl&colon;&colon;false&lowbar;type` otherwise&period; Note that this generic default template derives from `bsl&colon;&colon;false&lowbar;type`&period; A template specialization is provided (below) that derives from `bsl&colon;&colon;true&lowbar;type`&period;
| xref:bsl/list-054.adoc[`list`] 
| Forward declaration required by `List&lowbar;NodeProctor`&period;
| xref:bsl/map-0a7.adoc[`map`] 
| This class template implements a value&hyphen;semantic container type holding an ordered sequence of key&hyphen;value pairs having unique keys that provide a mapping from keys (of the template parameter type, `KEY`) to their associated values (of another template parameter type, `VALUE`)&period;
| xref:bsl/multimap-0ae.adoc[`multimap`] 
| This class template implements a value&hyphen;semantic container type holding an ordered sequence of key&hyphen;value pairs having possibly duplicate keys that provide a mapping from keys (of the template parameter type, `KEY`) to their associated values (of another template parameter type, `VALUE`)&period;
| xref:bsl/multiset-03.adoc[`multiset`] 
| This class template implements a value&hyphen;semantic container type holding an ordered sequence of possibly duplicate keys (of the template parameter type, `KEY`)&period;
| xref:bsl/nostopstate_t.adoc[`nostopstate&lowbar;t`] 
| An object of this empty struct can be passed to the constructor of `stop&lowbar;source` to create a `stop&lowbar;source` object that does not refer to any stop state&period;
| xref:bsl/optional-072.adoc[`optional`] 
| 
| xref:bsl/owner_equal.adoc[`owner&lowbar;equal`] 
| Function object that compares `shared&lowbar;ptr`&sol;`weak&lowbar;ptr` owner equality&period;
| xref:bsl/owner_hash.adoc[`owner&lowbar;hash`] 
| Function object that hashes `shared&lowbar;ptr`&sol;`weak&lowbar;ptr` owner identity&period;
| xref:bsl/owner_less-0c.adoc[`owner&lowbar;less`] 
| Function&hyphen;object type that orders two pointers by the ownership of their shared&sol;weak pointer objects rather than by the pointer addresses&period;
| xref:bsl/pair-0b.adoc[`pair`] 
| The class template `pair` provides a pair of public data members, `first` and `second`, of type `T1` and `T2` respectively&period; If either `T1` or `T2` uses `bslma&colon;&colon;Allocator` for memory management, then provide an optional `bslma&colon;&colon;Allocator` argument for each constructor, to be passed through to the constructors of `first` and&sol;or `second` as appropriate&period; The interface to this class is identical to the standard `std&colon;&colon;pair` except for the addition of the allocators&period; Note that the implementation of this class provides `first` and `second` through multiple base classes in order to simplify construction of each member when allowing for the various rules for passing allocators in C&plus;&plus;11&period;
| xref:bsl/priority_queue-034.adoc[`priority&lowbar;queue`] 
| This class is a value&hyphen;semantic class template, adapting a container of the (template parameter) type `CONTAINER`, that holds elements of the (template parameter) type `VALUE`, to provide a highest&hyphen;priority&hyphen;first priority queue data structure, where the priorities of elements are compared by a comparator of the template parameter type, `COMPARATOR`&period; The container object held by a `priority&lowbar;queue` class object is referenced as `c` in the following documentation&period;
| xref:bsl/queue-0a5.adoc[`queue`] 
| This class is a value&hyphen;semantic class template, having a container of the parameterized `CONTAINER` type that holds elements of the parameterized `VALUE` type, to provide a first&hyphen;in&hyphen;first&hyphen;out queue data structure&period; The container object held by a `queue` class object is referenced as `c` in the following function&hyphen;level documentation&period;
| xref:bsl/reference.adoc[`reference`] 
| Proxy providing a mutable reference to a single bit in a `bitset`&period;
| xref:bsl/remove_const-07.adoc[`remove&lowbar;const`] 
| This `struct` template implements the `remove&lowbar;const` meta&hyphen;function defined in the C&plus;&plus;11 standard &lsqb;meta&period;trans&period;cv&rsqb;, providing an alias, `type`, that returns the result&period; `type` has the same type as the (template parameter) `t&lowbar;TYPE` except that any top&hyphen;level `const`&hyphen;qualifier has been removed&period; Note that this generic default template provides a `type` that is an alias to `t&lowbar;TYPE` for when `t&lowbar;TYPE` is not `const`&hyphen;qualified&period; A template specialization is provided (below) that removes the `const`&hyphen;qualifier for when `t&lowbar;TYPE` is `const`&hyphen;qualified&period;
| xref:bsl/remove_cv.adoc[`remove&lowbar;cv`] 
| This `struct` template implements the `remove&lowbar;cv` meta&hyphen;function defined in the C&plus;&plus;11 standard &lsqb;meta&period;trans&period;cv&rsqb;, providing an alias, `type`, that returns the result&period; `type` has the same type as the (template parameter) `t&lowbar;TYPE` except that any top&hyphen;level cv&hyphen;qualifiers have been removed&period;
| xref:bsl/remove_extent-06.adoc[`remove&lowbar;extent`] 
| From the C&plus;&plus;14 standard&colon; If `T` names a type &quot;array of `U`&quot;, the member typedef `type` shall be `U`, otherwise `T`&period; &lsqb; _Note&colon;_ For&rsqb; multidimensional arrays, only the first array dimension is removed&period; For a type &quot;array of `const U`&quot;, the resulting type is `const U`&period; &hyphen;&hyphen; &ast;end note&ast; &rsqb;
| xref:bsl/remove_pointer.adoc[`remove&lowbar;pointer`] 
| This `struct` template implements the `remove&lowbar;pointer` meta&hyphen;function defined in the C&plus;&plus;11 standard &lsqb;meta&period;trans&period;ptr&rsqb;, providing an alias, `type`, that returns the result&period; If the (template parameter) `t&lowbar;TYPE` is a (possibly cv&hyphen;qualified) pointer type, then `type` is an alias to the type pointed to by `t&lowbar;TYPE`&semi; otherwise, `type` is an alias to `t&lowbar;TYPE`&period;
| xref:bsl/remove_volatile-0c.adoc[`remove&lowbar;volatile`] 
| This `struct` template implements the `remove&lowbar;volatile` meta&hyphen;function defined in the C&plus;&plus;11 standard &lsqb;meta&period;trans&period;cv&rsqb;, providing an alias, `type`, that returns the result&period; `type` has the same type as the (template parameter) `t&lowbar;TYPE` except that any top&hyphen;level `volatile`&hyphen;qualifier has been removed&period; Note that this generic default template provides a `type` that is an alias to `t&lowbar;TYPE` for when `t&lowbar;TYPE` is not `volatile`&hyphen;qualified&period; A template specialization is provided (below) that removes the `volatile`&hyphen;qualifier for when `t&lowbar;TYPE` is `volatile`&hyphen;qualified&period;
| xref:bsl/select1st.adoc[`select1st`] 
| This `struct` is a functor that returns the `first` member of its `PAIR` argument&period;
| xref:bsl/select2nd.adoc[`select2nd`] 
| This `struct` is a functor that returns the `second` member of its `PAIR` argument&period;
| xref:bsl/set-0d.adoc[`set`] 
| This class template implements a value&hyphen;semantic container type holding an ordered sequence of unique keys (of the template parameter type, `KEY`)&period;
| xref:bsl/shared_ptr-0a.adoc[`shared&lowbar;ptr`] 
| This class provides a thread&hyphen;safe reference&hyphen;counted &quot;smart pointer&quot; to support &quot;shared ownership&quot; of objects&colon; a shared pointer ensures that the shared object is destroyed, using the appropriate deletion method, only when there are no shared references to it&period; The object (of template parameter type `ELEMENT&lowbar;TYPE`) referred to by a shared pointer may be accessed directly using the `&hyphen;&gt;` operator, or the dereference operator (operator `&ast;`) can be used to obtain a reference to that object&period;
| xref:bsl/slist.adoc[`slist`] 
| Singly&hyphen;linked list container with constant&hyphen;time front insertion&period;
| xref:bsl/stack-05.adoc[`stack`] 
| This `class` defines a container adapter which supports access primarily via `push`, `pop`, and `top`&period; This type can be based on a variety of other container types, including `deque`, `vector`, and `list`&period; This type is value&hyphen;semantic if the supporting `CONTAINER` and `VALUE` are value&hyphen;semantic&period;
| xref:bsl/stop_callback-06.adoc[`stop&lowbar;callback`] 
| This class holds an object or reference of type `t&lowbar;CALLBACK` and, when constructed using a `stop&lowbar;token` that owns a stop state, schedules the held object or reference to be executed by the thread that requests cancellation on that stop state (if any)&period; However, if cancellation was already requested before the `stop&lowbar;callback` was constructed, the constructor invokes the callback immediately&period; If there is no stop state, or `request&lowbar;stop` is never called for the stop state, then the callback is not invoked&period; `stop&lowbar;callback` stores its callback within its own footprint, and thus never requires memory allocation&semi; however, `stop&lowbar;callback&lt;t&lowbar;CALLBACK&gt;` is an allocator&hyphen;aware class, if `t&lowbar;CALLBACK` is an allocator&hyphen;aware class, and any supplied allocator will then be passed to the constructor of `t&lowbar;CALLBACK`&period;
| xref:bsl/stop_source.adoc[`stop&lowbar;source`] 
| This class is a mechanism for making and observing cancellation requests&period; An object of this class may have (possibly shared) ownership of a stop state, in which case it can be used to make a cancellation request or observe whether a cancellation request has been made on the owned stop state&semi; it is also possible for a `stop&lowbar;source` object to not own a stop state&period; Due to its shared ownership semantics, it is safe to pass a copy of a `stop&lowbar;source` object to a callback that might outlive the original `stop&lowbar;source` object&semi; however, a callback that should only be able to observe a cancellation request, without being able to request cancellation itself, should instead be passed a `stop&lowbar;token`, which can be created by calling `stop&lowbar;source&colon;&colon;get&lowbar;token`&period;
| xref:bsl/stop_token.adoc[`stop&lowbar;token`] 
| This class is a mechanism for observing cancellation requests&period; An object of this class either has (possibly shared) ownership of a stop state and can be used to observe whether a cancellation request has been made on that stop state, or does not own a stop state&period; A `stop&lowbar;token` cannot be used to make a cancellation request&period;
| xref:bsl/type_index.adoc[`type&lowbar;index`] 
| This class implements an in&hyphen;core value&hyphen;semantic type wrapping a standard `type&lowbar;info` object&period;
| xref:bsl/unary_compose.adoc[`unary&lowbar;compose`] 
| This class provides a function object adaptor for two other functors&period; When given two adaptable unary functions `f` and `g`, and when `g`s return type is convertible to `f`s argument type, this class can be used to create a function object `h` that is equivalent to `f(g(x))`&period;
| xref:bsl/unordered_map-02b.adoc[`unordered&lowbar;map`] 
| This class template implements a value&hyphen;semantic container type holding an unordered set of `KEY&hyphen;VALUE` pairs having unique keys that provide a mapping from keys (of template parameter type `KEY`) to their associated mapped values (of template parameter type `VALUE`)&period;
| xref:bsl/unordered_multimap-0b0.adoc[`unordered&lowbar;multimap`] 
| This class template implements a value&hyphen;semantic container type holding a collection of (possibly equivalent) keys (of the template parameter type `KEY`), each mapped to their associated values (of another template parameter type `VALUE`)&period;
| xref:bsl/unordered_multiset-06c.adoc[`unordered&lowbar;multiset`] 
| This class template implements a value&hyphen;semantic container type holding an unordered multiset of values (of template parameter type `KEY`)&period;
| xref:bsl/unordered_set-0d2d.adoc[`unordered&lowbar;set`] 
| This class template implements a value&hyphen;semantic container type holding an unordered set of unique values (of template parameter type `KEY`)&period;
| xref:bsl/uses_allocator.adoc[`uses&lowbar;allocator`] 
| This `struct` template implements a meta&hyphen;function to determine whether a (template parameter) `t&lowbar;TYPE` uses a given (template parameter) `t&lowbar;ALLOCATOR&lowbar;TYPE`&period; This `struct` derives from `bsl&colon;&colon;true&lowbar;type` if `t&lowbar;TYPE` uses `t&lowbar;ALLOCATOR&lowbar;TYPE` and from `bsl&colon;&colon;false&lowbar;type` otherwise&period; This meta&hyphen;function has the same syntax as the `uses&lowbar;allocator` meta&hyphen;function defined in the C&plus;&plus;11 standard &lsqb;allocator&period;uses&period;trait&rsqb;&period;
| xref:bsl/variant.adoc[`variant`] 
| 
| xref:bsl/variant_alternative-0c.adoc[`variant&lowbar;alternative`] 
| This metafunction calculates the type of the alternative whose index is (template parameter) `t&lowbar;INDEX` in the possibly cv&hyphen;qualified `bsl&colon;&colon;variant` type of (template parameter) `t&lowbar;TYPE`&period; If `t&lowbar;TYPE` is cv&hyphen;qualified, its cv&hyphen;qualifiers are applied to the alternative&period;
| xref:bsl/variant_size-07.adoc[`variant&lowbar;size`] 
| This metafunction calculates the number of alternatives in the (possibly cv&hyphen;qualified) `bsl&colon;&colon;variant` type of (template parameter) `t&lowbar;BSL&lowbar;VARIANT`&period; The primary template is not defined&period;
| xref:bsl/vector-00d.adoc[`vector`] 
| This class template provides an STL&hyphen;compliant `vector` that conforms to the `bslma&colon;&colon;Allocator` model&period; For the requirements of a vector class, consult the C&plus;&plus;11 standard&period; In particular, this implementation offers the general rules that&colon;
| xref:bsl/vectorBase-06a.adoc[`vectorBase`] 
| This class describes the basic layout for a vector class, to be included into the `vector` layout _before_ the allocator (provided by `bslalg&colon;&colon;ContainerBase`) to take better advantage of cache prefetching&period; It is parameterized by `VALUE&lowbar;TYPE` only, and implements the portion of `vector` that does not need to know about its (template parameter) type `ALLOCATOR` (in order to generate shorter debug strings)&period; This class intentionally has *no* creators (other than the compiler&hyphen;generated ones)&period;
| xref:bsl/vector_ForwardIteratorForPtrs-08.adoc[`vector&lowbar;ForwardIteratorForPtrs`] 
| This metafunction provides an appropriate iterator adaptor for the specified (template parameter) type `ITERATOR` in order to implement members of the `vector` partial template specialization for vectors of pointers to the (template parameter) type `TARGET`&period; The metafunction will return the original `ITERATOR` type unless it truly is an iterator, using `is&lowbar;integral` as a proxy for testing that a type is NOT an iterator&period; This is needed to disambiguate only the cases of users passing `0` as a null&hyphen;pointer value to functions requesting a number of identical copies of an element&period;
| xref:bsl/vector_UintPtrConversionIterator.adoc[`vector&lowbar;UintPtrConversionIterator`] 
| This class provides a minimal proxy iterator adapter, transforming pointers to `uintptr&lowbar;t` values on the fly, for only the operations needed to implement the member functions and constructors of the `vector` partial template specialization that take iterator ranges as arguments&period; While it does not provide a standard conforming iterator itself, if provides exactly sufficient behavior to implement all the needed members&period; `VALUE&lowbar;TYPE` shall be a pointer type, and `ITERATOR` shall be a standard conforming iterator that dereferences to a type implicitly convertible to `VALUE&lowbar;TYPE`
| xref:bsl/vector_UintPtrRangeAdapter.adoc[`vector&lowbar;UintPtrRangeAdapter`] 
| This class provides a minimal proxy range adapter, transforming pointers to `uintptr&lowbar;t` values on the fly, for only the operations needed to implement the member functions and constructors of the `vector` partial template specialization that take iterator ranges as arguments&period; While it does not provide a standard conforming iterator itself, if provides exactly sufficient behavior to implement all the needed members&period; `t&lowbar;VALUE&lowbar;TYPE` shall be a pointer type, and `&lsqb;d&lowbar;begin, d&lowbar;end)&rsqb;` is a range of the input values&period;
| xref:bsl/weak_ptr-0d.adoc[`weak&lowbar;ptr`] 
| This `friend` declaration provides access to the internal data members while constructing a weak pointer from a weak pointer of a different type&period;
|===


== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:bsl/ErrcEnum.adoc[`ErrcEnum`] 
| Portable typedef for `std&colon;&colon;errc`&period;
| xref:bsl/Pair_BslmaIdiomAllocatorArgT.adoc[`Pair&lowbar;BslmaIdiomAllocatorArgT`] 
| Type tag for types that take a `bslma&colon;&colon;Allocator&ast;` as the second argument of their constructors, following an argument of type `bsl&colon;&colon;allocator&lowbar;arg&lowbar;t`&period;
| xref:bsl/Pair_BslmaIdiomAtEnd.adoc[`Pair&lowbar;BslmaIdiomAtEnd`] 
| Type tag for types that take a `bslma&colon;&colon;Allocator&ast;` as the last argument of their constructors&period;
| xref:bsl/Pair_BslmaIdiomNone.adoc[`Pair&lowbar;BslmaIdiomNone`] 
| Type tag for types that do not take a `bslma&colon;&colon;Allocator&ast;` constructor argument&period;
| xref:bsl/String_ComparisonCategoryType.adoc[`String&lowbar;ComparisonCategoryType`] 
| Alias for the comparison category type of `basic&lowbar;string`&period;
| xref:bsl/SyncBuf_Mutex.adoc[`SyncBuf&lowbar;Mutex`] 
| Mutex type used to synchronize `basic&lowbar;syncbuf` emission&period;
| xref:bsl/_Sl_global_inst.adoc[`&lowbar;Sl&lowbar;global&lowbar;inst`] 
| Instantiation of `&lowbar;Sl&lowbar;global` providing shared slist node algorithms&period;
| xref:bsl/_Stl_prime_type.adoc[`&lowbar;Stl&lowbar;prime&lowbar;type`] 
| Alias for `&lowbar;Stl&lowbar;prime&lt;bool&gt;` providing the prime bucket&hyphen;count table&period;
| xref:bsl/__oom_handler_type.adoc[`&lowbar;&lowbar;oom&lowbar;handler&lowbar;type`] 
| Function&hyphen;pointer type for an out&hyphen;of&hyphen;memory handler&period;
| xref:bsl/add_const_t.adoc[`add&lowbar;const&lowbar;t`] 
| `add&lowbar;const&lowbar;t` is an alias to the return type of the `add&lowbar;const` meta&hyphen;function&period; Note, that the `add&lowbar;const&lowbar;t` avoids the `&colon;&colon;type` suffix and `typename` prefix when we want to use the result of the meta&hyphen;function in templates&period;
| xref:bsl/add_cv_t.adoc[`add&lowbar;cv&lowbar;t`] 
| `add&lowbar;cv&lowbar;t` is an alias to the return type of the `bsl&colon;&colon;add&lowbar;cv` meta&hyphen;function&period; Note, that the `add&lowbar;cv&lowbar;t` avoids the `&colon;&colon;type` suffix and `typename` prefix when we want to use the result of the `bsl&colon;&colon;add&lowbar;cv` in templates&period;
| xref:bsl/add_lvalue_reference_t.adoc[`add&lowbar;lvalue&lowbar;reference&lowbar;t`] 
| `add&lowbar;lvalue&lowbar;reference&lowbar;t` is an alias to the return type of `add&lowbar;lvalue&lowbar;reference` meta&hyphen;function&period; Note, that the `add&lowbar;const&lowbar;t` avoids the `&colon;&colon;type` suffix and `typename` prefix when we want to use the result of the meta&hyphen;function in templates&period;
| xref:bsl/add_pointer_t.adoc[`add&lowbar;pointer&lowbar;t`] 
| `add&lowbar;pointer&lowbar;t` is an alias to the return type of the `bsl&colon;&colon;add&lowbar;pointer` meta&hyphen;function&period; Note, that the `remove&lowbar;pointer&lowbar;t` avoids the `&colon;&colon;type` suffix and `typename` prefix when we want to use the result of the meta&hyphen;function in templates&period;
| xref:bsl/add_rvalue_reference_t.adoc[`add&lowbar;rvalue&lowbar;reference&lowbar;t`] 
| `add&lowbar;rvalue&lowbar;reference&lowbar;t` is an alias to the return type of `add&lowbar;rvalue&lowbar;reference` meta&hyphen;function&period; Note, that the `add&lowbar;const&lowbar;t` avoids the `&colon;&colon;type` suffix and `typename` prefix when we want to use the result of the meta&hyphen;function in templates&period;
| xref:bsl/add_volatile_t.adoc[`add&lowbar;volatile&lowbar;t`] 
| `add&lowbar;volatile&lowbar;t` is an alias to the return type of the `bsl&colon;&colon;add&lowbar;volatile` meta&hyphen;function&period; Note, that the `bsl&colon;&colon;add&lowbar;volatile&lowbar;t` avoids the `&colon;&colon;type` suffix and `typename` prefix when we want to use the result of the meta&hyphen;function in templates&period;
| xref:bsl/aligned_storage.adoc[`aligned&lowbar;storage`]  [.small]#[deprecated]#
| Alias for `std&colon;&colon;aligned&lowbar;storage` in the `bsl` namespace&period;
| xref:bsl/aligned_storage_t.adoc[`aligned&lowbar;storage&lowbar;t`]  [.small]#[deprecated]#
| Alias for `std&colon;&colon;aligned&lowbar;storage&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/aligned_union.adoc[`aligned&lowbar;union`]  [.small]#[deprecated]#
| Alias for `std&colon;&colon;aligned&lowbar;union` in the `bsl` namespace&period;
| xref:bsl/aligned_union_t.adoc[`aligned&lowbar;union&lowbar;t`]  [.small]#[deprecated]#
| Alias for `std&colon;&colon;aligned&lowbar;union&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/bad_optional_access.adoc[`bad&lowbar;optional&lowbar;access`] 
| Alias for `std&colon;&colon;bad&lowbar;optional&lowbar;access` in the `bsl` namespace&period;
| xref:bsl/bad_weak_ptr.adoc[`bad&lowbar;weak&lowbar;ptr`] 
| Alias for `BloombergLP&colon;&colon;bslstl&colon;&colon;BadWeakPtr`&period;
| xref:bsl/bool_constant.adoc[`bool&lowbar;constant`] 
| Alias for `integral&lowbar;constant&lt;bool, t&lowbar;VALUE&gt;`&period;
| xref:bsl/common_type_t.adoc[`common&lowbar;type&lowbar;t`] 
| Alias for `std&colon;&colon;common&lowbar;type&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/conditional_t.adoc[`conditional&lowbar;t`] 
| `conditional&lowbar;t` is an alias to the return type of the `bsl&colon;&colon;conditional` meta&hyphen;function&period; Note, that the `conditional&lowbar;t` avoids the `&colon;&colon;type` suffix and `typename` prefix when we want to use the result of the meta&hyphen;function in templates&period;
| xref:bsl/decay_t.adoc[`decay&lowbar;t`] 
| `decay&lowbar;t` is an alias to the return type of the `bsl&colon;&colon;decay` meta&hyphen;function&period; Note, that the `enable&lowbar;if&lowbar;t` avoids the `&colon;&colon;type` suffix and `typename` prefix when we want to use the result of the meta&hyphen;function in templates&period;
| xref:bsl/enable_if_t.adoc[`enable&lowbar;if&lowbar;t`] 
| `enable&lowbar;if&lowbar;t` is an alias to the return type of the `bsl&colon;&colon;enable&lowbar;if` meta&hyphen;function&period; Note, that the `enable&lowbar;if&lowbar;t` avoids the `&colon;&colon;type` suffix and `typename` prefix when we want to use the result of the meta&hyphen;function in templates&period;
| xref:bsl/false_type.adoc[`false&lowbar;type`] 
| Metafunction representing the boolean constant `false`&period;
| xref:bsl/forward_list.adoc[`forward&lowbar;list`] 
| Singly&hyphen;linked list with `bsl&colon;&colon;allocator` as the default allocator&period;
| xref:bsl/generator.adoc[`generator`] 
| 
| xref:bsl/invoke_result_t.adoc[`invoke&lowbar;result&lowbar;t`] 
| `invoke&lowbar;result&lowbar;t` is an alias to the return type of the `bsl&colon;&colon;invoke&lowbar;result` meta&hyphen;function&period; Note, that the `invoke&lowbar;result&lowbar;t` avoids the `&colon;&colon;type` suffix and `typename` prefix when we want to use the result of the meta&hyphen;function in templates&period;
| xref:bsl/istringstream.adoc[`istringstream`] 
| This `typedef` is an alias to `basic&lowbar;istringstream&lt;char&gt;`&period;
| xref:bsl/make_signed_t.adoc[`make&lowbar;signed&lowbar;t`] 
| Alias for `std&colon;&colon;make&lowbar;signed&lowbar;t&lt;TYPE&gt;` in the `bsl` namespace&period;
| xref:bsl/make_unsigned_t.adoc[`make&lowbar;unsigned&lowbar;t`] 
| Alias for `std&colon;&colon;make&lowbar;unsigned&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/nullopt_t.adoc[`nullopt&lowbar;t`] 
| This `typedef` is an alias to `std&colon;&colon;nullopt&lowbar;t`&period;
| xref:bsl/nullptr_t-08.adoc[`nullptr&lowbar;t`] 
| Standard null pointer type for platforms with native `nullptr` support&period;
| xref:bsl/nullptr_t-0c.adoc[`nullptr&lowbar;t`] 
| Standard null pointer type for platforms with native `nullptr` support&period;
| xref:bsl/ostringstream.adoc[`ostringstream`] 
| This `typedef` is an alias to `basic&lowbar;ostringstream&lt;char&gt;`&period;
| xref:bsl/osyncstream.adoc[`osyncstream`] 
| This `typedef` is an alias to `basic&lowbar;osyncstream&lt;char&gt;`&period;
| xref:bsl/polymorphic_allocator.adoc[`polymorphic&lowbar;allocator`] 
| Alias for `std&colon;&colon;pmr&colon;&colon;polymorphic&lowbar;allocator` in the `bsl` namespace&period;
| xref:bsl/remove_all_extents_t.adoc[`remove&lowbar;all&lowbar;extents&lowbar;t`] 
| Alias for `std&colon;&colon;remove&lowbar;all&lowbar;extents&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/remove_const_t.adoc[`remove&lowbar;const&lowbar;t`] 
| `remove&lowbar;const&lowbar;t` is an alias to the return type of the `bsl&colon;&colon;remove&lowbar;const` meta&hyphen;function&period; Note, that the `remove&lowbar;const&lowbar;t` avoids the `&colon;&colon;type` suffix and `typename` prefix when we want to use the result of the meta&hyphen;function in templates&period;
| xref:bsl/remove_cv_t.adoc[`remove&lowbar;cv&lowbar;t`] 
| `remove&lowbar;cv&lowbar;t` is an alias to the return type of the `bsl&colon;&colon;remove&lowbar;cv` meta&hyphen;function&period; Note, that the `remove&lowbar;cv&lowbar;t` avoids the `&colon;&colon;type` suffix and `typename` prefix when we want to use the result of the meta&hyphen;function in templates&period;
| xref:bsl/remove_extent_t.adoc[`remove&lowbar;extent&lowbar;t`] 
| `remove&lowbar;extent&lowbar;t` is an alias to the return type of the `bsl&colon;&colon;remove&lowbar;extent` meta&hyphen;function&period; Note, that the `enable&lowbar;if&lowbar;t` avoids the `&colon;&colon;type` suffix and `typename` prefix when we want to use the result of the meta&hyphen;function in templates&period;
| xref:bsl/remove_pointer_t.adoc[`remove&lowbar;pointer&lowbar;t`] 
| `remove&lowbar;pointer&lowbar;t` is an alias to the return type of the `bsl&colon;&colon;remove&lowbar;pointer` meta&hyphen;function&period; Note, that the `remove&lowbar;pointer&lowbar;t` avoids the `&colon;&colon;type` suffix and `typename` prefix when we want to use the result of the meta&hyphen;function in templates&period;
| xref:bsl/remove_volatile_t.adoc[`remove&lowbar;volatile&lowbar;t`] 
| `remove&lowbar;volatile&lowbar;t` is an alias to the return type of the `bsl&colon;&colon;remove&lowbar;volatile` meta&hyphen;function&period; Note, that the `remove&lowbar;volatile&lowbar;t` avoids the `&colon;&colon;type` suffix and `typename` prefix when we want to use the result of the meta&hyphen;function in templates&period;
| xref:bsl/result_of_t.adoc[`result&lowbar;of&lowbar;t`] 
| 
| xref:bsl/string.adoc[`string`] 
| Narrow character string type (`basic&lowbar;string&lt;char&gt;`)&period;
| xref:bsl/stringbuf.adoc[`stringbuf`] 
| This `typedef` is an alias to `basic&lowbar;stringbuf&lt;char&gt;`&period;
| xref:bsl/stringstream.adoc[`stringstream`] 
| This `typedef` is an alias to `basic&lowbar;stringstream&lt;char&gt;`&period;
| xref:bsl/syncbuf.adoc[`syncbuf`] 
| This `typedef` is an alias to `basic&lowbar;syncbuf&lt;char&gt;`&period;
| xref:bsl/true_type.adoc[`true&lowbar;type`] 
| Metafunction representing the boolean constant `true`&period;
| xref:bsl/tuple_element_t.adoc[`tuple&lowbar;element&lowbar;t`] 
| Alias for the element type at index `I` of tuple&hyphen;like `TYPE`&period;
| xref:bsl/u16string.adoc[`u16string`] 
| UTF&hyphen;16 string type (`basic&lowbar;string&lt;char16&lowbar;t&gt;`)&period;
| xref:bsl/u32string.adoc[`u32string`] 
| UTF&hyphen;32 string type (`basic&lowbar;string&lt;char32&lowbar;t&gt;`)&period;
| xref:bsl/u8string.adoc[`u8string`] 
| UTF&hyphen;8 string type (`basic&lowbar;string&lt;char8&lowbar;t&gt;`)&period;
| xref:bsl/underlying_type_t.adoc[`underlying&lowbar;type&lowbar;t`] 
| Alias for `std&colon;&colon;underlying&lowbar;type&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/variant_alternative_t.adoc[`variant&lowbar;alternative&lowbar;t`] 
| `variant&lowbar;alternative&lowbar;t` is an alias to the return type of the `variant&lowbar;alternative` metafunction&period;
| xref:bsl/void_t.adoc[`void&lowbar;t`] 
| Alias template that always yields `void`&period;
| xref:bsl/wistringstream.adoc[`wistringstream`] 
| This `typedef` is an alias to `basic&lowbar;istringstream&lt;wchar&lowbar;t&gt;`&period;
| xref:bsl/wostringstream.adoc[`wostringstream`] 
| This `typedef` is an alias to `basic&lowbar;ostringstream&lt;wchar&lowbar;t&gt;`&period;
| xref:bsl/wosyncstream.adoc[`wosyncstream`] 
| This `typedef` is an alias to `basic&lowbar;osyncstream&lt;wchar&lowbar;t&gt;`&period;
| xref:bsl/wstring.adoc[`wstring`] 
| Wide character string type (`basic&lowbar;string&lt;wchar&lowbar;t&gt;`)&period;
| xref:bsl/wstringbuf.adoc[`wstringbuf`] 
| Wide&hyphen;character string stream buffer type&period;
| xref:bsl/wstringstream.adoc[`wstringstream`] 
| This `typedef` is an alias to `basic&lowbar;stringstream&lt;wchar&lowbar;t&gt;`&period;
| xref:bsl/wsyncbuf.adoc[`wsyncbuf`] 
| This `typedef` is an alias to `basic&lowbar;syncbuf&lt;wchar&lowbar;t&gt;`&period;
|===


== Enums

[cols="1,4"]
|===
| Name| Description
| xref:bsl/AllocConstants.adoc[`AllocConstants`] 
| Constants controlling the internal memory pool used by STLPort allocators&period;
| xref:bsl/MaxDecimalStringLengths.adoc[`MaxDecimalStringLengths`] 
| This `enum` give upper bounds on the maximum string lengths storing each scalar numerical type, and the starting value for `long double` that can get way too long for stack storage when printed&period; It is safe to use stack&hyphen;allocated buffers of these sizes for generating decimal representations of the corresponding type, including sign and terminating null character, using the default precision of 6 significant digits for floating point types&period;
|===


== Functions

[cols="1,4"]
|===
| Name| Description
| xref:bsl/PrintTo-09.adoc[`PrintTo`] 
| `PrintTo` overloads
| xref:bsl/__slist_make_link.adoc[`&lowbar;&lowbar;slist&lowbar;make&lowbar;link`] 
| Link `&lowbar;&lowbar;new&lowbar;node` immediately after `&lowbar;&lowbar;prev&lowbar;node` and return `&lowbar;&lowbar;new&lowbar;node`&period;
| xref:bsl/allocate_shared-0be.adoc[`allocate&lowbar;shared`] 
| `allocate&lowbar;shared` overloads
| xref:bsl/allocate_shared_for_overwrite-05.adoc[`allocate&lowbar;shared&lowbar;for&lowbar;overwrite`] 
| `allocate&lowbar;shared&lowbar;for&lowbar;overwrite` overloads
| xref:bsl/bdlat_valueTypeAssign.adoc[`bdlat&lowbar;valueTypeAssign`] 
| Assign the specified `rhs` vector to the specified `lhs` vector and return 0&period;
| xref:bsl/compose1.adoc[`compose1`] 
| Return an `unary&lowbar;compose` function object constructed using the specified `fn1` and `fn2` unary functions&period; The returned function object is equivalent to `fn1(fn2(x))`&period;
| xref:bsl/compose2.adoc[`compose2`] 
| Return a `binary&lowbar;compose` function object constructed using the specified `fn1` binary function, and the specified `fn2` and `fn3` unary functions&period; The returned function object is equivalent to `fn1(fn2(x), fn3(x))`&period;
| xref:bsl/const_pointer_cast.adoc[`const&lowbar;pointer&lowbar;cast`] 
| Return a `shared&lowbar;ptr&lt;TO&lowbar;TYPE&gt;` object sharing ownership of the same object as the specified `source` shared pointer to the (template parameter) `FROM&lowbar;TYPE`, and referring to `const&lowbar;cast&lt;TO&lowbar;TYPE &ast;&gt;(source&period;get())`&period; Note that if `source` cannot be `const`&hyphen;cast to `TO&lowbar;TYPE &ast;`, then a compiler diagnostic will be emitted indicating the error&period;
| xref:bsl/dynamic_pointer_cast.adoc[`dynamic&lowbar;pointer&lowbar;cast`] 
| Return a `shared&lowbar;ptr&lt;TO&lowbar;TYPE&gt;` object sharing ownership of the same object as the specified `source` shared pointer to the (template parameter) `FROM&lowbar;TYPE`, and referring to `dynamic&lowbar;cast&lt;TO&lowbar;TYPE&ast;&gt;(source&period;get())`&period; If `source` cannot be dynamically cast to `TO&lowbar;TYPE &ast;`, then an empty `shared&lowbar;ptr&lt;TO&lowbar;TYPE&gt;` object is returned&period;
| xref:bsl/emit_on_flush.adoc[`emit&lowbar;on&lowbar;flush`] 
| If, for the specified `stream`, `stream&period;rdbuf()` is a `basic&lowbar;syncbuf&lt;CHAR,TRAITS,ALLOCATOR&gt;`, make `stream` emit (i&period;e&period;, transmit data to the wrapped stream buffer) when flushed, otherwise has no effect&period; Return `stream`&period;
| xref:bsl/erase-03.adoc[`erase`] 
| `erase` overloads
| xref:bsl/erase_if-071.adoc[`erase&lowbar;if`] 
| `erase&lowbar;if` overloads
| xref:bsl/flush_emit.adoc[`flush&lowbar;emit`] 
| Flush the specified `stream` as if by calling `stream&period;flush()`&period; Then, if `stream&period;rdbuf()` actually points to a `basic&lowbar;syncbuf&lt;CHAR,TRAITS,ALLOCATOR&gt;` `buf`, call `buf&period;emit()`&period; Return `stream`&period;
| xref:bsl/format-00.adoc[`format`] 
| `format` overloads
| xref:bsl/format_to-0c.adoc[`format&lowbar;to`] 
| `format&lowbar;to` overloads
| xref:bsl/get-056.adoc[`get`] 
| `get` overloads
| xref:bsl/get_deleter.adoc[`get&lowbar;deleter`] 
| Return the address of deleter used by the specified `p` shared pointer if the (template parameter) type `DELETER` is the type of the deleter installed in `p`, and a null pointer value otherwise&period;
| xref:bsl/get_if-0b.adoc[`get&lowbar;if`] 
| `get&lowbar;if` overloads
| xref:bsl/getline-08.adoc[`getline`] 
| `getline` overloads
| xref:bsl/hashAppend-072.adoc[`hashAppend`] 
| `hashAppend` overloads
| xref:bsl/hashBasicString-02.adoc[`hashBasicString`] 
| Return a hash value for the specified `str`&period;
| xref:bsl/holds_alternative.adoc[`holds&lowbar;alternative`] 
| Return `true` if the specified `obj` currently holds the (template parameter) `t&lowbar;TYPE` alternative, and `false` otherwise&period; `t&lowbar;TYPE` shall appear exactly once in the variant&apos;s list of alternatives&period;
| xref:bsl/make_format_args.adoc[`make&lowbar;format&lowbar;args`] 
| Return an object, whose type is not specified, holding an array of `format&lowbar;arg` types constructed from the specified `args`&period; The type returned is implicitly convertible to a `format&lowbar;args` holding a reference to the contained array&period; This function will statically assert if any of the specified template parameters `t&lowbar;ARGS` is of type `long double`&period;
| xref:bsl/make_optional-0c.adoc[`make&lowbar;optional`] 
| `make&lowbar;optional` overloads
| xref:bsl/make_shared-09.adoc[`make&lowbar;shared`] 
| `make&lowbar;shared` overloads
| xref:bsl/make_shared_for_overwrite-0d.adoc[`make&lowbar;shared&lowbar;for&lowbar;overwrite`] 
| `make&lowbar;shared&lowbar;for&lowbar;overwrite` overloads
| xref:bsl/make_wformat_args.adoc[`make&lowbar;wformat&lowbar;args`] 
| Return an object, whose type is not specified, holding an array of `wformat&lowbar;arg` types constructed from the specified `args`&period; The type returned is implicitly convertible to a `wformat&lowbar;args` holding a reference to the contained array&period; This function will statically assert if any of the specified template parameters `t&lowbar;ARGS` is of type `long double`&period;
| xref:bsl/noemit_on_flush.adoc[`noemit&lowbar;on&lowbar;flush`] 
| If, for the specified `stream`, `stream&period;rdbuf()` is a `basic&lowbar;syncbuf&lt;CHAR,TRAITS,ALLOCATOR&gt;`, make `stream` not emit (i&period;e&period;, don&apos;t transmit data to the wrapped stream buffer) when flushed, otherwise has no effect&period; Return `stream`&period;
| xref:bsl/operator_S-06.adoc[`operator&quot;&quot;&lowbar;S`] 
| `operator&quot;&quot;&lowbar;S` overloads
| xref:bsl/operator_h-0f.adoc[`operator&quot;&quot;&lowbar;h`] 
| `operator&quot;&quot;&lowbar;h` overloads
| xref:bsl/operator_i-0fd.adoc[`operator&quot;&quot;&lowbar;i`] 
| `operator&quot;&quot;&lowbar;i` overloads
| xref:bsl/operator_if-0f.adoc[`operator&quot;&quot;&lowbar;if`] 
| `operator&quot;&quot;&lowbar;if` overloads
| xref:bsl/operator_il-01.adoc[`operator&quot;&quot;&lowbar;il`] 
| `operator&quot;&quot;&lowbar;il` overloads
| xref:bsl/operator_min-00.adoc[`operator&quot;&quot;&lowbar;min`] 
| `operator&quot;&quot;&lowbar;min` overloads
| xref:bsl/operator_ms-06.adoc[`operator&quot;&quot;&lowbar;ms`] 
| `operator&quot;&quot;&lowbar;ms` overloads
| xref:bsl/operator_ns-09.adoc[`operator&quot;&quot;&lowbar;ns`] 
| `operator&quot;&quot;&lowbar;ns` overloads
| xref:bsl/operator_s-0e87.adoc[`operator&quot;&quot;&lowbar;s`] 
| `operator&quot;&quot;&lowbar;s` overloads
| xref:bsl/operator_sv-04.adoc[`operator&quot;&quot;&lowbar;sv`] 
| `operator&quot;&quot;&lowbar;sv` overloads
| xref:bsl/operator_us-0b9.adoc[`operator&quot;&quot;&lowbar;us`] 
| `operator&quot;&quot;&lowbar;us` overloads
| xref:bsl/operator_bitand.adoc[`operator&amp;`] 
| Return a `bitset` that results from a bitwise AND of the specified `lhs` and `rhs`&period;
| xref:bsl/operator_plus-0d0.adoc[`operator&plus;`] 
| Addition operators
| xref:bsl/operator_minus-06.adoc[`operator&hyphen;`] 
| Subtraction operators
| xref:bsl/operator_slash-0e.adoc[`operator&sol;`] 
| Division operators
| xref:bsl/operator_slash_eq.adoc[`operator&sol;&equals;`] 
| Append the specified `string` to the specified `path` using the preferred directory separator if appropriate&period; Return a reference to `path`&period;
| xref:bsl/operator_rshift-08.adoc[`operator&gt;&gt;`] 
| Right shift operators
| xref:bsl/operator_xor.adoc[`operator&circ;`] 
| Return a `bitset` that results from a bitwise XOR of the specified `lhs` and `rhs`&period;
| xref:bsl/operator_bitor.adoc[`operator&verbar;`] 
| Return a `bitset` that results from a bitwise OR of the specified `lhs` and `rhs`&period;
| xref:bsl/quoted-04.adoc[`quoted`] 
| `quoted` overloads
| xref:bsl/reinterpret_pointer_cast.adoc[`reinterpret&lowbar;pointer&lowbar;cast`] 
| Return a `shared&lowbar;ptr&lt;TO&lowbar;TYPE&gt;` object sharing ownership of the same object as the specified `source` shared pointer to the (template parameter) `FROM&lowbar;TYPE`, and referring to `reinterpret&lowbar;cast&lt;TO&lowbar;TYPE &ast;&gt;(source&period;get())`&period; Note that if `source` cannot be reinterpret&lowbar;cast&hyphen;ed to `TO&lowbar;TYPE &ast;`, then a compiler diagnostic will be emitted indicating the error&period;
| xref:bsl/static_pointer_cast.adoc[`static&lowbar;pointer&lowbar;cast`] 
| Return a `shared&lowbar;ptr&lt;TO&lowbar;TYPE&gt;` object sharing ownership of the same object as the specified `source` shared pointer to the (template parameter) `FROM&lowbar;TYPE`, and referring to `static&lowbar;cast&lt;TO&lowbar;TYPE &ast;&gt;(source&period;get())`&period; Note that if `source` cannot be statically cast to `TO&lowbar;TYPE &ast;`, then a compiler diagnostic will be emitted indicating the error&period;
| xref:bsl/stod-04.adoc[`stod`] 
| `stod` overloads
| xref:bsl/stof-09.adoc[`stof`] 
| `stof` overloads
| xref:bsl/stoi-08.adoc[`stoi`] 
| `stoi` overloads
| xref:bsl/stol-0d.adoc[`stol`] 
| `stol` overloads
| xref:bsl/stold-04.adoc[`stold`] 
| `stold` overloads
| xref:bsl/stoll-0b.adoc[`stoll`] 
| `stoll` overloads
| xref:bsl/stoul-07.adoc[`stoul`] 
| `stoul` overloads
| xref:bsl/stoull-0a.adoc[`stoull`] 
| `stoull` overloads
| xref:bsl/swap-0dc.adoc[`swap`] 
| `swap` overloads
| xref:bsl/to_string-0f.adoc[`to&lowbar;string`] 
| `to&lowbar;string` overloads
| xref:bsl/to_wstring-05.adoc[`to&lowbar;wstring`] 
| `to&lowbar;wstring` overloads
| xref:bsl/vector_makeUintPtrRangeAdapter.adoc[`vector&lowbar;makeUintPtrRangeAdapter`] 
| Factory function for `vector&lowbar;UintPtrRangeAdapter`&period;
| xref:bsl/vformat-06.adoc[`vformat`] 
| `vformat` overloads
| xref:bsl/vformat_to-0c.adoc[`vformat&lowbar;to`] 
| `vformat&lowbar;to` overloads
| xref:bsl/visit-0de.adoc[`visit`] 
| `visit` overloads
| xref:bsl/visitR.adoc[`visitR`] 
| Return the result of invoking the specified `visitor` with the currently active alternative of the specified `variant`, implicitly converting the result to the explicitly specified (template parameter) `t&lowbar;RET`&period; If `variant` does not hold a value, throw an exception of type `bsl&colon;&colon;bad&lowbar;variant&lowbar;access`&period; This function is provided in all language versions for compatibility with the C&plus;&plus;03 version (see below), but in new code in C&plus;&plus;11 and later, `bsl&colon;&colon;visit` should be used instead of this function&period;
| xref:bsl/operator_lshift-05b.adoc[`operator&lt;&lt;`] 
| Stream insertion operators
| xref:bsl/operator_eq-08e.adoc[`operator&equals;&equals;`] 
| Equality operators
| xref:bsl/operator_not_eq-06.adoc[`operator!&equals;`] 
| Inequality operators
| xref:bsl/operator_lt-016.adoc[`operator&lt;`] 
| Less&hyphen;than operators
| xref:bsl/operator_le-06.adoc[`operator&lt;&equals;`] 
| Less&hyphen;than&hyphen;or&hyphen;equal operators
| xref:bsl/operator_gt-02.adoc[`operator&gt;`] 
| Greater&hyphen;than operators
| xref:bsl/operator_ge-0a.adoc[`operator&gt;&equals;`] 
| Greater&hyphen;than&hyphen;or&hyphen;equal operators
| xref:bsl/operator_3way-0f1.adoc[`operator&lt;&equals;&gt;`] 
| Three&hyphen;way comparison operators
|===


== Variables

[cols="1,4"]
|===
| Name| Description
| xref:bsl/alignment_of_v.adoc[`alignment&lowbar;of&lowbar;v`] 
| Variable template alias for `std&colon;&colon;alignment&lowbar;of&lowbar;v`&period;
| xref:bsl/extent_v.adoc[`extent&lowbar;v`] 
| Variable template alias for `std&colon;&colon;extent&lowbar;v`&period;
| xref:bsl/has_unique_object_representations_v.adoc[`has&lowbar;unique&lowbar;object&lowbar;representations&lowbar;v`] 
| Variable template alias for `std&colon;&colon;has&lowbar;unique&lowbar;object&lowbar;representations&lowbar;v`&period;
| xref:bsl/has_virtual_destructor_v.adoc[`has&lowbar;virtual&lowbar;destructor&lowbar;v`] 
| Variable template alias for `std&colon;&colon;has&lowbar;virtual&lowbar;destructor&lowbar;v`&period;
| xref:bsl/is_abstract_v.adoc[`is&lowbar;abstract&lowbar;v`] 
| Variable template alias for `std&colon;&colon;is&lowbar;abstract&lowbar;v`&period;
| xref:bsl/is_aggregate_v.adoc[`is&lowbar;aggregate&lowbar;v`] 
| Variable template alias for `std&colon;&colon;is&lowbar;aggregate&lowbar;v`&period;
| xref:bsl/is_arithmetic_v.adoc[`is&lowbar;arithmetic&lowbar;v`] 
| This template variable represents the result value of the `bsl&colon;&colon;is&lowbar;arithmetic` meta&hyphen;function&period;
| xref:bsl/is_array_v.adoc[`is&lowbar;array&lowbar;v`] 
| This template variable represents the result value of the `bsl&colon;&colon;is&lowbar;array` meta&hyphen;function&period;
| xref:bsl/is_assignable_v.adoc[`is&lowbar;assignable&lowbar;v`] 
| Variable template alias for `std&colon;&colon;is&lowbar;assignable&lowbar;v`&period;
| xref:bsl/is_base_of_v.adoc[`is&lowbar;base&lowbar;of&lowbar;v`] 
| Variable template alias for `std&colon;&colon;is&lowbar;base&lowbar;of&lowbar;v`&period;
| xref:bsl/is_bounded_array_v.adoc[`is&lowbar;bounded&lowbar;array&lowbar;v`] 
| This template variable represents the result value of the `bsl&colon;&colon;is&lowbar;bounded&lowbar;array` meta&hyphen;function&period;
| xref:bsl/is_class_v.adoc[`is&lowbar;class&lowbar;v`] 
| This template variable represents the result value of the `bsl&colon;&colon;is&lowbar;class` meta&hyphen;function&period;
| xref:bsl/is_compound_v.adoc[`is&lowbar;compound&lowbar;v`] 
| Variable template alias for `std&colon;&colon;is&lowbar;compound&lowbar;v`&period;
| xref:bsl/is_const_v.adoc[`is&lowbar;const&lowbar;v`] 
| This template variable represents the result value of the `bsl&colon;&colon;is&lowbar;const` meta&hyphen;function&period;
| xref:bsl/is_constructible_v.adoc[`is&lowbar;constructible&lowbar;v`] 
| Variable template alias for `std&colon;&colon;is&lowbar;constructible&lowbar;v`&period;
| xref:bsl/is_convertible_v.adoc[`is&lowbar;convertible&lowbar;v`] 
| This template variable represents the result value of the `bsl&colon;&colon;is&lowbar;convertible` meta&hyphen;function&period;
| xref:bsl/is_copy_assignable_v.adoc[`is&lowbar;copy&lowbar;assignable&lowbar;v`] 
| Variable template alias for `std&colon;&colon;is&lowbar;copy&lowbar;assignable&lowbar;v`&period;
| xref:bsl/is_copy_constructible_v.adoc[`is&lowbar;copy&lowbar;constructible&lowbar;v`] 
| This template variable represents the result value of the `bsl&colon;&colon;is&lowbar;copy&lowbar;constructible` meta&hyphen;function&period;
| xref:bsl/is_default_constructible_v.adoc[`is&lowbar;default&lowbar;constructible&lowbar;v`] 
| Variable template alias for `std&colon;&colon;is&lowbar;default&lowbar;constructible&lowbar;v`&period;
| xref:bsl/is_destructible_v.adoc[`is&lowbar;destructible&lowbar;v`] 
| Variable template alias for `std&colon;&colon;is&lowbar;destructible&lowbar;v`&period;
| xref:bsl/is_empty_v.adoc[`is&lowbar;empty&lowbar;v`] 
| This template variable represents the result value of the `bsl&colon;&colon;is&lowbar;empty` meta&hyphen;function&period;
| xref:bsl/is_enum_v.adoc[`is&lowbar;enum&lowbar;v`] 
| This template variable represents the result value of the `bsl&colon;&colon;is&lowbar;enum` meta&hyphen;function&period;
| xref:bsl/is_final_v.adoc[`is&lowbar;final&lowbar;v`] 
| Variable template alias for `std&colon;&colon;is&lowbar;final&lowbar;v`&period;
| xref:bsl/is_function_v.adoc[`is&lowbar;function&lowbar;v`] 
| This template variable represents the result value of the `bsl&colon;&colon;is&lowbar;function` meta&hyphen;function&period;
| xref:bsl/is_fundamental_v.adoc[`is&lowbar;fundamental&lowbar;v`] 
| This template variable represents the result value of the `bsl&colon;&colon;is&lowbar;fundamental` meta&hyphen;function&period;
| xref:bsl/is_invocable_r_v.adoc[`is&lowbar;invocable&lowbar;r&lowbar;v`] 
| Variable template alias for `std&colon;&colon;is&lowbar;invocable&lowbar;r&lowbar;v`&period;
| xref:bsl/is_invocable_v.adoc[`is&lowbar;invocable&lowbar;v`] 
| Variable template alias for `std&colon;&colon;is&lowbar;invocable&lowbar;v`&period;
| xref:bsl/is_literal_type_v.adoc[`is&lowbar;literal&lowbar;type&lowbar;v`]  [.small]#[deprecated]#
| Variable template alias for `std&colon;&colon;is&lowbar;literal&lowbar;type&lowbar;v`&period;
| xref:bsl/is_member_function_pointer_v.adoc[`is&lowbar;member&lowbar;function&lowbar;pointer&lowbar;v`] 
| This variable template represents the result value of the `bsl&colon;&colon;is&lowbar;member&lowbar;function&lowbar;pointer` meta&hyphen;function&period;
| xref:bsl/is_member_object_pointer_v.adoc[`is&lowbar;member&lowbar;object&lowbar;pointer&lowbar;v`] 
| This template variable represents the result value of the `bsl&colon;&colon;is&lowbar;member&lowbar;object&lowbar;pointer` meta&hyphen;function&period;
| xref:bsl/is_member_pointer_v.adoc[`is&lowbar;member&lowbar;pointer&lowbar;v`] 
| This template variable represents the result value of the `bsl&colon;&colon;is&lowbar;member&lowbar;pointer` meta&hyphen;function&period;
| xref:bsl/is_move_assignable_v.adoc[`is&lowbar;move&lowbar;assignable&lowbar;v`] 
| Variable template alias for `std&colon;&colon;is&lowbar;move&lowbar;assignable&lowbar;v`&period;
| xref:bsl/is_move_constructible_v.adoc[`is&lowbar;move&lowbar;constructible&lowbar;v`] 
| Variable template alias for `std&colon;&colon;is&lowbar;move&lowbar;constructible&lowbar;v`&period;
| xref:bsl/is_nothrow_assignable_v.adoc[`is&lowbar;nothrow&lowbar;assignable&lowbar;v`] 
| Variable template alias for `std&colon;&colon;is&lowbar;nothrow&lowbar;assignable&lowbar;v`&period;
| xref:bsl/is_nothrow_constructible_v.adoc[`is&lowbar;nothrow&lowbar;constructible&lowbar;v`] 
| Variable template alias for `std&colon;&colon;is&lowbar;nothrow&lowbar;constructible&lowbar;v`&period;
| xref:bsl/is_nothrow_copy_assignable_v.adoc[`is&lowbar;nothrow&lowbar;copy&lowbar;assignable&lowbar;v`] 
| Variable template alias for `std&colon;&colon;is&lowbar;nothrow&lowbar;copy&lowbar;assignable&lowbar;v`&period;
| xref:bsl/is_nothrow_copy_constructible_v.adoc[`is&lowbar;nothrow&lowbar;copy&lowbar;constructible&lowbar;v`] 
| Variable template alias for `std&colon;&colon;is&lowbar;nothrow&lowbar;copy&lowbar;constructible&lowbar;v`&period;
| xref:bsl/is_nothrow_default_constructible_v.adoc[`is&lowbar;nothrow&lowbar;default&lowbar;constructible&lowbar;v`] 
| Variable template alias for `std&colon;&colon;is&lowbar;nothrow&lowbar;default&lowbar;constructible&lowbar;v`&period;
| xref:bsl/is_nothrow_destructible_v.adoc[`is&lowbar;nothrow&lowbar;destructible&lowbar;v`] 
| Variable template alias for `std&colon;&colon;is&lowbar;nothrow&lowbar;destructible&lowbar;v`&period;
| xref:bsl/is_nothrow_invocable_r_v.adoc[`is&lowbar;nothrow&lowbar;invocable&lowbar;r&lowbar;v`] 
| Variable template alias for `std&colon;&colon;is&lowbar;nothrow&lowbar;invocable&lowbar;r&lowbar;v`&period;
| xref:bsl/is_nothrow_invocable_v.adoc[`is&lowbar;nothrow&lowbar;invocable&lowbar;v`] 
| Variable template alias for `std&colon;&colon;is&lowbar;nothrow&lowbar;invocable&lowbar;v`&period;
| xref:bsl/is_nothrow_move_assignable_v.adoc[`is&lowbar;nothrow&lowbar;move&lowbar;assignable&lowbar;v`] 
| Variable template alias for `std&colon;&colon;is&lowbar;nothrow&lowbar;move&lowbar;assignable&lowbar;v`&period;
| xref:bsl/is_nothrow_move_constructible_v.adoc[`is&lowbar;nothrow&lowbar;move&lowbar;constructible&lowbar;v`] 
| This template variable represents the result value of the `bsl&colon;&colon;is&lowbar;nothrow&lowbar;move&lowbar;constructible` metafunction&period;
| xref:bsl/is_nothrow_swappable_with_v.adoc[`is&lowbar;nothrow&lowbar;swappable&lowbar;with&lowbar;v`] 
| Variable template alias for `std&colon;&colon;is&lowbar;nothrow&lowbar;swappable&lowbar;with&lowbar;v`&period;
| xref:bsl/is_null_pointer_v.adoc[`is&lowbar;null&lowbar;pointer&lowbar;v`] 
| Variable template alias for `std&colon;&colon;is&lowbar;null&lowbar;pointer&lowbar;v`&period;
| xref:bsl/is_object_v.adoc[`is&lowbar;object&lowbar;v`] 
| Variable template alias for `std&colon;&colon;is&lowbar;object&lowbar;v`&period;
| xref:bsl/is_pod_v.adoc[`is&lowbar;pod&lowbar;v`]  [.small]#[deprecated]#
| Variable template alias for `std&colon;&colon;is&lowbar;pod&lowbar;v`&period;
| xref:bsl/is_pointer_v.adoc[`is&lowbar;pointer&lowbar;v`] 
| This template variable represents the result value of the `bsl&colon;&colon;is&lowbar;pointer` meta&hyphen;function&period;
| xref:bsl/is_polymorphic_v.adoc[`is&lowbar;polymorphic&lowbar;v`] 
| This template variable represents the result value of the `bsl&colon;&colon;is&lowbar;polymorphic` meta&hyphen;function&period;
| xref:bsl/is_reference_v.adoc[`is&lowbar;reference&lowbar;v`] 
| This template variable represents the result value of the `bsl&colon;&colon;is&lowbar;reference` meta&hyphen;function&period;
| xref:bsl/is_rvalue_reference_v.adoc[`is&lowbar;rvalue&lowbar;reference&lowbar;v`] 
| This template variable represents the result value of the `bsl&colon;&colon;is&lowbar;rvalue&lowbar;reference` meta&hyphen;function&period;
| xref:bsl/is_same_v.adoc[`is&lowbar;same&lowbar;v`] 
| This template variable represents the result value of the `bsl&colon;&colon;is&lowbar;same` meta&hyphen;function&period;
| xref:bsl/is_scalar_v.adoc[`is&lowbar;scalar&lowbar;v`] 
| Variable template alias for `std&colon;&colon;is&lowbar;scalar&lowbar;v`&period;
| xref:bsl/is_signed_v.adoc[`is&lowbar;signed&lowbar;v`] 
| Variable template alias for `std&colon;&colon;is&lowbar;signed&lowbar;v`&period;
| xref:bsl/is_standard_layout_v.adoc[`is&lowbar;standard&lowbar;layout&lowbar;v`] 
| Variable template alias for `std&colon;&colon;is&lowbar;standard&lowbar;layout&lowbar;v`&period;
| xref:bsl/is_swappable_with_v.adoc[`is&lowbar;swappable&lowbar;with&lowbar;v`] 
| Variable template alias for `std&colon;&colon;is&lowbar;swappable&lowbar;with&lowbar;v`&period;
| xref:bsl/is_trivial_v.adoc[`is&lowbar;trivial&lowbar;v`] 
| Variable template alias for `std&colon;&colon;is&lowbar;trivial&lowbar;v`&period;
| xref:bsl/is_trivially_assignable_v.adoc[`is&lowbar;trivially&lowbar;assignable&lowbar;v`] 
| Variable template alias for `std&colon;&colon;is&lowbar;trivially&lowbar;assignable&lowbar;v`&period;
| xref:bsl/is_trivially_constructible_v.adoc[`is&lowbar;trivially&lowbar;constructible&lowbar;v`] 
| Variable template alias for `std&colon;&colon;is&lowbar;trivially&lowbar;constructible&lowbar;v`&period;
| xref:bsl/is_trivially_copy_assignable_v.adoc[`is&lowbar;trivially&lowbar;copy&lowbar;assignable&lowbar;v`] 
| Variable template alias for `std&colon;&colon;is&lowbar;trivially&lowbar;copy&lowbar;assignable&lowbar;v`&period;
| xref:bsl/is_trivially_copy_constructible_v.adoc[`is&lowbar;trivially&lowbar;copy&lowbar;constructible&lowbar;v`] 
| Variable template alias for `std&colon;&colon;is&lowbar;trivially&lowbar;copy&lowbar;constructible&lowbar;v`&period;
| xref:bsl/is_trivially_copyable_v.adoc[`is&lowbar;trivially&lowbar;copyable&lowbar;v`] 
| This template variable represents the result value of the `bsl&colon;&colon;is&lowbar;trivially&lowbar;copyable` meta&hyphen;function&period;
| xref:bsl/is_trivially_default_constructible_v.adoc[`is&lowbar;trivially&lowbar;default&lowbar;constructible&lowbar;v`] 
| This template variable represents the result value of the `bsl&colon;&colon;is&lowbar;trivially&lowbar;default&lowbar;constructible` meta&hyphen;function&period;
| xref:bsl/is_trivially_destructible_v.adoc[`is&lowbar;trivially&lowbar;destructible&lowbar;v`] 
| Variable template alias for `std&colon;&colon;is&lowbar;trivially&lowbar;destructible&lowbar;v`&period;
| xref:bsl/is_trivially_move_assignable_v.adoc[`is&lowbar;trivially&lowbar;move&lowbar;assignable&lowbar;v`] 
| Variable template alias for `std&colon;&colon;is&lowbar;trivially&lowbar;move&lowbar;assignable&lowbar;v`&period;
| xref:bsl/is_trivially_move_constructible_v.adoc[`is&lowbar;trivially&lowbar;move&lowbar;constructible&lowbar;v`] 
| Variable template alias for `std&colon;&colon;is&lowbar;trivially&lowbar;move&lowbar;constructible&lowbar;v`&period;
| xref:bsl/is_unbounded_array_v.adoc[`is&lowbar;unbounded&lowbar;array&lowbar;v`] 
| This template variable represents the result value of the `bsl&colon;&colon;is&lowbar;unbounded&lowbar;array&lowbar;v` meta&hyphen;function&period;
| xref:bsl/is_union_v.adoc[`is&lowbar;union&lowbar;v`] 
| Variable template alias for `std&colon;&colon;is&lowbar;union&lowbar;v`&period;
| xref:bsl/is_unsigned_v.adoc[`is&lowbar;unsigned&lowbar;v`] 
| Variable template alias for `std&colon;&colon;is&lowbar;unsigned&lowbar;v`&period;
| xref:bsl/is_void_v.adoc[`is&lowbar;void&lowbar;v`] 
| This template variable represents the result value of the `bsl&colon;&colon;is&lowbar;void` meta&hyphen;function&period;
| xref:bsl/is_volatile_v.adoc[`is&lowbar;volatile&lowbar;v`] 
| This template variable represents the result value of the `bsl&colon;&colon;is&lowbar;volatile` meta&hyphen;function&period;
| xref:bsl/nostopstate.adoc[`nostopstate`] 
| Value of type `nostopstate&lowbar;t` used as an argument to functions that take a `nostopstate&lowbar;t` argument&period;
| xref:bsl/rank_v.adoc[`rank&lowbar;v`] 
| Variable template alias for `std&colon;&colon;rank&lowbar;v`&period;
| xref:bsl/uses_allocator_v.adoc[`uses&lowbar;allocator&lowbar;v`] 
| This template variable represents the result value of the `bsl&colon;&colon;uses&lowbar;allocator` meta&hyphen;function&period;
| xref:bsl/variant_npos.adoc[`variant&lowbar;npos`] 
| This value is returned by `bsl&colon;&colon;variant&colon;&colon;index()` if `valueless&lowbar;by&lowbar;exception()` is `true`&period;
| xref:bsl/variant_size_v.adoc[`variant&lowbar;size&lowbar;v`] 
| This variable template represents the result value of the `bsl&colon;&colon;variant&lowbar;size` metafunction&period;
|===


== Using Declarations

[cols="1,4"]
|===
| Name| Description
| xref:bsl/FILE.adoc[`FILE`] 
| Alias for `std&colon;&colon;FILE` in the `bsl` namespace&period;
| xref:bsl/IsStdAllocator.adoc[`IsStdAllocator`] 
| Alias for `bslma&colon;&colon;IsStdAllocator` in the `bsl` namespace&period;
| xref:bsl/IsStdAllocator_v.adoc[`IsStdAllocator&lowbar;v`] 
| Alias for `bslma&colon;&colon;IsStdAllocator&lowbar;v`&period;
| xref:bsl/_Exit.adoc[`&lowbar;Exit`] 
| Alias for `std&colon;&colon;&lowbar;Exit` in the `bsl` namespace&period;
| xref:bsl/abort.adoc[`abort`] 
| Alias for `std&colon;&colon;abort` in the `bsl` namespace&period;
| xref:bsl/abs-0f.adoc[`abs`] 
| Alias for `std&colon;&colon;abs` in the `bsl` namespace&period;
| xref:bsl/abs-0e.adoc[`abs`] 
| Alias for `std&colon;&colon;abs` in the `bsl` namespace&period;
| xref:bsl/abs-04.adoc[`abs`] 
| Alias for `std&colon;&colon;abs` in the `bsl` namespace&period;
| xref:bsl/accumulate.adoc[`accumulate`] 
| Alias for `std&colon;&colon;accumulate` in the `bsl` namespace&period;
| xref:bsl/acos-0d.adoc[`acos`] 
| Alias for `std&colon;&colon;acos` in the `bsl` namespace&period;
| xref:bsl/acos-0a.adoc[`acos`] 
| Alias for `std&colon;&colon;acos` in the `bsl` namespace&period;
| xref:bsl/acos-07.adoc[`acos`] 
| Alias for `std&colon;&colon;acos` in the `bsl` namespace&period;
| xref:bsl/acosh-05.adoc[`acosh`] 
| Alias for `std&colon;&colon;acosh` in the `bsl` namespace&period;
| xref:bsl/acosh-0b.adoc[`acosh`] 
| Alias for `std&colon;&colon;acosh` in the `bsl` namespace&period;
| xref:bsl/addressof.adoc[`addressof`] 
| Alias for `std&colon;&colon;addressof` in the `bsl` namespace&period;
| xref:bsl/adjacent_difference.adoc[`adjacent&lowbar;difference`] 
| Alias for `std&colon;&colon;adjacent&lowbar;difference` in the `bsl` namespace&period;
| xref:bsl/adjacent_find.adoc[`adjacent&lowbar;find`] 
| Alias for `std&colon;&colon;adjacent&lowbar;find` in the `bsl` namespace&period;
| xref:bsl/adopt_lock.adoc[`adopt&lowbar;lock`] 
| Alias for `std&colon;&colon;adopt&lowbar;lock` in the `bsl` namespace&period;
| xref:bsl/adopt_lock_t.adoc[`adopt&lowbar;lock&lowbar;t`] 
| Alias for `std&colon;&colon;adopt&lowbar;lock&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/advance.adoc[`advance`] 
| Alias for `std&colon;&colon;advance` in the `bsl` namespace&period;
| xref:bsl/align.adoc[`align`] 
| Alias for `std&colon;&colon;align` in the `bsl` namespace&period;
| xref:bsl/align_val_t.adoc[`align&lowbar;val&lowbar;t`] 
| Alias for `std&colon;&colon;align&lowbar;val&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/aligned_alloc.adoc[`aligned&lowbar;alloc`] 
| 
| xref:bsl/alignment_of.adoc[`alignment&lowbar;of`] 
| Alias for `std&colon;&colon;alignment&lowbar;of` in the `bsl` namespace&period;
| xref:bsl/all_of.adoc[`all&lowbar;of`] 
| Alias for `std&colon;&colon;all&lowbar;of` in the `bsl` namespace&period;
| xref:bsl/allocator_arg.adoc[`allocator&lowbar;arg`] 
| Alias for `std&colon;&colon;allocator&lowbar;arg` in the `bsl` namespace&period;
| xref:bsl/allocator_arg_t-04.adoc[`allocator&lowbar;arg&lowbar;t`] 
| Alias for `std&colon;&colon;allocator&lowbar;arg&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/any_of.adoc[`any&lowbar;of`] 
| Alias for `std&colon;&colon;any&lowbar;of` in the `bsl` namespace&period;
| xref:bsl/apply.adoc[`apply`] 
| Alias for `std&colon;&colon;apply` in the `bsl` namespace&period;
| xref:bsl/arg.adoc[`arg`] 
| Alias for `std&colon;&colon;arg` in the `bsl` namespace&period;
| xref:bsl/array.adoc[`array`] 
| Alias for `std&colon;&colon;array` in the `bsl` namespace&period;
| xref:bsl/as_bytes.adoc[`as&lowbar;bytes`] 
| Alias for `std&colon;&colon;as&lowbar;bytes`&period;
| xref:bsl/as_const.adoc[`as&lowbar;const`] 
| Alias for `std&colon;&colon;as&lowbar;const` in the `bsl` namespace&period;
| xref:bsl/as_writable_bytes.adoc[`as&lowbar;writable&lowbar;bytes`] 
| Alias for `std&colon;&colon;as&lowbar;writable&lowbar;bytes`&period;
| xref:bsl/asctime.adoc[`asctime`] 
| Alias for `std&colon;&colon;asctime` in the `bsl` namespace&period;
| xref:bsl/asin-0a.adoc[`asin`] 
| Alias for `std&colon;&colon;asin` in the `bsl` namespace&period;
| xref:bsl/asin-08.adoc[`asin`] 
| Alias for `std&colon;&colon;asin` in the `bsl` namespace&period;
| xref:bsl/asin-05.adoc[`asin`] 
| Alias for `std&colon;&colon;asin` in the `bsl` namespace&period;
| xref:bsl/asinh-01.adoc[`asinh`] 
| Alias for `std&colon;&colon;asinh` in the `bsl` namespace&period;
| xref:bsl/asinh-04.adoc[`asinh`] 
| Alias for `std&colon;&colon;asinh` in the `bsl` namespace&period;
| xref:bsl/assignable_from.adoc[`assignable&lowbar;from`] 
| Alias for `std&colon;&colon;assignable&lowbar;from` in the `bsl` namespace&period;
| xref:bsl/assoc_laguerre.adoc[`assoc&lowbar;laguerre`] 
| 
| xref:bsl/assoc_laguerref.adoc[`assoc&lowbar;laguerref`] 
| 
| xref:bsl/assoc_laguerrel.adoc[`assoc&lowbar;laguerrel`] 
| 
| xref:bsl/assoc_legendre.adoc[`assoc&lowbar;legendre`] 
| 
| xref:bsl/assoc_legendref.adoc[`assoc&lowbar;legendref`] 
| 
| xref:bsl/assoc_legendrel.adoc[`assoc&lowbar;legendrel`] 
| 
| xref:bsl/assume_aligned.adoc[`assume&lowbar;aligned`] 
| Alias for `std&colon;&colon;assume&lowbar;aligned` in the `bsl` namespace&period;
| xref:bsl/async.adoc[`async`] 
| Alias for `std&colon;&colon;async` in the `bsl` namespace&period;
| xref:bsl/at_quick_exit.adoc[`at&lowbar;quick&lowbar;exit`] 
| Alias for `std&colon;&colon;at&lowbar;quick&lowbar;exit` in the `bsl` namespace&period;
| xref:bsl/atan-05.adoc[`atan`] 
| Alias for `std&colon;&colon;atan` in the `bsl` namespace&period;
| xref:bsl/atan-08.adoc[`atan`] 
| Alias for `std&colon;&colon;atan` in the `bsl` namespace&period;
| xref:bsl/atan-0c.adoc[`atan`] 
| Alias for `std&colon;&colon;atan` in the `bsl` namespace&period;
| xref:bsl/atan2-01.adoc[`atan2`] 
| Import `std&colon;&colon;atan2` into the `bsl` namespace&period;
| xref:bsl/atan2-0f.adoc[`atan2`] 
| Alias for `std&colon;&colon;atan2` in the `bsl` namespace&period;
| xref:bsl/atanh-0e.adoc[`atanh`] 
| Alias for `std&colon;&colon;atanh` in the `bsl` namespace&period;
| xref:bsl/atanh-0c.adoc[`atanh`] 
| Alias for `std&colon;&colon;atanh` in the `bsl` namespace&period;
| xref:bsl/atexit.adoc[`atexit`] 
| Alias for `std&colon;&colon;atexit` in the `bsl` namespace&period;
| xref:bsl/atof.adoc[`atof`] 
| Alias for `std&colon;&colon;atof` in the `bsl` namespace&period;
| xref:bsl/atoi.adoc[`atoi`] 
| Alias for `std&colon;&colon;atoi` in the `bsl` namespace&period;
| xref:bsl/atol.adoc[`atol`] 
| Alias for `std&colon;&colon;atol` in the `bsl` namespace&period;
| xref:bsl/atoll.adoc[`atoll`] 
| Alias for `std&colon;&colon;atoll` in the `bsl` namespace&period;
| xref:bsl/atomic.adoc[`atomic`] 
| Alias for `std&colon;&colon;atomic` in the `bsl` namespace&period;
| xref:bsl/atomic_bool.adoc[`atomic&lowbar;bool`] 
| Alias for `std&colon;&colon;atomic&lowbar;bool` in the `bsl` namespace&period;
| xref:bsl/atomic_char.adoc[`atomic&lowbar;char`] 
| Alias for `std&colon;&colon;atomic&lowbar;char` in the `bsl` namespace&period;
| xref:bsl/atomic_char16_t.adoc[`atomic&lowbar;char16&lowbar;t`] 
| Alias for `std&colon;&colon;atomic&lowbar;char16&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/atomic_char32_t.adoc[`atomic&lowbar;char32&lowbar;t`] 
| Alias for `std&colon;&colon;atomic&lowbar;char32&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/atomic_char8_t.adoc[`atomic&lowbar;char8&lowbar;t`] 
| Alias for `std&colon;&colon;atomic&lowbar;char8&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/atomic_compare_exchange_strong.adoc[`atomic&lowbar;compare&lowbar;exchange&lowbar;strong`] 
| Alias for `std&colon;&colon;atomic&lowbar;compare&lowbar;exchange&lowbar;strong` in the `bsl` namespace&period;
| xref:bsl/atomic_compare_exchange_strong_explicit.adoc[`atomic&lowbar;compare&lowbar;exchange&lowbar;strong&lowbar;explicit`] 
| Alias for `std&colon;&colon;atomic&lowbar;compare&lowbar;exchange&lowbar;strong&lowbar;explicit` in the `bsl` namespace&period;
| xref:bsl/atomic_compare_exchange_weak.adoc[`atomic&lowbar;compare&lowbar;exchange&lowbar;weak`] 
| Alias for `std&colon;&colon;atomic&lowbar;compare&lowbar;exchange&lowbar;weak` in the `bsl` namespace&period;
| xref:bsl/atomic_compare_exchange_weak_explicit.adoc[`atomic&lowbar;compare&lowbar;exchange&lowbar;weak&lowbar;explicit`] 
| Alias for `std&colon;&colon;atomic&lowbar;compare&lowbar;exchange&lowbar;weak&lowbar;explicit` in the `bsl` namespace&period;
| xref:bsl/atomic_exchange.adoc[`atomic&lowbar;exchange`] 
| Alias for `std&colon;&colon;atomic&lowbar;exchange` in the `bsl` namespace&period;
| xref:bsl/atomic_exchange_explicit.adoc[`atomic&lowbar;exchange&lowbar;explicit`] 
| Alias for `std&colon;&colon;atomic&lowbar;exchange&lowbar;explicit` in the `bsl` namespace&period;
| xref:bsl/atomic_fetch_add.adoc[`atomic&lowbar;fetch&lowbar;add`] 
| Alias for `std&colon;&colon;atomic&lowbar;fetch&lowbar;add` in the `bsl` namespace&period;
| xref:bsl/atomic_fetch_add_explicit.adoc[`atomic&lowbar;fetch&lowbar;add&lowbar;explicit`] 
| Alias for `std&colon;&colon;atomic&lowbar;fetch&lowbar;add&lowbar;explicit` in the `bsl` namespace&period;
| xref:bsl/atomic_fetch_and.adoc[`atomic&lowbar;fetch&lowbar;and`] 
| Alias for `std&colon;&colon;atomic&lowbar;fetch&lowbar;and` in the `bsl` namespace&period;
| xref:bsl/atomic_fetch_and_explicit.adoc[`atomic&lowbar;fetch&lowbar;and&lowbar;explicit`] 
| Alias for `std&colon;&colon;atomic&lowbar;fetch&lowbar;and&lowbar;explicit` in the `bsl` namespace&period;
| xref:bsl/atomic_fetch_or_explicit.adoc[`atomic&lowbar;fetch&lowbar;or&lowbar;explicit`] 
| Alias for `std&colon;&colon;atomic&lowbar;fetch&lowbar;or&lowbar;explicit` in the `bsl` namespace&period;
| xref:bsl/atomic_fetch_sub.adoc[`atomic&lowbar;fetch&lowbar;sub`] 
| Alias for `std&colon;&colon;atomic&lowbar;fetch&lowbar;sub` in the `bsl` namespace&period;
| xref:bsl/atomic_fetch_sub_explicit.adoc[`atomic&lowbar;fetch&lowbar;sub&lowbar;explicit`] 
| Alias for `std&colon;&colon;atomic&lowbar;fetch&lowbar;sub&lowbar;explicit` in the `bsl` namespace&period;
| xref:bsl/atomic_fetch_xor.adoc[`atomic&lowbar;fetch&lowbar;xor`] 
| Alias for `std&colon;&colon;atomic&lowbar;fetch&lowbar;xor` in the `bsl` namespace&period;
| xref:bsl/atomic_fetch_xor_explicit.adoc[`atomic&lowbar;fetch&lowbar;xor&lowbar;explicit`] 
| Alias for `std&colon;&colon;atomic&lowbar;fetch&lowbar;xor&lowbar;explicit` in the `bsl` namespace&period;
| xref:bsl/atomic_flag.adoc[`atomic&lowbar;flag`] 
| Alias for `std&colon;&colon;atomic&lowbar;flag` in the `bsl` namespace&period;
| xref:bsl/atomic_flag_clear.adoc[`atomic&lowbar;flag&lowbar;clear`] 
| Alias for `std&colon;&colon;atomic&lowbar;flag&lowbar;clear` in the `bsl` namespace&period;
| xref:bsl/atomic_flag_clear_explicit.adoc[`atomic&lowbar;flag&lowbar;clear&lowbar;explicit`] 
| Alias for `std&colon;&colon;atomic&lowbar;flag&lowbar;clear&lowbar;explicit` in the `bsl` namespace&period;
| xref:bsl/atomic_flag_test_and_set.adoc[`atomic&lowbar;flag&lowbar;test&lowbar;and&lowbar;set`] 
| Alias for `std&colon;&colon;atomic&lowbar;flag&lowbar;test&lowbar;and&lowbar;set` in the `bsl` namespace&period;
| xref:bsl/atomic_flag_test_and_set_explicit.adoc[`atomic&lowbar;flag&lowbar;test&lowbar;and&lowbar;set&lowbar;explicit`] 
| Alias for `std&colon;&colon;atomic&lowbar;flag&lowbar;test&lowbar;and&lowbar;set&lowbar;explicit` in the `bsl` namespace&period;
| xref:bsl/atomic_init.adoc[`atomic&lowbar;init`] 
| Alias for `std&colon;&colon;atomic&lowbar;init` in the `bsl` namespace&period;
| xref:bsl/atomic_int.adoc[`atomic&lowbar;int`] 
| Alias for `std&colon;&colon;atomic&lowbar;int` in the `bsl` namespace&period;
| xref:bsl/atomic_int16_t.adoc[`atomic&lowbar;int16&lowbar;t`] 
| Alias for `std&colon;&colon;atomic&lowbar;int16&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/atomic_int32_t.adoc[`atomic&lowbar;int32&lowbar;t`] 
| Alias for `std&colon;&colon;atomic&lowbar;int32&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/atomic_int64_t.adoc[`atomic&lowbar;int64&lowbar;t`] 
| Alias for `std&colon;&colon;atomic&lowbar;int64&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/atomic_int8_t.adoc[`atomic&lowbar;int8&lowbar;t`] 
| Alias for `std&colon;&colon;atomic&lowbar;int8&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/atomic_int_fast16_t.adoc[`atomic&lowbar;int&lowbar;fast16&lowbar;t`] 
| Alias for `std&colon;&colon;atomic&lowbar;int&lowbar;fast16&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/atomic_int_fast32_t.adoc[`atomic&lowbar;int&lowbar;fast32&lowbar;t`] 
| Alias for `std&colon;&colon;atomic&lowbar;int&lowbar;fast32&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/atomic_int_fast64_t.adoc[`atomic&lowbar;int&lowbar;fast64&lowbar;t`] 
| Alias for `std&colon;&colon;atomic&lowbar;int&lowbar;fast64&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/atomic_int_fast8_t.adoc[`atomic&lowbar;int&lowbar;fast8&lowbar;t`] 
| Alias for `std&colon;&colon;atomic&lowbar;int&lowbar;fast8&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/atomic_int_least16_t.adoc[`atomic&lowbar;int&lowbar;least16&lowbar;t`] 
| Alias for `std&colon;&colon;atomic&lowbar;int&lowbar;least16&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/atomic_int_least32_t.adoc[`atomic&lowbar;int&lowbar;least32&lowbar;t`] 
| Alias for `std&colon;&colon;atomic&lowbar;int&lowbar;least32&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/atomic_int_least64_t.adoc[`atomic&lowbar;int&lowbar;least64&lowbar;t`] 
| Alias for `std&colon;&colon;atomic&lowbar;int&lowbar;least64&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/atomic_int_least8_t.adoc[`atomic&lowbar;int&lowbar;least8&lowbar;t`] 
| Alias for `std&colon;&colon;atomic&lowbar;int&lowbar;least8&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/atomic_intmax_t.adoc[`atomic&lowbar;intmax&lowbar;t`] 
| Alias for `std&colon;&colon;atomic&lowbar;intmax&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/atomic_intptr_t.adoc[`atomic&lowbar;intptr&lowbar;t`] 
| Alias for `std&colon;&colon;atomic&lowbar;intptr&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/atomic_is_lock_free.adoc[`atomic&lowbar;is&lowbar;lock&lowbar;free`] 
| Alias for `std&colon;&colon;atomic&lowbar;is&lowbar;lock&lowbar;free` in the `bsl` namespace&period;
| xref:bsl/atomic_llong.adoc[`atomic&lowbar;llong`] 
| Alias for `std&colon;&colon;atomic&lowbar;llong` in the `bsl` namespace&period;
| xref:bsl/atomic_load.adoc[`atomic&lowbar;load`] 
| Alias for `std&colon;&colon;atomic&lowbar;load` in the `bsl` namespace&period;
| xref:bsl/atomic_load_explicit.adoc[`atomic&lowbar;load&lowbar;explicit`] 
| Alias for `std&colon;&colon;atomic&lowbar;load&lowbar;explicit` in the `bsl` namespace&period;
| xref:bsl/atomic_long.adoc[`atomic&lowbar;long`] 
| Alias for `std&colon;&colon;atomic&lowbar;long` in the `bsl` namespace&period;
| xref:bsl/atomic_notify_all.adoc[`atomic&lowbar;notify&lowbar;all`] 
| Alias for `std&colon;&colon;atomic&lowbar;notify&lowbar;all` in the `bsl` namespace&period;
| xref:bsl/atomic_notify_one.adoc[`atomic&lowbar;notify&lowbar;one`] 
| Alias for `std&colon;&colon;atomic&lowbar;notify&lowbar;one` in the `bsl` namespace&period;
| xref:bsl/atomic_ptrdiff_t.adoc[`atomic&lowbar;ptrdiff&lowbar;t`] 
| Alias for `std&colon;&colon;atomic&lowbar;ptrdiff&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/atomic_ref.adoc[`atomic&lowbar;ref`] 
| Alias for `std&colon;&colon;atomic&lowbar;ref` in the `bsl` namespace&period;
| xref:bsl/atomic_schar.adoc[`atomic&lowbar;schar`] 
| Alias for `std&colon;&colon;atomic&lowbar;schar` in the `bsl` namespace&period;
| xref:bsl/atomic_short.adoc[`atomic&lowbar;short`] 
| Alias for `std&colon;&colon;atomic&lowbar;short` in the `bsl` namespace&period;
| xref:bsl/atomic_signal_fence.adoc[`atomic&lowbar;signal&lowbar;fence`] 
| Alias for `std&colon;&colon;atomic&lowbar;signal&lowbar;fence` in the `bsl` namespace&period;
| xref:bsl/atomic_signed_lock_free.adoc[`atomic&lowbar;signed&lowbar;lock&lowbar;free`] 
| Alias for `std&colon;&colon;atomic&lowbar;signed&lowbar;lock&lowbar;free` in the `bsl` namespace&period;
| xref:bsl/atomic_size_t.adoc[`atomic&lowbar;size&lowbar;t`] 
| Alias for `std&colon;&colon;atomic&lowbar;size&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/atomic_store.adoc[`atomic&lowbar;store`] 
| Alias for `std&colon;&colon;atomic&lowbar;store` in the `bsl` namespace&period;
| xref:bsl/atomic_store_explicit.adoc[`atomic&lowbar;store&lowbar;explicit`] 
| Alias for `std&colon;&colon;atomic&lowbar;store&lowbar;explicit` in the `bsl` namespace&period;
| xref:bsl/atomic_thread_fence.adoc[`atomic&lowbar;thread&lowbar;fence`] 
| Alias for `std&colon;&colon;atomic&lowbar;thread&lowbar;fence` in the `bsl` namespace&period;
| xref:bsl/atomic_uchar.adoc[`atomic&lowbar;uchar`] 
| Alias for `std&colon;&colon;atomic&lowbar;uchar` in the `bsl` namespace&period;
| xref:bsl/atomic_uint.adoc[`atomic&lowbar;uint`] 
| Alias for `std&colon;&colon;atomic&lowbar;uint` in the `bsl` namespace&period;
| xref:bsl/atomic_uint16_t.adoc[`atomic&lowbar;uint16&lowbar;t`] 
| Alias for `std&colon;&colon;atomic&lowbar;uint16&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/atomic_uint32_t.adoc[`atomic&lowbar;uint32&lowbar;t`] 
| Alias for `std&colon;&colon;atomic&lowbar;uint32&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/atomic_uint64_t.adoc[`atomic&lowbar;uint64&lowbar;t`] 
| Alias for `std&colon;&colon;atomic&lowbar;uint64&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/atomic_uint8_t.adoc[`atomic&lowbar;uint8&lowbar;t`] 
| Alias for `std&colon;&colon;atomic&lowbar;uint8&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/atomic_uint_fast16_t.adoc[`atomic&lowbar;uint&lowbar;fast16&lowbar;t`] 
| Alias for `std&colon;&colon;atomic&lowbar;uint&lowbar;fast16&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/atomic_uint_fast32_t.adoc[`atomic&lowbar;uint&lowbar;fast32&lowbar;t`] 
| Alias for `std&colon;&colon;atomic&lowbar;uint&lowbar;fast32&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/atomic_uint_fast64_t.adoc[`atomic&lowbar;uint&lowbar;fast64&lowbar;t`] 
| Alias for `std&colon;&colon;atomic&lowbar;uint&lowbar;fast64&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/atomic_uint_fast8_t.adoc[`atomic&lowbar;uint&lowbar;fast8&lowbar;t`] 
| Alias for `std&colon;&colon;atomic&lowbar;uint&lowbar;fast8&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/atomic_uint_least16_t.adoc[`atomic&lowbar;uint&lowbar;least16&lowbar;t`] 
| Alias for `std&colon;&colon;atomic&lowbar;uint&lowbar;least16&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/atomic_uint_least32_t.adoc[`atomic&lowbar;uint&lowbar;least32&lowbar;t`] 
| Alias for `std&colon;&colon;atomic&lowbar;uint&lowbar;least32&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/atomic_uint_least64_t.adoc[`atomic&lowbar;uint&lowbar;least64&lowbar;t`] 
| Alias for `std&colon;&colon;atomic&lowbar;uint&lowbar;least64&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/atomic_uint_least8_t.adoc[`atomic&lowbar;uint&lowbar;least8&lowbar;t`] 
| Alias for `std&colon;&colon;atomic&lowbar;uint&lowbar;least8&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/atomic_uintmax_t.adoc[`atomic&lowbar;uintmax&lowbar;t`] 
| Alias for `std&colon;&colon;atomic&lowbar;uintmax&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/atomic_uintptr_t.adoc[`atomic&lowbar;uintptr&lowbar;t`] 
| Alias for `std&colon;&colon;atomic&lowbar;uintptr&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/atomic_ullong.adoc[`atomic&lowbar;ullong`] 
| Alias for `std&colon;&colon;atomic&lowbar;ullong` in the `bsl` namespace&period;
| xref:bsl/atomic_ulong.adoc[`atomic&lowbar;ulong`] 
| Alias for `std&colon;&colon;atomic&lowbar;ulong` in the `bsl` namespace&period;
| xref:bsl/atomic_unsigned_lock_free.adoc[`atomic&lowbar;unsigned&lowbar;lock&lowbar;free`] 
| Alias for `std&colon;&colon;atomic&lowbar;unsigned&lowbar;lock&lowbar;free` in the `bsl` namespace&period;
| xref:bsl/atomic_ushort.adoc[`atomic&lowbar;ushort`] 
| Alias for `std&colon;&colon;atomic&lowbar;ushort` in the `bsl` namespace&period;
| xref:bsl/atomic_wait.adoc[`atomic&lowbar;wait`] 
| Alias for `std&colon;&colon;atomic&lowbar;wait` in the `bsl` namespace&period;
| xref:bsl/atomic_wait_explicit.adoc[`atomic&lowbar;wait&lowbar;explicit`] 
| Alias for `std&colon;&colon;atomic&lowbar;wait&lowbar;explicit` in the `bsl` namespace&period;
| xref:bsl/atomic_wchar_t.adoc[`atomic&lowbar;wchar&lowbar;t`] 
| Alias for `std&colon;&colon;atomic&lowbar;wchar&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/atto.adoc[`atto`] 
| Alias for `std&colon;&colon;atto`&period;
| xref:bsl/auto_ptr.adoc[`auto&lowbar;ptr`] 
| Alias for `std&colon;&colon;auto&lowbar;ptr` in the `bsl` namespace&period;
| xref:bsl/back_insert_iterator.adoc[`back&lowbar;insert&lowbar;iterator`] 
| Alias for `std&colon;&colon;back&lowbar;insert&lowbar;iterator` in the `bsl` namespace&period;
| xref:bsl/back_inserter.adoc[`back&lowbar;inserter`] 
| Alias for `std&colon;&colon;back&lowbar;inserter` in the `bsl` namespace&period;
| xref:bsl/bad_alloc.adoc[`bad&lowbar;alloc`] 
| Alias for `std&colon;&colon;bad&lowbar;alloc` in the `bsl` namespace&period;
| xref:bsl/bad_array_new_length.adoc[`bad&lowbar;array&lowbar;new&lowbar;length`] 
| Alias for `std&colon;&colon;bad&lowbar;array&lowbar;new&lowbar;length` in the `bsl` namespace&period;
| xref:bsl/bad_cast.adoc[`bad&lowbar;cast`] 
| Alias for `std&colon;&colon;bad&lowbar;cast` in the `bsl` namespace&period;
| xref:bsl/bad_exception.adoc[`bad&lowbar;exception`] 
| Alias for `std&colon;&colon;bad&lowbar;exception` in the `bsl` namespace&period;
| xref:bsl/bad_function_call.adoc[`bad&lowbar;function&lowbar;call`] 
| Alias for `std&colon;&colon;bad&lowbar;function&lowbar;call` in the `bsl` namespace&period;
| xref:bsl/bad_typeid.adoc[`bad&lowbar;typeid`] 
| Alias for `std&colon;&colon;bad&lowbar;typeid` in the `bsl` namespace&period;
| xref:bsl/bad_variant_access.adoc[`bad&lowbar;variant&lowbar;access`] 
| Alias for `std&colon;&colon;bad&lowbar;variant&lowbar;access` in the `bsl` namespace&period;
| xref:bsl/barrier.adoc[`barrier`] 
| Alias for `std&colon;&colon;barrier` in the `bsl` namespace&period;
| xref:bsl/basic_common_reference.adoc[`basic&lowbar;common&lowbar;reference`] 
| Alias for `std&colon;&colon;basic&lowbar;common&lowbar;reference` in the `bsl` namespace&period;
| xref:bsl/basic_const_iterator.adoc[`basic&lowbar;const&lowbar;iterator`] 
| Alias for `std&colon;&colon;basic&lowbar;const&lowbar;iterator` in the `bsl` namespace&period;
| xref:bsl/basic_filebuf.adoc[`basic&lowbar;filebuf`] 
| Alias for `std&colon;&colon;basic&lowbar;filebuf` in the `bsl` namespace&period;
| xref:bsl/basic_format_arg.adoc[`basic&lowbar;format&lowbar;arg`] 
| Alias for `std&colon;&colon;basic&lowbar;format&lowbar;arg` in the `bsl` namespace&period;
| xref:bsl/basic_format_args.adoc[`basic&lowbar;format&lowbar;args`] 
| Alias for `std&colon;&colon;basic&lowbar;format&lowbar;args` in the `bsl` namespace&period;
| xref:bsl/basic_format_context.adoc[`basic&lowbar;format&lowbar;context`] 
| Alias for `std&colon;&colon;basic&lowbar;format&lowbar;context` in the `bsl` namespace&period;
| xref:bsl/basic_format_parse_context.adoc[`basic&lowbar;format&lowbar;parse&lowbar;context`] 
| Alias for `std&colon;&colon;basic&lowbar;format&lowbar;parse&lowbar;context` in the `bsl` namespace&period;
| xref:bsl/basic_format_string.adoc[`basic&lowbar;format&lowbar;string`] 
| Alias for `std&colon;&colon;basic&lowbar;format&lowbar;string` in the `bsl` namespace&period;
| xref:bsl/basic_fstream.adoc[`basic&lowbar;fstream`] 
| Alias for `std&colon;&colon;basic&lowbar;fstream` in the `bsl` namespace&period;
| xref:bsl/basic_ifstream.adoc[`basic&lowbar;ifstream`] 
| Alias for `std&colon;&colon;basic&lowbar;ifstream` in the `bsl` namespace&period;
| xref:bsl/basic_ios.adoc[`basic&lowbar;ios`] 
| Alias for `std&colon;&colon;basic&lowbar;ios` in the `bsl` namespace&period;
| xref:bsl/basic_iostream.adoc[`basic&lowbar;iostream`] 
| Alias for `std&colon;&colon;basic&lowbar;iostream` in the `bsl` namespace&period;
| xref:bsl/basic_ispanstream.adoc[`basic&lowbar;ispanstream`] 
| Alias for `std&colon;&colon;basic&lowbar;ispanstream` in the `bsl` namespace&period;
| xref:bsl/basic_istream.adoc[`basic&lowbar;istream`] 
| Alias for `std&colon;&colon;basic&lowbar;istream` in the `bsl` namespace&period;
| xref:bsl/basic_ofstream.adoc[`basic&lowbar;ofstream`] 
| Alias for `std&colon;&colon;basic&lowbar;ofstream` in the `bsl` namespace&period;
| xref:bsl/basic_ospanstream.adoc[`basic&lowbar;ospanstream`] 
| Alias for `std&colon;&colon;basic&lowbar;ospanstream` in the `bsl` namespace&period;
| xref:bsl/basic_ostream.adoc[`basic&lowbar;ostream`] 
| Alias for `std&colon;&colon;basic&lowbar;ostream` in the `bsl` namespace&period;
| xref:bsl/basic_regex.adoc[`basic&lowbar;regex`] 
| Alias for `std&colon;&colon;basic&lowbar;regex` in the `bsl` namespace&period;
| xref:bsl/basic_spanbuf.adoc[`basic&lowbar;spanbuf`] 
| Alias for `std&colon;&colon;basic&lowbar;spanbuf` in the `bsl` namespace&period;
| xref:bsl/basic_spanstream.adoc[`basic&lowbar;spanstream`] 
| Alias for `std&colon;&colon;basic&lowbar;spanstream` in the `bsl` namespace&period;
| xref:bsl/basic_streambuf.adoc[`basic&lowbar;streambuf`] 
| Alias for `std&colon;&colon;basic&lowbar;streambuf` in the `bsl` namespace&period;
| xref:bsl/basic_string_view.adoc[`basic&lowbar;string&lowbar;view`] 
| Alias for `std&colon;&colon;basic&lowbar;string&lowbar;view` in the `bsl` namespace&period;
| xref:bsl/begin-0b.adoc[`begin`] 
| Alias for `std&colon;&colon;begin` in the `bsl` namespace&period;
| xref:bsl/begin-08.adoc[`begin`] 
| Alias for `std&colon;&colon;begin` in the `bsl` namespace&period;
| xref:bsl/begin-02.adoc[`begin`] 
| Alias for `std&colon;&colon;begin` in the `bsl` namespace&period;
| xref:bsl/bernoulli_distribution.adoc[`bernoulli&lowbar;distribution`] 
| Alias for `std&colon;&colon;bernoulli&lowbar;distribution` in the `bsl` namespace&period;
| xref:bsl/beta.adoc[`beta`] 
| 
| xref:bsl/betaf.adoc[`betaf`] 
| 
| xref:bsl/betal.adoc[`betal`] 
| 
| xref:bsl/bidirectional_iterator.adoc[`bidirectional&lowbar;iterator`] 
| Alias for `std&colon;&colon;bidirectional&lowbar;iterator` in the `bsl` namespace&period;
| xref:bsl/bidirectional_iterator_tag.adoc[`bidirectional&lowbar;iterator&lowbar;tag`] 
| Alias for `std&colon;&colon;bidirectional&lowbar;iterator&lowbar;tag` in the `bsl` namespace&period;
| xref:bsl/binary_function.adoc[`binary&lowbar;function`] 
| Alias for `std&colon;&colon;binary&lowbar;function` in the `bsl` namespace&period;
| xref:bsl/binary_negate.adoc[`binary&lowbar;negate`] 
| Alias for `std&colon;&colon;binary&lowbar;negate` in the `bsl` namespace&period;
| xref:bsl/binary_search.adoc[`binary&lowbar;search`] 
| Alias for `std&colon;&colon;binary&lowbar;search` in the `bsl` namespace&period;
| xref:bsl/binary_semaphore.adoc[`binary&lowbar;semaphore`] 
| Alias for `std&colon;&colon;binary&lowbar;semaphore` in the `bsl` namespace&period;
| xref:bsl/bind.adoc[`bind`] 
| Alias for `std&colon;&colon;bind` in the `bsl` namespace&period;
| xref:bsl/bind1st.adoc[`bind1st`] 
| Alias for `std&colon;&colon;bind1st` in the `bsl` namespace&period;
| xref:bsl/bind2nd.adoc[`bind2nd`] 
| Alias for `std&colon;&colon;bind2nd` in the `bsl` namespace&period;
| xref:bsl/bind_back.adoc[`bind&lowbar;back`] 
| Alias for `std&colon;&colon;bind&lowbar;back` in the `bsl` namespace&period;
| xref:bsl/bind_front.adoc[`bind&lowbar;front`] 
| Alias for `std&colon;&colon;bind&lowbar;front` in the `bsl` namespace&period;
| xref:bsl/binder1st.adoc[`binder1st`] 
| Alias for `std&colon;&colon;binder1st` in the `bsl` namespace&period;
| xref:bsl/binder2nd.adoc[`binder2nd`] 
| Alias for `std&colon;&colon;binder2nd` in the `bsl` namespace&period;
| xref:bsl/binomial_distribution.adoc[`binomial&lowbar;distribution`] 
| Alias for `std&colon;&colon;binomial&lowbar;distribution` in the `bsl` namespace&period;
| xref:bsl/bit_and.adoc[`bit&lowbar;and`] 
| Alias for `std&colon;&colon;bit&lowbar;and` in the `bsl` namespace&period;
| xref:bsl/bit_cast.adoc[`bit&lowbar;cast`] 
| Alias for `std&colon;&colon;bit&lowbar;cast` in the `bsl` namespace&period;
| xref:bsl/bit_ceil.adoc[`bit&lowbar;ceil`] 
| Alias for `std&colon;&colon;bit&lowbar;ceil` in the `bsl` namespace&period;
| xref:bsl/bit_floor.adoc[`bit&lowbar;floor`] 
| Alias for `std&colon;&colon;bit&lowbar;floor` in the `bsl` namespace&period;
| xref:bsl/bit_not.adoc[`bit&lowbar;not`] 
| Alias for `std&colon;&colon;bit&lowbar;not` in the `bsl` namespace&period;
| xref:bsl/bit_or.adoc[`bit&lowbar;or`] 
| Alias for `std&colon;&colon;bit&lowbar;or` in the `bsl` namespace&period;
| xref:bsl/bit_width.adoc[`bit&lowbar;width`] 
| Alias for `std&colon;&colon;bit&lowbar;width` in the `bsl` namespace&period;
| xref:bsl/bit_xor.adoc[`bit&lowbar;xor`] 
| Alias for `std&colon;&colon;bit&lowbar;xor` in the `bsl` namespace&period;
| xref:bsl/boolalpha.adoc[`boolalpha`] 
| Alias for `std&colon;&colon;boolalpha` in the `bsl` namespace&period;
| xref:bsl/boyer_moore_horspool_searcher.adoc[`boyer&lowbar;moore&lowbar;horspool&lowbar;searcher`] 
| Alias for `std&colon;&colon;boyer&lowbar;moore&lowbar;horspool&lowbar;searcher` in the `bsl` namespace&period;
| xref:bsl/boyer_moore_searcher.adoc[`boyer&lowbar;moore&lowbar;searcher`] 
| Alias for `std&colon;&colon;boyer&lowbar;moore&lowbar;searcher` in the `bsl` namespace&period;
| xref:bsl/bsearch.adoc[`bsearch`] 
| Alias for `std&colon;&colon;bsearch` in the `bsl` namespace&period;
| xref:bsl/btowc.adoc[`btowc`] 
| Alias for `std&colon;&colon;btowc` in the `bsl` namespace&period;
| xref:bsl/byte.adoc[`byte`] 
| Alias for `std&colon;&colon;byte` in the `bsl` namespace&period;
| xref:bsl/byteswap.adoc[`byteswap`] 
| Alias for `std&colon;&colon;byteswap` in the `bsl` namespace&period;
| xref:bsl/c16rtomb.adoc[`c16rtomb`] 
| Alias for `std&colon;&colon;c16rtomb` in the `bsl` namespace&period;
| xref:bsl/c32rtomb.adoc[`c32rtomb`] 
| Alias for `std&colon;&colon;c32rtomb` in the `bsl` namespace&period;
| xref:bsl/call_once.adoc[`call&lowbar;once`] 
| Alias for `std&colon;&colon;call&lowbar;once` in the `bsl` namespace&period;
| xref:bsl/calloc.adoc[`calloc`] 
| Alias for `std&colon;&colon;calloc` in the `bsl` namespace&period;
| xref:bsl/cauchy_distribution.adoc[`cauchy&lowbar;distribution`] 
| Alias for `std&colon;&colon;cauchy&lowbar;distribution` in the `bsl` namespace&period;
| xref:bsl/cbegin.adoc[`cbegin`] 
| Alias for `std&colon;&colon;cbegin` in the `bsl` namespace&period;
| xref:bsl/cbrt.adoc[`cbrt`] 
| Alias for `std&colon;&colon;cbrt` in the `bsl` namespace&period;
| xref:bsl/ceil.adoc[`ceil`] 
| Alias for `std&colon;&colon;ceil` in the `bsl` namespace&period;
| xref:bsl/cend.adoc[`cend`] 
| Alias for `std&colon;&colon;cend` in the `bsl` namespace&period;
| xref:bsl/centi.adoc[`centi`] 
| Alias for `std&colon;&colon;centi`&period;
| xref:bsl/cerr.adoc[`cerr`] 
| Alias for `std&colon;&colon;cerr` in the `bsl` namespace&period;
| xref:bsl/char_traits.adoc[`char&lowbar;traits`] 
| Alias for `std&colon;&colon;char&lowbar;traits` in the `bsl` namespace&period;
| xref:bsl/chars_format.adoc[`chars&lowbar;format`] 
| 
| xref:bsl/chi_squared_distribution.adoc[`chi&lowbar;squared&lowbar;distribution`] 
| Alias for `std&colon;&colon;chi&lowbar;squared&lowbar;distribution` in the `bsl` namespace&period;
| xref:bsl/cin.adoc[`cin`] 
| Alias for `std&colon;&colon;cin` in the `bsl` namespace&period;
| xref:bsl/clamp.adoc[`clamp`] 
| Alias for `std&colon;&colon;clamp` in the `bsl` namespace&period;
| xref:bsl/clearerr.adoc[`clearerr`] 
| Alias for `std&colon;&colon;clearerr` in the `bsl` namespace&period;
| xref:bsl/clock.adoc[`clock`] 
| Alias for `std&colon;&colon;clock` in the `bsl` namespace&period;
| xref:bsl/clock_t.adoc[`clock&lowbar;t`] 
| Alias for `std&colon;&colon;clock&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/clog.adoc[`clog`] 
| Alias for `std&colon;&colon;clog` in the `bsl` namespace&period;
| xref:bsl/cmatch.adoc[`cmatch`] 
| Alias for `std&colon;&colon;cmatch` in the `bsl` namespace&period;
| xref:bsl/cmp_equal.adoc[`cmp&lowbar;equal`] 
| Alias for `std&colon;&colon;cmp&lowbar;equal` in the `bsl` namespace&period;
| xref:bsl/cmp_greater.adoc[`cmp&lowbar;greater`] 
| Alias for `std&colon;&colon;cmp&lowbar;greater` in the `bsl` namespace&period;
| xref:bsl/cmp_greater_equal.adoc[`cmp&lowbar;greater&lowbar;equal`] 
| Alias for `std&colon;&colon;cmp&lowbar;greater&lowbar;equal` in the `bsl` namespace&period;
| xref:bsl/cmp_less.adoc[`cmp&lowbar;less`] 
| Alias for `std&colon;&colon;cmp&lowbar;less` in the `bsl` namespace&period;
| xref:bsl/cmp_less_equal.adoc[`cmp&lowbar;less&lowbar;equal`] 
| Alias for `std&colon;&colon;cmp&lowbar;less&lowbar;equal` in the `bsl` namespace&period;
| xref:bsl/cmp_not_equal.adoc[`cmp&lowbar;not&lowbar;equal`] 
| Alias for `std&colon;&colon;cmp&lowbar;not&lowbar;equal` in the `bsl` namespace&period;
| xref:bsl/codecvt.adoc[`codecvt`] 
| Alias for `std&colon;&colon;codecvt` in the `bsl` namespace&period;
| xref:bsl/codecvt_base.adoc[`codecvt&lowbar;base`] 
| Alias for `std&colon;&colon;codecvt&lowbar;base` in the `bsl` namespace&period;
| xref:bsl/codecvt_byname.adoc[`codecvt&lowbar;byname`] 
| Alias for `std&colon;&colon;codecvt&lowbar;byname` in the `bsl` namespace&period;
| xref:bsl/collate.adoc[`collate`] 
| Alias for `std&colon;&colon;collate` in the `bsl` namespace&period;
| xref:bsl/collate_byname.adoc[`collate&lowbar;byname`] 
| Alias for `std&colon;&colon;collate&lowbar;byname` in the `bsl` namespace&period;
| xref:bsl/common_comparison_category.adoc[`common&lowbar;comparison&lowbar;category`] 
| Alias for `std&colon;&colon;common&lowbar;comparison&lowbar;category` in the `bsl` namespace&period;
| xref:bsl/common_comparison_category_t.adoc[`common&lowbar;comparison&lowbar;category&lowbar;t`] 
| Alias for `std&colon;&colon;common&lowbar;comparison&lowbar;category&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/common_iterator.adoc[`common&lowbar;iterator`] 
| Alias for `std&colon;&colon;common&lowbar;iterator` in the `bsl` namespace&period;
| xref:bsl/common_reference.adoc[`common&lowbar;reference`] 
| Alias for `std&colon;&colon;common&lowbar;reference` in the `bsl` namespace&period;
| xref:bsl/common_reference_t.adoc[`common&lowbar;reference&lowbar;t`] 
| Alias for `std&colon;&colon;common&lowbar;reference&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/common_reference_with.adoc[`common&lowbar;reference&lowbar;with`] 
| Alias for `std&colon;&colon;common&lowbar;reference&lowbar;with` in the `bsl` namespace&period;
| xref:bsl/common_type.adoc[`common&lowbar;type`] 
| Alias for `std&colon;&colon;common&lowbar;type` in the `bsl` namespace&period;
| xref:bsl/common_with.adoc[`common&lowbar;with`] 
| Alias for `std&colon;&colon;common&lowbar;with` in the `bsl` namespace&period;
| xref:bsl/comp_ellint_1.adoc[`comp&lowbar;ellint&lowbar;1`] 
| 
| xref:bsl/comp_ellint_1f.adoc[`comp&lowbar;ellint&lowbar;1f`] 
| 
| xref:bsl/comp_ellint_1l.adoc[`comp&lowbar;ellint&lowbar;1l`] 
| 
| xref:bsl/comp_ellint_2.adoc[`comp&lowbar;ellint&lowbar;2`] 
| 
| xref:bsl/comp_ellint_2f.adoc[`comp&lowbar;ellint&lowbar;2f`] 
| 
| xref:bsl/comp_ellint_2l.adoc[`comp&lowbar;ellint&lowbar;2l`] 
| 
| xref:bsl/comp_ellint_3.adoc[`comp&lowbar;ellint&lowbar;3`] 
| 
| xref:bsl/comp_ellint_3f.adoc[`comp&lowbar;ellint&lowbar;3f`] 
| 
| xref:bsl/comp_ellint_3l.adoc[`comp&lowbar;ellint&lowbar;3l`] 
| 
| xref:bsl/compare_partial_order_fallback.adoc[`compare&lowbar;partial&lowbar;order&lowbar;fallback`] 
| Alias for `std&colon;&colon;compare&lowbar;partial&lowbar;order&lowbar;fallback` in the `bsl` namespace&period;
| xref:bsl/compare_strong_order_fallback.adoc[`compare&lowbar;strong&lowbar;order&lowbar;fallback`] 
| Alias for `std&colon;&colon;compare&lowbar;strong&lowbar;order&lowbar;fallback` in the `bsl` namespace&period;
| xref:bsl/compare_three_way.adoc[`compare&lowbar;three&lowbar;way`] 
| Alias for `std&colon;&colon;compare&lowbar;three&lowbar;way` in the `bsl` namespace&period;
| xref:bsl/compare_three_way_result.adoc[`compare&lowbar;three&lowbar;way&lowbar;result`] 
| Alias for `std&colon;&colon;compare&lowbar;three&lowbar;way&lowbar;result` in the `bsl` namespace&period;
| xref:bsl/compare_three_way_result_t.adoc[`compare&lowbar;three&lowbar;way&lowbar;result&lowbar;t`] 
| Alias for `std&colon;&colon;compare&lowbar;three&lowbar;way&lowbar;result&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/compare_weak_order_fallback.adoc[`compare&lowbar;weak&lowbar;order&lowbar;fallback`] 
| Alias for `std&colon;&colon;compare&lowbar;weak&lowbar;order&lowbar;fallback` in the `bsl` namespace&period;
| xref:bsl/complex.adoc[`complex`] 
| Alias for `std&colon;&colon;complex` in the `bsl` namespace&period;
| xref:bsl/condition_variable.adoc[`condition&lowbar;variable`] 
| Alias for `std&colon;&colon;condition&lowbar;variable` in the `bsl` namespace&period;
| xref:bsl/condition_variable_any.adoc[`condition&lowbar;variable&lowbar;any`] 
| Alias for `std&colon;&colon;condition&lowbar;variable&lowbar;any` in the `bsl` namespace&period;
| xref:bsl/conj.adoc[`conj`] 
| Alias for `std&colon;&colon;conj` in the `bsl` namespace&period;
| xref:bsl/conjunction.adoc[`conjunction`] 
| Alias for `std&colon;&colon;conjunction` in the `bsl` namespace&period;
| xref:bsl/conjunction_v.adoc[`conjunction&lowbar;v`] 
| Alias for `std&colon;&colon;conjunction&lowbar;v` in the `bsl` namespace&period;
| xref:bsl/const_iterator.adoc[`const&lowbar;iterator`] 
| Alias for `std&colon;&colon;const&lowbar;iterator` in the `bsl` namespace&period;
| xref:bsl/const_mem_fun1_ref_t.adoc[`const&lowbar;mem&lowbar;fun1&lowbar;ref&lowbar;t`] 
| Alias for `std&colon;&colon;const&lowbar;mem&lowbar;fun1&lowbar;ref&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/const_mem_fun1_t.adoc[`const&lowbar;mem&lowbar;fun1&lowbar;t`] 
| Alias for `std&colon;&colon;const&lowbar;mem&lowbar;fun1&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/const_mem_fun_ref_t.adoc[`const&lowbar;mem&lowbar;fun&lowbar;ref&lowbar;t`] 
| Alias for `std&colon;&colon;const&lowbar;mem&lowbar;fun&lowbar;ref&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/const_mem_fun_t.adoc[`const&lowbar;mem&lowbar;fun&lowbar;t`] 
| Alias for `std&colon;&colon;const&lowbar;mem&lowbar;fun&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/const_sentinel.adoc[`const&lowbar;sentinel`] 
| Alias for `std&colon;&colon;const&lowbar;sentinel` in the `bsl` namespace&period;
| xref:bsl/construct_at.adoc[`construct&lowbar;at`] 
| Alias for `std&colon;&colon;construct&lowbar;at` in the `bsl` namespace&period;
| xref:bsl/constructible_from.adoc[`constructible&lowbar;from`] 
| Alias for `std&colon;&colon;constructible&lowbar;from` in the `bsl` namespace&period;
| xref:bsl/contiguous_iterator.adoc[`contiguous&lowbar;iterator`] 
| Alias for `std&colon;&colon;contiguous&lowbar;iterator` in the `bsl` namespace&period;
| xref:bsl/contiguous_iterator_tag.adoc[`contiguous&lowbar;iterator&lowbar;tag`] 
| Alias for `std&colon;&colon;contiguous&lowbar;iterator&lowbar;tag` in the `bsl` namespace&period;
| xref:bsl/convertible_to.adoc[`convertible&lowbar;to`] 
| Alias for `std&colon;&colon;convertible&lowbar;to` in the `bsl` namespace&period;
| xref:bsl/copy-05.adoc[`copy`] 
| Alias for `std&colon;&colon;copy` in the `bsl` namespace&period;
| xref:bsl/copy-0b.adoc[`copy`] 
| Alias for `std&colon;&colon;copy` in the `bsl` namespace&period;
| xref:bsl/copy_backward.adoc[`copy&lowbar;backward`] 
| Alias for `std&colon;&colon;copy&lowbar;backward` in the `bsl` namespace&period;
| xref:bsl/copy_constructible.adoc[`copy&lowbar;constructible`] 
| Alias for `std&colon;&colon;copy&lowbar;constructible` in the `bsl` namespace&period;
| xref:bsl/copy_if.adoc[`copy&lowbar;if`] 
| Alias for `std&colon;&colon;copy&lowbar;if` in the `bsl` namespace&period;
| xref:bsl/copy_n.adoc[`copy&lowbar;n`] 
| Alias for `std&colon;&colon;copy&lowbar;n` in the `bsl` namespace&period;
| xref:bsl/copyable.adoc[`copyable`] 
| Alias for `std&colon;&colon;copyable` in the `bsl` namespace&period;
| xref:bsl/copysign.adoc[`copysign`] 
| Alias for `std&colon;&colon;copysign` in the `bsl` namespace&period;
| xref:bsl/coroutine_handle.adoc[`coroutine&lowbar;handle`] 
| Alias for `std&colon;&colon;coroutine&lowbar;handle` in the `bsl` namespace&period;
| xref:bsl/coroutine_traits.adoc[`coroutine&lowbar;traits`] 
| Alias for `std&colon;&colon;coroutine&lowbar;traits` in the `bsl` namespace&period;
| xref:bsl/cos-0e7.adoc[`cos`] 
| Alias for `std&colon;&colon;cos` in the `bsl` namespace&period;
| xref:bsl/cos-04.adoc[`cos`] 
| Alias for `std&colon;&colon;cos` in the `bsl` namespace&period;
| xref:bsl/cos-0ef.adoc[`cos`] 
| Alias for `std&colon;&colon;cos` in the `bsl` namespace&period;
| xref:bsl/cosh-06.adoc[`cosh`] 
| Alias for `std&colon;&colon;cosh` in the `bsl` namespace&period;
| xref:bsl/cosh-0c.adoc[`cosh`] 
| Alias for `std&colon;&colon;cosh` in the `bsl` namespace&period;
| xref:bsl/cosh-02.adoc[`cosh`] 
| Alias for `std&colon;&colon;cosh` in the `bsl` namespace&period;
| xref:bsl/count.adoc[`count`] 
| Alias for `std&colon;&colon;count` in the `bsl` namespace&period;
| xref:bsl/count_if.adoc[`count&lowbar;if`] 
| Alias for `std&colon;&colon;count&lowbar;if` in the `bsl` namespace&period;
| xref:bsl/counted_iterator.adoc[`counted&lowbar;iterator`] 
| Alias for `std&colon;&colon;counted&lowbar;iterator` in the `bsl` namespace&period;
| xref:bsl/counting_semaphore.adoc[`counting&lowbar;semaphore`] 
| Alias for `std&colon;&colon;counting&lowbar;semaphore` in the `bsl` namespace&period;
| xref:bsl/countl_one.adoc[`countl&lowbar;one`] 
| Alias for `std&colon;&colon;countl&lowbar;one` in the `bsl` namespace&period;
| xref:bsl/countl_zero.adoc[`countl&lowbar;zero`] 
| Alias for `std&colon;&colon;countl&lowbar;zero` in the `bsl` namespace&period;
| xref:bsl/countr_one.adoc[`countr&lowbar;one`] 
| Alias for `std&colon;&colon;countr&lowbar;one` in the `bsl` namespace&period;
| xref:bsl/countr_zero.adoc[`countr&lowbar;zero`] 
| Alias for `std&colon;&colon;countr&lowbar;zero` in the `bsl` namespace&period;
| xref:bsl/cout.adoc[`cout`] 
| Import `std&colon;&colon;cout` into the `bsl` namespace&period;
| xref:bsl/crbegin.adoc[`crbegin`] 
| Alias for `std&colon;&colon;crbegin` in the `bsl` namespace&period;
| xref:bsl/cref.adoc[`cref`] 
| Alias for `std&colon;&colon;cref` in the `bsl` namespace&period;
| xref:bsl/cregex_iterator.adoc[`cregex&lowbar;iterator`] 
| Alias for `std&colon;&colon;cregex&lowbar;iterator` in the `bsl` namespace&period;
| xref:bsl/crend.adoc[`crend`] 
| Alias for `std&colon;&colon;crend` in the `bsl` namespace&period;
| xref:bsl/csub_match.adoc[`csub&lowbar;match`] 
| Alias for `std&colon;&colon;csub&lowbar;match` in the `bsl` namespace&period;
| xref:bsl/ctime.adoc[`ctime`] 
| Alias for `std&colon;&colon;ctime` in the `bsl` namespace&period;
| xref:bsl/ctype.adoc[`ctype`] 
| Alias for `std&colon;&colon;ctype` in the `bsl` namespace&period;
| xref:bsl/ctype_base.adoc[`ctype&lowbar;base`] 
| Alias for `std&colon;&colon;ctype&lowbar;base` in the `bsl` namespace&period;
| xref:bsl/ctype_byname.adoc[`ctype&lowbar;byname`] 
| Alias for `std&colon;&colon;ctype&lowbar;byname` in the `bsl` namespace&period;
| xref:bsl/current_exception.adoc[`current&lowbar;exception`] 
| Undocumented symbol&period;
| xref:bsl/cv_status.adoc[`cv&lowbar;status`] 
| Alias for `std&colon;&colon;cv&lowbar;status` in the `bsl` namespace&period;
| xref:bsl/cyl_bessel_i.adoc[`cyl&lowbar;bessel&lowbar;i`] 
| 
| xref:bsl/cyl_bessel_if.adoc[`cyl&lowbar;bessel&lowbar;if`] 
| 
| xref:bsl/cyl_bessel_il.adoc[`cyl&lowbar;bessel&lowbar;il`] 
| 
| xref:bsl/cyl_bessel_j.adoc[`cyl&lowbar;bessel&lowbar;j`] 
| 
| xref:bsl/cyl_bessel_jf.adoc[`cyl&lowbar;bessel&lowbar;jf`] 
| 
| xref:bsl/cyl_bessel_jl.adoc[`cyl&lowbar;bessel&lowbar;jl`] 
| 
| xref:bsl/cyl_bessel_k.adoc[`cyl&lowbar;bessel&lowbar;k`] 
| 
| xref:bsl/cyl_bessel_kf.adoc[`cyl&lowbar;bessel&lowbar;kf`] 
| 
| xref:bsl/cyl_bessel_kl.adoc[`cyl&lowbar;bessel&lowbar;kl`] 
| 
| xref:bsl/cyl_neumann.adoc[`cyl&lowbar;neumann`] 
| 
| xref:bsl/cyl_neumannf.adoc[`cyl&lowbar;neumannf`] 
| 
| xref:bsl/cyl_neumannl.adoc[`cyl&lowbar;neumannl`] 
| 
| xref:bsl/data.adoc[`data`] 
| Alias for `std&colon;&colon;data` in the `bsl` namespace&period;
| xref:bsl/dec.adoc[`dec`] 
| Alias for `std&colon;&colon;dec` in the `bsl` namespace&period;
| xref:bsl/deca.adoc[`deca`] 
| Alias for `std&colon;&colon;deca`&period;
| xref:bsl/deci.adoc[`deci`] 
| Alias for `std&colon;&colon;deci`&period;
| xref:bsl/declval.adoc[`declval`] 
| Alias for `std&colon;&colon;declval` in the `bsl` namespace&period;
| xref:bsl/default_delete.adoc[`default&lowbar;delete`] 
| Alias for `std&colon;&colon;default&lowbar;delete` in the `bsl` namespace&period;
| xref:bsl/default_initializable.adoc[`default&lowbar;initializable`] 
| Alias for `std&colon;&colon;default&lowbar;initializable` in the `bsl` namespace&period;
| xref:bsl/default_random_engine.adoc[`default&lowbar;random&lowbar;engine`] 
| Alias for `std&colon;&colon;default&lowbar;random&lowbar;engine` in the `bsl` namespace&period;
| xref:bsl/default_searcher.adoc[`default&lowbar;searcher`] 
| Alias for `std&colon;&colon;default&lowbar;searcher` in the `bsl` namespace&period;
| xref:bsl/default_sentinel_t.adoc[`default&lowbar;sentinel&lowbar;t`] 
| Alias for `std&colon;&colon;default&lowbar;sentinel&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/defaultfloat.adoc[`defaultfloat`] 
| Alias for `std&colon;&colon;defaultfloat` in the `bsl` namespace&period;
| xref:bsl/defer_lock.adoc[`defer&lowbar;lock`] 
| Alias for `std&colon;&colon;defer&lowbar;lock` in the `bsl` namespace&period;
| xref:bsl/defer_lock_t.adoc[`defer&lowbar;lock&lowbar;t`] 
| Alias for `std&colon;&colon;defer&lowbar;lock&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/denorm_absent.adoc[`denorm&lowbar;absent`] 
| Alias for `std&colon;&colon;denorm&lowbar;absent` in the `bsl` namespace&period;
| xref:bsl/denorm_indeterminate.adoc[`denorm&lowbar;indeterminate`] 
| Alias for `std&colon;&colon;denorm&lowbar;indeterminate` in the `bsl` namespace&period;
| xref:bsl/denorm_present.adoc[`denorm&lowbar;present`] 
| Alias for `std&colon;&colon;denorm&lowbar;present` in the `bsl` namespace&period;
| xref:bsl/derived_from.adoc[`derived&lowbar;from`] 
| Alias for `std&colon;&colon;derived&lowbar;from` in the `bsl` namespace&period;
| xref:bsl/destroy.adoc[`destroy`] 
| Alias for `std&colon;&colon;destroy` in the `bsl` namespace&period;
| xref:bsl/destroy_at.adoc[`destroy&lowbar;at`] 
| Alias for `std&colon;&colon;destroy&lowbar;at` in the `bsl` namespace&period;
| xref:bsl/destroy_n.adoc[`destroy&lowbar;n`] 
| Alias for `std&colon;&colon;destroy&lowbar;n` in the `bsl` namespace&period;
| xref:bsl/destructible.adoc[`destructible`] 
| Alias for `std&colon;&colon;destructible` in the `bsl` namespace&period;
| xref:bsl/difftime.adoc[`difftime`] 
| Alias for `std&colon;&colon;difftime` in the `bsl` namespace&period;
| xref:bsl/discard_block_engine.adoc[`discard&lowbar;block&lowbar;engine`] 
| Alias for `std&colon;&colon;discard&lowbar;block&lowbar;engine` in the `bsl` namespace&period;
| xref:bsl/discrete_distribution.adoc[`discrete&lowbar;distribution`] 
| Alias for `std&colon;&colon;discrete&lowbar;distribution` in the `bsl` namespace&period;
| xref:bsl/disjunction.adoc[`disjunction`] 
| Alias for `std&colon;&colon;disjunction` in the `bsl` namespace&period;
| xref:bsl/disjunction_v.adoc[`disjunction&lowbar;v`] 
| Alias for `std&colon;&colon;disjunction&lowbar;v` in the `bsl` namespace&period;
| xref:bsl/distance.adoc[`distance`] 
| Alias for `std&colon;&colon;distance` in the `bsl` namespace&period;
| xref:bsl/div.adoc[`div`] 
| Alias for `std&colon;&colon;div` in the `bsl` namespace&period;
| xref:bsl/div_t.adoc[`div&lowbar;t`] 
| Alias for `std&colon;&colon;div&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/divides.adoc[`divides`] 
| Alias for `std&colon;&colon;divides` in the `bsl` namespace&period;
| xref:bsl/domain_error.adoc[`domain&lowbar;error`] 
| Alias for `std&colon;&colon;domain&lowbar;error` in the `bsl` namespace&period;
| xref:bsl/double_t.adoc[`double&lowbar;t`] 
| Alias for `std&colon;&colon;double&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/dynamic_extent.adoc[`dynamic&lowbar;extent`] 
| Alias for `std&colon;&colon;dynamic&lowbar;extent`&period;
| xref:bsl/ellint_1.adoc[`ellint&lowbar;1`] 
| 
| xref:bsl/ellint_1f.adoc[`ellint&lowbar;1f`] 
| 
| xref:bsl/ellint_1l.adoc[`ellint&lowbar;1l`] 
| 
| xref:bsl/ellint_2.adoc[`ellint&lowbar;2`] 
| 
| xref:bsl/ellint_2f.adoc[`ellint&lowbar;2f`] 
| 
| xref:bsl/ellint_2l.adoc[`ellint&lowbar;2l`] 
| 
| xref:bsl/ellint_3.adoc[`ellint&lowbar;3`] 
| 
| xref:bsl/ellint_3f.adoc[`ellint&lowbar;3f`] 
| 
| xref:bsl/ellint_3l.adoc[`ellint&lowbar;3l`] 
| 
| xref:bsl/empty.adoc[`empty`] 
| Alias for `std&colon;&colon;empty` in the `bsl` namespace&period;
| xref:bsl/end-01.adoc[`end`] 
| Alias for `std&colon;&colon;end` in the `bsl` namespace&period;
| xref:bsl/end-04e.adoc[`end`] 
| Alias for `std&colon;&colon;end` in the `bsl` namespace&period;
| xref:bsl/end-04f.adoc[`end`] 
| Alias for `std&colon;&colon;end` in the `bsl` namespace&period;
| xref:bsl/endian.adoc[`endian`] 
| Alias for `std&colon;&colon;endian` in the `bsl` namespace&period;
| xref:bsl/endl.adoc[`endl`] 
| Alias for `std&colon;&colon;endl` in the `bsl` namespace&period;
| xref:bsl/ends.adoc[`ends`] 
| Alias for `std&colon;&colon;ends` in the `bsl` namespace&period;
| xref:bsl/equal.adoc[`equal`] 
| Alias for `std&colon;&colon;equal` in the `bsl` namespace&period;
| xref:bsl/equal_range.adoc[`equal&lowbar;range`] 
| Alias for `std&colon;&colon;equal&lowbar;range` in the `bsl` namespace&period;
| xref:bsl/equality_comparable.adoc[`equality&lowbar;comparable`] 
| Alias for `std&colon;&colon;equality&lowbar;comparable` in the `bsl` namespace&period;
| xref:bsl/equality_comparable_with.adoc[`equality&lowbar;comparable&lowbar;with`] 
| Alias for `std&colon;&colon;equality&lowbar;comparable&lowbar;with` in the `bsl` namespace&period;
| xref:bsl/equivalence_relation.adoc[`equivalence&lowbar;relation`] 
| Alias for `std&colon;&colon;equivalence&lowbar;relation` in the `bsl` namespace&period;
| xref:bsl/erf.adoc[`erf`] 
| Alias for `std&colon;&colon;erf` in the `bsl` namespace&period;
| xref:bsl/erfc.adoc[`erfc`] 
| Alias for `std&colon;&colon;erfc` in the `bsl` namespace&period;
| xref:bsl/errc.adoc[`errc`] 
| Alias for `std&colon;&colon;errc` in the `bsl` namespace&period;
| xref:bsl/error_category.adoc[`error&lowbar;category`] 
| Alias for `std&colon;&colon;error&lowbar;category` in the `bsl` namespace&period;
| xref:bsl/error_code.adoc[`error&lowbar;code`] 
| Alias for `std&colon;&colon;error&lowbar;code` in the `bsl` namespace&period;
| xref:bsl/error_condition.adoc[`error&lowbar;condition`] 
| Alias for `std&colon;&colon;error&lowbar;condition` in the `bsl` namespace&period;
| xref:bsl/exa.adoc[`exa`] 
| Alias for `std&colon;&colon;exa`&period;
| xref:bsl/exception.adoc[`exception`] 
| Alias for `std&colon;&colon;exception` in the `bsl` namespace&period;
| xref:bsl/exception_ptr.adoc[`exception&lowbar;ptr`] 
| Undocumented symbol&period;
| xref:bsl/exchange.adoc[`exchange`] 
| Alias for `std&colon;&colon;exchange` in the `bsl` namespace&period;
| xref:bsl/exclusive_scan.adoc[`exclusive&lowbar;scan`] 
| Alias for `std&colon;&colon;exclusive&lowbar;scan` in the `bsl` namespace&period;
| xref:bsl/exit.adoc[`exit`] 
| Import `std&colon;&colon;exit` into the `bsl` namespace&period;
| xref:bsl/exp-03.adoc[`exp`] 
| Alias for `std&colon;&colon;exp` in the `bsl` namespace&period;
| xref:bsl/exp-01.adoc[`exp`] 
| Alias for `std&colon;&colon;exp` in the `bsl` namespace&period;
| xref:bsl/exp-0f.adoc[`exp`] 
| Alias for `std&colon;&colon;exp` in the `bsl` namespace&period;
| xref:bsl/exp2.adoc[`exp2`] 
| Alias for `std&colon;&colon;exp2` in the `bsl` namespace&period;
| xref:bsl/expint.adoc[`expint`] 
| 
| xref:bsl/expintf.adoc[`expintf`] 
| 
| xref:bsl/expintl.adoc[`expintl`] 
| 
| xref:bsl/expm1.adoc[`expm1`] 
| Alias for `std&colon;&colon;expm1` in the `bsl` namespace&period;
| xref:bsl/exponential_distribution.adoc[`exponential&lowbar;distribution`] 
| Alias for `std&colon;&colon;exponential&lowbar;distribution` in the `bsl` namespace&period;
| xref:bsl/extent.adoc[`extent`] 
| Alias for `std&colon;&colon;extent` in the `bsl` namespace&period;
| xref:bsl/extreme_value_distribution.adoc[`extreme&lowbar;value&lowbar;distribution`] 
| Alias for `std&colon;&colon;extreme&lowbar;value&lowbar;distribution` in the `bsl` namespace&period;
| xref:bsl/fabs.adoc[`fabs`] 
| Alias for `std&colon;&colon;fabs` in the `bsl` namespace&period;
| xref:bsl/fclose.adoc[`fclose`] 
| Alias for `std&colon;&colon;fclose` in the `bsl` namespace&period;
| xref:bsl/fdim.adoc[`fdim`] 
| Alias for `std&colon;&colon;fdim` in the `bsl` namespace&period;
| xref:bsl/feclearexcept.adoc[`feclearexcept`] 
| Alias for `std&colon;&colon;feclearexcept` in the `bsl` namespace&period;
| xref:bsl/fegetenv.adoc[`fegetenv`] 
| Alias for `std&colon;&colon;fegetenv` in the `bsl` namespace&period;
| xref:bsl/fegetexceptflag.adoc[`fegetexceptflag`] 
| Alias for `std&colon;&colon;fegetexceptflag` in the `bsl` namespace&period;
| xref:bsl/fegetround.adoc[`fegetround`] 
| Alias for `std&colon;&colon;fegetround` in the `bsl` namespace&period;
| xref:bsl/feholdexcept.adoc[`feholdexcept`] 
| Alias for `std&colon;&colon;feholdexcept` in the `bsl` namespace&period;
| xref:bsl/femto.adoc[`femto`] 
| Alias for `std&colon;&colon;femto`&period;
| xref:bsl/fenv_t.adoc[`fenv&lowbar;t`] 
| Alias for `std&colon;&colon;fenv&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/feof.adoc[`feof`] 
| Alias for `std&colon;&colon;feof` in the `bsl` namespace&period;
| xref:bsl/feraiseexcept.adoc[`feraiseexcept`] 
| Alias for `std&colon;&colon;feraiseexcept` in the `bsl` namespace&period;
| xref:bsl/ferror.adoc[`ferror`] 
| Alias for `std&colon;&colon;ferror` in the `bsl` namespace&period;
| xref:bsl/fesetenv.adoc[`fesetenv`] 
| Alias for `std&colon;&colon;fesetenv` in the `bsl` namespace&period;
| xref:bsl/fesetexceptflag.adoc[`fesetexceptflag`] 
| Alias for `std&colon;&colon;fesetexceptflag` in the `bsl` namespace&period;
| xref:bsl/fesetround.adoc[`fesetround`] 
| Alias for `std&colon;&colon;fesetround` in the `bsl` namespace&period;
| xref:bsl/fetestexcept.adoc[`fetestexcept`] 
| Alias for `std&colon;&colon;fetestexcept` in the `bsl` namespace&period;
| xref:bsl/feupdateenv.adoc[`feupdateenv`] 
| Alias for `std&colon;&colon;feupdateenv` in the `bsl` namespace&period;
| xref:bsl/fexcept_t.adoc[`fexcept&lowbar;t`] 
| Alias for `std&colon;&colon;fexcept&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/fflush.adoc[`fflush`] 
| Alias for `std&colon;&colon;fflush` in the `bsl` namespace&period;
| xref:bsl/fgetc.adoc[`fgetc`] 
| Alias for `std&colon;&colon;fgetc` in the `bsl` namespace&period;
| xref:bsl/fgetpos.adoc[`fgetpos`] 
| Alias for `std&colon;&colon;fgetpos` in the `bsl` namespace&period;
| xref:bsl/fgets.adoc[`fgets`] 
| Alias for `std&colon;&colon;fgets` in the `bsl` namespace&period;
| xref:bsl/fgetwc.adoc[`fgetwc`] 
| Alias for `std&colon;&colon;fgetwc` in the `bsl` namespace&period;
| xref:bsl/fgetws.adoc[`fgetws`] 
| Alias for `std&colon;&colon;fgetws` in the `bsl` namespace&period;
| xref:bsl/filebuf.adoc[`filebuf`] 
| Alias for `std&colon;&colon;filebuf` in the `bsl` namespace&period;
| xref:bsl/fill.adoc[`fill`] 
| Alias for `std&colon;&colon;fill` in the `bsl` namespace&period;
| xref:bsl/fill_n.adoc[`fill&lowbar;n`] 
| Alias for `std&colon;&colon;fill&lowbar;n` in the `bsl` namespace&period;
| xref:bsl/find-00.adoc[`find`] 
| Alias for `std&colon;&colon;find` in the `bsl` namespace&period;
| xref:bsl/find-08.adoc[`find`] 
| Alias for `std&colon;&colon;find` in the `bsl` namespace&period;
| xref:bsl/find_end.adoc[`find&lowbar;end`] 
| Alias for `std&colon;&colon;find&lowbar;end` in the `bsl` namespace&period;
| xref:bsl/find_first_of.adoc[`find&lowbar;first&lowbar;of`] 
| Alias for `std&colon;&colon;find&lowbar;first&lowbar;of` in the `bsl` namespace&period;
| xref:bsl/find_if.adoc[`find&lowbar;if`] 
| Alias for `std&colon;&colon;find&lowbar;if` in the `bsl` namespace&period;
| xref:bsl/find_if_not.adoc[`find&lowbar;if&lowbar;not`] 
| Alias for `std&colon;&colon;find&lowbar;if&lowbar;not` in the `bsl` namespace&period;
| xref:bsl/fisher_f_distribution.adoc[`fisher&lowbar;f&lowbar;distribution`] 
| Alias for `std&colon;&colon;fisher&lowbar;f&lowbar;distribution` in the `bsl` namespace&period;
| xref:bsl/fixed.adoc[`fixed`] 
| Alias for `std&colon;&colon;fixed` in the `bsl` namespace&period;
| xref:bsl/float_denorm_style.adoc[`float&lowbar;denorm&lowbar;style`] 
| Alias for `std&colon;&colon;float&lowbar;denorm&lowbar;style` in the `bsl` namespace&period;
| xref:bsl/float_round_style.adoc[`float&lowbar;round&lowbar;style`] 
| Alias for `std&colon;&colon;float&lowbar;round&lowbar;style` in the `bsl` namespace&period;
| xref:bsl/float_t.adoc[`float&lowbar;t`] 
| Alias for `std&colon;&colon;float&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/floating_point.adoc[`floating&lowbar;point`] 
| Alias for `std&colon;&colon;floating&lowbar;point` in the `bsl` namespace&period;
| xref:bsl/floor.adoc[`floor`] 
| Alias for `std&colon;&colon;floor` in the `bsl` namespace&period;
| xref:bsl/flush.adoc[`flush`] 
| Alias for `std&colon;&colon;flush` in the `bsl` namespace&period;
| xref:bsl/fma.adoc[`fma`] 
| Alias for `std&colon;&colon;fma` in the `bsl` namespace&period;
| xref:bsl/fmax.adoc[`fmax`] 
| Alias for `std&colon;&colon;fmax` in the `bsl` namespace&period;
| xref:bsl/fmin.adoc[`fmin`] 
| Alias for `std&colon;&colon;fmin` in the `bsl` namespace&period;
| xref:bsl/fmod.adoc[`fmod`] 
| Alias for `std&colon;&colon;fmod` in the `bsl` namespace&period;
| xref:bsl/fopen.adoc[`fopen`] 
| Alias for `std&colon;&colon;fopen` in the `bsl` namespace&period;
| xref:bsl/for_each.adoc[`for&lowbar;each`] 
| Alias for `std&colon;&colon;for&lowbar;each` in the `bsl` namespace&period;
| xref:bsl/for_each_n.adoc[`for&lowbar;each&lowbar;n`] 
| Alias for `std&colon;&colon;for&lowbar;each&lowbar;n` in the `bsl` namespace&period;
| xref:bsl/format_args.adoc[`format&lowbar;args`] 
| Alias for `std&colon;&colon;format&lowbar;args` in the `bsl` namespace&period;
| xref:bsl/format_context.adoc[`format&lowbar;context`] 
| Alias for `std&colon;&colon;format&lowbar;context` in the `bsl` namespace&period;
| xref:bsl/format_error.adoc[`format&lowbar;error`] 
| Alias for `std&colon;&colon;format&lowbar;error` in the `bsl` namespace&period;
| xref:bsl/format_parse_context.adoc[`format&lowbar;parse&lowbar;context`] 
| Alias for `std&colon;&colon;format&lowbar;parse&lowbar;context` in the `bsl` namespace&period;
| xref:bsl/format_string.adoc[`format&lowbar;string`] 
| Alias for `std&colon;&colon;format&lowbar;string` in the `bsl` namespace&period;
| xref:bsl/format_to-02.adoc[`format&lowbar;to`] 
| Alias for `std&colon;&colon;format&lowbar;to` in the `bsl` namespace&period;
| xref:bsl/format_to_n.adoc[`format&lowbar;to&lowbar;n`] 
| Alias for `std&colon;&colon;format&lowbar;to&lowbar;n` in the `bsl` namespace&period;
| xref:bsl/format_to_n_result.adoc[`format&lowbar;to&lowbar;n&lowbar;result`] 
| Alias for `std&colon;&colon;format&lowbar;to&lowbar;n&lowbar;result` in the `bsl` namespace&period;
| xref:bsl/formattable.adoc[`formattable`] 
| Import `std&colon;&colon;formattable` into namespace `bsl`&period;
| xref:bsl/formatted_size.adoc[`formatted&lowbar;size`] 
| Alias for `std&colon;&colon;formatted&lowbar;size` in the `bsl` namespace&period;
| xref:bsl/forward.adoc[`forward`] 
| Alias for `std&colon;&colon;forward` in the `bsl` namespace&period;
| xref:bsl/forward_as_tuple.adoc[`forward&lowbar;as&lowbar;tuple`] 
| Alias for `std&colon;&colon;forward&lowbar;as&lowbar;tuple` in the `bsl` namespace&period;
| xref:bsl/forward_iterator.adoc[`forward&lowbar;iterator`] 
| Alias for `std&colon;&colon;forward&lowbar;iterator` in the `bsl` namespace&period;
| xref:bsl/forward_iterator_tag.adoc[`forward&lowbar;iterator&lowbar;tag`] 
| Alias for `std&colon;&colon;forward&lowbar;iterator&lowbar;tag` in the `bsl` namespace&period;
| xref:bsl/forward_like.adoc[`forward&lowbar;like`] 
| Alias for `std&colon;&colon;forward&lowbar;like` in the `bsl` namespace&period;
| xref:bsl/fpclassify.adoc[`fpclassify`] 
| Alias for `std&colon;&colon;fpclassify` in the `bsl` namespace&period;
| xref:bsl/fpos.adoc[`fpos`] 
| Alias for `std&colon;&colon;fpos` in the `bsl` namespace&period;
| xref:bsl/fpos_t.adoc[`fpos&lowbar;t`] 
| Alias for `std&colon;&colon;fpos&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/fprintf.adoc[`fprintf`] 
| Alias for `std&colon;&colon;fprintf` in the `bsl` namespace&period;
| xref:bsl/fputc.adoc[`fputc`] 
| Alias for `std&colon;&colon;fputc` in the `bsl` namespace&period;
| xref:bsl/fputs.adoc[`fputs`] 
| Alias for `std&colon;&colon;fputs` in the `bsl` namespace&period;
| xref:bsl/fputwc.adoc[`fputwc`] 
| Alias for `std&colon;&colon;fputwc` in the `bsl` namespace&period;
| xref:bsl/fputws.adoc[`fputws`] 
| Alias for `std&colon;&colon;fputws` in the `bsl` namespace&period;
| xref:bsl/fread.adoc[`fread`] 
| Alias for `std&colon;&colon;fread` in the `bsl` namespace&period;
| xref:bsl/free.adoc[`free`] 
| Alias for `std&colon;&colon;free` in the `bsl` namespace&period;
| xref:bsl/freopen.adoc[`freopen`] 
| Alias for `std&colon;&colon;freopen` in the `bsl` namespace&period;
| xref:bsl/frexp.adoc[`frexp`] 
| Alias for `std&colon;&colon;frexp` in the `bsl` namespace&period;
| xref:bsl/from_chars.adoc[`from&lowbar;chars`] 
| 
| xref:bsl/from_chars_result.adoc[`from&lowbar;chars&lowbar;result`] 
| 
| xref:bsl/from_range.adoc[`from&lowbar;range`] 
| Alias for `std&colon;&colon;from&lowbar;range` in the `bsl` namespace&period;
| xref:bsl/from_range_t.adoc[`from&lowbar;range&lowbar;t`] 
| Alias for `std&colon;&colon;from&lowbar;range&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/front_insert_iterator.adoc[`front&lowbar;insert&lowbar;iterator`] 
| Alias for `std&colon;&colon;front&lowbar;insert&lowbar;iterator` in the `bsl` namespace&period;
| xref:bsl/front_inserter.adoc[`front&lowbar;inserter`] 
| Standard library alias for `std&colon;&colon;front&lowbar;inserter`&period;
| xref:bsl/fscanf.adoc[`fscanf`] 
| Alias for `std&colon;&colon;fscanf` in the `bsl` namespace&period;
| xref:bsl/fseek.adoc[`fseek`] 
| Alias for `std&colon;&colon;fseek` in the `bsl` namespace&period;
| xref:bsl/fsetpos.adoc[`fsetpos`] 
| Alias for `std&colon;&colon;fsetpos` in the `bsl` namespace&period;
| xref:bsl/fstream.adoc[`fstream`] 
| Alias for `std&colon;&colon;fstream` in the `bsl` namespace&period;
| xref:bsl/ftell.adoc[`ftell`] 
| Alias for `std&colon;&colon;ftell` in the `bsl` namespace&period;
| xref:bsl/future.adoc[`future`] 
| Alias for `std&colon;&colon;future` in the `bsl` namespace&period;
| xref:bsl/future_category.adoc[`future&lowbar;category`] 
| Alias for `std&colon;&colon;future&lowbar;category` in the `bsl` namespace&period;
| xref:bsl/future_errc.adoc[`future&lowbar;errc`] 
| Alias for `std&colon;&colon;future&lowbar;errc` in the `bsl` namespace&period;
| xref:bsl/future_error.adoc[`future&lowbar;error`] 
| Alias for `std&colon;&colon;future&lowbar;error` in the `bsl` namespace&period;
| xref:bsl/future_status.adoc[`future&lowbar;status`] 
| Alias for `std&colon;&colon;future&lowbar;status` in the `bsl` namespace&period;
| xref:bsl/fwide.adoc[`fwide`] 
| Alias for `std&colon;&colon;fwide` in the `bsl` namespace&period;
| xref:bsl/fwprintf.adoc[`fwprintf`] 
| Alias for `std&colon;&colon;fwprintf` in the `bsl` namespace&period;
| xref:bsl/fwrite.adoc[`fwrite`] 
| Alias for `std&colon;&colon;fwrite` in the `bsl` namespace&period;
| xref:bsl/fwscanf.adoc[`fwscanf`] 
| Alias for `std&colon;&colon;fwscanf` in the `bsl` namespace&period;
| xref:bsl/gamma_distribution.adoc[`gamma&lowbar;distribution`] 
| Alias for `std&colon;&colon;gamma&lowbar;distribution` in the `bsl` namespace&period;
| xref:bsl/gcd.adoc[`gcd`] 
| Alias for `std&colon;&colon;gcd` in the `bsl` namespace&period;
| xref:bsl/generate.adoc[`generate`] 
| Alias for `std&colon;&colon;generate` in the `bsl` namespace&period;
| xref:bsl/generate_canonical.adoc[`generate&lowbar;canonical`] 
| Alias for `std&colon;&colon;generate&lowbar;canonical` in the `bsl` namespace&period;
| xref:bsl/generate_n.adoc[`generate&lowbar;n`] 
| Alias for `std&colon;&colon;generate&lowbar;n` in the `bsl` namespace&period;
| xref:bsl/generic_category.adoc[`generic&lowbar;category`] 
| Alias for `std&colon;&colon;generic&lowbar;category` in the `bsl` namespace&period;
| xref:bsl/geometric_distribution.adoc[`geometric&lowbar;distribution`] 
| Alias for `std&colon;&colon;geometric&lowbar;distribution` in the `bsl` namespace&period;
| xref:bsl/get-09.adoc[`get`] 
| Alias for `std&colon;&colon;get` in the `bsl` namespace&period;
| xref:bsl/get-0c.adoc[`get`] 
| Alias for `std&colon;&colon;get` in the `bsl` namespace&period;
| xref:bsl/get_money.adoc[`get&lowbar;money`] 
| Alias for `std&colon;&colon;get&lowbar;money` in the `bsl` namespace&period;
| xref:bsl/get_new_handler.adoc[`get&lowbar;new&lowbar;handler`] 
| Alias for `std&colon;&colon;get&lowbar;new&lowbar;handler` in the `bsl` namespace&period;
| xref:bsl/get_temporary_buffer.adoc[`get&lowbar;temporary&lowbar;buffer`] 
| Alias for `std&colon;&colon;get&lowbar;temporary&lowbar;buffer` in the `bsl` namespace&period;
| xref:bsl/get_terminate.adoc[`get&lowbar;terminate`] 
| Undocumented symbol&period;
| xref:bsl/get_time.adoc[`get&lowbar;time`] 
| Alias for `std&colon;&colon;get&lowbar;time` in the `bsl` namespace&period;
| xref:bsl/getc.adoc[`getc`] 
| Alias for `std&colon;&colon;getc` in the `bsl` namespace&period;
| xref:bsl/getchar.adoc[`getchar`] 
| Alias for `std&colon;&colon;getchar` in the `bsl` namespace&period;
| xref:bsl/getenv.adoc[`getenv`] 
| Import `std&colon;&colon;getenv` into the `bsl` namespace&period;
| xref:bsl/getwc.adoc[`getwc`] 
| Alias for `std&colon;&colon;getwc` in the `bsl` namespace&period;
| xref:bsl/getwchar.adoc[`getwchar`] 
| Alias for `std&colon;&colon;getwchar` in the `bsl` namespace&period;
| xref:bsl/giga.adoc[`giga`] 
| Alias for `std&colon;&colon;giga`&period;
| xref:bsl/gmtime.adoc[`gmtime`] 
| Alias for `std&colon;&colon;gmtime` in the `bsl` namespace&period;
| xref:bsl/greater.adoc[`greater`] 
| Alias for `std&colon;&colon;greater` in the `bsl` namespace&period;
| xref:bsl/greater_equal.adoc[`greater&lowbar;equal`] 
| Alias for `std&colon;&colon;greater&lowbar;equal` in the `bsl` namespace&period;
| xref:bsl/gslice.adoc[`gslice`] 
| Alias for `std&colon;&colon;gslice` in the `bsl` namespace&period;
| xref:bsl/gslice_array.adoc[`gslice&lowbar;array`] 
| Alias for `std&colon;&colon;gslice&lowbar;array` in the `bsl` namespace&period;
| xref:bsl/hardware_constructive_interference_size.adoc[`hardware&lowbar;constructive&lowbar;interference&lowbar;size`] 
| Alias for `std&colon;&colon;hardware&lowbar;constructive&lowbar;interference&lowbar;size` in the `bsl` namespace&period;
| xref:bsl/hardware_destructive_interference_size.adoc[`hardware&lowbar;destructive&lowbar;interference&lowbar;size`] 
| Alias for `std&colon;&colon;hardware&lowbar;destructive&lowbar;interference&lowbar;size` in the `bsl` namespace&period;
| xref:bsl/has_facet.adoc[`has&lowbar;facet`] 
| Alias for `std&colon;&colon;has&lowbar;facet` in the `bsl` namespace&period;
| xref:bsl/has_single_bit.adoc[`has&lowbar;single&lowbar;bit`] 
| Alias for `std&colon;&colon;has&lowbar;single&lowbar;bit` in the `bsl` namespace&period;
| xref:bsl/has_unique_object_representations.adoc[`has&lowbar;unique&lowbar;object&lowbar;representations`] 
| Alias for `std&colon;&colon;has&lowbar;unique&lowbar;object&lowbar;representations` in the `bsl` namespace&period;
| xref:bsl/has_virtual_destructor.adoc[`has&lowbar;virtual&lowbar;destructor`] 
| Alias for `std&colon;&colon;has&lowbar;virtual&lowbar;destructor` in the `bsl` namespace&period;
| xref:bsl/hecto.adoc[`hecto`] 
| Alias for `std&colon;&colon;hecto`&period;
| xref:bsl/hermite.adoc[`hermite`] 
| 
| xref:bsl/hermitef.adoc[`hermitef`] 
| 
| xref:bsl/hermitel.adoc[`hermitel`] 
| 
| xref:bsl/hex.adoc[`hex`] 
| Alias for `std&colon;&colon;hex` in the `bsl` namespace&period;
| xref:bsl/hexfloat.adoc[`hexfloat`] 
| Alias for `std&colon;&colon;hexfloat` in the `bsl` namespace&period;
| xref:bsl/hypot.adoc[`hypot`] 
| Alias for `std&colon;&colon;hypot` in the `bsl` namespace&period;
| xref:bsl/ifstream.adoc[`ifstream`] 
| Alias for `std&colon;&colon;ifstream` in the `bsl` namespace&period;
| xref:bsl/ignore.adoc[`ignore`] 
| Alias for `std&colon;&colon;ignore` in the `bsl` namespace&period;
| xref:bsl/ilogb.adoc[`ilogb`] 
| Alias for `std&colon;&colon;ilogb` in the `bsl` namespace&period;
| xref:bsl/imag.adoc[`imag`] 
| Alias for `std&colon;&colon;imag` in the `bsl` namespace&period;
| xref:bsl/imaxabs.adoc[`imaxabs`] 
| Alias for `std&colon;&colon;imaxabs` in the `bsl` namespace&period;
| xref:bsl/imaxdiv.adoc[`imaxdiv`] 
| Alias for `std&colon;&colon;imaxdiv` in the `bsl` namespace&period;
| xref:bsl/imaxdiv_t.adoc[`imaxdiv&lowbar;t`] 
| Alias for `std&colon;&colon;imaxdiv&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/in_place.adoc[`in&lowbar;place`] 
| Alias for `std&colon;&colon;in&lowbar;place` in the `bsl` namespace&period;
| xref:bsl/in_place_index.adoc[`in&lowbar;place&lowbar;index`] 
| Alias for `std&colon;&colon;in&lowbar;place&lowbar;index` in the `bsl` namespace&period;
| xref:bsl/in_place_index_t.adoc[`in&lowbar;place&lowbar;index&lowbar;t`] 
| Alias for `std&colon;&colon;in&lowbar;place&lowbar;index&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/in_place_t.adoc[`in&lowbar;place&lowbar;t`] 
| Alias for `std&colon;&colon;in&lowbar;place&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/in_place_type.adoc[`in&lowbar;place&lowbar;type`] 
| Alias for `std&colon;&colon;in&lowbar;place&lowbar;type` in the `bsl` namespace&period;
| xref:bsl/in_place_type_t.adoc[`in&lowbar;place&lowbar;type&lowbar;t`] 
| Alias for `std&colon;&colon;in&lowbar;place&lowbar;type&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/in_range.adoc[`in&lowbar;range`] 
| Alias for `std&colon;&colon;in&lowbar;range` in the `bsl` namespace&period;
| xref:bsl/includes.adoc[`includes`] 
| Alias for `std&colon;&colon;includes` in the `bsl` namespace&period;
| xref:bsl/inclusive_scan.adoc[`inclusive&lowbar;scan`] 
| Alias for `std&colon;&colon;inclusive&lowbar;scan` in the `bsl` namespace&period;
| xref:bsl/incrementable.adoc[`incrementable`] 
| Alias for `std&colon;&colon;incrementable` in the `bsl` namespace&period;
| xref:bsl/incrementable_traits.adoc[`incrementable&lowbar;traits`] 
| Alias for `std&colon;&colon;incrementable&lowbar;traits` in the `bsl` namespace&period;
| xref:bsl/independent_bits_engine.adoc[`independent&lowbar;bits&lowbar;engine`] 
| Alias for `std&colon;&colon;independent&lowbar;bits&lowbar;engine` in the `bsl` namespace&period;
| xref:bsl/index_sequence.adoc[`index&lowbar;sequence`] 
| Alias for `std&colon;&colon;index&lowbar;sequence` in the `bsl` namespace&period;
| xref:bsl/index_sequence_for.adoc[`index&lowbar;sequence&lowbar;for`] 
| Alias for `std&colon;&colon;index&lowbar;sequence&lowbar;for` in the `bsl` namespace&period;
| xref:bsl/indirect_array.adoc[`indirect&lowbar;array`] 
| Alias for `std&colon;&colon;indirect&lowbar;array` in the `bsl` namespace&period;
| xref:bsl/indirect_binary_predicate.adoc[`indirect&lowbar;binary&lowbar;predicate`] 
| Alias for `std&colon;&colon;indirect&lowbar;binary&lowbar;predicate` in the `bsl` namespace&period;
| xref:bsl/indirect_equivalence_relation.adoc[`indirect&lowbar;equivalence&lowbar;relation`] 
| Alias for `std&colon;&colon;indirect&lowbar;equivalence&lowbar;relation` in the `bsl` namespace&period;
| xref:bsl/indirect_result_t.adoc[`indirect&lowbar;result&lowbar;t`] 
| Alias for `std&colon;&colon;indirect&lowbar;result&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/indirect_strict_weak_order.adoc[`indirect&lowbar;strict&lowbar;weak&lowbar;order`] 
| Alias for `std&colon;&colon;indirect&lowbar;strict&lowbar;weak&lowbar;order` in the `bsl` namespace&period;
| xref:bsl/indirect_unary_predicate.adoc[`indirect&lowbar;unary&lowbar;predicate`] 
| Standard library alias for `std&colon;&colon;indirect&lowbar;unary&lowbar;predicate`&period;
| xref:bsl/indirectly_comparable.adoc[`indirectly&lowbar;comparable`] 
| Alias for `std&colon;&colon;indirectly&lowbar;comparable` in the `bsl` namespace&period;
| xref:bsl/indirectly_copyable.adoc[`indirectly&lowbar;copyable`] 
| Alias for `std&colon;&colon;indirectly&lowbar;copyable` in the `bsl` namespace&period;
| xref:bsl/indirectly_copyable_storable.adoc[`indirectly&lowbar;copyable&lowbar;storable`] 
| Alias for `std&colon;&colon;indirectly&lowbar;copyable&lowbar;storable` in the `bsl` namespace&period;
| xref:bsl/indirectly_movable.adoc[`indirectly&lowbar;movable`] 
| Alias for `std&colon;&colon;indirectly&lowbar;movable` in the `bsl` namespace&period;
| xref:bsl/indirectly_movable_storable.adoc[`indirectly&lowbar;movable&lowbar;storable`] 
| Alias for `std&colon;&colon;indirectly&lowbar;movable&lowbar;storable` in the `bsl` namespace&period;
| xref:bsl/indirectly_readable.adoc[`indirectly&lowbar;readable`] 
| Alias for `std&colon;&colon;indirectly&lowbar;readable` in the `bsl` namespace&period;
| xref:bsl/indirectly_readable_traits.adoc[`indirectly&lowbar;readable&lowbar;traits`] 
| Alias for `std&colon;&colon;indirectly&lowbar;readable&lowbar;traits` in the `bsl` namespace&period;
| xref:bsl/indirectly_regular_unary_invocable.adoc[`indirectly&lowbar;regular&lowbar;unary&lowbar;invocable`] 
| Alias for `std&colon;&colon;indirectly&lowbar;regular&lowbar;unary&lowbar;invocable` in the `bsl` namespace&period;
| xref:bsl/indirectly_swappable.adoc[`indirectly&lowbar;swappable`] 
| Alias for `std&colon;&colon;indirectly&lowbar;swappable` in the `bsl` namespace&period;
| xref:bsl/indirectly_unary_invocable.adoc[`indirectly&lowbar;unary&lowbar;invocable`] 
| Alias for `std&colon;&colon;indirectly&lowbar;unary&lowbar;invocable` in the `bsl` namespace&period;
| xref:bsl/indirectly_writable.adoc[`indirectly&lowbar;writable`] 
| Alias for `std&colon;&colon;indirectly&lowbar;writable` in the `bsl` namespace&period;
| xref:bsl/initializer_list.adoc[`initializer&lowbar;list`] 
| Alias for `std&colon;&colon;initializer&lowbar;list` in the `bsl` namespace&period;
| xref:bsl/inner_product.adoc[`inner&lowbar;product`] 
| Alias for `std&colon;&colon;inner&lowbar;product` in the `bsl` namespace&period;
| xref:bsl/inout_ptr.adoc[`inout&lowbar;ptr`] 
| Alias for `std&colon;&colon;inout&lowbar;ptr` in the `bsl` namespace&period;
| xref:bsl/inout_ptr_t.adoc[`inout&lowbar;ptr&lowbar;t`] 
| Alias for `std&colon;&colon;inout&lowbar;ptr&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/inplace_merge.adoc[`inplace&lowbar;merge`] 
| Alias for `std&colon;&colon;inplace&lowbar;merge` in the `bsl` namespace&period;
| xref:bsl/input_iterator.adoc[`input&lowbar;iterator`] 
| Alias for `std&colon;&colon;input&lowbar;iterator` in the `bsl` namespace&period;
| xref:bsl/input_iterator_tag.adoc[`input&lowbar;iterator&lowbar;tag`] 
| Alias for `std&colon;&colon;input&lowbar;iterator&lowbar;tag` in the `bsl` namespace&period;
| xref:bsl/input_or_output_iterator.adoc[`input&lowbar;or&lowbar;output&lowbar;iterator`] 
| Alias for `std&colon;&colon;input&lowbar;or&lowbar;output&lowbar;iterator` in the `bsl` namespace&period;
| xref:bsl/insert_iterator.adoc[`insert&lowbar;iterator`] 
| Alias for `std&colon;&colon;insert&lowbar;iterator` in the `bsl` namespace&period;
| xref:bsl/inserter.adoc[`inserter`] 
| Alias for `std&colon;&colon;inserter` in the `bsl` namespace&period;
| xref:bsl/int16_t.adoc[`int16&lowbar;t`] 
| Alias for `&colon;&colon;int16&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/int32_t.adoc[`int32&lowbar;t`] 
| Alias for `&colon;&colon;int32&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/int64_t.adoc[`int64&lowbar;t`] 
| Alias for `&colon;&colon;int64&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/int8_t.adoc[`int8&lowbar;t`] 
| Alias for `&colon;&colon;int8&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/int_fast16_t.adoc[`int&lowbar;fast16&lowbar;t`] 
| Alias for `&colon;&colon;int&lowbar;fast16&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/int_fast32_t.adoc[`int&lowbar;fast32&lowbar;t`] 
| Alias for `&colon;&colon;int&lowbar;fast32&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/int_fast64_t.adoc[`int&lowbar;fast64&lowbar;t`] 
| Alias for `&colon;&colon;int&lowbar;fast64&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/int_fast8_t.adoc[`int&lowbar;fast8&lowbar;t`] 
| Alias for `&colon;&colon;int&lowbar;fast8&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/int_least16_t.adoc[`int&lowbar;least16&lowbar;t`] 
| Alias for `&colon;&colon;int&lowbar;least16&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/int_least32_t.adoc[`int&lowbar;least32&lowbar;t`] 
| Alias for `&colon;&colon;int&lowbar;least32&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/int_least64_t.adoc[`int&lowbar;least64&lowbar;t`] 
| Alias for `&colon;&colon;int&lowbar;least64&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/int_least8_t.adoc[`int&lowbar;least8&lowbar;t`] 
| Alias for `&colon;&colon;int&lowbar;least8&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/integer_sequence.adoc[`integer&lowbar;sequence`] 
| Alias for `std&colon;&colon;integer&lowbar;sequence` in the `bsl` namespace&period;
| xref:bsl/integral.adoc[`integral`] 
| Alias for `std&colon;&colon;integral` in the `bsl` namespace&period;
| xref:bsl/internal.adoc[`internal`] 
| Alias for `std&colon;&colon;internal` in the `bsl` namespace&period;
| xref:bsl/intmax_t.adoc[`intmax&lowbar;t`] 
| Alias for `&colon;&colon;intmax&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/intptr_t.adoc[`intptr&lowbar;t`] 
| Alias for `&colon;&colon;intptr&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/invalid_argument.adoc[`invalid&lowbar;argument`] 
| Alias for `std&colon;&colon;invalid&lowbar;argument` in the `bsl` namespace&period;
| xref:bsl/invocable.adoc[`invocable`] 
| Alias for `std&colon;&colon;invocable` in the `bsl` namespace&period;
| xref:bsl/invoke.adoc[`invoke`] 
| Alias for `std&colon;&colon;invoke` in the `bsl` namespace&period;
| xref:bsl/invoke_r.adoc[`invoke&lowbar;r`] 
| Alias for `std&colon;&colon;invoke&lowbar;r` in the `bsl` namespace&period;
| xref:bsl/io_errc.adoc[`io&lowbar;errc`] 
| Alias for `std&colon;&colon;io&lowbar;errc` in the `bsl` namespace&period;
| xref:bsl/ios.adoc[`ios`] 
| Alias for `std&colon;&colon;ios` in the `bsl` namespace&period;
| xref:bsl/ios_base.adoc[`ios&lowbar;base`] 
| Alias for `std&colon;&colon;ios&lowbar;base` in the `bsl` namespace&period;
| xref:bsl/iostream.adoc[`iostream`] 
| Alias for `std&colon;&colon;iostream` in the `bsl` namespace&period;
| xref:bsl/iostream_category.adoc[`iostream&lowbar;category`] 
| Alias for `std&colon;&colon;iostream&lowbar;category` in the `bsl` namespace&period;
| xref:bsl/iota.adoc[`iota`] 
| Alias for `std&colon;&colon;iota` in the `bsl` namespace&period;
| xref:bsl/is_abstract.adoc[`is&lowbar;abstract`] 
| Alias for `std&colon;&colon;is&lowbar;abstract` in the `bsl` namespace&period;
| xref:bsl/is_aggregate.adoc[`is&lowbar;aggregate`] 
| Alias for `std&colon;&colon;is&lowbar;aggregate` in the `bsl` namespace&period;
| xref:bsl/is_assignable.adoc[`is&lowbar;assignable`] 
| Alias for `std&colon;&colon;is&lowbar;assignable` in the `bsl` namespace&period;
| xref:bsl/is_base_of.adoc[`is&lowbar;base&lowbar;of`] 
| Alias for `std&colon;&colon;is&lowbar;base&lowbar;of` in the `bsl` namespace&period;
| xref:bsl/is_bind_expression.adoc[`is&lowbar;bind&lowbar;expression`] 
| Alias for `std&colon;&colon;is&lowbar;bind&lowbar;expression` in the `bsl` namespace&period;
| xref:bsl/is_bind_expression_v.adoc[`is&lowbar;bind&lowbar;expression&lowbar;v`] 
| Alias for `std&colon;&colon;is&lowbar;bind&lowbar;expression&lowbar;v` in the `bsl` namespace&period;
| xref:bsl/is_compound.adoc[`is&lowbar;compound`] 
| Alias for `std&colon;&colon;is&lowbar;compound` in the `bsl` namespace&period;
| xref:bsl/is_constant_evaluated.adoc[`is&lowbar;constant&lowbar;evaluated`] 
| Alias for `std&colon;&colon;is&lowbar;constant&lowbar;evaluated` in the `bsl` namespace&period;
| xref:bsl/is_constructible.adoc[`is&lowbar;constructible`] 
| Alias for `std&colon;&colon;is&lowbar;constructible` in the `bsl` namespace&period;
| xref:bsl/is_copy_assignable.adoc[`is&lowbar;copy&lowbar;assignable`] 
| Alias for `std&colon;&colon;is&lowbar;copy&lowbar;assignable` in the `bsl` namespace&period;
| xref:bsl/is_default_constructible.adoc[`is&lowbar;default&lowbar;constructible`] 
| Alias for `std&colon;&colon;is&lowbar;default&lowbar;constructible` in the `bsl` namespace&period;
| xref:bsl/is_destructible.adoc[`is&lowbar;destructible`] 
| Alias for `std&colon;&colon;is&lowbar;destructible` in the `bsl` namespace&period;
| xref:bsl/is_eq.adoc[`is&lowbar;eq`] 
| Alias for `std&colon;&colon;is&lowbar;eq` in the `bsl` namespace&period;
| xref:bsl/is_error_code_enum.adoc[`is&lowbar;error&lowbar;code&lowbar;enum`] 
| Alias for `std&colon;&colon;is&lowbar;error&lowbar;code&lowbar;enum` in the `bsl` namespace&period;
| xref:bsl/is_error_code_enum_v.adoc[`is&lowbar;error&lowbar;code&lowbar;enum&lowbar;v`] 
| Alias for `std&colon;&colon;is&lowbar;error&lowbar;code&lowbar;enum&lowbar;v` in the `bsl` namespace&period;
| xref:bsl/is_error_condition_enum.adoc[`is&lowbar;error&lowbar;condition&lowbar;enum`] 
| Alias for `std&colon;&colon;is&lowbar;error&lowbar;condition&lowbar;enum` in the `bsl` namespace&period;
| xref:bsl/is_error_condition_enum_v.adoc[`is&lowbar;error&lowbar;condition&lowbar;enum&lowbar;v`] 
| Alias for `std&colon;&colon;is&lowbar;error&lowbar;condition&lowbar;enum&lowbar;v` in the `bsl` namespace&period;
| xref:bsl/is_final.adoc[`is&lowbar;final`] 
| Alias for `std&colon;&colon;is&lowbar;final` in the `bsl` namespace&period;
| xref:bsl/is_floating_point_v.adoc[`is&lowbar;floating&lowbar;point&lowbar;v`] 
| Variable template alias for `is&lowbar;floating&lowbar;point&lt;TYPE&gt;&colon;&colon;value`&period;
| xref:bsl/is_gt.adoc[`is&lowbar;gt`] 
| Alias for `std&colon;&colon;is&lowbar;gt` in the `bsl` namespace&period;
| xref:bsl/is_gteq.adoc[`is&lowbar;gteq`] 
| Alias for `std&colon;&colon;is&lowbar;gteq` in the `bsl` namespace&period;
| xref:bsl/is_heap.adoc[`is&lowbar;heap`] 
| Alias for `std&colon;&colon;is&lowbar;heap` in the `bsl` namespace&period;
| xref:bsl/is_heap_until.adoc[`is&lowbar;heap&lowbar;until`] 
| Alias for `std&colon;&colon;is&lowbar;heap&lowbar;until` in the `bsl` namespace&period;
| xref:bsl/is_integral_v.adoc[`is&lowbar;integral&lowbar;v`] 
| This template variable represents the result value of the `bsl&colon;&colon;is&lowbar;integral` meta&hyphen;function&period;
| xref:bsl/is_invocable.adoc[`is&lowbar;invocable`] 
| Alias for `std&colon;&colon;is&lowbar;invocable` in the `bsl` namespace&period;
| xref:bsl/is_invocable_r.adoc[`is&lowbar;invocable&lowbar;r`] 
| Alias for `std&colon;&colon;is&lowbar;invocable&lowbar;r` in the `bsl` namespace&period;
| xref:bsl/is_literal_type.adoc[`is&lowbar;literal&lowbar;type`] 
| Alias for `std&colon;&colon;is&lowbar;literal&lowbar;type` in the `bsl` namespace&period;
| xref:bsl/is_lt.adoc[`is&lowbar;lt`] 
| Alias for `std&colon;&colon;is&lowbar;lt` in the `bsl` namespace&period;
| xref:bsl/is_lteq.adoc[`is&lowbar;lteq`] 
| Alias for `std&colon;&colon;is&lowbar;lteq` in the `bsl` namespace&period;
| xref:bsl/is_lvalue_reference_v.adoc[`is&lowbar;lvalue&lowbar;reference&lowbar;v`] 
| This template variable represents the result value of the `bsl&colon;&colon;is&lowbar;lvalue&lowbar;reference` meta&hyphen;function&period;
| xref:bsl/is_move_assignable.adoc[`is&lowbar;move&lowbar;assignable`] 
| Alias for `std&colon;&colon;is&lowbar;move&lowbar;assignable` in the `bsl` namespace&period;
| xref:bsl/is_move_constructible.adoc[`is&lowbar;move&lowbar;constructible`] 
| Alias for `std&colon;&colon;is&lowbar;move&lowbar;constructible` in the `bsl` namespace&period;
| xref:bsl/is_neq.adoc[`is&lowbar;neq`] 
| Alias for `std&colon;&colon;is&lowbar;neq` in the `bsl` namespace&period;
| xref:bsl/is_nothrow_assignable.adoc[`is&lowbar;nothrow&lowbar;assignable`] 
| Alias for `std&colon;&colon;is&lowbar;nothrow&lowbar;assignable` in the `bsl` namespace&period;
| xref:bsl/is_nothrow_constructible.adoc[`is&lowbar;nothrow&lowbar;constructible`] 
| Alias for `std&colon;&colon;is&lowbar;nothrow&lowbar;constructible` in the `bsl` namespace&period;
| xref:bsl/is_nothrow_convertible.adoc[`is&lowbar;nothrow&lowbar;convertible`] 
| Alias for `std&colon;&colon;is&lowbar;nothrow&lowbar;convertible` in the `bsl` namespace&period;
| xref:bsl/is_nothrow_convertible_v.adoc[`is&lowbar;nothrow&lowbar;convertible&lowbar;v`] 
| Alias for `std&colon;&colon;is&lowbar;nothrow&lowbar;convertible&lowbar;v` in the `bsl` namespace&period;
| xref:bsl/is_nothrow_copy_assignable.adoc[`is&lowbar;nothrow&lowbar;copy&lowbar;assignable`] 
| Alias for `std&colon;&colon;is&lowbar;nothrow&lowbar;copy&lowbar;assignable` in the `bsl` namespace&period;
| xref:bsl/is_nothrow_copy_constructible.adoc[`is&lowbar;nothrow&lowbar;copy&lowbar;constructible`] 
| Alias for `std&colon;&colon;is&lowbar;nothrow&lowbar;copy&lowbar;constructible` in the `bsl` namespace&period;
| xref:bsl/is_nothrow_default_constructible.adoc[`is&lowbar;nothrow&lowbar;default&lowbar;constructible`] 
| Alias for `std&colon;&colon;is&lowbar;nothrow&lowbar;default&lowbar;constructible` in the `bsl` namespace&period;
| xref:bsl/is_nothrow_destructible.adoc[`is&lowbar;nothrow&lowbar;destructible`] 
| Alias for `std&colon;&colon;is&lowbar;nothrow&lowbar;destructible` in the `bsl` namespace&period;
| xref:bsl/is_nothrow_invocable.adoc[`is&lowbar;nothrow&lowbar;invocable`] 
| Alias for `std&colon;&colon;is&lowbar;nothrow&lowbar;invocable` in the `bsl` namespace&period;
| xref:bsl/is_nothrow_invocable_r.adoc[`is&lowbar;nothrow&lowbar;invocable&lowbar;r`] 
| Alias for `std&colon;&colon;is&lowbar;nothrow&lowbar;invocable&lowbar;r` in the `bsl` namespace&period;
| xref:bsl/is_nothrow_move_assignable.adoc[`is&lowbar;nothrow&lowbar;move&lowbar;assignable`] 
| Alias for `std&colon;&colon;is&lowbar;nothrow&lowbar;move&lowbar;assignable` in the `bsl` namespace&period;
| xref:bsl/is_nothrow_swappable.adoc[`is&lowbar;nothrow&lowbar;swappable`] 
| This `struct` template implements the `is&lowbar;nothrow&lowbar;swappable` meta&hyphen;function defined in the C&plus;&plus;17 standard&period;
| xref:bsl/is_nothrow_swappable_v.adoc[`is&lowbar;nothrow&lowbar;swappable&lowbar;v`] 
| This template variable represents the result value of the `bsl&colon;&colon;is&lowbar;nothrow&lowbar;swappable` meta&hyphen;function&period;
| xref:bsl/is_nothrow_swappable_with.adoc[`is&lowbar;nothrow&lowbar;swappable&lowbar;with`] 
| Alias for `std&colon;&colon;is&lowbar;nothrow&lowbar;swappable&lowbar;with` in the `bsl` namespace&period;
| xref:bsl/is_null_pointer.adoc[`is&lowbar;null&lowbar;pointer`] 
| Alias for `std&colon;&colon;is&lowbar;null&lowbar;pointer` in the `bsl` namespace&period;
| xref:bsl/is_object.adoc[`is&lowbar;object`] 
| Alias for `std&colon;&colon;is&lowbar;object` in the `bsl` namespace&period;
| xref:bsl/is_partitioned.adoc[`is&lowbar;partitioned`] 
| Alias for `std&colon;&colon;is&lowbar;partitioned` in the `bsl` namespace&period;
| xref:bsl/is_permutation.adoc[`is&lowbar;permutation`] 
| Alias for `std&colon;&colon;is&lowbar;permutation` in the `bsl` namespace&period;
| xref:bsl/is_placeholder.adoc[`is&lowbar;placeholder`] 
| Alias for `std&colon;&colon;is&lowbar;placeholder` in the `bsl` namespace&period;
| xref:bsl/is_placeholder_v.adoc[`is&lowbar;placeholder&lowbar;v`] 
| Alias for `std&colon;&colon;is&lowbar;placeholder&lowbar;v` in the `bsl` namespace&period;
| xref:bsl/is_pod.adoc[`is&lowbar;pod`] 
| Alias for `std&colon;&colon;is&lowbar;pod` in the `bsl` namespace&period;
| xref:bsl/is_scalar.adoc[`is&lowbar;scalar`] 
| Alias for `std&colon;&colon;is&lowbar;scalar` in the `bsl` namespace&period;
| xref:bsl/is_scoped_enum.adoc[`is&lowbar;scoped&lowbar;enum`] 
| Alias for `std&colon;&colon;is&lowbar;scoped&lowbar;enum` in the `bsl` namespace&period;
| xref:bsl/is_scoped_enum_v.adoc[`is&lowbar;scoped&lowbar;enum&lowbar;v`] 
| Alias for `std&colon;&colon;is&lowbar;scoped&lowbar;enum&lowbar;v` in the `bsl` namespace&period;
| xref:bsl/is_signed.adoc[`is&lowbar;signed`] 
| Alias for `std&colon;&colon;is&lowbar;signed` in the `bsl` namespace&period;
| xref:bsl/is_sorted.adoc[`is&lowbar;sorted`] 
| Alias for `std&colon;&colon;is&lowbar;sorted` in the `bsl` namespace&period;
| xref:bsl/is_sorted_until.adoc[`is&lowbar;sorted&lowbar;until`] 
| Alias for `std&colon;&colon;is&lowbar;sorted&lowbar;until` in the `bsl` namespace&period;
| xref:bsl/is_standard_layout.adoc[`is&lowbar;standard&lowbar;layout`] 
| Alias for `std&colon;&colon;is&lowbar;standard&lowbar;layout` in the `bsl` namespace&period;
| xref:bsl/is_swappable.adoc[`is&lowbar;swappable`] 
| Alias for `std&colon;&colon;is&lowbar;swappable` in the `bsl` namespace&period;
| xref:bsl/is_swappable_v.adoc[`is&lowbar;swappable&lowbar;v`] 
| This template variable represents the result value of the `bsl&colon;&colon;is&lowbar;swappable` meta&hyphen;function&period;
| xref:bsl/is_swappable_with.adoc[`is&lowbar;swappable&lowbar;with`] 
| Alias for `std&colon;&colon;is&lowbar;swappable&lowbar;with` in the `bsl` namespace&period;
| xref:bsl/is_trivial.adoc[`is&lowbar;trivial`] 
| Alias for `std&colon;&colon;is&lowbar;trivial` in the `bsl` namespace&period;
| xref:bsl/is_trivially_assignable.adoc[`is&lowbar;trivially&lowbar;assignable`] 
| Alias for `std&colon;&colon;is&lowbar;trivially&lowbar;assignable` in the `bsl` namespace&period;
| xref:bsl/is_trivially_constructible.adoc[`is&lowbar;trivially&lowbar;constructible`] 
| Alias for `std&colon;&colon;is&lowbar;trivially&lowbar;constructible` in the `bsl` namespace&period;
| xref:bsl/is_trivially_copy_assignable.adoc[`is&lowbar;trivially&lowbar;copy&lowbar;assignable`] 
| Alias for `std&colon;&colon;is&lowbar;trivially&lowbar;copy&lowbar;assignable` in the `bsl` namespace&period;
| xref:bsl/is_trivially_copy_constructible.adoc[`is&lowbar;trivially&lowbar;copy&lowbar;constructible`] 
| Alias for `std&colon;&colon;is&lowbar;trivially&lowbar;copy&lowbar;constructible` in the `bsl` namespace&period;
| xref:bsl/is_trivially_destructible.adoc[`is&lowbar;trivially&lowbar;destructible`] 
| Alias for `std&colon;&colon;is&lowbar;trivially&lowbar;destructible` in the `bsl` namespace&period;
| xref:bsl/is_trivially_move_assignable.adoc[`is&lowbar;trivially&lowbar;move&lowbar;assignable`] 
| Alias for `std&colon;&colon;is&lowbar;trivially&lowbar;move&lowbar;assignable` in the `bsl` namespace&period;
| xref:bsl/is_trivially_move_constructible.adoc[`is&lowbar;trivially&lowbar;move&lowbar;constructible`] 
| Alias for `std&colon;&colon;is&lowbar;trivially&lowbar;move&lowbar;constructible` in the `bsl` namespace&period;
| xref:bsl/is_union.adoc[`is&lowbar;union`] 
| Alias for `std&colon;&colon;is&lowbar;union` in the `bsl` namespace&period;
| xref:bsl/is_unsigned.adoc[`is&lowbar;unsigned`] 
| Alias for `std&colon;&colon;is&lowbar;unsigned` in the `bsl` namespace&period;
| xref:bsl/isalnum-02.adoc[`isalnum`] 
| Alias for `std&colon;&colon;isalnum` in the `bsl` namespace&period;
| xref:bsl/isalnum-01.adoc[`isalnum`] 
| Alias for `std&colon;&colon;isalnum` in the `bsl` namespace&period;
| xref:bsl/isalpha-01.adoc[`isalpha`] 
| Alias for `std&colon;&colon;isalpha` in the `bsl` namespace&period;
| xref:bsl/isalpha-08.adoc[`isalpha`] 
| Alias for `std&colon;&colon;isalpha` in the `bsl` namespace&period;
| xref:bsl/isblank-03.adoc[`isblank`] 
| Alias for `std&colon;&colon;isblank` in the `bsl` namespace&period;
| xref:bsl/isblank-06.adoc[`isblank`] 
| Alias for `std&colon;&colon;isblank` in the `bsl` namespace&period;
| xref:bsl/iscntrl-08.adoc[`iscntrl`] 
| Alias for `std&colon;&colon;iscntrl` in the `bsl` namespace&period;
| xref:bsl/iscntrl-03.adoc[`iscntrl`] 
| Alias for `std&colon;&colon;iscntrl` in the `bsl` namespace&period;
| xref:bsl/isdigit-08.adoc[`isdigit`] 
| Alias for `std&colon;&colon;isdigit` in the `bsl` namespace&period;
| xref:bsl/isdigit-06.adoc[`isdigit`] 
| Alias for `std&colon;&colon;isdigit` in the `bsl` namespace&period;
| xref:bsl/isfinite.adoc[`isfinite`] 
| Alias for `std&colon;&colon;isfinite` in the `bsl` namespace&period;
| xref:bsl/isgraph-04.adoc[`isgraph`] 
| Alias for `std&colon;&colon;isgraph` in the `bsl` namespace&period;
| xref:bsl/isgraph-0c.adoc[`isgraph`] 
| Alias for `std&colon;&colon;isgraph` in the `bsl` namespace&period;
| xref:bsl/isgreater.adoc[`isgreater`] 
| Import `std&colon;&colon;isgreater` into the `bsl` namespace&period;
| xref:bsl/isgreaterequal.adoc[`isgreaterequal`] 
| Alias for `std&colon;&colon;isgreaterequal` in the `bsl` namespace&period;
| xref:bsl/isinf.adoc[`isinf`] 
| Alias for `std&colon;&colon;isinf` in the `bsl` namespace&period;
| xref:bsl/isless.adoc[`isless`] 
| Alias for `std&colon;&colon;isless` in the `bsl` namespace&period;
| xref:bsl/islessequal.adoc[`islessequal`] 
| Alias for `std&colon;&colon;islessequal` in the `bsl` namespace&period;
| xref:bsl/islessgreater.adoc[`islessgreater`] 
| Alias for `std&colon;&colon;islessgreater` in the `bsl` namespace&period;
| xref:bsl/islower-07.adoc[`islower`] 
| Alias for `std&colon;&colon;islower` in the `bsl` namespace&period;
| xref:bsl/islower-0c.adoc[`islower`] 
| Alias for `std&colon;&colon;islower` in the `bsl` namespace&period;
| xref:bsl/isnan.adoc[`isnan`] 
| Alias for `std&colon;&colon;isnan` in the `bsl` namespace&period;
| xref:bsl/isnormal.adoc[`isnormal`] 
| Alias for `std&colon;&colon;isnormal` in the `bsl` namespace&period;
| xref:bsl/ispanstream.adoc[`ispanstream`] 
| Alias for `std&colon;&colon;ispanstream` in the `bsl` namespace&period;
| xref:bsl/isprint-01.adoc[`isprint`] 
| Alias for `std&colon;&colon;isprint` in the `bsl` namespace&period;
| xref:bsl/isprint-0e.adoc[`isprint`] 
| Alias for `std&colon;&colon;isprint` in the `bsl` namespace&period;
| xref:bsl/ispunct-01.adoc[`ispunct`] 
| Alias for `std&colon;&colon;ispunct` in the `bsl` namespace&period;
| xref:bsl/ispunct-0b.adoc[`ispunct`] 
| Alias for `std&colon;&colon;ispunct` in the `bsl` namespace&period;
| xref:bsl/isspace-0d.adoc[`isspace`] 
| Alias for `std&colon;&colon;isspace` in the `bsl` namespace&period;
| xref:bsl/isspace-01.adoc[`isspace`] 
| Alias for `std&colon;&colon;isspace` in the `bsl` namespace&period;
| xref:bsl/istream.adoc[`istream`] 
| Alias for `std&colon;&colon;istream` in the `bsl` namespace&period;
| xref:bsl/istream_iterator.adoc[`istream&lowbar;iterator`] 
| Alias for `std&colon;&colon;istream&lowbar;iterator` in the `bsl` namespace&period;
| xref:bsl/istreambuf_iterator.adoc[`istreambuf&lowbar;iterator`] 
| Alias for `std&colon;&colon;istreambuf&lowbar;iterator` in the `bsl` namespace&period;
| xref:bsl/istrstream.adoc[`istrstream`] 
| Alias for `std&colon;&colon;istrstream` in the `bsl` namespace&period;
| xref:bsl/isunordered.adoc[`isunordered`] 
| Alias for `std&colon;&colon;isunordered` in the `bsl` namespace&period;
| xref:bsl/isupper-07.adoc[`isupper`] 
| Alias for `std&colon;&colon;isupper` in the `bsl` namespace&period;
| xref:bsl/isupper-0d.adoc[`isupper`] 
| Alias for `std&colon;&colon;isupper` in the `bsl` namespace&period;
| xref:bsl/iswalnum.adoc[`iswalnum`] 
| Alias for `std&colon;&colon;iswalnum` in the `bsl` namespace&period;
| xref:bsl/iswalpha.adoc[`iswalpha`] 
| Alias for `std&colon;&colon;iswalpha` in the `bsl` namespace&period;
| xref:bsl/iswblank.adoc[`iswblank`] 
| Alias for `std&colon;&colon;iswblank` in the `bsl` namespace&period;
| xref:bsl/iswcntrl.adoc[`iswcntrl`] 
| Alias for `std&colon;&colon;iswcntrl` in the `bsl` namespace&period;
| xref:bsl/iswctype.adoc[`iswctype`] 
| Alias for `std&colon;&colon;iswctype` in the `bsl` namespace&period;
| xref:bsl/iswdigit.adoc[`iswdigit`] 
| Alias for `std&colon;&colon;iswdigit` in the `bsl` namespace&period;
| xref:bsl/iswgraph.adoc[`iswgraph`] 
| Alias for `std&colon;&colon;iswgraph` in the `bsl` namespace&period;
| xref:bsl/iswlower.adoc[`iswlower`] 
| Alias for `std&colon;&colon;iswlower` in the `bsl` namespace&period;
| xref:bsl/iswprint.adoc[`iswprint`] 
| Alias for `std&colon;&colon;iswprint` in the `bsl` namespace&period;
| xref:bsl/iswpunct.adoc[`iswpunct`] 
| Alias for `std&colon;&colon;iswpunct` in the `bsl` namespace&period;
| xref:bsl/iswspace.adoc[`iswspace`] 
| Alias for `std&colon;&colon;iswspace` in the `bsl` namespace&period;
| xref:bsl/iswupper.adoc[`iswupper`] 
| Alias for `std&colon;&colon;iswupper` in the `bsl` namespace&period;
| xref:bsl/iswxdigit.adoc[`iswxdigit`] 
| Alias for `std&colon;&colon;iswxdigit` in the `bsl` namespace&period;
| xref:bsl/isxdigit-04.adoc[`isxdigit`] 
| Alias for `std&colon;&colon;isxdigit` in the `bsl` namespace&period;
| xref:bsl/isxdigit-05.adoc[`isxdigit`] 
| Alias for `std&colon;&colon;isxdigit` in the `bsl` namespace&period;
| xref:bsl/iter_common_reference_t.adoc[`iter&lowbar;common&lowbar;reference&lowbar;t`] 
| Alias for `std&colon;&colon;iter&lowbar;common&lowbar;reference&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/iter_const_reference_t.adoc[`iter&lowbar;const&lowbar;reference&lowbar;t`] 
| Alias for `std&colon;&colon;iter&lowbar;const&lowbar;reference&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/iter_difference_t.adoc[`iter&lowbar;difference&lowbar;t`] 
| Alias for `std&colon;&colon;iter&lowbar;difference&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/iter_reference_t.adoc[`iter&lowbar;reference&lowbar;t`] 
| Alias for `std&colon;&colon;iter&lowbar;reference&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/iter_rvalue_reference_t.adoc[`iter&lowbar;rvalue&lowbar;reference&lowbar;t`] 
| Alias for `std&colon;&colon;iter&lowbar;rvalue&lowbar;reference&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/iter_swap.adoc[`iter&lowbar;swap`] 
| Alias for `std&colon;&colon;iter&lowbar;swap` in the `bsl` namespace&period;
| xref:bsl/iter_value_t.adoc[`iter&lowbar;value&lowbar;t`] 
| Alias for `std&colon;&colon;iter&lowbar;value&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/iterator.adoc[`iterator`] 
| Alias for `std&colon;&colon;iterator` in the `bsl` namespace&period;
| xref:bsl/iterator_traits.adoc[`iterator&lowbar;traits`] 
| Alias for `std&colon;&colon;iterator&lowbar;traits` in the `bsl` namespace&period;
| xref:bsl/jmp_buf.adoc[`jmp&lowbar;buf`] 
| Alias for `std&colon;&colon;jmp&lowbar;buf` in the `bsl` namespace&period;
| xref:bsl/jthread.adoc[`jthread`] 
| Alias for `std&colon;&colon;jthread` in the `bsl` namespace&period;
| xref:bsl/kill_dependency.adoc[`kill&lowbar;dependency`] 
| Alias for `std&colon;&colon;kill&lowbar;dependency` in the `bsl` namespace&period;
| xref:bsl/kilo.adoc[`kilo`] 
| Alias for `std&colon;&colon;kilo`&period;
| xref:bsl/knuth_b.adoc[`knuth&lowbar;b`] 
| Alias for `std&colon;&colon;knuth&lowbar;b` in the `bsl` namespace&period;
| xref:bsl/labs.adoc[`labs`] 
| Import `std&colon;&colon;labs` into the `bsl` namespace&period;
| xref:bsl/laguerre.adoc[`laguerre`] 
| 
| xref:bsl/laguerref.adoc[`laguerref`] 
| 
| xref:bsl/laguerrel.adoc[`laguerrel`] 
| 
| xref:bsl/latch.adoc[`latch`] 
| Alias for `std&colon;&colon;latch` in the `bsl` namespace&period;
| xref:bsl/launch.adoc[`launch`] 
| Alias for `std&colon;&colon;launch` in the `bsl` namespace&period;
| xref:bsl/launder.adoc[`launder`] 
| Alias for `std&colon;&colon;launder` in the `bsl` namespace&period;
| xref:bsl/lcm.adoc[`lcm`] 
| Alias for `std&colon;&colon;lcm` in the `bsl` namespace&period;
| xref:bsl/lconv.adoc[`lconv`] 
| Alias for `std&colon;&colon;lconv` in the `bsl` namespace&period;
| xref:bsl/ldexp.adoc[`ldexp`] 
| Alias for `std&colon;&colon;ldexp` in the `bsl` namespace&period;
| xref:bsl/ldiv.adoc[`ldiv`] 
| Alias for `std&colon;&colon;ldiv` in the `bsl` namespace&period;
| xref:bsl/ldiv_t.adoc[`ldiv&lowbar;t`] 
| Alias for `std&colon;&colon;ldiv&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/left.adoc[`left`] 
| Alias for `std&colon;&colon;left` in the `bsl` namespace&period;
| xref:bsl/legendre.adoc[`legendre`] 
| 
| xref:bsl/legendref.adoc[`legendref`] 
| 
| xref:bsl/legendrel.adoc[`legendrel`] 
| 
| xref:bsl/length_error.adoc[`length&lowbar;error`] 
| Alias for `std&colon;&colon;length&lowbar;error` in the `bsl` namespace&period;
| xref:bsl/lerp.adoc[`lerp`] 
| Alias for `std&colon;&colon;lerp` in the `bsl` namespace&period;
| xref:bsl/less.adoc[`less`] 
| Alias for `std&colon;&colon;less` in the `bsl` namespace&period;
| xref:bsl/less_equal.adoc[`less&lowbar;equal`] 
| Alias for `std&colon;&colon;less&lowbar;equal` in the `bsl` namespace&period;
| xref:bsl/lexicographical_compare.adoc[`lexicographical&lowbar;compare`] 
| Alias for `std&colon;&colon;lexicographical&lowbar;compare` in the `bsl` namespace&period;
| xref:bsl/lexicographical_compare_three_way.adoc[`lexicographical&lowbar;compare&lowbar;three&lowbar;way`] 
| Alias for `std&colon;&colon;lexicographical&lowbar;compare&lowbar;three&lowbar;way` in the `bsl` namespace&period;
| xref:bsl/lgamma.adoc[`lgamma`] 
| Alias for `std&colon;&colon;lgamma` in the `bsl` namespace&period;
| xref:bsl/linear_congruential_engine.adoc[`linear&lowbar;congruential&lowbar;engine`] 
| Alias for `std&colon;&colon;linear&lowbar;congruential&lowbar;engine` in the `bsl` namespace&period;
| xref:bsl/llabs.adoc[`llabs`] 
| Import `std&colon;&colon;llabs` into the `bsl` namespace&period;
| xref:bsl/lldiv.adoc[`lldiv`] 
| Alias for `std&colon;&colon;lldiv` in the `bsl` namespace&period;
| xref:bsl/lldiv_t.adoc[`lldiv&lowbar;t`] 
| Alias for `std&colon;&colon;lldiv&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/llrint.adoc[`llrint`] 
| Alias for `std&colon;&colon;llrint` in the `bsl` namespace&period;
| xref:bsl/llround.adoc[`llround`] 
| Alias for `std&colon;&colon;llround` in the `bsl` namespace&period;
| xref:bsl/locale.adoc[`locale`] 
| Alias for `std&colon;&colon;locale` in the `bsl` namespace&period;
| xref:bsl/localeconv.adoc[`localeconv`] 
| Alias for `std&colon;&colon;localeconv` in the `bsl` namespace&period;
| xref:bsl/localtime.adoc[`localtime`] 
| Alias for `std&colon;&colon;localtime` in the `bsl` namespace&period;
| xref:bsl/lock.adoc[`lock`] 
| Alias for `std&colon;&colon;lock` in the `bsl` namespace&period;
| xref:bsl/lock_guard.adoc[`lock&lowbar;guard`] 
| Alias for `std&colon;&colon;lock&lowbar;guard` in the `bsl` namespace&period;
| xref:bsl/log-0b.adoc[`log`] 
| Alias for `std&colon;&colon;log` in the `bsl` namespace&period;
| xref:bsl/log-0f.adoc[`log`] 
| Alias for `std&colon;&colon;log` in the `bsl` namespace&period;
| xref:bsl/log-06.adoc[`log`] 
| Alias for `std&colon;&colon;log` in the `bsl` namespace&period;
| xref:bsl/log10-01.adoc[`log10`] 
| Alias for `std&colon;&colon;log10` in the `bsl` namespace&period;
| xref:bsl/log10-0e.adoc[`log10`] 
| Alias for `std&colon;&colon;log10` in the `bsl` namespace&period;
| xref:bsl/log10-09.adoc[`log10`] 
| Alias for `std&colon;&colon;log10` in the `bsl` namespace&period;
| xref:bsl/log1p.adoc[`log1p`] 
| Alias for `std&colon;&colon;log1p` in the `bsl` namespace&period;
| xref:bsl/log2.adoc[`log2`] 
| Alias for `std&colon;&colon;log2` in the `bsl` namespace&period;
| xref:bsl/logb.adoc[`logb`] 
| Import `std&colon;&colon;logb` into the `bsl` namespace&period;
| xref:bsl/logic_error.adoc[`logic&lowbar;error`] 
| Alias for `std&colon;&colon;logic&lowbar;error` in the `bsl` namespace&period;
| xref:bsl/logical_and.adoc[`logical&lowbar;and`] 
| Alias for `std&colon;&colon;logical&lowbar;and` in the `bsl` namespace&period;
| xref:bsl/logical_not.adoc[`logical&lowbar;not`] 
| Alias for `std&colon;&colon;logical&lowbar;not` in the `bsl` namespace&period;
| xref:bsl/logical_or.adoc[`logical&lowbar;or`] 
| Alias for `std&colon;&colon;logical&lowbar;or` in the `bsl` namespace&period;
| xref:bsl/lognormal_distribution.adoc[`lognormal&lowbar;distribution`] 
| Alias for `std&colon;&colon;lognormal&lowbar;distribution` in the `bsl` namespace&period;
| xref:bsl/longjmp.adoc[`longjmp`] 
| Alias for `std&colon;&colon;longjmp` in the `bsl` namespace&period;
| xref:bsl/lower_bound.adoc[`lower&lowbar;bound`] 
| Alias for `std&colon;&colon;lower&lowbar;bound` in the `bsl` namespace&period;
| xref:bsl/lrint.adoc[`lrint`] 
| Alias for `std&colon;&colon;lrint` in the `bsl` namespace&period;
| xref:bsl/lround.adoc[`lround`] 
| Alias for `std&colon;&colon;lround` in the `bsl` namespace&period;
| xref:bsl/make_const_iterator.adoc[`make&lowbar;const&lowbar;iterator`] 
| Alias for `std&colon;&colon;make&lowbar;const&lowbar;iterator` in the `bsl` namespace&period;
| xref:bsl/make_const_sentinel.adoc[`make&lowbar;const&lowbar;sentinel`] 
| Alias for `std&colon;&colon;make&lowbar;const&lowbar;sentinel` in the `bsl` namespace&period;
| xref:bsl/make_error_code.adoc[`make&lowbar;error&lowbar;code`] 
| Alias for `std&colon;&colon;make&lowbar;error&lowbar;code` in the `bsl` namespace&period;
| xref:bsl/make_error_condition.adoc[`make&lowbar;error&lowbar;condition`] 
| Alias for `std&colon;&colon;make&lowbar;error&lowbar;condition` in the `bsl` namespace&period;
| xref:bsl/make_exception_ptr.adoc[`make&lowbar;exception&lowbar;ptr`] 
| Undocumented symbol&period;
| xref:bsl/make_from_tuple.adoc[`make&lowbar;from&lowbar;tuple`] 
| Alias for `std&colon;&colon;make&lowbar;from&lowbar;tuple` in the `bsl` namespace&period;
| xref:bsl/make_heap.adoc[`make&lowbar;heap`] 
| Alias for `std&colon;&colon;make&lowbar;heap` in the `bsl` namespace&period;
| xref:bsl/make_index_sequence.adoc[`make&lowbar;index&lowbar;sequence`] 
| Alias for `std&colon;&colon;make&lowbar;index&lowbar;sequence` in the `bsl` namespace&period;
| xref:bsl/make_integer_sequence.adoc[`make&lowbar;integer&lowbar;sequence`] 
| Alias for `std&colon;&colon;make&lowbar;integer&lowbar;sequence` in the `bsl` namespace&period;
| xref:bsl/make_move_iterator.adoc[`make&lowbar;move&lowbar;iterator`] 
| Alias for `std&colon;&colon;make&lowbar;move&lowbar;iterator` in the `bsl` namespace&period;
| xref:bsl/make_pair.adoc[`make&lowbar;pair`] 
| Alias for `std&colon;&colon;make&lowbar;pair` in the `bsl` namespace&period;
| xref:bsl/make_reverse_iterator.adoc[`make&lowbar;reverse&lowbar;iterator`] 
| Alias for `std&colon;&colon;make&lowbar;reverse&lowbar;iterator` in the `bsl` namespace&period;
| xref:bsl/make_signed.adoc[`make&lowbar;signed`] 
| Alias for `std&colon;&colon;make&lowbar;signed` in the `bsl` namespace&period;
| xref:bsl/make_tuple.adoc[`make&lowbar;tuple`] 
| Alias for `std&colon;&colon;make&lowbar;tuple` in the `bsl` namespace&period;
| xref:bsl/make_unique.adoc[`make&lowbar;unique`] 
| Alias for `std&colon;&colon;make&lowbar;unique` in the `bsl` namespace&period;
| xref:bsl/make_unique_for_overwrite.adoc[`make&lowbar;unique&lowbar;for&lowbar;overwrite`] 
| Alias for `std&colon;&colon;make&lowbar;unique&lowbar;for&lowbar;overwrite` in the `bsl` namespace&period;
| xref:bsl/make_unsigned.adoc[`make&lowbar;unsigned`] 
| Alias for `std&colon;&colon;make&lowbar;unsigned` in the `bsl` namespace&period;
| xref:bsl/malloc.adoc[`malloc`] 
| Alias for `std&colon;&colon;malloc` in the `bsl` namespace&period;
| xref:bsl/mask_array.adoc[`mask&lowbar;array`] 
| Alias for `std&colon;&colon;mask&lowbar;array` in the `bsl` namespace&period;
| xref:bsl/match_results.adoc[`match&lowbar;results`] 
| Alias for `std&colon;&colon;match&lowbar;results` in the `bsl` namespace&period;
| xref:bsl/max.adoc[`max`] 
| Alias for `std&colon;&colon;max` in the `bsl` namespace&period;
| xref:bsl/max_align_t.adoc[`max&lowbar;align&lowbar;t`] 
| Alias for `std&colon;&colon;max&lowbar;align&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/max_element.adoc[`max&lowbar;element`] 
| Alias for `std&colon;&colon;max&lowbar;element` in the `bsl` namespace&period;
| xref:bsl/mblen.adoc[`mblen`] 
| Alias for `std&colon;&colon;mblen` in the `bsl` namespace&period;
| xref:bsl/mbrlen.adoc[`mbrlen`] 
| Alias for `std&colon;&colon;mbrlen` in the `bsl` namespace&period;
| xref:bsl/mbrtoc16.adoc[`mbrtoc16`] 
| Alias for `std&colon;&colon;mbrtoc16` in the `bsl` namespace&period;
| xref:bsl/mbrtoc32.adoc[`mbrtoc32`] 
| Alias for `std&colon;&colon;mbrtoc32` in the `bsl` namespace&period;
| xref:bsl/mbrtowc.adoc[`mbrtowc`] 
| Alias for `std&colon;&colon;mbrtowc` in the `bsl` namespace&period;
| xref:bsl/mbsinit.adoc[`mbsinit`] 
| Alias for `std&colon;&colon;mbsinit` in the `bsl` namespace&period;
| xref:bsl/mbsrtowcs.adoc[`mbsrtowcs`] 
| Alias for `std&colon;&colon;mbsrtowcs` in the `bsl` namespace&period;
| xref:bsl/mbstate_t.adoc[`mbstate&lowbar;t`] 
| Alias for `std&colon;&colon;mbstate&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/mbstowcs.adoc[`mbstowcs`] 
| Alias for `std&colon;&colon;mbstowcs` in the `bsl` namespace&period;
| xref:bsl/mbtowc.adoc[`mbtowc`] 
| Import `std&colon;&colon;mbtowc` into the `bsl` namespace&period;
| xref:bsl/mega.adoc[`mega`] 
| Alias for `std&colon;&colon;mega`&period;
| xref:bsl/mem_fn.adoc[`mem&lowbar;fn`] 
| Alias for `std&colon;&colon;mem&lowbar;fn` in the `bsl` namespace&period;
| xref:bsl/mem_fun.adoc[`mem&lowbar;fun`] 
| Alias for `std&colon;&colon;mem&lowbar;fun` in the `bsl` namespace&period;
| xref:bsl/mem_fun1_ref_t.adoc[`mem&lowbar;fun1&lowbar;ref&lowbar;t`] 
| Alias for `std&colon;&colon;mem&lowbar;fun1&lowbar;ref&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/mem_fun1_t.adoc[`mem&lowbar;fun1&lowbar;t`] 
| Alias for `std&colon;&colon;mem&lowbar;fun1&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/mem_fun_ref.adoc[`mem&lowbar;fun&lowbar;ref`] 
| Alias for `std&colon;&colon;mem&lowbar;fun&lowbar;ref` in the `bsl` namespace&period;
| xref:bsl/mem_fun_ref_t.adoc[`mem&lowbar;fun&lowbar;ref&lowbar;t`] 
| Alias for `std&colon;&colon;mem&lowbar;fun&lowbar;ref&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/mem_fun_t.adoc[`mem&lowbar;fun&lowbar;t`] 
| Alias for `std&colon;&colon;mem&lowbar;fun&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/memchr.adoc[`memchr`] 
| Alias for `std&colon;&colon;memchr` in the `bsl` namespace&period;
| xref:bsl/memcmp.adoc[`memcmp`] 
| Alias for `std&colon;&colon;memcmp` in the `bsl` namespace&period;
| xref:bsl/memcpy.adoc[`memcpy`] 
| Alias for `std&colon;&colon;memcpy` in the `bsl` namespace&period;
| xref:bsl/memmove.adoc[`memmove`] 
| Alias for `std&colon;&colon;memmove` in the `bsl` namespace&period;
| xref:bsl/memory_order.adoc[`memory&lowbar;order`] 
| Alias for `std&colon;&colon;memory&lowbar;order` in the `bsl` namespace&period;
| xref:bsl/memory_order_acq_rel.adoc[`memory&lowbar;order&lowbar;acq&lowbar;rel`] 
| Alias for `std&colon;&colon;memory&lowbar;order&lowbar;acq&lowbar;rel` in the `bsl` namespace&period;
| xref:bsl/memory_order_acquire.adoc[`memory&lowbar;order&lowbar;acquire`] 
| Alias for `std&colon;&colon;memory&lowbar;order&lowbar;acquire` in the `bsl` namespace&period;
| xref:bsl/memory_order_consume.adoc[`memory&lowbar;order&lowbar;consume`] 
| Alias for `std&colon;&colon;memory&lowbar;order&lowbar;consume` in the `bsl` namespace&period;
| xref:bsl/memory_order_relaxed.adoc[`memory&lowbar;order&lowbar;relaxed`] 
| Alias for `std&colon;&colon;memory&lowbar;order&lowbar;relaxed` in the `bsl` namespace&period;
| xref:bsl/memory_order_release.adoc[`memory&lowbar;order&lowbar;release`] 
| Alias for `std&colon;&colon;memory&lowbar;order&lowbar;release` in the `bsl` namespace&period;
| xref:bsl/memory_order_seq_cst.adoc[`memory&lowbar;order&lowbar;seq&lowbar;cst`] 
| Alias for `std&colon;&colon;memory&lowbar;order&lowbar;seq&lowbar;cst` in the `bsl` namespace&period;
| xref:bsl/memory_resource.adoc[`memory&lowbar;resource`] 
| Alias for `std&colon;&colon;pmr&colon;&colon;memory&lowbar;resource` in the `bsl` namespace&period;
| xref:bsl/memset.adoc[`memset`] 
| Alias for `std&colon;&colon;memset` in the `bsl` namespace&period;
| xref:bsl/merge.adoc[`merge`] 
| Alias for `std&colon;&colon;merge` in the `bsl` namespace&period;
| xref:bsl/mergeable.adoc[`mergeable`] 
| Alias for `std&colon;&colon;mergeable` in the `bsl` namespace&period;
| xref:bsl/mersenne_twister_engine.adoc[`mersenne&lowbar;twister&lowbar;engine`] 
| Alias for `std&colon;&colon;mersenne&lowbar;twister&lowbar;engine` in the `bsl` namespace&period;
| xref:bsl/messages.adoc[`messages`] 
| Alias for `std&colon;&colon;messages` in the `bsl` namespace&period;
| xref:bsl/messages_base.adoc[`messages&lowbar;base`] 
| Alias for `std&colon;&colon;messages&lowbar;base` in the `bsl` namespace&period;
| xref:bsl/messages_byname.adoc[`messages&lowbar;byname`] 
| Alias for `std&colon;&colon;messages&lowbar;byname` in the `bsl` namespace&period;
| xref:bsl/micro.adoc[`micro`] 
| Alias for `std&colon;&colon;micro`&period;
| xref:bsl/midpoint.adoc[`midpoint`] 
| Alias for `std&colon;&colon;midpoint` in the `bsl` namespace&period;
| xref:bsl/milli.adoc[`milli`] 
| Alias for `std&colon;&colon;milli`&period;
| xref:bsl/min.adoc[`min`] 
| Alias for `std&colon;&colon;min` in the `bsl` namespace&period;
| xref:bsl/min_element.adoc[`min&lowbar;element`] 
| Alias for `std&colon;&colon;min&lowbar;element` in the `bsl` namespace&period;
| xref:bsl/minmax.adoc[`minmax`] 
| Alias for `std&colon;&colon;minmax` in the `bsl` namespace&period;
| xref:bsl/minmax_element.adoc[`minmax&lowbar;element`] 
| Alias for `std&colon;&colon;minmax&lowbar;element` in the `bsl` namespace&period;
| xref:bsl/minstd_rand.adoc[`minstd&lowbar;rand`] 
| Alias for `std&colon;&colon;minstd&lowbar;rand` in the `bsl` namespace&period;
| xref:bsl/minstd_rand0.adoc[`minstd&lowbar;rand0`] 
| Alias for `std&colon;&colon;minstd&lowbar;rand0` in the `bsl` namespace&period;
| xref:bsl/minus.adoc[`minus`] 
| Alias for `std&colon;&colon;minus` in the `bsl` namespace&period;
| xref:bsl/mismatch.adoc[`mismatch`] 
| Alias for `std&colon;&colon;mismatch` in the `bsl` namespace&period;
| xref:bsl/mktime.adoc[`mktime`] 
| Alias for `std&colon;&colon;mktime` in the `bsl` namespace&period;
| xref:bsl/modf.adoc[`modf`] 
| Alias for `std&colon;&colon;modf` in the `bsl` namespace&period;
| xref:bsl/modulus.adoc[`modulus`] 
| Alias for `std&colon;&colon;modulus` in the `bsl` namespace&period;
| xref:bsl/money_base.adoc[`money&lowbar;base`] 
| Alias for `std&colon;&colon;money&lowbar;base` in the `bsl` namespace&period;
| xref:bsl/money_get.adoc[`money&lowbar;get`] 
| Alias for `std&colon;&colon;money&lowbar;get` in the `bsl` namespace&period;
| xref:bsl/money_put.adoc[`money&lowbar;put`] 
| Alias for `std&colon;&colon;money&lowbar;put` in the `bsl` namespace&period;
| xref:bsl/moneypunct.adoc[`moneypunct`] 
| Alias for `std&colon;&colon;moneypunct` in the `bsl` namespace&period;
| xref:bsl/moneypunct_byname.adoc[`moneypunct&lowbar;byname`] 
| Alias for `std&colon;&colon;moneypunct&lowbar;byname` in the `bsl` namespace&period;
| xref:bsl/monostate.adoc[`monostate`] 
| Alias for `std&colon;&colon;monostate` in the `bsl` namespace&period;
| xref:bsl/movable.adoc[`movable`] 
| Alias for `std&colon;&colon;movable` in the `bsl` namespace&period;
| xref:bsl/move-0f.adoc[`move`] 
| Alias for `std&colon;&colon;move` in the `bsl` namespace&period;
| xref:bsl/move-0e.adoc[`move`] 
| Alias for `std&colon;&colon;move` in the `bsl` namespace&period;
| xref:bsl/move_backward.adoc[`move&lowbar;backward`] 
| Alias for `std&colon;&colon;move&lowbar;backward` in the `bsl` namespace&period;
| xref:bsl/move_constructible.adoc[`move&lowbar;constructible`] 
| Alias for `std&colon;&colon;move&lowbar;constructible` in the `bsl` namespace&period;
| xref:bsl/move_if_noexcept.adoc[`move&lowbar;if&lowbar;noexcept`] 
| Alias for `std&colon;&colon;move&lowbar;if&lowbar;noexcept` in the `bsl` namespace&period;
| xref:bsl/move_iterator.adoc[`move&lowbar;iterator`] 
| Alias for `std&colon;&colon;move&lowbar;iterator` in the `bsl` namespace&period;
| xref:bsl/move_sentinel.adoc[`move&lowbar;sentinel`] 
| Standard library alias for `std&colon;&colon;move&lowbar;sentinel`&period;
| xref:bsl/mt19937.adoc[`mt19937`] 
| Alias for `std&colon;&colon;mt19937` in the `bsl` namespace&period;
| xref:bsl/mt19937_64.adoc[`mt19937&lowbar;64`] 
| Alias for `std&colon;&colon;mt19937&lowbar;64` in the `bsl` namespace&period;
| xref:bsl/multiplies.adoc[`multiplies`] 
| Alias for `std&colon;&colon;multiplies` in the `bsl` namespace&period;
| xref:bsl/mutex.adoc[`mutex`] 
| Alias for `std&colon;&colon;mutex` in the `bsl` namespace&period;
| xref:bsl/nan.adoc[`nan`] 
| Alias for `std&colon;&colon;nan` in the `bsl` namespace&period;
| xref:bsl/nanf.adoc[`nanf`] 
| Alias for `std&colon;&colon;nanf` in the `bsl` namespace&period;
| xref:bsl/nanl.adoc[`nanl`] 
| Alias for `std&colon;&colon;nanl` in the `bsl` namespace&period;
| xref:bsl/nano.adoc[`nano`] 
| Alias for `std&colon;&colon;nano`&period;
| xref:bsl/nearbyint.adoc[`nearbyint`] 
| Alias for `std&colon;&colon;nearbyint` in the `bsl` namespace&period;
| xref:bsl/negate.adoc[`negate`] 
| Alias for `std&colon;&colon;negate` in the `bsl` namespace&period;
| xref:bsl/negation.adoc[`negation`] 
| Alias for `std&colon;&colon;negation` in the `bsl` namespace&period;
| xref:bsl/negation_v.adoc[`negation&lowbar;v`] 
| Alias for `std&colon;&colon;negation&lowbar;v` in the `bsl` namespace&period;
| xref:bsl/negative_binomial_distribution.adoc[`negative&lowbar;binomial&lowbar;distribution`] 
| Alias for `std&colon;&colon;negative&lowbar;binomial&lowbar;distribution` in the `bsl` namespace&period;
| xref:bsl/nested_exception.adoc[`nested&lowbar;exception`] 
| Undocumented symbol&period;
| xref:bsl/new_handler.adoc[`new&lowbar;handler`] 
| Alias for `std&colon;&colon;new&lowbar;handler` in the `bsl` namespace&period;
| xref:bsl/next.adoc[`next`] 
| Alias for `std&colon;&colon;next` in the `bsl` namespace&period;
| xref:bsl/next_permutation.adoc[`next&lowbar;permutation`] 
| Alias for `std&colon;&colon;next&lowbar;permutation` in the `bsl` namespace&period;
| xref:bsl/nextafter.adoc[`nextafter`] 
| Alias for `std&colon;&colon;nextafter` in the `bsl` namespace&period;
| xref:bsl/nexttoward.adoc[`nexttoward`] 
| Alias for `std&colon;&colon;nexttoward` in the `bsl` namespace&period;
| xref:bsl/noboolalpha.adoc[`noboolalpha`] 
| Alias for `std&colon;&colon;noboolalpha` in the `bsl` namespace&period;
| xref:bsl/none_of.adoc[`none&lowbar;of`] 
| Alias for `std&colon;&colon;none&lowbar;of` in the `bsl` namespace&period;
| xref:bsl/noop_coroutine.adoc[`noop&lowbar;coroutine`] 
| Alias for `std&colon;&colon;noop&lowbar;coroutine` in the `bsl` namespace&period;
| xref:bsl/noop_coroutine_handle.adoc[`noop&lowbar;coroutine&lowbar;handle`] 
| Alias for `std&colon;&colon;noop&lowbar;coroutine&lowbar;handle` in the `bsl` namespace&period;
| xref:bsl/noop_coroutine_promise.adoc[`noop&lowbar;coroutine&lowbar;promise`] 
| Alias for `std&colon;&colon;noop&lowbar;coroutine&lowbar;promise` in the `bsl` namespace&period;
| xref:bsl/norm.adoc[`norm`] 
| Alias for `std&colon;&colon;norm` in the `bsl` namespace&period;
| xref:bsl/normal_distribution.adoc[`normal&lowbar;distribution`] 
| Alias for `std&colon;&colon;normal&lowbar;distribution` in the `bsl` namespace&period;
| xref:bsl/noshowbase.adoc[`noshowbase`] 
| Alias for `std&colon;&colon;noshowbase` in the `bsl` namespace&period;
| xref:bsl/noshowpoint.adoc[`noshowpoint`] 
| Alias for `std&colon;&colon;noshowpoint` in the `bsl` namespace&period;
| xref:bsl/noshowpos.adoc[`noshowpos`] 
| Alias for `std&colon;&colon;noshowpos` in the `bsl` namespace&period;
| xref:bsl/noskipws.adoc[`noskipws`] 
| Alias for `std&colon;&colon;noskipws` in the `bsl` namespace&period;
| xref:bsl/not1.adoc[`not1`] 
| Alias for `std&colon;&colon;not1` in the `bsl` namespace&period;
| xref:bsl/not2.adoc[`not2`] 
| Alias for `std&colon;&colon;not2` in the `bsl` namespace&period;
| xref:bsl/not_equal_to.adoc[`not&lowbar;equal&lowbar;to`] 
| Alias for `std&colon;&colon;not&lowbar;equal&lowbar;to` in the `bsl` namespace&period;
| xref:bsl/not_fn.adoc[`not&lowbar;fn`] 
| Alias for `std&colon;&colon;not&lowbar;fn` in the `bsl` namespace&period;
| xref:bsl/nothrow.adoc[`nothrow`] 
| Alias for `std&colon;&colon;nothrow` in the `bsl` namespace&period;
| xref:bsl/nothrow_t.adoc[`nothrow&lowbar;t`] 
| Alias for `std&colon;&colon;nothrow&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/nounitbuf.adoc[`nounitbuf`] 
| Alias for `std&colon;&colon;nounitbuf` in the `bsl` namespace&period;
| xref:bsl/nouppercase.adoc[`nouppercase`] 
| Alias for `std&colon;&colon;nouppercase` in the `bsl` namespace&period;
| xref:bsl/nth_element.adoc[`nth&lowbar;element`] 
| Alias for `std&colon;&colon;nth&lowbar;element` in the `bsl` namespace&period;
| xref:bsl/nullopt.adoc[`nullopt`] 
| Constant used to construct disengaged `optional` objects&period;
| xref:bsl/nullptr_t-04.adoc[`nullptr&lowbar;t`] 
| Alias for `std&colon;&colon;nullptr&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/num_get.adoc[`num&lowbar;get`] 
| Alias for `std&colon;&colon;num&lowbar;get` in the `bsl` namespace&period;
| xref:bsl/num_put.adoc[`num&lowbar;put`] 
| Alias for `std&colon;&colon;num&lowbar;put` in the `bsl` namespace&period;
| xref:bsl/numeric_limits.adoc[`numeric&lowbar;limits`] 
| Alias for `std&colon;&colon;numeric&lowbar;limits` in the `bsl` namespace&period;
| xref:bsl/numpunct.adoc[`numpunct`] 
| Alias for `std&colon;&colon;numpunct` in the `bsl` namespace&period;
| xref:bsl/numpunct_byname.adoc[`numpunct&lowbar;byname`] 
| Import `std&colon;&colon;numpunct&lowbar;byname` into the `bsl` namespace&period;
| xref:bsl/oct.adoc[`oct`] 
| Alias for `std&colon;&colon;oct` in the `bsl` namespace&period;
| xref:bsl/ofstream.adoc[`ofstream`] 
| Alias for `std&colon;&colon;ofstream` in the `bsl` namespace&period;
| xref:bsl/once_flag.adoc[`once&lowbar;flag`] 
| Alias for `std&colon;&colon;once&lowbar;flag` in the `bsl` namespace&period;
| xref:bsl/operator!=-01.adoc[`operator!&equals;`] 
| Import `std&colon;&colon;operator!&equals;` for `basic&lowbar;string&lowbar;view` into the `bsl` namespace&period;
| xref:bsl/operator!=-097.adoc[`operator!&equals;`] 
| Import `std&colon;&colon;operator!&equals;` for `basic&lowbar;string&lowbar;view` into the `bsl` namespace&period;
| xref:bsl/operator!=-09a.adoc[`operator!&equals;`] 
| Import `std&colon;&colon;operator!&equals;` for `basic&lowbar;string&lowbar;view` into the `bsl` namespace&period;
| xref:bsl/operator!=-0c.adoc[`operator!&equals;`] 
| Import `std&colon;&colon;operator!&equals;` for `basic&lowbar;string&lowbar;view` into the `bsl` namespace&period;
| xref:bsl/operator!=-0d8.adoc[`operator!&equals;`] 
| Import `std&colon;&colon;operator!&equals;` for `basic&lowbar;string&lowbar;view` into the `bsl` namespace&period;
| xref:bsl/operator!=-0d9.adoc[`operator!&equals;`] 
| Import `std&colon;&colon;operator!&equals;` for `basic&lowbar;string&lowbar;view` into the `bsl` namespace&period;
| xref:bsl/operator<-03.adoc[`operator&lt;`] 
| Import `std&colon;&colon;operator&lt;` for `basic&lowbar;string&lowbar;view` into the `bsl` namespace&period;
| xref:bsl/operator<-07.adoc[`operator&lt;`] 
| Import `std&colon;&colon;operator&lt;` for `basic&lowbar;string&lowbar;view` into the `bsl` namespace&period;
| xref:bsl/operator<-09.adoc[`operator&lt;`] 
| Import `std&colon;&colon;operator&lt;` for `basic&lowbar;string&lowbar;view` into the `bsl` namespace&period;
| xref:bsl/operator<-0d.adoc[`operator&lt;`] 
| Import `std&colon;&colon;operator&lt;` for `basic&lowbar;string&lowbar;view` into the `bsl` namespace&period;
| xref:bsl/operator<=-04.adoc[`operator&lt;&equals;`] 
| Import `std&colon;&colon;operator&lt;&equals;` for `basic&lowbar;string&lowbar;view` into the `bsl` namespace&period;
| xref:bsl/operator<=-06.adoc[`operator&lt;&equals;`] 
| Import `std&colon;&colon;operator&lt;&equals;` for `basic&lowbar;string&lowbar;view` into the `bsl` namespace&period;
| xref:bsl/operator<=-08.adoc[`operator&lt;&equals;`] 
| Import `std&colon;&colon;operator&lt;&equals;` for `basic&lowbar;string&lowbar;view` into the `bsl` namespace&period;
| xref:bsl/operator<=-0a.adoc[`operator&lt;&equals;`] 
| Import `std&colon;&colon;operator&lt;&equals;` for `basic&lowbar;string&lowbar;view` into the `bsl` namespace&period;
| xref:bsl/operator==-01.adoc[`operator&equals;&equals;`] 
| Import `std&colon;&colon;operator&equals;&equals;` for `basic&lowbar;string&lowbar;view` into the `bsl` namespace&period;
| xref:bsl/operator==-02.adoc[`operator&equals;&equals;`] 
| Import `std&colon;&colon;operator&equals;&equals;` for `basic&lowbar;string&lowbar;view` into the `bsl` namespace&period;
| xref:bsl/operator==-058.adoc[`operator&equals;&equals;`] 
| Import `std&colon;&colon;operator&equals;&equals;` for `basic&lowbar;string&lowbar;view` into the `bsl` namespace&period;
| xref:bsl/operator==-05a.adoc[`operator&equals;&equals;`] 
| Import `std&colon;&colon;operator&equals;&equals;` for `basic&lowbar;string&lowbar;view` into the `bsl` namespace&period;
| xref:bsl/operator==-05b.adoc[`operator&equals;&equals;`] 
| Import `std&colon;&colon;operator&equals;&equals;` for `basic&lowbar;string&lowbar;view` into the `bsl` namespace&period;
| xref:bsl/operator==-05d.adoc[`operator&equals;&equals;`] 
| Import `std&colon;&colon;operator&equals;&equals;` for `basic&lowbar;string&lowbar;view` into the `bsl` namespace&period;
| xref:bsl/operator==-063.adoc[`operator&equals;&equals;`] 
| Import `std&colon;&colon;operator&equals;&equals;` for `basic&lowbar;string&lowbar;view` into the `bsl` namespace&period;
| xref:bsl/operator==-06b.adoc[`operator&equals;&equals;`] 
| Import `std&colon;&colon;operator&equals;&equals;` for `basic&lowbar;string&lowbar;view` into the `bsl` namespace&period;
| xref:bsl/operator==-077.adoc[`operator&equals;&equals;`] 
| Import `std&colon;&colon;operator&equals;&equals;` for `basic&lowbar;string&lowbar;view` into the `bsl` namespace&period;
| xref:bsl/operator==-079.adoc[`operator&equals;&equals;`] 
| Import `std&colon;&colon;operator&equals;&equals;` for `basic&lowbar;string&lowbar;view` into the `bsl` namespace&period;
| xref:bsl/operator==-088.adoc[`operator&equals;&equals;`] 
| Import `std&colon;&colon;operator&equals;&equals;` for `basic&lowbar;string&lowbar;view` into the `bsl` namespace&period;
| xref:bsl/operator==-08a.adoc[`operator&equals;&equals;`] 
| Import `std&colon;&colon;operator&equals;&equals;` for `basic&lowbar;string&lowbar;view` into the `bsl` namespace&period;
| xref:bsl/operator==-08f.adoc[`operator&equals;&equals;`] 
| Import `std&colon;&colon;operator&equals;&equals;` for `basic&lowbar;string&lowbar;view` into the `bsl` namespace&period;
| xref:bsl/operator==-09.adoc[`operator&equals;&equals;`] 
| Import `std&colon;&colon;operator&equals;&equals;` for `basic&lowbar;string&lowbar;view` into the `bsl` namespace&period;
| xref:bsl/operator==-0a1.adoc[`operator&equals;&equals;`] 
| Import `std&colon;&colon;operator&equals;&equals;` for `basic&lowbar;string&lowbar;view` into the `bsl` namespace&period;
| xref:bsl/operator==-0ae.adoc[`operator&equals;&equals;`] 
| Import `std&colon;&colon;operator&equals;&equals;` for `basic&lowbar;string&lowbar;view` into the `bsl` namespace&period;
| xref:bsl/operator==-0c.adoc[`operator&equals;&equals;`] 
| Import `std&colon;&colon;operator&equals;&equals;` for `basic&lowbar;string&lowbar;view` into the `bsl` namespace&period;
| xref:bsl/operator==-0d.adoc[`operator&equals;&equals;`] 
| Import `std&colon;&colon;operator&equals;&equals;` for `basic&lowbar;string&lowbar;view` into the `bsl` namespace&period;
| xref:bsl/operator>-01.adoc[`operator&gt;`] 
| Import `std&colon;&colon;operator&gt;` for `basic&lowbar;string&lowbar;view` into the `bsl` namespace&period;
| xref:bsl/operator>-03.adoc[`operator&gt;`] 
| Import `std&colon;&colon;operator&gt;` for `basic&lowbar;string&lowbar;view` into the `bsl` namespace&period;
| xref:bsl/operator>-06.adoc[`operator&gt;`] 
| Import `std&colon;&colon;operator&gt;` for `basic&lowbar;string&lowbar;view` into the `bsl` namespace&period;
| xref:bsl/operator>-0d.adoc[`operator&gt;`] 
| Import `std&colon;&colon;operator&gt;` for `basic&lowbar;string&lowbar;view` into the `bsl` namespace&period;
| xref:bsl/operator>=-03.adoc[`operator&gt;&equals;`] 
| Import `std&colon;&colon;operator&gt;&equals;` for `basic&lowbar;string&lowbar;view` into the `bsl` namespace&period;
| xref:bsl/operator>=-07.adoc[`operator&gt;&equals;`] 
| Import `std&colon;&colon;operator&gt;&equals;` for `basic&lowbar;string&lowbar;view` into the `bsl` namespace&period;
| xref:bsl/operator>=-0a.adoc[`operator&gt;&equals;`] 
| Import `std&colon;&colon;operator&gt;&equals;` for `basic&lowbar;string&lowbar;view` into the `bsl` namespace&period;
| xref:bsl/operator>=-0e.adoc[`operator&gt;&equals;`] 
| Import `std&colon;&colon;operator&gt;&equals;` for `basic&lowbar;string&lowbar;view` into the `bsl` namespace&period;
| xref:bsl/ospanstream.adoc[`ospanstream`] 
| Alias for `std&colon;&colon;ospanstream` in the `bsl` namespace&period;
| xref:bsl/ostream.adoc[`ostream`] 
| Alias for `std&colon;&colon;ostream` in the `bsl` namespace&period;
| xref:bsl/ostream_iterator.adoc[`ostream&lowbar;iterator`] 
| Alias for `std&colon;&colon;ostream&lowbar;iterator` in the `bsl` namespace&period;
| xref:bsl/ostreambuf_iterator.adoc[`ostreambuf&lowbar;iterator`] 
| Alias for `std&colon;&colon;ostreambuf&lowbar;iterator` in the `bsl` namespace&period;
| xref:bsl/ostrstream.adoc[`ostrstream`] 
| Alias for `std&colon;&colon;ostrstream` in the `bsl` namespace&period;
| xref:bsl/out_of_range.adoc[`out&lowbar;of&lowbar;range`] 
| Alias for `std&colon;&colon;out&lowbar;of&lowbar;range` in the `bsl` namespace&period;
| xref:bsl/out_ptr.adoc[`out&lowbar;ptr`] 
| Alias for `std&colon;&colon;out&lowbar;ptr` in the `bsl` namespace&period;
| xref:bsl/out_ptr_t.adoc[`out&lowbar;ptr&lowbar;t`] 
| Alias for `std&colon;&colon;out&lowbar;ptr&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/output_iterator.adoc[`output&lowbar;iterator`] 
| Alias for `std&colon;&colon;output&lowbar;iterator` in the `bsl` namespace&period;
| xref:bsl/output_iterator_tag.adoc[`output&lowbar;iterator&lowbar;tag`] 
| Alias for `std&colon;&colon;output&lowbar;iterator&lowbar;tag` in the `bsl` namespace&period;
| xref:bsl/overflow_error.adoc[`overflow&lowbar;error`] 
| Alias for `std&colon;&colon;overflow&lowbar;error` in the `bsl` namespace&period;
| xref:bsl/packaged_task.adoc[`packaged&lowbar;task`] 
| Alias for `std&colon;&colon;packaged&lowbar;task` in the `bsl` namespace&period;
| xref:bsl/partial_order.adoc[`partial&lowbar;order`] 
| Alias for `std&colon;&colon;partial&lowbar;order` in the `bsl` namespace&period;
| xref:bsl/partial_ordering.adoc[`partial&lowbar;ordering`] 
| Alias for `std&colon;&colon;partial&lowbar;ordering` in the `bsl` namespace&period;
| xref:bsl/partial_sort.adoc[`partial&lowbar;sort`] 
| Alias for `std&colon;&colon;partial&lowbar;sort` in the `bsl` namespace&period;
| xref:bsl/partial_sort_copy.adoc[`partial&lowbar;sort&lowbar;copy`] 
| Alias for `std&colon;&colon;partial&lowbar;sort&lowbar;copy` in the `bsl` namespace&period;
| xref:bsl/partial_sum.adoc[`partial&lowbar;sum`] 
| Alias for `std&colon;&colon;partial&lowbar;sum` in the `bsl` namespace&period;
| xref:bsl/partition.adoc[`partition`] 
| Alias for `std&colon;&colon;partition` in the `bsl` namespace&period;
| xref:bsl/partition_copy.adoc[`partition&lowbar;copy`] 
| Alias for `std&colon;&colon;partition&lowbar;copy` in the `bsl` namespace&period;
| xref:bsl/partition_point.adoc[`partition&lowbar;point`] 
| Alias for `std&colon;&colon;partition&lowbar;point` in the `bsl` namespace&period;
| xref:bsl/permutable.adoc[`permutable`] 
| Alias for `std&colon;&colon;permutable` in the `bsl` namespace&period;
| xref:bsl/perror.adoc[`perror`] 
| Alias for `std&colon;&colon;perror` in the `bsl` namespace&period;
| xref:bsl/peta.adoc[`peta`] 
| Alias for `std&colon;&colon;peta`&period;
| xref:bsl/pico.adoc[`pico`] 
| Alias for `std&colon;&colon;pico`&period;
| xref:bsl/piecewise_constant_distribution.adoc[`piecewise&lowbar;constant&lowbar;distribution`] 
| Alias for `std&colon;&colon;piecewise&lowbar;constant&lowbar;distribution` in the `bsl` namespace&period;
| xref:bsl/piecewise_construct.adoc[`piecewise&lowbar;construct`] 
| Alias for `std&colon;&colon;piecewise&lowbar;construct` in the `bsl` namespace&period;
| xref:bsl/piecewise_construct_t.adoc[`piecewise&lowbar;construct&lowbar;t`] 
| Alias for `std&colon;&colon;piecewise&lowbar;construct&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/piecewise_linear_distribution.adoc[`piecewise&lowbar;linear&lowbar;distribution`] 
| Alias for `std&colon;&colon;piecewise&lowbar;linear&lowbar;distribution` in the `bsl` namespace&period;
| xref:bsl/plus.adoc[`plus`] 
| Alias for `std&colon;&colon;plus` in the `bsl` namespace&period;
| xref:bsl/pointer_to_binary_function.adoc[`pointer&lowbar;to&lowbar;binary&lowbar;function`] 
| Alias for `std&colon;&colon;pointer&lowbar;to&lowbar;binary&lowbar;function` in the `bsl` namespace&period;
| xref:bsl/pointer_to_unary_function.adoc[`pointer&lowbar;to&lowbar;unary&lowbar;function`] 
| Alias for `std&colon;&colon;pointer&lowbar;to&lowbar;unary&lowbar;function` in the `bsl` namespace&period;
| xref:bsl/pointer_traits.adoc[`pointer&lowbar;traits`] 
| Alias for `std&colon;&colon;pointer&lowbar;traits` in the `bsl` namespace&period;
| xref:bsl/poisson_distribution.adoc[`poisson&lowbar;distribution`] 
| Alias for `std&colon;&colon;poisson&lowbar;distribution` in the `bsl` namespace&period;
| xref:bsl/polar.adoc[`polar`] 
| Alias for `std&colon;&colon;polar` in the `bsl` namespace&period;
| xref:bsl/pop_heap.adoc[`pop&lowbar;heap`] 
| Alias for `std&colon;&colon;pop&lowbar;heap` in the `bsl` namespace&period;
| xref:bsl/popcount.adoc[`popcount`] 
| Alias for `std&colon;&colon;popcount` in the `bsl` namespace&period;
| xref:bsl/pow-0f.adoc[`pow`] 
| Alias for `std&colon;&colon;pow` in the `bsl` namespace&period;
| xref:bsl/pow-00.adoc[`pow`] 
| Alias for `std&colon;&colon;pow` in the `bsl` namespace&period;
| xref:bsl/pow-07.adoc[`pow`] 
| Alias for `std&colon;&colon;pow` in the `bsl` namespace&period;
| xref:bsl/predicate.adoc[`predicate`] 
| Alias for `std&colon;&colon;predicate` in the `bsl` namespace&period;
| xref:bsl/prev.adoc[`prev`] 
| Standard library alias for `std&colon;&colon;prev`&period;
| xref:bsl/prev_permutation.adoc[`prev&lowbar;permutation`] 
| Alias for `std&colon;&colon;prev&lowbar;permutation` in the `bsl` namespace&period;
| xref:bsl/print-02.adoc[`print`] 
| Alias for `BloombergLP&colon;&colon;bslfmt&colon;&colon;print` in the `bsl` namespace&period;
| xref:bsl/print-0e.adoc[`print`] 
| Alias for `BloombergLP&colon;&colon;bslfmt&colon;&colon;print` in the `bsl` namespace&period;
| xref:bsl/printf.adoc[`printf`] 
| Alias for `std&colon;&colon;printf` in the `bsl` namespace&period;
| xref:bsl/println-05.adoc[`println`] 
| Alias for `BloombergLP&colon;&colon;bslfmt&colon;&colon;println` in the `bsl` namespace&period;
| xref:bsl/println-0f.adoc[`println`] 
| Alias for `BloombergLP&colon;&colon;bslfmt&colon;&colon;println` in the `bsl` namespace&period;
| xref:bsl/proj.adoc[`proj`] 
| Alias for `std&colon;&colon;proj` in the `bsl` namespace&period;
| xref:bsl/projected.adoc[`projected`] 
| Alias for `std&colon;&colon;projected` in the `bsl` namespace&period;
| xref:bsl/promise.adoc[`promise`] 
| Alias for `std&colon;&colon;promise` in the `bsl` namespace&period;
| xref:bsl/ptr_fun.adoc[`ptr&lowbar;fun`] 
| Alias for `std&colon;&colon;ptr&lowbar;fun` in the `bsl` namespace&period;
| xref:bsl/ptrdiff_t.adoc[`ptrdiff&lowbar;t`] 
| Alias for `std&colon;&colon;ptrdiff&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/push_heap.adoc[`push&lowbar;heap`] 
| Alias for `std&colon;&colon;push&lowbar;heap` in the `bsl` namespace&period;
| xref:bsl/put_money.adoc[`put&lowbar;money`] 
| Alias for `std&colon;&colon;put&lowbar;money` in the `bsl` namespace&period;
| xref:bsl/put_time.adoc[`put&lowbar;time`] 
| Alias for `std&colon;&colon;put&lowbar;time` in the `bsl` namespace&period;
| xref:bsl/putc.adoc[`putc`] 
| Alias for `std&colon;&colon;putc` in the `bsl` namespace&period;
| xref:bsl/putchar.adoc[`putchar`] 
| Alias for `std&colon;&colon;putchar` in the `bsl` namespace&period;
| xref:bsl/puts.adoc[`puts`] 
| Alias for `std&colon;&colon;puts` in the `bsl` namespace&period;
| xref:bsl/putwc.adoc[`putwc`] 
| Alias for `std&colon;&colon;putwc` in the `bsl` namespace&period;
| xref:bsl/putwchar.adoc[`putwchar`] 
| Alias for `std&colon;&colon;putwchar` in the `bsl` namespace&period;
| xref:bsl/qsort.adoc[`qsort`] 
| Alias for `std&colon;&colon;qsort` in the `bsl` namespace&period;
| xref:bsl/quick_exit.adoc[`quick&lowbar;exit`] 
| Alias for `std&colon;&colon;quick&lowbar;exit` in the `bsl` namespace&period;
| xref:bsl/quoted-02.adoc[`quoted`] 
| Alias for `std&colon;&colon;quoted` in the `bsl` namespace&period;
| xref:bsl/raise.adoc[`raise`] 
| Alias for `std&colon;&colon;raise` in the `bsl` namespace&period;
| xref:bsl/rand.adoc[`rand`] 
| Alias for `std&colon;&colon;rand` in the `bsl` namespace&period;
| xref:bsl/random_access_iterator.adoc[`random&lowbar;access&lowbar;iterator`] 
| Alias for `std&colon;&colon;random&lowbar;access&lowbar;iterator` in the `bsl` namespace&period;
| xref:bsl/random_access_iterator_tag.adoc[`random&lowbar;access&lowbar;iterator&lowbar;tag`] 
| Alias for `std&colon;&colon;random&lowbar;access&lowbar;iterator&lowbar;tag` in the `bsl` namespace&period;
| xref:bsl/random_device.adoc[`random&lowbar;device`] 
| Alias for `std&colon;&colon;random&lowbar;device` in the `bsl` namespace&period;
| xref:bsl/random_shuffle.adoc[`random&lowbar;shuffle`] 
| Alias for `std&colon;&colon;random&lowbar;shuffle` in the `bsl` namespace&period;
| xref:bsl/range_error.adoc[`range&lowbar;error`] 
| Alias for `std&colon;&colon;range&lowbar;error` in the `bsl` namespace&period;
| xref:bsl/rank.adoc[`rank`] 
| Alias for `std&colon;&colon;rank` in the `bsl` namespace&period;
| xref:bsl/ranlux24.adoc[`ranlux24`] 
| Alias for `std&colon;&colon;ranlux24` in the `bsl` namespace&period;
| xref:bsl/ranlux24_base.adoc[`ranlux24&lowbar;base`] 
| Alias for `std&colon;&colon;ranlux24&lowbar;base` in the `bsl` namespace&period;
| xref:bsl/ranlux48.adoc[`ranlux48`] 
| Alias for `std&colon;&colon;ranlux48` in the `bsl` namespace&period;
| xref:bsl/ranlux48_base.adoc[`ranlux48&lowbar;base`] 
| Alias for `std&colon;&colon;ranlux48&lowbar;base` in the `bsl` namespace&period;
| xref:bsl/ratio.adoc[`ratio`] 
| Alias for `std&colon;&colon;ratio`&period;
| xref:bsl/ratio_add.adoc[`ratio&lowbar;add`] 
| Alias for `std&colon;&colon;ratio&lowbar;add`&period;
| xref:bsl/ratio_divide.adoc[`ratio&lowbar;divide`] 
| Alias for `std&colon;&colon;ratio&lowbar;divide`&period;
| xref:bsl/ratio_equal.adoc[`ratio&lowbar;equal`] 
| Alias for `std&colon;&colon;ratio&lowbar;equal`&period;
| xref:bsl/ratio_equal_v.adoc[`ratio&lowbar;equal&lowbar;v`] 
| Alias for `std&colon;&colon;ratio&lowbar;equal&lowbar;v`&period;
| xref:bsl/ratio_greater.adoc[`ratio&lowbar;greater`] 
| Alias for `std&colon;&colon;ratio&lowbar;greater`&period;
| xref:bsl/ratio_greater_equal.adoc[`ratio&lowbar;greater&lowbar;equal`] 
| Alias for `std&colon;&colon;ratio&lowbar;greater&lowbar;equal`&period;
| xref:bsl/ratio_greater_equal_v.adoc[`ratio&lowbar;greater&lowbar;equal&lowbar;v`] 
| Alias for `std&colon;&colon;ratio&lowbar;greater&lowbar;equal&lowbar;v`&period;
| xref:bsl/ratio_greater_v.adoc[`ratio&lowbar;greater&lowbar;v`] 
| Alias for `std&colon;&colon;ratio&lowbar;greater&lowbar;v`&period;
| xref:bsl/ratio_less.adoc[`ratio&lowbar;less`] 
| Alias for `std&colon;&colon;ratio&lowbar;less`&period;
| xref:bsl/ratio_less_equal.adoc[`ratio&lowbar;less&lowbar;equal`] 
| Alias for `std&colon;&colon;ratio&lowbar;less&lowbar;equal`&period;
| xref:bsl/ratio_less_equal_v.adoc[`ratio&lowbar;less&lowbar;equal&lowbar;v`] 
| Alias for `std&colon;&colon;ratio&lowbar;less&lowbar;equal&lowbar;v`&period;
| xref:bsl/ratio_less_v.adoc[`ratio&lowbar;less&lowbar;v`] 
| Alias for `std&colon;&colon;ratio&lowbar;less&lowbar;v`&period;
| xref:bsl/ratio_multiply.adoc[`ratio&lowbar;multiply`] 
| Alias for `std&colon;&colon;ratio&lowbar;multiply`&period;
| xref:bsl/ratio_not_equal.adoc[`ratio&lowbar;not&lowbar;equal`] 
| Alias for `std&colon;&colon;ratio&lowbar;not&lowbar;equal`&period;
| xref:bsl/ratio_not_equal_v.adoc[`ratio&lowbar;not&lowbar;equal&lowbar;v`] 
| Alias for `std&colon;&colon;ratio&lowbar;not&lowbar;equal&lowbar;v`&period;
| xref:bsl/ratio_subtract.adoc[`ratio&lowbar;subtract`] 
| Alias for `std&colon;&colon;ratio&lowbar;subtract`&period;
| xref:bsl/raw_storage_iterator.adoc[`raw&lowbar;storage&lowbar;iterator`] 
| Alias for `std&colon;&colon;raw&lowbar;storage&lowbar;iterator` in the `bsl` namespace&period;
| xref:bsl/rbegin.adoc[`rbegin`] 
| Alias for `std&colon;&colon;rbegin` in the `bsl` namespace&period;
| xref:bsl/real.adoc[`real`] 
| Alias for `std&colon;&colon;real` in the `bsl` namespace&period;
| xref:bsl/realloc.adoc[`realloc`] 
| Alias for `std&colon;&colon;realloc` in the `bsl` namespace&period;
| xref:bsl/recursive_mutex.adoc[`recursive&lowbar;mutex`] 
| Alias for `std&colon;&colon;recursive&lowbar;mutex` in the `bsl` namespace&period;
| xref:bsl/recursive_timed_mutex.adoc[`recursive&lowbar;timed&lowbar;mutex`] 
| Alias for `std&colon;&colon;recursive&lowbar;timed&lowbar;mutex` in the `bsl` namespace&period;
| xref:bsl/reduce.adoc[`reduce`] 
| Alias for `std&colon;&colon;reduce` in the `bsl` namespace&period;
| xref:bsl/ref.adoc[`ref`] 
| Alias for `std&colon;&colon;ref` in the `bsl` namespace&period;
| xref:bsl/reference_constructs_from_temporary.adoc[`reference&lowbar;constructs&lowbar;from&lowbar;temporary`] 
| Alias for `std&colon;&colon;reference&lowbar;constructs&lowbar;from&lowbar;temporary` in the `bsl` namespace&period;
| xref:bsl/reference_constructs_from_temporary_v.adoc[`reference&lowbar;constructs&lowbar;from&lowbar;temporary&lowbar;v`] 
| Alias for `std&colon;&colon;reference&lowbar;constructs&lowbar;from&lowbar;temporary&lowbar;v` in the `bsl` namespace&period;
| xref:bsl/reference_converts_from_temporary.adoc[`reference&lowbar;converts&lowbar;from&lowbar;temporary`] 
| Alias for `std&colon;&colon;reference&lowbar;converts&lowbar;from&lowbar;temporary` in the `bsl` namespace&period;
| xref:bsl/reference_converts_from_temporary_v.adoc[`reference&lowbar;converts&lowbar;from&lowbar;temporary&lowbar;v`] 
| Alias for `std&colon;&colon;reference&lowbar;converts&lowbar;from&lowbar;temporary&lowbar;v` in the `bsl` namespace&period;
| xref:bsl/reference_wrapper.adoc[`reference&lowbar;wrapper`] 
| Alias for `std&colon;&colon;reference&lowbar;wrapper` in the `bsl` namespace&period;
| xref:bsl/regex.adoc[`regex`] 
| Alias for `std&colon;&colon;regex` in the `bsl` namespace&period;
| xref:bsl/regex_error.adoc[`regex&lowbar;error`] 
| Alias for `std&colon;&colon;regex&lowbar;error` in the `bsl` namespace&period;
| xref:bsl/regex_iterator.adoc[`regex&lowbar;iterator`] 
| Alias for `std&colon;&colon;regex&lowbar;iterator` in the `bsl` namespace&period;
| xref:bsl/regex_match.adoc[`regex&lowbar;match`] 
| Alias for `std&colon;&colon;regex&lowbar;match` in the `bsl` namespace&period;
| xref:bsl/regex_replace.adoc[`regex&lowbar;replace`] 
| Alias for `std&colon;&colon;regex&lowbar;replace` in the `bsl` namespace&period;
| xref:bsl/regex_search.adoc[`regex&lowbar;search`] 
| Alias for `std&colon;&colon;regex&lowbar;search` in the `bsl` namespace&period;
| xref:bsl/regex_token_iterator.adoc[`regex&lowbar;token&lowbar;iterator`] 
| Alias for `std&colon;&colon;regex&lowbar;token&lowbar;iterator` in the `bsl` namespace&period;
| xref:bsl/regex_traits.adoc[`regex&lowbar;traits`] 
| Alias for `std&colon;&colon;regex&lowbar;traits` in the `bsl` namespace&period;
| xref:bsl/regular.adoc[`regular`] 
| Alias for `std&colon;&colon;regular` in the `bsl` namespace&period;
| xref:bsl/regular_invocable.adoc[`regular&lowbar;invocable`] 
| Alias for `std&colon;&colon;regular&lowbar;invocable` in the `bsl` namespace&period;
| xref:bsl/relation.adoc[`relation`] 
| Alias for `std&colon;&colon;relation` in the `bsl` namespace&period;
| xref:bsl/remainder.adoc[`remainder`] 
| Alias for `std&colon;&colon;remainder` in the `bsl` namespace&period;
| xref:bsl/remove-08.adoc[`remove`] 
| Alias for `std&colon;&colon;remove` in the `bsl` namespace&period;
| xref:bsl/remove-04.adoc[`remove`] 
| Alias for `std&colon;&colon;remove` in the `bsl` namespace&period;
| xref:bsl/remove-09.adoc[`remove`] 
| Alias for `std&colon;&colon;remove` in the `bsl` namespace&period;
| xref:bsl/remove_all_extents.adoc[`remove&lowbar;all&lowbar;extents`] 
| Alias for `std&colon;&colon;remove&lowbar;all&lowbar;extents` in the `bsl` namespace&period;
| xref:bsl/remove_copy.adoc[`remove&lowbar;copy`] 
| Alias for `std&colon;&colon;remove&lowbar;copy` in the `bsl` namespace&period;
| xref:bsl/remove_copy_if.adoc[`remove&lowbar;copy&lowbar;if`] 
| Alias for `std&colon;&colon;remove&lowbar;copy&lowbar;if` in the `bsl` namespace&period;
| xref:bsl/remove_cvref.adoc[`remove&lowbar;cvref`] 
| Alias for `std&colon;&colon;remove&lowbar;cvref` in the `bsl` namespace&period;
| xref:bsl/remove_cvref_t.adoc[`remove&lowbar;cvref&lowbar;t`] 
| Alias for `std&colon;&colon;remove&lowbar;cvref&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/remove_if.adoc[`remove&lowbar;if`] 
| Alias for `std&colon;&colon;remove&lowbar;if` in the `bsl` namespace&period;
| xref:bsl/remove_reference.adoc[`remove&lowbar;reference`] 
| Alias for `std&colon;&colon;remove&lowbar;reference` in the `bsl` namespace&period;
| xref:bsl/remove_reference_t.adoc[`remove&lowbar;reference&lowbar;t`] 
| Alias for `std&colon;&colon;remove&lowbar;reference&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/remquo.adoc[`remquo`] 
| Alias for `std&colon;&colon;remquo` in the `bsl` namespace&period;
| xref:bsl/rename.adoc[`rename`] 
| Alias for `std&colon;&colon;rename` in the `bsl` namespace&period;
| xref:bsl/rend.adoc[`rend`] 
| Alias for `std&colon;&colon;rend` in the `bsl` namespace&period;
| xref:bsl/replace.adoc[`replace`] 
| Alias for `std&colon;&colon;replace` in the `bsl` namespace&period;
| xref:bsl/replace_copy.adoc[`replace&lowbar;copy`] 
| Alias for `std&colon;&colon;replace&lowbar;copy` in the `bsl` namespace&period;
| xref:bsl/replace_copy_if.adoc[`replace&lowbar;copy&lowbar;if`] 
| Alias for `std&colon;&colon;replace&lowbar;copy&lowbar;if` in the `bsl` namespace&period;
| xref:bsl/replace_if.adoc[`replace&lowbar;if`] 
| Alias for `std&colon;&colon;replace&lowbar;if` in the `bsl` namespace&period;
| xref:bsl/resetiosflags.adoc[`resetiosflags`] 
| Alias for `std&colon;&colon;resetiosflags` in the `bsl` namespace&period;
| xref:bsl/result_of.adoc[`result&lowbar;of`] 
| Alias for `std&colon;&colon;result&lowbar;of` in the `bsl` namespace&period;
| xref:bsl/rethrow_exception.adoc[`rethrow&lowbar;exception`] 
| Undocumented symbol&period;
| xref:bsl/rethrow_if_nested.adoc[`rethrow&lowbar;if&lowbar;nested`] 
| Undocumented symbol&period;
| xref:bsl/return_temporary_buffer.adoc[`return&lowbar;temporary&lowbar;buffer`] 
| Alias for `std&colon;&colon;return&lowbar;temporary&lowbar;buffer` in the `bsl` namespace&period;
| xref:bsl/reverse.adoc[`reverse`] 
| Alias for `std&colon;&colon;reverse` in the `bsl` namespace&period;
| xref:bsl/reverse_copy.adoc[`reverse&lowbar;copy`] 
| Alias for `std&colon;&colon;reverse&lowbar;copy` in the `bsl` namespace&period;
| xref:bsl/reverse_iterator.adoc[`reverse&lowbar;iterator`] 
| Alias for `std&colon;&colon;reverse&lowbar;iterator` in the `bsl` namespace&period;
| xref:bsl/rewind.adoc[`rewind`] 
| Alias for `std&colon;&colon;rewind` in the `bsl` namespace&period;
| xref:bsl/riemann_zeta.adoc[`riemann&lowbar;zeta`] 
| 
| xref:bsl/riemann_zetaf.adoc[`riemann&lowbar;zetaf`] 
| 
| xref:bsl/riemann_zetal.adoc[`riemann&lowbar;zetal`] 
| 
| xref:bsl/right.adoc[`right`] 
| Alias for `std&colon;&colon;right` in the `bsl` namespace&period;
| xref:bsl/rint.adoc[`rint`] 
| Alias for `std&colon;&colon;rint` in the `bsl` namespace&period;
| xref:bsl/rotate.adoc[`rotate`] 
| Alias for `std&colon;&colon;rotate` in the `bsl` namespace&period;
| xref:bsl/rotate_copy.adoc[`rotate&lowbar;copy`] 
| Alias for `std&colon;&colon;rotate&lowbar;copy` in the `bsl` namespace&period;
| xref:bsl/rotl.adoc[`rotl`] 
| Alias for `std&colon;&colon;rotl` in the `bsl` namespace&period;
| xref:bsl/rotr.adoc[`rotr`] 
| Alias for `std&colon;&colon;rotr` in the `bsl` namespace&period;
| xref:bsl/round.adoc[`round`] 
| Alias for `std&colon;&colon;round` in the `bsl` namespace&period;
| xref:bsl/round_indeterminate.adoc[`round&lowbar;indeterminate`] 
| Alias for `std&colon;&colon;round&lowbar;indeterminate` in the `bsl` namespace&period;
| xref:bsl/round_to_nearest.adoc[`round&lowbar;to&lowbar;nearest`] 
| Alias for `std&colon;&colon;round&lowbar;to&lowbar;nearest` in the `bsl` namespace&period;
| xref:bsl/round_toward_infinity.adoc[`round&lowbar;toward&lowbar;infinity`] 
| Alias for `std&colon;&colon;round&lowbar;toward&lowbar;infinity` in the `bsl` namespace&period;
| xref:bsl/round_toward_neg_infinity.adoc[`round&lowbar;toward&lowbar;neg&lowbar;infinity`] 
| Alias for `std&colon;&colon;round&lowbar;toward&lowbar;neg&lowbar;infinity` in the `bsl` namespace&period;
| xref:bsl/round_toward_zero.adoc[`round&lowbar;toward&lowbar;zero`] 
| Alias for `std&colon;&colon;round&lowbar;toward&lowbar;zero` in the `bsl` namespace&period;
| xref:bsl/runtime_error.adoc[`runtime&lowbar;error`] 
| Alias for `std&colon;&colon;runtime&lowbar;error` in the `bsl` namespace&period;
| xref:bsl/same_as.adoc[`same&lowbar;as`] 
| Alias for `std&colon;&colon;same&lowbar;as` in the `bsl` namespace&period;
| xref:bsl/sample.adoc[`sample`] 
| Alias for `std&colon;&colon;sample` in the `bsl` namespace&period;
| xref:bsl/scalbln.adoc[`scalbln`] 
| Alias for `std&colon;&colon;scalbln` in the `bsl` namespace&period;
| xref:bsl/scalbn.adoc[`scalbn`] 
| Alias for `std&colon;&colon;scalbn` in the `bsl` namespace&period;
| xref:bsl/scanf.adoc[`scanf`] 
| Alias for `std&colon;&colon;scanf` in the `bsl` namespace&period;
| xref:bsl/scientific.adoc[`scientific`] 
| Alias for `std&colon;&colon;scientific` in the `bsl` namespace&period;
| xref:bsl/scoped_allocator_adaptor.adoc[`scoped&lowbar;allocator&lowbar;adaptor`] 
| Alias for `std&colon;&colon;scoped&lowbar;allocator&lowbar;adaptor` in the `bsl` namespace&period;
| xref:bsl/scoped_lock.adoc[`scoped&lowbar;lock`] 
| Alias for `std&colon;&colon;scoped&lowbar;lock` in the `bsl` namespace&period;
| xref:bsl/search.adoc[`search`] 
| Alias for `std&colon;&colon;search` in the `bsl` namespace&period;
| xref:bsl/search_n.adoc[`search&lowbar;n`] 
| Alias for `std&colon;&colon;search&lowbar;n` in the `bsl` namespace&period;
| xref:bsl/seed_seq.adoc[`seed&lowbar;seq`] 
| Alias for `std&colon;&colon;seed&lowbar;seq` in the `bsl` namespace&period;
| xref:bsl/semiregular.adoc[`semiregular`] 
| Alias for `std&colon;&colon;semiregular` in the `bsl` namespace&period;
| xref:bsl/sentinel_for.adoc[`sentinel&lowbar;for`] 
| Alias for `std&colon;&colon;sentinel&lowbar;for` in the `bsl` namespace&period;
| xref:bsl/set_difference.adoc[`set&lowbar;difference`] 
| Alias for `std&colon;&colon;set&lowbar;difference` in the `bsl` namespace&period;
| xref:bsl/set_intersection.adoc[`set&lowbar;intersection`] 
| Alias for `std&colon;&colon;set&lowbar;intersection` in the `bsl` namespace&period;
| xref:bsl/set_new_handler.adoc[`set&lowbar;new&lowbar;handler`] 
| Alias for `std&colon;&colon;set&lowbar;new&lowbar;handler` in the `bsl` namespace&period;
| xref:bsl/set_symmetric_difference.adoc[`set&lowbar;symmetric&lowbar;difference`] 
| Alias for `std&colon;&colon;set&lowbar;symmetric&lowbar;difference` in the `bsl` namespace&period;
| xref:bsl/set_terminate.adoc[`set&lowbar;terminate`] 
| Undocumented symbol&period;
| xref:bsl/set_union.adoc[`set&lowbar;union`] 
| Alias for `std&colon;&colon;set&lowbar;union` in the `bsl` namespace&period;
| xref:bsl/setbase.adoc[`setbase`] 
| Alias for `std&colon;&colon;setbase` in the `bsl` namespace&period;
| xref:bsl/setbuf.adoc[`setbuf`] 
| Alias for `std&colon;&colon;setbuf` in the `bsl` namespace&period;
| xref:bsl/setfill.adoc[`setfill`] 
| Alias for `std&colon;&colon;setfill` in the `bsl` namespace&period;
| xref:bsl/setiosflags.adoc[`setiosflags`] 
| Alias for `std&colon;&colon;setiosflags` in the `bsl` namespace&period;
| xref:bsl/setlocale.adoc[`setlocale`] 
| Alias for `std&colon;&colon;setlocale` in the `bsl` namespace&period;
| xref:bsl/setprecision.adoc[`setprecision`] 
| Alias for `std&colon;&colon;setprecision` in the `bsl` namespace&period;
| xref:bsl/setvbuf.adoc[`setvbuf`] 
| Alias for `std&colon;&colon;setvbuf` in the `bsl` namespace&period;
| xref:bsl/setw.adoc[`setw`] 
| Alias for `std&colon;&colon;setw` in the `bsl` namespace&period;
| xref:bsl/shared_future.adoc[`shared&lowbar;future`] 
| Alias for `std&colon;&colon;shared&lowbar;future` in the `bsl` namespace&period;
| xref:bsl/shared_lock.adoc[`shared&lowbar;lock`] 
| Alias for `std&colon;&colon;shared&lowbar;lock` in the `bsl` namespace&period;
| xref:bsl/shared_mutex.adoc[`shared&lowbar;mutex`] 
| Alias for `std&colon;&colon;shared&lowbar;mutex` in the `bsl` namespace&period;
| xref:bsl/shared_timed_mutex.adoc[`shared&lowbar;timed&lowbar;mutex`] 
| Alias for `std&colon;&colon;shared&lowbar;timed&lowbar;mutex` in the `bsl` namespace&period;
| xref:bsl/showbase.adoc[`showbase`] 
| Alias for `std&colon;&colon;showbase` in the `bsl` namespace&period;
| xref:bsl/showpoint.adoc[`showpoint`] 
| Alias for `std&colon;&colon;showpoint` in the `bsl` namespace&period;
| xref:bsl/showpos.adoc[`showpos`] 
| Alias for `std&colon;&colon;showpos` in the `bsl` namespace&period;
| xref:bsl/shuffle.adoc[`shuffle`] 
| Alias for `std&colon;&colon;shuffle` in the `bsl` namespace&period;
| xref:bsl/shuffle_order_engine.adoc[`shuffle&lowbar;order&lowbar;engine`] 
| Alias for `std&colon;&colon;shuffle&lowbar;order&lowbar;engine` in the `bsl` namespace&period;
| xref:bsl/sig_atomic_t.adoc[`sig&lowbar;atomic&lowbar;t`] 
| Alias for `std&colon;&colon;sig&lowbar;atomic&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/signal.adoc[`signal`] 
| Alias for `std&colon;&colon;signal` in the `bsl` namespace&period;
| xref:bsl/signbit.adoc[`signbit`] 
| Alias for `std&colon;&colon;signbit` in the `bsl` namespace&period;
| xref:bsl/signed_integral.adoc[`signed&lowbar;integral`] 
| Alias for `std&colon;&colon;signed&lowbar;integral` in the `bsl` namespace&period;
| xref:bsl/sin-0a.adoc[`sin`] 
| Alias for `std&colon;&colon;sin` in the `bsl` namespace&period;
| xref:bsl/sin-05.adoc[`sin`] 
| Alias for `std&colon;&colon;sin` in the `bsl` namespace&period;
| xref:bsl/sin-0b.adoc[`sin`] 
| Alias for `std&colon;&colon;sin` in the `bsl` namespace&period;
| xref:bsl/sinh-00.adoc[`sinh`] 
| Alias for `std&colon;&colon;sinh` in the `bsl` namespace&period;
| xref:bsl/sinh-09.adoc[`sinh`] 
| Alias for `std&colon;&colon;sinh` in the `bsl` namespace&period;
| xref:bsl/sinh-02.adoc[`sinh`] 
| Alias for `std&colon;&colon;sinh` in the `bsl` namespace&period;
| xref:bsl/size.adoc[`size`] 
| Alias for `std&colon;&colon;size` in the `bsl` namespace&period;
| xref:bsl/size_t.adoc[`size&lowbar;t`] 
| Alias for `std&colon;&colon;size&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/sized_sentinel_for.adoc[`sized&lowbar;sentinel&lowbar;for`] 
| Alias for `std&colon;&colon;sized&lowbar;sentinel&lowbar;for` in the `bsl` namespace&period;
| xref:bsl/skipws.adoc[`skipws`] 
| Alias for `std&colon;&colon;skipws` in the `bsl` namespace&period;
| xref:bsl/slice.adoc[`slice`] 
| Alias for `std&colon;&colon;slice` in the `bsl` namespace&period;
| xref:bsl/slice_array.adoc[`slice&lowbar;array`] 
| Alias for `std&colon;&colon;slice&lowbar;array` in the `bsl` namespace&period;
| xref:bsl/smatch.adoc[`smatch`] 
| Alias for `std&colon;&colon;smatch` in the `bsl` namespace&period;
| xref:bsl/snprintf.adoc[`snprintf`] 
| Alias for `std&colon;&colon;snprintf` in the `bsl` namespace&period;
| xref:bsl/sort.adoc[`sort`] 
| Alias for `std&colon;&colon;sort` in the `bsl` namespace&period;
| xref:bsl/sort_heap.adoc[`sort&lowbar;heap`] 
| Alias for `std&colon;&colon;sort&lowbar;heap` in the `bsl` namespace&period;
| xref:bsl/sortable.adoc[`sortable`] 
| Alias for `std&colon;&colon;sortable` in the `bsl` namespace&period;
| xref:bsl/source_location.adoc[`source&lowbar;location`] 
| Alias for `std&colon;&colon;source&lowbar;location` in the `bsl` namespace&period;
| xref:bsl/span.adoc[`span`] 
| Alias for `std&colon;&colon;span`&period;
| xref:bsl/spanbuf.adoc[`spanbuf`] 
| Alias for `std&colon;&colon;spanbuf` in the `bsl` namespace&period;
| xref:bsl/spanstream.adoc[`spanstream`] 
| Alias for `std&colon;&colon;spanstream` in the `bsl` namespace&period;
| xref:bsl/sph_bessel.adoc[`sph&lowbar;bessel`] 
| 
| xref:bsl/sph_besself.adoc[`sph&lowbar;besself`] 
| 
| xref:bsl/sph_bessell.adoc[`sph&lowbar;bessell`] 
| 
| xref:bsl/sph_legendre.adoc[`sph&lowbar;legendre`] 
| 
| xref:bsl/sph_legendref.adoc[`sph&lowbar;legendref`] 
| 
| xref:bsl/sph_legendrel.adoc[`sph&lowbar;legendrel`] 
| 
| xref:bsl/sph_neumann.adoc[`sph&lowbar;neumann`] 
| 
| xref:bsl/sph_neumannf.adoc[`sph&lowbar;neumannf`] 
| 
| xref:bsl/sph_neumannl.adoc[`sph&lowbar;neumannl`] 
| 
| xref:bsl/sprintf.adoc[`sprintf`] 
| Alias for `std&colon;&colon;sprintf` in the `bsl` namespace&period;
| xref:bsl/sqrt-0cd.adoc[`sqrt`] 
| Alias for `std&colon;&colon;sqrt` in the `bsl` namespace&period;
| xref:bsl/sqrt-0c4.adoc[`sqrt`] 
| Alias for `std&colon;&colon;sqrt` in the `bsl` namespace&period;
| xref:bsl/sqrt-07.adoc[`sqrt`] 
| Alias for `std&colon;&colon;sqrt` in the `bsl` namespace&period;
| xref:bsl/srand.adoc[`srand`] 
| Alias for `std&colon;&colon;srand` in the `bsl` namespace&period;
| xref:bsl/sregex_iterator.adoc[`sregex&lowbar;iterator`] 
| Alias for `std&colon;&colon;sregex&lowbar;iterator` in the `bsl` namespace&period;
| xref:bsl/sscanf.adoc[`sscanf`] 
| Alias for `std&colon;&colon;sscanf` in the `bsl` namespace&period;
| xref:bsl/ssize.adoc[`ssize`] 
| Alias for `std&colon;&colon;ssize` in the `bsl` namespace&period;
| xref:bsl/ssub_match.adoc[`ssub&lowbar;match`] 
| Alias for `std&colon;&colon;ssub&lowbar;match` in the `bsl` namespace&period;
| xref:bsl/stable_partition.adoc[`stable&lowbar;partition`] 
| Alias for `std&colon;&colon;stable&lowbar;partition` in the `bsl` namespace&period;
| xref:bsl/stable_sort.adoc[`stable&lowbar;sort`] 
| Alias for `std&colon;&colon;stable&lowbar;sort` in the `bsl` namespace&period;
| xref:bsl/strcat.adoc[`strcat`] 
| Alias for `std&colon;&colon;strcat` in the `bsl` namespace&period;
| xref:bsl/strchr.adoc[`strchr`] 
| Alias for `std&colon;&colon;strchr` in the `bsl` namespace&period;
| xref:bsl/strcmp.adoc[`strcmp`] 
| Alias for `std&colon;&colon;strcmp` in the `bsl` namespace&period;
| xref:bsl/strcoll.adoc[`strcoll`] 
| Alias for `std&colon;&colon;strcoll` in the `bsl` namespace&period;
| xref:bsl/strcpy.adoc[`strcpy`] 
| Alias for `std&colon;&colon;strcpy` in the `bsl` namespace&period;
| xref:bsl/strcspn.adoc[`strcspn`] 
| Alias for `std&colon;&colon;strcspn` in the `bsl` namespace&period;
| xref:bsl/streambuf.adoc[`streambuf`] 
| Alias for `std&colon;&colon;streambuf` in the `bsl` namespace&period;
| xref:bsl/streamoff.adoc[`streamoff`] 
| Alias for `std&colon;&colon;streamoff` in the `bsl` namespace&period;
| xref:bsl/streampos.adoc[`streampos`] 
| Alias for `std&colon;&colon;streampos` in the `bsl` namespace&period;
| xref:bsl/streamsize.adoc[`streamsize`] 
| Alias for `std&colon;&colon;streamsize` in the `bsl` namespace&period;
| xref:bsl/strerror.adoc[`strerror`] 
| Alias for `std&colon;&colon;strerror` in the `bsl` namespace&period;
| xref:bsl/strftime.adoc[`strftime`] 
| Alias for `std&colon;&colon;strftime` in the `bsl` namespace&period;
| xref:bsl/strict_weak_order.adoc[`strict&lowbar;weak&lowbar;order`] 
| Alias for `std&colon;&colon;strict&lowbar;weak&lowbar;order` in the `bsl` namespace&period;
| xref:bsl/string_view.adoc[`string&lowbar;view`] 
| Alias for `std&colon;&colon;string&lowbar;view` in the `bsl` namespace&period;
| xref:bsl/strlen.adoc[`strlen`] 
| Alias for `std&colon;&colon;strlen` in the `bsl` namespace&period;
| xref:bsl/strncat.adoc[`strncat`] 
| Alias for `std&colon;&colon;strncat` in the `bsl` namespace&period;
| xref:bsl/strncmp.adoc[`strncmp`] 
| Alias for `std&colon;&colon;strncmp` in the `bsl` namespace&period;
| xref:bsl/strncpy.adoc[`strncpy`] 
| Alias for `std&colon;&colon;strncpy` in the `bsl` namespace&period;
| xref:bsl/strong_order.adoc[`strong&lowbar;order`] 
| Alias for `std&colon;&colon;strong&lowbar;order` in the `bsl` namespace&period;
| xref:bsl/strong_ordering.adoc[`strong&lowbar;ordering`] 
| Alias for `std&colon;&colon;strong&lowbar;ordering` in the `bsl` namespace&period;
| xref:bsl/strpbrk.adoc[`strpbrk`] 
| Alias for `std&colon;&colon;strpbrk` in the `bsl` namespace&period;
| xref:bsl/strrchr.adoc[`strrchr`] 
| Alias for `std&colon;&colon;strrchr` in the `bsl` namespace&period;
| xref:bsl/strspn.adoc[`strspn`] 
| Alias for `std&colon;&colon;strspn` in the `bsl` namespace&period;
| xref:bsl/strstr.adoc[`strstr`] 
| Alias for `std&colon;&colon;strstr` in the `bsl` namespace&period;
| xref:bsl/strstream.adoc[`strstream`] 
| Alias for `std&colon;&colon;strstream` in the `bsl` namespace&period;
| xref:bsl/strstreambuf.adoc[`strstreambuf`] 
| Alias for `std&colon;&colon;strstreambuf` in the `bsl` namespace&period;
| xref:bsl/strtod.adoc[`strtod`] 
| Alias for `std&colon;&colon;strtod` in the `bsl` namespace&period;
| xref:bsl/strtof.adoc[`strtof`] 
| Alias for `std&colon;&colon;strtof` in the `bsl` namespace&period;
| xref:bsl/strtoimax.adoc[`strtoimax`] 
| Alias for `std&colon;&colon;strtoimax` in the `bsl` namespace&period;
| xref:bsl/strtok.adoc[`strtok`] 
| Alias for `std&colon;&colon;strtok` in the `bsl` namespace&period;
| xref:bsl/strtol.adoc[`strtol`] 
| Alias for `std&colon;&colon;strtol` in the `bsl` namespace&period;
| xref:bsl/strtold.adoc[`strtold`] 
| Alias for `std&colon;&colon;strtold` in the `bsl` namespace&period;
| xref:bsl/strtoll.adoc[`strtoll`] 
| Alias for `std&colon;&colon;strtoll` in the `bsl` namespace&period;
| xref:bsl/strtoul.adoc[`strtoul`] 
| Import `std&colon;&colon;strtoul` into the `bsl` namespace&period;
| xref:bsl/strtoull.adoc[`strtoull`] 
| Alias for `std&colon;&colon;strtoull` in the `bsl` namespace&period;
| xref:bsl/strtoumax.adoc[`strtoumax`] 
| Alias for `std&colon;&colon;strtoumax` in the `bsl` namespace&period;
| xref:bsl/strxfrm.adoc[`strxfrm`] 
| Alias for `std&colon;&colon;strxfrm` in the `bsl` namespace&period;
| xref:bsl/student_t_distribution.adoc[`student&lowbar;t&lowbar;distribution`] 
| Alias for `std&colon;&colon;student&lowbar;t&lowbar;distribution` in the `bsl` namespace&period;
| xref:bsl/sub_match.adoc[`sub&lowbar;match`] 
| Alias for `std&colon;&colon;sub&lowbar;match` in the `bsl` namespace&period;
| xref:bsl/subtract_with_carry_engine.adoc[`subtract&lowbar;with&lowbar;carry&lowbar;engine`] 
| Alias for `std&colon;&colon;subtract&lowbar;with&lowbar;carry&lowbar;engine` in the `bsl` namespace&period;
| xref:bsl/suspend_always.adoc[`suspend&lowbar;always`] 
| Alias for `std&colon;&colon;suspend&lowbar;always` in the `bsl` namespace&period;
| xref:bsl/suspend_never.adoc[`suspend&lowbar;never`] 
| Alias for `std&colon;&colon;suspend&lowbar;never` in the `bsl` namespace&period;
| xref:bsl/swap-00b.adoc[`swap`] 
| Alias for `std&colon;&colon;swap` in the `bsl` namespace&period;
| xref:bsl/swap-00ea.adoc[`swap`] 
| Alias for `std&colon;&colon;swap` in the `bsl` namespace&period;
| xref:bsl/swap-011.adoc[`swap`] 
| Alias for `std&colon;&colon;swap` in the `bsl` namespace&period;
| xref:bsl/swap-049.adoc[`swap`] 
| Alias for `std&colon;&colon;swap` in the `bsl` namespace&period;
| xref:bsl/swap-058.adoc[`swap`] 
| Alias for `std&colon;&colon;swap` in the `bsl` namespace&period;
| xref:bsl/swap-074.adoc[`swap`] 
| Alias for `std&colon;&colon;swap` in the `bsl` namespace&period;
| xref:bsl/swap-07c.adoc[`swap`] 
| Alias for `std&colon;&colon;swap` in the `bsl` namespace&period;
| xref:bsl/swap-09f.adoc[`swap`] 
| Alias for `std&colon;&colon;swap` in the `bsl` namespace&period;
| xref:bsl/swap-0b4.adoc[`swap`] 
| Alias for `std&colon;&colon;swap` in the `bsl` namespace&period;
| xref:bsl/swap-0d8.adoc[`swap`] 
| Alias for `std&colon;&colon;swap` in the `bsl` namespace&period;
| xref:bsl/swap-0e5.adoc[`swap`] 
| Alias for `std&colon;&colon;swap` in the `bsl` namespace&period;
| xref:bsl/swap-08e.adoc[`swap`] 
| Alias for `std&colon;&colon;swap` in the `bsl` namespace&period;
| xref:bsl/swap-014.adoc[`swap`] 
| Alias for `std&colon;&colon;swap` in the `bsl` namespace&period;
| xref:bsl/swap-01a.adoc[`swap`] 
| Alias for `std&colon;&colon;swap` in the `bsl` namespace&period;
| xref:bsl/swap-07e.adoc[`swap`] 
| Alias for `std&colon;&colon;swap` in the `bsl` namespace&period;
| xref:bsl/swap-0c6.adoc[`swap`] 
| Alias for `std&colon;&colon;swap` in the `bsl` namespace&period;
| xref:bsl/swap-0ec.adoc[`swap`] 
| Alias for `std&colon;&colon;swap` in the `bsl` namespace&period;
| xref:bsl/swap-03f4.adoc[`swap`] 
| Alias for `std&colon;&colon;swap` in the `bsl` namespace&period;
| xref:bsl/swap-099.adoc[`swap`] 
| Alias for `std&colon;&colon;swap` in the `bsl` namespace&period;
| xref:bsl/swap-0de.adoc[`swap`] 
| Alias for `std&colon;&colon;swap` in the `bsl` namespace&period;
| xref:bsl/swap-000.adoc[`swap`] 
| Alias for `std&colon;&colon;swap` in the `bsl` namespace&period;
| xref:bsl/swap-005.adoc[`swap`] 
| Alias for `std&colon;&colon;swap` in the `bsl` namespace&period;
| xref:bsl/swap-00ef.adoc[`swap`] 
| Alias for `std&colon;&colon;swap` in the `bsl` namespace&period;
| xref:bsl/swap-037.adoc[`swap`] 
| Alias for `std&colon;&colon;swap` in the `bsl` namespace&period;
| xref:bsl/swap-05cf.adoc[`swap`] 
| Alias for `std&colon;&colon;swap` in the `bsl` namespace&period;
| xref:bsl/swap-06b.adoc[`swap`] 
| Alias for `std&colon;&colon;swap` in the `bsl` namespace&period;
| xref:bsl/swap-083.adoc[`swap`] 
| Alias for `std&colon;&colon;swap` in the `bsl` namespace&period;
| xref:bsl/swap-0a2.adoc[`swap`] 
| Alias for `std&colon;&colon;swap` in the `bsl` namespace&period;
| xref:bsl/swap-0e8.adoc[`swap`] 
| Alias for `std&colon;&colon;swap` in the `bsl` namespace&period;
| xref:bsl/swap-0eb9.adoc[`swap`] 
| Alias for `std&colon;&colon;swap` in the `bsl` namespace&period;
| xref:bsl/swap-0f0b.adoc[`swap`] 
| Alias for `std&colon;&colon;swap` in the `bsl` namespace&period;
| xref:bsl/swap-0fe.adoc[`swap`] 
| Alias for `std&colon;&colon;swap` in the `bsl` namespace&period;
| xref:bsl/swap-021.adoc[`swap`] 
| Alias for `std&colon;&colon;swap` in the `bsl` namespace&period;
| xref:bsl/swap-03dc.adoc[`swap`] 
| Alias for `std&colon;&colon;swap` in the `bsl` namespace&period;
| xref:bsl/swap-0445.adoc[`swap`] 
| Alias for `std&colon;&colon;swap` in the `bsl` namespace&period;
| xref:bsl/swap-05c5.adoc[`swap`] 
| Alias for `std&colon;&colon;swap` in the `bsl` namespace&period;
| xref:bsl/swap-08f.adoc[`swap`] 
| Alias for `std&colon;&colon;swap` in the `bsl` namespace&period;
| xref:bsl/swap-0f00.adoc[`swap`] 
| Alias for `std&colon;&colon;swap` in the `bsl` namespace&period;
| xref:bsl/swap-0f49.adoc[`swap`] 
| Alias for `std&colon;&colon;swap` in the `bsl` namespace&period;
| xref:bsl/swap-0f4d.adoc[`swap`] 
| Alias for `std&colon;&colon;swap` in the `bsl` namespace&period;
| xref:bsl/swap_ranges.adoc[`swap&lowbar;ranges`] 
| Alias for `std&colon;&colon;swap&lowbar;ranges` in the `bsl` namespace&period;
| xref:bsl/swappable.adoc[`swappable`] 
| Alias for `std&colon;&colon;swappable` in the `bsl` namespace&period;
| xref:bsl/swappable_with.adoc[`swappable&lowbar;with`] 
| Alias for `std&colon;&colon;swappable&lowbar;with` in the `bsl` namespace&period;
| xref:bsl/swprintf.adoc[`swprintf`] 
| Alias for `std&colon;&colon;swprintf` in the `bsl` namespace&period;
| xref:bsl/swscanf.adoc[`swscanf`] 
| Alias for `std&colon;&colon;swscanf` in the `bsl` namespace&period;
| xref:bsl/system.adoc[`system`] 
| Alias for `std&colon;&colon;system` in the `bsl` namespace&period;
| xref:bsl/system_category.adoc[`system&lowbar;category`] 
| Alias for `std&colon;&colon;system&lowbar;category` in the `bsl` namespace&period;
| xref:bsl/system_error.adoc[`system&lowbar;error`] 
| Alias for `std&colon;&colon;system&lowbar;error` in the `bsl` namespace&period;
| xref:bsl/tan-03f.adoc[`tan`] 
| Alias for `std&colon;&colon;tan` in the `bsl` namespace&period;
| xref:bsl/tan-036.adoc[`tan`] 
| Alias for `std&colon;&colon;tan` in the `bsl` namespace&period;
| xref:bsl/tanh-0f.adoc[`tanh`] 
| Alias for `std&colon;&colon;tanh` in the `bsl` namespace&period;
| xref:bsl/tanh-08.adoc[`tanh`] 
| Alias for `std&colon;&colon;tanh` in the `bsl` namespace&period;
| xref:bsl/tanh-09.adoc[`tanh`] 
| Alias for `std&colon;&colon;tanh` in the `bsl` namespace&period;
| xref:bsl/tera.adoc[`tera`] 
| Alias for `std&colon;&colon;tera`&period;
| xref:bsl/terminate.adoc[`terminate`] 
| Undocumented symbol&period;
| xref:bsl/terminate_handler.adoc[`terminate&lowbar;handler`] 
| Alias for `std&colon;&colon;terminate&lowbar;handler` in the `bsl` namespace&period;
| xref:bsl/tgamma.adoc[`tgamma`] 
| Alias for `std&colon;&colon;tgamma` in the `bsl` namespace&period;
| xref:bsl/thread.adoc[`thread`] 
| Alias for `std&colon;&colon;thread` in the `bsl` namespace&period;
| xref:bsl/three_way_comparable.adoc[`three&lowbar;way&lowbar;comparable`] 
| Alias for `std&colon;&colon;three&lowbar;way&lowbar;comparable` in the `bsl` namespace&period;
| xref:bsl/three_way_comparable_with.adoc[`three&lowbar;way&lowbar;comparable&lowbar;with`] 
| Alias for `std&colon;&colon;three&lowbar;way&lowbar;comparable&lowbar;with` in the `bsl` namespace&period;
| xref:bsl/throw_with_nested.adoc[`throw&lowbar;with&lowbar;nested`] 
| Undocumented symbol&period;
| xref:bsl/tie.adoc[`tie`] 
| Alias for `std&colon;&colon;tie` in the `bsl` namespace&period;
| xref:bsl/time.adoc[`time`] 
| Alias for `std&colon;&colon;time` in the `bsl` namespace&period;
| xref:bsl/time_base.adoc[`time&lowbar;base`] 
| Alias for `std&colon;&colon;time&lowbar;base` in the `bsl` namespace&period;
| xref:bsl/time_get.adoc[`time&lowbar;get`] 
| Alias for `std&colon;&colon;time&lowbar;get` in the `bsl` namespace&period;
| xref:bsl/time_get_byname.adoc[`time&lowbar;get&lowbar;byname`] 
| Alias for `std&colon;&colon;time&lowbar;get&lowbar;byname` in the `bsl` namespace&period;
| xref:bsl/time_put.adoc[`time&lowbar;put`] 
| Alias for `std&colon;&colon;time&lowbar;put` in the `bsl` namespace&period;
| xref:bsl/time_put_byname.adoc[`time&lowbar;put&lowbar;byname`] 
| Alias for `std&colon;&colon;time&lowbar;put&lowbar;byname` in the `bsl` namespace&period;
| xref:bsl/time_t.adoc[`time&lowbar;t`] 
| Alias for `std&colon;&colon;time&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/timed_mutex.adoc[`timed&lowbar;mutex`] 
| Alias for `std&colon;&colon;timed&lowbar;mutex` in the `bsl` namespace&period;
| xref:bsl/timespec.adoc[`timespec`] 
| Alias for `std&colon;&colon;timespec` in the `bsl` namespace&period;
| xref:bsl/timespec_get.adoc[`timespec&lowbar;get`] 
| Alias for `std&colon;&colon;timespec&lowbar;get` in the `bsl` namespace&period;
| xref:bsl/tm.adoc[`tm`] 
| Alias for `std&colon;&colon;tm` in the `bsl` namespace&period;
| xref:bsl/tmpfile.adoc[`tmpfile`] 
| Alias for `std&colon;&colon;tmpfile` in the `bsl` namespace&period;
| xref:bsl/tmpnam.adoc[`tmpnam`] 
| Alias for `std&colon;&colon;tmpnam` in the `bsl` namespace&period;
| xref:bsl/to_address.adoc[`to&lowbar;address`] 
| Alias for `std&colon;&colon;to&lowbar;address` in the `bsl` namespace&period;
| xref:bsl/to_array.adoc[`to&lowbar;array`] 
| Alias for `std&colon;&colon;to&lowbar;array` in the `bsl` namespace&period;
| xref:bsl/to_chars.adoc[`to&lowbar;chars`] 
| 
| xref:bsl/to_chars_result.adoc[`to&lowbar;chars&lowbar;result`] 
| 
| xref:bsl/to_underlying.adoc[`to&lowbar;underlying`] 
| Alias for `std&colon;&colon;to&lowbar;underlying` in the `bsl` namespace&period;
| xref:bsl/tolower-00.adoc[`tolower`] 
| Alias for `std&colon;&colon;tolower` in the `bsl` namespace&period;
| xref:bsl/tolower-02.adoc[`tolower`] 
| Alias for `std&colon;&colon;tolower` in the `bsl` namespace&period;
| xref:bsl/totally_ordered.adoc[`totally&lowbar;ordered`] 
| Alias for `std&colon;&colon;totally&lowbar;ordered` in the `bsl` namespace&period;
| xref:bsl/totally_ordered_with.adoc[`totally&lowbar;ordered&lowbar;with`] 
| Alias for `std&colon;&colon;totally&lowbar;ordered&lowbar;with` in the `bsl` namespace&period;
| xref:bsl/toupper-0e.adoc[`toupper`] 
| Alias for `std&colon;&colon;toupper` in the `bsl` namespace&period;
| xref:bsl/toupper-0f.adoc[`toupper`] 
| Alias for `std&colon;&colon;toupper` in the `bsl` namespace&period;
| xref:bsl/towctrans.adoc[`towctrans`] 
| Alias for `std&colon;&colon;towctrans` in the `bsl` namespace&period;
| xref:bsl/towlower.adoc[`towlower`] 
| Alias for `std&colon;&colon;towlower` in the `bsl` namespace&period;
| xref:bsl/towupper.adoc[`towupper`] 
| Alias for `std&colon;&colon;towupper` in the `bsl` namespace&period;
| xref:bsl/transform.adoc[`transform`] 
| Alias for `std&colon;&colon;transform` in the `bsl` namespace&period;
| xref:bsl/transform_exclusive_scan.adoc[`transform&lowbar;exclusive&lowbar;scan`] 
| Alias for `std&colon;&colon;transform&lowbar;exclusive&lowbar;scan` in the `bsl` namespace&period;
| xref:bsl/transform_inclusive_scan.adoc[`transform&lowbar;inclusive&lowbar;scan`] 
| Alias for `std&colon;&colon;transform&lowbar;inclusive&lowbar;scan` in the `bsl` namespace&period;
| xref:bsl/transform_reduce.adoc[`transform&lowbar;reduce`] 
| Alias for `std&colon;&colon;transform&lowbar;reduce` in the `bsl` namespace&period;
| xref:bsl/trunc.adoc[`trunc`] 
| Alias for `std&colon;&colon;trunc` in the `bsl` namespace&period;
| xref:bsl/try_lock.adoc[`try&lowbar;lock`] 
| Alias for `std&colon;&colon;try&lowbar;lock` in the `bsl` namespace&period;
| xref:bsl/try_to_lock.adoc[`try&lowbar;to&lowbar;lock`] 
| Alias for `std&colon;&colon;try&lowbar;to&lowbar;lock` in the `bsl` namespace&period;
| xref:bsl/try_to_lock_t.adoc[`try&lowbar;to&lowbar;lock&lowbar;t`] 
| Alias for `std&colon;&colon;try&lowbar;to&lowbar;lock&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/tuple.adoc[`tuple`] 
| Alias for `std&colon;&colon;tuple` in the `bsl` namespace&period;
| xref:bsl/tuple_cat.adoc[`tuple&lowbar;cat`] 
| Alias for `std&colon;&colon;tuple&lowbar;cat` in the `bsl` namespace&period;
| xref:bsl/tuple_element.adoc[`tuple&lowbar;element`] 
| Alias for `std&colon;&colon;tuple&lowbar;element` in the `bsl` namespace&period;
| xref:bsl/tuple_size.adoc[`tuple&lowbar;size`] 
| Alias for `std&colon;&colon;tuple&lowbar;size` in the `bsl` namespace&period;
| xref:bsl/tuple_size_v.adoc[`tuple&lowbar;size&lowbar;v`] 
| Alias for `std&colon;&colon;tuple&lowbar;size&lowbar;v` in the `bsl` namespace&period;
| xref:bsl/type_identity.adoc[`type&lowbar;identity`] 
| Alias for `std&colon;&colon;type&lowbar;identity` in the `bsl` namespace&period;
| xref:bsl/type_identity_t.adoc[`type&lowbar;identity&lowbar;t`] 
| Alias for `std&colon;&colon;type&lowbar;identity&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/type_info.adoc[`type&lowbar;info`] 
| Alias for `std&colon;&colon;type&lowbar;info` in the `bsl` namespace&period;
| xref:bsl/u16streampos.adoc[`u16streampos`] 
| Alias for `std&colon;&colon;u16streampos` in the `bsl` namespace&period;
| xref:bsl/u16string_view.adoc[`u16string&lowbar;view`] 
| Alias for `std&colon;&colon;u16string&lowbar;view` in the `bsl` namespace&period;
| xref:bsl/u32streampos.adoc[`u32streampos`] 
| Alias for `std&colon;&colon;u32streampos` in the `bsl` namespace&period;
| xref:bsl/u32string_view.adoc[`u32string&lowbar;view`] 
| Alias for `std&colon;&colon;u32string&lowbar;view` in the `bsl` namespace&period;
| xref:bsl/u8streampos.adoc[`u8streampos`] 
| Alias for `std&colon;&colon;u8streampos` in the `bsl` namespace&period;
| xref:bsl/u8string_view.adoc[`u8string&lowbar;view`] 
| Alias for `std&colon;&colon;u8string&lowbar;view` in the `bsl` namespace&period;
| xref:bsl/uint16_t.adoc[`uint16&lowbar;t`] 
| Alias for `&colon;&colon;uint16&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/uint32_t.adoc[`uint32&lowbar;t`] 
| Alias for `&colon;&colon;uint32&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/uint64_t.adoc[`uint64&lowbar;t`] 
| Alias for `&colon;&colon;uint64&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/uint8_t.adoc[`uint8&lowbar;t`] 
| Alias for `&colon;&colon;uint8&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/uint_fast16_t.adoc[`uint&lowbar;fast16&lowbar;t`] 
| Alias for `&colon;&colon;uint&lowbar;fast16&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/uint_fast32_t.adoc[`uint&lowbar;fast32&lowbar;t`] 
| Alias for `&colon;&colon;uint&lowbar;fast32&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/uint_fast64_t.adoc[`uint&lowbar;fast64&lowbar;t`] 
| Alias for `&colon;&colon;uint&lowbar;fast64&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/uint_fast8_t.adoc[`uint&lowbar;fast8&lowbar;t`] 
| Alias for `&colon;&colon;uint&lowbar;fast8&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/uint_least16_t.adoc[`uint&lowbar;least16&lowbar;t`] 
| Alias for `&colon;&colon;uint&lowbar;least16&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/uint_least32_t.adoc[`uint&lowbar;least32&lowbar;t`] 
| Alias for `&colon;&colon;uint&lowbar;least32&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/uint_least64_t.adoc[`uint&lowbar;least64&lowbar;t`] 
| Alias for `&colon;&colon;uint&lowbar;least64&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/uint_least8_t.adoc[`uint&lowbar;least8&lowbar;t`] 
| Alias for `&colon;&colon;uint&lowbar;least8&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/uintmax_t.adoc[`uintmax&lowbar;t`] 
| Alias for `&colon;&colon;uintmax&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/uintptr_t.adoc[`uintptr&lowbar;t`] 
| Alias for `&colon;&colon;uintptr&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/unary_function.adoc[`unary&lowbar;function`] 
| Alias for `std&colon;&colon;unary&lowbar;function` in the `bsl` namespace&period;
| xref:bsl/unary_negate.adoc[`unary&lowbar;negate`] 
| Alias for `std&colon;&colon;unary&lowbar;negate` in the `bsl` namespace&period;
| xref:bsl/uncaught_exception.adoc[`uncaught&lowbar;exception`] 
| 
| xref:bsl/uncaught_exceptions.adoc[`uncaught&lowbar;exceptions`] 
| Alias for `std&colon;&colon;uncaught&lowbar;exceptions` in the `bsl` namespace&period;
| xref:bsl/underflow_error.adoc[`underflow&lowbar;error`] 
| Alias for `std&colon;&colon;underflow&lowbar;error` in the `bsl` namespace&period;
| xref:bsl/underlying_type.adoc[`underlying&lowbar;type`] 
| Alias for `std&colon;&colon;underlying&lowbar;type` in the `bsl` namespace&period;
| xref:bsl/ungetc.adoc[`ungetc`] 
| Alias for `std&colon;&colon;ungetc` in the `bsl` namespace&period;
| xref:bsl/ungetwc.adoc[`ungetwc`] 
| Alias for `std&colon;&colon;ungetwc` in the `bsl` namespace&period;
| xref:bsl/uniform_int_distribution.adoc[`uniform&lowbar;int&lowbar;distribution`] 
| Alias for `std&colon;&colon;uniform&lowbar;int&lowbar;distribution` in the `bsl` namespace&period;
| xref:bsl/uniform_real_distribution.adoc[`uniform&lowbar;real&lowbar;distribution`] 
| Alias for `std&colon;&colon;uniform&lowbar;real&lowbar;distribution` in the `bsl` namespace&period;
| xref:bsl/uninitialized_copy.adoc[`uninitialized&lowbar;copy`] 
| Alias for `std&colon;&colon;uninitialized&lowbar;copy` in the `bsl` namespace&period;
| xref:bsl/uninitialized_copy_n.adoc[`uninitialized&lowbar;copy&lowbar;n`] 
| Alias for `std&colon;&colon;uninitialized&lowbar;copy&lowbar;n` in the `bsl` namespace&period;
| xref:bsl/uninitialized_default_construct.adoc[`uninitialized&lowbar;default&lowbar;construct`] 
| Alias for `std&colon;&colon;uninitialized&lowbar;default&lowbar;construct` in the `bsl` namespace&period;
| xref:bsl/uninitialized_default_construct_n.adoc[`uninitialized&lowbar;default&lowbar;construct&lowbar;n`] 
| Alias for `std&colon;&colon;uninitialized&lowbar;default&lowbar;construct&lowbar;n` in the `bsl` namespace&period;
| xref:bsl/uninitialized_fill.adoc[`uninitialized&lowbar;fill`] 
| Alias for `std&colon;&colon;uninitialized&lowbar;fill` in the `bsl` namespace&period;
| xref:bsl/uninitialized_fill_n.adoc[`uninitialized&lowbar;fill&lowbar;n`] 
| Alias for `std&colon;&colon;uninitialized&lowbar;fill&lowbar;n` in the `bsl` namespace&period;
| xref:bsl/uninitialized_move.adoc[`uninitialized&lowbar;move`] 
| Alias for `std&colon;&colon;uninitialized&lowbar;move` in the `bsl` namespace&period;
| xref:bsl/uninitialized_move_n.adoc[`uninitialized&lowbar;move&lowbar;n`] 
| Alias for `std&colon;&colon;uninitialized&lowbar;move&lowbar;n` in the `bsl` namespace&period;
| xref:bsl/uninitialized_value_construct.adoc[`uninitialized&lowbar;value&lowbar;construct`] 
| Alias for `std&colon;&colon;uninitialized&lowbar;value&lowbar;construct` in the `bsl` namespace&period;
| xref:bsl/uninitialized_value_construct_n.adoc[`uninitialized&lowbar;value&lowbar;construct&lowbar;n`] 
| Alias for `std&colon;&colon;uninitialized&lowbar;value&lowbar;construct&lowbar;n` in the `bsl` namespace&period;
| xref:bsl/unique.adoc[`unique`] 
| Alias for `std&colon;&colon;unique` in the `bsl` namespace&period;
| xref:bsl/unique_copy.adoc[`unique&lowbar;copy`] 
| Alias for `std&colon;&colon;unique&lowbar;copy` in the `bsl` namespace&period;
| xref:bsl/unique_lock.adoc[`unique&lowbar;lock`] 
| Alias for `std&colon;&colon;unique&lowbar;lock` in the `bsl` namespace&period;
| xref:bsl/unique_ptr.adoc[`unique&lowbar;ptr`] 
| Alias for `std&colon;&colon;unique&lowbar;ptr` in the `bsl` namespace&period;
| xref:bsl/unitbuf.adoc[`unitbuf`] 
| Alias for `std&colon;&colon;unitbuf` in the `bsl` namespace&period;
| xref:bsl/unreachable.adoc[`unreachable`] 
| Alias for `std&colon;&colon;unreachable` in the `bsl` namespace&period;
| xref:bsl/unreachable_sentinel_t.adoc[`unreachable&lowbar;sentinel&lowbar;t`] 
| Alias for `std&colon;&colon;unreachable&lowbar;sentinel&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/unsigned_integral.adoc[`unsigned&lowbar;integral`] 
| Alias for `std&colon;&colon;unsigned&lowbar;integral` in the `bsl` namespace&period;
| xref:bsl/unwrap_ref_decay.adoc[`unwrap&lowbar;ref&lowbar;decay`] 
| Alias for `std&colon;&colon;unwrap&lowbar;ref&lowbar;decay` in the `bsl` namespace&period;
| xref:bsl/unwrap_ref_decay_t.adoc[`unwrap&lowbar;ref&lowbar;decay&lowbar;t`] 
| Alias for `std&colon;&colon;unwrap&lowbar;ref&lowbar;decay&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/unwrap_reference.adoc[`unwrap&lowbar;reference`] 
| Alias for `std&colon;&colon;unwrap&lowbar;reference` in the `bsl` namespace&period;
| xref:bsl/unwrap_reference_t.adoc[`unwrap&lowbar;reference&lowbar;t`] 
| Alias for `std&colon;&colon;unwrap&lowbar;reference&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/upper_bound.adoc[`upper&lowbar;bound`] 
| Alias for `std&colon;&colon;upper&lowbar;bound` in the `bsl` namespace&period;
| xref:bsl/uppercase.adoc[`uppercase`] 
| Alias for `std&colon;&colon;uppercase` in the `bsl` namespace&period;
| xref:bsl/use_facet.adoc[`use&lowbar;facet`] 
| Alias for `std&colon;&colon;use&lowbar;facet` in the `bsl` namespace&period;
| xref:bsl/va_list.adoc[`va&lowbar;list`] 
| Import `std&colon;&colon;va&lowbar;list` into namespace `bsl`&period;
| xref:bsl/valarray.adoc[`valarray`] 
| Alias for `std&colon;&colon;valarray` in the `bsl` namespace&period;
| xref:bsl/vformat_to-06.adoc[`vformat&lowbar;to`] 
| Alias for `std&colon;&colon;vformat&lowbar;to` in the `bsl` namespace&period;
| xref:bsl/vfprintf.adoc[`vfprintf`] 
| Alias for `std&colon;&colon;vfprintf` in the `bsl` namespace&period;
| xref:bsl/vfscanf.adoc[`vfscanf`] 
| Alias for `std&colon;&colon;vfscanf` in the `bsl` namespace&period;
| xref:bsl/vfwprintf.adoc[`vfwprintf`] 
| Alias for `std&colon;&colon;vfwprintf` in the `bsl` namespace&period;
| xref:bsl/vfwscanf.adoc[`vfwscanf`] 
| Alias for `std&colon;&colon;vfwscanf` in the `bsl` namespace&period;
| xref:bsl/visit_format_arg.adoc[`visit&lowbar;format&lowbar;arg`] 
| Alias for `std&colon;&colon;visit&lowbar;format&lowbar;arg` in the `bsl` namespace&period;
| xref:bsl/vprint_nonunicode-0d.adoc[`vprint&lowbar;nonunicode`] 
| Alias for `BloombergLP&colon;&colon;bslfmt&colon;&colon;vprint&lowbar;nonunicode` in the `bsl` namespace&period;
| xref:bsl/vprint_nonunicode-0b.adoc[`vprint&lowbar;nonunicode`] 
| Alias for `BloombergLP&colon;&colon;bslfmt&colon;&colon;vprint&lowbar;nonunicode` in the `bsl` namespace&period;
| xref:bsl/vprint_nonunicode_buffered.adoc[`vprint&lowbar;nonunicode&lowbar;buffered`] 
| Alias for `BloombergLP&colon;&colon;bslfmt&colon;&colon;vprint&lowbar;nonunicode&lowbar;buffered` in the `bsl` namespace&period;
| xref:bsl/vprint_unicode-01.adoc[`vprint&lowbar;unicode`] 
| Alias for `BloombergLP&colon;&colon;bslfmt&colon;&colon;vprint&lowbar;unicode` in the `bsl` namespace&period;
| xref:bsl/vprint_unicode-07.adoc[`vprint&lowbar;unicode`] 
| Alias for `BloombergLP&colon;&colon;bslfmt&colon;&colon;vprint&lowbar;unicode` in the `bsl` namespace&period;
| xref:bsl/vprint_unicode_buffered.adoc[`vprint&lowbar;unicode&lowbar;buffered`] 
| Alias for `BloombergLP&colon;&colon;bslfmt&colon;&colon;vprint&lowbar;unicode&lowbar;buffered` in the `bsl` namespace&period;
| xref:bsl/vprintf.adoc[`vprintf`] 
| Alias for `std&colon;&colon;vprintf` in the `bsl` namespace&period;
| xref:bsl/vscanf.adoc[`vscanf`] 
| Alias for `std&colon;&colon;vscanf` in the `bsl` namespace&period;
| xref:bsl/vsnprintf.adoc[`vsnprintf`] 
| Alias for `std&colon;&colon;vsnprintf` in the `bsl` namespace&period;
| xref:bsl/vsprintf.adoc[`vsprintf`] 
| Alias for `std&colon;&colon;vsprintf` in the `bsl` namespace&period;
| xref:bsl/vsscanf.adoc[`vsscanf`] 
| Alias for `std&colon;&colon;vsscanf` in the `bsl` namespace&period;
| xref:bsl/vswprintf.adoc[`vswprintf`] 
| Alias for `std&colon;&colon;vswprintf` in the `bsl` namespace&period;
| xref:bsl/vswscanf.adoc[`vswscanf`] 
| Alias for `std&colon;&colon;vswscanf` in the `bsl` namespace&period;
| xref:bsl/vwprintf.adoc[`vwprintf`] 
| Alias for `std&colon;&colon;vwprintf` in the `bsl` namespace&period;
| xref:bsl/vwscanf.adoc[`vwscanf`] 
| Alias for `std&colon;&colon;vwscanf` in the `bsl` namespace&period;
| xref:bsl/wbuffer_convert.adoc[`wbuffer&lowbar;convert`] 
| Alias for `std&colon;&colon;wbuffer&lowbar;convert` in the `bsl` namespace&period;
| xref:bsl/wcerr.adoc[`wcerr`] 
| Alias for `std&colon;&colon;wcerr` in the `bsl` namespace&period;
| xref:bsl/wcin.adoc[`wcin`] 
| Alias for `std&colon;&colon;wcin` in the `bsl` namespace&period;
| xref:bsl/wclog.adoc[`wclog`] 
| Alias for `std&colon;&colon;wclog` in the `bsl` namespace&period;
| xref:bsl/wcmatch.adoc[`wcmatch`] 
| Alias for `std&colon;&colon;wcmatch` in the `bsl` namespace&period;
| xref:bsl/wcout.adoc[`wcout`] 
| Alias for `std&colon;&colon;wcout` in the `bsl` namespace&period;
| xref:bsl/wcregex_iterator.adoc[`wcregex&lowbar;iterator`] 
| Alias for `std&colon;&colon;wcregex&lowbar;iterator` in the `bsl` namespace&period;
| xref:bsl/wcrtomb.adoc[`wcrtomb`] 
| Alias for `std&colon;&colon;wcrtomb` in the `bsl` namespace&period;
| xref:bsl/wcscat.adoc[`wcscat`] 
| Alias for `std&colon;&colon;wcscat` in the `bsl` namespace&period;
| xref:bsl/wcschr.adoc[`wcschr`] 
| Alias for `std&colon;&colon;wcschr` in the `bsl` namespace&period;
| xref:bsl/wcscmp.adoc[`wcscmp`] 
| Alias for `std&colon;&colon;wcscmp` in the `bsl` namespace&period;
| xref:bsl/wcscoll.adoc[`wcscoll`] 
| Alias for `std&colon;&colon;wcscoll` in the `bsl` namespace&period;
| xref:bsl/wcscpy.adoc[`wcscpy`] 
| Alias for `std&colon;&colon;wcscpy` in the `bsl` namespace&period;
| xref:bsl/wcscspn.adoc[`wcscspn`] 
| Alias for `std&colon;&colon;wcscspn` in the `bsl` namespace&period;
| xref:bsl/wcsftime.adoc[`wcsftime`] 
| Alias for `std&colon;&colon;wcsftime` in the `bsl` namespace&period;
| xref:bsl/wcslen.adoc[`wcslen`] 
| Alias for `std&colon;&colon;wcslen` in the `bsl` namespace&period;
| xref:bsl/wcsncat.adoc[`wcsncat`] 
| Alias for `std&colon;&colon;wcsncat` in the `bsl` namespace&period;
| xref:bsl/wcsncmp.adoc[`wcsncmp`] 
| Alias for `std&colon;&colon;wcsncmp` in the `bsl` namespace&period;
| xref:bsl/wcsncpy.adoc[`wcsncpy`] 
| Alias for `std&colon;&colon;wcsncpy` in the `bsl` namespace&period;
| xref:bsl/wcspbrk.adoc[`wcspbrk`] 
| Alias for `std&colon;&colon;wcspbrk` in the `bsl` namespace&period;
| xref:bsl/wcsrchr.adoc[`wcsrchr`] 
| Alias for `std&colon;&colon;wcsrchr` in the `bsl` namespace&period;
| xref:bsl/wcsrtombs.adoc[`wcsrtombs`] 
| Alias for `std&colon;&colon;wcsrtombs` in the `bsl` namespace&period;
| xref:bsl/wcsspn.adoc[`wcsspn`] 
| Alias for `std&colon;&colon;wcsspn` in the `bsl` namespace&period;
| xref:bsl/wcsstr.adoc[`wcsstr`] 
| Alias for `std&colon;&colon;wcsstr` in the `bsl` namespace&period;
| xref:bsl/wcstod.adoc[`wcstod`] 
| Alias for `std&colon;&colon;wcstod` in the `bsl` namespace&period;
| xref:bsl/wcstof.adoc[`wcstof`] 
| Alias for `std&colon;&colon;wcstof` in the `bsl` namespace&period;
| xref:bsl/wcstoimax.adoc[`wcstoimax`] 
| Alias for `std&colon;&colon;wcstoimax` in the `bsl` namespace&period;
| xref:bsl/wcstok.adoc[`wcstok`] 
| Alias for `std&colon;&colon;wcstok` in the `bsl` namespace&period;
| xref:bsl/wcstol.adoc[`wcstol`] 
| Alias for `std&colon;&colon;wcstol` in the `bsl` namespace&period;
| xref:bsl/wcstold.adoc[`wcstold`] 
| Alias for `std&colon;&colon;wcstold` in the `bsl` namespace&period;
| xref:bsl/wcstoll.adoc[`wcstoll`] 
| Alias for `std&colon;&colon;wcstoll` in the `bsl` namespace&period;
| xref:bsl/wcstombs.adoc[`wcstombs`] 
| Alias for `std&colon;&colon;wcstombs` in the `bsl` namespace&period;
| xref:bsl/wcstoul.adoc[`wcstoul`] 
| Alias for `std&colon;&colon;wcstoul` in the `bsl` namespace&period;
| xref:bsl/wcstoull.adoc[`wcstoull`] 
| Alias for `std&colon;&colon;wcstoull` in the `bsl` namespace&period;
| xref:bsl/wcstoumax.adoc[`wcstoumax`] 
| Alias for `std&colon;&colon;wcstoumax` in the `bsl` namespace&period;
| xref:bsl/wcsub_match.adoc[`wcsub&lowbar;match`] 
| Alias for `std&colon;&colon;wcsub&lowbar;match` in the `bsl` namespace&period;
| xref:bsl/wcsxfrm.adoc[`wcsxfrm`] 
| Alias for `std&colon;&colon;wcsxfrm` in the `bsl` namespace&period;
| xref:bsl/wctob.adoc[`wctob`] 
| Alias for `std&colon;&colon;wctob` in the `bsl` namespace&period;
| xref:bsl/wctomb.adoc[`wctomb`] 
| Alias for `std&colon;&colon;wctomb` in the `bsl` namespace&period;
| xref:bsl/wctrans.adoc[`wctrans`] 
| Alias for `std&colon;&colon;wctrans` in the `bsl` namespace&period;
| xref:bsl/wctrans_t.adoc[`wctrans&lowbar;t`] 
| Alias for `std&colon;&colon;wctrans&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/wctype.adoc[`wctype`] 
| Alias for `std&colon;&colon;wctype` in the `bsl` namespace&period;
| xref:bsl/wctype_t.adoc[`wctype&lowbar;t`] 
| Alias for `std&colon;&colon;wctype&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/weak_order.adoc[`weak&lowbar;order`] 
| Alias for `std&colon;&colon;weak&lowbar;order` in the `bsl` namespace&period;
| xref:bsl/weak_ordering.adoc[`weak&lowbar;ordering`] 
| Alias for `std&colon;&colon;weak&lowbar;ordering` in the `bsl` namespace&period;
| xref:bsl/weakly_incrementable.adoc[`weakly&lowbar;incrementable`] 
| Alias for `std&colon;&colon;weakly&lowbar;incrementable` in the `bsl` namespace&period;
| xref:bsl/weibull_distribution.adoc[`weibull&lowbar;distribution`] 
| Alias for `std&colon;&colon;weibull&lowbar;distribution` in the `bsl` namespace&period;
| xref:bsl/wfilebuf.adoc[`wfilebuf`] 
| Alias for `std&colon;&colon;wfilebuf` in the `bsl` namespace&period;
| xref:bsl/wformat_args.adoc[`wformat&lowbar;args`] 
| Alias for `std&colon;&colon;wformat&lowbar;args` in the `bsl` namespace&period;
| xref:bsl/wformat_context.adoc[`wformat&lowbar;context`] 
| Alias for `std&colon;&colon;wformat&lowbar;context` in the `bsl` namespace&period;
| xref:bsl/wformat_parse_context.adoc[`wformat&lowbar;parse&lowbar;context`] 
| Alias for `std&colon;&colon;wformat&lowbar;parse&lowbar;context` in the `bsl` namespace&period;
| xref:bsl/wformat_string.adoc[`wformat&lowbar;string`] 
| Alias for `std&colon;&colon;wformat&lowbar;string` in the `bsl` namespace&period;
| xref:bsl/wfstream.adoc[`wfstream`] 
| Alias for `std&colon;&colon;wfstream` in the `bsl` namespace&period;
| xref:bsl/wifstream.adoc[`wifstream`] 
| Alias for `std&colon;&colon;wifstream` in the `bsl` namespace&period;
| xref:bsl/wint_t.adoc[`wint&lowbar;t`] 
| Alias for `std&colon;&colon;wint&lowbar;t` in the `bsl` namespace&period;
| xref:bsl/wios.adoc[`wios`] 
| Alias for `std&colon;&colon;wios` in the `bsl` namespace&period;
| xref:bsl/wiostream.adoc[`wiostream`] 
| Alias for `std&colon;&colon;wiostream` in the `bsl` namespace&period;
| xref:bsl/wispanstream.adoc[`wispanstream`] 
| Alias for `std&colon;&colon;wispanstream` in the `bsl` namespace&period;
| xref:bsl/wistream.adoc[`wistream`] 
| Alias for `std&colon;&colon;wistream` in the `bsl` namespace&period;
| xref:bsl/wmemchr.adoc[`wmemchr`] 
| Alias for `std&colon;&colon;wmemchr` in the `bsl` namespace&period;
| xref:bsl/wmemcmp.adoc[`wmemcmp`] 
| Alias for `std&colon;&colon;wmemcmp` in the `bsl` namespace&period;
| xref:bsl/wmemcpy.adoc[`wmemcpy`] 
| Alias for `std&colon;&colon;wmemcpy` in the `bsl` namespace&period;
| xref:bsl/wmemmove.adoc[`wmemmove`] 
| Alias for `std&colon;&colon;wmemmove` in the `bsl` namespace&period;
| xref:bsl/wmemset.adoc[`wmemset`] 
| Alias for `std&colon;&colon;wmemset` in the `bsl` namespace&period;
| xref:bsl/wofstream.adoc[`wofstream`] 
| Alias for `std&colon;&colon;wofstream` in the `bsl` namespace&period;
| xref:bsl/wospanstream.adoc[`wospanstream`] 
| Alias for `std&colon;&colon;wospanstream` in the `bsl` namespace&period;
| xref:bsl/wostream.adoc[`wostream`] 
| Alias for `std&colon;&colon;wostream` in the `bsl` namespace&period;
| xref:bsl/wprintf.adoc[`wprintf`] 
| Alias for `std&colon;&colon;wprintf` in the `bsl` namespace&period;
| xref:bsl/wregex.adoc[`wregex`] 
| Alias for `std&colon;&colon;wregex` in the `bsl` namespace&period;
| xref:bsl/ws.adoc[`ws`] 
| Alias for `std&colon;&colon;ws` in the `bsl` namespace&period;
| xref:bsl/wscanf.adoc[`wscanf`] 
| Alias for `std&colon;&colon;wscanf` in the `bsl` namespace&period;
| xref:bsl/wsmatch.adoc[`wsmatch`] 
| Alias for `std&colon;&colon;wsmatch` in the `bsl` namespace&period;
| xref:bsl/wspanbuf.adoc[`wspanbuf`] 
| Alias for `std&colon;&colon;wspanbuf` in the `bsl` namespace&period;
| xref:bsl/wspanstream.adoc[`wspanstream`] 
| Alias for `std&colon;&colon;wspanstream` in the `bsl` namespace&period;
| xref:bsl/wsregex_iterator.adoc[`wsregex&lowbar;iterator`] 
| Alias for `std&colon;&colon;wsregex&lowbar;iterator` in the `bsl` namespace&period;
| xref:bsl/wssub_match.adoc[`wssub&lowbar;match`] 
| Alias for `std&colon;&colon;wssub&lowbar;match` in the `bsl` namespace&period;
| xref:bsl/wstreambuf.adoc[`wstreambuf`] 
| Alias for `std&colon;&colon;wstreambuf` in the `bsl` namespace&period;
| xref:bsl/wstreampos.adoc[`wstreampos`] 
| Alias for `std&colon;&colon;wstreampos` in the `bsl` namespace&period;
| xref:bsl/wstring_convert.adoc[`wstring&lowbar;convert`] 
| Alias for `std&colon;&colon;wstring&lowbar;convert` in the `bsl` namespace&period;
| xref:bsl/wstring_view.adoc[`wstring&lowbar;view`] 
| Alias for `std&colon;&colon;wstring&lowbar;view` in the `bsl` namespace&period;
|===



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