[#bsl]
= bsl
:mrdocs:

Namespace containing forward declarations for standard stream classes.

== Namespaces

[cols="1,4"]
|===
| Name| Description
| xref:bsl/chrono.adoc[`chrono`] 
| Namespace for C++11 `chrono` facilities in the `bsl` package.
| xref:bsl/filesystem.adoc[`filesystem`] 
| Namespace for filesystem facilities equivalent to `std::filesystem`.
| xref:bsl/ranges.adoc[`ranges`] 
| Namespace for C++20 range access functions.
| xref:bsl/regex_constants.adoc[`regex_constants`] 
| Namespace for `std::regex_constants` symbols in the `bsl` namespace.
| xref:bsl/this_thread.adoc[`this_thread`] 
| Namespace for `std::this_thread` functionality in the `bsl` namespace.
|===


== Namespace Aliases

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


== Types

[cols="1,4"]
|===
| Name| Description
| xref:bsl/ComparatorSelector-061.adoc[`ComparatorSelector`] 
| This meta‐function selects the appropriate implementation for comparing the parameterized `TYPE`. This generic template uses the `std::equal_to` functor.
| xref:bsl/Deque_Base.adoc[`Deque_Base`] 
| This class describes the basic layout for a deque class. It is important that this class has the same layout as the deque class implementation. It is parameterized by `VALUE_TYPE` only and implements the portion of `bsl::deque` that does not need to know about its (template parameter) type `ALLOCATOR` (in order to generate shorter debug strings). Note that this class must have the same layout as `Deque_Imp` (see implementation file).
| xref:bsl/Deque_BlockCreator.adoc[`Deque_BlockCreator`] 
| This class allocates blocks at the front or back of a deque and tentatively adds them to the deque. It also keeps track of how many of the newly allocated blocks have actually been used by the deque. The destructor automatically frees any unused blocks (e.g., in case an exception is thrown).
| xref:bsl/Deque_BlockLengthCalcUtil.adoc[`Deque_BlockLengthCalcUtil`] 
| This `struct` provides a namespace for the calculation of block length (the number of elements per block within a `deque`). This ensures that each block in the deque can hold at least 16 elements.
| xref:bsl/Deque_BlockProctor.adoc[`Deque_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.e., front or back) of a proctored deque. The end at which empty blocks are to be proctored is indicated by a flag supplied at construction. See `emplace` for a use case.
| xref:bsl/Deque_ClearGuard.adoc[`Deque_ClearGuard`] 
| This class provides a proctor which, at destruction, calls `clear` on the deque supplied at construction, unless the guard has been released prior.
| xref:bsl/Deque_Guard.adoc[`Deque_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's range of valid elements; if the count is non‐zero at destruction, the destructor destroys the elements in the range `[d_deque_p‐>end() .. d_deque_p‐>end() + d_count)]`, or the range `[d_deque_p‐>begin() ‐ d_count .. d_deque_p‐>begin())]`, depending on whether this proctor guards the back or front. This guard is used to undo element constructors in the event of an exception. It is up to the client code to increment the count whenever a new element is constructed and to decrement the count whenever `d_start` or `d_finish` of the guarded deque is moved to incorporate more elements.
| xref:bsl/Deque_Util.adoc[`Deque_Util`] 
| This `struct` provides a namespace to implement the `swap` member function of `deque<VALUE_TYPE, ALLOCATOR>`. This function can be implemented irrespective of the `VALUE_TYPE` or `ALLOCATOR` template parameters, which is why we implement it in this non‐parameterized, non‐inlined utility.
| xref:bsl/FunctionDeductionHelper.adoc[`FunctionDeductionHelper`] 
| This struct provides a set of template `meta‐functions` that extract the signature of a class member function, stripping any qualifiers such as `const`, `noexcept` or `&`.
| xref:bsl/List_AllocAndSizeWrapper.adoc[`List_AllocAndSizeWrapper`] 
| This struct is a wrapper around the allocator and size data members of a `list`. It takes advantage of the empty‐base optimization (EBO) so that if the allocator is stateless, it takes up no space.
| xref:bsl/List_DefaultLessThan.adoc[`List_DefaultLessThan`] 
| Binary predicate type for comparing two `VALUE` objects using `operator<`. This operation is usually, but not always, the same as that provided by `std::less<VALUE>`. The standard requires that certain functions use `operator<`, which means that divergent specializations of `std::less` are to be ignored.
| xref:bsl/List_Iterator.adoc[`List_Iterator`] 
| 
| xref:bsl/List_Node.adoc[`List_Node`] 
| PRIVATE CLASS TEMPLATE. For use only by `bsl::list` implementation. An instance of `List_Node<T>` is a single node in a doubly‐linked list used to implement `bsl::list<T,A>`, for a given element type `T` and allocator type `A`. Note that an instantiation of this `class` for a given `bsl::list` is independent of the allocator type.
| xref:bsl/List_NodeProctor.adoc[`List_NodeProctor`] 
| This class provides a proctor to free a node containing an uninitialized `VALUE` object in the event that an exception is thrown.
| xref:bsl/Pair_BslmaIdiom.adoc[`Pair_BslmaIdiom`] 
| This component‐private meta‐function determines whether the specified `TYPE` template parameter takes a `bslma::Allocator*` 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::allocator_arg_t`. This type derived from `bsl::integral_constant<int, N>` where `N` is the number of additional parameters required to pass an allocator to a constructor using the chosen idiom.
| xref:bsl/Pair_ConstructionParametersPackLength.adoc[`Pair_ConstructionParametersPackLength`] 
| This component‐private component‐private meta‐function determines the number of elements in a tuple containing parameters for piecewise construction of a `bsl::pair` member having the specified `TYPE`. Result value depends on the `TYPE`, whether it takes a `bslma::Allocator*` constructor argument and, if so, whether that argument follows an argument of type `bsl::allocator_arg_t`.
| xref:bsl/Pair_First-00.adoc[`Pair_First`] 
| This component‐private `class` holds the `first` data member of a `pair` and constructs it appropriately. Note the partial specializations below for the cases that (template parameter) 'TYPE' is a reference.
| xref:bsl/Pair_Second-05e.adoc[`Pair_Second`] 
| This component‐private `class` holds the `second` data member of a `pair` and constructs it appropriately. Note the partial specializations below for the cases that (template parameter) 'TYPE' is a reference.
| xref:bsl/StringBufContainer.adoc[`StringBufContainer`] 
| This class enables the implementation of string‐stream types by providing a trivial type containing a `basic_stringbuf` that is suitable as a (`private`) base class for a string‐stream. Inheriting from `StringBufContainer` allows the string‐stream to ensure that the contained `basic_stringbuf` is initialized before initializing other base classes or data members without potentially overriding `virtual` methods in the `basic_stringbuf` type. Note that implementations of string‐stream types must pass the address of a string‐buffer to their `public` base class (e.g., `basic_stream`), so the string‐stream must ensure (using `private` inheritance) that the string‐buffer is initialized before constructing the `public` base class. If a string‐stream implementation were to directly inherit from `basic_streambuf`, then `virtual` methods defined in that string‐stream (e.g., `underflow`) might incorrectly override those in the `basic_stringbuf` implementation.
| xref:bsl/StringComparator.adoc[`StringComparator`] 
| This class is a functor that provides comparison between two `const char *` strings.
| xref:bsl/String_ClearProctor.adoc[`String_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's destruction. 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. Note that after constructing this proctor for a string `s`, the invariant `s[s.length()]== CHAR_TYPE()` is violated for non‐empty `s`. This invariant will be restored by either a successful `append` or by the proctor's destructor if an exception is thrown. Note that the template parameter was renamed from STRING_TYPE to FULL_STRING_TYPE due to a name clash with a define elsewhere in the code base (see DRQS 112049582).
| xref:bsl/String_ComparisonCategory-07.adoc[`String_ComparisonCategory`] 
| This meta‐function selects the comparison category type for `basic_string` with the specified `CHAR_TRAITS`.
| xref:bsl/SyncBuf_MutexUtil.adoc[`SyncBuf_MutexUtil`] 
| Internal mutex‐related utils.
| xref:bsl/Variant_VariantAlternativeImpl-06e.adoc[`Variant_VariantAlternativeImpl`] 
| This component‐private metafunction provides the implementation of `bsl::variant_alternative`.
| xref:bsl/Vector_DeduceIteratorCategory-0d.adoc[`Vector_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. By default, it is assumed that any type that is not a fundamental type, as determined by the type trait `bsl::is_fundamental`, must be an iterator type. `std::iterator_traits` is updated in C++17 to provide a SFINAE‐friendly instantiation of the primary‐template for types that do not provide all of the nested typedef names, but we cannot portably rely on such a scheme yet.
| xref:bsl/Vector_PushProctor.adoc[`Vector_PushProctor`] 
| This class template provides a proctor for a newly created object that is managed by an allocator. The object will be constructed through a call to `allocator_traits<ALLOCATOR>::construct`, and it should be destroyed by a call to `allocator_traits<ALLOCATOR>::destroy`. Note that this proctor takes no responsibility for the allocated memory that the supplied value is constructed in.
| xref:bsl/Vector_RangeIteratorCategory-09.adoc[`Vector_RangeIteratorCategory`] 
| This `struct` provides a primitive means to determine the iterator category for an iterator/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.
| xref:bsl/Vector_Util.adoc[`Vector_Util`] 
| This `struct` provides a namespace for implementing the `swap` member function of `vector<VALUE_TYPE, ALLOCATOR>`. `swap` can be implemented irrespective of the `VALUE_TYPE` or `ALLOCATOR` template parameters, which is why we implement it in this non‐parameterized, non‐inlined utility.
| xref:bsl/_Alloc_traits.adoc[`_Alloc_traits`] 
| Traits for rebinding STLPort allocators to a different value type.
| xref:bsl/_Const_traits.adoc[`_Const_traits`] 
| Iterator traits for `const` access to objects of type `_Tp`.
| xref:bsl/_Hashtable_iterator.adoc[`_Hashtable_iterator`] 
| 
| xref:bsl/_Hashtable_node.adoc[`_Hashtable_node`] 
| Internal hashtable node holding a value and a next‐node pointer.
| xref:bsl/_Ht_iterator.adoc[`_Ht_iterator`] 
| 
| xref:bsl/_Nonconst_traits.adoc[`_Nonconst_traits`] 
| Iterator traits for modifiable access to objects of type `_Tp`.
| xref:bsl/_STLP_alloc_proxy.adoc[`_STLP_alloc_proxy`] 
| Proxy combining an allocator with a stored value for STLPort containers.
| xref:bsl/_Sl_global.adoc[`_Sl_global`] 
| Shared algorithms for intrusive singly‐linked list node manipulation.
| xref:bsl/_Slist_base.adoc[`_Slist_base`] 
| Allocator‐aware base that owns the sentinel head node of an `slist`.
| xref:bsl/_Slist_iterator.adoc[`_Slist_iterator`] 
| Forward iterator over an `slist` of `_Tp` with constness from `_Traits`.
| xref:bsl/_Slist_iterator_base.adoc[`_Slist_iterator_base`] 
| Non‐templated base for forward iterators over an slist.
| xref:bsl/_Slist_node.adoc[`_Slist_node`] 
| Singly‐linked list node storing a value of type `_Tp`.
| xref:bsl/_Slist_node_base.adoc[`_Slist_node_base`] 
| Intrusive singly‐linked list node base holding a next pointer.
| xref:bsl/_Stl_prime.adoc[`_Stl_prime`] 
| Table of prime bucket counts used for hash table sizing.
| xref:bsl/add_const.adoc[`add_const`] 
| This `struct` template implements the `add_const` meta‐function defined in the C++11 standard [meta.trans.cv], providing an alias, `type`, that returns the result. If the (template parameter) `t_TYPE` is not a reference type, nor a function type, nor already `const`‐qualified at the top‐level, then `type` is an alias to `t_TYPE` with a top‐level `const`‐qualifier added; otherwise, `type` is an alias to `t_TYPE`.
| xref:bsl/add_cv.adoc[`add_cv`] 
| This `struct` template implements the `add_cv` meta‐function defined in the C++11 standard [meta.trans.cv], providing an alias, `type`, that returns the result. If the (template parameter) `t_TYPE` is not a reference type, nor a function type, nor already `const`‐qualified and `volatile`‐qualified at the top‐level, then `type` is an alias to `t_TYPE` with a top‐level `const`‐qualifier and a `volatile`‐qualifier added; otherwise, `type` is an alias to `t_TYPE`.
| xref:bsl/add_lvalue_reference-0e2.adoc[`add_lvalue_reference`] 
| This `struct` template implements a meta‐function to transform the (template parameter) `t_TYPE` to its lvalue reference type.
| xref:bsl/add_pointer-080.adoc[`add_pointer`] 
| This `struct` template implements the `add_pointer` meta‐function defined in the C++11 standard [meta.trans.ptr], providing an alias, `type`, that returns the result. If the (template parameter) `t_TYPE` is not a reference type, then `type` is an alias to a pointer type that points to `t_TYPE`; otherwise, `type` is an alias to a pointer type that points to the type referred to by the reference `t_TYPE`, unless it is not legal to form such a pointer type, in which case `type` is an alias for `t_TYPE`.
| xref:bsl/add_rvalue_reference-00.adoc[`add_rvalue_reference`] 
| This `struct` template implements a meta‐function to transform the (template parameter) `t_TYPE` to its rvalue reference type.
| xref:bsl/add_volatile.adoc[`add_volatile`] 
| This `struct` template implements the `add_volatile` meta‐function defined in the C++11 standard [meta.trans.cv], providing an alias, `type`, that returns the result. If the (template parameter) `t_TYPE` is not a reference type, nor a function type, nor already `volatile`‐qualified at the top‐level, then `type` is an alias to `t_TYPE` with a top‐level `volatile`‐qualifier added; otherwise, `type` is an alias to `t_TYPE`.
| xref:bsl/allocator-0df.adoc[`allocator`] 
| An STL‐compatible allocator that forwards allocation calls to an underlying mechanism object of a type derived from `bslma::Allocator`. This class template adheres to the allocator requirements defined in section [allocator.requirements]and implements a superset of the `std::pmr::polymorphic_allocator` class template described in section [mem.poly.allocator.class]of the C++ standard and may be used to instantiate any [container]class template that follows the STL allocator protocol. The allocation mechanism is chosen at run‐time, giving the programmer run‐time control over how a container allocates and frees memory.
| xref:bsl/allocator_arg_t-0b.adoc[`allocator_arg_t`] 
| Tag type indicating that next argument is an allocator. TBD: If native library declares `std::allocator_arg_t`, then this struct should be an replaced by an alias for `std::allocator_arg_t`.
| xref:bsl/allocator_traits-0108.adoc[`allocator_traits`] 
| This class supports the complete interface of the C++11 `allocator_traits` class template, which provides a uniform mechanism for accessing nested types within, and operations on, any standard‐conforming allocator. A specialization of this class template for `bsl::allocator` provides support for Bloomberg's `bslma` allocator model (see the `bslma_bslallocator` component for more details). In C++11 compilation environments, the `construct` methods forward to the allocator's `construct` method if such a method matching the (variable number of) specified constructor arguments exists; otherwise, the `construct` method falls back to invoking the constructor of the element type directly. In C++03 compilation environments, there is no reliable way to detect if the type provide a method that matches a (variable number of) specified arguments; therefore, we require that standard allocator types define `construct` methods taking a variable number of arguments in those environments. This implementation is not fully‐standard‐conforming in that it does not support deduce data types that are not specified in the allocator.
| xref:bsl/basic_istringstream.adoc[`basic_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::basic_string`.
| xref:bsl/basic_ostringstream.adoc[`basic_ostringstream`] 
| This class implements a standard output stream that provides an accessor for obtaining a `bsl::basic_string` containing the sequence of characters that have been written to the stream.
| xref:bsl/basic_osyncstream.adoc[`basic_osyncstream`] 
| Forward declaration of `basic_osyncstream`.
| xref:bsl/basic_string-0faf.adoc[`basic_string`] 
| This class template provides an STL‐compliant `string` that conforms to the `bslma::Allocator` model. For the requirements of a string class, consult the second revision of the ISO/IEC 14882 Programming Language C++ (2003). Note that the (template parameter) `CHAR_TYPE` must be _equal_ to `ALLOCATOR::value_type`. In addition, this implementation offers strong exception guarantees (see below), with the general rules that:
| xref:bsl/basic_stringbuf.adoc[`basic_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.
| xref:bsl/basic_stringstream.adoc[`basic_stringstream`] 
| This class implements a standard stream providing operations using `bsl::basic_string` for modifying or accessing the sequence of characters read from, or written to, the stream.
| xref:bsl/basic_syncbuf.adoc[`basic_syncbuf`] 
| Forward declaration of `basic_syncbuf`.
| xref:bsl/binary_compose.adoc[`binary_compose`] 
| This class provides a function object adaptor for three other functors. 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))`.
| xref:bsl/bitset.adoc[`bitset`] 
| This class template provides an STL‐compliant `bitset`. For the requirements of a `bitset` class, consult the second revision of the ISO/IEC 14882 Programming Language c++ (2011).
| xref:bsl/conditional-0c.adoc[`conditional`] 
| This `struct` template implements the `conditional` meta‐function defined in the C++ standard [meta.trans.other], providing an alias, `type`, that returns the result. If the (template parameter) value `t_COND` is `true`, then `type` has the same type as the (template parameter) type `t_TRUE_TYPE`; otherwise, `type` has the same type as the (template parameter) type `t_FALSE_TYPE`. Note that this generic default template defines `type` to be an alias to `t_TRUE_TYPE` for when `t_COND` is `true`. A template specialization is provided (below) handles the case for when `t_COND` is `false`.
| xref:bsl/decay.adoc[`decay`] 
| Metafunction to return the variant of the specified parameter `t_TYPE` used for pass‐by‐reference, e.g., by applying array‐to‐pointer and function‐to‐pointer conversion.
| xref:bsl/decay_imp-03.adoc[`decay_imp`] 
| Component‐private implementation of `decay`. Do not use.
| xref:bsl/deque-0c.adoc[`deque`] 
| This class template provides an STL‐compliant `deque` that conforms to the `bslma::Allocator` model. For the requirements of a deque class, consult the C++11 standard. In particular, this implementation offers the general rules that: 1. A call to any method that would result in a deque having a size greater than the value returned by `max_size` triggers a call to `bslstl::StdExceptUtil::throwLengthError`. 2. 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::StdExceptUtil::throwOutOfRange`.
| xref:bsl/enable_if-07.adoc[`enable_if`] 
| This `struct` template implements the `enable_if` meta‐function defined in the C++11 standard [meta.trans.ptr]. This `struct` template provides a `typedef` `type` that is an alias to the (template parameter) `t_TYPE` if the (template parameter) `t_COND` is `true`; otherwise, `type` is not provided. If `t_TYPE` is not specified, it is set to `void`. Note that this generic default template provides `type` for when `t_COND` is `true`; a template specialization is provided (below) that omits `type` for when `t_COND` is `false`.
| xref:bsl/enable_shared_from_this.adoc[`enable_shared_from_this`] 
| This class allows an object that is currently managed by a `shared_ptr` to safely generate a copy of the managing `shared_ptr` object. Inheriting from `enable_shared_from_this<ELEMENT_TYPE>` provides the (template parameter) `ELEMENT_TYPE` type with a member function `shared_from_this`. If an object of type `ELEMENT_TYPE` is managed by a `shared_ptr` then calling `shared_from_this` will return a `shared_ptr<ELEMENT_TYPE>` that shares ownership of that object. It is undefined behavior to call `shared_from_this` on an object unless that object is managed by a `shared_ptr`.
| xref:bsl/equal_to-0d.adoc[`equal_to`] 
| This `struct` defines a binary comparison functor applying `operator==` to two `VALUE_TYPE` objects. This class conforms to the C++11 standard specification of `std::equal_to` that does not require inheriting from `std::binary_function`. Note that this class is an empty POD type.
| xref:bsl/formatter.adoc[`formatter`] 
| This is the base template for the `bsl::formatter` class. 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.
| xref:bsl/function-0a.adoc[`function`] 
| Forward declaration.
| xref:bsl/hash-06.adoc[`hash`] 
| Empty base class for hashing. This class, and all explicit and partial specializations of this class, shall conform to the C++11 Hash Requirements (C++11 17.6.3.4, [hash.requirements]). Unless this template is explicitly specialized, it will use the default hash algorithm provided by `bslh::Hash<>` to supply hash values. In order to hash a user‐defined type using `bsl::hash`, `bsl::hash` must be explicitly specialized for the type, or, preferably, `hashAppend` must be implemented for the type. For more details on `hashAppend` and `bslh::Hash` see the component `bslh_hash`.
| xref:bsl/hash_map.adoc[`hash_map`] 
| Legacy STLPort hash container mapping unique keys to values.
| xref:bsl/hash_multimap.adoc[`hash_multimap`] 
| Legacy STLPort hash container mapping keys to possibly duplicate values.
| xref:bsl/hash_multiset.adoc[`hash_multiset`] 
| Legacy STLPort hash container storing possibly duplicate values.
| xref:bsl/hash_set.adoc[`hash_set`] 
| Legacy STLPort hash container storing unique values.
| xref:bsl/hashtable.adoc[`hashtable`] 
| Internal STLPort hash table used to implement legacy hash containers.
| xref:bsl/integral_constant-02.adoc[`integral_constant`] 
| Metafunction representing a compile‐time constant of the specified (template parameter) `t_TYPE` with the specified (template parameter) `t_VALUE`.
| xref:bsl/invoke_result.adoc[`invoke_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_FN` template parameter with arguments of the specified `t_ARGTYPES` template parameters. More precisely, given types `F`, `T1`, `T2`, ..., `TN` corresponding to expressions `f`, `t1`, `t2`, ..., `tN`, `bslmf::ResultType<F, T1, T2, ..., TN>::type` is usually the type of the psuedo‐expression `(f, t1, t2, ..., tN)`, as defined in section [func.rquire]of the C++11 standard. If the compiler supports C++11 `decltype` and the psuedo‐expression `(f, t1, t2, ..., tN)` is not well‐formed, this class provides no `type` member. If `t_FN` is a class (functor) type and the compiler doesn't support C++11 `decltype`, the return type is automatically deduced for fundamental types, `void`, pointers or references to those, or `bsl::nullptr_t` and is deduced by `bslmf::ResultType<t_FN>::type` otherwise. If deduction fails, this metafunction yields `bslmf::InvokeResultDeductionFailed`. See component‐level documentation for more detail.
| xref:bsl/is_arithmetic.adoc[`is_arithmetic`] 
| This `struct` template implements the `is_arithmetic` meta‐function defined in the C++11 standard [meta.unary.comp]to determine if the (template parameter) `t_TYPE` is an arithmetic type. This `struct` derives from `bsl::true_type` if the `t_TYPE` is an arithmetic type, and from `bsl::false_type` otherwise.
| xref:bsl/is_array-06.adoc[`is_array`] 
| This `struct` template implements the `is_array` meta‐function defined in the C++11 standard [meta.unary.cat]to determine if the (template parameter) `t_TYPE` is an array type. This `struct` derives from `bsl::true_type` if the `t_TYPE` is an array type, and `bsl::false_type` otherwise.
| xref:bsl/is_bounded_array-0c.adoc[`is_bounded_array`] 
| This `struct` template implements the `is_bounded_array` meta‐function defined in the C++20 standard [meta.unary.cat]to determine if the (template parameter) `t_TYPE` is an array type of known bound. This `struct` derives from `bsl::true_type` if the `t_TYPE` is an array type of known bound, and `bsl::false_type` otherwise.
| xref:bsl/is_class.adoc[`is_class`] 
| This `struct` template implements the `is_class` meta‐function defined in the C++11 standard [meta.unary.cat]to determine if the (template parameter) `t_TYPE` is a class. Note that for implementations without native library support, this component will mis‐diagnose `union` types as classes. 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.
| xref:bsl/is_const-00.adoc[`is_const`] 
| This `struct` template implements the `is_const` meta‐function defined in the C++11 standard [meta.unary.cat]to determine if the (template parameter) `t_TYPE` is `const`‐qualified. This `struct` derives from `bsl::true_type` if the `t_TYPE` is `const`‐qualified, and `bsl::false_type` otherwise. Note that this generic default template derives from `bsl::false_type`. A template specialization is provided (below) that derives from `bsl::true_type`.
| xref:bsl/is_convertible.adoc[`is_convertible`] 
| This `struct` template implements the `is_convertible` meta‐function defined in the C++11 standard to determine whether the (template parameter) `t_FROM_TYPE` is implicitly convertible to the (template parameter) `t_TO_TYPE`.
| xref:bsl/is_copy_constructible.adoc[`is_copy_constructible`] 
| This `struct` template implements a meta‐function to determine whether the (template parameter) `t_TYPE` is copy constructible. This `struct` derives from `bsl::true_type` if the `t_TYPE` is copy constructible, and from `bsl::false_type` otherwise. This meta‐function has the same syntax as the `is_copy_constructible` meta‐function defined in the C++11 standard [meta.unary.prop]; on C++03 platforms, however, this meta‐function defaults to `true_type` for all types that are not explicitly declared to have the `bslmf::IsNonCopyable` trait using the `BSLMF_NESTED_TRAIT_DECLARATION` macro. To mark a type as non‐copyable, `bslmf::IsNonCopyable` must be specialized (for that type) to inherit from `bsl::true_type`.
| xref:bsl/is_empty.adoc[`is_empty`] 
| This `struct` is a meta‐function to determine whether the (template parameter) `t_TYPE` is an empty class type. This `struct` derives from `bsl::true_type` if the `t_TYPE` is empty, and from `bsl::false_type` otherwise. This meta‐function has the same syntax as the `is_empty` meta‐function defined in the C++11 standard [meta.unary.prop]; on C++03 platforms, however, this meta‐function defaults to `true_type` if `t_TYPE` is a `class` or `struct` with no non‐static data members other than bit‐fields of length 0, no virtual member functions, no virtual base classes, and no base class `B` for which `is_empty<B>::value` is `false`; otherwise `is_empty` defaults to `false_type`. Note that this meta‐function will fail to compile for a union that is the same size as an empty class in C++03.
| xref:bsl/is_enum.adoc[`is_enum`] 
| This `struct` template implements the `is_enum` meta‐function defined in the C++11 standard [meta.unary.cat]to determine if the (template parameter) `t_TYPE` is an enumerated type. This `struct` derives from `bsl::true_type` if the `t_TYPE` is an enumerated type, and from `bsl::false_type` otherwise.
| xref:bsl/is_floating_point.adoc[`is_floating_point`] 
| This `struct` template implements the `is_floating_point` meta‐function defined in the C++11 standard [meta.unary.cat]to determine if the (template parameter) `t_TYPE` is a floating‐point type.
| xref:bsl/is_function-05.adoc[`is_function`] 
| This `struct` template implements the `is_function` meta‐function defined in the C++11 standard [meta.unary.cat]to determine if the (template parameter) `t_TYPE` is a function type. This `struct` derives from `bsl::true_type` if the `t_TYPE` is a function type, and from `bsl::false_type` otherwise. This implementation relies on the fact that neither function types nor reference types can be cv‐qualified so that `is_const<const t_TYPE>` will actually yield `false`.
| xref:bsl/is_fundamental-09.adoc[`is_fundamental`] 
| This `struct` template implements a meta‐function for checking if a type is fundamental as defined in the C++11 standard [basic.fundamental]. Note that this is subtly differemt from `bslmf::IsFundamental`, which also returns `true_type` for references to fundamental types.
| xref:bsl/is_integral.adoc[`is_integral`] 
| This `struct` template implements the `is_integral` meta‐function defined in the C++11 standard to determine if the (template parameter) `t_TYPE` is an integral type.
| xref:bsl/is_lvalue_reference.adoc[`is_lvalue_reference`] 
| Metafunction that is `true` if the (template parameter) `t_TYPE` is an lvalue reference type.
| xref:bsl/is_member_function_pointer-081.adoc[`is_member_function_pointer`] 
| This `struct` template implements the `is_member_function_pointer` meta‐function defined in the C++11 standard [meta.unary.cat]to determine if the (template parameter) `t_TYPE` is a pointer to non‐static member function type. This `struct` derives from `bsl::true_type` if the `t_TYPE` is a pointer to non‐static member function type, and from `bsl::false_type` otherwise. Additional specializations are provided below to give the correct answer in all cases.
| xref:bsl/is_member_object_pointer-0b.adoc[`is_member_object_pointer`] 
| This `struct` template implements the `is_member_object_pointer` meta‐function defined in the C++11 standard [meta.unary.cat]to determine if the (template parameter) `t_TYPE` is a pointer to non‐static data member type. This `struct` derives from `bsl::true_type` if the `t_TYPE` is a pointer to non‐static data member type, and from `bsl::false_type` otherwise.
| xref:bsl/is_member_pointer-0e.adoc[`is_member_pointer`] 
| This `struct` template implements the `is_member_pointer` meta‐function defined in the C++11 standard [meta.unary.comp]to determine if the (template parameter) `t_TYPE` is a member pointer type. This `struct` derives from `bsl::true_type` if the `t_TYPE` is a member pointer type, and from `bsl::false_type` otherwise. Additional specializations are provided below to give the correct answer in all cases.
| xref:bsl/is_nothrow_move_constructible.adoc[`is_nothrow_move_constructible`] 
| This `struct` template implements a metafunction to determine whether the (template parameter) `t_TYPE` has a no‐throw move constructor. This `struct` derives from `bsl::true_type` if the `t_TYPE` has a no‐throw move constructor, and from `bsl::false_type` otherwise. This metafunction has the same syntax as the `is_nothrow_move_constructible` metafunction defined in the C++11 standard [meta.unary.prop]; on C++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::is_nothrow_move_constructible` trait using the `BSLMF_NESTED_TRAIT_DECLARATION` macro. To support other no‐throw move constructible types, this template should be specialized to inherit from `bsl::true_type`. Note that cv‐qualified user defined types are rarely no‐throw move constructible unless they are also trivially copyable, so there are no cv‐qualified partial specializations of this trait.
| xref:bsl/is_pointer-0c.adoc[`is_pointer`] 
| This `struct` template implements the `is_pointer` meta‐function defined in the C++11 standard [meta.unary.cat]to determine if the (template parameter) `t_TYPE` is a pointer. This `struct` derives from `bsl::true_type` if the `t_TYPE` is a pointer type (but not a pointer‐to‐non‐static‐member type), and `bsl::false_type` otherwise.
| xref:bsl/is_polymorphic.adoc[`is_polymorphic`] 
| This `struct` template implements the `is_polymorphic` meta‐function defined in the C++11 standard [meta.unary.prop]to determine if the (template parameter) `t_TYPE` is a (possibly cv‐qualified) polymorphic type. This `struct` derives from `bsl::true_type` if the `t_TYPE` is a polymorphic type, and `bsl::false_type` otherwise.
| xref:bsl/is_reference-05.adoc[`is_reference`] 
| This `struct` template implements the `is_reference` meta‐function defined in the C++11 standard [meta.unary.comp]to determine if the (template parameter) `t_TYPE` is a (lvalue or rvalue) reference type.
| xref:bsl/is_rvalue_reference-00.adoc[`is_rvalue_reference`] 
| This `struct` template provides a meta‐function to determine whether the (template parameter) `t_TYPE` is a (possibly cv‐qualified) rvalue reference type. This generic default template derives from `bsl::false_type`. A template specialization is provided (below) that derives from `bsl::true_type`.
| xref:bsl/is_same-051.adoc[`is_same`] 
| This `struct` template provides a meta‐function to determine whether the (template parameter) `t_TYPE1` and the (template parameter) `t_TYPE2` are the same. This generic default template derives from `bsl::false_type`. A template specialization is provided (below) that derives from `bsl::true_type`.
| xref:bsl/is_trivially_copyable-044.adoc[`is_trivially_copyable`] 
| This `struct` template implements a meta‐function to determine whether the (template parameter) `t_TYPE` is trivially copyable. This `struct` derives from `bsl::true_type` if the `t_TYPE` is trivially copyable, and from `bsl::false_type` otherwise. This meta‐function has the same syntax as the `is_trivially_copyable` meta‐function defined in the C++11 standard [meta.unary.prop]; however, this meta‐function can automatically determine the value for the following types only: reference types, fundamental types, enumerated types, pointers to members, and types declared to have the `bsl::is_trivially_copyable` trait using the `BSLMF_NESTED_TRAIT_DECLARATION` macro (the value for other types defaults to `false`). To support other trivially copyable types, this template must be specialized to inherit from `bsl::true_type` for them.
| xref:bsl/is_trivially_default_constructible-09c.adoc[`is_trivially_default_constructible`] 
| This `struct` template implements a meta‐function to determine whether the (template parameter) `t_TYPE` is trivially default‐constructible. This `struct` derives from `bsl::true_type` if the `t_TYPE` is trivially default‐constructible, and from `bsl::false_type` otherwise. This meta‐function has the same syntax as the `is_trivially_default_constructible` meta‐function defined in the C++11 standard [meta.unary.prop]; however, this meta‐function can automatically determine the value for the following types only: reference types, fundamental types, enums, pointers to members, and types declared to have the `bsl::is_trivially_default_constructible` trait using the `BSLMF_NESTED_TRAIT_DECLARATION` macro (and the value for other types defaults to `false`). To support other trivially default‐constructible types, this template must be specialized to inherit from `bsl::true_type` for them.
| xref:bsl/is_unbounded_array-00.adoc[`is_unbounded_array`] 
| This `struct` template implements the `is_unbounded_array` meta‐function defined in the C++20 standard [meta.unary.cat]to determine if the (template parameter) `t_TYPE` is an array type of unknown bound. This `struct` derives from `bsl::true_type` if the `t_TYPE` is an array type of unknown bound, and `bsl::false_type` otherwise.
| xref:bsl/is_void-06.adoc[`is_void`] 
| This `struct` template implements the `is_void` meta‐function defined in the C++11 standard [meta.unary.cat]to determine if the (template parameter) `t_TYPE` is the (possibly cv‐qualified) `void` type. This `struct` derives from `bsl::true_type` if `t_TYPE` is the `void` type, and `bsl::false_type` otherwise.
| xref:bsl/is_volatile-02.adoc[`is_volatile`] 
| This `struct` template implements the `is_volatile` meta‐function defined in the C++11 standard [meta.unary.cat]to determine if the (template parameter) `t_TYPE` is `volatile`‐qualified. This `struct` derives from `bsl::true_type` if the `t_TYPE` is `volatile`‐qualified, and `bsl::false_type` otherwise. Note that this generic default template derives from `bsl::false_type`. A template specialization is provided (below) that derives from `bsl::true_type`.
| xref:bsl/list-054.adoc[`list`] 
| Forward declaration required by `List_NodeProctor`.
| xref:bsl/map-0a7.adoc[`map`] 
| This class template implements a value‐semantic container type holding an ordered sequence of key‐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`).
| xref:bsl/multimap-0ae.adoc[`multimap`] 
| This class template implements a value‐semantic container type holding an ordered sequence of key‐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`).
| xref:bsl/multiset-03.adoc[`multiset`] 
| This class template implements a value‐semantic container type holding an ordered sequence of possibly duplicate keys (of the template parameter type, `KEY`).
| xref:bsl/nostopstate_t.adoc[`nostopstate_t`] 
| An object of this empty struct can be passed to the constructor of `stop_source` to create a `stop_source` object that does not refer to any stop state.
| xref:bsl/optional-072.adoc[`optional`] 
| 
| xref:bsl/owner_equal.adoc[`owner_equal`] 
| Function object that compares `shared_ptr`/`weak_ptr` owner equality.
| xref:bsl/owner_hash.adoc[`owner_hash`] 
| Function object that hashes `shared_ptr`/`weak_ptr` owner identity.
| xref:bsl/owner_less-0c.adoc[`owner_less`] 
| Function‐object type that orders two pointers by the ownership of their shared/weak pointer objects rather than by the pointer addresses.
| 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. If either `T1` or `T2` uses `bslma::Allocator` for memory management, then provide an optional `bslma::Allocator` argument for each constructor, to be passed through to the constructors of `first` and/or `second` as appropriate. The interface to this class is identical to the standard `std::pair` except for the addition of the allocators. 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++11.
| xref:bsl/priority_queue-034.adoc[`priority_queue`] 
| This class is a value‐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‐priority‐first priority queue data structure, where the priorities of elements are compared by a comparator of the template parameter type, `COMPARATOR`. The container object held by a `priority_queue` class object is referenced as `c` in the following documentation.
| xref:bsl/queue-0a5.adoc[`queue`] 
| This class is a value‐semantic class template, having a container of the parameterized `CONTAINER` type that holds elements of the parameterized `VALUE` type, to provide a first‐in‐first‐out queue data structure. The container object held by a `queue` class object is referenced as `c` in the following function‐level documentation.
| xref:bsl/reference.adoc[`reference`] 
| Proxy providing a mutable reference to a single bit in a `bitset`.
| xref:bsl/remove_const-07.adoc[`remove_const`] 
| This `struct` template implements the `remove_const` meta‐function defined in the C++11 standard [meta.trans.cv], providing an alias, `type`, that returns the result. `type` has the same type as the (template parameter) `t_TYPE` except that any top‐level `const`‐qualifier has been removed. Note that this generic default template provides a `type` that is an alias to `t_TYPE` for when `t_TYPE` is not `const`‐qualified. A template specialization is provided (below) that removes the `const`‐qualifier for when `t_TYPE` is `const`‐qualified.
| xref:bsl/remove_cv.adoc[`remove_cv`] 
| This `struct` template implements the `remove_cv` meta‐function defined in the C++11 standard [meta.trans.cv], providing an alias, `type`, that returns the result. `type` has the same type as the (template parameter) `t_TYPE` except that any top‐level cv‐qualifiers have been removed.
| xref:bsl/remove_extent-06.adoc[`remove_extent`] 
| From the C++14 standard: If `T` names a type "array of `U`", the member typedef `type` shall be `U`, otherwise `T`. [ _Note:_ For] multidimensional arrays, only the first array dimension is removed. For a type "array of `const U`", the resulting type is `const U`. ‐‐ *end note* ]
| xref:bsl/remove_pointer.adoc[`remove_pointer`] 
| This `struct` template implements the `remove_pointer` meta‐function defined in the C++11 standard [meta.trans.ptr], providing an alias, `type`, that returns the result. If the (template parameter) `t_TYPE` is a (possibly cv‐qualified) pointer type, then `type` is an alias to the type pointed to by `t_TYPE`; otherwise, `type` is an alias to `t_TYPE`.
| xref:bsl/remove_volatile-0c.adoc[`remove_volatile`] 
| This `struct` template implements the `remove_volatile` meta‐function defined in the C++11 standard [meta.trans.cv], providing an alias, `type`, that returns the result. `type` has the same type as the (template parameter) `t_TYPE` except that any top‐level `volatile`‐qualifier has been removed. Note that this generic default template provides a `type` that is an alias to `t_TYPE` for when `t_TYPE` is not `volatile`‐qualified. A template specialization is provided (below) that removes the `volatile`‐qualifier for when `t_TYPE` is `volatile`‐qualified.
| xref:bsl/select1st.adoc[`select1st`] 
| This `struct` is a functor that returns the `first` member of its `PAIR` argument.
| xref:bsl/select2nd.adoc[`select2nd`] 
| This `struct` is a functor that returns the `second` member of its `PAIR` argument.
| xref:bsl/set-0d.adoc[`set`] 
| This class template implements a value‐semantic container type holding an ordered sequence of unique keys (of the template parameter type, `KEY`).
| xref:bsl/shared_ptr-0a.adoc[`shared_ptr`] 
| This class provides a thread‐safe reference‐counted "smart pointer" to support "shared ownership" of objects: a shared pointer ensures that the shared object is destroyed, using the appropriate deletion method, only when there are no shared references to it. The object (of template parameter type `ELEMENT_TYPE`) referred to by a shared pointer may be accessed directly using the `‐>` operator, or the dereference operator (operator `*`) can be used to obtain a reference to that object.
| xref:bsl/slist.adoc[`slist`] 
| Singly‐linked list container with constant‐time front insertion.
| xref:bsl/stack-05.adoc[`stack`] 
| This `class` defines a container adapter which supports access primarily via `push`, `pop`, and `top`. This type can be based on a variety of other container types, including `deque`, `vector`, and `list`. This type is value‐semantic if the supporting `CONTAINER` and `VALUE` are value‐semantic.
| xref:bsl/stop_callback-06.adoc[`stop_callback`] 
| This class holds an object or reference of type `t_CALLBACK` and, when constructed using a `stop_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). However, if cancellation was already requested before the `stop_callback` was constructed, the constructor invokes the callback immediately. If there is no stop state, or `request_stop` is never called for the stop state, then the callback is not invoked. `stop_callback` stores its callback within its own footprint, and thus never requires memory allocation; however, `stop_callback<t_CALLBACK>` is an allocator‐aware class, if `t_CALLBACK` is an allocator‐aware class, and any supplied allocator will then be passed to the constructor of `t_CALLBACK`.
| xref:bsl/stop_source.adoc[`stop_source`] 
| This class is a mechanism for making and observing cancellation requests. 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; it is also possible for a `stop_source` object to not own a stop state. Due to its shared ownership semantics, it is safe to pass a copy of a `stop_source` object to a callback that might outlive the original `stop_source` object; 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_token`, which can be created by calling `stop_source::get_token`.
| xref:bsl/stop_token.adoc[`stop_token`] 
| This class is a mechanism for observing cancellation requests. 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. A `stop_token` cannot be used to make a cancellation request.
| xref:bsl/type_index.adoc[`type_index`] 
| This class implements an in‐core value‐semantic type wrapping a standard `type_info` object.
| xref:bsl/unary_compose.adoc[`unary_compose`] 
| This class provides a function object adaptor for two other functors. 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))`.
| xref:bsl/unordered_map-02b.adoc[`unordered_map`] 
| This class template implements a value‐semantic container type holding an unordered set of `KEY‐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`).
| xref:bsl/unordered_multimap-0b0.adoc[`unordered_multimap`] 
| This class template implements a value‐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`).
| xref:bsl/unordered_multiset-06c.adoc[`unordered_multiset`] 
| This class template implements a value‐semantic container type holding an unordered multiset of values (of template parameter type `KEY`).
| xref:bsl/unordered_set-0d2d.adoc[`unordered_set`] 
| This class template implements a value‐semantic container type holding an unordered set of unique values (of template parameter type `KEY`).
| xref:bsl/uses_allocator.adoc[`uses_allocator`] 
| This `struct` template implements a meta‐function to determine whether a (template parameter) `t_TYPE` uses a given (template parameter) `t_ALLOCATOR_TYPE`. This `struct` derives from `bsl::true_type` if `t_TYPE` uses `t_ALLOCATOR_TYPE` and from `bsl::false_type` otherwise. This meta‐function has the same syntax as the `uses_allocator` meta‐function defined in the C++11 standard [allocator.uses.trait].
| xref:bsl/variant.adoc[`variant`] 
| 
| xref:bsl/variant_alternative-0c.adoc[`variant_alternative`] 
| This metafunction calculates the type of the alternative whose index is (template parameter) `t_INDEX` in the possibly cv‐qualified `bsl::variant` type of (template parameter) `t_TYPE`. If `t_TYPE` is cv‐qualified, its cv‐qualifiers are applied to the alternative.
| xref:bsl/variant_size-07.adoc[`variant_size`] 
| This metafunction calculates the number of alternatives in the (possibly cv‐qualified) `bsl::variant` type of (template parameter) `t_BSL_VARIANT`. The primary template is not defined.
| xref:bsl/vector-00d.adoc[`vector`] 
| This class template provides an STL‐compliant `vector` that conforms to the `bslma::Allocator` model. For the requirements of a vector class, consult the C++11 standard. In particular, this implementation offers the general rules that:
| 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::ContainerBase`) to take better advantage of cache prefetching. It is parameterized by `VALUE_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). This class intentionally has *no* creators (other than the compiler‐generated ones).
| xref:bsl/vector_ForwardIteratorForPtrs-08.adoc[`vector_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`. The metafunction will return the original `ITERATOR` type unless it truly is an iterator, using `is_integral` as a proxy for testing that a type is NOT an iterator. This is needed to disambiguate only the cases of users passing `0` as a null‐pointer value to functions requesting a number of identical copies of an element.
| xref:bsl/vector_UintPtrConversionIterator.adoc[`vector_UintPtrConversionIterator`] 
| This class provides a minimal proxy iterator adapter, transforming pointers to `uintptr_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. While it does not provide a standard conforming iterator itself, if provides exactly sufficient behavior to implement all the needed members. `VALUE_TYPE` shall be a pointer type, and `ITERATOR` shall be a standard conforming iterator that dereferences to a type implicitly convertible to `VALUE_TYPE`
| xref:bsl/vector_UintPtrRangeAdapter.adoc[`vector_UintPtrRangeAdapter`] 
| This class provides a minimal proxy range adapter, transforming pointers to `uintptr_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. While it does not provide a standard conforming iterator itself, if provides exactly sufficient behavior to implement all the needed members. `t_VALUE_TYPE` shall be a pointer type, and `[d_begin, d_end)]` is a range of the input values.
| xref:bsl/weak_ptr-0d.adoc[`weak_ptr`] 
| This `friend` declaration provides access to the internal data members while constructing a weak pointer from a weak pointer of a different type.
|===


== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:bsl/ErrcEnum.adoc[`ErrcEnum`] 
| Portable typedef for `std::errc`.
| xref:bsl/Pair_BslmaIdiomAllocatorArgT.adoc[`Pair_BslmaIdiomAllocatorArgT`] 
| Type tag for types that take a `bslma::Allocator*` as the second argument of their constructors, following an argument of type `bsl::allocator_arg_t`.
| xref:bsl/Pair_BslmaIdiomAtEnd.adoc[`Pair_BslmaIdiomAtEnd`] 
| Type tag for types that take a `bslma::Allocator*` as the last argument of their constructors.
| xref:bsl/Pair_BslmaIdiomNone.adoc[`Pair_BslmaIdiomNone`] 
| Type tag for types that do not take a `bslma::Allocator*` constructor argument.
| xref:bsl/String_ComparisonCategoryType.adoc[`String_ComparisonCategoryType`] 
| Alias for the comparison category type of `basic_string`.
| xref:bsl/SyncBuf_Mutex.adoc[`SyncBuf_Mutex`] 
| Mutex type used to synchronize `basic_syncbuf` emission.
| xref:bsl/_Sl_global_inst.adoc[`_Sl_global_inst`] 
| Instantiation of `_Sl_global` providing shared slist node algorithms.
| xref:bsl/_Stl_prime_type.adoc[`_Stl_prime_type`] 
| Alias for `_Stl_prime<bool>` providing the prime bucket‐count table.
| xref:bsl/__oom_handler_type.adoc[`__oom_handler_type`] 
| Function‐pointer type for an out‐of‐memory handler.
| xref:bsl/add_const_t.adoc[`add_const_t`] 
| `add_const_t` is an alias to the return type of the `add_const` meta‐function. Note, that the `add_const_t` avoids the `::type` suffix and `typename` prefix when we want to use the result of the meta‐function in templates.
| xref:bsl/add_cv_t.adoc[`add_cv_t`] 
| `add_cv_t` is an alias to the return type of the `bsl::add_cv` meta‐function. Note, that the `add_cv_t` avoids the `::type` suffix and `typename` prefix when we want to use the result of the `bsl::add_cv` in templates.
| xref:bsl/add_lvalue_reference_t.adoc[`add_lvalue_reference_t`] 
| `add_lvalue_reference_t` is an alias to the return type of `add_lvalue_reference` meta‐function. Note, that the `add_const_t` avoids the `::type` suffix and `typename` prefix when we want to use the result of the meta‐function in templates.
| xref:bsl/add_pointer_t.adoc[`add_pointer_t`] 
| `add_pointer_t` is an alias to the return type of the `bsl::add_pointer` meta‐function. Note, that the `remove_pointer_t` avoids the `::type` suffix and `typename` prefix when we want to use the result of the meta‐function in templates.
| xref:bsl/add_rvalue_reference_t.adoc[`add_rvalue_reference_t`] 
| `add_rvalue_reference_t` is an alias to the return type of `add_rvalue_reference` meta‐function. Note, that the `add_const_t` avoids the `::type` suffix and `typename` prefix when we want to use the result of the meta‐function in templates.
| xref:bsl/add_volatile_t.adoc[`add_volatile_t`] 
| `add_volatile_t` is an alias to the return type of the `bsl::add_volatile` meta‐function. Note, that the `bsl::add_volatile_t` avoids the `::type` suffix and `typename` prefix when we want to use the result of the meta‐function in templates.
| xref:bsl/aligned_storage.adoc[`aligned_storage`]  [.small]#[deprecated]#
| Alias for `std::aligned_storage` in the `bsl` namespace.
| xref:bsl/aligned_storage_t.adoc[`aligned_storage_t`]  [.small]#[deprecated]#
| Alias for `std::aligned_storage_t` in the `bsl` namespace.
| xref:bsl/aligned_union.adoc[`aligned_union`]  [.small]#[deprecated]#
| Alias for `std::aligned_union` in the `bsl` namespace.
| xref:bsl/aligned_union_t.adoc[`aligned_union_t`]  [.small]#[deprecated]#
| Alias for `std::aligned_union_t` in the `bsl` namespace.
| xref:bsl/bad_optional_access.adoc[`bad_optional_access`] 
| Alias for `std::bad_optional_access` in the `bsl` namespace.
| xref:bsl/bad_weak_ptr.adoc[`bad_weak_ptr`] 
| Alias for `BloombergLP::bslstl::BadWeakPtr`.
| xref:bsl/bool_constant.adoc[`bool_constant`] 
| Alias for `integral_constant<bool, t_VALUE>`.
| xref:bsl/common_type_t.adoc[`common_type_t`] 
| Alias for `std::common_type_t` in the `bsl` namespace.
| xref:bsl/conditional_t.adoc[`conditional_t`] 
| `conditional_t` is an alias to the return type of the `bsl::conditional` meta‐function. Note, that the `conditional_t` avoids the `::type` suffix and `typename` prefix when we want to use the result of the meta‐function in templates.
| xref:bsl/decay_t.adoc[`decay_t`] 
| `decay_t` is an alias to the return type of the `bsl::decay` meta‐function. Note, that the `enable_if_t` avoids the `::type` suffix and `typename` prefix when we want to use the result of the meta‐function in templates.
| xref:bsl/enable_if_t.adoc[`enable_if_t`] 
| `enable_if_t` is an alias to the return type of the `bsl::enable_if` meta‐function. Note, that the `enable_if_t` avoids the `::type` suffix and `typename` prefix when we want to use the result of the meta‐function in templates.
| xref:bsl/false_type.adoc[`false_type`] 
| Metafunction representing the boolean constant `false`.
| xref:bsl/forward_list.adoc[`forward_list`] 
| Singly‐linked list with `bsl::allocator` as the default allocator.
| xref:bsl/generator.adoc[`generator`] 
| 
| xref:bsl/invoke_result_t.adoc[`invoke_result_t`] 
| `invoke_result_t` is an alias to the return type of the `bsl::invoke_result` meta‐function. Note, that the `invoke_result_t` avoids the `::type` suffix and `typename` prefix when we want to use the result of the meta‐function in templates.
| xref:bsl/istringstream.adoc[`istringstream`] 
| This `typedef` is an alias to `basic_istringstream<char>`.
| xref:bsl/make_signed_t.adoc[`make_signed_t`] 
| Alias for `std::make_signed_t<TYPE>` in the `bsl` namespace.
| xref:bsl/make_unsigned_t.adoc[`make_unsigned_t`] 
| Alias for `std::make_unsigned_t` in the `bsl` namespace.
| xref:bsl/nullopt_t.adoc[`nullopt_t`] 
| This `typedef` is an alias to `std::nullopt_t`.
| xref:bsl/nullptr_t-08.adoc[`nullptr_t`] 
| Standard null pointer type for platforms with native `nullptr` support.
| xref:bsl/nullptr_t-0c.adoc[`nullptr_t`] 
| Standard null pointer type for platforms with native `nullptr` support.
| xref:bsl/ostringstream.adoc[`ostringstream`] 
| This `typedef` is an alias to `basic_ostringstream<char>`.
| xref:bsl/osyncstream.adoc[`osyncstream`] 
| This `typedef` is an alias to `basic_osyncstream<char>`.
| xref:bsl/polymorphic_allocator.adoc[`polymorphic_allocator`] 
| Alias for `std::pmr::polymorphic_allocator` in the `bsl` namespace.
| xref:bsl/remove_all_extents_t.adoc[`remove_all_extents_t`] 
| Alias for `std::remove_all_extents_t` in the `bsl` namespace.
| xref:bsl/remove_const_t.adoc[`remove_const_t`] 
| `remove_const_t` is an alias to the return type of the `bsl::remove_const` meta‐function. Note, that the `remove_const_t` avoids the `::type` suffix and `typename` prefix when we want to use the result of the meta‐function in templates.
| xref:bsl/remove_cv_t.adoc[`remove_cv_t`] 
| `remove_cv_t` is an alias to the return type of the `bsl::remove_cv` meta‐function. Note, that the `remove_cv_t` avoids the `::type` suffix and `typename` prefix when we want to use the result of the meta‐function in templates.
| xref:bsl/remove_extent_t.adoc[`remove_extent_t`] 
| `remove_extent_t` is an alias to the return type of the `bsl::remove_extent` meta‐function. Note, that the `enable_if_t` avoids the `::type` suffix and `typename` prefix when we want to use the result of the meta‐function in templates.
| xref:bsl/remove_pointer_t.adoc[`remove_pointer_t`] 
| `remove_pointer_t` is an alias to the return type of the `bsl::remove_pointer` meta‐function. Note, that the `remove_pointer_t` avoids the `::type` suffix and `typename` prefix when we want to use the result of the meta‐function in templates.
| xref:bsl/remove_volatile_t.adoc[`remove_volatile_t`] 
| `remove_volatile_t` is an alias to the return type of the `bsl::remove_volatile` meta‐function. Note, that the `remove_volatile_t` avoids the `::type` suffix and `typename` prefix when we want to use the result of the meta‐function in templates.
| xref:bsl/result_of_t.adoc[`result_of_t`] 
| 
| xref:bsl/string.adoc[`string`] 
| Narrow character string type (`basic_string<char>`).
| xref:bsl/stringbuf.adoc[`stringbuf`] 
| This `typedef` is an alias to `basic_stringbuf<char>`.
| xref:bsl/stringstream.adoc[`stringstream`] 
| This `typedef` is an alias to `basic_stringstream<char>`.
| xref:bsl/syncbuf.adoc[`syncbuf`] 
| This `typedef` is an alias to `basic_syncbuf<char>`.
| xref:bsl/true_type.adoc[`true_type`] 
| Metafunction representing the boolean constant `true`.
| xref:bsl/tuple_element_t.adoc[`tuple_element_t`] 
| Alias for the element type at index `I` of tuple‐like `TYPE`.
| xref:bsl/u16string.adoc[`u16string`] 
| UTF‐16 string type (`basic_string<char16_t>`).
| xref:bsl/u32string.adoc[`u32string`] 
| UTF‐32 string type (`basic_string<char32_t>`).
| xref:bsl/u8string.adoc[`u8string`] 
| UTF‐8 string type (`basic_string<char8_t>`).
| xref:bsl/underlying_type_t.adoc[`underlying_type_t`] 
| Alias for `std::underlying_type_t` in the `bsl` namespace.
| xref:bsl/variant_alternative_t.adoc[`variant_alternative_t`] 
| `variant_alternative_t` is an alias to the return type of the `variant_alternative` metafunction.
| xref:bsl/void_t.adoc[`void_t`] 
| Alias template that always yields `void`.
| xref:bsl/wistringstream.adoc[`wistringstream`] 
| This `typedef` is an alias to `basic_istringstream<wchar_t>`.
| xref:bsl/wostringstream.adoc[`wostringstream`] 
| This `typedef` is an alias to `basic_ostringstream<wchar_t>`.
| xref:bsl/wosyncstream.adoc[`wosyncstream`] 
| This `typedef` is an alias to `basic_osyncstream<wchar_t>`.
| xref:bsl/wstring.adoc[`wstring`] 
| Wide character string type (`basic_string<wchar_t>`).
| xref:bsl/wstringbuf.adoc[`wstringbuf`] 
| Wide‐character string stream buffer type.
| xref:bsl/wstringstream.adoc[`wstringstream`] 
| This `typedef` is an alias to `basic_stringstream<wchar_t>`.
| xref:bsl/wsyncbuf.adoc[`wsyncbuf`] 
| This `typedef` is an alias to `basic_syncbuf<wchar_t>`.
|===


== Enums

[cols="1,4"]
|===
| Name| Description
| xref:bsl/AllocConstants.adoc[`AllocConstants`] 
| Constants controlling the internal memory pool used by STLPort allocators.
| 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. It is safe to use stack‐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.
|===


== Functions

[cols="1,4"]
|===
| Name| Description
| xref:bsl/PrintTo-09.adoc[`PrintTo`] 
| `PrintTo` overloads
| xref:bsl/__slist_make_link.adoc[`__slist_make_link`] 
| Link `__new_node` immediately after `__prev_node` and return `__new_node`.
| xref:bsl/allocate_shared-0be.adoc[`allocate_shared`] 
| `allocate_shared` overloads
| xref:bsl/allocate_shared_for_overwrite-05.adoc[`allocate_shared_for_overwrite`] 
| `allocate_shared_for_overwrite` overloads
| xref:bsl/bdlat_valueTypeAssign.adoc[`bdlat_valueTypeAssign`] 
| Assign the specified `rhs` vector to the specified `lhs` vector and return 0.
| xref:bsl/compose1.adoc[`compose1`] 
| Return an `unary_compose` function object constructed using the specified `fn1` and `fn2` unary functions. The returned function object is equivalent to `fn1(fn2(x))`.
| xref:bsl/compose2.adoc[`compose2`] 
| Return a `binary_compose` function object constructed using the specified `fn1` binary function, and the specified `fn2` and `fn3` unary functions. The returned function object is equivalent to `fn1(fn2(x), fn3(x))`.
| xref:bsl/const_pointer_cast.adoc[`const_pointer_cast`] 
| Return a `shared_ptr<TO_TYPE>` object sharing ownership of the same object as the specified `source` shared pointer to the (template parameter) `FROM_TYPE`, and referring to `const_cast<TO_TYPE *>(source.get())`. Note that if `source` cannot be `const`‐cast to `TO_TYPE *`, then a compiler diagnostic will be emitted indicating the error.
| xref:bsl/dynamic_pointer_cast.adoc[`dynamic_pointer_cast`] 
| Return a `shared_ptr<TO_TYPE>` object sharing ownership of the same object as the specified `source` shared pointer to the (template parameter) `FROM_TYPE`, and referring to `dynamic_cast<TO_TYPE*>(source.get())`. If `source` cannot be dynamically cast to `TO_TYPE *`, then an empty `shared_ptr<TO_TYPE>` object is returned.
| xref:bsl/emit_on_flush.adoc[`emit_on_flush`] 
| If, for the specified `stream`, `stream.rdbuf()` is a `basic_syncbuf<CHAR,TRAITS,ALLOCATOR>`, make `stream` emit (i.e., transmit data to the wrapped stream buffer) when flushed, otherwise has no effect. Return `stream`.
| xref:bsl/erase-03.adoc[`erase`] 
| `erase` overloads
| xref:bsl/erase_if-071.adoc[`erase_if`] 
| `erase_if` overloads
| xref:bsl/flush_emit.adoc[`flush_emit`] 
| Flush the specified `stream` as if by calling `stream.flush()`. Then, if `stream.rdbuf()` actually points to a `basic_syncbuf<CHAR,TRAITS,ALLOCATOR>` `buf`, call `buf.emit()`. Return `stream`.
| xref:bsl/format-00.adoc[`format`] 
| `format` overloads
| xref:bsl/format_to-0c.adoc[`format_to`] 
| `format_to` overloads
| xref:bsl/get-056.adoc[`get`] 
| `get` overloads
| xref:bsl/get_deleter.adoc[`get_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.
| xref:bsl/get_if-0b.adoc[`get_if`] 
| `get_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`.
| xref:bsl/holds_alternative.adoc[`holds_alternative`] 
| Return `true` if the specified `obj` currently holds the (template parameter) `t_TYPE` alternative, and `false` otherwise. `t_TYPE` shall appear exactly once in the variant's list of alternatives.
| xref:bsl/make_format_args.adoc[`make_format_args`] 
| Return an object, whose type is not specified, holding an array of `format_arg` types constructed from the specified `args`. The type returned is implicitly convertible to a `format_args` holding a reference to the contained array. This function will statically assert if any of the specified template parameters `t_ARGS` is of type `long double`.
| xref:bsl/make_optional-0c.adoc[`make_optional`] 
| `make_optional` overloads
| xref:bsl/make_shared-09.adoc[`make_shared`] 
| `make_shared` overloads
| xref:bsl/make_shared_for_overwrite-0d.adoc[`make_shared_for_overwrite`] 
| `make_shared_for_overwrite` overloads
| xref:bsl/make_wformat_args.adoc[`make_wformat_args`] 
| Return an object, whose type is not specified, holding an array of `wformat_arg` types constructed from the specified `args`. The type returned is implicitly convertible to a `wformat_args` holding a reference to the contained array. This function will statically assert if any of the specified template parameters `t_ARGS` is of type `long double`.
| xref:bsl/noemit_on_flush.adoc[`noemit_on_flush`] 
| If, for the specified `stream`, `stream.rdbuf()` is a `basic_syncbuf<CHAR,TRAITS,ALLOCATOR>`, make `stream` not emit (i.e., don't transmit data to the wrapped stream buffer) when flushed, otherwise has no effect. Return `stream`.
| xref:bsl/operator_S-06.adoc[`operator""_S`] 
| `operator""_S` overloads
| xref:bsl/operator_h-0f.adoc[`operator""_h`] 
| `operator""_h` overloads
| xref:bsl/operator_i-0fd.adoc[`operator""_i`] 
| `operator""_i` overloads
| xref:bsl/operator_if-0f.adoc[`operator""_if`] 
| `operator""_if` overloads
| xref:bsl/operator_il-01.adoc[`operator""_il`] 
| `operator""_il` overloads
| xref:bsl/operator_min-00.adoc[`operator""_min`] 
| `operator""_min` overloads
| xref:bsl/operator_ms-06.adoc[`operator""_ms`] 
| `operator""_ms` overloads
| xref:bsl/operator_ns-09.adoc[`operator""_ns`] 
| `operator""_ns` overloads
| xref:bsl/operator_s-0e87.adoc[`operator""_s`] 
| `operator""_s` overloads
| xref:bsl/operator_sv-04.adoc[`operator""_sv`] 
| `operator""_sv` overloads
| xref:bsl/operator_us-0b9.adoc[`operator""_us`] 
| `operator""_us` overloads
| xref:bsl/operator_bitand.adoc[`operator&`] 
| Return a `bitset` that results from a bitwise AND of the specified `lhs` and `rhs`.
| xref:bsl/operator_plus-0d0.adoc[`operator+`] 
| Addition operators
| xref:bsl/operator_minus-06.adoc[`operator‐`] 
| Subtraction operators
| xref:bsl/operator_slash-0e.adoc[`operator/`] 
| Division operators
| xref:bsl/operator_slash_eq.adoc[`operator/=`] 
| Append the specified `string` to the specified `path` using the preferred directory separator if appropriate. Return a reference to `path`.
| xref:bsl/operator_rshift-08.adoc[`operator>>`] 
| Right shift operators
| xref:bsl/operator_xor.adoc[`operatorˆ`] 
| Return a `bitset` that results from a bitwise XOR of the specified `lhs` and `rhs`.
| xref:bsl/operator_bitor.adoc[`operator|`] 
| Return a `bitset` that results from a bitwise OR of the specified `lhs` and `rhs`.
| xref:bsl/quoted-04.adoc[`quoted`] 
| `quoted` overloads
| xref:bsl/reinterpret_pointer_cast.adoc[`reinterpret_pointer_cast`] 
| Return a `shared_ptr<TO_TYPE>` object sharing ownership of the same object as the specified `source` shared pointer to the (template parameter) `FROM_TYPE`, and referring to `reinterpret_cast<TO_TYPE *>(source.get())`. Note that if `source` cannot be reinterpret_cast‐ed to `TO_TYPE *`, then a compiler diagnostic will be emitted indicating the error.
| xref:bsl/static_pointer_cast.adoc[`static_pointer_cast`] 
| Return a `shared_ptr<TO_TYPE>` object sharing ownership of the same object as the specified `source` shared pointer to the (template parameter) `FROM_TYPE`, and referring to `static_cast<TO_TYPE *>(source.get())`. Note that if `source` cannot be statically cast to `TO_TYPE *`, then a compiler diagnostic will be emitted indicating the error.
| 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_string`] 
| `to_string` overloads
| xref:bsl/to_wstring-05.adoc[`to_wstring`] 
| `to_wstring` overloads
| xref:bsl/vector_makeUintPtrRangeAdapter.adoc[`vector_makeUintPtrRangeAdapter`] 
| Factory function for `vector_UintPtrRangeAdapter`.
| xref:bsl/vformat-06.adoc[`vformat`] 
| `vformat` overloads
| xref:bsl/vformat_to-0c.adoc[`vformat_to`] 
| `vformat_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_RET`. If `variant` does not hold a value, throw an exception of type `bsl::bad_variant_access`. This function is provided in all language versions for compatibility with the C++03 version (see below), but in new code in C++11 and later, `bsl::visit` should be used instead of this function.
| xref:bsl/operator_lshift-05b.adoc[`operator<<`] 
| Stream insertion operators
| xref:bsl/operator_eq-08e.adoc[`operator==`] 
| Equality operators
| xref:bsl/operator_not_eq-06.adoc[`operator!=`] 
| Inequality operators
| xref:bsl/operator_lt-016.adoc[`operator<`] 
| Less‐than operators
| xref:bsl/operator_le-06.adoc[`operator<=`] 
| Less‐than‐or‐equal operators
| xref:bsl/operator_gt-02.adoc[`operator>`] 
| Greater‐than operators
| xref:bsl/operator_ge-0a.adoc[`operator>=`] 
| Greater‐than‐or‐equal operators
| xref:bsl/operator_3way-0f1.adoc[`operator<=>`] 
| Three‐way comparison operators
|===


== Variables

[cols="1,4"]
|===
| Name| Description
| xref:bsl/alignment_of_v.adoc[`alignment_of_v`] 
| Variable template alias for `std::alignment_of_v`.
| xref:bsl/extent_v.adoc[`extent_v`] 
| Variable template alias for `std::extent_v`.
| xref:bsl/has_unique_object_representations_v.adoc[`has_unique_object_representations_v`] 
| Variable template alias for `std::has_unique_object_representations_v`.
| xref:bsl/has_virtual_destructor_v.adoc[`has_virtual_destructor_v`] 
| Variable template alias for `std::has_virtual_destructor_v`.
| xref:bsl/is_abstract_v.adoc[`is_abstract_v`] 
| Variable template alias for `std::is_abstract_v`.
| xref:bsl/is_aggregate_v.adoc[`is_aggregate_v`] 
| Variable template alias for `std::is_aggregate_v`.
| xref:bsl/is_arithmetic_v.adoc[`is_arithmetic_v`] 
| This template variable represents the result value of the `bsl::is_arithmetic` meta‐function.
| xref:bsl/is_array_v.adoc[`is_array_v`] 
| This template variable represents the result value of the `bsl::is_array` meta‐function.
| xref:bsl/is_assignable_v.adoc[`is_assignable_v`] 
| Variable template alias for `std::is_assignable_v`.
| xref:bsl/is_base_of_v.adoc[`is_base_of_v`] 
| Variable template alias for `std::is_base_of_v`.
| xref:bsl/is_bounded_array_v.adoc[`is_bounded_array_v`] 
| This template variable represents the result value of the `bsl::is_bounded_array` meta‐function.
| xref:bsl/is_class_v.adoc[`is_class_v`] 
| This template variable represents the result value of the `bsl::is_class` meta‐function.
| xref:bsl/is_compound_v.adoc[`is_compound_v`] 
| Variable template alias for `std::is_compound_v`.
| xref:bsl/is_const_v.adoc[`is_const_v`] 
| This template variable represents the result value of the `bsl::is_const` meta‐function.
| xref:bsl/is_constructible_v.adoc[`is_constructible_v`] 
| Variable template alias for `std::is_constructible_v`.
| xref:bsl/is_convertible_v.adoc[`is_convertible_v`] 
| This template variable represents the result value of the `bsl::is_convertible` meta‐function.
| xref:bsl/is_copy_assignable_v.adoc[`is_copy_assignable_v`] 
| Variable template alias for `std::is_copy_assignable_v`.
| xref:bsl/is_copy_constructible_v.adoc[`is_copy_constructible_v`] 
| This template variable represents the result value of the `bsl::is_copy_constructible` meta‐function.
| xref:bsl/is_default_constructible_v.adoc[`is_default_constructible_v`] 
| Variable template alias for `std::is_default_constructible_v`.
| xref:bsl/is_destructible_v.adoc[`is_destructible_v`] 
| Variable template alias for `std::is_destructible_v`.
| xref:bsl/is_empty_v.adoc[`is_empty_v`] 
| This template variable represents the result value of the `bsl::is_empty` meta‐function.
| xref:bsl/is_enum_v.adoc[`is_enum_v`] 
| This template variable represents the result value of the `bsl::is_enum` meta‐function.
| xref:bsl/is_final_v.adoc[`is_final_v`] 
| Variable template alias for `std::is_final_v`.
| xref:bsl/is_function_v.adoc[`is_function_v`] 
| This template variable represents the result value of the `bsl::is_function` meta‐function.
| xref:bsl/is_fundamental_v.adoc[`is_fundamental_v`] 
| This template variable represents the result value of the `bsl::is_fundamental` meta‐function.
| xref:bsl/is_invocable_r_v.adoc[`is_invocable_r_v`] 
| Variable template alias for `std::is_invocable_r_v`.
| xref:bsl/is_invocable_v.adoc[`is_invocable_v`] 
| Variable template alias for `std::is_invocable_v`.
| xref:bsl/is_literal_type_v.adoc[`is_literal_type_v`]  [.small]#[deprecated]#
| Variable template alias for `std::is_literal_type_v`.
| xref:bsl/is_member_function_pointer_v.adoc[`is_member_function_pointer_v`] 
| This variable template represents the result value of the `bsl::is_member_function_pointer` meta‐function.
| xref:bsl/is_member_object_pointer_v.adoc[`is_member_object_pointer_v`] 
| This template variable represents the result value of the `bsl::is_member_object_pointer` meta‐function.
| xref:bsl/is_member_pointer_v.adoc[`is_member_pointer_v`] 
| This template variable represents the result value of the `bsl::is_member_pointer` meta‐function.
| xref:bsl/is_move_assignable_v.adoc[`is_move_assignable_v`] 
| Variable template alias for `std::is_move_assignable_v`.
| xref:bsl/is_move_constructible_v.adoc[`is_move_constructible_v`] 
| Variable template alias for `std::is_move_constructible_v`.
| xref:bsl/is_nothrow_assignable_v.adoc[`is_nothrow_assignable_v`] 
| Variable template alias for `std::is_nothrow_assignable_v`.
| xref:bsl/is_nothrow_constructible_v.adoc[`is_nothrow_constructible_v`] 
| Variable template alias for `std::is_nothrow_constructible_v`.
| xref:bsl/is_nothrow_copy_assignable_v.adoc[`is_nothrow_copy_assignable_v`] 
| Variable template alias for `std::is_nothrow_copy_assignable_v`.
| xref:bsl/is_nothrow_copy_constructible_v.adoc[`is_nothrow_copy_constructible_v`] 
| Variable template alias for `std::is_nothrow_copy_constructible_v`.
| xref:bsl/is_nothrow_default_constructible_v.adoc[`is_nothrow_default_constructible_v`] 
| Variable template alias for `std::is_nothrow_default_constructible_v`.
| xref:bsl/is_nothrow_destructible_v.adoc[`is_nothrow_destructible_v`] 
| Variable template alias for `std::is_nothrow_destructible_v`.
| xref:bsl/is_nothrow_invocable_r_v.adoc[`is_nothrow_invocable_r_v`] 
| Variable template alias for `std::is_nothrow_invocable_r_v`.
| xref:bsl/is_nothrow_invocable_v.adoc[`is_nothrow_invocable_v`] 
| Variable template alias for `std::is_nothrow_invocable_v`.
| xref:bsl/is_nothrow_move_assignable_v.adoc[`is_nothrow_move_assignable_v`] 
| Variable template alias for `std::is_nothrow_move_assignable_v`.
| xref:bsl/is_nothrow_move_constructible_v.adoc[`is_nothrow_move_constructible_v`] 
| This template variable represents the result value of the `bsl::is_nothrow_move_constructible` metafunction.
| xref:bsl/is_nothrow_swappable_with_v.adoc[`is_nothrow_swappable_with_v`] 
| Variable template alias for `std::is_nothrow_swappable_with_v`.
| xref:bsl/is_null_pointer_v.adoc[`is_null_pointer_v`] 
| Variable template alias for `std::is_null_pointer_v`.
| xref:bsl/is_object_v.adoc[`is_object_v`] 
| Variable template alias for `std::is_object_v`.
| xref:bsl/is_pod_v.adoc[`is_pod_v`]  [.small]#[deprecated]#
| Variable template alias for `std::is_pod_v`.
| xref:bsl/is_pointer_v.adoc[`is_pointer_v`] 
| This template variable represents the result value of the `bsl::is_pointer` meta‐function.
| xref:bsl/is_polymorphic_v.adoc[`is_polymorphic_v`] 
| This template variable represents the result value of the `bsl::is_polymorphic` meta‐function.
| xref:bsl/is_reference_v.adoc[`is_reference_v`] 
| This template variable represents the result value of the `bsl::is_reference` meta‐function.
| xref:bsl/is_rvalue_reference_v.adoc[`is_rvalue_reference_v`] 
| This template variable represents the result value of the `bsl::is_rvalue_reference` meta‐function.
| xref:bsl/is_same_v.adoc[`is_same_v`] 
| This template variable represents the result value of the `bsl::is_same` meta‐function.
| xref:bsl/is_scalar_v.adoc[`is_scalar_v`] 
| Variable template alias for `std::is_scalar_v`.
| xref:bsl/is_signed_v.adoc[`is_signed_v`] 
| Variable template alias for `std::is_signed_v`.
| xref:bsl/is_standard_layout_v.adoc[`is_standard_layout_v`] 
| Variable template alias for `std::is_standard_layout_v`.
| xref:bsl/is_swappable_with_v.adoc[`is_swappable_with_v`] 
| Variable template alias for `std::is_swappable_with_v`.
| xref:bsl/is_trivial_v.adoc[`is_trivial_v`] 
| Variable template alias for `std::is_trivial_v`.
| xref:bsl/is_trivially_assignable_v.adoc[`is_trivially_assignable_v`] 
| Variable template alias for `std::is_trivially_assignable_v`.
| xref:bsl/is_trivially_constructible_v.adoc[`is_trivially_constructible_v`] 
| Variable template alias for `std::is_trivially_constructible_v`.
| xref:bsl/is_trivially_copy_assignable_v.adoc[`is_trivially_copy_assignable_v`] 
| Variable template alias for `std::is_trivially_copy_assignable_v`.
| xref:bsl/is_trivially_copy_constructible_v.adoc[`is_trivially_copy_constructible_v`] 
| Variable template alias for `std::is_trivially_copy_constructible_v`.
| xref:bsl/is_trivially_copyable_v.adoc[`is_trivially_copyable_v`] 
| This template variable represents the result value of the `bsl::is_trivially_copyable` meta‐function.
| xref:bsl/is_trivially_default_constructible_v.adoc[`is_trivially_default_constructible_v`] 
| This template variable represents the result value of the `bsl::is_trivially_default_constructible` meta‐function.
| xref:bsl/is_trivially_destructible_v.adoc[`is_trivially_destructible_v`] 
| Variable template alias for `std::is_trivially_destructible_v`.
| xref:bsl/is_trivially_move_assignable_v.adoc[`is_trivially_move_assignable_v`] 
| Variable template alias for `std::is_trivially_move_assignable_v`.
| xref:bsl/is_trivially_move_constructible_v.adoc[`is_trivially_move_constructible_v`] 
| Variable template alias for `std::is_trivially_move_constructible_v`.
| xref:bsl/is_unbounded_array_v.adoc[`is_unbounded_array_v`] 
| This template variable represents the result value of the `bsl::is_unbounded_array_v` meta‐function.
| xref:bsl/is_union_v.adoc[`is_union_v`] 
| Variable template alias for `std::is_union_v`.
| xref:bsl/is_unsigned_v.adoc[`is_unsigned_v`] 
| Variable template alias for `std::is_unsigned_v`.
| xref:bsl/is_void_v.adoc[`is_void_v`] 
| This template variable represents the result value of the `bsl::is_void` meta‐function.
| xref:bsl/is_volatile_v.adoc[`is_volatile_v`] 
| This template variable represents the result value of the `bsl::is_volatile` meta‐function.
| xref:bsl/nostopstate.adoc[`nostopstate`] 
| Value of type `nostopstate_t` used as an argument to functions that take a `nostopstate_t` argument.
| xref:bsl/rank_v.adoc[`rank_v`] 
| Variable template alias for `std::rank_v`.
| xref:bsl/uses_allocator_v.adoc[`uses_allocator_v`] 
| This template variable represents the result value of the `bsl::uses_allocator` meta‐function.
| xref:bsl/variant_npos.adoc[`variant_npos`] 
| This value is returned by `bsl::variant::index()` if `valueless_by_exception()` is `true`.
| xref:bsl/variant_size_v.adoc[`variant_size_v`] 
| This variable template represents the result value of the `bsl::variant_size` metafunction.
|===


== Using Declarations

[cols="1,4"]
|===
| Name| Description
| xref:bsl/FILE.adoc[`FILE`] 
| Alias for `std::FILE` in the `bsl` namespace.
| xref:bsl/IsStdAllocator.adoc[`IsStdAllocator`] 
| Alias for `bslma::IsStdAllocator` in the `bsl` namespace.
| xref:bsl/IsStdAllocator_v.adoc[`IsStdAllocator_v`] 
| Alias for `bslma::IsStdAllocator_v`.
| xref:bsl/_Exit.adoc[`_Exit`] 
| Alias for `std::_Exit` in the `bsl` namespace.
| xref:bsl/abort.adoc[`abort`] 
| Alias for `std::abort` in the `bsl` namespace.
| xref:bsl/abs-0f.adoc[`abs`] 
| Alias for `std::abs` in the `bsl` namespace.
| xref:bsl/abs-0e.adoc[`abs`] 
| Alias for `std::abs` in the `bsl` namespace.
| xref:bsl/abs-04.adoc[`abs`] 
| Alias for `std::abs` in the `bsl` namespace.
| xref:bsl/accumulate.adoc[`accumulate`] 
| Alias for `std::accumulate` in the `bsl` namespace.
| xref:bsl/acos-0d.adoc[`acos`] 
| Alias for `std::acos` in the `bsl` namespace.
| xref:bsl/acos-0a.adoc[`acos`] 
| Alias for `std::acos` in the `bsl` namespace.
| xref:bsl/acos-07.adoc[`acos`] 
| Alias for `std::acos` in the `bsl` namespace.
| xref:bsl/acosh-05.adoc[`acosh`] 
| Alias for `std::acosh` in the `bsl` namespace.
| xref:bsl/acosh-0b.adoc[`acosh`] 
| Alias for `std::acosh` in the `bsl` namespace.
| xref:bsl/addressof.adoc[`addressof`] 
| Alias for `std::addressof` in the `bsl` namespace.
| xref:bsl/adjacent_difference.adoc[`adjacent_difference`] 
| Alias for `std::adjacent_difference` in the `bsl` namespace.
| xref:bsl/adjacent_find.adoc[`adjacent_find`] 
| Alias for `std::adjacent_find` in the `bsl` namespace.
| xref:bsl/adopt_lock.adoc[`adopt_lock`] 
| Alias for `std::adopt_lock` in the `bsl` namespace.
| xref:bsl/adopt_lock_t.adoc[`adopt_lock_t`] 
| Alias for `std::adopt_lock_t` in the `bsl` namespace.
| xref:bsl/advance.adoc[`advance`] 
| Alias for `std::advance` in the `bsl` namespace.
| xref:bsl/align.adoc[`align`] 
| Alias for `std::align` in the `bsl` namespace.
| xref:bsl/align_val_t.adoc[`align_val_t`] 
| Alias for `std::align_val_t` in the `bsl` namespace.
| xref:bsl/aligned_alloc.adoc[`aligned_alloc`] 
| 
| xref:bsl/alignment_of.adoc[`alignment_of`] 
| Alias for `std::alignment_of` in the `bsl` namespace.
| xref:bsl/all_of.adoc[`all_of`] 
| Alias for `std::all_of` in the `bsl` namespace.
| xref:bsl/allocator_arg.adoc[`allocator_arg`] 
| Alias for `std::allocator_arg` in the `bsl` namespace.
| xref:bsl/allocator_arg_t-04.adoc[`allocator_arg_t`] 
| Alias for `std::allocator_arg_t` in the `bsl` namespace.
| xref:bsl/any_of.adoc[`any_of`] 
| Alias for `std::any_of` in the `bsl` namespace.
| xref:bsl/apply.adoc[`apply`] 
| Alias for `std::apply` in the `bsl` namespace.
| xref:bsl/arg.adoc[`arg`] 
| Alias for `std::arg` in the `bsl` namespace.
| xref:bsl/array.adoc[`array`] 
| Alias for `std::array` in the `bsl` namespace.
| xref:bsl/as_bytes.adoc[`as_bytes`] 
| Alias for `std::as_bytes`.
| xref:bsl/as_const.adoc[`as_const`] 
| Alias for `std::as_const` in the `bsl` namespace.
| xref:bsl/as_writable_bytes.adoc[`as_writable_bytes`] 
| Alias for `std::as_writable_bytes`.
| xref:bsl/asctime.adoc[`asctime`] 
| Alias for `std::asctime` in the `bsl` namespace.
| xref:bsl/asin-0a.adoc[`asin`] 
| Alias for `std::asin` in the `bsl` namespace.
| xref:bsl/asin-08.adoc[`asin`] 
| Alias for `std::asin` in the `bsl` namespace.
| xref:bsl/asin-05.adoc[`asin`] 
| Alias for `std::asin` in the `bsl` namespace.
| xref:bsl/asinh-01.adoc[`asinh`] 
| Alias for `std::asinh` in the `bsl` namespace.
| xref:bsl/asinh-04.adoc[`asinh`] 
| Alias for `std::asinh` in the `bsl` namespace.
| xref:bsl/assignable_from.adoc[`assignable_from`] 
| Alias for `std::assignable_from` in the `bsl` namespace.
| xref:bsl/assoc_laguerre.adoc[`assoc_laguerre`] 
| 
| xref:bsl/assoc_laguerref.adoc[`assoc_laguerref`] 
| 
| xref:bsl/assoc_laguerrel.adoc[`assoc_laguerrel`] 
| 
| xref:bsl/assoc_legendre.adoc[`assoc_legendre`] 
| 
| xref:bsl/assoc_legendref.adoc[`assoc_legendref`] 
| 
| xref:bsl/assoc_legendrel.adoc[`assoc_legendrel`] 
| 
| xref:bsl/assume_aligned.adoc[`assume_aligned`] 
| Alias for `std::assume_aligned` in the `bsl` namespace.
| xref:bsl/async.adoc[`async`] 
| Alias for `std::async` in the `bsl` namespace.
| xref:bsl/at_quick_exit.adoc[`at_quick_exit`] 
| Alias for `std::at_quick_exit` in the `bsl` namespace.
| xref:bsl/atan-05.adoc[`atan`] 
| Alias for `std::atan` in the `bsl` namespace.
| xref:bsl/atan-08.adoc[`atan`] 
| Alias for `std::atan` in the `bsl` namespace.
| xref:bsl/atan-0c.adoc[`atan`] 
| Alias for `std::atan` in the `bsl` namespace.
| xref:bsl/atan2-01.adoc[`atan2`] 
| Import `std::atan2` into the `bsl` namespace.
| xref:bsl/atan2-0f.adoc[`atan2`] 
| Alias for `std::atan2` in the `bsl` namespace.
| xref:bsl/atanh-0e.adoc[`atanh`] 
| Alias for `std::atanh` in the `bsl` namespace.
| xref:bsl/atanh-0c.adoc[`atanh`] 
| Alias for `std::atanh` in the `bsl` namespace.
| xref:bsl/atexit.adoc[`atexit`] 
| Alias for `std::atexit` in the `bsl` namespace.
| xref:bsl/atof.adoc[`atof`] 
| Alias for `std::atof` in the `bsl` namespace.
| xref:bsl/atoi.adoc[`atoi`] 
| Alias for `std::atoi` in the `bsl` namespace.
| xref:bsl/atol.adoc[`atol`] 
| Alias for `std::atol` in the `bsl` namespace.
| xref:bsl/atoll.adoc[`atoll`] 
| Alias for `std::atoll` in the `bsl` namespace.
| xref:bsl/atomic.adoc[`atomic`] 
| Alias for `std::atomic` in the `bsl` namespace.
| xref:bsl/atomic_bool.adoc[`atomic_bool`] 
| Alias for `std::atomic_bool` in the `bsl` namespace.
| xref:bsl/atomic_char.adoc[`atomic_char`] 
| Alias for `std::atomic_char` in the `bsl` namespace.
| xref:bsl/atomic_char16_t.adoc[`atomic_char16_t`] 
| Alias for `std::atomic_char16_t` in the `bsl` namespace.
| xref:bsl/atomic_char32_t.adoc[`atomic_char32_t`] 
| Alias for `std::atomic_char32_t` in the `bsl` namespace.
| xref:bsl/atomic_char8_t.adoc[`atomic_char8_t`] 
| Alias for `std::atomic_char8_t` in the `bsl` namespace.
| xref:bsl/atomic_compare_exchange_strong.adoc[`atomic_compare_exchange_strong`] 
| Alias for `std::atomic_compare_exchange_strong` in the `bsl` namespace.
| xref:bsl/atomic_compare_exchange_strong_explicit.adoc[`atomic_compare_exchange_strong_explicit`] 
| Alias for `std::atomic_compare_exchange_strong_explicit` in the `bsl` namespace.
| xref:bsl/atomic_compare_exchange_weak.adoc[`atomic_compare_exchange_weak`] 
| Alias for `std::atomic_compare_exchange_weak` in the `bsl` namespace.
| xref:bsl/atomic_compare_exchange_weak_explicit.adoc[`atomic_compare_exchange_weak_explicit`] 
| Alias for `std::atomic_compare_exchange_weak_explicit` in the `bsl` namespace.
| xref:bsl/atomic_exchange.adoc[`atomic_exchange`] 
| Alias for `std::atomic_exchange` in the `bsl` namespace.
| xref:bsl/atomic_exchange_explicit.adoc[`atomic_exchange_explicit`] 
| Alias for `std::atomic_exchange_explicit` in the `bsl` namespace.
| xref:bsl/atomic_fetch_add.adoc[`atomic_fetch_add`] 
| Alias for `std::atomic_fetch_add` in the `bsl` namespace.
| xref:bsl/atomic_fetch_add_explicit.adoc[`atomic_fetch_add_explicit`] 
| Alias for `std::atomic_fetch_add_explicit` in the `bsl` namespace.
| xref:bsl/atomic_fetch_and.adoc[`atomic_fetch_and`] 
| Alias for `std::atomic_fetch_and` in the `bsl` namespace.
| xref:bsl/atomic_fetch_and_explicit.adoc[`atomic_fetch_and_explicit`] 
| Alias for `std::atomic_fetch_and_explicit` in the `bsl` namespace.
| xref:bsl/atomic_fetch_or_explicit.adoc[`atomic_fetch_or_explicit`] 
| Alias for `std::atomic_fetch_or_explicit` in the `bsl` namespace.
| xref:bsl/atomic_fetch_sub.adoc[`atomic_fetch_sub`] 
| Alias for `std::atomic_fetch_sub` in the `bsl` namespace.
| xref:bsl/atomic_fetch_sub_explicit.adoc[`atomic_fetch_sub_explicit`] 
| Alias for `std::atomic_fetch_sub_explicit` in the `bsl` namespace.
| xref:bsl/atomic_fetch_xor.adoc[`atomic_fetch_xor`] 
| Alias for `std::atomic_fetch_xor` in the `bsl` namespace.
| xref:bsl/atomic_fetch_xor_explicit.adoc[`atomic_fetch_xor_explicit`] 
| Alias for `std::atomic_fetch_xor_explicit` in the `bsl` namespace.
| xref:bsl/atomic_flag.adoc[`atomic_flag`] 
| Alias for `std::atomic_flag` in the `bsl` namespace.
| xref:bsl/atomic_flag_clear.adoc[`atomic_flag_clear`] 
| Alias for `std::atomic_flag_clear` in the `bsl` namespace.
| xref:bsl/atomic_flag_clear_explicit.adoc[`atomic_flag_clear_explicit`] 
| Alias for `std::atomic_flag_clear_explicit` in the `bsl` namespace.
| xref:bsl/atomic_flag_test_and_set.adoc[`atomic_flag_test_and_set`] 
| Alias for `std::atomic_flag_test_and_set` in the `bsl` namespace.
| xref:bsl/atomic_flag_test_and_set_explicit.adoc[`atomic_flag_test_and_set_explicit`] 
| Alias for `std::atomic_flag_test_and_set_explicit` in the `bsl` namespace.
| xref:bsl/atomic_init.adoc[`atomic_init`] 
| Alias for `std::atomic_init` in the `bsl` namespace.
| xref:bsl/atomic_int.adoc[`atomic_int`] 
| Alias for `std::atomic_int` in the `bsl` namespace.
| xref:bsl/atomic_int16_t.adoc[`atomic_int16_t`] 
| Alias for `std::atomic_int16_t` in the `bsl` namespace.
| xref:bsl/atomic_int32_t.adoc[`atomic_int32_t`] 
| Alias for `std::atomic_int32_t` in the `bsl` namespace.
| xref:bsl/atomic_int64_t.adoc[`atomic_int64_t`] 
| Alias for `std::atomic_int64_t` in the `bsl` namespace.
| xref:bsl/atomic_int8_t.adoc[`atomic_int8_t`] 
| Alias for `std::atomic_int8_t` in the `bsl` namespace.
| xref:bsl/atomic_int_fast16_t.adoc[`atomic_int_fast16_t`] 
| Alias for `std::atomic_int_fast16_t` in the `bsl` namespace.
| xref:bsl/atomic_int_fast32_t.adoc[`atomic_int_fast32_t`] 
| Alias for `std::atomic_int_fast32_t` in the `bsl` namespace.
| xref:bsl/atomic_int_fast64_t.adoc[`atomic_int_fast64_t`] 
| Alias for `std::atomic_int_fast64_t` in the `bsl` namespace.
| xref:bsl/atomic_int_fast8_t.adoc[`atomic_int_fast8_t`] 
| Alias for `std::atomic_int_fast8_t` in the `bsl` namespace.
| xref:bsl/atomic_int_least16_t.adoc[`atomic_int_least16_t`] 
| Alias for `std::atomic_int_least16_t` in the `bsl` namespace.
| xref:bsl/atomic_int_least32_t.adoc[`atomic_int_least32_t`] 
| Alias for `std::atomic_int_least32_t` in the `bsl` namespace.
| xref:bsl/atomic_int_least64_t.adoc[`atomic_int_least64_t`] 
| Alias for `std::atomic_int_least64_t` in the `bsl` namespace.
| xref:bsl/atomic_int_least8_t.adoc[`atomic_int_least8_t`] 
| Alias for `std::atomic_int_least8_t` in the `bsl` namespace.
| xref:bsl/atomic_intmax_t.adoc[`atomic_intmax_t`] 
| Alias for `std::atomic_intmax_t` in the `bsl` namespace.
| xref:bsl/atomic_intptr_t.adoc[`atomic_intptr_t`] 
| Alias for `std::atomic_intptr_t` in the `bsl` namespace.
| xref:bsl/atomic_is_lock_free.adoc[`atomic_is_lock_free`] 
| Alias for `std::atomic_is_lock_free` in the `bsl` namespace.
| xref:bsl/atomic_llong.adoc[`atomic_llong`] 
| Alias for `std::atomic_llong` in the `bsl` namespace.
| xref:bsl/atomic_load.adoc[`atomic_load`] 
| Alias for `std::atomic_load` in the `bsl` namespace.
| xref:bsl/atomic_load_explicit.adoc[`atomic_load_explicit`] 
| Alias for `std::atomic_load_explicit` in the `bsl` namespace.
| xref:bsl/atomic_long.adoc[`atomic_long`] 
| Alias for `std::atomic_long` in the `bsl` namespace.
| xref:bsl/atomic_notify_all.adoc[`atomic_notify_all`] 
| Alias for `std::atomic_notify_all` in the `bsl` namespace.
| xref:bsl/atomic_notify_one.adoc[`atomic_notify_one`] 
| Alias for `std::atomic_notify_one` in the `bsl` namespace.
| xref:bsl/atomic_ptrdiff_t.adoc[`atomic_ptrdiff_t`] 
| Alias for `std::atomic_ptrdiff_t` in the `bsl` namespace.
| xref:bsl/atomic_ref.adoc[`atomic_ref`] 
| Alias for `std::atomic_ref` in the `bsl` namespace.
| xref:bsl/atomic_schar.adoc[`atomic_schar`] 
| Alias for `std::atomic_schar` in the `bsl` namespace.
| xref:bsl/atomic_short.adoc[`atomic_short`] 
| Alias for `std::atomic_short` in the `bsl` namespace.
| xref:bsl/atomic_signal_fence.adoc[`atomic_signal_fence`] 
| Alias for `std::atomic_signal_fence` in the `bsl` namespace.
| xref:bsl/atomic_signed_lock_free.adoc[`atomic_signed_lock_free`] 
| Alias for `std::atomic_signed_lock_free` in the `bsl` namespace.
| xref:bsl/atomic_size_t.adoc[`atomic_size_t`] 
| Alias for `std::atomic_size_t` in the `bsl` namespace.
| xref:bsl/atomic_store.adoc[`atomic_store`] 
| Alias for `std::atomic_store` in the `bsl` namespace.
| xref:bsl/atomic_store_explicit.adoc[`atomic_store_explicit`] 
| Alias for `std::atomic_store_explicit` in the `bsl` namespace.
| xref:bsl/atomic_thread_fence.adoc[`atomic_thread_fence`] 
| Alias for `std::atomic_thread_fence` in the `bsl` namespace.
| xref:bsl/atomic_uchar.adoc[`atomic_uchar`] 
| Alias for `std::atomic_uchar` in the `bsl` namespace.
| xref:bsl/atomic_uint.adoc[`atomic_uint`] 
| Alias for `std::atomic_uint` in the `bsl` namespace.
| xref:bsl/atomic_uint16_t.adoc[`atomic_uint16_t`] 
| Alias for `std::atomic_uint16_t` in the `bsl` namespace.
| xref:bsl/atomic_uint32_t.adoc[`atomic_uint32_t`] 
| Alias for `std::atomic_uint32_t` in the `bsl` namespace.
| xref:bsl/atomic_uint64_t.adoc[`atomic_uint64_t`] 
| Alias for `std::atomic_uint64_t` in the `bsl` namespace.
| xref:bsl/atomic_uint8_t.adoc[`atomic_uint8_t`] 
| Alias for `std::atomic_uint8_t` in the `bsl` namespace.
| xref:bsl/atomic_uint_fast16_t.adoc[`atomic_uint_fast16_t`] 
| Alias for `std::atomic_uint_fast16_t` in the `bsl` namespace.
| xref:bsl/atomic_uint_fast32_t.adoc[`atomic_uint_fast32_t`] 
| Alias for `std::atomic_uint_fast32_t` in the `bsl` namespace.
| xref:bsl/atomic_uint_fast64_t.adoc[`atomic_uint_fast64_t`] 
| Alias for `std::atomic_uint_fast64_t` in the `bsl` namespace.
| xref:bsl/atomic_uint_fast8_t.adoc[`atomic_uint_fast8_t`] 
| Alias for `std::atomic_uint_fast8_t` in the `bsl` namespace.
| xref:bsl/atomic_uint_least16_t.adoc[`atomic_uint_least16_t`] 
| Alias for `std::atomic_uint_least16_t` in the `bsl` namespace.
| xref:bsl/atomic_uint_least32_t.adoc[`atomic_uint_least32_t`] 
| Alias for `std::atomic_uint_least32_t` in the `bsl` namespace.
| xref:bsl/atomic_uint_least64_t.adoc[`atomic_uint_least64_t`] 
| Alias for `std::atomic_uint_least64_t` in the `bsl` namespace.
| xref:bsl/atomic_uint_least8_t.adoc[`atomic_uint_least8_t`] 
| Alias for `std::atomic_uint_least8_t` in the `bsl` namespace.
| xref:bsl/atomic_uintmax_t.adoc[`atomic_uintmax_t`] 
| Alias for `std::atomic_uintmax_t` in the `bsl` namespace.
| xref:bsl/atomic_uintptr_t.adoc[`atomic_uintptr_t`] 
| Alias for `std::atomic_uintptr_t` in the `bsl` namespace.
| xref:bsl/atomic_ullong.adoc[`atomic_ullong`] 
| Alias for `std::atomic_ullong` in the `bsl` namespace.
| xref:bsl/atomic_ulong.adoc[`atomic_ulong`] 
| Alias for `std::atomic_ulong` in the `bsl` namespace.
| xref:bsl/atomic_unsigned_lock_free.adoc[`atomic_unsigned_lock_free`] 
| Alias for `std::atomic_unsigned_lock_free` in the `bsl` namespace.
| xref:bsl/atomic_ushort.adoc[`atomic_ushort`] 
| Alias for `std::atomic_ushort` in the `bsl` namespace.
| xref:bsl/atomic_wait.adoc[`atomic_wait`] 
| Alias for `std::atomic_wait` in the `bsl` namespace.
| xref:bsl/atomic_wait_explicit.adoc[`atomic_wait_explicit`] 
| Alias for `std::atomic_wait_explicit` in the `bsl` namespace.
| xref:bsl/atomic_wchar_t.adoc[`atomic_wchar_t`] 
| Alias for `std::atomic_wchar_t` in the `bsl` namespace.
| xref:bsl/atto.adoc[`atto`] 
| Alias for `std::atto`.
| xref:bsl/auto_ptr.adoc[`auto_ptr`] 
| Alias for `std::auto_ptr` in the `bsl` namespace.
| xref:bsl/back_insert_iterator.adoc[`back_insert_iterator`] 
| Alias for `std::back_insert_iterator` in the `bsl` namespace.
| xref:bsl/back_inserter.adoc[`back_inserter`] 
| Alias for `std::back_inserter` in the `bsl` namespace.
| xref:bsl/bad_alloc.adoc[`bad_alloc`] 
| Alias for `std::bad_alloc` in the `bsl` namespace.
| xref:bsl/bad_array_new_length.adoc[`bad_array_new_length`] 
| Alias for `std::bad_array_new_length` in the `bsl` namespace.
| xref:bsl/bad_cast.adoc[`bad_cast`] 
| Alias for `std::bad_cast` in the `bsl` namespace.
| xref:bsl/bad_exception.adoc[`bad_exception`] 
| Alias for `std::bad_exception` in the `bsl` namespace.
| xref:bsl/bad_function_call.adoc[`bad_function_call`] 
| Alias for `std::bad_function_call` in the `bsl` namespace.
| xref:bsl/bad_typeid.adoc[`bad_typeid`] 
| Alias for `std::bad_typeid` in the `bsl` namespace.
| xref:bsl/bad_variant_access.adoc[`bad_variant_access`] 
| Alias for `std::bad_variant_access` in the `bsl` namespace.
| xref:bsl/barrier.adoc[`barrier`] 
| Alias for `std::barrier` in the `bsl` namespace.
| xref:bsl/basic_common_reference.adoc[`basic_common_reference`] 
| Alias for `std::basic_common_reference` in the `bsl` namespace.
| xref:bsl/basic_const_iterator.adoc[`basic_const_iterator`] 
| Alias for `std::basic_const_iterator` in the `bsl` namespace.
| xref:bsl/basic_filebuf.adoc[`basic_filebuf`] 
| Alias for `std::basic_filebuf` in the `bsl` namespace.
| xref:bsl/basic_format_arg.adoc[`basic_format_arg`] 
| Alias for `std::basic_format_arg` in the `bsl` namespace.
| xref:bsl/basic_format_args.adoc[`basic_format_args`] 
| Alias for `std::basic_format_args` in the `bsl` namespace.
| xref:bsl/basic_format_context.adoc[`basic_format_context`] 
| Alias for `std::basic_format_context` in the `bsl` namespace.
| xref:bsl/basic_format_parse_context.adoc[`basic_format_parse_context`] 
| Alias for `std::basic_format_parse_context` in the `bsl` namespace.
| xref:bsl/basic_format_string.adoc[`basic_format_string`] 
| Alias for `std::basic_format_string` in the `bsl` namespace.
| xref:bsl/basic_fstream.adoc[`basic_fstream`] 
| Alias for `std::basic_fstream` in the `bsl` namespace.
| xref:bsl/basic_ifstream.adoc[`basic_ifstream`] 
| Alias for `std::basic_ifstream` in the `bsl` namespace.
| xref:bsl/basic_ios.adoc[`basic_ios`] 
| Alias for `std::basic_ios` in the `bsl` namespace.
| xref:bsl/basic_iostream.adoc[`basic_iostream`] 
| Alias for `std::basic_iostream` in the `bsl` namespace.
| xref:bsl/basic_ispanstream.adoc[`basic_ispanstream`] 
| Alias for `std::basic_ispanstream` in the `bsl` namespace.
| xref:bsl/basic_istream.adoc[`basic_istream`] 
| Alias for `std::basic_istream` in the `bsl` namespace.
| xref:bsl/basic_ofstream.adoc[`basic_ofstream`] 
| Alias for `std::basic_ofstream` in the `bsl` namespace.
| xref:bsl/basic_ospanstream.adoc[`basic_ospanstream`] 
| Alias for `std::basic_ospanstream` in the `bsl` namespace.
| xref:bsl/basic_ostream.adoc[`basic_ostream`] 
| Alias for `std::basic_ostream` in the `bsl` namespace.
| xref:bsl/basic_regex.adoc[`basic_regex`] 
| Alias for `std::basic_regex` in the `bsl` namespace.
| xref:bsl/basic_spanbuf.adoc[`basic_spanbuf`] 
| Alias for `std::basic_spanbuf` in the `bsl` namespace.
| xref:bsl/basic_spanstream.adoc[`basic_spanstream`] 
| Alias for `std::basic_spanstream` in the `bsl` namespace.
| xref:bsl/basic_streambuf.adoc[`basic_streambuf`] 
| Alias for `std::basic_streambuf` in the `bsl` namespace.
| xref:bsl/basic_string_view.adoc[`basic_string_view`] 
| Alias for `std::basic_string_view` in the `bsl` namespace.
| xref:bsl/begin-0b.adoc[`begin`] 
| Alias for `std::begin` in the `bsl` namespace.
| xref:bsl/begin-08.adoc[`begin`] 
| Alias for `std::begin` in the `bsl` namespace.
| xref:bsl/begin-02.adoc[`begin`] 
| Alias for `std::begin` in the `bsl` namespace.
| xref:bsl/bernoulli_distribution.adoc[`bernoulli_distribution`] 
| Alias for `std::bernoulli_distribution` in the `bsl` namespace.
| xref:bsl/beta.adoc[`beta`] 
| 
| xref:bsl/betaf.adoc[`betaf`] 
| 
| xref:bsl/betal.adoc[`betal`] 
| 
| xref:bsl/bidirectional_iterator.adoc[`bidirectional_iterator`] 
| Alias for `std::bidirectional_iterator` in the `bsl` namespace.
| xref:bsl/bidirectional_iterator_tag.adoc[`bidirectional_iterator_tag`] 
| Alias for `std::bidirectional_iterator_tag` in the `bsl` namespace.
| xref:bsl/binary_function.adoc[`binary_function`] 
| Alias for `std::binary_function` in the `bsl` namespace.
| xref:bsl/binary_negate.adoc[`binary_negate`] 
| Alias for `std::binary_negate` in the `bsl` namespace.
| xref:bsl/binary_search.adoc[`binary_search`] 
| Alias for `std::binary_search` in the `bsl` namespace.
| xref:bsl/binary_semaphore.adoc[`binary_semaphore`] 
| Alias for `std::binary_semaphore` in the `bsl` namespace.
| xref:bsl/bind.adoc[`bind`] 
| Alias for `std::bind` in the `bsl` namespace.
| xref:bsl/bind1st.adoc[`bind1st`] 
| Alias for `std::bind1st` in the `bsl` namespace.
| xref:bsl/bind2nd.adoc[`bind2nd`] 
| Alias for `std::bind2nd` in the `bsl` namespace.
| xref:bsl/bind_back.adoc[`bind_back`] 
| Alias for `std::bind_back` in the `bsl` namespace.
| xref:bsl/bind_front.adoc[`bind_front`] 
| Alias for `std::bind_front` in the `bsl` namespace.
| xref:bsl/binder1st.adoc[`binder1st`] 
| Alias for `std::binder1st` in the `bsl` namespace.
| xref:bsl/binder2nd.adoc[`binder2nd`] 
| Alias for `std::binder2nd` in the `bsl` namespace.
| xref:bsl/binomial_distribution.adoc[`binomial_distribution`] 
| Alias for `std::binomial_distribution` in the `bsl` namespace.
| xref:bsl/bit_and.adoc[`bit_and`] 
| Alias for `std::bit_and` in the `bsl` namespace.
| xref:bsl/bit_cast.adoc[`bit_cast`] 
| Alias for `std::bit_cast` in the `bsl` namespace.
| xref:bsl/bit_ceil.adoc[`bit_ceil`] 
| Alias for `std::bit_ceil` in the `bsl` namespace.
| xref:bsl/bit_floor.adoc[`bit_floor`] 
| Alias for `std::bit_floor` in the `bsl` namespace.
| xref:bsl/bit_not.adoc[`bit_not`] 
| Alias for `std::bit_not` in the `bsl` namespace.
| xref:bsl/bit_or.adoc[`bit_or`] 
| Alias for `std::bit_or` in the `bsl` namespace.
| xref:bsl/bit_width.adoc[`bit_width`] 
| Alias for `std::bit_width` in the `bsl` namespace.
| xref:bsl/bit_xor.adoc[`bit_xor`] 
| Alias for `std::bit_xor` in the `bsl` namespace.
| xref:bsl/boolalpha.adoc[`boolalpha`] 
| Alias for `std::boolalpha` in the `bsl` namespace.
| xref:bsl/boyer_moore_horspool_searcher.adoc[`boyer_moore_horspool_searcher`] 
| Alias for `std::boyer_moore_horspool_searcher` in the `bsl` namespace.
| xref:bsl/boyer_moore_searcher.adoc[`boyer_moore_searcher`] 
| Alias for `std::boyer_moore_searcher` in the `bsl` namespace.
| xref:bsl/bsearch.adoc[`bsearch`] 
| Alias for `std::bsearch` in the `bsl` namespace.
| xref:bsl/btowc.adoc[`btowc`] 
| Alias for `std::btowc` in the `bsl` namespace.
| xref:bsl/byte.adoc[`byte`] 
| Alias for `std::byte` in the `bsl` namespace.
| xref:bsl/byteswap.adoc[`byteswap`] 
| Alias for `std::byteswap` in the `bsl` namespace.
| xref:bsl/c16rtomb.adoc[`c16rtomb`] 
| Alias for `std::c16rtomb` in the `bsl` namespace.
| xref:bsl/c32rtomb.adoc[`c32rtomb`] 
| Alias for `std::c32rtomb` in the `bsl` namespace.
| xref:bsl/call_once.adoc[`call_once`] 
| Alias for `std::call_once` in the `bsl` namespace.
| xref:bsl/calloc.adoc[`calloc`] 
| Alias for `std::calloc` in the `bsl` namespace.
| xref:bsl/cauchy_distribution.adoc[`cauchy_distribution`] 
| Alias for `std::cauchy_distribution` in the `bsl` namespace.
| xref:bsl/cbegin.adoc[`cbegin`] 
| Alias for `std::cbegin` in the `bsl` namespace.
| xref:bsl/cbrt.adoc[`cbrt`] 
| Alias for `std::cbrt` in the `bsl` namespace.
| xref:bsl/ceil.adoc[`ceil`] 
| Alias for `std::ceil` in the `bsl` namespace.
| xref:bsl/cend.adoc[`cend`] 
| Alias for `std::cend` in the `bsl` namespace.
| xref:bsl/centi.adoc[`centi`] 
| Alias for `std::centi`.
| xref:bsl/cerr.adoc[`cerr`] 
| Alias for `std::cerr` in the `bsl` namespace.
| xref:bsl/char_traits.adoc[`char_traits`] 
| Alias for `std::char_traits` in the `bsl` namespace.
| xref:bsl/chars_format.adoc[`chars_format`] 
| 
| xref:bsl/chi_squared_distribution.adoc[`chi_squared_distribution`] 
| Alias for `std::chi_squared_distribution` in the `bsl` namespace.
| xref:bsl/cin.adoc[`cin`] 
| Alias for `std::cin` in the `bsl` namespace.
| xref:bsl/clamp.adoc[`clamp`] 
| Alias for `std::clamp` in the `bsl` namespace.
| xref:bsl/clearerr.adoc[`clearerr`] 
| Alias for `std::clearerr` in the `bsl` namespace.
| xref:bsl/clock.adoc[`clock`] 
| Alias for `std::clock` in the `bsl` namespace.
| xref:bsl/clock_t.adoc[`clock_t`] 
| Alias for `std::clock_t` in the `bsl` namespace.
| xref:bsl/clog.adoc[`clog`] 
| Alias for `std::clog` in the `bsl` namespace.
| xref:bsl/cmatch.adoc[`cmatch`] 
| Alias for `std::cmatch` in the `bsl` namespace.
| xref:bsl/cmp_equal.adoc[`cmp_equal`] 
| Alias for `std::cmp_equal` in the `bsl` namespace.
| xref:bsl/cmp_greater.adoc[`cmp_greater`] 
| Alias for `std::cmp_greater` in the `bsl` namespace.
| xref:bsl/cmp_greater_equal.adoc[`cmp_greater_equal`] 
| Alias for `std::cmp_greater_equal` in the `bsl` namespace.
| xref:bsl/cmp_less.adoc[`cmp_less`] 
| Alias for `std::cmp_less` in the `bsl` namespace.
| xref:bsl/cmp_less_equal.adoc[`cmp_less_equal`] 
| Alias for `std::cmp_less_equal` in the `bsl` namespace.
| xref:bsl/cmp_not_equal.adoc[`cmp_not_equal`] 
| Alias for `std::cmp_not_equal` in the `bsl` namespace.
| xref:bsl/codecvt.adoc[`codecvt`] 
| Alias for `std::codecvt` in the `bsl` namespace.
| xref:bsl/codecvt_base.adoc[`codecvt_base`] 
| Alias for `std::codecvt_base` in the `bsl` namespace.
| xref:bsl/codecvt_byname.adoc[`codecvt_byname`] 
| Alias for `std::codecvt_byname` in the `bsl` namespace.
| xref:bsl/collate.adoc[`collate`] 
| Alias for `std::collate` in the `bsl` namespace.
| xref:bsl/collate_byname.adoc[`collate_byname`] 
| Alias for `std::collate_byname` in the `bsl` namespace.
| xref:bsl/common_comparison_category.adoc[`common_comparison_category`] 
| Alias for `std::common_comparison_category` in the `bsl` namespace.
| xref:bsl/common_comparison_category_t.adoc[`common_comparison_category_t`] 
| Alias for `std::common_comparison_category_t` in the `bsl` namespace.
| xref:bsl/common_iterator.adoc[`common_iterator`] 
| Alias for `std::common_iterator` in the `bsl` namespace.
| xref:bsl/common_reference.adoc[`common_reference`] 
| Alias for `std::common_reference` in the `bsl` namespace.
| xref:bsl/common_reference_t.adoc[`common_reference_t`] 
| Alias for `std::common_reference_t` in the `bsl` namespace.
| xref:bsl/common_reference_with.adoc[`common_reference_with`] 
| Alias for `std::common_reference_with` in the `bsl` namespace.
| xref:bsl/common_type.adoc[`common_type`] 
| Alias for `std::common_type` in the `bsl` namespace.
| xref:bsl/common_with.adoc[`common_with`] 
| Alias for `std::common_with` in the `bsl` namespace.
| xref:bsl/comp_ellint_1.adoc[`comp_ellint_1`] 
| 
| xref:bsl/comp_ellint_1f.adoc[`comp_ellint_1f`] 
| 
| xref:bsl/comp_ellint_1l.adoc[`comp_ellint_1l`] 
| 
| xref:bsl/comp_ellint_2.adoc[`comp_ellint_2`] 
| 
| xref:bsl/comp_ellint_2f.adoc[`comp_ellint_2f`] 
| 
| xref:bsl/comp_ellint_2l.adoc[`comp_ellint_2l`] 
| 
| xref:bsl/comp_ellint_3.adoc[`comp_ellint_3`] 
| 
| xref:bsl/comp_ellint_3f.adoc[`comp_ellint_3f`] 
| 
| xref:bsl/comp_ellint_3l.adoc[`comp_ellint_3l`] 
| 
| xref:bsl/compare_partial_order_fallback.adoc[`compare_partial_order_fallback`] 
| Alias for `std::compare_partial_order_fallback` in the `bsl` namespace.
| xref:bsl/compare_strong_order_fallback.adoc[`compare_strong_order_fallback`] 
| Alias for `std::compare_strong_order_fallback` in the `bsl` namespace.
| xref:bsl/compare_three_way.adoc[`compare_three_way`] 
| Alias for `std::compare_three_way` in the `bsl` namespace.
| xref:bsl/compare_three_way_result.adoc[`compare_three_way_result`] 
| Alias for `std::compare_three_way_result` in the `bsl` namespace.
| xref:bsl/compare_three_way_result_t.adoc[`compare_three_way_result_t`] 
| Alias for `std::compare_three_way_result_t` in the `bsl` namespace.
| xref:bsl/compare_weak_order_fallback.adoc[`compare_weak_order_fallback`] 
| Alias for `std::compare_weak_order_fallback` in the `bsl` namespace.
| xref:bsl/complex.adoc[`complex`] 
| Alias for `std::complex` in the `bsl` namespace.
| xref:bsl/condition_variable.adoc[`condition_variable`] 
| Alias for `std::condition_variable` in the `bsl` namespace.
| xref:bsl/condition_variable_any.adoc[`condition_variable_any`] 
| Alias for `std::condition_variable_any` in the `bsl` namespace.
| xref:bsl/conj.adoc[`conj`] 
| Alias for `std::conj` in the `bsl` namespace.
| xref:bsl/conjunction.adoc[`conjunction`] 
| Alias for `std::conjunction` in the `bsl` namespace.
| xref:bsl/conjunction_v.adoc[`conjunction_v`] 
| Alias for `std::conjunction_v` in the `bsl` namespace.
| xref:bsl/const_iterator.adoc[`const_iterator`] 
| Alias for `std::const_iterator` in the `bsl` namespace.
| xref:bsl/const_mem_fun1_ref_t.adoc[`const_mem_fun1_ref_t`] 
| Alias for `std::const_mem_fun1_ref_t` in the `bsl` namespace.
| xref:bsl/const_mem_fun1_t.adoc[`const_mem_fun1_t`] 
| Alias for `std::const_mem_fun1_t` in the `bsl` namespace.
| xref:bsl/const_mem_fun_ref_t.adoc[`const_mem_fun_ref_t`] 
| Alias for `std::const_mem_fun_ref_t` in the `bsl` namespace.
| xref:bsl/const_mem_fun_t.adoc[`const_mem_fun_t`] 
| Alias for `std::const_mem_fun_t` in the `bsl` namespace.
| xref:bsl/const_sentinel.adoc[`const_sentinel`] 
| Alias for `std::const_sentinel` in the `bsl` namespace.
| xref:bsl/construct_at.adoc[`construct_at`] 
| Alias for `std::construct_at` in the `bsl` namespace.
| xref:bsl/constructible_from.adoc[`constructible_from`] 
| Alias for `std::constructible_from` in the `bsl` namespace.
| xref:bsl/contiguous_iterator.adoc[`contiguous_iterator`] 
| Alias for `std::contiguous_iterator` in the `bsl` namespace.
| xref:bsl/contiguous_iterator_tag.adoc[`contiguous_iterator_tag`] 
| Alias for `std::contiguous_iterator_tag` in the `bsl` namespace.
| xref:bsl/convertible_to.adoc[`convertible_to`] 
| Alias for `std::convertible_to` in the `bsl` namespace.
| xref:bsl/copy-05.adoc[`copy`] 
| Alias for `std::copy` in the `bsl` namespace.
| xref:bsl/copy-0b.adoc[`copy`] 
| Alias for `std::copy` in the `bsl` namespace.
| xref:bsl/copy_backward.adoc[`copy_backward`] 
| Alias for `std::copy_backward` in the `bsl` namespace.
| xref:bsl/copy_constructible.adoc[`copy_constructible`] 
| Alias for `std::copy_constructible` in the `bsl` namespace.
| xref:bsl/copy_if.adoc[`copy_if`] 
| Alias for `std::copy_if` in the `bsl` namespace.
| xref:bsl/copy_n.adoc[`copy_n`] 
| Alias for `std::copy_n` in the `bsl` namespace.
| xref:bsl/copyable.adoc[`copyable`] 
| Alias for `std::copyable` in the `bsl` namespace.
| xref:bsl/copysign.adoc[`copysign`] 
| Alias for `std::copysign` in the `bsl` namespace.
| xref:bsl/coroutine_handle.adoc[`coroutine_handle`] 
| Alias for `std::coroutine_handle` in the `bsl` namespace.
| xref:bsl/coroutine_traits.adoc[`coroutine_traits`] 
| Alias for `std::coroutine_traits` in the `bsl` namespace.
| xref:bsl/cos-0e7.adoc[`cos`] 
| Alias for `std::cos` in the `bsl` namespace.
| xref:bsl/cos-04.adoc[`cos`] 
| Alias for `std::cos` in the `bsl` namespace.
| xref:bsl/cos-0ef.adoc[`cos`] 
| Alias for `std::cos` in the `bsl` namespace.
| xref:bsl/cosh-06.adoc[`cosh`] 
| Alias for `std::cosh` in the `bsl` namespace.
| xref:bsl/cosh-0c.adoc[`cosh`] 
| Alias for `std::cosh` in the `bsl` namespace.
| xref:bsl/cosh-02.adoc[`cosh`] 
| Alias for `std::cosh` in the `bsl` namespace.
| xref:bsl/count.adoc[`count`] 
| Alias for `std::count` in the `bsl` namespace.
| xref:bsl/count_if.adoc[`count_if`] 
| Alias for `std::count_if` in the `bsl` namespace.
| xref:bsl/counted_iterator.adoc[`counted_iterator`] 
| Alias for `std::counted_iterator` in the `bsl` namespace.
| xref:bsl/counting_semaphore.adoc[`counting_semaphore`] 
| Alias for `std::counting_semaphore` in the `bsl` namespace.
| xref:bsl/countl_one.adoc[`countl_one`] 
| Alias for `std::countl_one` in the `bsl` namespace.
| xref:bsl/countl_zero.adoc[`countl_zero`] 
| Alias for `std::countl_zero` in the `bsl` namespace.
| xref:bsl/countr_one.adoc[`countr_one`] 
| Alias for `std::countr_one` in the `bsl` namespace.
| xref:bsl/countr_zero.adoc[`countr_zero`] 
| Alias for `std::countr_zero` in the `bsl` namespace.
| xref:bsl/cout.adoc[`cout`] 
| Import `std::cout` into the `bsl` namespace.
| xref:bsl/crbegin.adoc[`crbegin`] 
| Alias for `std::crbegin` in the `bsl` namespace.
| xref:bsl/cref.adoc[`cref`] 
| Alias for `std::cref` in the `bsl` namespace.
| xref:bsl/cregex_iterator.adoc[`cregex_iterator`] 
| Alias for `std::cregex_iterator` in the `bsl` namespace.
| xref:bsl/crend.adoc[`crend`] 
| Alias for `std::crend` in the `bsl` namespace.
| xref:bsl/csub_match.adoc[`csub_match`] 
| Alias for `std::csub_match` in the `bsl` namespace.
| xref:bsl/ctime.adoc[`ctime`] 
| Alias for `std::ctime` in the `bsl` namespace.
| xref:bsl/ctype.adoc[`ctype`] 
| Alias for `std::ctype` in the `bsl` namespace.
| xref:bsl/ctype_base.adoc[`ctype_base`] 
| Alias for `std::ctype_base` in the `bsl` namespace.
| xref:bsl/ctype_byname.adoc[`ctype_byname`] 
| Alias for `std::ctype_byname` in the `bsl` namespace.
| xref:bsl/current_exception.adoc[`current_exception`] 
| Undocumented symbol.
| xref:bsl/cv_status.adoc[`cv_status`] 
| Alias for `std::cv_status` in the `bsl` namespace.
| xref:bsl/cyl_bessel_i.adoc[`cyl_bessel_i`] 
| 
| xref:bsl/cyl_bessel_if.adoc[`cyl_bessel_if`] 
| 
| xref:bsl/cyl_bessel_il.adoc[`cyl_bessel_il`] 
| 
| xref:bsl/cyl_bessel_j.adoc[`cyl_bessel_j`] 
| 
| xref:bsl/cyl_bessel_jf.adoc[`cyl_bessel_jf`] 
| 
| xref:bsl/cyl_bessel_jl.adoc[`cyl_bessel_jl`] 
| 
| xref:bsl/cyl_bessel_k.adoc[`cyl_bessel_k`] 
| 
| xref:bsl/cyl_bessel_kf.adoc[`cyl_bessel_kf`] 
| 
| xref:bsl/cyl_bessel_kl.adoc[`cyl_bessel_kl`] 
| 
| xref:bsl/cyl_neumann.adoc[`cyl_neumann`] 
| 
| xref:bsl/cyl_neumannf.adoc[`cyl_neumannf`] 
| 
| xref:bsl/cyl_neumannl.adoc[`cyl_neumannl`] 
| 
| xref:bsl/data.adoc[`data`] 
| Alias for `std::data` in the `bsl` namespace.
| xref:bsl/dec.adoc[`dec`] 
| Alias for `std::dec` in the `bsl` namespace.
| xref:bsl/deca.adoc[`deca`] 
| Alias for `std::deca`.
| xref:bsl/deci.adoc[`deci`] 
| Alias for `std::deci`.
| xref:bsl/declval.adoc[`declval`] 
| Alias for `std::declval` in the `bsl` namespace.
| xref:bsl/default_delete.adoc[`default_delete`] 
| Alias for `std::default_delete` in the `bsl` namespace.
| xref:bsl/default_initializable.adoc[`default_initializable`] 
| Alias for `std::default_initializable` in the `bsl` namespace.
| xref:bsl/default_random_engine.adoc[`default_random_engine`] 
| Alias for `std::default_random_engine` in the `bsl` namespace.
| xref:bsl/default_searcher.adoc[`default_searcher`] 
| Alias for `std::default_searcher` in the `bsl` namespace.
| xref:bsl/default_sentinel_t.adoc[`default_sentinel_t`] 
| Alias for `std::default_sentinel_t` in the `bsl` namespace.
| xref:bsl/defaultfloat.adoc[`defaultfloat`] 
| Alias for `std::defaultfloat` in the `bsl` namespace.
| xref:bsl/defer_lock.adoc[`defer_lock`] 
| Alias for `std::defer_lock` in the `bsl` namespace.
| xref:bsl/defer_lock_t.adoc[`defer_lock_t`] 
| Alias for `std::defer_lock_t` in the `bsl` namespace.
| xref:bsl/denorm_absent.adoc[`denorm_absent`] 
| Alias for `std::denorm_absent` in the `bsl` namespace.
| xref:bsl/denorm_indeterminate.adoc[`denorm_indeterminate`] 
| Alias for `std::denorm_indeterminate` in the `bsl` namespace.
| xref:bsl/denorm_present.adoc[`denorm_present`] 
| Alias for `std::denorm_present` in the `bsl` namespace.
| xref:bsl/derived_from.adoc[`derived_from`] 
| Alias for `std::derived_from` in the `bsl` namespace.
| xref:bsl/destroy.adoc[`destroy`] 
| Alias for `std::destroy` in the `bsl` namespace.
| xref:bsl/destroy_at.adoc[`destroy_at`] 
| Alias for `std::destroy_at` in the `bsl` namespace.
| xref:bsl/destroy_n.adoc[`destroy_n`] 
| Alias for `std::destroy_n` in the `bsl` namespace.
| xref:bsl/destructible.adoc[`destructible`] 
| Alias for `std::destructible` in the `bsl` namespace.
| xref:bsl/difftime.adoc[`difftime`] 
| Alias for `std::difftime` in the `bsl` namespace.
| xref:bsl/discard_block_engine.adoc[`discard_block_engine`] 
| Alias for `std::discard_block_engine` in the `bsl` namespace.
| xref:bsl/discrete_distribution.adoc[`discrete_distribution`] 
| Alias for `std::discrete_distribution` in the `bsl` namespace.
| xref:bsl/disjunction.adoc[`disjunction`] 
| Alias for `std::disjunction` in the `bsl` namespace.
| xref:bsl/disjunction_v.adoc[`disjunction_v`] 
| Alias for `std::disjunction_v` in the `bsl` namespace.
| xref:bsl/distance.adoc[`distance`] 
| Alias for `std::distance` in the `bsl` namespace.
| xref:bsl/div.adoc[`div`] 
| Alias for `std::div` in the `bsl` namespace.
| xref:bsl/div_t.adoc[`div_t`] 
| Alias for `std::div_t` in the `bsl` namespace.
| xref:bsl/divides.adoc[`divides`] 
| Alias for `std::divides` in the `bsl` namespace.
| xref:bsl/domain_error.adoc[`domain_error`] 
| Alias for `std::domain_error` in the `bsl` namespace.
| xref:bsl/double_t.adoc[`double_t`] 
| Alias for `std::double_t` in the `bsl` namespace.
| xref:bsl/dynamic_extent.adoc[`dynamic_extent`] 
| Alias for `std::dynamic_extent`.
| xref:bsl/ellint_1.adoc[`ellint_1`] 
| 
| xref:bsl/ellint_1f.adoc[`ellint_1f`] 
| 
| xref:bsl/ellint_1l.adoc[`ellint_1l`] 
| 
| xref:bsl/ellint_2.adoc[`ellint_2`] 
| 
| xref:bsl/ellint_2f.adoc[`ellint_2f`] 
| 
| xref:bsl/ellint_2l.adoc[`ellint_2l`] 
| 
| xref:bsl/ellint_3.adoc[`ellint_3`] 
| 
| xref:bsl/ellint_3f.adoc[`ellint_3f`] 
| 
| xref:bsl/ellint_3l.adoc[`ellint_3l`] 
| 
| xref:bsl/empty.adoc[`empty`] 
| Alias for `std::empty` in the `bsl` namespace.
| xref:bsl/end-01.adoc[`end`] 
| Alias for `std::end` in the `bsl` namespace.
| xref:bsl/end-04e.adoc[`end`] 
| Alias for `std::end` in the `bsl` namespace.
| xref:bsl/end-04f.adoc[`end`] 
| Alias for `std::end` in the `bsl` namespace.
| xref:bsl/endian.adoc[`endian`] 
| Alias for `std::endian` in the `bsl` namespace.
| xref:bsl/endl.adoc[`endl`] 
| Alias for `std::endl` in the `bsl` namespace.
| xref:bsl/ends.adoc[`ends`] 
| Alias for `std::ends` in the `bsl` namespace.
| xref:bsl/equal.adoc[`equal`] 
| Alias for `std::equal` in the `bsl` namespace.
| xref:bsl/equal_range.adoc[`equal_range`] 
| Alias for `std::equal_range` in the `bsl` namespace.
| xref:bsl/equality_comparable.adoc[`equality_comparable`] 
| Alias for `std::equality_comparable` in the `bsl` namespace.
| xref:bsl/equality_comparable_with.adoc[`equality_comparable_with`] 
| Alias for `std::equality_comparable_with` in the `bsl` namespace.
| xref:bsl/equivalence_relation.adoc[`equivalence_relation`] 
| Alias for `std::equivalence_relation` in the `bsl` namespace.
| xref:bsl/erf.adoc[`erf`] 
| Alias for `std::erf` in the `bsl` namespace.
| xref:bsl/erfc.adoc[`erfc`] 
| Alias for `std::erfc` in the `bsl` namespace.
| xref:bsl/errc.adoc[`errc`] 
| Alias for `std::errc` in the `bsl` namespace.
| xref:bsl/error_category.adoc[`error_category`] 
| Alias for `std::error_category` in the `bsl` namespace.
| xref:bsl/error_code.adoc[`error_code`] 
| Alias for `std::error_code` in the `bsl` namespace.
| xref:bsl/error_condition.adoc[`error_condition`] 
| Alias for `std::error_condition` in the `bsl` namespace.
| xref:bsl/exa.adoc[`exa`] 
| Alias for `std::exa`.
| xref:bsl/exception.adoc[`exception`] 
| Alias for `std::exception` in the `bsl` namespace.
| xref:bsl/exception_ptr.adoc[`exception_ptr`] 
| Undocumented symbol.
| xref:bsl/exchange.adoc[`exchange`] 
| Alias for `std::exchange` in the `bsl` namespace.
| xref:bsl/exclusive_scan.adoc[`exclusive_scan`] 
| Alias for `std::exclusive_scan` in the `bsl` namespace.
| xref:bsl/exit.adoc[`exit`] 
| Import `std::exit` into the `bsl` namespace.
| xref:bsl/exp-03.adoc[`exp`] 
| Alias for `std::exp` in the `bsl` namespace.
| xref:bsl/exp-01.adoc[`exp`] 
| Alias for `std::exp` in the `bsl` namespace.
| xref:bsl/exp-0f.adoc[`exp`] 
| Alias for `std::exp` in the `bsl` namespace.
| xref:bsl/exp2.adoc[`exp2`] 
| Alias for `std::exp2` in the `bsl` namespace.
| xref:bsl/expint.adoc[`expint`] 
| 
| xref:bsl/expintf.adoc[`expintf`] 
| 
| xref:bsl/expintl.adoc[`expintl`] 
| 
| xref:bsl/expm1.adoc[`expm1`] 
| Alias for `std::expm1` in the `bsl` namespace.
| xref:bsl/exponential_distribution.adoc[`exponential_distribution`] 
| Alias for `std::exponential_distribution` in the `bsl` namespace.
| xref:bsl/extent.adoc[`extent`] 
| Alias for `std::extent` in the `bsl` namespace.
| xref:bsl/extreme_value_distribution.adoc[`extreme_value_distribution`] 
| Alias for `std::extreme_value_distribution` in the `bsl` namespace.
| xref:bsl/fabs.adoc[`fabs`] 
| Alias for `std::fabs` in the `bsl` namespace.
| xref:bsl/fclose.adoc[`fclose`] 
| Alias for `std::fclose` in the `bsl` namespace.
| xref:bsl/fdim.adoc[`fdim`] 
| Alias for `std::fdim` in the `bsl` namespace.
| xref:bsl/feclearexcept.adoc[`feclearexcept`] 
| Alias for `std::feclearexcept` in the `bsl` namespace.
| xref:bsl/fegetenv.adoc[`fegetenv`] 
| Alias for `std::fegetenv` in the `bsl` namespace.
| xref:bsl/fegetexceptflag.adoc[`fegetexceptflag`] 
| Alias for `std::fegetexceptflag` in the `bsl` namespace.
| xref:bsl/fegetround.adoc[`fegetround`] 
| Alias for `std::fegetround` in the `bsl` namespace.
| xref:bsl/feholdexcept.adoc[`feholdexcept`] 
| Alias for `std::feholdexcept` in the `bsl` namespace.
| xref:bsl/femto.adoc[`femto`] 
| Alias for `std::femto`.
| xref:bsl/fenv_t.adoc[`fenv_t`] 
| Alias for `std::fenv_t` in the `bsl` namespace.
| xref:bsl/feof.adoc[`feof`] 
| Alias for `std::feof` in the `bsl` namespace.
| xref:bsl/feraiseexcept.adoc[`feraiseexcept`] 
| Alias for `std::feraiseexcept` in the `bsl` namespace.
| xref:bsl/ferror.adoc[`ferror`] 
| Alias for `std::ferror` in the `bsl` namespace.
| xref:bsl/fesetenv.adoc[`fesetenv`] 
| Alias for `std::fesetenv` in the `bsl` namespace.
| xref:bsl/fesetexceptflag.adoc[`fesetexceptflag`] 
| Alias for `std::fesetexceptflag` in the `bsl` namespace.
| xref:bsl/fesetround.adoc[`fesetround`] 
| Alias for `std::fesetround` in the `bsl` namespace.
| xref:bsl/fetestexcept.adoc[`fetestexcept`] 
| Alias for `std::fetestexcept` in the `bsl` namespace.
| xref:bsl/feupdateenv.adoc[`feupdateenv`] 
| Alias for `std::feupdateenv` in the `bsl` namespace.
| xref:bsl/fexcept_t.adoc[`fexcept_t`] 
| Alias for `std::fexcept_t` in the `bsl` namespace.
| xref:bsl/fflush.adoc[`fflush`] 
| Alias for `std::fflush` in the `bsl` namespace.
| xref:bsl/fgetc.adoc[`fgetc`] 
| Alias for `std::fgetc` in the `bsl` namespace.
| xref:bsl/fgetpos.adoc[`fgetpos`] 
| Alias for `std::fgetpos` in the `bsl` namespace.
| xref:bsl/fgets.adoc[`fgets`] 
| Alias for `std::fgets` in the `bsl` namespace.
| xref:bsl/fgetwc.adoc[`fgetwc`] 
| Alias for `std::fgetwc` in the `bsl` namespace.
| xref:bsl/fgetws.adoc[`fgetws`] 
| Alias for `std::fgetws` in the `bsl` namespace.
| xref:bsl/filebuf.adoc[`filebuf`] 
| Alias for `std::filebuf` in the `bsl` namespace.
| xref:bsl/fill.adoc[`fill`] 
| Alias for `std::fill` in the `bsl` namespace.
| xref:bsl/fill_n.adoc[`fill_n`] 
| Alias for `std::fill_n` in the `bsl` namespace.
| xref:bsl/find-00.adoc[`find`] 
| Alias for `std::find` in the `bsl` namespace.
| xref:bsl/find-08.adoc[`find`] 
| Alias for `std::find` in the `bsl` namespace.
| xref:bsl/find_end.adoc[`find_end`] 
| Alias for `std::find_end` in the `bsl` namespace.
| xref:bsl/find_first_of.adoc[`find_first_of`] 
| Alias for `std::find_first_of` in the `bsl` namespace.
| xref:bsl/find_if.adoc[`find_if`] 
| Alias for `std::find_if` in the `bsl` namespace.
| xref:bsl/find_if_not.adoc[`find_if_not`] 
| Alias for `std::find_if_not` in the `bsl` namespace.
| xref:bsl/fisher_f_distribution.adoc[`fisher_f_distribution`] 
| Alias for `std::fisher_f_distribution` in the `bsl` namespace.
| xref:bsl/fixed.adoc[`fixed`] 
| Alias for `std::fixed` in the `bsl` namespace.
| xref:bsl/float_denorm_style.adoc[`float_denorm_style`] 
| Alias for `std::float_denorm_style` in the `bsl` namespace.
| xref:bsl/float_round_style.adoc[`float_round_style`] 
| Alias for `std::float_round_style` in the `bsl` namespace.
| xref:bsl/float_t.adoc[`float_t`] 
| Alias for `std::float_t` in the `bsl` namespace.
| xref:bsl/floating_point.adoc[`floating_point`] 
| Alias for `std::floating_point` in the `bsl` namespace.
| xref:bsl/floor.adoc[`floor`] 
| Alias for `std::floor` in the `bsl` namespace.
| xref:bsl/flush.adoc[`flush`] 
| Alias for `std::flush` in the `bsl` namespace.
| xref:bsl/fma.adoc[`fma`] 
| Alias for `std::fma` in the `bsl` namespace.
| xref:bsl/fmax.adoc[`fmax`] 
| Alias for `std::fmax` in the `bsl` namespace.
| xref:bsl/fmin.adoc[`fmin`] 
| Alias for `std::fmin` in the `bsl` namespace.
| xref:bsl/fmod.adoc[`fmod`] 
| Alias for `std::fmod` in the `bsl` namespace.
| xref:bsl/fopen.adoc[`fopen`] 
| Alias for `std::fopen` in the `bsl` namespace.
| xref:bsl/for_each.adoc[`for_each`] 
| Alias for `std::for_each` in the `bsl` namespace.
| xref:bsl/for_each_n.adoc[`for_each_n`] 
| Alias for `std::for_each_n` in the `bsl` namespace.
| xref:bsl/format_args.adoc[`format_args`] 
| Alias for `std::format_args` in the `bsl` namespace.
| xref:bsl/format_context.adoc[`format_context`] 
| Alias for `std::format_context` in the `bsl` namespace.
| xref:bsl/format_error.adoc[`format_error`] 
| Alias for `std::format_error` in the `bsl` namespace.
| xref:bsl/format_parse_context.adoc[`format_parse_context`] 
| Alias for `std::format_parse_context` in the `bsl` namespace.
| xref:bsl/format_string.adoc[`format_string`] 
| Alias for `std::format_string` in the `bsl` namespace.
| xref:bsl/format_to-02.adoc[`format_to`] 
| Alias for `std::format_to` in the `bsl` namespace.
| xref:bsl/format_to_n.adoc[`format_to_n`] 
| Alias for `std::format_to_n` in the `bsl` namespace.
| xref:bsl/format_to_n_result.adoc[`format_to_n_result`] 
| Alias for `std::format_to_n_result` in the `bsl` namespace.
| xref:bsl/formattable.adoc[`formattable`] 
| Import `std::formattable` into namespace `bsl`.
| xref:bsl/formatted_size.adoc[`formatted_size`] 
| Alias for `std::formatted_size` in the `bsl` namespace.
| xref:bsl/forward.adoc[`forward`] 
| Alias for `std::forward` in the `bsl` namespace.
| xref:bsl/forward_as_tuple.adoc[`forward_as_tuple`] 
| Alias for `std::forward_as_tuple` in the `bsl` namespace.
| xref:bsl/forward_iterator.adoc[`forward_iterator`] 
| Alias for `std::forward_iterator` in the `bsl` namespace.
| xref:bsl/forward_iterator_tag.adoc[`forward_iterator_tag`] 
| Alias for `std::forward_iterator_tag` in the `bsl` namespace.
| xref:bsl/forward_like.adoc[`forward_like`] 
| Alias for `std::forward_like` in the `bsl` namespace.
| xref:bsl/fpclassify.adoc[`fpclassify`] 
| Alias for `std::fpclassify` in the `bsl` namespace.
| xref:bsl/fpos.adoc[`fpos`] 
| Alias for `std::fpos` in the `bsl` namespace.
| xref:bsl/fpos_t.adoc[`fpos_t`] 
| Alias for `std::fpos_t` in the `bsl` namespace.
| xref:bsl/fprintf.adoc[`fprintf`] 
| Alias for `std::fprintf` in the `bsl` namespace.
| xref:bsl/fputc.adoc[`fputc`] 
| Alias for `std::fputc` in the `bsl` namespace.
| xref:bsl/fputs.adoc[`fputs`] 
| Alias for `std::fputs` in the `bsl` namespace.
| xref:bsl/fputwc.adoc[`fputwc`] 
| Alias for `std::fputwc` in the `bsl` namespace.
| xref:bsl/fputws.adoc[`fputws`] 
| Alias for `std::fputws` in the `bsl` namespace.
| xref:bsl/fread.adoc[`fread`] 
| Alias for `std::fread` in the `bsl` namespace.
| xref:bsl/free.adoc[`free`] 
| Alias for `std::free` in the `bsl` namespace.
| xref:bsl/freopen.adoc[`freopen`] 
| Alias for `std::freopen` in the `bsl` namespace.
| xref:bsl/frexp.adoc[`frexp`] 
| Alias for `std::frexp` in the `bsl` namespace.
| xref:bsl/from_chars.adoc[`from_chars`] 
| 
| xref:bsl/from_chars_result.adoc[`from_chars_result`] 
| 
| xref:bsl/from_range.adoc[`from_range`] 
| Alias for `std::from_range` in the `bsl` namespace.
| xref:bsl/from_range_t.adoc[`from_range_t`] 
| Alias for `std::from_range_t` in the `bsl` namespace.
| xref:bsl/front_insert_iterator.adoc[`front_insert_iterator`] 
| Alias for `std::front_insert_iterator` in the `bsl` namespace.
| xref:bsl/front_inserter.adoc[`front_inserter`] 
| Standard library alias for `std::front_inserter`.
| xref:bsl/fscanf.adoc[`fscanf`] 
| Alias for `std::fscanf` in the `bsl` namespace.
| xref:bsl/fseek.adoc[`fseek`] 
| Alias for `std::fseek` in the `bsl` namespace.
| xref:bsl/fsetpos.adoc[`fsetpos`] 
| Alias for `std::fsetpos` in the `bsl` namespace.
| xref:bsl/fstream.adoc[`fstream`] 
| Alias for `std::fstream` in the `bsl` namespace.
| xref:bsl/ftell.adoc[`ftell`] 
| Alias for `std::ftell` in the `bsl` namespace.
| xref:bsl/future.adoc[`future`] 
| Alias for `std::future` in the `bsl` namespace.
| xref:bsl/future_category.adoc[`future_category`] 
| Alias for `std::future_category` in the `bsl` namespace.
| xref:bsl/future_errc.adoc[`future_errc`] 
| Alias for `std::future_errc` in the `bsl` namespace.
| xref:bsl/future_error.adoc[`future_error`] 
| Alias for `std::future_error` in the `bsl` namespace.
| xref:bsl/future_status.adoc[`future_status`] 
| Alias for `std::future_status` in the `bsl` namespace.
| xref:bsl/fwide.adoc[`fwide`] 
| Alias for `std::fwide` in the `bsl` namespace.
| xref:bsl/fwprintf.adoc[`fwprintf`] 
| Alias for `std::fwprintf` in the `bsl` namespace.
| xref:bsl/fwrite.adoc[`fwrite`] 
| Alias for `std::fwrite` in the `bsl` namespace.
| xref:bsl/fwscanf.adoc[`fwscanf`] 
| Alias for `std::fwscanf` in the `bsl` namespace.
| xref:bsl/gamma_distribution.adoc[`gamma_distribution`] 
| Alias for `std::gamma_distribution` in the `bsl` namespace.
| xref:bsl/gcd.adoc[`gcd`] 
| Alias for `std::gcd` in the `bsl` namespace.
| xref:bsl/generate.adoc[`generate`] 
| Alias for `std::generate` in the `bsl` namespace.
| xref:bsl/generate_canonical.adoc[`generate_canonical`] 
| Alias for `std::generate_canonical` in the `bsl` namespace.
| xref:bsl/generate_n.adoc[`generate_n`] 
| Alias for `std::generate_n` in the `bsl` namespace.
| xref:bsl/generic_category.adoc[`generic_category`] 
| Alias for `std::generic_category` in the `bsl` namespace.
| xref:bsl/geometric_distribution.adoc[`geometric_distribution`] 
| Alias for `std::geometric_distribution` in the `bsl` namespace.
| xref:bsl/get-09.adoc[`get`] 
| Alias for `std::get` in the `bsl` namespace.
| xref:bsl/get-0c.adoc[`get`] 
| Alias for `std::get` in the `bsl` namespace.
| xref:bsl/get_money.adoc[`get_money`] 
| Alias for `std::get_money` in the `bsl` namespace.
| xref:bsl/get_new_handler.adoc[`get_new_handler`] 
| Alias for `std::get_new_handler` in the `bsl` namespace.
| xref:bsl/get_temporary_buffer.adoc[`get_temporary_buffer`] 
| Alias for `std::get_temporary_buffer` in the `bsl` namespace.
| xref:bsl/get_terminate.adoc[`get_terminate`] 
| Undocumented symbol.
| xref:bsl/get_time.adoc[`get_time`] 
| Alias for `std::get_time` in the `bsl` namespace.
| xref:bsl/getc.adoc[`getc`] 
| Alias for `std::getc` in the `bsl` namespace.
| xref:bsl/getchar.adoc[`getchar`] 
| Alias for `std::getchar` in the `bsl` namespace.
| xref:bsl/getenv.adoc[`getenv`] 
| Import `std::getenv` into the `bsl` namespace.
| xref:bsl/getwc.adoc[`getwc`] 
| Alias for `std::getwc` in the `bsl` namespace.
| xref:bsl/getwchar.adoc[`getwchar`] 
| Alias for `std::getwchar` in the `bsl` namespace.
| xref:bsl/giga.adoc[`giga`] 
| Alias for `std::giga`.
| xref:bsl/gmtime.adoc[`gmtime`] 
| Alias for `std::gmtime` in the `bsl` namespace.
| xref:bsl/greater.adoc[`greater`] 
| Alias for `std::greater` in the `bsl` namespace.
| xref:bsl/greater_equal.adoc[`greater_equal`] 
| Alias for `std::greater_equal` in the `bsl` namespace.
| xref:bsl/gslice.adoc[`gslice`] 
| Alias for `std::gslice` in the `bsl` namespace.
| xref:bsl/gslice_array.adoc[`gslice_array`] 
| Alias for `std::gslice_array` in the `bsl` namespace.
| xref:bsl/hardware_constructive_interference_size.adoc[`hardware_constructive_interference_size`] 
| Alias for `std::hardware_constructive_interference_size` in the `bsl` namespace.
| xref:bsl/hardware_destructive_interference_size.adoc[`hardware_destructive_interference_size`] 
| Alias for `std::hardware_destructive_interference_size` in the `bsl` namespace.
| xref:bsl/has_facet.adoc[`has_facet`] 
| Alias for `std::has_facet` in the `bsl` namespace.
| xref:bsl/has_single_bit.adoc[`has_single_bit`] 
| Alias for `std::has_single_bit` in the `bsl` namespace.
| xref:bsl/has_unique_object_representations.adoc[`has_unique_object_representations`] 
| Alias for `std::has_unique_object_representations` in the `bsl` namespace.
| xref:bsl/has_virtual_destructor.adoc[`has_virtual_destructor`] 
| Alias for `std::has_virtual_destructor` in the `bsl` namespace.
| xref:bsl/hecto.adoc[`hecto`] 
| Alias for `std::hecto`.
| xref:bsl/hermite.adoc[`hermite`] 
| 
| xref:bsl/hermitef.adoc[`hermitef`] 
| 
| xref:bsl/hermitel.adoc[`hermitel`] 
| 
| xref:bsl/hex.adoc[`hex`] 
| Alias for `std::hex` in the `bsl` namespace.
| xref:bsl/hexfloat.adoc[`hexfloat`] 
| Alias for `std::hexfloat` in the `bsl` namespace.
| xref:bsl/hypot.adoc[`hypot`] 
| Alias for `std::hypot` in the `bsl` namespace.
| xref:bsl/ifstream.adoc[`ifstream`] 
| Alias for `std::ifstream` in the `bsl` namespace.
| xref:bsl/ignore.adoc[`ignore`] 
| Alias for `std::ignore` in the `bsl` namespace.
| xref:bsl/ilogb.adoc[`ilogb`] 
| Alias for `std::ilogb` in the `bsl` namespace.
| xref:bsl/imag.adoc[`imag`] 
| Alias for `std::imag` in the `bsl` namespace.
| xref:bsl/imaxabs.adoc[`imaxabs`] 
| Alias for `std::imaxabs` in the `bsl` namespace.
| xref:bsl/imaxdiv.adoc[`imaxdiv`] 
| Alias for `std::imaxdiv` in the `bsl` namespace.
| xref:bsl/imaxdiv_t.adoc[`imaxdiv_t`] 
| Alias for `std::imaxdiv_t` in the `bsl` namespace.
| xref:bsl/in_place.adoc[`in_place`] 
| Alias for `std::in_place` in the `bsl` namespace.
| xref:bsl/in_place_index.adoc[`in_place_index`] 
| Alias for `std::in_place_index` in the `bsl` namespace.
| xref:bsl/in_place_index_t.adoc[`in_place_index_t`] 
| Alias for `std::in_place_index_t` in the `bsl` namespace.
| xref:bsl/in_place_t.adoc[`in_place_t`] 
| Alias for `std::in_place_t` in the `bsl` namespace.
| xref:bsl/in_place_type.adoc[`in_place_type`] 
| Alias for `std::in_place_type` in the `bsl` namespace.
| xref:bsl/in_place_type_t.adoc[`in_place_type_t`] 
| Alias for `std::in_place_type_t` in the `bsl` namespace.
| xref:bsl/in_range.adoc[`in_range`] 
| Alias for `std::in_range` in the `bsl` namespace.
| xref:bsl/includes.adoc[`includes`] 
| Alias for `std::includes` in the `bsl` namespace.
| xref:bsl/inclusive_scan.adoc[`inclusive_scan`] 
| Alias for `std::inclusive_scan` in the `bsl` namespace.
| xref:bsl/incrementable.adoc[`incrementable`] 
| Alias for `std::incrementable` in the `bsl` namespace.
| xref:bsl/incrementable_traits.adoc[`incrementable_traits`] 
| Alias for `std::incrementable_traits` in the `bsl` namespace.
| xref:bsl/independent_bits_engine.adoc[`independent_bits_engine`] 
| Alias for `std::independent_bits_engine` in the `bsl` namespace.
| xref:bsl/index_sequence.adoc[`index_sequence`] 
| Alias for `std::index_sequence` in the `bsl` namespace.
| xref:bsl/index_sequence_for.adoc[`index_sequence_for`] 
| Alias for `std::index_sequence_for` in the `bsl` namespace.
| xref:bsl/indirect_array.adoc[`indirect_array`] 
| Alias for `std::indirect_array` in the `bsl` namespace.
| xref:bsl/indirect_binary_predicate.adoc[`indirect_binary_predicate`] 
| Alias for `std::indirect_binary_predicate` in the `bsl` namespace.
| xref:bsl/indirect_equivalence_relation.adoc[`indirect_equivalence_relation`] 
| Alias for `std::indirect_equivalence_relation` in the `bsl` namespace.
| xref:bsl/indirect_result_t.adoc[`indirect_result_t`] 
| Alias for `std::indirect_result_t` in the `bsl` namespace.
| xref:bsl/indirect_strict_weak_order.adoc[`indirect_strict_weak_order`] 
| Alias for `std::indirect_strict_weak_order` in the `bsl` namespace.
| xref:bsl/indirect_unary_predicate.adoc[`indirect_unary_predicate`] 
| Standard library alias for `std::indirect_unary_predicate`.
| xref:bsl/indirectly_comparable.adoc[`indirectly_comparable`] 
| Alias for `std::indirectly_comparable` in the `bsl` namespace.
| xref:bsl/indirectly_copyable.adoc[`indirectly_copyable`] 
| Alias for `std::indirectly_copyable` in the `bsl` namespace.
| xref:bsl/indirectly_copyable_storable.adoc[`indirectly_copyable_storable`] 
| Alias for `std::indirectly_copyable_storable` in the `bsl` namespace.
| xref:bsl/indirectly_movable.adoc[`indirectly_movable`] 
| Alias for `std::indirectly_movable` in the `bsl` namespace.
| xref:bsl/indirectly_movable_storable.adoc[`indirectly_movable_storable`] 
| Alias for `std::indirectly_movable_storable` in the `bsl` namespace.
| xref:bsl/indirectly_readable.adoc[`indirectly_readable`] 
| Alias for `std::indirectly_readable` in the `bsl` namespace.
| xref:bsl/indirectly_readable_traits.adoc[`indirectly_readable_traits`] 
| Alias for `std::indirectly_readable_traits` in the `bsl` namespace.
| xref:bsl/indirectly_regular_unary_invocable.adoc[`indirectly_regular_unary_invocable`] 
| Alias for `std::indirectly_regular_unary_invocable` in the `bsl` namespace.
| xref:bsl/indirectly_swappable.adoc[`indirectly_swappable`] 
| Alias for `std::indirectly_swappable` in the `bsl` namespace.
| xref:bsl/indirectly_unary_invocable.adoc[`indirectly_unary_invocable`] 
| Alias for `std::indirectly_unary_invocable` in the `bsl` namespace.
| xref:bsl/indirectly_writable.adoc[`indirectly_writable`] 
| Alias for `std::indirectly_writable` in the `bsl` namespace.
| xref:bsl/initializer_list.adoc[`initializer_list`] 
| Alias for `std::initializer_list` in the `bsl` namespace.
| xref:bsl/inner_product.adoc[`inner_product`] 
| Alias for `std::inner_product` in the `bsl` namespace.
| xref:bsl/inout_ptr.adoc[`inout_ptr`] 
| Alias for `std::inout_ptr` in the `bsl` namespace.
| xref:bsl/inout_ptr_t.adoc[`inout_ptr_t`] 
| Alias for `std::inout_ptr_t` in the `bsl` namespace.
| xref:bsl/inplace_merge.adoc[`inplace_merge`] 
| Alias for `std::inplace_merge` in the `bsl` namespace.
| xref:bsl/input_iterator.adoc[`input_iterator`] 
| Alias for `std::input_iterator` in the `bsl` namespace.
| xref:bsl/input_iterator_tag.adoc[`input_iterator_tag`] 
| Alias for `std::input_iterator_tag` in the `bsl` namespace.
| xref:bsl/input_or_output_iterator.adoc[`input_or_output_iterator`] 
| Alias for `std::input_or_output_iterator` in the `bsl` namespace.
| xref:bsl/insert_iterator.adoc[`insert_iterator`] 
| Alias for `std::insert_iterator` in the `bsl` namespace.
| xref:bsl/inserter.adoc[`inserter`] 
| Alias for `std::inserter` in the `bsl` namespace.
| xref:bsl/int16_t.adoc[`int16_t`] 
| Alias for `::int16_t` in the `bsl` namespace.
| xref:bsl/int32_t.adoc[`int32_t`] 
| Alias for `::int32_t` in the `bsl` namespace.
| xref:bsl/int64_t.adoc[`int64_t`] 
| Alias for `::int64_t` in the `bsl` namespace.
| xref:bsl/int8_t.adoc[`int8_t`] 
| Alias for `::int8_t` in the `bsl` namespace.
| xref:bsl/int_fast16_t.adoc[`int_fast16_t`] 
| Alias for `::int_fast16_t` in the `bsl` namespace.
| xref:bsl/int_fast32_t.adoc[`int_fast32_t`] 
| Alias for `::int_fast32_t` in the `bsl` namespace.
| xref:bsl/int_fast64_t.adoc[`int_fast64_t`] 
| Alias for `::int_fast64_t` in the `bsl` namespace.
| xref:bsl/int_fast8_t.adoc[`int_fast8_t`] 
| Alias for `::int_fast8_t` in the `bsl` namespace.
| xref:bsl/int_least16_t.adoc[`int_least16_t`] 
| Alias for `::int_least16_t` in the `bsl` namespace.
| xref:bsl/int_least32_t.adoc[`int_least32_t`] 
| Alias for `::int_least32_t` in the `bsl` namespace.
| xref:bsl/int_least64_t.adoc[`int_least64_t`] 
| Alias for `::int_least64_t` in the `bsl` namespace.
| xref:bsl/int_least8_t.adoc[`int_least8_t`] 
| Alias for `::int_least8_t` in the `bsl` namespace.
| xref:bsl/integer_sequence.adoc[`integer_sequence`] 
| Alias for `std::integer_sequence` in the `bsl` namespace.
| xref:bsl/integral.adoc[`integral`] 
| Alias for `std::integral` in the `bsl` namespace.
| xref:bsl/internal.adoc[`internal`] 
| Alias for `std::internal` in the `bsl` namespace.
| xref:bsl/intmax_t.adoc[`intmax_t`] 
| Alias for `::intmax_t` in the `bsl` namespace.
| xref:bsl/intptr_t.adoc[`intptr_t`] 
| Alias for `::intptr_t` in the `bsl` namespace.
| xref:bsl/invalid_argument.adoc[`invalid_argument`] 
| Alias for `std::invalid_argument` in the `bsl` namespace.
| xref:bsl/invocable.adoc[`invocable`] 
| Alias for `std::invocable` in the `bsl` namespace.
| xref:bsl/invoke.adoc[`invoke`] 
| Alias for `std::invoke` in the `bsl` namespace.
| xref:bsl/invoke_r.adoc[`invoke_r`] 
| Alias for `std::invoke_r` in the `bsl` namespace.
| xref:bsl/io_errc.adoc[`io_errc`] 
| Alias for `std::io_errc` in the `bsl` namespace.
| xref:bsl/ios.adoc[`ios`] 
| Alias for `std::ios` in the `bsl` namespace.
| xref:bsl/ios_base.adoc[`ios_base`] 
| Alias for `std::ios_base` in the `bsl` namespace.
| xref:bsl/iostream.adoc[`iostream`] 
| Alias for `std::iostream` in the `bsl` namespace.
| xref:bsl/iostream_category.adoc[`iostream_category`] 
| Alias for `std::iostream_category` in the `bsl` namespace.
| xref:bsl/iota.adoc[`iota`] 
| Alias for `std::iota` in the `bsl` namespace.
| xref:bsl/is_abstract.adoc[`is_abstract`] 
| Alias for `std::is_abstract` in the `bsl` namespace.
| xref:bsl/is_aggregate.adoc[`is_aggregate`] 
| Alias for `std::is_aggregate` in the `bsl` namespace.
| xref:bsl/is_assignable.adoc[`is_assignable`] 
| Alias for `std::is_assignable` in the `bsl` namespace.
| xref:bsl/is_base_of.adoc[`is_base_of`] 
| Alias for `std::is_base_of` in the `bsl` namespace.
| xref:bsl/is_bind_expression.adoc[`is_bind_expression`] 
| Alias for `std::is_bind_expression` in the `bsl` namespace.
| xref:bsl/is_bind_expression_v.adoc[`is_bind_expression_v`] 
| Alias for `std::is_bind_expression_v` in the `bsl` namespace.
| xref:bsl/is_compound.adoc[`is_compound`] 
| Alias for `std::is_compound` in the `bsl` namespace.
| xref:bsl/is_constant_evaluated.adoc[`is_constant_evaluated`] 
| Alias for `std::is_constant_evaluated` in the `bsl` namespace.
| xref:bsl/is_constructible.adoc[`is_constructible`] 
| Alias for `std::is_constructible` in the `bsl` namespace.
| xref:bsl/is_copy_assignable.adoc[`is_copy_assignable`] 
| Alias for `std::is_copy_assignable` in the `bsl` namespace.
| xref:bsl/is_default_constructible.adoc[`is_default_constructible`] 
| Alias for `std::is_default_constructible` in the `bsl` namespace.
| xref:bsl/is_destructible.adoc[`is_destructible`] 
| Alias for `std::is_destructible` in the `bsl` namespace.
| xref:bsl/is_eq.adoc[`is_eq`] 
| Alias for `std::is_eq` in the `bsl` namespace.
| xref:bsl/is_error_code_enum.adoc[`is_error_code_enum`] 
| Alias for `std::is_error_code_enum` in the `bsl` namespace.
| xref:bsl/is_error_code_enum_v.adoc[`is_error_code_enum_v`] 
| Alias for `std::is_error_code_enum_v` in the `bsl` namespace.
| xref:bsl/is_error_condition_enum.adoc[`is_error_condition_enum`] 
| Alias for `std::is_error_condition_enum` in the `bsl` namespace.
| xref:bsl/is_error_condition_enum_v.adoc[`is_error_condition_enum_v`] 
| Alias for `std::is_error_condition_enum_v` in the `bsl` namespace.
| xref:bsl/is_final.adoc[`is_final`] 
| Alias for `std::is_final` in the `bsl` namespace.
| xref:bsl/is_floating_point_v.adoc[`is_floating_point_v`] 
| Variable template alias for `is_floating_point<TYPE>::value`.
| xref:bsl/is_gt.adoc[`is_gt`] 
| Alias for `std::is_gt` in the `bsl` namespace.
| xref:bsl/is_gteq.adoc[`is_gteq`] 
| Alias for `std::is_gteq` in the `bsl` namespace.
| xref:bsl/is_heap.adoc[`is_heap`] 
| Alias for `std::is_heap` in the `bsl` namespace.
| xref:bsl/is_heap_until.adoc[`is_heap_until`] 
| Alias for `std::is_heap_until` in the `bsl` namespace.
| xref:bsl/is_integral_v.adoc[`is_integral_v`] 
| This template variable represents the result value of the `bsl::is_integral` meta‐function.
| xref:bsl/is_invocable.adoc[`is_invocable`] 
| Alias for `std::is_invocable` in the `bsl` namespace.
| xref:bsl/is_invocable_r.adoc[`is_invocable_r`] 
| Alias for `std::is_invocable_r` in the `bsl` namespace.
| xref:bsl/is_literal_type.adoc[`is_literal_type`] 
| Alias for `std::is_literal_type` in the `bsl` namespace.
| xref:bsl/is_lt.adoc[`is_lt`] 
| Alias for `std::is_lt` in the `bsl` namespace.
| xref:bsl/is_lteq.adoc[`is_lteq`] 
| Alias for `std::is_lteq` in the `bsl` namespace.
| xref:bsl/is_lvalue_reference_v.adoc[`is_lvalue_reference_v`] 
| This template variable represents the result value of the `bsl::is_lvalue_reference` meta‐function.
| xref:bsl/is_move_assignable.adoc[`is_move_assignable`] 
| Alias for `std::is_move_assignable` in the `bsl` namespace.
| xref:bsl/is_move_constructible.adoc[`is_move_constructible`] 
| Alias for `std::is_move_constructible` in the `bsl` namespace.
| xref:bsl/is_neq.adoc[`is_neq`] 
| Alias for `std::is_neq` in the `bsl` namespace.
| xref:bsl/is_nothrow_assignable.adoc[`is_nothrow_assignable`] 
| Alias for `std::is_nothrow_assignable` in the `bsl` namespace.
| xref:bsl/is_nothrow_constructible.adoc[`is_nothrow_constructible`] 
| Alias for `std::is_nothrow_constructible` in the `bsl` namespace.
| xref:bsl/is_nothrow_convertible.adoc[`is_nothrow_convertible`] 
| Alias for `std::is_nothrow_convertible` in the `bsl` namespace.
| xref:bsl/is_nothrow_convertible_v.adoc[`is_nothrow_convertible_v`] 
| Alias for `std::is_nothrow_convertible_v` in the `bsl` namespace.
| xref:bsl/is_nothrow_copy_assignable.adoc[`is_nothrow_copy_assignable`] 
| Alias for `std::is_nothrow_copy_assignable` in the `bsl` namespace.
| xref:bsl/is_nothrow_copy_constructible.adoc[`is_nothrow_copy_constructible`] 
| Alias for `std::is_nothrow_copy_constructible` in the `bsl` namespace.
| xref:bsl/is_nothrow_default_constructible.adoc[`is_nothrow_default_constructible`] 
| Alias for `std::is_nothrow_default_constructible` in the `bsl` namespace.
| xref:bsl/is_nothrow_destructible.adoc[`is_nothrow_destructible`] 
| Alias for `std::is_nothrow_destructible` in the `bsl` namespace.
| xref:bsl/is_nothrow_invocable.adoc[`is_nothrow_invocable`] 
| Alias for `std::is_nothrow_invocable` in the `bsl` namespace.
| xref:bsl/is_nothrow_invocable_r.adoc[`is_nothrow_invocable_r`] 
| Alias for `std::is_nothrow_invocable_r` in the `bsl` namespace.
| xref:bsl/is_nothrow_move_assignable.adoc[`is_nothrow_move_assignable`] 
| Alias for `std::is_nothrow_move_assignable` in the `bsl` namespace.
| xref:bsl/is_nothrow_swappable.adoc[`is_nothrow_swappable`] 
| This `struct` template implements the `is_nothrow_swappable` meta‐function defined in the C++17 standard.
| xref:bsl/is_nothrow_swappable_v.adoc[`is_nothrow_swappable_v`] 
| This template variable represents the result value of the `bsl::is_nothrow_swappable` meta‐function.
| xref:bsl/is_nothrow_swappable_with.adoc[`is_nothrow_swappable_with`] 
| Alias for `std::is_nothrow_swappable_with` in the `bsl` namespace.
| xref:bsl/is_null_pointer.adoc[`is_null_pointer`] 
| Alias for `std::is_null_pointer` in the `bsl` namespace.
| xref:bsl/is_object.adoc[`is_object`] 
| Alias for `std::is_object` in the `bsl` namespace.
| xref:bsl/is_partitioned.adoc[`is_partitioned`] 
| Alias for `std::is_partitioned` in the `bsl` namespace.
| xref:bsl/is_permutation.adoc[`is_permutation`] 
| Alias for `std::is_permutation` in the `bsl` namespace.
| xref:bsl/is_placeholder.adoc[`is_placeholder`] 
| Alias for `std::is_placeholder` in the `bsl` namespace.
| xref:bsl/is_placeholder_v.adoc[`is_placeholder_v`] 
| Alias for `std::is_placeholder_v` in the `bsl` namespace.
| xref:bsl/is_pod.adoc[`is_pod`] 
| Alias for `std::is_pod` in the `bsl` namespace.
| xref:bsl/is_scalar.adoc[`is_scalar`] 
| Alias for `std::is_scalar` in the `bsl` namespace.
| xref:bsl/is_scoped_enum.adoc[`is_scoped_enum`] 
| Alias for `std::is_scoped_enum` in the `bsl` namespace.
| xref:bsl/is_scoped_enum_v.adoc[`is_scoped_enum_v`] 
| Alias for `std::is_scoped_enum_v` in the `bsl` namespace.
| xref:bsl/is_signed.adoc[`is_signed`] 
| Alias for `std::is_signed` in the `bsl` namespace.
| xref:bsl/is_sorted.adoc[`is_sorted`] 
| Alias for `std::is_sorted` in the `bsl` namespace.
| xref:bsl/is_sorted_until.adoc[`is_sorted_until`] 
| Alias for `std::is_sorted_until` in the `bsl` namespace.
| xref:bsl/is_standard_layout.adoc[`is_standard_layout`] 
| Alias for `std::is_standard_layout` in the `bsl` namespace.
| xref:bsl/is_swappable.adoc[`is_swappable`] 
| Alias for `std::is_swappable` in the `bsl` namespace.
| xref:bsl/is_swappable_v.adoc[`is_swappable_v`] 
| This template variable represents the result value of the `bsl::is_swappable` meta‐function.
| xref:bsl/is_swappable_with.adoc[`is_swappable_with`] 
| Alias for `std::is_swappable_with` in the `bsl` namespace.
| xref:bsl/is_trivial.adoc[`is_trivial`] 
| Alias for `std::is_trivial` in the `bsl` namespace.
| xref:bsl/is_trivially_assignable.adoc[`is_trivially_assignable`] 
| Alias for `std::is_trivially_assignable` in the `bsl` namespace.
| xref:bsl/is_trivially_constructible.adoc[`is_trivially_constructible`] 
| Alias for `std::is_trivially_constructible` in the `bsl` namespace.
| xref:bsl/is_trivially_copy_assignable.adoc[`is_trivially_copy_assignable`] 
| Alias for `std::is_trivially_copy_assignable` in the `bsl` namespace.
| xref:bsl/is_trivially_copy_constructible.adoc[`is_trivially_copy_constructible`] 
| Alias for `std::is_trivially_copy_constructible` in the `bsl` namespace.
| xref:bsl/is_trivially_destructible.adoc[`is_trivially_destructible`] 
| Alias for `std::is_trivially_destructible` in the `bsl` namespace.
| xref:bsl/is_trivially_move_assignable.adoc[`is_trivially_move_assignable`] 
| Alias for `std::is_trivially_move_assignable` in the `bsl` namespace.
| xref:bsl/is_trivially_move_constructible.adoc[`is_trivially_move_constructible`] 
| Alias for `std::is_trivially_move_constructible` in the `bsl` namespace.
| xref:bsl/is_union.adoc[`is_union`] 
| Alias for `std::is_union` in the `bsl` namespace.
| xref:bsl/is_unsigned.adoc[`is_unsigned`] 
| Alias for `std::is_unsigned` in the `bsl` namespace.
| xref:bsl/isalnum-02.adoc[`isalnum`] 
| Alias for `std::isalnum` in the `bsl` namespace.
| xref:bsl/isalnum-01.adoc[`isalnum`] 
| Alias for `std::isalnum` in the `bsl` namespace.
| xref:bsl/isalpha-01.adoc[`isalpha`] 
| Alias for `std::isalpha` in the `bsl` namespace.
| xref:bsl/isalpha-08.adoc[`isalpha`] 
| Alias for `std::isalpha` in the `bsl` namespace.
| xref:bsl/isblank-03.adoc[`isblank`] 
| Alias for `std::isblank` in the `bsl` namespace.
| xref:bsl/isblank-06.adoc[`isblank`] 
| Alias for `std::isblank` in the `bsl` namespace.
| xref:bsl/iscntrl-08.adoc[`iscntrl`] 
| Alias for `std::iscntrl` in the `bsl` namespace.
| xref:bsl/iscntrl-03.adoc[`iscntrl`] 
| Alias for `std::iscntrl` in the `bsl` namespace.
| xref:bsl/isdigit-08.adoc[`isdigit`] 
| Alias for `std::isdigit` in the `bsl` namespace.
| xref:bsl/isdigit-06.adoc[`isdigit`] 
| Alias for `std::isdigit` in the `bsl` namespace.
| xref:bsl/isfinite.adoc[`isfinite`] 
| Alias for `std::isfinite` in the `bsl` namespace.
| xref:bsl/isgraph-04.adoc[`isgraph`] 
| Alias for `std::isgraph` in the `bsl` namespace.
| xref:bsl/isgraph-0c.adoc[`isgraph`] 
| Alias for `std::isgraph` in the `bsl` namespace.
| xref:bsl/isgreater.adoc[`isgreater`] 
| Import `std::isgreater` into the `bsl` namespace.
| xref:bsl/isgreaterequal.adoc[`isgreaterequal`] 
| Alias for `std::isgreaterequal` in the `bsl` namespace.
| xref:bsl/isinf.adoc[`isinf`] 
| Alias for `std::isinf` in the `bsl` namespace.
| xref:bsl/isless.adoc[`isless`] 
| Alias for `std::isless` in the `bsl` namespace.
| xref:bsl/islessequal.adoc[`islessequal`] 
| Alias for `std::islessequal` in the `bsl` namespace.
| xref:bsl/islessgreater.adoc[`islessgreater`] 
| Alias for `std::islessgreater` in the `bsl` namespace.
| xref:bsl/islower-07.adoc[`islower`] 
| Alias for `std::islower` in the `bsl` namespace.
| xref:bsl/islower-0c.adoc[`islower`] 
| Alias for `std::islower` in the `bsl` namespace.
| xref:bsl/isnan.adoc[`isnan`] 
| Alias for `std::isnan` in the `bsl` namespace.
| xref:bsl/isnormal.adoc[`isnormal`] 
| Alias for `std::isnormal` in the `bsl` namespace.
| xref:bsl/ispanstream.adoc[`ispanstream`] 
| Alias for `std::ispanstream` in the `bsl` namespace.
| xref:bsl/isprint-01.adoc[`isprint`] 
| Alias for `std::isprint` in the `bsl` namespace.
| xref:bsl/isprint-0e.adoc[`isprint`] 
| Alias for `std::isprint` in the `bsl` namespace.
| xref:bsl/ispunct-01.adoc[`ispunct`] 
| Alias for `std::ispunct` in the `bsl` namespace.
| xref:bsl/ispunct-0b.adoc[`ispunct`] 
| Alias for `std::ispunct` in the `bsl` namespace.
| xref:bsl/isspace-0d.adoc[`isspace`] 
| Alias for `std::isspace` in the `bsl` namespace.
| xref:bsl/isspace-01.adoc[`isspace`] 
| Alias for `std::isspace` in the `bsl` namespace.
| xref:bsl/istream.adoc[`istream`] 
| Alias for `std::istream` in the `bsl` namespace.
| xref:bsl/istream_iterator.adoc[`istream_iterator`] 
| Alias for `std::istream_iterator` in the `bsl` namespace.
| xref:bsl/istreambuf_iterator.adoc[`istreambuf_iterator`] 
| Alias for `std::istreambuf_iterator` in the `bsl` namespace.
| xref:bsl/istrstream.adoc[`istrstream`] 
| Alias for `std::istrstream` in the `bsl` namespace.
| xref:bsl/isunordered.adoc[`isunordered`] 
| Alias for `std::isunordered` in the `bsl` namespace.
| xref:bsl/isupper-07.adoc[`isupper`] 
| Alias for `std::isupper` in the `bsl` namespace.
| xref:bsl/isupper-0d.adoc[`isupper`] 
| Alias for `std::isupper` in the `bsl` namespace.
| xref:bsl/iswalnum.adoc[`iswalnum`] 
| Alias for `std::iswalnum` in the `bsl` namespace.
| xref:bsl/iswalpha.adoc[`iswalpha`] 
| Alias for `std::iswalpha` in the `bsl` namespace.
| xref:bsl/iswblank.adoc[`iswblank`] 
| Alias for `std::iswblank` in the `bsl` namespace.
| xref:bsl/iswcntrl.adoc[`iswcntrl`] 
| Alias for `std::iswcntrl` in the `bsl` namespace.
| xref:bsl/iswctype.adoc[`iswctype`] 
| Alias for `std::iswctype` in the `bsl` namespace.
| xref:bsl/iswdigit.adoc[`iswdigit`] 
| Alias for `std::iswdigit` in the `bsl` namespace.
| xref:bsl/iswgraph.adoc[`iswgraph`] 
| Alias for `std::iswgraph` in the `bsl` namespace.
| xref:bsl/iswlower.adoc[`iswlower`] 
| Alias for `std::iswlower` in the `bsl` namespace.
| xref:bsl/iswprint.adoc[`iswprint`] 
| Alias for `std::iswprint` in the `bsl` namespace.
| xref:bsl/iswpunct.adoc[`iswpunct`] 
| Alias for `std::iswpunct` in the `bsl` namespace.
| xref:bsl/iswspace.adoc[`iswspace`] 
| Alias for `std::iswspace` in the `bsl` namespace.
| xref:bsl/iswupper.adoc[`iswupper`] 
| Alias for `std::iswupper` in the `bsl` namespace.
| xref:bsl/iswxdigit.adoc[`iswxdigit`] 
| Alias for `std::iswxdigit` in the `bsl` namespace.
| xref:bsl/isxdigit-04.adoc[`isxdigit`] 
| Alias for `std::isxdigit` in the `bsl` namespace.
| xref:bsl/isxdigit-05.adoc[`isxdigit`] 
| Alias for `std::isxdigit` in the `bsl` namespace.
| xref:bsl/iter_common_reference_t.adoc[`iter_common_reference_t`] 
| Alias for `std::iter_common_reference_t` in the `bsl` namespace.
| xref:bsl/iter_const_reference_t.adoc[`iter_const_reference_t`] 
| Alias for `std::iter_const_reference_t` in the `bsl` namespace.
| xref:bsl/iter_difference_t.adoc[`iter_difference_t`] 
| Alias for `std::iter_difference_t` in the `bsl` namespace.
| xref:bsl/iter_reference_t.adoc[`iter_reference_t`] 
| Alias for `std::iter_reference_t` in the `bsl` namespace.
| xref:bsl/iter_rvalue_reference_t.adoc[`iter_rvalue_reference_t`] 
| Alias for `std::iter_rvalue_reference_t` in the `bsl` namespace.
| xref:bsl/iter_swap.adoc[`iter_swap`] 
| Alias for `std::iter_swap` in the `bsl` namespace.
| xref:bsl/iter_value_t.adoc[`iter_value_t`] 
| Alias for `std::iter_value_t` in the `bsl` namespace.
| xref:bsl/iterator.adoc[`iterator`] 
| Alias for `std::iterator` in the `bsl` namespace.
| xref:bsl/iterator_traits.adoc[`iterator_traits`] 
| Alias for `std::iterator_traits` in the `bsl` namespace.
| xref:bsl/jmp_buf.adoc[`jmp_buf`] 
| Alias for `std::jmp_buf` in the `bsl` namespace.
| xref:bsl/jthread.adoc[`jthread`] 
| Alias for `std::jthread` in the `bsl` namespace.
| xref:bsl/kill_dependency.adoc[`kill_dependency`] 
| Alias for `std::kill_dependency` in the `bsl` namespace.
| xref:bsl/kilo.adoc[`kilo`] 
| Alias for `std::kilo`.
| xref:bsl/knuth_b.adoc[`knuth_b`] 
| Alias for `std::knuth_b` in the `bsl` namespace.
| xref:bsl/labs.adoc[`labs`] 
| Import `std::labs` into the `bsl` namespace.
| xref:bsl/laguerre.adoc[`laguerre`] 
| 
| xref:bsl/laguerref.adoc[`laguerref`] 
| 
| xref:bsl/laguerrel.adoc[`laguerrel`] 
| 
| xref:bsl/latch.adoc[`latch`] 
| Alias for `std::latch` in the `bsl` namespace.
| xref:bsl/launch.adoc[`launch`] 
| Alias for `std::launch` in the `bsl` namespace.
| xref:bsl/launder.adoc[`launder`] 
| Alias for `std::launder` in the `bsl` namespace.
| xref:bsl/lcm.adoc[`lcm`] 
| Alias for `std::lcm` in the `bsl` namespace.
| xref:bsl/lconv.adoc[`lconv`] 
| Alias for `std::lconv` in the `bsl` namespace.
| xref:bsl/ldexp.adoc[`ldexp`] 
| Alias for `std::ldexp` in the `bsl` namespace.
| xref:bsl/ldiv.adoc[`ldiv`] 
| Alias for `std::ldiv` in the `bsl` namespace.
| xref:bsl/ldiv_t.adoc[`ldiv_t`] 
| Alias for `std::ldiv_t` in the `bsl` namespace.
| xref:bsl/left.adoc[`left`] 
| Alias for `std::left` in the `bsl` namespace.
| xref:bsl/legendre.adoc[`legendre`] 
| 
| xref:bsl/legendref.adoc[`legendref`] 
| 
| xref:bsl/legendrel.adoc[`legendrel`] 
| 
| xref:bsl/length_error.adoc[`length_error`] 
| Alias for `std::length_error` in the `bsl` namespace.
| xref:bsl/lerp.adoc[`lerp`] 
| Alias for `std::lerp` in the `bsl` namespace.
| xref:bsl/less.adoc[`less`] 
| Alias for `std::less` in the `bsl` namespace.
| xref:bsl/less_equal.adoc[`less_equal`] 
| Alias for `std::less_equal` in the `bsl` namespace.
| xref:bsl/lexicographical_compare.adoc[`lexicographical_compare`] 
| Alias for `std::lexicographical_compare` in the `bsl` namespace.
| xref:bsl/lexicographical_compare_three_way.adoc[`lexicographical_compare_three_way`] 
| Alias for `std::lexicographical_compare_three_way` in the `bsl` namespace.
| xref:bsl/lgamma.adoc[`lgamma`] 
| Alias for `std::lgamma` in the `bsl` namespace.
| xref:bsl/linear_congruential_engine.adoc[`linear_congruential_engine`] 
| Alias for `std::linear_congruential_engine` in the `bsl` namespace.
| xref:bsl/llabs.adoc[`llabs`] 
| Import `std::llabs` into the `bsl` namespace.
| xref:bsl/lldiv.adoc[`lldiv`] 
| Alias for `std::lldiv` in the `bsl` namespace.
| xref:bsl/lldiv_t.adoc[`lldiv_t`] 
| Alias for `std::lldiv_t` in the `bsl` namespace.
| xref:bsl/llrint.adoc[`llrint`] 
| Alias for `std::llrint` in the `bsl` namespace.
| xref:bsl/llround.adoc[`llround`] 
| Alias for `std::llround` in the `bsl` namespace.
| xref:bsl/locale.adoc[`locale`] 
| Alias for `std::locale` in the `bsl` namespace.
| xref:bsl/localeconv.adoc[`localeconv`] 
| Alias for `std::localeconv` in the `bsl` namespace.
| xref:bsl/localtime.adoc[`localtime`] 
| Alias for `std::localtime` in the `bsl` namespace.
| xref:bsl/lock.adoc[`lock`] 
| Alias for `std::lock` in the `bsl` namespace.
| xref:bsl/lock_guard.adoc[`lock_guard`] 
| Alias for `std::lock_guard` in the `bsl` namespace.
| xref:bsl/log-0b.adoc[`log`] 
| Alias for `std::log` in the `bsl` namespace.
| xref:bsl/log-0f.adoc[`log`] 
| Alias for `std::log` in the `bsl` namespace.
| xref:bsl/log-06.adoc[`log`] 
| Alias for `std::log` in the `bsl` namespace.
| xref:bsl/log10-01.adoc[`log10`] 
| Alias for `std::log10` in the `bsl` namespace.
| xref:bsl/log10-0e.adoc[`log10`] 
| Alias for `std::log10` in the `bsl` namespace.
| xref:bsl/log10-09.adoc[`log10`] 
| Alias for `std::log10` in the `bsl` namespace.
| xref:bsl/log1p.adoc[`log1p`] 
| Alias for `std::log1p` in the `bsl` namespace.
| xref:bsl/log2.adoc[`log2`] 
| Alias for `std::log2` in the `bsl` namespace.
| xref:bsl/logb.adoc[`logb`] 
| Import `std::logb` into the `bsl` namespace.
| xref:bsl/logic_error.adoc[`logic_error`] 
| Alias for `std::logic_error` in the `bsl` namespace.
| xref:bsl/logical_and.adoc[`logical_and`] 
| Alias for `std::logical_and` in the `bsl` namespace.
| xref:bsl/logical_not.adoc[`logical_not`] 
| Alias for `std::logical_not` in the `bsl` namespace.
| xref:bsl/logical_or.adoc[`logical_or`] 
| Alias for `std::logical_or` in the `bsl` namespace.
| xref:bsl/lognormal_distribution.adoc[`lognormal_distribution`] 
| Alias for `std::lognormal_distribution` in the `bsl` namespace.
| xref:bsl/longjmp.adoc[`longjmp`] 
| Alias for `std::longjmp` in the `bsl` namespace.
| xref:bsl/lower_bound.adoc[`lower_bound`] 
| Alias for `std::lower_bound` in the `bsl` namespace.
| xref:bsl/lrint.adoc[`lrint`] 
| Alias for `std::lrint` in the `bsl` namespace.
| xref:bsl/lround.adoc[`lround`] 
| Alias for `std::lround` in the `bsl` namespace.
| xref:bsl/make_const_iterator.adoc[`make_const_iterator`] 
| Alias for `std::make_const_iterator` in the `bsl` namespace.
| xref:bsl/make_const_sentinel.adoc[`make_const_sentinel`] 
| Alias for `std::make_const_sentinel` in the `bsl` namespace.
| xref:bsl/make_error_code.adoc[`make_error_code`] 
| Alias for `std::make_error_code` in the `bsl` namespace.
| xref:bsl/make_error_condition.adoc[`make_error_condition`] 
| Alias for `std::make_error_condition` in the `bsl` namespace.
| xref:bsl/make_exception_ptr.adoc[`make_exception_ptr`] 
| Undocumented symbol.
| xref:bsl/make_from_tuple.adoc[`make_from_tuple`] 
| Alias for `std::make_from_tuple` in the `bsl` namespace.
| xref:bsl/make_heap.adoc[`make_heap`] 
| Alias for `std::make_heap` in the `bsl` namespace.
| xref:bsl/make_index_sequence.adoc[`make_index_sequence`] 
| Alias for `std::make_index_sequence` in the `bsl` namespace.
| xref:bsl/make_integer_sequence.adoc[`make_integer_sequence`] 
| Alias for `std::make_integer_sequence` in the `bsl` namespace.
| xref:bsl/make_move_iterator.adoc[`make_move_iterator`] 
| Alias for `std::make_move_iterator` in the `bsl` namespace.
| xref:bsl/make_pair.adoc[`make_pair`] 
| Alias for `std::make_pair` in the `bsl` namespace.
| xref:bsl/make_reverse_iterator.adoc[`make_reverse_iterator`] 
| Alias for `std::make_reverse_iterator` in the `bsl` namespace.
| xref:bsl/make_signed.adoc[`make_signed`] 
| Alias for `std::make_signed` in the `bsl` namespace.
| xref:bsl/make_tuple.adoc[`make_tuple`] 
| Alias for `std::make_tuple` in the `bsl` namespace.
| xref:bsl/make_unique.adoc[`make_unique`] 
| Alias for `std::make_unique` in the `bsl` namespace.
| xref:bsl/make_unique_for_overwrite.adoc[`make_unique_for_overwrite`] 
| Alias for `std::make_unique_for_overwrite` in the `bsl` namespace.
| xref:bsl/make_unsigned.adoc[`make_unsigned`] 
| Alias for `std::make_unsigned` in the `bsl` namespace.
| xref:bsl/malloc.adoc[`malloc`] 
| Alias for `std::malloc` in the `bsl` namespace.
| xref:bsl/mask_array.adoc[`mask_array`] 
| Alias for `std::mask_array` in the `bsl` namespace.
| xref:bsl/match_results.adoc[`match_results`] 
| Alias for `std::match_results` in the `bsl` namespace.
| xref:bsl/max.adoc[`max`] 
| Alias for `std::max` in the `bsl` namespace.
| xref:bsl/max_align_t.adoc[`max_align_t`] 
| Alias for `std::max_align_t` in the `bsl` namespace.
| xref:bsl/max_element.adoc[`max_element`] 
| Alias for `std::max_element` in the `bsl` namespace.
| xref:bsl/mblen.adoc[`mblen`] 
| Alias for `std::mblen` in the `bsl` namespace.
| xref:bsl/mbrlen.adoc[`mbrlen`] 
| Alias for `std::mbrlen` in the `bsl` namespace.
| xref:bsl/mbrtoc16.adoc[`mbrtoc16`] 
| Alias for `std::mbrtoc16` in the `bsl` namespace.
| xref:bsl/mbrtoc32.adoc[`mbrtoc32`] 
| Alias for `std::mbrtoc32` in the `bsl` namespace.
| xref:bsl/mbrtowc.adoc[`mbrtowc`] 
| Alias for `std::mbrtowc` in the `bsl` namespace.
| xref:bsl/mbsinit.adoc[`mbsinit`] 
| Alias for `std::mbsinit` in the `bsl` namespace.
| xref:bsl/mbsrtowcs.adoc[`mbsrtowcs`] 
| Alias for `std::mbsrtowcs` in the `bsl` namespace.
| xref:bsl/mbstate_t.adoc[`mbstate_t`] 
| Alias for `std::mbstate_t` in the `bsl` namespace.
| xref:bsl/mbstowcs.adoc[`mbstowcs`] 
| Alias for `std::mbstowcs` in the `bsl` namespace.
| xref:bsl/mbtowc.adoc[`mbtowc`] 
| Import `std::mbtowc` into the `bsl` namespace.
| xref:bsl/mega.adoc[`mega`] 
| Alias for `std::mega`.
| xref:bsl/mem_fn.adoc[`mem_fn`] 
| Alias for `std::mem_fn` in the `bsl` namespace.
| xref:bsl/mem_fun.adoc[`mem_fun`] 
| Alias for `std::mem_fun` in the `bsl` namespace.
| xref:bsl/mem_fun1_ref_t.adoc[`mem_fun1_ref_t`] 
| Alias for `std::mem_fun1_ref_t` in the `bsl` namespace.
| xref:bsl/mem_fun1_t.adoc[`mem_fun1_t`] 
| Alias for `std::mem_fun1_t` in the `bsl` namespace.
| xref:bsl/mem_fun_ref.adoc[`mem_fun_ref`] 
| Alias for `std::mem_fun_ref` in the `bsl` namespace.
| xref:bsl/mem_fun_ref_t.adoc[`mem_fun_ref_t`] 
| Alias for `std::mem_fun_ref_t` in the `bsl` namespace.
| xref:bsl/mem_fun_t.adoc[`mem_fun_t`] 
| Alias for `std::mem_fun_t` in the `bsl` namespace.
| xref:bsl/memchr.adoc[`memchr`] 
| Alias for `std::memchr` in the `bsl` namespace.
| xref:bsl/memcmp.adoc[`memcmp`] 
| Alias for `std::memcmp` in the `bsl` namespace.
| xref:bsl/memcpy.adoc[`memcpy`] 
| Alias for `std::memcpy` in the `bsl` namespace.
| xref:bsl/memmove.adoc[`memmove`] 
| Alias for `std::memmove` in the `bsl` namespace.
| xref:bsl/memory_order.adoc[`memory_order`] 
| Alias for `std::memory_order` in the `bsl` namespace.
| xref:bsl/memory_order_acq_rel.adoc[`memory_order_acq_rel`] 
| Alias for `std::memory_order_acq_rel` in the `bsl` namespace.
| xref:bsl/memory_order_acquire.adoc[`memory_order_acquire`] 
| Alias for `std::memory_order_acquire` in the `bsl` namespace.
| xref:bsl/memory_order_consume.adoc[`memory_order_consume`] 
| Alias for `std::memory_order_consume` in the `bsl` namespace.
| xref:bsl/memory_order_relaxed.adoc[`memory_order_relaxed`] 
| Alias for `std::memory_order_relaxed` in the `bsl` namespace.
| xref:bsl/memory_order_release.adoc[`memory_order_release`] 
| Alias for `std::memory_order_release` in the `bsl` namespace.
| xref:bsl/memory_order_seq_cst.adoc[`memory_order_seq_cst`] 
| Alias for `std::memory_order_seq_cst` in the `bsl` namespace.
| xref:bsl/memory_resource.adoc[`memory_resource`] 
| Alias for `std::pmr::memory_resource` in the `bsl` namespace.
| xref:bsl/memset.adoc[`memset`] 
| Alias for `std::memset` in the `bsl` namespace.
| xref:bsl/merge.adoc[`merge`] 
| Alias for `std::merge` in the `bsl` namespace.
| xref:bsl/mergeable.adoc[`mergeable`] 
| Alias for `std::mergeable` in the `bsl` namespace.
| xref:bsl/mersenne_twister_engine.adoc[`mersenne_twister_engine`] 
| Alias for `std::mersenne_twister_engine` in the `bsl` namespace.
| xref:bsl/messages.adoc[`messages`] 
| Alias for `std::messages` in the `bsl` namespace.
| xref:bsl/messages_base.adoc[`messages_base`] 
| Alias for `std::messages_base` in the `bsl` namespace.
| xref:bsl/messages_byname.adoc[`messages_byname`] 
| Alias for `std::messages_byname` in the `bsl` namespace.
| xref:bsl/micro.adoc[`micro`] 
| Alias for `std::micro`.
| xref:bsl/midpoint.adoc[`midpoint`] 
| Alias for `std::midpoint` in the `bsl` namespace.
| xref:bsl/milli.adoc[`milli`] 
| Alias for `std::milli`.
| xref:bsl/min.adoc[`min`] 
| Alias for `std::min` in the `bsl` namespace.
| xref:bsl/min_element.adoc[`min_element`] 
| Alias for `std::min_element` in the `bsl` namespace.
| xref:bsl/minmax.adoc[`minmax`] 
| Alias for `std::minmax` in the `bsl` namespace.
| xref:bsl/minmax_element.adoc[`minmax_element`] 
| Alias for `std::minmax_element` in the `bsl` namespace.
| xref:bsl/minstd_rand.adoc[`minstd_rand`] 
| Alias for `std::minstd_rand` in the `bsl` namespace.
| xref:bsl/minstd_rand0.adoc[`minstd_rand0`] 
| Alias for `std::minstd_rand0` in the `bsl` namespace.
| xref:bsl/minus.adoc[`minus`] 
| Alias for `std::minus` in the `bsl` namespace.
| xref:bsl/mismatch.adoc[`mismatch`] 
| Alias for `std::mismatch` in the `bsl` namespace.
| xref:bsl/mktime.adoc[`mktime`] 
| Alias for `std::mktime` in the `bsl` namespace.
| xref:bsl/modf.adoc[`modf`] 
| Alias for `std::modf` in the `bsl` namespace.
| xref:bsl/modulus.adoc[`modulus`] 
| Alias for `std::modulus` in the `bsl` namespace.
| xref:bsl/money_base.adoc[`money_base`] 
| Alias for `std::money_base` in the `bsl` namespace.
| xref:bsl/money_get.adoc[`money_get`] 
| Alias for `std::money_get` in the `bsl` namespace.
| xref:bsl/money_put.adoc[`money_put`] 
| Alias for `std::money_put` in the `bsl` namespace.
| xref:bsl/moneypunct.adoc[`moneypunct`] 
| Alias for `std::moneypunct` in the `bsl` namespace.
| xref:bsl/moneypunct_byname.adoc[`moneypunct_byname`] 
| Alias for `std::moneypunct_byname` in the `bsl` namespace.
| xref:bsl/monostate.adoc[`monostate`] 
| Alias for `std::monostate` in the `bsl` namespace.
| xref:bsl/movable.adoc[`movable`] 
| Alias for `std::movable` in the `bsl` namespace.
| xref:bsl/move-0f.adoc[`move`] 
| Alias for `std::move` in the `bsl` namespace.
| xref:bsl/move-0e.adoc[`move`] 
| Alias for `std::move` in the `bsl` namespace.
| xref:bsl/move_backward.adoc[`move_backward`] 
| Alias for `std::move_backward` in the `bsl` namespace.
| xref:bsl/move_constructible.adoc[`move_constructible`] 
| Alias for `std::move_constructible` in the `bsl` namespace.
| xref:bsl/move_if_noexcept.adoc[`move_if_noexcept`] 
| Alias for `std::move_if_noexcept` in the `bsl` namespace.
| xref:bsl/move_iterator.adoc[`move_iterator`] 
| Alias for `std::move_iterator` in the `bsl` namespace.
| xref:bsl/move_sentinel.adoc[`move_sentinel`] 
| Standard library alias for `std::move_sentinel`.
| xref:bsl/mt19937.adoc[`mt19937`] 
| Alias for `std::mt19937` in the `bsl` namespace.
| xref:bsl/mt19937_64.adoc[`mt19937_64`] 
| Alias for `std::mt19937_64` in the `bsl` namespace.
| xref:bsl/multiplies.adoc[`multiplies`] 
| Alias for `std::multiplies` in the `bsl` namespace.
| xref:bsl/mutex.adoc[`mutex`] 
| Alias for `std::mutex` in the `bsl` namespace.
| xref:bsl/nan.adoc[`nan`] 
| Alias for `std::nan` in the `bsl` namespace.
| xref:bsl/nanf.adoc[`nanf`] 
| Alias for `std::nanf` in the `bsl` namespace.
| xref:bsl/nanl.adoc[`nanl`] 
| Alias for `std::nanl` in the `bsl` namespace.
| xref:bsl/nano.adoc[`nano`] 
| Alias for `std::nano`.
| xref:bsl/nearbyint.adoc[`nearbyint`] 
| Alias for `std::nearbyint` in the `bsl` namespace.
| xref:bsl/negate.adoc[`negate`] 
| Alias for `std::negate` in the `bsl` namespace.
| xref:bsl/negation.adoc[`negation`] 
| Alias for `std::negation` in the `bsl` namespace.
| xref:bsl/negation_v.adoc[`negation_v`] 
| Alias for `std::negation_v` in the `bsl` namespace.
| xref:bsl/negative_binomial_distribution.adoc[`negative_binomial_distribution`] 
| Alias for `std::negative_binomial_distribution` in the `bsl` namespace.
| xref:bsl/nested_exception.adoc[`nested_exception`] 
| Undocumented symbol.
| xref:bsl/new_handler.adoc[`new_handler`] 
| Alias for `std::new_handler` in the `bsl` namespace.
| xref:bsl/next.adoc[`next`] 
| Alias for `std::next` in the `bsl` namespace.
| xref:bsl/next_permutation.adoc[`next_permutation`] 
| Alias for `std::next_permutation` in the `bsl` namespace.
| xref:bsl/nextafter.adoc[`nextafter`] 
| Alias for `std::nextafter` in the `bsl` namespace.
| xref:bsl/nexttoward.adoc[`nexttoward`] 
| Alias for `std::nexttoward` in the `bsl` namespace.
| xref:bsl/noboolalpha.adoc[`noboolalpha`] 
| Alias for `std::noboolalpha` in the `bsl` namespace.
| xref:bsl/none_of.adoc[`none_of`] 
| Alias for `std::none_of` in the `bsl` namespace.
| xref:bsl/noop_coroutine.adoc[`noop_coroutine`] 
| Alias for `std::noop_coroutine` in the `bsl` namespace.
| xref:bsl/noop_coroutine_handle.adoc[`noop_coroutine_handle`] 
| Alias for `std::noop_coroutine_handle` in the `bsl` namespace.
| xref:bsl/noop_coroutine_promise.adoc[`noop_coroutine_promise`] 
| Alias for `std::noop_coroutine_promise` in the `bsl` namespace.
| xref:bsl/norm.adoc[`norm`] 
| Alias for `std::norm` in the `bsl` namespace.
| xref:bsl/normal_distribution.adoc[`normal_distribution`] 
| Alias for `std::normal_distribution` in the `bsl` namespace.
| xref:bsl/noshowbase.adoc[`noshowbase`] 
| Alias for `std::noshowbase` in the `bsl` namespace.
| xref:bsl/noshowpoint.adoc[`noshowpoint`] 
| Alias for `std::noshowpoint` in the `bsl` namespace.
| xref:bsl/noshowpos.adoc[`noshowpos`] 
| Alias for `std::noshowpos` in the `bsl` namespace.
| xref:bsl/noskipws.adoc[`noskipws`] 
| Alias for `std::noskipws` in the `bsl` namespace.
| xref:bsl/not1.adoc[`not1`] 
| Alias for `std::not1` in the `bsl` namespace.
| xref:bsl/not2.adoc[`not2`] 
| Alias for `std::not2` in the `bsl` namespace.
| xref:bsl/not_equal_to.adoc[`not_equal_to`] 
| Alias for `std::not_equal_to` in the `bsl` namespace.
| xref:bsl/not_fn.adoc[`not_fn`] 
| Alias for `std::not_fn` in the `bsl` namespace.
| xref:bsl/nothrow.adoc[`nothrow`] 
| Alias for `std::nothrow` in the `bsl` namespace.
| xref:bsl/nothrow_t.adoc[`nothrow_t`] 
| Alias for `std::nothrow_t` in the `bsl` namespace.
| xref:bsl/nounitbuf.adoc[`nounitbuf`] 
| Alias for `std::nounitbuf` in the `bsl` namespace.
| xref:bsl/nouppercase.adoc[`nouppercase`] 
| Alias for `std::nouppercase` in the `bsl` namespace.
| xref:bsl/nth_element.adoc[`nth_element`] 
| Alias for `std::nth_element` in the `bsl` namespace.
| xref:bsl/nullopt.adoc[`nullopt`] 
| Constant used to construct disengaged `optional` objects.
| xref:bsl/nullptr_t-04.adoc[`nullptr_t`] 
| Alias for `std::nullptr_t` in the `bsl` namespace.
| xref:bsl/num_get.adoc[`num_get`] 
| Alias for `std::num_get` in the `bsl` namespace.
| xref:bsl/num_put.adoc[`num_put`] 
| Alias for `std::num_put` in the `bsl` namespace.
| xref:bsl/numeric_limits.adoc[`numeric_limits`] 
| Alias for `std::numeric_limits` in the `bsl` namespace.
| xref:bsl/numpunct.adoc[`numpunct`] 
| Alias for `std::numpunct` in the `bsl` namespace.
| xref:bsl/numpunct_byname.adoc[`numpunct_byname`] 
| Import `std::numpunct_byname` into the `bsl` namespace.
| xref:bsl/oct.adoc[`oct`] 
| Alias for `std::oct` in the `bsl` namespace.
| xref:bsl/ofstream.adoc[`ofstream`] 
| Alias for `std::ofstream` in the `bsl` namespace.
| xref:bsl/once_flag.adoc[`once_flag`] 
| Alias for `std::once_flag` in the `bsl` namespace.
| xref:bsl/operator!=-01.adoc[`operator!=`] 
| Import `std::operator!=` for `basic_string_view` into the `bsl` namespace.
| xref:bsl/operator!=-097.adoc[`operator!=`] 
| Import `std::operator!=` for `basic_string_view` into the `bsl` namespace.
| xref:bsl/operator!=-09a.adoc[`operator!=`] 
| Import `std::operator!=` for `basic_string_view` into the `bsl` namespace.
| xref:bsl/operator!=-0c.adoc[`operator!=`] 
| Import `std::operator!=` for `basic_string_view` into the `bsl` namespace.
| xref:bsl/operator!=-0d8.adoc[`operator!=`] 
| Import `std::operator!=` for `basic_string_view` into the `bsl` namespace.
| xref:bsl/operator!=-0d9.adoc[`operator!=`] 
| Import `std::operator!=` for `basic_string_view` into the `bsl` namespace.
| 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]#