| Csl::nullables::adapter< TNull, TAdapted > | A adapter class, mimic the behaviour of nullable types |
| Csl::nullables::adapter_null_t | Dedicated null type for adapters |
| Csl::add_type_const< T > | Primary template, adding const to value types |
| Csl::add_type_const< T & > | Specialization, unwrapping lvalue reference types |
| Csl::add_type_const< T && > | Specialization, unwrapping rvalue reference types |
| Csl::add_type_const< T * > | Specialization, unwrapping pointer types |
| Csl::add_type_const< T *const > | Specialization, unwrapping const pointer types |
| Csl::add_type_const< T *const volatile > | Specialization, unwrapping const volatile pointer types |
| Csl::add_type_const< T *volatile > | Specialization, unwrapping volatile pointer types |
| Csl::add_type_cv< T > | Primary template, adding const and volatile to value types |
| Csl::add_type_volatile< T > | Primary template, adding volatile to value types |
| Csl::add_type_volatile< T & > | Specialization, unwrapping lvalue reference types |
| Csl::add_type_volatile< T && > | Specialization, unwrapping rvalue reference types |
| Csl::add_type_volatile< T * > | Specialization, unwrapping pointer types |
| Csl::add_type_volatile< T *const > | Specialization, unwrapping const pointer types |
| Csl::add_type_volatile< T *const volatile > | Specialization, unwrapping const volatile pointer types |
| Csl::add_type_volatile< T *volatile > | Specialization, unwrapping volatile pointer types |
| Csl::nullables::Algorithm< Operation > | The core algorithm helper, which executes the held operation when used as the right-hand-side of operator | expressions, when the left-hand-side is a valid nullable type |
| Csl::type_list::append< List, Types > | Primary template isn't defined on purpose |
| Csl::type_list::append< Container< Elements... >, Types... > | Adds the given types at the end of the source type-list |
| Csl::tuple::apply_result< Func, Tuple > | Trait type determining the result of a std::apply call |
| Csl::type_list::back< List > | Primary template isn't defined on purpose |
| Csl::type_list::back< Container< Element > > | Specialization retrieving the last element of the source type-list |
| ►Csl::type_list::back< Container< Others... > > | |
| Csl::type_list::back< Container< First, Others... > > | Specialization investigating the current element of the source type-list |
| ►Cstd::bool_constant | |
| Csl::type_list::contains< Container< Elements... >, Query > | Specialization determining the presence of the query type, due to comparing it with each element of the type-list |
| Csl::type_list::unordered_equal< First, OtherLists... > | Specialization, determining whether the current element appears equally often in all type-lists |
| Csl::type_list::cartesian_product_as< TargetContainer, Lists > | Primary template isn't defined on purpose |
| Csl::type_list::cartesian_product_as< TargetContainer, Container< Elements... > > | Root specialization, enveloping each element of the list in a TargetContainer |
| Csl::type_list::cartesian_product_as< TargetContainer, Container< Elements... >, OtherLists... > | Specialization, prepending all elements of the current type-list to the already created type-lists |
| Csl::tuple::cartesian_product_result< Tuples > | Trait type determining the result of a cartesian_product call |
| Csl::tuple::cat_result< Tuple, Others > | Trait type determining the result of a std::tuple_cat call |
| Csl::functional::closure_template< T > | Primary template, purposely undefined |
| Csl::functional::closure_template< BasicClosure< Fn, InvokePolicy, OperatorPolicies... > > | Specialization, providing the closure template as member alias |
| Csl::type_list::common_container< Lists > | Primary template isn't defined on purpose |
| Csl::type_list::common_container< Container< Elements... > > | Unary trait defining the type member-alias |
| ►Csl::type_list::common_container< Container< LhsElements... >, Others... > | |
| Csl::type_list::common_container< Container< LhsElements... >, Container< RhsElements... >, Others... > | Trait reducing the amount of participating type-lists, if the first two have the container in common |
| Csl::functional::Composition< CompStrategy, FirstFn, SecondFn, OtherFns > | Functional type, composing multiple other functional types via the provided strategy |
| Csl::type_list::concat< Lists > | Primary template isn't defined on purpose |
| ►Csl::type_list::concat< difference_as_t< TargetContainer, First, Second >, difference_as_t< TargetContainer, Second, First > > | |
| Csl::type_list::symmetric_difference_as< TargetContainer, First, Second > | Determines which elements are in either of the source type-lists, but not in both. The order doesn't matter |
| ►Csl::type_list::concat< LhsContainer< LhsElements..., RhsElements... >, Others... > | |
| Csl::type_list::concat< LhsContainer< LhsElements... >, RhsContainer< RhsElements... >, Others... > | Specialization appending all elements of the second type-list at the back of the first type-list and repeating it for any other not yet investigated type-lists |
| Csl::type_list::concat< List > | Unary specialization, simply using the given type-list as result |
| Csl::functional::ConjunctionOperator< Derived > | |
| Csl::functional::ConjunctionStrategy | |
| Csl::type_list::contains< List, Query > | Primary template isn't defined on purpose |
| Csl::type_list::count< Query, List > | Primary template isn't defined on purpose |
| Csl::CRTPBase< Derived, Disambiguity > | Utility type, which can be used as a base class for the crtp pattern |
| Csl::cv_qualified_type< T > | Primary template, taking the T as-is |
| Csl::cv_qualified_type< T > | Specialization, unwrapping reference types |
| Csl::default_delete_action | Default delete action for unique_handle with an empty operator () |
| Csl::type_list::difference_as< TargetContainer, First, Second > | Primary template, yielding a the elements of First in the TargetContainer |
| ►Csl::type_list::difference_as< TargetContainer, First, difference_as_t< TargetContainer, First, Second > > | |
| Csl::type_list::intersection_as< TargetContainer, First, Second > | Determines the intersection between the elements of two type-lists. The order doesn't matter |
| ►Csl::type_list::difference_as< TargetContainer, remove_at_t< First, index_of_v< First, front_t< Second > > >, pop_front_t< Second > > | |
| Csl::type_list::difference_as< TargetContainer, First, Second > | Specialization, if the front element of Second is not contained in First |
| Csl::functional::DisjunctionOperator< Derived > | |
| Csl::functional::DisjunctionStrategy | |
| ►Csl::type_list::detail::element< index, sl::type_list::TypeList< Types... > > | |
| Cstd::tuple_element< index, sl::type_list::TypeList< Types... > > | Specialization of std::tuple_element for TypeList |
| Csl::tuple::envelop_elements_result< Tuple > | Trait type determining the result of a tuple_envelop_elements call |
| Csl::functional::EqualityOperator< Derived > | |
| Csl::functional::EqualityStrategy | |
| ►Cstd::false_type | |
| ►Csl::type_list::equal< FirstContainer< Elements... >, Others... > | |
| Csl::type_list::equal< FirstContainer< Elements... >, SecondContainer< Elements... >, Others... > | Specialization, determining whether the first two type-lists have equal template arguments |
| ►Csl::type_list::equal< FirstContainer<>, OtherLists... > | |
| Csl::type_list::unordered_equal< FirstContainer<>, OtherLists... > | Root specialization, determining whether all type-lists are empty |
| Csl::functional::is_composition< T > | Primary template, yielding false type |
| Csl::type_list::equal< First, Others > | Primary template yields false |
| Csl::type_list::filter< List, Filter > | Primary template isn't defined on purpose |
| Csl::type_list::filter< Container< Elements... >, Filter > | Applies the filter trait on each element of the source type-list |
| ►Csl::type_list::filter< List, detail::not_same_as_filter< Type >::template type > | |
| Csl::type_list::remove< List, Type > | Applies the filter trait on each element of the source type-list |
| Csl::math::frexp_result< T > | Result type for the frexp operation |
| Csl::type_list::front< List > | Primary template isn't defined on purpose |
| Csl::type_list::front< Container< First, Others... > > | Specialization retrieving the first element of the source type-list |
| Csl::nullables::in_place_null_t | Tag type for adapters, which can be used to disambiguate the construction with just a null-object |
| ►Cstd::integral_constant | |
| Csl::type_list::count< Query, Container< Elements... > > | Specialization counting the presence of the query type, due to comparing it with each element of the type-list |
| Csl::type_list::index_of< List, Query > | Primary template, traversing the elements of the source type-list |
| Csl::type_list::index_of< List, front_t< List > > | Specialization if the queried type appears at the beginning of the type-list |
| Cstd::tuple_size< sl::type_list::TypeList< Types... > > | Specialization of std::tuple_size for TypeList |
| ►CInvokePolicy | |
| Csl::functional::BasicClosure< Fn, InvokePolicy, OperatorPolicies > | The core class, wrapping one functional object and enabling a variety of composing operators for it |
| Csl::math::modf_result< T > | Result type for the modf operation |
| Csl::functional::NegationOperator< Derived > | |
| Csl::nullhandle_t | Helper type for indicating unique_handles with uninitialized state |
| ►COperatorPolicies | |
| Csl::functional::BasicClosure< Fn, InvokePolicy, OperatorPolicies > | The core class, wrapping one functional object and enabling a variety of composing operators for it |
| Csl::functional::PipeOperator< Derived > | |
| Csl::functional::PipeStrategy | |
| Csl::type_list::populated_from< TargetContainer, List > | Primary template isn't defined on purpose |
| Csl::type_list::populated_from< TargetContainer, SourceContainer< Elements... > > | Specialization applying each element of the source container as template argument of the target container |
| Csl::type_list::prepend< List, Types > | Primary template isn't defined on purpose |
| Csl::type_list::prepend< Container< Elements... >, Types... > | Adds the given types at the begin of the source type-list |
| Csl::qualified_category_as< To, From > | |
| Csl::type_list::remove_at< List, index > | Primary template, traversing all elements of the given type-list |
| Csl::type_list::remove_at< List, 0 > | Root specialization, omitting the first element from the source type-list |
| Csl::remove_type_const< T > | Primary template, removing const from value types |
| Csl::remove_type_const< T & > | Specialization, unwrapping lvalue reference types |
| Csl::remove_type_const< T && > | Specialization, unwrapping rvalue reference types |
| Csl::remove_type_const< T * > | Specialization, unwrapping pointer types |
| Csl::remove_type_const< T *const > | Specialization, unwrapping const pointer types |
| Csl::remove_type_const< T *const volatile > | Specialization, unwrapping const volatile pointer types |
| Csl::remove_type_const< T *volatile > | Specialization, unwrapping volatile pointer types |
| Csl::remove_type_cv< T > | Primary template, removing const and volatile from value types |
| Csl::remove_type_volatile< T > | Primary template, removing volatile from value types |
| Csl::remove_type_volatile< T & > | Specialization, unwrapping lvalue reference types |
| Csl::remove_type_volatile< T && > | Specialization, unwrapping rvalue reference types |
| Csl::remove_type_volatile< T * > | Specialization, unwrapping pointer types |
| Csl::remove_type_volatile< T *const > | Specialization, unwrapping const pointer types |
| Csl::remove_type_volatile< T *const volatile > | Specialization, unwrapping const volatile pointer types |
| Csl::remove_type_volatile< T *volatile > | Specialization, unwrapping volatile pointer types |
| Csl::math::remquo_result< T > | Result type for the remquo operation |
| Csl::type_list::reverse< List > | Reverses the order of all elements |
| Csl::type_list::reverse< Container<> > | Specialization for empty type-lists |
| Csl::type_list::tail< List > | Primary template isn't defined on purpose |
| Csl::type_list::tail< Container< First, Others... > > | Specialization for non-empty source type-lists |
| Csl::type_list::tail< Container<> > | Specialization for empty source type-lists |
| Csl::nullables::traits< T > | The main trait, which may be specialized from |
| Csl::nullables::traits< adapter< TNull, TAdapted > > | Specialization for raw pointers |
| Csl::nullables::traits< std::optional< TArgs... > > | Specialization for std::optional |
| Csl::nullables::traits< std::shared_ptr< TArgs... > > | Specialization for std::shared_ptr |
| Csl::nullables::traits< std::unique_ptr< TArgs... > > | Specialization for std::unique_ptr |
| Csl::nullables::traits< T > | Specialization for raw pointers |
| Csl::nullables::traits< unique_handle< T, TDeleteAction > > | Specialization for unique_handle types |
| Csl::type_list::transform< UnaryOperation, List > | Primary template isn't defined on purpose |
| Csl::type_list::transform< UnaryOperation, Container< Elements... > > | Specialization, which applies the UnaryOperation on each element of the given type-list |
| ►Cstd::true_type | |
| Csl::functional::is_composition< Composition< CompositionStrategy, Fns... > > | Specialization for Composition |
| Csl::type_list::equal< First > | Specialization for single type-list |
| Csl::type_constness_as< To, From > | Applies or removes the const qualification of To in regards of From |
| Csl::type_qualification_as< To, From > | Applies or removes the const and/or volatile qualifications of To in regards of From |
| Csl::type_volatileness_as< To, From > | Applies or removes the volatile qualification of To in regards of From |
| Csl::type_list::TypeList< Types > | A variadic template type, which's only serves as a container for an arbitrary amount of types. Neither of the given types will be actually instantiated |
| Csl::unified_base< TTag > | Helper type, which can be used to create a unified base class for templated derived classes and thus getting an straight-forward way of disambiguing binary operators |
| Csl::type_list::unique< List > | Root specialization for empty type lists |
| Csl::type_list::unique< List > | Specialization, traversing each element of the given type-list |
| Csl::unique_handle< T, TDeleteAction > | This type models some kind of std::optional behaviour but resets itself on move operations |
| Csl::type_list::unordered_equal< First, OtherLists > | Primary template isn't defined on purpose |
| Csl::functional::unwrap_functional< T > | Primary template for non BasicClosure types |
| Csl::functional::unwrap_functional< BasicClosure< Fn, InvokePolicy, OperatorPolicies... > & > | Specialization for lvalue-references of BasicClosure class |
| Csl::functional::unwrap_functional< BasicClosure< Fn, InvokePolicy, OperatorPolicies... > && > | Specialization for rvalue-references of BasicClosure class |
| Csl::functional::unwrap_functional< const BasicClosure< Fn, InvokePolicy, OperatorPolicies... > & > | Specialization for const lvalue-references of BasicClosure class |
| Csl::functional::unwrap_functional< const BasicClosure< Fn, InvokePolicy, OperatorPolicies... > && > | Specialization for const rvalue-references of BasicClosure class |
| Csl::value_category_as< To, From > | Primary template, removing any reference category |
| Csl::value_category_as< To, From & > | Specialization, applying the lvalue reference category |
| Csl::value_category_as< To, From && > | Specialization, applying the rvalue reference category |
| Csl::type_list::zip_as< TargetContainer, Lists > | Algorithm yielding the result as the type member alias |
| Csl::type_list::zip_nth_elements_as< TargetContainer, index, Lists > | Algorithm yielding the result as the type member alias |
| Csl::tuple::zip_result< Tuples > | Trait type determining the result of a zip call |
| ►Csl::functional::Fns | |
| Csl::functional::Overloaded< Fns > | Helper invocable type which can hold an arbitrary amount of functions, from which the best match will be selected during invocation |
1.9.6