etl Namespace Reference

Namespaces
namespace	chrono
namespace	chrono_literals
namespace	complex_literals
namespace	execution
namespace	experimental
namespace	linalg
namespace	literals
namespace	mpl
namespace	numbers
namespace	placeholders
namespace	ranges
namespace	string_view_literals
namespace	strings

Classes
struct	_swap_no_throw
struct	_swappable_with_helper
struct	_swappable_with_helper< T, U, void_t< decltype(swap(declval< T >(), declval< U >()))> >
struct	add_const
	Provides the member typedef type which is the same as T, except it has a cv-qualifier added (unless T is a function, a reference, or already has this cv-qualifier). Adds const. More...
struct	add_cv
	Provides the member typedef type which is the same as T, except it has a cv-qualifier added (unless T is a function, a reference, or already has this cv-qualifier). Adds both const and volatile. More...
struct	add_lvalue_reference
	Creates a lvalue reference type of T. More...
struct	add_pointer
	If T is a reference type, then provides the member typedef type which is a pointer to the referred type. Otherwise, if T names an object type, a function type that is not cv- or ref-qualified, or a (possibly cv-qualified) void type, provides the member typedef type which is the type T*. Otherwise (if T is a cv- or ref-qualified function type), provides the member typedef type which is the type T. The behavior of a program that adds specializations for add_pointer is undefined. More...
struct	add_rvalue_reference
	Creates a rvalue reference type of T. More...
struct	add_volatile
	Provides the member typedef type which is the same as T, except it has a cv-qualifier added (unless T is a function, a reference, or already has this cv-qualifier). Adds volatile. More...
struct	adopt_lock_t
	Empty struct tag types used to specify locking strategy for etl::lock_guard, etl::scoped_lock, etl::unique_lock, and etl::shared_lock. More...
struct	aligned_storage
	Provides the nested type type, which is a trivial standard-layout type suitable for use as uninitialized storage for any object whose size is at most Len and whose alignment requirement is a divisor of Align. The default value of Align is the most stringent (the largest) alignment requirement for any object whose size is at most Len. If the default value is not used, Align must be the value of alignof(T) for some type T, or the behavior is undefined. More...
struct	aligned_union
	Provides the nested type type, which is a trivial standard-layout type of a size and alignment suitable for use as uninitialized storage for an object of any of the types listed in Types. The size of the storage is at least Len. aligned_union also determines the strictest (largest) alignment requirement among all Types and makes it available as the constant alignment_value. If sizeof...(Types) == 0 or if any of the types in Types is not a complete object type, the behavior is undefined. It is implementation-defined whether any extended alignment is supported. The behavior of a program that adds specializations for aligned_union is undefined. More...
struct	alignment_of
	alignment_of More...
struct	allocator_arg_t
	allocator_arg_t is an empty class type used to disambiguate the overloads of constructors and member functions of allocator-aware objects. More...
struct	allocator_traits
struct	array
	A container that encapsulates fixed size arrays. More...
struct	assert_msg
	Payload for an assertion. More...
struct	back_insert_iterator
	etl::back_insert_iterator is a LegacyOutputIterator that appends to a container for which it was constructed. The container's push_back() member function is called whenever the iterator (whether dereferenced or not) is assigned to. Incrementing the etl::back_insert_iterator is a no-op. More...
struct	bad_function_call
struct	bad_optional_access
	Defines a type of object to be thrown by etl::optional::value when accessing an optional object that does not contain a value. More...
struct	bad_variant_access
	etl::bad_variant_access is the type of the exception thrown in the following situations: (1) etl::get(etl::variant) called with an index or type that does not match the currently active alternative. (2) etl::visit called to visit a variant that is valueless_by_exception More...
struct	basic_bitset
struct	basic_common_reference
	The class template basic_common_reference is a customization point that allows users to influence the result of common_reference for user-defined types (typically proxy references). The primary template is empty. More...
struct	basic_common_reference< pair< T1, T2 >, pair< U1, U2 >, TQual, UQual >
struct	basic_format_arg
struct	basic_format_args
struct	basic_format_context
	Provides access to formatting state consisting of the formatting arguments and the output iterator. More...
struct	basic_format_parse_context
struct	basic_format_string
struct	basic_inplace_string
	basic_inplace_string class with fixed size capacity. More...
struct	basic_string_view
	The class template basic_string_view describes an object that can refer to a constant contiguous sequence of char-like objects with the first element of the sequence at position zero. A typical implementation holds only two members: a pointer to constant Char and a size. More...
struct	bernoulli_distribution
struct	bidirectional_iterator_tag
	Defines the category of an iterator. Each tag is an empty type and corresponds to one of the five (until C++20) six (since C++20) iterator categories. More...
struct	binary_t
struct	bit_and
	Function object for performing bitwise AND. Effectively calls operator& on type T. More...
struct	bit_and< void >
struct	bit_not
	Function object for performing bitwise NOT. Effectively calls operator~ on type T. More...
struct	bit_not< void >
struct	bit_or
	Function object for performing bitwise OR. Effectively calls operator| on type T. More...
struct	bit_or< void >
struct	bit_xor
	Function object for performing bitwise XOR. Effectively calls operator^ on type T. https://en.cppreference.com/w/cpp/utility/functional/bit_xor. More...
struct	bit_xor< void >
struct	bitset
	The class template bitset represents a fixed-size sequence of Bits bits. Bitsets can be manipulated by standard logic operators. More...
struct	char_traits
	The char_traits class is a traits class template that abstracts basic character and string operations for a given character type. More...
struct	char_traits< char >
	Specializations of char_traits for type char. More...
struct	char_traits< char16_t >
	Specializations of char_traits for type char16_t. More...
struct	char_traits< char32_t >
	Specializations of char_traits for type char32_t. More...
struct	char_traits< char8_t >
	Specializations of char_traits for type char8_t. More...
struct	char_traits< wchar_t >
	Specializations of char_traits for type wchar_t. More...
struct	common_comparison_category
struct	common_reference
	Determines the common reference type of the types T..., that is, the type to which all the types in T... can be converted or bound. If such a type exists (as determined according to the rules below), the member type names that type. Otherwise, there is no member type. The behavior is undefined if any of the types in T... is an incomplete type other than (possibly cv-qualified) void. More...
struct	common_reference< T0 >
struct	common_reference< T1, T2 >
struct	common_reference<>
struct	common_type
	Determines the common type among all types T..., that is the type all T... can be implicitly converted to. If such a type exists, the member type names that type. Otherwise, there is no member type. More...
struct	common_type< T >
struct	common_type< T1, T2 >
struct	common_type< T1, T2, R... >
struct	compare_three_way_result
struct	compare_three_way_result< T, U >
struct	complex
	A complex number. More...
struct	conditional
	Provides member typedef type, which is defined as T if B is true at compile time, or as F if B is false. More...
struct	conditional< false, T, F >
struct	conjunction
	Forms the logical conjunction of the type traits B..., effectively performing a logical AND on the sequence of traits. More...
struct	contiguous_iterator_tag
	Defines the category of an iterator. Each tag is an empty type and corresponds to one of the five (until C++20) six (since C++20) iterator categories. More...
struct	copy_cv
struct	copy_cv< From const volatile, T0 >
struct	copy_cv< From const, T0 >
struct	copy_cv< From volatile, T0 >
struct	coroutine_handle
struct	coroutine_handle< void >
struct	coroutine_traits
struct	decay
	Applies lvalue-to-rvalue, array-to-pointer, and function-to-pointer implicit conversions to the type T, removes cv-qualifiers, and defines the resulting type as the member typedef type. More...
struct	default_accessor
struct	default_delete
struct	default_delete< T[]>
struct	default_searcher
	Default searcher. A class suitable for use with Searcher overload of etl::search that delegates the search operation to the pre-C++17 standard library's etl::search. More...
struct	defer_lock_t
	Empty struct tag types used to specify locking strategy for etl::lock_guard, etl::scoped_lock, etl::unique_lock, and etl::shared_lock. More...
struct	destroying_delete_t
	Tag type used to identify the destroying delete form of operator delete. More...
struct	disjunction
	Forms the logical disjunction of the type traits B..., effectively performing a logical OR on the sequence of traits. More...
struct	div_t
	Return type for div. More...
struct	divides
	Function object for performing division. Effectively calls operator/ on two instances of type T. https://en.cppreference.com/w/cpp/utility/functional/divides. More...
struct	divides< void >
struct	domain_error
struct	dynamic_array
struct	empty_c_array
struct	enable_if
	Define a member typedef only if a boolean constant is true. More...
struct	enable_if< true, Type >
struct	equal_to
	Function object for performing comparisons. Unless specialised, invokes operator== on type T. https://en.cppreference.com/w/cpp/utility/functional/equal_to. More...
struct	equal_to< void >
struct	exception
struct	expected
struct	extent
	If T is an array type, provides the member constant value equal to the number of elements along the Nth dimension of the array, if N is in [0, rank_v<T>). For any other type, or if T is an array of unknown bound along its first dimension and N is 0, value is 0. More...
struct	extent< T[], 0 >
struct	extent< T[], N >
struct	extent< T[I], 0 >
struct	extent< T[I], N >
struct	extents
struct	flat_multiset
struct	flat_set
	A flat_set is a container adaptor that provides an associative container interface that supports unique keys (contains at most one of each key value) and provides for fast retrieval of the keys themselves. flat_set supports random access iterators. Any sequence container supporting random access iteration can be used to instantiate flat_set. More...
struct	fnv1a
struct	format_to_n_result
	etl::format_to_n_result has no base classes, or members other than out, size and implicitly declared special member functions. More...
struct	formatter
	The enabled specializations of formatter define formatting rules for a given type. Enabled specializations meet the Formatter requirements. More...
struct	formatter< char const *, char >
struct	formatter< char, char >
	Standard specializations for basic type char. More...
struct	formatter< char[N], char >
struct	formatter< etl::inplace_string< Capacity >, char >
struct	formatter< etl::string_view, char >
struct	formatter< int, char >
struct	formatter< long long, char >
struct	formatter< long, char >
struct	formatter< short, char >
struct	formatter< unsigned long long, char >
struct	formatter< unsigned long, char >
struct	formatter< unsigned short, char >
struct	formatter< unsigned, char >
struct	forward_iterator_tag
	Defines the category of an iterator. Each tag is an empty type and corresponds to one of the five (until C++20) six (since C++20) iterator categories. More...
struct	from_chars_result
	Primitive numerical input conversion. More...
struct	front_insert_iterator
	front_insert_iterator is an LegacyOutputIterator that prepends elements to a container for which it was constructed. More...
struct	full_extent_t
struct	function_ref
	Non-owning view of a callable. More...
struct	function_ref< R(Args...) noexcept >
struct	function_ref< R(Args...)>
struct	greater
	Function object for performing comparisons. Unless specialised, invokes operator> on type T. https://en.cppreference.com/w/cpp/utility/functional/greater. More...
struct	greater< void >
struct	greater_equal
	Function object for performing comparisons. Unless specialised, invokes operator>= on type T. https://en.cppreference.com/w/cpp/utility/functional/greater_equal. More...
struct	greater_equal< void >
struct	half
struct	has_unique_object_representations
	If T is TriviallyCopyable and if any two objects of type T with the same value have the same object representation, provides the member constant value equal true. For any other type, value is false. More...
struct	has_virtual_destructor
	https://en.cppreference.com/w/cpp/types/has_virtual_destructor More...
struct	hash
	hash More...
struct	hash< bool >
struct	hash< char >
struct	hash< char16_t >
struct	hash< char32_t >
struct	hash< char8_t >
struct	hash< coroutine_handle< T > >
struct	hash< double >
struct	hash< etl::nullptr_t >
struct	hash< etl::optional< T > >
	The template specialization of etl::hash for the etl::optional class allows users to obtain hashes of the values contained in optional objects. More...
struct	hash< float >
struct	hash< int >
struct	hash< long >
struct	hash< long double >
struct	hash< long long >
struct	hash< short >
struct	hash< signed char >
struct	hash< T * >
struct	hash< unsigned char >
struct	hash< unsigned int >
struct	hash< unsigned long >
struct	hash< unsigned long long >
struct	hash< unsigned short >
struct	hash< wchar_t >
struct	identity
	etl::identity is a function object type whose operator() returns its argument unchanged. More...
struct	idiv_result
struct	ignore
	An object of unspecified type such that any value can be assigned to it with no effect. Intended for use with etl::tie when unpacking a etl::tuple, as a placeholder for the arguments that are not used. More...
struct	imaxdiv_t
	Return type for imaxdiv. More...
struct	in_place_index_t
	Disambiguation tags that can be passed to the constructors of etl::optional, etl::variant, and etl::any to indicate that the contained object should be constructed in-place, and (for the latter two) the type of the object to be constructed. More...
struct	in_place_t
	Disambiguation tags that can be passed to the constructors of optional, variant, and any to indicate that the contained object should be constructed in-place, and (for the latter two) the type of the object to be constructed. More...
struct	in_place_type_t
	Disambiguation tags that can be passed to the constructors of etl::optional, etl::variant, and etl::any to indicate that the contained object should be constructed in-place, and (for the latter two) the type of the object to be constructed. More...
struct	incrementable_traits
struct	incrementable_traits< T * >
struct	incrementable_traits< T >
struct	incrementable_traits< T const >
struct	indirectly_readable_traits
struct	indirectly_readable_traits< I >
struct	indirectly_readable_traits< T * >
struct	indirectly_readable_traits< T >
struct	indirectly_readable_traits< T const >
struct	inplace_function
struct	inplace_function< R(Args...), Capacity, Alignment >
struct	inplace_vector
struct	inplace_vector< T, 0 >
struct	input_iterator_tag
	Defines the category of an iterator. Each tag is an empty type and corresponds to one of the five (until C++20) six (since C++20) iterator categories. More...
struct	integer_sequence
struct	integral_constant
struct	invalid_argument
struct	invoke_result
	Deduces the return type of an INVOKE expression at compile time. More...
struct	is_abstract
struct	is_aggregate
struct	is_arithmetic
	If T is an arithmetic type (that is, an integral type or a floating-point type) or a cv-qualified version thereof, provides the member constant value equal true. For any other type, value is false. The behavior of a program that adds specializations for is_arithmetic or is_arithmetic_v (since C++17) is undefined. More...
struct	is_array
	Checks whether T is an array type. Provides the member constant value which is equal to true, if T is an array type. Otherwise, value is equal to false. More...
struct	is_array< T[]>
struct	is_array< T[N]>
struct	is_assignable
	If the expression etl::declval<T>() = etl::declval<U>() is well-formed in unevaluated context, provides the member constant value equal true. Otherwise, value is false. Access checks are performed as if from a context unrelated to either type. More...
struct	is_base_of
	If Derived is derived from Base or if both are the same non-union class (in both cases ignoring cv-qualification), provides the member constant value equal to true. Otherwise value is false. More...
struct	is_bitmask_type
struct	is_bounded_array
	Checks whether T is an array type of known bound. Provides the member constant value which is equal to true, if T is an array type of known bound. Otherwise, value is equal to false. More...
struct	is_bounded_array< T[N]>
struct	is_builtin_integer
struct	is_builtin_signed_integer
struct	is_builtin_unsigned_integer
	True if T is unsigned char or unsigned short or unsigned int or unsigned long or unsigned long long More...
struct	is_class
struct	is_compound
	If T is a compound type (that is, array, function, object pointer, function pointer, member object pointer, member function pointer, reference, class, union, or enumeration, including any cv-qualified variants), provides the member constant value equal true. For any other type, value is false. More...
struct	is_const
	If T is a const-qualified type (that is, const, or const volatile), provides the member constant value equal to true. For any other type, value is false. More...
struct	is_const< T const >
struct	is_convertible
	If the imaginary function definition To test() { return etl::declval<From>(); } is well-formed, (that is, either etl::declval<From>() can be converted to To using implicit conversions, or both From and To are possibly cv-qualified void), provides the member constant value equal to true. Otherwise value is false. For the purposes of this check, the use of etl::declval in the return statement is not considered an odr-use. Access checks are performed as if from a context unrelated to either type. Only the validity of the immediate context of the expression in the return statement (including conversions to the return type) is considered. More...
struct	is_copy_assignable
	If T is not a referenceable type (i.e., possibly cv-qualified void or a function type with a cv-qualifier-seq or a ref-qualifier), provides a member constant value equal to false. Otherwise, provides a member constant value equal to etl::is_assignable<T&, T const&>::value. More...
struct	is_copy_constructible
	If T is not a referenceable type (i.e., possibly cv-qualified void or a function type with a cv-qualifier-seq or a ref-qualifier), provides a member constant value equal to false. Otherwise, provides a member constant value equal to etl::is_constructible<T, T const&>::value. More...
struct	is_default_constructible
	If etl::is_constructible<T>::value is true, provides the member constant value equal to true, otherwise value is false. More...
struct	is_destructible
	Because the C++ program terminates if a destructor throws an exception during stack unwinding (which usually cannot be predicted), all practical destructors are non-throwing even if they are not declared noexcept. All destructors found in the C++ standard library are non-throwing. More...
struct	is_destructible< Type[]>
struct	is_destructible< void >
struct	is_empty
	f T is an empty type (that is, a non-union class type with no non-static data members other than bit-fields of size 0, no virtual functions, no virtual base classes, and no non-empty base classes), provides the member constant value equal to true. For any other type, value is false. More...
struct	is_enum
struct	is_error_condition_enum
struct	is_error_condition_enum< errc >
struct	is_execution_policy
	Checks whether T is a standard or implementation-defined execution policy type. More...
struct	is_execution_policy< etl::execution::sequenced_policy >
struct	is_execution_policy< etl::execution::unsequenced_policy >
struct	is_final
	If T is a final class (that is, a class declared with the final specifier), provides the member constant value equal true. For any other type, value is false. If T is a class type, T shall be a complete type; otherwise, the behavior is undefined. More...
struct	is_floating_point
	Checks whether T is a floating-point type. Provides the member constant value which is equal to true, if T is the type float, double, long double, including any cv-qualified variants. Otherwise, value is equal to false. More...
struct	is_function
struct	is_fundamental
	If T is a fundamental type (that is, arithmetic type, void, or nullptr_t), provides the member constant value equal true. For any other type, value is false. More...
struct	is_implicit_default_constructible
struct	is_implicit_default_constructible< T, decltype(test_implicit_default_constructible< T const & >({})), false_type >
struct	is_implicit_default_constructible< T, decltype(test_implicit_default_constructible< T const & >({})), true_type >
struct	is_integral
struct	is_invocable
struct	is_invocable_r
struct	is_lvalue_reference
	Checks whether T is a lvalue reference type. Provides the member constant value which is equal to true, if T is a lvalue reference type. Otherwise, value is equal to false. More...
struct	is_lvalue_reference< T & >
struct	is_member_function_pointer
	Checks whether T is a non-static member function pointer. Provides the member constant value which is equal to true, if T is a non-static member function pointer type. Otherwise, value is equal to false. More...
struct	is_member_object_pointer
	Checks whether T is a non-static member object pointer. Provides the member constant value which is equal to true, if T is a non-static member object pointer type. Otherwise, value is equal to false. More...
struct	is_member_pointer
	If T is pointer to non-static member object or a pointer to non-static member function, provides the member constant value equal true. For any other type, value is false. The behavior of a program that adds specializations for is_member_pointer or is_member_pointer_v (since C++17) is undefined. More...
struct	is_move_assignable
	If T is not a referenceable type (i.e., possibly cv-qualified void or a function type with a cv-qualifier-seq or a ref-qualifier), provides a member constant value equal to false. Otherwise, provides a member constant value equal to etl::is_assignable<T&, T&&>::value. More...
struct	is_move_constructible
	If T is not a referenceable type (i.e., possibly cv-qualified void or a function type with a cv-qualifier-seq or a ref-qualifier), provides a member constant value equal to false. Otherwise, provides a member constant value equal to etl::is_constructible<T, T&&>::value. More...
struct	is_nothrow_assignable
	If the expression etl::declval<T>() = etl::declval<U>() is well-formed in unevaluated context, provides the member constant value equal true. Otherwise, value is false. Access checks are performed as if from a context unrelated to either type. More...
struct	is_nothrow_assignable< T, U >
struct	is_nothrow_constructible
	The variable definition does not call any operation that is not trivial. For the purposes of this check, the call to etl::declval is considered trivial. More...
struct	is_nothrow_convertible
struct	is_nothrow_convertible< From, To >
struct	is_nothrow_copy_assignable
	If T is not a referenceable type (i.e., possibly cv-qualified void or a function type with a cv-qualifier-seq or a ref-qualifier), provides a member constant value equal to false. Otherwise, provides a member constant value equal to etl::is_nothrow_assignable<T&, T const&>::value. More...
struct	is_nothrow_copy_constructible
	Same as copy, but uses etl::is_nothrow_constructible<T, T const&>. More...
struct	is_nothrow_default_constructible
	If etl::is_nothrow_constructible<T>::value is true, provides the member constant value equal to true, otherwise value is false. More...
struct	is_nothrow_destructible
	https://en.cppreference.com/w/cpp/types/is_destructible More...
struct	is_nothrow_destructible< Type & >
struct	is_nothrow_destructible< Type && >
struct	is_nothrow_destructible< Type[N]>
struct	is_nothrow_move_assignable
	If T is not a referenceable type (i.e., possibly cv-qualified void or a function type with a cv-qualifier-seq or a ref-qualifier), provides a member constant value equal to false. Otherwise, provides a member constant value equal to etl::is_assignable<T&, T&&>::value. More...
struct	is_nothrow_move_constructible
	If T is not a referenceable type (i.e., possibly cv-qualified void or a function type with a cv-qualifier-seq or a ref-qualifier), provides a member constant value equal to false. Otherwise, provides a member constant value equal to etl::is_nothrow_constructible<T, T&&>::value. More...
struct	is_nothrow_swappable
	If T is not a referenceable type (i.e., possibly cv-qualified void or a function type with a cv-qualifier-seq or a ref-qualifier), provides a member constant value equal to false. Otherwise, provides a member constant value equal to etl::is_nothrow_swappable_with<T&, T&>::value. More...
struct	is_nothrow_swappable_with
struct	is_null_pointer
struct	is_object
	If T is an object type (that is any possibly cv-qualified type other than function, reference, or void types), provides the member constant value equal true. For any other type, value is false. More...
struct	is_placeholder
struct	is_placeholder< detail::placeholder_type< N > >
struct	is_placeholder< T const >
struct	is_placeholder< T const volatile >
struct	is_placeholder< T volatile >
struct	is_pointer
	Checks whether T is a pointer to object or a pointer to function (but not a pointer to member/member function). Provides the member constant value which is equal to true, if T is a object/function pointer type. Otherwise, value is equal to false. More...
struct	is_polymorphic
struct	is_reference
	If T is a reference type (lvalue reference or rvalue reference), provides the member constant value equal true. For any other type, value is false. The behavior of a program that adds specializations for is_reference or is_reference_v is undefined. More...
struct	is_reference< T & >
struct	is_reference< T && >
struct	is_reference_wrapper
struct	is_reference_wrapper< reference_wrapper< U > >
struct	is_rvalue_reference
	Checks whether T is a rvalue reference type. Provides the member constant value which is equal to true, if T is a rvalue reference type. Otherwise, value is equal to false. More...
struct	is_rvalue_reference< T && >
struct	is_same
	If T and U name the same type (taking into account const/volatile qualifications), provides the member constant value equal to true. Otherwise value is false. More...
struct	is_same< T, T >
struct	is_scalar
	If T is a scalar type (that is a possibly cv-qualified arithmetic, pointer, pointer to member, enumeration, or etl::nullptr_t type), provides the member constant value equal true. For any other type, value is false. More...
struct	is_scoped_enum
struct	is_scoped_enum< T >
struct	is_signed
	If T is an arithmetic type, provides the member constant value equal to true if T(-1) < T(0): this results in true for the floating-point types and the signed integer types, and in false for the unsigned integer types and the type bool. For any other type, value is false. More...
struct	is_specialized
struct	is_specialized< Template, T, void_t< decltype(Template< T >{})> >
struct	is_standard_layout
	If T is a standard layout type (that is, a scalar type, a standard-layout class, or an array of such type/class, possibly cv-qualified), provides the member constant value equal to true. For any other type, value is false. More...
struct	is_swappable
	If T is not a referenceable type (i.e., possibly cv-qualified void or a function type with a cv-qualifier-seq or a ref-qualifier), provides a member constant value equal to false. Otherwise, provides a member constant value equal to etl::is_swappable_with<T&, T&>::value. More...
struct	is_swappable_with
struct	is_trivial
	If T is TrivialType (that is, a scalar type, a trivially copyable class with a trivial default constructor, or array of such type/class, possibly cv-qualified), provides the member constant value equal to true. For any other type, value is false. More...
struct	is_trivially_assignable
	If the expression etl::declval<T>() = etl::declval<U>() is well-formed in unevaluated context, provides the member constant value equal true. Otherwise, value is false. Access checks are performed as if from a context unrelated to either type. More...
struct	is_trivially_constructible
	The variable definition does not call any operation that is not trivial. For the purposes of this check, the call to etl::declval is considered trivial. More...
struct	is_trivially_copy_assignable
	If T is not a referenceable type (i.e., possibly cv-qualified void or a function type with a cv-qualifier-seq or a ref-qualifier), provides a member constant value equal to false. Otherwise, provides a member constant value equal to etl::is_trivially_assignable<T&, T const&>::value. More...
struct	is_trivially_copy_constructible
	Same as copy, but uses etl::is_trivially_constructible<T, T const&>. More...
struct	is_trivially_copyable
	If T is a TriviallyCopyable type, provides the member constant value equal to true. For any other type, value is false. The only trivially copyable types are scalar types, trivially copyable classes, and arrays of such types/classes (possibly cv-qualified). group is_trivial_copyable. More...
struct	is_trivially_default_constructible
	If etl::is_trivially_constructible<T>::value is true, provides the member constant value equal to true, otherwise value is false. More...
struct	is_trivially_destructible
	Storage occupied by trivially destructible objects may be reused without calling the destructor. More...
struct	is_trivially_move_assignable
	If T is not a referenceable type (i.e., possibly cv-qualified void or a function type with a cv-qualifier-seq or a ref-qualifier), provides a member constant value equal to false. Otherwise, provides a member constant value equal to etl::is_assignable<T&, T&&>::value. More...
struct	is_trivially_move_constructible
	If T is not a referenceable type (i.e., possibly cv-qualified void or a function type with a cv-qualifier-seq or a ref-qualifier), provides a member constant value equal to false. Otherwise, provides a member constant value equal to etl::is_trivially_constructible<T, T&&>::value. More...
struct	is_typename
struct	is_unbounded_array
	Checks whether T is an array type of unknown bound. Provides the member constant value which is equal to true, if T is an array type of unknown bound. Otherwise, value is equal to false. More...
struct	is_unbounded_array< T[]>
struct	is_union
struct	is_unsigned
	If T is an arithmetic type, provides the member constant value equal to true if T(0) < T(-1): this results in true for the unsigned integer types and the type bool and in false for the signed integer types and the floating-point types. For any other type, value is false. The behavior of a program that adds specializations for is_unsigned or is_unsigned_v (since C++17) is undefined. More...
struct	is_void
	Define a member typedef only if a boolean constant is true. More...
struct	is_volatile
struct	is_volatile< T volatile >
struct	iterator_traits
	iterator_traits is the type trait class that provides uniform interface to the properties of LegacyIterator types. This makes it possible to implement algorithms only in terms of iterators. More...
struct	iterator_traits< T * >
struct	layout_left
struct	layout_right
struct	layout_stride
struct	ldiv_t
	Return type for ldiv. More...
struct	length_error
struct	less
	Function object for performing comparisons. Unless specialised, invokes operator< on type T. https://en.cppreference.com/w/cpp/utility/functional/less. More...
struct	less< void >
struct	less_equal
	Function object for performing comparisons. Unless specialised, invokes operator<= on type T. https://en.cppreference.com/w/cpp/utility/functional/less_equal. More...
struct	less_equal< void >
struct	lldiv_t
	Return type for lldiv. More...
struct	lock_guard
	The struct lock_guard is a mutex wrapper that provides a convenient RAII-style mechanism for owning a mutex for the duration of a scoped block. When a lock_guard object is created, it attempts to take ownership of the mutex it is given. When control leaves the scope in which the lock_guard object was created, the lock_guard is destructed and the mutex is released. The lock_guard struct is non-copyable. More...
struct	logic_error
struct	logical_and
	Function object for performing logical AND (logical conjunction). Effectively calls operator&& on type T. https://en.cppreference.com/w/cpp/utility/functional/logical_and. More...
struct	logical_and< void >
struct	logical_not
	Function object for performing logical NOT (logical negation). Effectively calls operator! for type T. https://en.cppreference.com/w/cpp/utility/functional/logical_not. More...
struct	logical_not< void >
struct	logical_or
	Function object for performing logical OR (logical disjunction). Effectively calls operator|| on type T. https://en.cppreference.com/w/cpp/utility/functional/logical_or. More...
struct	logical_or< void >
struct	make_signed
	If T is an integral (except bool) or enumeration type, provides the member typedef type which is the unsigned integer type corresponding to T, with the same cv-qualifiers. If T is signed or unsigned char, short, int, long, long long; the unsigned type from this list corresponding to T is provided. The behavior of a program that adds specializations for make_signed is undefined. More...
struct	make_unsigned
	If T is an integral (except bool) or enumeration type, provides the member typedef type which is the unsigned integer type corresponding to T, with the same cv-qualifiers. If T is signed or unsigned char, short, int, long, long long; the unsigned type from this list corresponding to T is provided. The behavior of a program that adds specializations for make_unsigned is undefined. More...
struct	max_align_t
	etl::max_align_t is a trivial standard-layout type whose alignment requirement is at least as strict (as large) as that of every scalar type. More...
struct	mdarray
struct	mdspan
struct	minus
	Function object for performing subtraction. Effectively calls operator- on two instances of type T. https://en.cppreference.com/w/cpp/utility/functional/minus. More...
struct	minus< void >
struct	modulus
	Function object for computing remainders of divisions. Implements operator% for type T. https://en.cppreference.com/w/cpp/utility/functional/modulus. More...
struct	modulus< void >
struct	monostate
	Unit type intended for use as a well-behaved empty alternative in etl::variant. In particular, a variant of non-default-constructible types may list etl::monostate as its first alternative: this makes the variant itself default-constructible. More...
struct	monotonic_allocator
struct	multiplies
	Function object for performing multiplication. Effectively calls operator* on two instances of type T. https://en.cppreference.com/w/cpp/utility/functional/multiplies. More...
struct	multiplies< void >
struct	negate
	Function object for performing negation. Effectively calls operator- on an instance of type T. https://en.cppreference.com/w/cpp/utility/functional/negate. More...
struct	negate< void >
struct	negation
	Forms the logical negation of the type trait B. More...
struct	nontype_t
struct	not_equal_to
	Function object for performing comparisons. Unless specialised, invokes operator!= on type T. https://en.cppreference.com/w/cpp/utility/functional/not_equal_to. More...
struct	not_equal_to< void >
struct	nothrow_t
	etl::nothrow_t is an empty class type used to disambiguate the overloads of throwing and non-throwing allocation functions. More...
struct	nullopt_t
	etl::nullopt_t is an empty class type used to indicate optional type with uninitialized state. In particular, etl::optional has a constructor with nullopt_t as a single argument, which creates an optional that does not contain a value. More...
struct	numeric_limits
struct	numeric_limits< bool >
struct	numeric_limits< char >
struct	numeric_limits< char8_t >
struct	numeric_limits< double >
struct	numeric_limits< float >
struct	numeric_limits< int >
struct	numeric_limits< long >
struct	numeric_limits< long double >
struct	numeric_limits< long long >
struct	numeric_limits< short >
struct	numeric_limits< signed char >
struct	numeric_limits< T const >
struct	numeric_limits< T const volatile >
struct	numeric_limits< T volatile >
struct	numeric_limits< uint128 >
struct	numeric_limits< unsigned char >
struct	numeric_limits< unsigned int >
struct	numeric_limits< unsigned long >
struct	numeric_limits< unsigned long long >
struct	numeric_limits< unsigned short >
struct	optional
	The class template optional manages an optional contained value, i.e. a value that may or may not be present. More...
struct	optional< T & >
struct	out_of_range
struct	output_iterator_tag
	Defines the category of an iterator. Each tag is an empty type and corresponds to one of the five (until C++20) six (since C++20) iterator categories. More...
struct	overflow_error
struct	overload
struct	pair
	etl::pair is a class template that provides a way to store two heterogeneous objects as a single unit. A pair is a specific case of a etl::tuple with two elements. If neither T1 nor T2 is a possibly cv-qualified class type with non-trivial destructor, or array thereof, the destructor of pair is trivial. More...
struct	partial_ordering
struct	piecewise_construct_t
	etl::piecewise_construct_t is an empty class tag type used to disambiguate between different functions that take two tuple arguments. More...
struct	plus
	Function object for performing addition. Effectively calls operator+ on two instances of type T. https://en.cppreference.com/w/cpp/utility/functional/plus. More...
struct	plus< void >
struct	pointer_int_pair
	This struct implements a pair of a pointer and small integer. It is designed to represent this in the space required by one pointer by bitmangling the integer into the low part of the pointer. This can only be done for small integers: typically up to 3 bits, but it depends on the number of bits available according to pointer_like_traits for the type. More...
struct	pointer_int_pair_info
struct	pointer_like_traits
	A traits type that is used to handle pointer types and things that are just wrappers for pointers as a uniform entity. More...
struct	pointer_like_traits< pointer_int_pair< PtrT, IntBits, IntT, PtrTraits > >
struct	pointer_like_traits< T * >
	Provide pointer_like_traits for non-cvr pointers. More...
struct	pointer_like_traits< T const * >
	Provide pointer_like_traits for const pointers. More...
struct	pointer_like_traits< T const >
	Provide pointer_like_traits for const things. More...
struct	pointer_like_traits< uintptr_t >
	Provide pointer_like_traits for uintptr_t. More...
struct	pointer_traits
	The pointer_traits class template provides the standardized way to access certain properties of pointer-like types. More...
struct	pointer_traits< T * >
	The pointer_traits class template provides the standardized way to access certain properties of pointer-like types. More...
struct	random_access_iterator_tag
	Defines the category of an iterator. Each tag is an empty type and corresponds to one of the five (until C++20) six (since C++20) iterator categories. More...
struct	range_error
struct	rank
	If Type is an array type, provides the member constant value equal to the number of dimensions of the array. For any other type, value is 0. The behavior of a program that adds specializations for rank or rank_v is undefined. More...
struct	rank< T[]>
struct	rank< T[N]>
struct	ratio
	The typename template provides compile-time rational arithmetic support. Each instantiation of this template exactly represents any finite rational number as long as its numerator Num and denominator Denom are representable as compile-time constants of type intmax_t. More...
struct	ratio_equal
	Compares two ratio objects for equality at compile-time. If the ratios R1 and R2 are equal, provides the member constant value equal true. Otherwise, value is false. More...
struct	ratio_greater
	Compares two ratio objects for equality at compile-time. If the ratio R1 is greater than the ratio R2, provides the member constant value equal true. Otherwise, value is false. More...
struct	ratio_greater_equal
	Compares two ratio objects for equality at compile-time. If the ratio R1 is greater than or equal to the ratio R2, provides the member constant value equal true. Otherwise, value is false. More...
struct	ratio_less
	Compares two ratio objects for equality at compile-time. If the ratio R1 is less than the ratio R2, provides the member constant value equal true. Otherwise, value is false. More...
struct	ratio_less_equal
	Compares two ratio objects for equality at compile-time. If the ratio R1 is less than or equal to the ratio R2, provides the member constant value equal true. Otherwise, value is false. More...
struct	ratio_not_equal
	Compares two ratio objects for equality at compile-time. If the ratios R1 and R2 are not equal, provides the member constant value equal true. Otherwise, value is false. More...
struct	reference_wrapper
	reference_wrapper is a class template that wraps a reference in a copyable, assignable object. It is frequently used as a mechanism to store references inside standard containers (like etl::static_vector) which cannot normally hold references. Specifically, reference_wrapper is a CopyConstructible and CopyAssignable wrapper around a reference to object or reference to function of type T. Instances of reference_wrapper are objects (they can be copied or stored in containers) but they are implicitly convertible to T&, so that they can be used as arguments with the functions that take the underlying type by reference. If the stored reference is Callable, reference_wrapper is callable with the same arguments. More...
struct	remove_all_extents
	If T is a multidimensional array of some type X, provides the member typedef type equal to X, otherwise type is T. The behavior of a program that adds specializations for remove_all_extents is undefined. More...
struct	remove_all_extents< T[]>
struct	remove_all_extents< T[N]>
struct	remove_const
	Provides the member typedef type which is the same as T, except that its topmost cv-qualifiers are removed. Removes the topmost const. More...
struct	remove_const< Type const >
struct	remove_cv
	Provides the member typedef type which is the same as T, except that its topmost cv-qualifiers are removed. Removes the topmost const, or the topmost volatile, or both, if present. More...
struct	remove_cvref
	If the type T is a reference type, provides the member typedef type which is the type referred to by T with its topmost cv-qualifiers removed. Otherwise type is T with its topmost cv-qualifiers removed. More...
struct	remove_extent
	If T is an array of some type X, provides the member typedef type equal to X, otherwise type is T. Note that if T is a multidimensional array, only the first dimension is removed. The behavior of a program that adds specializations for remove_extent is undefined. More...
struct	remove_extent< T[]>
struct	remove_extent< T[N]>
struct	remove_pointer
	Provides the member typedef type which is the type pointed to by T, or, if T is not a pointer, then type is the same as T. The behavior of a program that adds specializations for remove_pointer is undefined. More...
struct	remove_pointer< T * >
struct	remove_pointer< T *const >
struct	remove_pointer< T *const volatile >
struct	remove_pointer< T *volatile >
struct	remove_reference
struct	remove_reference< T & >
struct	remove_reference< T && >
struct	remove_volatile
	Provides the member typedef type which is the same as T, except that its topmost cv-qualifiers are removed. Removes the topmost volatile. More...
struct	remove_volatile< Type volatile >
struct	reverse_iterator
	reverse_iterator is an iterator adaptor that reverses the direction of a given iterator. In other words, when provided with a bidirectional iterator, reverse_iterator produces a new iterator that moves from the end to the beginning of the sequence defined by the underlying bidirectional iterator. This is the iterator returned by member functions rbegin() and rend() of the standard library containers. More...
struct	runtime_error
struct	scope_exit
	The class template scope_exit is a general-purpose scope guard intended to call its exit function when a scope is exited. More...
struct	small_ptr
	Compressed pointer to specified size. Intended to be used as a drop in replacement for native pointers. More...
struct	smallest_size
	Smallest unsigned integer type that can represent values in the range [0, N]. More...
struct	sorted_equivalent_t
struct	sorted_unique_t
struct	source_location
	A class representing information about the source code, such as file names, line numbers, and function names. More...
struct	span
	A non-owning view over a contiguous sequence of objects. More...
struct	stack
	The stack class is a container adapter that gives the programmer the functionality of a stack - specifically, a LIFO (last-in, first-out) data structure. More...
struct	static_set
	static_set is an associative container that contains a sorted set of unique objects of type Key. Sorting is done using the key comparison function Compare. More...
struct	static_vector
	Dynamically-resizable fixed-capacity vector. More...
struct	strided_slice
struct	string_constant
struct	strong_ordering
struct	submdspan_mapping_result
struct	suspend_always
struct	suspend_never
struct	timespec
struct	tm
struct	to_chars_result
	Primitive numerical output conversion. More...
struct	try_to_lock_t
	Empty struct tag types used to specify locking strategy for etl::lock_guard, etl::scoped_lock, etl::unique_lock, and etl::shared_lock. More...
struct	tuple
struct	tuple_element
	Provides compile-time indexed access to the type of the elements of the array using tuple-like interface. More...
struct	tuple_element< I, array< T, N > >
struct	tuple_element< I, etl::complex< T > >
struct	tuple_element< I, pair< T1, T2 > >
	The partial specializations of tuple_element for pairs provide compile-time access to the types of the pair's elements, using tuple-like syntax. The program is ill-formed if I >= 2. More...
struct	tuple_element< I, T const >
struct	tuple_element< I, T const volatile >
struct	tuple_element< I, T volatile >
struct	tuple_element< I, tuple< Ts... > >
struct	tuple_size
struct	tuple_size< array< T, N > >
	Provides access to the number of elements in an array as a compile-time constant expression. More...
struct	tuple_size< etl::complex< T > >
struct	tuple_size< pair< T1, T2 > >
	The partial specialization of tuple_size for pairs provides a compile-time way to obtain the number of elements in a pair, which is always 2, using tuple-like syntax. More...
struct	tuple_size< T const >
struct	tuple_size< T const volatile >
struct	tuple_size< T volatile >
struct	tuple_size< tuple< Ts... > >
struct	type_identity
struct	uint128
struct	underflow_error
struct	underlying_type
	The underlying type of an enum. More...
struct	unexpect_t
struct	unexpected
struct	uniform_int_distribution
struct	uniform_real_distribution
struct	uninitialized_array
struct	uninitialized_array< T, Size >
struct	uninitialized_union
struct	unique_lock
	The struct unique_lock is a general-purpose mutex ownership wrapper allowing deferred locking, time-constrained attempts at locking, recursive locking, transfer of lock ownership, and use with condition variables. More...
struct	unwrap_ref_decay
struct	unwrap_reference
struct	unwrap_reference< reference_wrapper< T > >
struct	uses_allocator
	If T has a member typedef allocator_type which is convertible from Alloc, the member constant value is true. Otherwise value is false. More...
union	variadic_union
union	variadic_union< T, Ts... >
struct	variant
struct	variant_alternative
	Provides compile-time indexed access to the types of the alternatives of the possibly cv-qualified variant, combining cv-qualifications of the variant (if any) with the cv-qualifications of the alternative. More...
struct	variant_alternative< Idx, T const >
struct	variant_alternative< Idx, T const volatile >
struct	variant_alternative< Idx, T volatile >
struct	variant_alternative< Idx, variant< Ts... > >
struct	variant_size
struct	variant_size< T const >
struct	variant_size< T const volatile >
struct	variant_size< T volatile >
struct	variant_size< variant< Ts... > >
struct	vector
struct	weak_ordering
struct	xorshift
	https://en.wikipedia.org/wiki/Xorshift More...
struct	xoshiro128plus
struct	xoshiro128plusplus
struct	xoshiro128starstar

Concepts
concept	bitmask_type
concept	three_way_comparable
concept	assignable_from
concept	boolean_testable
concept	builtin_integer
concept	builtin_signed_integer
concept	builtin_unsigned_integer
concept	common_reference_with
concept	common_with
concept	constructible_from
	The constructible_from concept specifies that a variable of type T can be initialized with the given set of argument types Args....
concept	convertible_to
	The concept convertible_to<From, To> specifies that an expression of the same type and value category as those of declval<From>() can be implicitly and explicitly converted to the type To, and the two forms of conversion are equivalent.
concept	copy_constructible
	The concept copy_constructible is satisfied if T is an lvalue reference type, or if it is a move_constructible object type where an object of that type can constructed from a (possibly const) lvalue or const rvalue of that type in both direct- and copy-initialization contexts with the usual semantics (a copy is constructed with the source unchanged).
concept	copyable
concept	default_initializable
	The default_initializable concept checks whether variables of type T can be value-initialized (T() is well-formed); direct-list-initialized from an empty initializer list (T{} is well-formed); and default-initialized (T t; is well-formed). Access checking is performed as if in a context unrelated to T. Only the validity of the immediate context of the variable initialization is considered.
concept	derived_from
	The concept derived_from<Derived, Base> is satisfied if and only if Base is a class type that is either Derived or a public and unambiguous base of Derived, ignoring cv-qualifiers. Note that this behaviour is different to is_base_of when Base is a private or protected base of Derived.
concept	destructible
	The concept destructible specifies the concept of all types whose instances can safely be destroyed at the end of their lifetime (including reference types).
concept	equality_comparable
concept	equivalence_relation
concept	floating_point
	The concept floating_point<T> is satisfied if and only if T is a floating-point type.
concept	integral
	The concept integral<T> is satisfied if and only if T is an integral type.
concept	invocable
concept	movable
concept	move_constructible
	The concept move_constructible is satisfied if T is a reference type, or if it is an object type where an object of that type can be constructed from an rvalue of that type in both direct- and copy-initialization contexts, with the usual semantics.
concept	predicate
concept	referenceable
concept	regular
concept	regular_invocable
concept	relation
concept	same_as
	The concept same_as<T, U> is satisfied if and only if T and U denote the same type. same_as<T, U> subsumes same_as<U, T> and vice versa.
concept	semiregular
concept	signed_integral
	The concept signed_integral<T> is satisfied if and only if T is an integral type and is_signed_v<T> is true.
concept	strict_weak_order
concept	swappable
concept	unsigned_integral
	The concept unsigned_integral<T> is satisfied if and only if T is an integral type and is_unsigned_v<T> is true.
concept	weakly_equality_comparable_with
concept	execution_policy
concept	incrementable
concept	indirectly_readable
concept	indirectly_regular_unary_invocable
concept	indirectly_unary_invocable
concept	input_or_output_iterator
concept	legacy_bidirectional_iterator
concept	legacy_forward_iterator
concept	legacy_input_iterator
concept	legacy_iterator
concept	sentinel_for
concept	weakly_incrementable
concept	pair_like
concept	tuple_like

Typedefs
template<size_t Len, size_t Align = alignof(detail::aligned_storage_impl<Len>)>
using	aligned_storage_t = typename aligned_storage< Len, Align >::type
template<size_t Len, typename... Types>
using	aligned_union_t = typename aligned_union< Len, Types... >::type
template<bool B>
using	bool_constant = integral_constant< bool, B >
template<typename ValueType , etl::size_t Size>
using	c_array = ValueType[Size]
using	clock_t = etl::size_t
template<typename... T>
using	common_reference_t = typename common_reference< T... >::type
template<typename... T>
using	common_type_t = typename common_type< T... >::type
template<typename T , typename U = T>
using	compare_three_way_result_t = decltype(etl::declval< etl::remove_reference_t< T > const & >()<=> etl::declval< etl::remove_reference_t< U > const & >())
template<bool B, typename T , typename F >
using	conditional_t = typename conditional< B, T, F >::type
template<typename A , typename B >
using	copy_cv_t = typename copy_cv< A, B >::type
template<typename T >
using	decay_t = typename etl::decay< T >::type
template<typename IndexType , etl::size_t Rank>
using	dextents = typename detail::dextents_impl< IndexType, etl::make_index_sequence< Rank > >::type
template<typename Iter >
using	diff_t = typename etl::iterator_traits< etl::remove_cvref_t< Iter > >::difference_type
using	double_t = double
	Most efficient floating-point type at least as wide as double.
template<bool B, typename T = void>
using	enable_if_t = typename enable_if< B, T >::type
using	false_type = bool_constant< false >
using	float_t = float
	Most efficient floating-point type at least as wide as float.
using	fnv1a32 = fnv1a< etl::uint32_t, 0x01000193, 0x811c9dc5 >
using	fnv1a64 = fnv1a< etl::uint64_t, 0x00000100000001b3, 0xcbf29ce484222325 >
using	format_args = basic_format_args< format_context >
using	format_context = basic_format_context< back_insert_iterator< detail::fmt_buffer< char > >, char >
	Provides access to formatting state consisting of the formatting arguments and the output iterator.
using	format_parse_context = basic_format_parse_context< char >
template<typename... Args>
using	format_string = basic_format_string< char, type_identity_t< Args >... >
template<size_t I>
using	index_constant = integral_constant< size_t, I >
template<etl::size_t... Ints>
using	index_sequence = etl::integer_sequence< etl::size_t, Ints... >
template<typename... T>
using	index_sequence_for = etl::make_index_sequence< sizeof...(T)>
template<typename F , typename... Iters>
using	indirect_result_t = etl::invoke_result_t< F, etl::iter_reference_t< Iters >... >
template<etl::size_t Capacity>
using	inplace_string = basic_inplace_string< char, Capacity >
	Typedef for a basic_inplace_string using 'char'.
template<etl::size_t Capacity>
using	inplace_u16string = basic_inplace_string< char16_t, Capacity >
	Typedef for a basic_inplace_string using 'char16_t'.
template<etl::size_t Capacity>
using	inplace_u32string = basic_inplace_string< char32_t, Capacity >
	Typedef for a basic_inplace_string using 'char32_t'.
template<etl::size_t Capacity>
using	inplace_u8string = basic_inplace_string< char8_t, Capacity >
	Typedef for a basic_inplace_string using 'char8_t'.
template<etl::size_t Capacity>
using	inplace_wstring = basic_inplace_string< wchar_t, Capacity >
	Typedef for a basic_inplace_string using 'wchar_t'.
using	int16_t = TETL_BUILTIN_INT16
	Signed integer type with width of exactly 16 bits.
using	int32_t = TETL_BUILTIN_INT32
	Signed integer type with width of exactly 32 bits.
using	int64_t = TETL_BUILTIN_INT64
	Signed integer type with width of exactly 64 bits.
using	int8_t = TETL_BUILTIN_INT8
	Signed integer type with width of exactly 8 bits.
using	int_fast16_t = TETL_BUILTIN_INT16
	Signed integer type with width of at least 16 bits.
using	int_fast32_t = TETL_BUILTIN_INT32
	Signed integer type with width of at least 32 bits.
using	int_fast64_t = TETL_BUILTIN_INT64
	Signed integer type with width of at least 64 bits.
using	int_fast8_t = TETL_BUILTIN_INT8
	Signed integer type with width of at least 8 bits.
using	int_least16_t = TETL_BUILTIN_INT16
	Signed integer type with width of at least 16 bits.
using	int_least32_t = TETL_BUILTIN_INT32
	Signed integer type with width of at least 32 bits.
using	int_least64_t = TETL_BUILTIN_INT64
	Signed integer type with width of at least 64 bits.
using	int_least8_t = TETL_BUILTIN_INT8
	Signed integer type with width of at least 8 bits.
using	intmax_t = TETL_BUILTIN_INTMAX
	Maximum-width signed integer type.
using	intptr_t = TETL_BUILTIN_INTPTR
	Signed integer type capable of holding a pointer.
template<typename T , typename... Args>
using	is_constructible = detail::is_constructible_helper< void_t<>, T, Args... >
template<etl::indirectly_readable T>
using	iter_common_reference_t = etl::common_reference_t< etl::iter_reference_t< T >, etl::iter_value_t< T > & >
template<typename T >
using	iter_difference_t = typename detail::iter_difference< T >::type
template<etl::detail::dereferenceable T>
using	iter_reference_t = decltype(*etl::declval< T & >())
template<etl::detail::dereferenceable T>
using	iter_rvalue_reference_t = decltype(etl::ranges::iter_move(etl::declval< T & >()))
template<typename T >
using	iter_value_t = typename detail::iter_value< T >::type
template<etl::size_t Size>
using	make_index_sequence = etl::make_integer_sequence< etl::size_t, Size >
template<typename T , T Size>
using	make_integer_sequence = TETL_BUILTIN_INT_SEQ(T, Size)
template<typename T >
using	make_signed_t = typename make_signed< T >::type
template<typename T >
using	make_unsigned_t = typename make_unsigned< T >::type
using	new_handler = void(*)()
	etl::new_handler is the function pointer type (pointer to function that takes no arguments and returns void), which is used by the functions etl::set_new_handler and etl::get_new_handler
using	nullptr_t = decltype(nullptr)
	etl::nullptr_t is the type of the null pointer literal, nullptr. It is a distinct type that is not itself a pointer type or a pointer to member type.
template<etl::indirectly_readable Iter, etl::indirectly_regular_unary_invocable< Iter > Proj>
using	projected = etl::detail::projected_impl< Iter, Proj >::type
using	ptrdiff_t = TETL_BUILTIN_PTRDIFF
	etl::ptrdiff_t is the signed integer type of the result of subtracting two pointers.
template<typename R1 , typename R2 >
using	ratio_add = ratio< R1::num *R2::den+R2::num *R1::den, R1::den *R2::den >
	The alias template ratio_add denotes the result of adding two exact rational fractions represented by the ratio specializations R1 and R2.
template<typename R1 , typename R2 >
using	ratio_divide = ratio< R1::num *R2::den, R1::den *R2::num >
	The alias template ratio_divide denotes the result of dividing two exact rational fractions represented by the ratio specializations R1 and R2.
template<typename R1 , typename R2 >
using	ratio_multiply = ratio< R1::num *R2::num, R1::den *R2::den >
	The alias template ratio_multiply denotes the result of multiplying two exact rational fractions represented by the ratio specializations R1 and R2.
template<typename R1 , typename R2 >
using	ratio_subtract = ratio<(R1::num *R2::den) -(R2::num *R1::den), R1::den *R2::den >
	The alias template ratio_subtract denotes the result of subtracting two exact rational fractions represented by the ratio specializations R1 and R2.
template<typename T >
using	remove_all_extents_t = typename remove_all_extents< T >::type
template<typename T >
using	remove_const_t = typename remove_const< T >::type
template<typename T >
using	remove_cv_t = remove_const_t< remove_volatile_t< T > >
template<typename T >
using	remove_cvref_t = remove_cv_t< remove_reference_t< T > >
template<typename T >
using	remove_extent_t = typename remove_extent< T >::type
template<typename T >
using	remove_pointer_t = typename remove_pointer< T >::type
template<typename T >
using	remove_reference_t = typename remove_reference< T >::type
template<typename T >
using	remove_volatile_t = typename remove_volatile< T >::type
using	size_t = TETL_BUILTIN_SIZET
	etl::size_t is the unsigned integer type of the result of the sizeof operator.
template<unsigned long long N>
using	smallest_size_t = typename smallest_size< N >::type
using	streamoff = long
using	streamsize = make_signed_t< size_t >
using	string_view = basic_string_view< char, etl::char_traits< char > >
	Typedef for common character type char
using	time_t = etl::size_t
	Arithmetic type capable of representing times.
using	true_type = bool_constant< true >
template<size_t I, typename T >
using	tuple_element_t = typename tuple_element< I, T >::type
template<typename T >
using	type_identity_t = typename type_identity< T >::type
using	u16string_view = basic_string_view< char16_t, etl::char_traits< char16_t > >
	Typedef for common character type char16_t
using	u32string_view = basic_string_view< char32_t, etl::char_traits< char32_t > >
	Typedef for common character type char32_t
using	u8string_view = basic_string_view< char8_t, etl::char_traits< char8_t > >
	Typedef for common character type char8_t
using	uint128_t = uint128
using	uint16_t = TETL_BUILTIN_UINT16
	Unsigned integer type with width of exactly 16 bits.
using	uint32_t = TETL_BUILTIN_UINT32
	Unsigned integer type with width of exactly 32 bits.
using	uint64_t = TETL_BUILTIN_UINT64
	Unsigned integer type with width of exactly 64 bits.
using	uint8_t = TETL_BUILTIN_UINT8
	Unsigned integer type with width of exactly 8 bits.
using	uint_fast16_t = TETL_BUILTIN_UINT16
	Signed integer type with width of at least 16 bits.
using	uint_fast32_t = TETL_BUILTIN_UINT32
	Signed integer type with width of at least 32 bits.
using	uint_fast64_t = TETL_BUILTIN_UINT64
	Signed integer type with width of at least 64 bits.
using	uint_fast8_t = TETL_BUILTIN_UINT8
	Signed integer type with width of at least 8 bits.
using	uint_least16_t = TETL_BUILTIN_UINT16
	Signed integer type with width of at least 16 bits.
using	uint_least32_t = TETL_BUILTIN_UINT32
	Signed integer type with width of at least 32 bits.
using	uint_least64_t = TETL_BUILTIN_UINT64
	Signed integer type with width of at least 64 bits.
using	uint_least8_t = TETL_BUILTIN_UINT8
	Signed integer type with width of at least 8 bits.
using	uintmax_t = TETL_BUILTIN_UINTMAX
	Maximum-width unsigned integer type.
using	uintptr_t = TETL_BUILTIN_UINTPTR
	Unsigned integer type capable of holding a pointer.
template<typename T >
using	underlying_type_t = typename underlying_type< T >::type
template<typename T >
using	unwrap_ref_decay_t = typename unwrap_ref_decay< T >::type
template<typename T >
using	unwrap_reference_t = typename unwrap_reference< T >::type
template<size_t I, typename T >
using	variant_alternative_t = typename variant_alternative< I, T >::type
template<typename... >
using	void_t = void
using	wformat_args = basic_format_args< wformat_context >
using	wformat_context = basic_format_context< back_insert_iterator< detail::fmt_buffer< wchar_t > >, wchar_t >
using	wformat_parse_context = basic_format_parse_context< wchar_t >
template<typename... Args>
using	wformat_string = basic_format_string< wchar_t, type_identity_t< Args >... >
using	wint_t = unsigned int
using	wstring_view = basic_string_view< wchar_t, etl::char_traits< wchar_t > >
	Typedef for common character type wchar_t
using	atto = ratio< 1, 1 '000 '000 '000 '000 '000 '000 >
using	femto = ratio< 1, 1 '000 '000 '000 '000 '000 >
using	pico = ratio< 1, 1 '000 '000 '000 '000 >
using	nano = ratio< 1, 1 '000 '000 '000 >
using	micro = ratio< 1, 1 '000 '000 >
using	milli = ratio< 1, 1 '000 >
using	centi = ratio< 1, 100 >
using	deci = ratio< 1, 10 >
using	deca = ratio< 10, 1 >
using	hecto = ratio< 100, 1 >
using	kilo = ratio< 1 '000, 1 >
using	mega = ratio< 1 '000 '000, 1 >
using	giga = ratio< 1 '000 '000 '000, 1 >
using	tera = ratio< 1 '000 '000 '000 '000, 1 >
using	peta = ratio< 1 '000 '000 '000 '000 '000, 1 >
using	exa = ratio< 1 '000 '000 '000 '000 '000 '000, 1 >

Enumerations
enum struct	align_val_t : etl::size_t
	Both new-expression and delete-expression, when used with objects whose alignment requirement is greater than the default, pass that alignment requirement as an argument of type align_val_t to the selected allocation/deallocation function. More...
enum struct	chars_format : etl::uint8_t { scientific = 0x1 , fixed = 0x2 , hex = 0x4 , general = fixed | scientific }
	A BitmaskType used to specify floating-point formatting for to_chars and from_chars. More...
enum struct	endian { little = __ORDER_LITTLE_ENDIAN__ , big = __ORDER_BIG_ENDIAN__ , native = __BYTE_ORDER__ }
	Indicates the endianness of all scalar types. If all scalar types are little-endian, endian::native equals endian::little. If all scalar types are big-endian, endian::native equals endian::big. More...
enum struct	errc : unsigned char {   address_family_not_supported = 1 , address_in_use , address_not_available , already_connected ,   argument_list_too_long , argument_out_of_domain , bad_address , bad_file_descriptor ,   bad_message , broken_pipe , connection_aborted , connection_already_in_progress ,   connection_refused , connection_reset , cross_device_link , destination_address_required ,   device_or_resource_busy , directory_not_empty , executable_format_error , file_exists ,   file_too_large , filename_too_long , function_not_supported , host_unreachable ,   identifier_removed , illegal_byte_sequence , inappropriate_io_control_operation , interrupted ,   invalid_argument , invalid_seek , io_error , is_a_directory ,   message_size , network_down , network_reset , network_unreachable ,   no_buffer_space , no_child_process , no_link , no_lock_available ,   no_message_available , no_message , no_protocol_option , no_space_on_device ,   no_stream_resources , no_such_device_or_address , no_such_device , no_such_file_or_directory ,   no_such_process , not_a_directory , not_a_socket , not_a_stream ,   not_connected , not_enough_memory , not_supported , operation_canceled ,   operation_in_progress , operation_not_permitted , operation_not_supported , operation_would_block ,   owner_dead , permission_denied , protocol_error , protocol_not_supported ,   read_only_file_system , resource_deadlock_would_occur , resource_unavailable_try_again , result_out_of_range ,   state_not_recoverable , stream_timeout , text_file_busy , timed_out ,   too_many_files_open_in_system , too_many_files_open , too_many_links , too_many_symbolic_link_levels ,   value_too_large , wrong_protocol_type }
	The scoped enumeration etl::errc defines the values of portable error conditions. More...
enum	float_denorm_style { denorm_indeterminate = -1 , denorm_absent = 0 , denorm_present = 1 }
enum	float_round_style {   round_indeterminate = -1 , round_toward_zero = 0 , round_to_nearest = 1 , round_toward_infinity = 2 ,   round_toward_neg_infinity = 3 }
enum struct	implementation { freestanding = 0 , hosted = 1 }
enum struct	language_standard : unsigned char { cpp_17 = 17 , cpp_20 = 20 , cpp_23 = 23 , cpp_26 = 26 }
	Enumeration for the currently selected C++ standard version. Unlike the official macro __cplusplus, these values only include the published year. This is to make the actual values smaller and therfore fit on smaller word sized chips. More...

Functions
template<typename T >
constexpr auto	abs (complex< T > const &z) -> T
constexpr auto	abs (double n) noexcept -> double
constexpr auto	abs (float n) noexcept -> float
constexpr auto	abs (int n) noexcept -> int
	Computes the absolute value of an integer number. The behavior is undefined if the result cannot be represented by the return type. If abs is called with an unsigned integral argument that cannot be converted to int by integral promotion, the program is ill-formed.
constexpr auto	abs (long double n) noexcept -> long double
constexpr auto	abs (long long n) noexcept -> long long
constexpr auto	abs (long n) noexcept -> long
template<typename Type >
constexpr auto	abs (Type input) noexcept -> Type
	Returns the absolute value.
template<typename InputIt , typename Type >
constexpr auto	accumulate (InputIt first, InputIt last, Type init) noexcept -> Type
	Computes the sum of the given value init and the elements in the range [first, last).
template<typename InputIt , typename Type , typename BinaryOperation >
constexpr auto	accumulate (InputIt first, InputIt last, Type init, BinaryOperation op) noexcept -> Type
	Computes the sum of the given value init and the elements in the range [first, last).
template<etl::builtin_integer Int>
constexpr auto	add_sat (Int x, Int y) noexcept -> Int
template<typename T > requires (is_object_v<T>)
constexpr auto	addressof (T &arg) noexcept -> T *
	Obtains the actual address of the object or function arg, even in presence of overloaded operator&.
template<typename T > requires (not is_object_v<T>)
constexpr auto	addressof (T &arg) noexcept -> T *
	Obtains the actual address of the object or function arg, even in presence of overloaded operator&.
template<typename T >
auto	addressof (T const &&)=delete
template<typename InputIt , typename OutputIt >
constexpr auto	adjacent_difference (InputIt first, InputIt last, OutputIt destination) -> OutputIt
template<typename InputIt , typename OutputIt , typename BinaryOperation >
constexpr auto	adjacent_difference (InputIt first, InputIt last, OutputIt destination, BinaryOperation op) -> OutputIt
	Computes the differences between the second and the first of each adjacent pair of elements of the range [first, last) and writes them to the range beginning at destination + 1. An unmodified copy of *first is written to *destination.
template<typename It , typename Distance >
constexpr auto	advance (It &it, Distance n) -> void
	Increments given iterator it by n elements.
auto	align (etl::size_t alignment, etl::size_t size, void *&ptr, etl::size_t &space) noexcept -> void *
	Given a pointer ptr to a buffer of size space, returns a pointer aligned by the specified alignment for size number of bytes and decreases space argument by the number of bytes used for alignment. The first aligned address is returned.
template<typename F , typename Tuple >
constexpr auto	apply (F &&f, Tuple &&t) -> decltype(auto)
template<typename T >
constexpr auto	arg (complex< T > const &z) noexcept -> T
template<floating_point Float>
constexpr auto	arg (Float f) noexcept -> complex< Float >
template<integral Integer>
constexpr auto	arg (Integer i) noexcept -> complex< double >
template<typename T >
constexpr auto	as_const (T &t) noexcept -> add_const_t< T > &
	Forms lvalue reference to const type of t.
template<typename T >
constexpr auto	as_const (T const &&) -> void=delete
template<typename Assertion >
auto	assert_handler (Assertion const &msg) -> void
template<etl::size_t N, typename T >
constexpr auto	assume_aligned (T *ptr) -> T *
	Informs the implementation that the object ptr points to is aligned to at least N. The implementation may use this information to generate more efficient code, but it might only make this assumption if the object is accessed via the return value of assume_aligned.
constexpr auto	atof (char const *str) noexcept -> double
	Interprets a floating point value in a byte string pointed to by str.
constexpr auto	atoi (char const *str) noexcept -> int
	Interprets an integer value in a byte string pointed to by str. Discards any whitespace characters until the first non-whitespace character is found, then takes as many characters as possible to form a valid integer number representation and converts them to an integer value.
constexpr auto	atol (char const *str) noexcept -> long
	Interprets an integer value in a byte string pointed to by str. Discards any whitespace characters until the first non-whitespace character is found, then takes as many characters as possible to form a valid integer number representation and converts them to an integer value.
constexpr auto	atoll (char const *str) noexcept -> long long
	Interprets an integer value in a byte string pointed to by str. Discards any whitespace characters until the first non-whitespace character is found, then takes as many characters as possible to form a valid integer number representation and converts them to an integer value.
template<typename Container >
constexpr auto	back_inserter (Container &container) -> back_insert_iterator< Container >
	back_inserter is a convenience function template that constructs a back_insert_iterator for the container c with the type deduced from the type of the argument.
template<typename C >
constexpr auto	begin (C &c) -> decltype(c.begin())
	Returns an iterator to the beginning of the given container c or array array. These templates rely on C::begin() having a reasonable implementation. Returns exactly c.begin(), which is typically an iterator to the beginning of the sequence represented by c. If C is a standard Container, this returns C::iterator when c is not const-qualified, and C::const_iterator otherwise. Custom overloads of begin may be provided for classes that do not expose a suitable begin() member function, yet can be iterated.
template<typename C >
constexpr auto	begin (C const &c) -> decltype(c.begin())
template<typename T , etl::size_t N>
constexpr auto	begin (T(&array)[N]) noexcept -> T *
template<typename Func , typename... BoundArgs>
constexpr auto	bind_front (Func &&func, BoundArgs &&... boundArgs)
	The function template bind_front generates a forwarding call wrapper for f. Calling this wrapper is equivalent to invoking f with its first sizeof...(Args) parameters bound to args. In other words, bind_front(f, bound_args...)(call_args...) is equivalent to invoke(f, bound_args..., call_args....).
template<typename To , typename From > requires detail::bitcastable<To, From>
constexpr auto	bit_cast (From const &src) noexcept -> To
	Obtain a value of type To by reinterpreting the object representation of from. Every bit in the value representation of the returned To object is equal to the corresponding bit in the object representation of from.
template<etl::builtin_unsigned_integer UInt>
constexpr auto	bit_ceil (UInt x) noexcept -> UInt
	Calculates the smallest integral power of two that is not smaller than x. If that value is not representable in UInt, the behavior is undefined. Call to this function is permitted in constant evaluation only if the undefined behavior does not occur.
template<etl::builtin_unsigned_integer UInt>
constexpr auto	bit_floor (UInt x) noexcept -> UInt
	If x is not zero, calculates the largest integral power of two that is not greater than x. If x is zero, returns zero.
template<etl::builtin_unsigned_integer UInt>
constexpr auto	bit_width (UInt x) noexcept -> int
	If x is not zero, calculates the number of bits needed to store the value x, that is, 1+⌊log2(x)⌋. If x is zero, returns zero.
auto	breakpoint () noexcept -> void
	Unconditional breakpoint: attempts to temporarily halt the execution of the program and transfer control to the debugger.
auto	breakpoint_if_debugging () noexcept -> void
	Conditional breakpoint: attempts to temporarily halt the execution of the program and transfer control to the debugger if it were able to determine that the debugger is present. Acts as a no-op otherwise.
template<integral Int>
constexpr auto	byteswap (Int val) noexcept -> Int
	Reverses the bytes in the given integer value n.
template<typename C >
constexpr auto	cbegin (C const &c) noexcept(noexcept(begin(c))) -> decltype(begin(c))
template<typename C >
constexpr auto	cend (C const &c) noexcept(noexcept(end(c))) -> decltype(end(c))
template<builtin_integer T, builtin_integer U>
constexpr auto	cmp_equal (T t, U u) noexcept -> bool
	Compare the values of two integers t and u. Unlike builtin comparison operators, negative signed integers always compare less than (and not equal to) unsigned integers: the comparison is safe against lossy integer conversion.
template<builtin_integer T, builtin_integer U>
constexpr auto	cmp_greater (T t, U u) noexcept -> bool
	Compare the values of two integers t and u. Unlike builtin comparison operators, negative signed integers always compare less than (and not equal to) unsigned integers: the comparison is safe against lossy integer conversion.
template<builtin_integer T, builtin_integer U>
constexpr auto	cmp_greater_equal (T t, U u) noexcept -> bool
	Compare the values of two integers t and u. Unlike builtin comparison operators, negative signed integers always compare less than (and not equal to) unsigned integers: the comparison is safe against lossy integer conversion.
template<builtin_integer T, builtin_integer U>
constexpr auto	cmp_less (T t, U u) noexcept -> bool
	Compare the values of two integers t and u. Unlike builtin comparison operators, negative signed integers always compare less than (and not equal to) unsigned integers: the comparison is safe against lossy integer conversion.
template<builtin_integer T, builtin_integer U>
constexpr auto	cmp_less_equal (T t, U u) noexcept -> bool
	Compare the values of two integers t and u. Unlike builtin comparison operators, negative signed integers always compare less than (and not equal to) unsigned integers: the comparison is safe against lossy integer conversion.
template<builtin_integer T, builtin_integer U>
constexpr auto	cmp_not_equal (T t, U u) noexcept -> bool
	Compare the values of two integers t and u. Unlike builtin comparison operators, negative signed integers always compare less than (and not equal to) unsigned integers: the comparison is safe against lossy integer conversion.
template<typename T >
constexpr auto	conj (complex< T > const &z) noexcept -> complex< T >
template<floating_point Float>
constexpr auto	conj (Float f) noexcept -> complex< Float >
template<integral Integer>
constexpr auto	conj (Integer i) noexcept -> complex< double >
template<typename T , typename... Args, typename = decltype(::new (etl::declval<void*>()) T(etl::declval<Args>()...))>
constexpr auto	construct_at (T *p, Args &&... args) -> T *
	Creates a T object initialized with arguments args... at given address p.
template<typename InputIt , typename OutputIt >
constexpr auto	copy (InputIt first, InputIt last, OutputIt destination) -> OutputIt
	Copies the elements in the range, defined by [first, last), to another range beginning at destination.
template<typename BidirIt1 , typename BidirIt2 >
constexpr auto	copy_backward (BidirIt1 first, BidirIt1 last, BidirIt2 dLast) -> BidirIt2
	Copies the elements from the range, defined by [first, last), to another range ending at dLast. The elements are copied in reverse order (the last element is copied first), but their relative order is preserved.
template<typename InIt , typename OutIt , typename Pred >
constexpr auto	copy_if (InIt first, InIt last, OutIt dFirst, Pred pred) -> OutIt
	Copies the elements in the range, defined by [first, last), to another range beginning at destination.
template<typename InputIt , typename Size , typename OutputIt >
constexpr auto	copy_n (InputIt first, Size count, OutputIt result) -> OutputIt
	Copies exactly count values from the range beginning at first to the range beginning at result. Formally, for each integer 0 <= i < count, performs *(result + i) = *(first + i). Overlap of ranges is formally permitted, but leads to unpredictable ordering of the results.
template<typename T >
constexpr auto	cos (complex< T > const &z) -> complex< T >
template<typename T >
constexpr auto	cosh (complex< T > const &z) -> complex< T >
template<typename InputIt , typename T >
constexpr auto	count (InputIt first, InputIt last, T const &value) -> typename iterator_traits< InputIt >::difference_type
	Returns the number of elements in the range [first, last) satisfying specific criteria. Counts the elements that are equal to value.
template<typename InputIt , typename Predicate >
constexpr auto	count_if (InputIt first, InputIt last, Predicate p) -> typename iterator_traits< InputIt >::difference_type
	Returns the number of elements in the range [first, last) satisfying specific criteria. Counts elements for which predicate p returns true.
template<etl::builtin_unsigned_integer UInt>
constexpr auto	countl_one (UInt x) noexcept -> int
	Returns the number of consecutive 1 ("one") bits in the value of x, starting from the most significant bit ("left").
template<etl::builtin_unsigned_integer UInt>
constexpr auto	countl_zero (UInt x) noexcept -> int
	Returns the number of consecutive 0 bits in the value of x, starting from the most significant bit ("left").
template<etl::builtin_unsigned_integer UInt>
constexpr auto	countr_one (UInt x) noexcept -> int
	Returns the number of consecutive 1 bits in the value of x, starting from the least significant bit ("right").
template<etl::builtin_unsigned_integer UInt>
constexpr auto	countr_zero (UInt x) noexcept -> int
	Returns the number of consecutive 0 bits in the value of x, starting from the least significant bit ("right").
template<typename Container >
constexpr auto	crbegin (Container const &c) -> decltype(rbegin(c))
template<typename T >
constexpr auto	cref (reference_wrapper< T > t) noexcept -> reference_wrapper< T const >
template<typename T >
void	cref (T const &&)=delete
template<typename T >
constexpr auto	cref (T const &t) noexcept -> reference_wrapper< T const >
	Function templates ref and cref are helper functions that generate an object of type reference_wrapper, using template argument deduction to determine the template argument of the result. module Utility.
template<typename Container >
constexpr auto	crend (Container const &c) -> decltype(rend(c))
	Returns an iterator to the reverse-end of the given container.
template<typename C >
constexpr auto	data (C &c) noexcept(noexcept(c.data())) -> decltype(c.data())
	Returns a pointer to the block of memory containing the elements of the container.
template<typename C >
constexpr auto	data (C const &c) noexcept(noexcept(c.data())) -> decltype(c.data())
template<typename T , size_t N>
constexpr auto	data (T(&array)[N]) noexcept -> T *
template<typename T >
constexpr auto	decay_copy (T &&t) noexcept(is_nothrow_convertible_v< T, decay_t< T > >) -> decay_t< T >
template<typename T >
auto	declval () noexcept -> add_rvalue_reference_t< T >
template<typename ForwardIt >
constexpr auto	destroy (ForwardIt first, ForwardIt last) -> void
	Destroys the objects in the range [first, last).
template<typename T >
constexpr auto	destroy_at (T *p) -> void
	If T is not an array type, calls the destructor of the object pointed to by p, as if by p->~T(). If T is an array type, recursively destroys elements of *p in order, as if by calling destroy(begin(*p), end(*p)).
template<typename ForwardIt , typename Size >
constexpr auto	destroy_n (ForwardIt first, Size n) -> ForwardIt
	Destroys the n objects in the range starting at first.
template<typename It >
constexpr auto	distance (It first, It last) -> typename iterator_traits< It >::difference_type
	Returns the number of hops from first to last.
constexpr auto	div (int x, int y) noexcept -> div_t
	Computes both the quotient and the remainder of the division of the numerator x by the denominator y. The quotient is the result of the expression x/y. The remainder is the result of the expression xy.
constexpr auto	div (long long x, long long y) noexcept -> lldiv_t
	Computes both the quotient and the remainder of the division of the numerator x by the denominator y. The quotient is the result of the expression x/y. The remainder is the result of the expression xy.
constexpr auto	div (long x, long y) noexcept -> ldiv_t
	Computes both the quotient and the remainder of the division of the numerator x by the denominator y. The quotient is the result of the expression x/y. The remainder is the result of the expression xy.
template<builtin_integer Int>
constexpr auto	div_sat (Int x, Int y) noexcept -> Int
	Computes the saturating division x / y.
template<typename C >
constexpr auto	empty (C const &c) noexcept(noexcept(c.empty())) -> decltype(c.empty())
	Returns whether the given container is empty.
template<typename T , size_t N>
constexpr auto	empty (T(&array)[N]) noexcept -> bool
	Returns whether the given container is empty.
template<typename C >
constexpr auto	end (C &c) -> decltype(c.end())
	Returns an iterator to the end (i.e. the element after the last element) of the given container c or array array. These templates rely on.
template<typename C >
constexpr auto	end (C const &c) -> decltype(c.end())
template<typename T , etl::size_t N>
constexpr auto	end (T(&array)[N]) noexcept -> T *
template<typename InputIt1 , typename InputIt2 >
constexpr auto	equal (InputIt1 first1, InputIt1 last1, InputIt2 first2) -> bool
template<typename InputIt1 , typename InputIt2 >
constexpr auto	equal (InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2) -> bool
template<typename InputIt1 , typename InputIt2 , typename Predicate >
constexpr auto	equal (InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, Predicate p) -> bool
template<typename InputIt1 , typename InputIt2 , typename Predicate >
constexpr auto	equal (InputIt1 first1, InputIt1 last1, InputIt2 first2, Predicate p) -> bool
	Returns true if the range [first1, last1) is equal to the range [first2, first2 + (last1 - first1)), and false otherwise.
template<typename ForwardIt , typename T >
constexpr auto	equal_range (ForwardIt first, ForwardIt last, T const &value) -> pair< ForwardIt, ForwardIt >
template<typename ForwardIt , typename T , typename Compare >
constexpr auto	equal_range (ForwardIt first, ForwardIt last, T const &value, Compare comp) -> pair< ForwardIt, ForwardIt >
	Returns a range containing all elements equivalent to value in the range [first, last).
template<typename Char , typename Traits , etl::size_t Capacity, typename U >
constexpr auto	erase (basic_inplace_string< Char, Capacity, Traits > &c, U const &value) noexcept -> typename basic_inplace_string< Char, Capacity, Traits >::size_type
	Erases all elements that compare equal to value from the container.
template<typename T , size_t Capacity, typename U >
constexpr auto	erase (static_vector< T, Capacity > &c, U const &value) -> typename static_vector< T, Capacity >::size_type
template<typename Char , typename Traits , etl::size_t Capacity, typename Predicate >
constexpr auto	erase_if (basic_inplace_string< Char, Capacity, Traits > &c, Predicate pred) noexcept -> typename basic_inplace_string< Char, Capacity, Traits >::size_type
	Erases all elements that satisfy the predicate pred from the container.
template<typename Key , typename Container , typename Compare , typename Pred >
constexpr auto	erase_if (etl::flat_set< Key, Container, Compare > &c, Pred pred) -> typename etl::flat_set< Key, Container, Compare >::size_type
template<typename T , size_t Capacity, typename Predicate >
constexpr auto	erase_if (static_vector< T, Capacity > &c, Predicate pred) -> typename static_vector< T, Capacity >::size_type
	Erases all elements that satisfy the predicate pred from the container.
template<typename T , typename U = T>
constexpr auto	exchange (T &obj, U &&newValue) noexcept(etl::is_nothrow_move_constructible_v< T > and etl::is_nothrow_assignable_v< T &, U >) -> T
	Replaces the value of obj with new_value and returns the old value of obj.
template<typename RandomIt >
constexpr auto	exchange_sort (RandomIt first, RandomIt last) -> void
	Sorts the elements in the range [first, last) in non-descending order.
template<typename RandomIt , typename Compare >
constexpr auto	exchange_sort (RandomIt first, RandomIt last, Compare comp) -> void
	Sorts the elements in the range [first, last) in non-descending order.
template<typename... Integrals> requires (etl::is_convertible_v<Integrals, etl::size_t> and ...)
	extents (Integrals...) -> extents< etl::size_t, etl::size_t((Integrals(), etl::dynamic_extent))... >
constexpr auto	fabs (double n) noexcept -> double
constexpr auto	fabs (float n) noexcept -> float
constexpr auto	fabs (long double n) noexcept -> long double
constexpr auto	fabsf (float n) noexcept -> float
constexpr auto	fabsl (long double n) noexcept -> long double
template<typename ForwardIt , typename T >
constexpr auto	fill (ForwardIt first, ForwardIt last, T const &value) -> void
	Assigns the given value to the elements in the range [first, last).
template<typename OutputIt , typename Size , typename T >
constexpr auto	fill_n (OutputIt first, Size count, T const &value) -> OutputIt
	Assigns the given value to the first count elements in the range beginning at first if count > 0. Does nothing otherwise.
template<typename InputIt , typename T >
constexpr auto	find (InputIt first, InputIt last, T const &value) noexcept -> InputIt
	Searches for an element equal to value.
template<typename ForwardIt1 , typename ForwardIt2 >
constexpr auto	find_end (ForwardIt1 first, ForwardIt1 last, ForwardIt2 sFirst, ForwardIt2 sLast) -> ForwardIt1
template<typename ForwardIt1 , typename ForwardIt2 , typename Predicate >
constexpr auto	find_end (ForwardIt1 first, ForwardIt1 last, ForwardIt2 sFirst, ForwardIt2 sLast, Predicate p) -> ForwardIt1
	Searches for the last occurrence of the sequence [sFirst, sLast) in the range [first, last). Elements are compared using the given binary predicate p.
template<typename InputIt , typename ForwardIt >
constexpr auto	find_first_of (InputIt first, InputIt last, ForwardIt sFirst, ForwardIt sLast) -> InputIt
	Searches the range [first, last) for any of the elements in the range [sFirst, sLast).
template<typename InputIt , typename ForwardIt , typename Predicate >
constexpr auto	find_first_of (InputIt first, InputIt last, ForwardIt sFirst, ForwardIt sLast, Predicate pred) -> InputIt
	Searches the range [first, last) for any of the elements in the range [sFirst, sLast). Elements are compared using the given binary predicate pred.
template<typename InputIt , typename Predicate >
constexpr auto	find_if (InputIt first, InputIt last, Predicate pred) noexcept -> InputIt
	Searches for an element for which predicate p returns true.
template<typename InputIt , typename Predicate >
constexpr auto	find_if_not (InputIt first, InputIt last, Predicate pred) noexcept -> InputIt
	Searches for an element for which predicate q returns false.
template<etl::size_t Pos, etl::builtin_unsigned_integer UInt>
constexpr auto	flip_bit (UInt word) noexcept -> UInt
	Flip bit at position Pos.
template<etl::builtin_unsigned_integer UInt>
constexpr auto	flip_bit (UInt word, UInt pos) noexcept -> UInt
	Flip bit at position pos.
template<typename InputIt , typename UnaryFunc >
constexpr auto	for_each (InputIt first, InputIt last, UnaryFunc f) noexcept -> UnaryFunc
	Applies the given function object f to the result of dereferencing every iterator in the range [first, last) in order.
template<typename InputIt , typename Size , typename UnaryFunc >
constexpr auto	for_each_n (InputIt first, Size n, UnaryFunc f) noexcept -> InputIt
	Applies the given function object f to the result of dereferencing every iterator in the range [first, first + n] in order.
template<typename OutputIt , typename... Args>
auto	format_to (OutputIt out, etl::string_view fmt, Args const &... args) -> OutputIt
	Format args according to the format string fmt, and write the result to the output iterator out.
template<typename OutputIter , typename... Args>
auto	format_to_n (OutputIter out, diff_t< OutputIter > n, etl::string_view fmt, Args const &... args) -> format_to_n_result< OutputIter >
	Format args according to the format string fmt, and write the result to the output iterator out. At most n characters are written.
template<typename T >
constexpr auto	forward (remove_reference_t< T > &&param) noexcept -> T &&
template<typename T >
constexpr auto	forward (remove_reference_t< T > &param) noexcept -> T &&
	Forwards lvalues as either lvalues or as rvalues, depending on T. When t is a forwarding reference (a function argument that is declared as an rvalue reference to a cv-unqualified function template parameter), this overload forwards the argument to another function with the value category it had when passed to the calling function.
template<typename... Args>
constexpr auto	forward_as_tuple (Args &&... args) noexcept -> etl::tuple< Args &&... >
	Constructs a tuple of references to the arguments in args suitable for forwarding as an argument to a function. The tuple has rvalue reference data members when rvalues are used as arguments, and otherwise has lvalue reference data members.
template<typename T , typename U >
constexpr auto	forward_like (U &&x) noexcept -> auto &&
template<integral Int> requires (not same_as<Int, bool>)
constexpr auto	from_chars (char const *first, char const *last, Int &value, int base=10) -> from_chars_result
	Analyzes the character sequence [first,last) for a pattern described below. If no characters match the pattern or if the value obtained by parsing the matched characters is not representable in the type of value, value is unmodified, otherwise the characters matching the pattern are interpreted as a text representation of an arithmetic value, which is stored in value.
template<typename Container >
constexpr auto	front_inserter (Container &c) -> front_insert_iterator< Container >
	front_inserter is a convenience function template that constructs a front_insert_iterator for the container c with the type deduced from the type of the argument.
template<typename C >
constexpr auto	full (C const &c) noexcept(noexcept(c.full())) -> decltype(c.full())
	Returns whether the given container is full.
template<typename T , size_t N>
constexpr auto	full (T(&array)[N]) noexcept -> bool
template<typename R , typename... Args>
	function_ref (R(*)(Args...)) -> function_ref< R(Args...)>
template<typename M , typename N >
constexpr auto	gcd (M m, N n) noexcept -> etl::common_type_t< M, N >
	Computes the greatest common divisor of the integers m and n.
template<typename ForwardIt , typename Generator >
constexpr auto	generate (ForwardIt first, ForwardIt last, Generator g) -> void
	Assigns each element in range [first, last) a value generated by the given function object g.
template<typename Real , size_t Bits, typename RNG >
constexpr auto	generate_canonical (RNG &g) noexcept(noexcept(g())) -> Real
	Generates a random floating point number in range [0,1).
template<typename OutputIt , typename SizeT , typename Generator >
constexpr auto	generate_n (OutputIt first, SizeT count, Generator g) -> OutputIt
	Assigns values, generated by given function object g, to the first count elements in the range beginning at first, if count > 0. Does nothing otherwise.
template<size_t I, typename X >
constexpr auto	get (complex< X > &&z) noexcept -> X &&
template<size_t I, typename X >
constexpr auto	get (complex< X > &z) noexcept -> X &
template<size_t I, typename X >
constexpr auto	get (complex< X > const &&z) noexcept -> X const &&
template<size_t I, typename X >
constexpr auto	get (complex< X > const &z) noexcept -> X const &
template<size_t I, typename T1 , typename T2 >
constexpr auto	get (pair< T1, T2 > &&p) noexcept -> tuple_element_t< I, pair< T1, T2 > > &&
	Extracts an element from the pair using tuple-like interface.
template<size_t I, typename T1 , typename T2 >
constexpr auto	get (pair< T1, T2 > &p) noexcept -> tuple_element_t< I, pair< T1, T2 > > &
	Extracts an element from the pair using tuple-like interface.
template<size_t I, typename T1 , typename T2 >
constexpr auto	get (pair< T1, T2 > const &&p) noexcept -> tuple_element_t< I, pair< T1, T2 > > const &&
	Extracts an element from the pair using tuple-like interface.
template<size_t I, typename T1 , typename T2 >
constexpr auto	get (pair< T1, T2 > const &p) noexcept -> tuple_element_t< I, pair< T1, T2 > > const &
	Extracts an element from the pair using tuple-like interface.
template<etl::size_t I, typename... Ts>
constexpr auto	get (tuple< Ts... > &&t) -> auto &&
template<etl::size_t I, typename... Ts>
constexpr auto	get (tuple< Ts... > &t) -> auto &
template<etl::size_t I, typename... Ts>
constexpr auto	get (tuple< Ts... > const &&t) -> auto const &&
template<etl::size_t I, typename... Ts>
constexpr auto	get (tuple< Ts... > const &t) -> auto const &
template<typename T , typename... Types>
constexpr auto	get_if (variant< Types... > *pv) noexcept -> add_pointer_t< T >
template<typename T , typename... Types>
constexpr auto	get_if (variant< Types... > const *pv) noexcept -> add_pointer_t< T const >
template<typename BidirIt >
constexpr auto	gnome_sort (BidirIt first, BidirIt last) -> void
	Sorts the elements in the range [first, last) in non-descending order.
template<typename BidirIt , typename Compare >
constexpr auto	gnome_sort (BidirIt first, BidirIt last, Compare comp) -> void
	Sorts the elements in the range [first, last) in non-descending order.
template<etl::builtin_unsigned_integer UInt>
constexpr auto	has_single_bit (UInt x) noexcept -> bool
	Checks if x is an integral power of two.
template<integral Int>
constexpr auto	idiv (Int x, Int y) noexcept -> idiv_result< Int >
template<typename... Types>
constexpr auto	ignore_unused (Types &&...) -> void
	Explicitly ignore arguments or variables.
template<integral Int>
constexpr auto	ilog2 (Int x) noexcept -> Int
template<typename T >
constexpr auto	imag (complex< T > const &z) noexcept(noexcept(z.imag())) -> T
template<floating_point Float>
constexpr auto	imag (Float) noexcept -> Float
template<integral Integer>
constexpr auto	imag (Integer) noexcept -> double
constexpr auto	imaxdiv (intmax_t x, intmax_t y) noexcept -> imaxdiv_t
	Computes both the quotient and the remainder of the division of the numerator x by the denominator y. The quotient is the result of the expression x/y. The remainder is the result of the expression xy.
template<builtin_integer R, builtin_integer T>
constexpr auto	in_range (T t) noexcept -> bool
	Returns true if the value of t is in the range of values that can be represented in R, that is, if t can be converted to R without data loss.
template<typename InputIt1 , typename InputIt2 >
constexpr auto	includes (InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2) -> bool
template<typename InputIt1 , typename InputIt2 , typename Compare >
constexpr auto	includes (InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, Compare comp) -> bool
	Returns true if the sorted range [first2, last2) is a subsequence of the sorted range [first1, last1). Both ranges must be sorted.
template<typename InputIt1 , typename InputIt2 , typename T >
constexpr auto	inner_product (InputIt1 first1, InputIt1 last1, InputIt2 first2, T init) -> T
	Computes inner product (i.e. sum of products) or performs ordered map/reduce operation on the range [first1, last1) and the range beginning at first2.
template<typename InputIt1 , typename InputIt2 , typename T , typename BinaryOperation1 , typename BinaryOperation2 >
constexpr auto	inner_product (InputIt1 first1, InputIt1 last1, InputIt2 first2, T init, BinaryOperation1 op1, BinaryOperation2 op2) -> T
template<typename BidirIt , typename Compare >
constexpr auto	inplace_merge (BidirIt begin, BidirIt mid, BidirIt end, Compare comp) -> void
	Merges two consecutive sorted ranges [first, middle) and [middle, last) into one sorted range [first, last).
template<typename BidirIt >
constexpr auto	inplace_merge (BidirIt first, BidirIt mid, BidirIt last) -> void
template<typename RandomIt >
constexpr auto	insertion_sort (RandomIt first, RandomIt last) -> void
template<typename RandomIt , typename Compare >
constexpr auto	insertion_sort (RandomIt first, RandomIt last, Compare comp) -> void
	Sorts the elements in the range [first, last) in non-descending order. The order of equal elements is guaranteed to be preserved.
template<typename F , typename... Args>
constexpr auto	invoke (F &&f, Args &&... args) -> invoke_result_t< F, Args... >
template<typename R , typename F , typename... Args> requires (etl::is_invocable_r_v<R, F, Args...>)
constexpr auto	invoke_r (F &&f, Args &&... args) -> R
template<typename ForwardIt , typename T >
constexpr auto	iota (ForwardIt first, ForwardIt last, T value) -> void
	Fills the range [first, last) with sequentially increasing values, starting with value and repetitively evaluating ++value.
template<auto Base>
constexpr auto	ipow (decltype(Base) exponent) noexcept -> decltype(Base)
template<integral Int>
constexpr auto	ipow (Int base, Int exponent) noexcept -> Int
constexpr auto	is_constant_evaluated () noexcept -> bool
	Detects whether the function call occurs within a constant-evaluated context. Returns true if the evaluation of the call occurs within the evaluation of an expression or conversion that is manifestly constant-evaluated; otherwise returns false.
auto	is_debugger_present () noexcept -> bool
	Attempts to determine if the program is being executed with debugger present.
constexpr auto	is_eq (partial_ordering cmp) noexcept -> bool
consteval auto	is_freestanding () noexcept -> bool
constexpr auto	is_gt (partial_ordering cmp) noexcept -> bool
constexpr auto	is_gteq (partial_ordering cmp) noexcept -> bool
consteval auto	is_hosted () noexcept -> bool
constexpr auto	is_lt (partial_ordering cmp) noexcept -> bool
constexpr auto	is_lteq (partial_ordering cmp) noexcept -> bool
constexpr auto	is_neq (partial_ordering cmp) noexcept -> bool
template<typename InputIt , typename Predicate >
constexpr auto	is_partitioned (InputIt first, InputIt last, Predicate p) -> bool
	Returns true if all elements in the range [first, last) that satisfy the predicate p appear before all elements that don't. Also returns true if the range is empty.
template<typename ForwardIt1 , typename ForwardIt2 >
constexpr auto	is_permutation (ForwardIt1 first, ForwardIt1 last, ForwardIt2 first2) -> bool
	Returns true if there exists a permutation of the elements in the range [first1, last1) that makes that range equal to the range [first2, last2), where last2 denotes first2 + (last1 - first1) if it was not given.
template<typename ForwardIt1 , typename ForwardIt2 >
constexpr auto	is_permutation (ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2, ForwardIt2 last2) -> bool
template<typename ForwardIt >
constexpr auto	is_sorted (ForwardIt first, ForwardIt last) -> bool
	Checks if the elements in range [first, last) are sorted in non-descending order.
template<typename ForwardIt , typename Compare >
constexpr auto	is_sorted (ForwardIt first, ForwardIt last, Compare comp) -> bool
template<typename ForwardIt >
constexpr auto	is_sorted_until (ForwardIt first, ForwardIt last) -> ForwardIt
	Examines the range [first, last) and finds the largest range beginning at first in which the elements are sorted in non-descending order.
template<typename ForwardIt , typename Compare >
constexpr auto	is_sorted_until (ForwardIt first, ForwardIt last, Compare comp) -> ForwardIt
constexpr auto	isalnum (int ch) noexcept -> int
	Checks if the given character is an alphanumeric character as classified by the default C locale.
constexpr auto	isalpha (int ch) noexcept -> int
	Checks if the given character is an alphabetic character as classified by the default C locale.
constexpr auto	isblank (int ch) noexcept -> int
	Checks if the given character is a blank character as classified by the currently installed C locale. Blank characters are whitespace characters used to separate words within a sentence. In the default C locale, only space (0x20) and horizontal tab (0x09) are classified as blank characters.
constexpr auto	iscntrl (int ch) noexcept -> int
	Checks if the given character is a control character as classified by the currently installed C locale. In the default, "C" locale, the control characters are the characters with the codes 0x00-0x1F and 0x7F.
constexpr auto	isdigit (int ch) noexcept -> int
	Checks if the given character is one of the 10 decimal digits: 0123456789.
constexpr auto	isfinite (double arg) -> bool
constexpr auto	isfinite (float arg) -> bool
	Determines if the given floating point number arg has finite value i.e. it is normal, subnormal or zero, but not infinite or NaN.
constexpr auto	isfinite (half arg) noexcept -> bool
constexpr auto	isfinite (long double arg) -> bool
constexpr auto	isgraph (int ch) noexcept -> int
	Checks if the given character is graphic (has a graphical representation) as classified by the default C locale.
constexpr auto	isinf (double arg) -> bool
constexpr auto	isinf (float arg) -> bool
	Determines if the given floating point number arg is a positive or negative infinity.
constexpr auto	isinf (half arg) noexcept -> bool
template<etl::integral Int>
constexpr auto	isinf (Int arg) -> bool
constexpr auto	isinf (long double arg) -> bool
constexpr auto	islower (int ch) noexcept -> int
	Checks if the given character is classified as a lowercase character according to the default C locale.
constexpr auto	isnan (double arg) -> bool
constexpr auto	isnan (float arg) -> bool
	Determines if the given floating point number arg is a not-a-number (NaN) value.
constexpr auto	isnan (half arg) noexcept -> bool
template<integral Int>
constexpr auto	isnan (Int arg) -> bool
	Determines if the given floating point number arg is a not-a-number (NaN) value.
constexpr auto	isnan (long double arg) -> bool
constexpr auto	isnormal (half arg) noexcept -> bool
constexpr auto	isprint (int ch) noexcept -> int
	Checks if ch is a printable character as classified by the default C locale.
constexpr auto	ispunct (int ch) noexcept -> int
	Checks if the given character is a punctuation character as classified by the current C locale.
constexpr auto	isspace (int ch) noexcept -> int
	Checks if the given character is whitespace character as classified by the default C locale.
constexpr auto	isupper (int ch) noexcept -> int
	Checks if the given character is classified as a uppercase character according to the default C locale.
constexpr auto	iswalnum (wint_t ch) noexcept -> int
	Checks if the given wide character is an alphanumeric character, i.e. either a number (0123456789), an uppercase letter (ABCDEFGHIJKLMNOPQRSTUVWXYZ), a lowercase letter (abcdefghijklmnopqrstuvwxyz) or any alphanumeric character specific to the current locale.
constexpr auto	iswalpha (wint_t ch) noexcept -> int
	Checks if the given wide character is an alphabetic character, i.e. either an uppercase letter (ABCDEFGHIJKLMNOPQRSTUVWXYZ), a lowercase letter (abcdefghijklmnopqrstuvwxyz) or any alphabetic character specific to the current locale.
constexpr auto	iswblank (wint_t ch) noexcept -> int
	Checks if the given wide character is classified as blank character (that is, a whitespace character used to separate words in a sentence) by the current C locale. In the default C locale, only space (0x20) and horizontal tab (0x09) are blank characters.
constexpr auto	iswcntrl (wint_t ch) noexcept -> int
	Checks if the given wide character is a control character, i.e. codes 0x00-0x1F and 0x7F and any control characters specific to the current locale.
constexpr auto	iswdigit (wint_t ch) noexcept -> int
	Checks if the given wide character corresponds (if narrowed) to one of the ten decimal digit characters 0123456789.
constexpr auto	iswgraph (wint_t ch) noexcept -> int
	Checks if the given wide character has a graphical representation, i.e. it is either a number (0123456789), an uppercase letter (ABCDEFGHIJKLMNOPQRSTUVWXYZ), a lowercase letter (abcdefghijklmnopqrstuvwxyz), a punctuation character(!"#$%&'()*+,-./:;<=>?@[]^_`{|}~) or any graphical character specific to the current C locale.
constexpr auto	iswlower (wint_t ch) noexcept -> int
	Checks if the given wide character is a lowercase letter, i.e. one of abcdefghijklmnopqrstuvwxyz or any lowercase letter specific to the current locale.
constexpr auto	iswprint (wint_t ch) noexcept -> int
	Checks if the given wide character can be printed, i.e. it is either a number (0123456789), an uppercase letter (ABCDEFGHIJKLMNOPQRSTUVWXYZ), a lowercase letter (abcdefghijklmnopqrstuvwxyz), a punctuation character(!"#$%&'()*+,-./:;<=>?@[]^_`{|}~), space or any printable character specific to the current C locale.
constexpr auto	iswpunct (wint_t ch) noexcept -> int
	Checks if the given wide character is a punctuation character, i.e. it is one of !"#$%&'()*+,-./:;<=>?@[]^_`{|}~ or any punctuation character specific to the current locale.
constexpr auto	iswspace (wint_t ch) noexcept -> int
	Checks if the given wide character is a wide whitespace character as classified by the currently installed C locale.
constexpr auto	iswupper (wint_t ch) noexcept -> int
	Checks if the given wide character is an uppercase letter, i.e. one of ABCDEFGHIJKLMNOPQRSTUVWXYZ or any uppercase letter specific to the current locale.
constexpr auto	iswxdigit (wint_t ch) noexcept -> int
	Checks if the given wide character corresponds (if narrowed) to a hexadecimal numeric character, i.e. one of 0123456789abcdefABCDEF.
constexpr auto	isxdigit (int ch) noexcept -> int
	Checks if the given character is a hexadecimal numeric character (0123456789abcdefABCDEF).
template<typename ForwardIt1 , typename ForwardIt2 >
constexpr auto	iter_swap (ForwardIt1 a, ForwardIt2 b) -> void
	Swaps the values of the elements the given iterators are pointing to.
constexpr auto	labs (long n) noexcept -> long
	Computes the absolute value of an integer number. The behavior is undefined if the result cannot be represented by the return type. If abs is called with an unsigned integral argument that cannot be converted to int by integral promotion, the program is ill-formed.
template<typename M , typename N > requires (is_integral_v<M> and not is_same_v<M, bool> and is_integral_v<N> and not is_same_v<N, bool>)
constexpr auto	lcm (M m, N n) -> common_type_t< M, N >
	Computes the least common multiple of the integers m and n.
constexpr auto	ldiv (long x, long y) noexcept -> ldiv_t
	Computes both the quotient and the remainder of the division of the numerator x by the denominator y. The quotient is the result of the expression x/y. The remainder is the result of the expression xy.
template<floating_point Float>
constexpr auto	lerp (Float a, Float b, Float t) noexcept -> Float
	Computes a+t(b−a), i.e. the linear interpolation between a and b for the parameter t (or extrapolation, when t is outside the range [0,1]).
template<typename InputIt1 , typename InputIt2 >
constexpr auto	lexicographical_compare (InputIt1 f1, InputIt1 l1, InputIt2 f2, InputIt2 l2) -> bool
template<typename InputIt1 , typename InputIt2 , typename Compare >
constexpr auto	lexicographical_compare (InputIt1 f1, InputIt1 l1, InputIt2 f2, InputIt2 l2, Compare comp) -> bool
	Checks if the first range [f1, l1) is lexicographically less than the second range [f2, l2).
constexpr auto	lgamma (double arg) noexcept -> double
	Computes the natural logarithm of the absolute value of the gamma function of arg.
constexpr auto	lgamma (float arg) noexcept -> float
	Computes the natural logarithm of the absolute value of the gamma function of arg.
constexpr auto	lgamma (long double arg) noexcept -> long double
	Computes the natural logarithm of the absolute value of the gamma function of arg.
template<integral T>
constexpr auto	lgamma (T arg) noexcept -> double
	Computes the natural logarithm of the absolute value of the gamma function of arg.
constexpr auto	lgammaf (float arg) noexcept -> float
	Computes the natural logarithm of the absolute value of the gamma function of arg.
constexpr auto	lgammal (long double arg) noexcept -> long double
	Computes the natural logarithm of the absolute value of the gamma function of arg.
constexpr auto	llabs (long long n) noexcept -> long long
	Computes the absolute value of an integer number. The behavior is undefined if the result cannot be represented by the return type. If abs is called with an unsigned integral argument that cannot be converted to int by integral promotion, the program is ill-formed.
constexpr auto	lldiv (long long x, long long y) noexcept -> lldiv_t
	Computes both the quotient and the remainder of the division of the numerator x by the denominator y. The quotient is the result of the expression x/y. The remainder is the result of the expression xy.
constexpr auto	llrint (double arg) noexcept -> long long
	Rounds the floating-point argument arg to an integer value, using the current rounding mode.
constexpr auto	llrint (float arg) noexcept -> long long
	Rounds the floating-point argument arg to an integer value, using the current rounding mode.
constexpr auto	llrint (long double arg) noexcept -> long long
	Rounds the floating-point argument arg to an integer value, using the current rounding mode.
template<integral T>
constexpr auto	llrint (T arg) noexcept -> long long
	Rounds the floating-point argument arg to an integer value, using the current rounding mode.
constexpr auto	llrintf (float arg) noexcept -> long long
	Rounds the floating-point argument arg to an integer value, using the current rounding mode.
constexpr auto	llrintl (long double arg) noexcept -> long long
	Rounds the floating-point argument arg to an integer value, using the current rounding mode.
template<typename T >
constexpr auto	log (complex< T > const &z) noexcept -> complex< T >
template<typename T >
constexpr auto	log10 (complex< T > const &z) noexcept -> complex< T >
template<typename ForwardIt , typename T >
constexpr auto	lower_bound (ForwardIt first, ForwardIt last, T const &value) noexcept -> ForwardIt
template<typename ForwardIt , typename T , typename Compare >
constexpr auto	lower_bound (ForwardIt first, ForwardIt last, T const &value, Compare comp) noexcept -> ForwardIt
	Returns an iterator pointing to the first element in the range [first, last) that is not less than (i.e. greater or equal to) value, or last if no such element is found.
constexpr auto	lrint (double arg) noexcept -> long
	Rounds the floating-point argument arg to an integer value, using the current rounding mode.
constexpr auto	lrint (float arg) noexcept -> long
	Rounds the floating-point argument arg to an integer value, using the current rounding mode.
constexpr auto	lrint (long double arg) noexcept -> long
	Rounds the floating-point argument arg to an integer value, using the current rounding mode.
template<integral T>
constexpr auto	lrint (T arg) noexcept -> long
	Rounds the floating-point argument arg to an integer value, using the current rounding mode.
constexpr auto	lrintf (float arg) noexcept -> long
	Rounds the floating-point argument arg to an integer value, using the current rounding mode.
constexpr auto	lrintl (long double arg) noexcept -> long
	Rounds the floating-point argument arg to an integer value, using the current rounding mode.
template<typename Context = etl::format_context, typename... Args>
auto	make_format_args (Args &&... args) -> detail::format_arg_store< Context, Args... >
template<typename T , typename Tuple >
constexpr auto	make_from_tuple (Tuple &&t) -> T
template<typename T1 , typename T2 >
constexpr auto	make_pair (T1 &&t, T2 &&u) -> pair< decay_t< T1 >, decay_t< T2 > >
	Creates a etl::pair object, deducing the target type from the types of arguments.
template<typename Iter >
constexpr auto	make_reverse_iterator (Iter i) noexcept -> etl::reverse_iterator< Iter >
	Convenience function template that constructs a etl::reverse_iterator for the given iterator i (which must be a LegacyBidirectionalIterator) with the type deduced from the type of the argument.
template<typename... Args>
constexpr auto	make_tuple (Args &&... args)
	Creates a tuple object, deducing the target type from the types of arguments.
template<typename... Args>
auto	make_wformat_args (Args &&... args) -> detail::format_arg_store< wformat_context, Args... >
template<typename Type >
constexpr auto	max (Type const &a, Type const &b) noexcept -> Type const &
	Returns the greater of a and b.
template<typename Type , typename Compare >
constexpr auto	max (Type const &a, Type const &b, Compare comp) noexcept -> Type const &
	Returns the greater of a and b, using a compare function.
template<typename ForwardIt >
constexpr auto	max_element (ForwardIt first, ForwardIt last) noexcept -> ForwardIt
	Finds the greatest element in the range [first, last). Elements are compared using operator<.
template<typename ForwardIt , typename Compare >
constexpr auto	max_element (ForwardIt first, ForwardIt last, Compare comp) -> ForwardIt
	Finds the greatest element in the range [first, last). Elements are compared using the given binary comparison function comp.
template<typename CArray > requires (is_array_v<CArray> && rank_v<CArray> == 1)
	mdspan (CArray &) -> mdspan< remove_all_extents_t< CArray >, extents< size_t, extent_v< CArray, 0 > > >
template<typename ElementType , typename IndexType , size_t... ExtentsPack>
	mdspan (ElementType *, extents< IndexType, ExtentsPack... > const &) -> mdspan< ElementType, extents< IndexType, ExtentsPack... > >
template<typename ElementType , typename... Integrals> requires ((is_convertible_v<Integrals, size_t> && ...) && sizeof...(Integrals) > 0)
	mdspan (ElementType *, Integrals...) -> mdspan< ElementType, dextents< size_t, sizeof...(Integrals)> >
template<typename ElementType , typename MappingType >
	mdspan (ElementType *, MappingType const &) -> mdspan< ElementType, typename MappingType::extents_type, typename MappingType::layout_type >
template<class ElementType , class Extents , class Layout , class Container >
	mdspan (mdarray< ElementType, Extents, Layout, Container >) -> mdspan< typename decltype(declval< mdarray< ElementType, Extents, Layout, Container > >().to_mdspan())::element_type, typename decltype(declval< mdarray< ElementType, Extents, Layout, Container > >().to_mdspan())::extens_type, typename decltype(declval< mdarray< ElementType, Extents, Layout, Container > >().to_mdspan())::layout_type, typename decltype(declval< mdarray< ElementType, Extents, Layout, Container > >().to_mdspan())::accessor_type >
template<typename Pointer > requires (is_pointer_v<remove_reference_t<Pointer>>)
	mdspan (Pointer &&) -> mdspan< remove_pointer_t< remove_reference_t< Pointer > >, extents< size_t > >
template<typename MappingType , typename AccessorType >
	mdspan (typename AccessorType::data_handle_type const &, MappingType const &, AccessorType const &) -> mdspan< typename AccessorType::element_type, typename MappingType::extents_type, typename MappingType::layout_type, AccessorType >
auto	memcmp (void const *lhs, void const *rhs, etl::size_t count) noexcept -> int
	Reinterprets the objects pointed to by lhs and rhs as arrays of unsigned char and compares the first count bytes of these arrays. The comparison is done lexicographically.
auto	memcpy (void *dest, void const *src, etl::size_t n) -> void *
	Copy the first n bytes pointed to by src to the buffer pointed to by dest. Source and destination may not overlap. If source and destination might overlap, memmove() must be used instead.
auto	memmove (void *dest, void const *src, etl::size_t count) -> void *
	Copy the first n bytes pointed to by src to the buffer pointed to by dest. Source and destination may overlap.
auto	memset (void *s, int c, etl::size_t n) -> void *
	Copies the value of c (converted to an unsigned char) into each of the first n characters of the object pointed to by s.
template<typename InputIt1 , typename InputIt2 , typename OutputIt >
constexpr auto	merge (InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, OutputIt destination) -> OutputIt
template<typename InputIt1 , typename InputIt2 , typename OutputIt , typename Compare >
constexpr auto	merge (InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, OutputIt destination, Compare comp) -> OutputIt
	Merges two sorted ranges [first1, last1) and [first2, last2) into one sorted range beginning at destination.
template<etl::floating_point Float>
constexpr auto	midpoint (Float a, Float b) noexcept -> Float
template<typename Int > requires (etl::is_integral_v<Int> and not etl::is_same_v<Int, bool>)
constexpr auto	midpoint (Int a, Int b) noexcept -> Int
	Returns half the sum of a + b. If the sum is odd, the result is rounded towards a.
template<typename Ptr > requires etl::is_pointer_v<Ptr>
constexpr auto	midpoint (Ptr a, Ptr b) noexcept -> Ptr
template<typename Type >
constexpr auto	min (Type const &a, Type const &b) noexcept -> Type const &
	Returns the smaller of a and b.
template<typename Type , typename Compare >
constexpr auto	min (Type const &a, Type const &b, Compare comp) noexcept -> Type const &
	Returns the smaller of a and b, using a compare function.
template<typename ForwardIt >
constexpr auto	min_element (ForwardIt first, ForwardIt last) noexcept -> ForwardIt
	Finds the smallest element in the range [first, last). Elements are compared using operator<.
template<typename ForwardIt , typename Compare >
constexpr auto	min_element (ForwardIt first, ForwardIt last, Compare comp) -> ForwardIt
	Finds the smallest element in the range [first, last). Elements are compared using the given binary comparison function comp.
template<typename T >
constexpr auto	minmax (T const &a, T const &b) -> pair< T const &, T const & >
	Returns the lowest and the greatest of the given values.
template<typename T , typename Compare >
constexpr auto	minmax (T const &a, T const &b, Compare comp) -> pair< T const &, T const & >
	Returns the lowest and the greatest of the given values.
template<typename ForwardIt >
constexpr auto	minmax_element (ForwardIt first, ForwardIt last) -> pair< ForwardIt, ForwardIt >
	Finds the smallest and greatest element in the range [first, last).
template<typename ForwardIt , typename Compare >
constexpr auto	minmax_element (ForwardIt first, ForwardIt last, Compare comp) -> pair< ForwardIt, ForwardIt >
	Finds the smallest and greatest element in the range [first, last).
template<typename InputIt1 , typename InputIt2 >
constexpr auto	mismatch (InputIt1 first1, InputIt1 last1, InputIt2 first2) -> pair< InputIt1, InputIt2 >
template<typename InputIt1 , typename InputIt2 >
constexpr auto	mismatch (InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2) -> pair< InputIt1, InputIt2 >
template<typename InputIt1 , typename InputIt2 , typename Predicate >
constexpr auto	mismatch (InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, Predicate pred) -> pair< InputIt1, InputIt2 >
template<typename InputIt1 , typename InputIt2 , typename Predicate >
constexpr auto	mismatch (InputIt1 first1, InputIt1 last1, InputIt2 first2, Predicate pred) -> pair< InputIt1, InputIt2 >
	Returns the first mismatching pair of elements from two ranges: one defined by [first1, last1) and another defined by [first2,last2). If last2 is not provided (overloads (1-4)), it denotes first2 + (last1 - first1). Elements are compared using the given binary predicate pred.
template<typename InputIt , typename OutputIt >
constexpr auto	move (InputIt first, InputIt last, OutputIt destination) -> OutputIt
	Moves the elements in the range [first, last), to another range beginning at destination, starting from first and proceeding to last - 1. After this operation the elements in the moved-from range will still contain valid values of the appropriate type, but not necessarily the same values as before the move.
template<typename T >
constexpr auto	move (T &&t) noexcept -> etl::remove_reference_t< T > &&
	move is used to indicate that an object t may be "moved from", i.e. allowing the efficient transfer of resources from t to another object. In particular, move produces an xvalue expression that identifies its argument t. It is exactly equivalent to a static_cast to an rvalue reference type.
template<typename BidirIt1 , typename BidirIt2 >
constexpr auto	move_backward (BidirIt1 first, BidirIt1 last, BidirIt2 destination) -> BidirIt2
	Moves the elements from the range [first, last), to another range ending at destination. The elements are moved in reverse order (the last element is moved first), but their relative order is preserved.
template<typename T >
constexpr auto	move_if_noexcept (T &x) noexcept -> etl::conditional_t<!etl::is_nothrow_move_constructible_v< T > and etl::is_copy_constructible_v< T >, T const &, T && >
	Conditionally convert a value to an rvalue.
template<typename InputIt >
constexpr auto	next (InputIt it, typename iterator_traits< InputIt >::difference_type n=1) -> InputIt
	Return the nth successor of iterator it.
template<typename InputIt , typename Predicate >
constexpr auto	none_of (InputIt first, InputIt last, Predicate p) -> bool
	Checks if unary predicate p returns true for no elements in the range [first, last).
template<typename T >
constexpr auto	norm (complex< T > const &z) noexcept -> T
template<floating_point Float>
constexpr auto	norm (Float f) noexcept -> complex< Float >
template<integral Integer>
constexpr auto	norm (Integer i) noexcept -> complex< double >
template<auto ConstFn>
constexpr auto	not_fn () noexcept -> detail::stateless_not_fn< ConstFn >
template<typename F >
constexpr auto	not_fn (F &&f) -> detail::not_fn_t< etl::decay_t< F > >
template<typename RandomIt >
constexpr auto	nth_element (RandomIt first, RandomIt nth, RandomIt last) -> void
template<typename RandomIt , typename Compare >
constexpr auto	nth_element (RandomIt first, RandomIt nth, RandomIt last, Compare comp) -> void
	nth_element is a partial sorting algorithm that rearranges elements in [first, last) such that:
template<typename Char , typename Traits , etl::size_t Capacity>
constexpr auto	operator!= (Char const *lhs, etl::basic_inplace_string< Char, Capacity, Traits > const &rhs) noexcept -> bool
	Compares the contents of a string with another string or a null-terminated array of Char.
template<typename Char , typename Traits , etl::size_t Capacity1>
constexpr auto	operator!= (etl::basic_inplace_string< Char, Capacity1, Traits > const &lhs, Char const *rhs) noexcept -> bool
	Compares the contents of a string with another string or a null-terminated array of Char.
template<typename Char , typename Traits , etl::size_t Capacity1, etl::size_t Capacity2>
constexpr auto	operator!= (etl::basic_inplace_string< Char, Capacity1, Traits > const &lhs, etl::basic_inplace_string< Char, Capacity2, Traits > const &rhs) noexcept -> bool
	Compares the contents of a string with another string or a null-terminated array of Char.
template<typename Iter1 , typename Iter2 >
constexpr auto	operator!= (etl::reverse_iterator< Iter1 > const &lhs, etl::reverse_iterator< Iter2 > const &rhs) -> bool
	Compares the underlying iterators. Inverse comparisons are applied in order to take into account that the iterator order is reversed.
template<typename R , typename... Args, size_t Capacity, size_t Alignment>
constexpr auto	operator!= (inplace_function< R(Args...), Capacity, Alignment > const &f, nullptr_t) noexcept -> bool
	Compares a etl::inplace_function with a null pointer. Empty functions (that is, functions without a callable target) compare equal, non-empty functions compare non-equal.
template<typename Rhs , Rhs R, typename Lhs , Lhs L>
constexpr auto	operator!= (integral_constant< Rhs, R >, integral_constant< Lhs, L >) -> integral_constant< bool, L !=R >
constexpr auto	operator!= (language_standard lhs, language_standard rhs) noexcept -> bool
template<typename R , typename... Args, size_t Capacity, size_t Alignment>
constexpr auto	operator!= (nullptr_t, inplace_function< R(Args...), Capacity, Alignment > const &f) noexcept -> bool
	Compares a etl::inplace_function with a null pointer. Empty functions (that is, functions without a callable target) compare equal, non-empty functions compare non-equal.
template<typename Key , size_t Capacity, typename Comp >
constexpr auto	operator!= (static_set< Key, Capacity, Comp > const &lhs, static_set< Key, Capacity, Comp > const &rhs) -> bool
	Compares the contents of two sets.
template<typename T , size_t Capacity>
constexpr auto	operator!= (static_vector< T, Capacity > const &lhs, static_vector< T, Capacity > const &rhs) noexcept -> bool
constexpr auto	operator""_h (long double h) -> etl::chrono::duration< long double, ratio< 3600, 1 > >
	Forms a etl::chrono::duration literal representing hours. Floating-point literal, returns a floating-point duration equivalent to etl::chrono::hours.
constexpr auto	operator""_h (unsigned long long h) -> etl::chrono::hours
	Forms a etl::chrono::duration literal representing hours. Integer literal, returns exactly etl::chrono::hours(hrs).
constexpr auto	operator""_i (long double d) -> complex< double >
constexpr auto	operator""_i (unsigned long long d) -> complex< double >
constexpr auto	operator""_if (long double d) -> complex< float >
constexpr auto	operator""_if (unsigned long long d) -> complex< float >
constexpr auto	operator""_il (long double d) -> complex< long double >
constexpr auto	operator""_il (unsigned long long d) -> complex< long double >
constexpr auto	operator""_min (long double m) -> etl::chrono::duration< long double, etl::ratio< 60, 1 > >
	Forms a etl::chrono::duration literal representing minutes. Floating-point literal, returns a floating-point duration equivalent to etl::chrono::minutes.
constexpr auto	operator""_min (unsigned long long m) -> etl::chrono::minutes
	Forms a etl::chrono::duration literal representing minutes. Integer literal, returns exactly etl::chrono::minutes(mins).
constexpr auto	operator""_ms (long double m) -> etl::chrono::duration< long double, etl::milli >
	Forms a etl::chrono::duration literal representing milliseconds. Floating-point literal, returns a floating-point duration equivalent to etl::chrono::milliseconds.
constexpr auto	operator""_ms (unsigned long long m) -> etl::chrono::milliseconds
	Forms a etl::chrono::duration literal representing milliseconds. Integer literal, returns exactly etl::chrono::milliseconds(mins).
constexpr auto	operator""_ns (long double m) -> etl::chrono::duration< long double, etl::nano >
	Forms a etl::chrono::duration literal representing nanoseconds. Floating-point literal, returns a floating-point duration equivalent to etl::chrono::nanoseconds.
constexpr auto	operator""_ns (unsigned long long m) -> etl::chrono::nanoseconds
	Forms a etl::chrono::duration literal representing nanoseconds. Integer literal, returns exactly etl::chrono::nanoseconds(mins).
constexpr auto	operator""_s (long double m) -> etl::chrono::duration< long double >
	Forms a etl::chrono::duration literal representing seconds. Floating-point literal, returns a floating-point duration equivalent to etl::chrono::seconds.
constexpr auto	operator""_s (unsigned long long m) -> etl::chrono::seconds
	Forms a etl::chrono::duration literal representing seconds. Integer literal, returns exactly etl::chrono::seconds(mins).
constexpr auto	operator""_us (long double m) -> etl::chrono::duration< long double, etl::micro >
	Forms a etl::chrono::duration literal representing microseconds. Floating-point literal, returns a floating-point duration equivalent to etl::chrono::microseconds.
constexpr auto	operator""_us (unsigned long long m) -> etl::chrono::microseconds
	Forms a etl::chrono::duration literal representing microseconds. Integer literal, returns exactly etl::chrono::microseconds(mins).
TETL_ALWAYS_INLINE constexpr auto	operator& (etl::byte lhs, etl::byte rhs) noexcept -> etl::byte
	Equivalent to: return byte(static_cast<unsigned int>(lhs) & static_cast<unsigned int>(rhs));
template<bitmask_type T>
constexpr auto	operator& (T x, T y) -> T
TETL_ALWAYS_INLINE constexpr auto	operator&= (etl::byte &lhs, etl::byte rhs) noexcept -> etl::byte &
	Equivalent to: return lhs = lhs & rhs;
template<bitmask_type T>
constexpr auto	operator&= (T &x, T y) noexcept -> T const &
template<typename T >
constexpr auto	operator* (complex< T > const &lhs, complex< T > const &rhs) -> complex< T >
template<typename T >
constexpr auto	operator* (complex< T > const &lhs, T const &rhs) -> complex< T >
template<typename T >
constexpr auto	operator* (T const &lhs, complex< T > const &rhs) -> complex< T >
template<typename Char , typename Traits , size_t Capacity>
constexpr auto	operator+ (basic_inplace_string< Char, Capacity, Traits > const &lhs, Char const *rhs) noexcept -> basic_inplace_string< Char, Capacity, Traits >
	Returns a string containing characters from lhs followed by the characters from rhs.
template<typename Char , typename Traits , size_t Capacity>
constexpr auto	operator+ (basic_inplace_string< Char, Capacity, Traits > const &lhs, Char rhs) noexcept -> basic_inplace_string< Char, Capacity, Traits >
	Returns a string containing characters from lhs followed by the characters from rhs.
template<typename Char , typename Traits , size_t Capacity1, size_t Capacity2>
constexpr auto	operator+ (basic_inplace_string< Char, Capacity1, Traits > const &lhs, basic_inplace_string< Char, Capacity2, Traits > const &rhs) noexcept -> basic_inplace_string< Char, Capacity1, Traits >
	Returns a string containing characters from lhs followed by the characters from rhs.
template<typename Char , typename Traits , size_t Capacity>
constexpr auto	operator+ (Char const *lhs, basic_inplace_string< Char, Capacity, Traits > const &rhs) noexcept -> basic_inplace_string< Char, Capacity, Traits >
	Returns a string containing characters from lhs followed by the characters from rhs.
template<typename Char , typename Traits , size_t Capacity>
constexpr auto	operator+ (Char lhs, basic_inplace_string< Char, Capacity, Traits > const &rhs) noexcept -> basic_inplace_string< Char, Capacity, Traits >
	Returns a string containing characters from lhs followed by the characters from rhs.
template<typename T >
constexpr auto	operator+ (complex< T > const &lhs, complex< T > const &rhs) -> complex< T >
template<typename T >
constexpr auto	operator+ (complex< T > const &lhs, T const &rhs) -> complex< T >
template<typename T >
constexpr auto	operator+ (complex< T > const &val) -> complex< T >
template<typename Rhs , Rhs R, typename Lhs , Lhs L>
constexpr auto	operator+ (integral_constant< Rhs, R >, integral_constant< Lhs, L >) -> integral_constant< decltype(L+R), L+R >
template<typename T >
constexpr auto	operator+ (T const &lhs, complex< T > const &rhs) -> complex< T >
template<typename Iter >
constexpr auto	operator+ (typename reverse_iterator< Iter >::difference_type n, reverse_iterator< Iter > const &it) noexcept(noexcept(it.base() - n)) -> reverse_iterator< Iter >
	Returns the iterator it incremented by n.
template<typename T >
constexpr auto	operator- (complex< T > const &lhs, complex< T > const &rhs) -> complex< T >
template<typename T >
constexpr auto	operator- (complex< T > const &lhs, T const &rhs) -> complex< T >
template<typename T >
constexpr auto	operator- (complex< T > const &val) -> complex< T >
template<typename Iterator1 , typename Iterator2 >
constexpr auto	operator- (reverse_iterator< Iterator1 > const &lhs, reverse_iterator< Iterator2 > const &rhs) noexcept(noexcept(rhs.base() - lhs.base())) -> decltype(rhs.base() - lhs.base())
	Returns the distance between two iterator adaptors.
template<typename T >
constexpr auto	operator- (T const &lhs, complex< T > const &rhs) -> complex< T >
template<typename T >
constexpr auto	operator/ (complex< T > const &lhs, complex< T > const &rhs) -> complex< T >
template<typename T >
constexpr auto	operator/ (complex< T > const &lhs, T const &rhs) -> complex< T >
template<typename T >
constexpr auto	operator/ (T const &lhs, complex< T > const &rhs) -> complex< T >
template<typename Char , typename Traits >
constexpr auto	operator< (basic_string_view< Char, Traits > lhs, basic_string_view< Char, Traits > rhs) noexcept -> bool
	Compares two views. All comparisons are done via the compare() member function (which itself is defined in terms of Traits::compare()):
template<typename Char , typename Traits , int = 2>
constexpr auto	operator< (basic_string_view< Char, Traits > lhs, type_identity_t< basic_string_view< Char, Traits > > rhs) noexcept -> bool
template<typename Char , typename Traits , etl::size_t Capacity1>
constexpr auto	operator< (Char const *lhs, etl::basic_inplace_string< Char, Capacity1, Traits > const &rhs) noexcept -> bool
	Compares the contents of a string with another string or a null-terminated array of Char.
template<typename Char , typename Traits , etl::size_t Capacity1>
constexpr auto	operator< (etl::basic_inplace_string< Char, Capacity1, Traits > const &lhs, Char const *rhs) noexcept -> bool
	Compares the contents of a string with another string or a null-terminated array of Char.
template<typename Char , typename Traits , etl::size_t Capacity1, etl::size_t Capacity2>
constexpr auto	operator< (etl::basic_inplace_string< Char, Capacity1, Traits > const &lhs, etl::basic_inplace_string< Char, Capacity2, Traits > const &rhs) noexcept
	Compares the contents of a string with another string or a null-terminated array of Char.
template<typename Iter1 , typename Iter2 >
constexpr auto	operator< (etl::reverse_iterator< Iter1 > const &lhs, etl::reverse_iterator< Iter2 > const &rhs) -> bool
	Compares the underlying iterators. Inverse comparisons are applied in order to take into account that the iterator order is reversed.
constexpr auto	operator< (language_standard lhs, language_standard rhs) noexcept -> bool
template<typename T1 , typename T2 >
constexpr auto	operator< (pair< T1, T2 > const &lhs, pair< T1, T2 > const &rhs) -> bool
	Compares lhs and rhs lexicographically by operator<, that is, compares the first elements and only if they are equivalent, compares the second elements.
template<typename Key , size_t Capacity, typename Comp >
constexpr auto	operator< (static_set< Key, Capacity, Comp > const &lhs, static_set< Key, Capacity, Comp > const &rhs) -> bool
	Compares the contents of two sets.
template<typename T , size_t Capacity>
constexpr auto	operator< (static_vector< T, Capacity > const &lhs, static_vector< T, Capacity > const &rhs) noexcept -> bool
	Compares the contents of two vectors.
template<typename Char , typename Traits , int = 1>
constexpr auto	operator< (type_identity_t< basic_string_view< Char, Traits > > lhs, basic_string_view< Char, Traits > rhs) noexcept -> bool
template<etl::integral Int>
TETL_ALWAYS_INLINE constexpr auto	operator<< (etl::byte b, Int shift) noexcept -> etl::byte
	Equivalent to: return etl::byte(static_cast<unsigned int>(b) << shift);
template<etl::integral Int>
TETL_ALWAYS_INLINE constexpr auto	operator<<= (etl::byte &b, Int shift) noexcept -> etl::byte &
	Equivalent to: return b = b << shift;
template<typename Char , typename Traits >
constexpr auto	operator<= (basic_string_view< Char, Traits > lhs, basic_string_view< Char, Traits > rhs) noexcept -> bool
	Compares two views. All comparisons are done via the compare() member function (which itself is defined in terms of Traits::compare()):
template<typename Char , typename Traits , int = 2>
constexpr auto	operator<= (basic_string_view< Char, Traits > lhs, type_identity_t< basic_string_view< Char, Traits > > rhs) noexcept -> bool
template<typename Char , typename Traits , etl::size_t Capacity1>
constexpr auto	operator<= (Char const *lhs, etl::basic_inplace_string< Char, Capacity1, Traits > const &rhs) noexcept -> bool
	Compares the contents of a string with another string or a null-terminated array of Char.
template<typename Char , typename Traits , etl::size_t Capacity1>
constexpr auto	operator<= (etl::basic_inplace_string< Char, Capacity1, Traits > const &lhs, Char const *rhs) noexcept -> bool
	Compares the contents of a string with another string or a null-terminated array of Char.
template<typename Char , typename Traits , etl::size_t Capacity1, etl::size_t Capacity2>
constexpr auto	operator<= (etl::basic_inplace_string< Char, Capacity1, Traits > const &lhs, etl::basic_inplace_string< Char, Capacity2, Traits > const &rhs) noexcept
	Compares the contents of a string with another string or a null-terminated array of Char.
template<typename Iter1 , typename Iter2 >
constexpr auto	operator<= (etl::reverse_iterator< Iter1 > const &lhs, etl::reverse_iterator< Iter2 > const &rhs) -> bool
	Compares the underlying iterators. Inverse comparisons are applied in order to take into account that the iterator order is reversed.
constexpr auto	operator<= (language_standard lhs, language_standard rhs) noexcept -> bool
template<typename T1 , typename T2 >
constexpr auto	operator<= (pair< T1, T2 > const &lhs, pair< T1, T2 > const &rhs) -> bool
	Compares lhs and rhs lexicographically by operator<, that is, compares the first elements and only if they are equivalent, compares the second elements.
template<typename Key , size_t Capacity, typename Comp >
constexpr auto	operator<= (static_set< Key, Capacity, Comp > const &lhs, static_set< Key, Capacity, Comp > const &rhs) -> bool
	Compares the contents of two sets.
template<typename T , size_t Capacity>
constexpr auto	operator<= (static_vector< T, Capacity > const &lhs, static_vector< T, Capacity > const &rhs) noexcept -> bool
template<typename Char , typename Traits , int = 1>
constexpr auto	operator<= (type_identity_t< basic_string_view< Char, Traits > > lhs, basic_string_view< Char, Traits > rhs) noexcept -> bool
template<typename Char , typename Traits >
constexpr auto	operator== (basic_string_view< Char, Traits > lhs, type_identity_t< basic_string_view< Char, Traits > > rhs) noexcept -> bool
	Compares two views. All comparisons are done via the compare() member function (which itself is defined in terms of Traits::compare()):
template<typename Char , typename Traits , etl::size_t Capacity>
constexpr auto	operator== (Char const *lhs, etl::basic_inplace_string< Char, Capacity, Traits > const &rhs) noexcept -> bool
	Compares the contents of a string with another string or a null-terminated array of Char.
template<typename Char , typename Traits , etl::size_t Capacity>
constexpr auto	operator== (etl::basic_inplace_string< Char, Capacity, Traits > const &lhs, Char const *rhs) noexcept -> bool
	Compares the contents of a string with another string or a null-terminated array of Char.
template<typename Char , typename Traits , etl::size_t Capacity1, etl::size_t Capacity2>
constexpr auto	operator== (etl::basic_inplace_string< Char, Capacity1, Traits > const &lhs, etl::basic_inplace_string< Char, Capacity2, Traits > const &rhs) noexcept -> bool
	Compares the contents of a string with another string or a null-terminated array of Char.
template<typename Iter1 , typename Iter2 >
constexpr auto	operator== (etl::reverse_iterator< Iter1 > const &lhs, etl::reverse_iterator< Iter2 > const &rhs) -> bool
	Compares the underlying iterators. Inverse comparisons are applied in order to take into account that the iterator order is reversed.
template<typename R , typename... Args, size_t Capacity, size_t Alignment>
constexpr auto	operator== (inplace_function< R(Args...), Capacity, Alignment > const &f, nullptr_t) noexcept -> bool
	Compares a etl::inplace_function with a null pointer. Empty functions (that is, functions without a callable target) compare equal, non-empty functions compare non-equal.
template<typename Rhs , Rhs R, typename Lhs , Lhs L>
constexpr auto	operator== (integral_constant< Rhs, R >, integral_constant< Lhs, L >) -> integral_constant< bool, L==R >
constexpr auto	operator== (language_standard lhs, language_standard rhs) noexcept -> bool
	Compares language_standards.
template<typename R , typename... Args, size_t Capacity, size_t Alignment>
constexpr auto	operator== (nullptr_t, inplace_function< R(Args...), Capacity, Alignment > const &f) noexcept -> bool
	Compares a etl::inplace_function with a null pointer. Empty functions (that is, functions without a callable target) compare equal, non-empty functions compare non-equal.
template<typename T1 , typename T2 >
constexpr auto	operator== (pair< T1, T2 > const &lhs, pair< T1, T2 > const &rhs) -> bool
	Tests if both elements of lhs and rhs are equal, that is, compares lhs.first with rhs.first and lhs.second with rhs.second.
template<typename Key , size_t Capacity, typename Comp >
constexpr auto	operator== (static_set< Key, Capacity, Comp > const &lhs, static_set< Key, Capacity, Comp > const &rhs) -> bool
	Compares the contents of two sets.
template<typename T , size_t Capacity>
constexpr auto	operator== (static_vector< T, Capacity > const &lhs, static_vector< T, Capacity > const &rhs) noexcept -> bool
	Compares the contents of two vectors.
template<typename CharT , CharT... Chars>
constexpr auto	operator== (string_constant< CharT, Chars... >, string_constant< CharT, Chars... >) noexcept -> bool
template<typename CharT , CharT... CharsL, CharT... CharsR>
constexpr auto	operator== (string_constant< CharT, CharsL... >, string_constant< CharT, CharsR... >) noexcept -> bool
template<typename... Ts, typename... Us> requires (sizeof...(Ts) == sizeof...(Us))
constexpr auto	operator== (tuple< Ts... > const &lhs, tuple< Us... > const &rhs) -> bool
template<typename Char , typename Traits >
constexpr auto	operator> (basic_string_view< Char, Traits > lhs, basic_string_view< Char, Traits > rhs) noexcept -> bool
	Compares two views. All comparisons are done via the compare() member function (which itself is defined in terms of Traits::compare()):
template<typename Char , typename Traits , int = 2>
constexpr auto	operator> (basic_string_view< Char, Traits > lhs, type_identity_t< basic_string_view< Char, Traits > > rhs) noexcept -> bool
template<typename Char , typename Traits , etl::size_t Capacity1>
constexpr auto	operator> (Char const *lhs, etl::basic_inplace_string< Char, Capacity1, Traits > const &rhs) noexcept -> bool
	Compares the contents of a string with another string or a null-terminated array of Char.
template<typename Char , typename Traits , etl::size_t Capacity1>
constexpr auto	operator> (etl::basic_inplace_string< Char, Capacity1, Traits > const &lhs, Char const *rhs) noexcept -> bool
	Compares the contents of a string with another string or a null-terminated array of Char.
template<typename Char , typename Traits , etl::size_t Capacity1, etl::size_t Capacity2>
constexpr auto	operator> (etl::basic_inplace_string< Char, Capacity1, Traits > const &lhs, etl::basic_inplace_string< Char, Capacity2, Traits > const &rhs) noexcept
	Compares the contents of a string with another string or a null-terminated array of Char.
template<typename Iter1 , typename Iter2 >
constexpr auto	operator> (etl::reverse_iterator< Iter1 > const &lhs, etl::reverse_iterator< Iter2 > const &rhs) -> bool
	Compares the underlying iterators. Inverse comparisons are applied in order to take into account that the iterator order is reversed.
constexpr auto	operator> (language_standard lhs, language_standard rhs) noexcept -> bool
template<typename T1 , typename T2 >
constexpr auto	operator> (pair< T1, T2 > const &lhs, pair< T1, T2 > const &rhs) -> bool
	Compares lhs and rhs lexicographically by operator<, that is, compares the first elements and only if they are equivalent, compares the second elements.
template<typename Key , size_t Capacity, typename Comp >
constexpr auto	operator> (static_set< Key, Capacity, Comp > const &lhs, static_set< Key, Capacity, Comp > const &rhs) -> bool
	Compares the contents of two sets.
template<typename T , size_t Capacity>
constexpr auto	operator> (static_vector< T, Capacity > const &lhs, static_vector< T, Capacity > const &rhs) noexcept -> bool
template<typename Char , typename Traits , int = 1>
constexpr auto	operator> (type_identity_t< basic_string_view< Char, Traits > > lhs, basic_string_view< Char, Traits > rhs) noexcept -> bool
template<typename Char , typename Traits >
constexpr auto	operator>= (basic_string_view< Char, Traits > lhs, basic_string_view< Char, Traits > rhs) noexcept -> bool
	Compares two views. All comparisons are done via the compare() member function (which itself is defined in terms of Traits::compare()):
template<typename Char , typename Traits , int = 2>
constexpr auto	operator>= (basic_string_view< Char, Traits > lhs, type_identity_t< basic_string_view< Char, Traits > > rhs) noexcept -> bool
template<typename Char , typename Traits , etl::size_t Capacity>
constexpr auto	operator>= (Char const *lhs, etl::basic_inplace_string< Char, Capacity, Traits > const &rhs) noexcept -> bool
	Compares the contents of a string with another string or a null-terminated array of Char.
template<typename Char , typename Traits , etl::size_t Capacity>
constexpr auto	operator>= (etl::basic_inplace_string< Char, Capacity, Traits > const &lhs, Char const *rhs) noexcept -> bool
	Compares the contents of a string with another string or a null-terminated array of Char.
template<typename Char , typename Traits , etl::size_t Capacity1, etl::size_t Capacity2>
constexpr auto	operator>= (etl::basic_inplace_string< Char, Capacity1, Traits > const &lhs, etl::basic_inplace_string< Char, Capacity2, Traits > const &rhs) noexcept
	Compares the contents of a string with another string or a null-terminated array of Char.
template<typename Iter1 , typename Iter2 >
constexpr auto	operator>= (etl::reverse_iterator< Iter1 > const &lhs, etl::reverse_iterator< Iter2 > const &rhs) -> bool
	Compares the underlying iterators. Inverse comparisons are applied in order to take into account that the iterator order is reversed.
constexpr auto	operator>= (language_standard lhs, language_standard rhs) noexcept -> bool
template<typename T1 , typename T2 >
constexpr auto	operator>= (pair< T1, T2 > const &lhs, pair< T1, T2 > const &rhs) -> bool
	Compares lhs and rhs lexicographically by operator<, that is, compares the first elements and only if they are equivalent, compares the second elements.
template<typename Key , size_t Capacity, typename Comp >
constexpr auto	operator>= (static_set< Key, Capacity, Comp > const &lhs, static_set< Key, Capacity, Comp > const &rhs) -> bool
	Compares the contents of two sets.
template<typename T , size_t Capacity>
constexpr auto	operator>= (static_vector< T, Capacity > const &lhs, static_vector< T, Capacity > const &rhs) noexcept -> bool
template<typename Char , typename Traits , int = 1>
constexpr auto	operator>= (type_identity_t< basic_string_view< Char, Traits > > lhs, basic_string_view< Char, Traits > rhs) noexcept -> bool
template<etl::integral Int>
TETL_ALWAYS_INLINE constexpr auto	operator>> (etl::byte b, Int shift) noexcept -> etl::byte
	Equivalent to: return etl::byte(static_cast<unsigned int>(b) >> shift);
template<etl::integral Int>
TETL_ALWAYS_INLINE constexpr auto	operator>>= (etl::byte &b, Int shift) noexcept -> etl::byte &
	Equivalent to: return b = b >> shift;
TETL_ALWAYS_INLINE constexpr auto	operator^ (etl::byte lhs, etl::byte rhs) noexcept -> etl::byte
	Equivalent to: return byte(static_cast<unsigned int>(lhs) ^ static_cast<unsigned int>(rhs));
template<bitmask_type T>
constexpr auto	operator^ (T x, T y) -> T
TETL_ALWAYS_INLINE constexpr auto	operator^= (etl::byte &lhs, etl::byte rhs) noexcept -> etl::byte &
	Equivalent to: return lhs = lhs ^ rhs;
template<bitmask_type T>
constexpr auto	operator^= (T &x, T y) noexcept -> T const &
TETL_ALWAYS_INLINE constexpr auto	operator| (etl::byte lhs, etl::byte rhs) noexcept -> etl::byte
	Equivalent to: return byte(static_cast<unsigned int>(lhs) | static_cast<unsigned int>(rhs));
template<bitmask_type T>
constexpr auto	operator| (T x, T y) -> T
TETL_ALWAYS_INLINE constexpr auto	operator|= (etl::byte &lhs, etl::byte rhs) noexcept -> etl::byte &
	Equivalent to: return lhs = lhs | rhs;
template<bitmask_type T>
constexpr auto	operator|= (T &x, T y) noexcept -> T const &
TETL_ALWAYS_INLINE constexpr auto	operator~ (etl::byte b) noexcept -> etl::byte
	Equivalent to: return byte(~static_cast<unsigned int>(b));
template<bitmask_type T>
constexpr auto	operator~ (T x) -> T
template<typename... Functor>
	overload (Functor...) -> overload< Functor... >
template<typename T1 , typename T2 >
	pair (T1, T2) -> pair< T1, T2 >
template<typename RandomIt >
constexpr auto	partial_sort (RandomIt first, RandomIt middle, RandomIt last) -> void
template<typename RandomIt , typename Compare >
constexpr auto	partial_sort (RandomIt first, RandomIt middle, RandomIt last, Compare comp) -> void
	Rearranges elements such that the range [first, middle) contains the sorted middle - first smallest elements in the range [first, last). The order of equal elements is not guaranteed to be preserved. The order of the remaining elements in the range [middle, last) is unspecified.
template<typename InputIt , typename OutputIt >
constexpr auto	partial_sum (InputIt first, InputIt last, OutputIt destination) -> OutputIt
template<typename InputIt , typename OutputIt , typename BinaryOperation >
constexpr auto	partial_sum (InputIt first, InputIt last, OutputIt destination, BinaryOperation op) -> OutputIt
	Computes the partial sums of the elements in the subranges of the range [first, last) and writes them to the range beginning at destination. This version uses the given binary function op, both applying etl::move to their operands on the left hand side.
template<typename ForwardIt , typename Predicate >
constexpr auto	partition (ForwardIt first, ForwardIt last, Predicate p) -> ForwardIt
	Reorders the elements in the range [first, last) in such a way that all elements for which the predicate p returns true precede the elements for which predicate p returns false. Relative order of the elements is not preserved.
template<typename InputIt , typename OutputIt1 , typename OutputIt2 , typename Predicate >
constexpr auto	partition_copy (InputIt first, InputIt last, OutputIt1 destinationTrue, OutputIt2 destinationFalse, Predicate p) -> pair< OutputIt1, OutputIt2 >
	Copies the elements from the range [first, last) to two different ranges depending on the value returned by the predicate p. The elements that satisfy the predicate p are copied to the range beginning at destination_true. The rest of the elements are copied to the range beginning at destination_false.
template<typename ForwardIt , typename Predicate >
constexpr auto	partition_point (ForwardIt first, ForwardIt last, Predicate p) -> ForwardIt
	Examines the partitioned (as if by partition) range [first, last) and locates the end of the first partition, that is, the first element that does not satisfy p or last if all elements satisfy p.
template<typename T >
constexpr auto	polar (T const &r, T const &theta=T()) noexcept -> etl::complex< T >
template<etl::builtin_unsigned_integer UInt>
constexpr auto	popcount (UInt val) noexcept -> int
	Returns the number of 1 bits in the value of x.
constexpr auto	pow (double base, double exp) -> double
	Computes the value of base raised to the power exp.
constexpr auto	pow (double base, int iexp) -> double
	Computes the value of base raised to the power exp.
constexpr auto	pow (float base, float exp) -> float
	Computes the value of base raised to the power exp.
constexpr auto	pow (float base, int iexp) -> float
	Computes the value of base raised to the power exp.
constexpr auto	pow (long double base, int iexp) -> long double
	Computes the value of base raised to the power exp.
constexpr auto	pow (long double base, long double exp) -> long double
	Computes the value of base raised to the power exp.
constexpr auto	powf (float base, float exp) -> float
	Computes the value of base raised to the power exp.
constexpr auto	powl (long double base, long double exp) -> long double
	Computes the value of base raised to the power exp.
template<typename BidirIt >
constexpr auto	prev (BidirIt it, typename iterator_traits< BidirIt >::difference_type n=1) -> BidirIt
	Return the nth predecessor of iterator it.
template<typename Exception >
TETL_NO_INLINE TETL_COLD auto	raise (char const *msg, etl::source_location const loc=etl::source_location::current()) -> void
template<typename Container >
constexpr auto	rbegin (Container &c) -> decltype(c.rbegin())
	Returns an iterator to the reverse-beginning of the given container.
template<typename Container >
constexpr auto	rbegin (Container const &c) -> decltype(c.rbegin())
template<typename T , size_t N>
constexpr auto	rbegin (T(&array)[N]) -> reverse_iterator< T * >
template<typename T >
constexpr auto	real (complex< T > const &z) noexcept(noexcept(z.real())) -> T
template<floating_point Float>
constexpr auto	real (Float f) noexcept -> Float
template<integral Integer>
constexpr auto	real (Integer i) noexcept -> double
template<typename InputIter >
constexpr auto	reduce (InputIter first, InputIter last) -> typename etl::iterator_traits< InputIter >::value_type
	Similar to etl::accumulate.
template<typename InputIter , typename T >
constexpr auto	reduce (InputIter first, InputIter last, T init) -> T
	Similar to etl::accumulate.
template<typename InputIter , typename T , typename BinaryOp >
constexpr auto	reduce (InputIter first, InputIter last, T init, BinaryOp op) -> T
	Similar to etl::accumulate.
template<typename T >
constexpr auto	ref (reference_wrapper< T > t) noexcept -> reference_wrapper< T >
	Function templates ref and cref are helper functions that generate an object of type reference_wrapper, using template argument deduction to determine the template argument of the result.
template<typename T >
constexpr auto	ref (T &t) noexcept -> reference_wrapper< T >
	Function templates ref and cref are helper functions that generate an object of type reference_wrapper, using template argument deduction to determine the template argument of the result.
template<typename T >
	reference_wrapper (T &) -> reference_wrapper< T >
constexpr auto	remainder (double x, double y) noexcept -> double
	Computes the remainder of the floating point division operation x/y.
constexpr auto	remainder (float x, float y) noexcept -> float
	Computes the remainder of the floating point division operation x/y.
constexpr auto	remainder (long double x, long double y) noexcept -> long double
	Computes the remainder of the floating point division operation x/y.
constexpr auto	remainderf (float x, float y) noexcept -> float
	Computes the remainder of the floating point division operation x/y.
constexpr auto	remainderl (long double x, long double y) noexcept -> long double
	Computes the remainder of the floating point division operation x/y.
template<typename ForwardIt , typename T >
constexpr auto	remove (ForwardIt first, ForwardIt last, T const &value) -> ForwardIt
	Removes all elements satisfying specific criteria from the range [first, last) and returns a past-the-end iterator for the new end of the range.
template<typename InputIt , typename OutputIt , typename T >
constexpr auto	remove_copy (InputIt first, InputIt last, OutputIt destination, T const &value) -> OutputIt
	Copies elements from the range [first, last), to another range beginning at destination, omitting the elements which satisfy specific criteria. Source and destination ranges cannot overlap. Ignores all elements that are equal to value.
template<typename InputIt , typename OutputIt , typename Predicate >
constexpr auto	remove_copy_if (InputIt first, InputIt last, OutputIt destination, Predicate p) -> OutputIt
	Copies elements from the range [first, last), to another range beginning at destination, omitting the elements which satisfy specific criteria. Source and destination ranges cannot overlap. Ignores all elements for which predicate p returns true.
template<typename ForwardIt , typename Predicate >
constexpr auto	remove_if (ForwardIt first, ForwardIt last, Predicate pred) -> ForwardIt
	Removes all elements satisfying specific criteria from the range [first, last) and returns a past-the-end iterator for the new end of the range.
template<typename Container >
constexpr auto	rend (Container &c) -> decltype(c.rend())
	Returns an iterator to the reverse-end of the given container.
template<typename Container >
constexpr auto	rend (Container const &c) -> decltype(c.rend())
template<typename T , size_t N>
constexpr auto	rend (T(&array)[N]) -> reverse_iterator< T * >
template<typename ForwardIt , typename T >
constexpr auto	replace (ForwardIt first, ForwardIt last, T const &oldValue, T const &newValue) -> void
	Replaces all elements satisfying specific criteria with new_value in the range [first, last). Replaces all elements that are equal to old_value.
template<typename ForwardIt , typename Predicate , typename T >
constexpr auto	replace_if (ForwardIt first, ForwardIt last, Predicate p, T const &newValue) -> void
	Replaces all elements satisfying specific criteria with new_value in the range [first, last). Replaces all elements for which predicate p returns true.
template<etl::size_t Pos, etl::builtin_unsigned_integer UInt>
constexpr auto	reset_bit (UInt word) noexcept -> UInt
	Reset bit at position Pos.
template<etl::builtin_unsigned_integer UInt>
constexpr auto	reset_bit (UInt word, UInt pos) noexcept -> UInt
	Reset bit at position pos.
template<typename BidirIt >
constexpr auto	reverse (BidirIt first, BidirIt last) -> void
	Reverses the order of the elements in the range [first, last).
template<typename BidirIt , typename OutputIt >
constexpr auto	reverse_copy (BidirIt first, BidirIt last, OutputIt destination) -> OutputIt
	Copies the elements from the range [first, last) to another range beginning at d_first in such a way that the elements in the new range are in reverse order.
constexpr auto	rint (double arg) noexcept -> double
	Rounds the floating-point argument arg to an integer value (in floating-point format), using the current rounding mode.
constexpr auto	rint (float arg) noexcept -> float
	Rounds the floating-point argument arg to an integer value (in floating-point format), using the current rounding mode.
constexpr auto	rint (long double arg) noexcept -> long double
	Rounds the floating-point argument arg to an integer value (in floating-point format), using the current rounding mode.
template<integral T>
constexpr auto	rint (T arg) noexcept -> double
	Rounds the floating-point argument arg to an integer value (in floating-point format), using the current rounding mode.
constexpr auto	rintf (float arg) noexcept -> float
	Rounds the floating-point argument arg to an integer value (in floating-point format), using the current rounding mode.
constexpr auto	rintl (long double arg) noexcept -> long double
	Rounds the floating-point argument arg to an integer value (in floating-point format), using the current rounding mode.
template<typename ForwardIt >
constexpr auto	rotate (ForwardIt first, ForwardIt nFirst, ForwardIt last) -> ForwardIt
	Performs a left rotation on a range of elements.
template<typename ForwardIt , typename OutputIt >
constexpr auto	rotate_copy (ForwardIt first, ForwardIt nFirst, ForwardIt last, OutputIt destination) -> OutputIt
	Copies the elements from the range [first, last), to another range beginning at destination in such a way, that the element nFirst becomes the first element of the new range and nFirst - 1 becomes the last element.
template<etl::builtin_unsigned_integer UInt>
constexpr auto	rotl (UInt t, int s) noexcept -> UInt
	Computes the result of bitwise left-rotating the value of x by s positions. This operation is also known as a left circular shift.
template<etl::builtin_unsigned_integer UInt>
constexpr auto	rotr (UInt t, int s) noexcept -> UInt
	Computes the result of bitwise right-rotating the value of x by s positions. This operation is also known as a right circular shift.
template<builtin_integer To, builtin_integer From>
constexpr auto	saturate_cast (From x) noexcept -> To
	Converts the value x to a value of type T, clamping x between the minimum and maximum values of type T.
template<typename FuncT >
	scope_exit (FuncT) -> scope_exit< decay_t< FuncT > >
template<etl::size_t Pos, etl::builtin_unsigned_integer UInt>
constexpr auto	set_bit (UInt word) noexcept -> UInt
	Set bit at position Pos
template<etl::size_t Pos, etl::builtin_unsigned_integer UInt>
constexpr auto	set_bit (UInt word, bool value) noexcept -> UInt
	Set bit at position Pos to value.
template<etl::builtin_unsigned_integer UInt>
constexpr auto	set_bit (UInt word, UInt pos) noexcept -> UInt
	Set bit at position pos.
template<etl::builtin_unsigned_integer UInt>
constexpr auto	set_bit (UInt word, UInt pos, bool value) -> UInt
	Set bit at position pos to value.
template<typename ForwardIt >
constexpr auto	shift_left (ForwardIt first, ForwardIt const last, typename iterator_traits< ForwardIt >::difference_type n) -> ForwardIt
	Shifts the elements in the range [first, last) by n positions.
template<typename BidiIt >
constexpr auto	shift_right (BidiIt first, BidiIt last, typename etl::iterator_traits< BidiIt >::difference_type n) -> BidiIt
	Shifts the elements in the range [first, last) by n positions.
constexpr auto	signbit (double arg) noexcept -> bool
	Determines if the given floating point number arg is negative.
constexpr auto	signbit (float arg) noexcept -> bool
	Determines if the given floating point number arg is negative.
constexpr auto	signbit (half arg) noexcept -> bool
constexpr auto	signbit (long double arg) noexcept -> bool
	Determines if the given floating point number arg is negative.
template<typename T >
constexpr auto	sin (complex< T > const &z) -> complex< T >
template<typename T >
constexpr auto	sinh (complex< T > const &z) -> complex< T >
constexpr auto	sinh (double arg) noexcept -> double
	Computes the hyperbolic sine of arg.
constexpr auto	sinh (float arg) noexcept -> float
	Computes the hyperbolic sine of arg.
constexpr auto	sinh (long double arg) noexcept -> long double
	Computes the hyperbolic sine of arg.
template<integral T>
constexpr auto	sinh (T arg) noexcept -> double
	Computes the hyperbolic sine of arg.
constexpr auto	sinhf (float arg) noexcept -> float
	Computes the hyperbolic sine of arg.
constexpr auto	sinhl (long double arg) noexcept -> long double
	Computes the hyperbolic sine of arg.
template<typename C >
constexpr auto	size (C const &c) noexcept(noexcept(c.size())) -> decltype(c.size())
	Returns the size of the given container c or array array. Returns c.size(), converted to the return type if necessary.
template<typename T , size_t N>
constexpr auto	size (T const (&array)[N]) noexcept -> size_t
template<typename Type , size_t Size>
	span (array< Type, Size > &) -> span< Type, Size >
template<typename Type , size_t Size>
	span (array< Type, Size > const &) -> span< Type const, Size >
template<typename Type , size_t Extent>
	span (c_array< Type, Extent > &) -> span< Type, Extent >
template<ranges::range R>
	span (R &&) -> span< remove_reference_t< ranges::range_reference_t< R > > >
constexpr auto	sqrt (double arg) noexcept -> double
	Computes the square root of arg.
constexpr auto	sqrt (float arg) noexcept -> float
	Computes the square root of arg.
constexpr auto	sqrt (long double arg) noexcept -> long double
	Computes the square root of arg.
template<integral T>
constexpr auto	sqrt (T arg) noexcept -> double
	Computes the square root of arg.
constexpr auto	sqrtf (float arg) noexcept -> float
	Computes the square root of arg.
constexpr auto	sqrtl (long double arg) noexcept -> long double
	Computes the square root of arg.
template<typename C >
constexpr auto	ssize (C const &c) -> common_type_t< ptrdiff_t, make_signed_t< decltype(c.size())> >
template<typename T , ptrdiff_t N>
constexpr auto	ssize (T const (&array)[static_cast< size_t >(N)]) noexcept -> ptrdiff_t
template<typename BidirIt , typename Predicate >
constexpr auto	stable_partition (BidirIt f, BidirIt l, Predicate p) -> BidirIt
	Reorders the elements in the range [first, last) in such a way that all elements for which the predicate p returns true precede the elements for which predicate p returns false. Relative order of the elements is preserved.
template<typename Container >
	stack (Container) -> stack< typename Container::value_type, Container >
template<size_t Capacity>
constexpr auto	stod (inplace_string< Capacity > const &str, size_t *pos=nullptr) -> double
	Interprets a floating point value in a string str.
template<size_t Capacity>
constexpr auto	stof (inplace_string< Capacity > const &str, size_t *pos=nullptr) -> float
	Interprets a floating point value in a string str.
constexpr auto	stoi (etl::string_view str, etl::size_t *pos=nullptr, int base=10) -> int
	Interprets a signed integer value in the string str.
constexpr auto	stol (etl::string_view str, etl::size_t *pos=nullptr, int base=10) -> long
	Interprets a signed integer value in the string str.
template<size_t Capacity>
constexpr auto	stold (inplace_string< Capacity > const &str, size_t *pos=nullptr) -> long double
	Interprets a floating point value in a string str.
constexpr auto	stoll (etl::string_view str, etl::size_t *pos=nullptr, int base=10) -> long long
	Interprets a signed integer value in the string str.
constexpr auto	stoul (etl::string_view str, etl::size_t *pos=nullptr, int base=10) -> unsigned long
	Interprets a signed integer value in the string str.
constexpr auto	stoull (etl::string_view str, etl::size_t *pos=nullptr, int base=10) -> unsigned long long
	Interprets a signed integer value in the string str.
constexpr auto	strcat (char *dest, char const *src) noexcept -> char *
	Appends a copy of the character string pointed to by src to the end of the character string pointed to by dest. The character src[0] replaces the null terminator at the end of dest. The resulting byte string is null-terminated.
constexpr auto	strcmp (char const *lhs, char const *rhs) -> int
	Compares the C string lhs to the C string rhs.
constexpr auto	strcpy (char *dest, char const *src) -> char *
	Copies the character string pointed to by src, including the null terminator, to the character array whose first element is pointed to by dest.
constexpr auto	strcspn (char const *dest, char const *src) noexcept -> etl::size_t
	Returns the length of the maximum initial segment of the byte string pointed to by dest, that consists of only the characters not found in byte string pointed to by src.
template<typename OffsetType , typename ExtentType , typename StrideType >
	strided_slice (OffsetType, ExtentType, StrideType) -> strided_slice< OffsetType, ExtentType, StrideType >
constexpr auto	strlen (char const *str) -> etl::size_t
	Returns the length of the C string str.
constexpr auto	strncat (char *dest, char const *src, etl::size_t const count) -> char *
	Appends a byte string pointed to by src to a byte string pointed to by dest. At most count characters are copied. The resulting byte string is null-terminated.
constexpr auto	strncmp (char const *lhs, char const *rhs, etl::size_t count) -> int
	Compares at most count characters of two possibly null-terminated arrays. The comparison is done lexicographically. Characters following the null character are not compared.
constexpr auto	strncpy (char *dest, char const *src, etl::size_t const count) -> char *
	Copies at most count characters of the byte string pointed to by src (including the terminating null character) to character array pointed to by dest.
constexpr auto	strspn (char const *dest, char const *src) noexcept -> etl::size_t
	Returns the length of the maximum initial segment (span) of the byte string pointed to by dest, that consists of only the characters found in byte string pointed to by src.
constexpr auto	strtod (char const *str, char const **last=nullptr) noexcept -> double
	Interprets a floating point value in a byte string pointed to by str.
constexpr auto	strtof (char const *str, char const **last=nullptr) noexcept -> float
	Interprets a floating point value in a byte string pointed to by str.
constexpr auto	strtol (char const *str, char const **last, int base) noexcept -> long
	Interprets an integer value in a byte string pointed to by str.
constexpr auto	strtold (char const *str, char const **last=nullptr) noexcept -> long double
	Interprets a floating point value in a byte string pointed to by str.
constexpr auto	strtoll (char const *str, char const **last, int base) noexcept -> long long
	Interprets an integer value in a byte string pointed to by str.
constexpr auto	strtoul (char const *str, char const **last, int base) noexcept -> unsigned long
	Interprets an integer value in a byte string pointed to by str.
constexpr auto	strtoull (char const *str, char const **last, int base) noexcept -> unsigned long long
	Interprets an integer value in a byte string pointed to by str.
template<typename IndexT , etl::size_t... Extents, typename... SliceSpecifiers> requires (sizeof...(slices) == etl::extents<IndexT, Extents...>::rank())
constexpr auto	submdspan_extents (etl::extents< IndexT, Extents... > const &ext, SliceSpecifiers... slices)
template<typename Char , typename Traits , etl::size_t Capacity>
constexpr auto	swap (etl::basic_inplace_string< Char, Capacity, Traits > &lhs, etl::basic_inplace_string< Char, Capacity, Traits > &rhs) noexcept(noexcept(lhs.swap(rhs))) -> void
	Specializes the etl::swap algorithm for etl::basic_inplace_string. Swaps the contents of lhs and rhs. Equivalent to lhs.swap(rhs).
template<typename R , typename... Args, size_t Capacity, size_t Alignment>
auto	swap (inplace_function< R(Args...), Capacity, Alignment > &lhs, inplace_function< R(Args...), Capacity, Alignment > &rhs) noexcept -> void
	Overloads the etl::swap algorithm for etl::inplace_function. Exchanges the state of lhs with that of rhs. Effectively calls lhs.swap(rhs).
template<typename T1 , typename T2 >
constexpr auto	swap (pair< T1, T2 > &lhs, pair< T1, T2 > &rhs) noexcept(noexcept(lhs.swap(rhs))) -> void
	Swaps the contents of x and y. Equivalent to x.swap(y).
template<typename T , typename C > requires (is_swappable_v<C>)
constexpr auto	swap (stack< T, C > &lhs, stack< T, C > &rhs) noexcept(noexcept(lhs.swap(rhs))) -> void
	Specializes the swap algorithm for stack. Swaps the contents of lhs and rhs. This overload only participates in overload resolution if is_swappable<C>::value is true.
template<typename Key , size_t Capacity, typename Compare >
constexpr auto	swap (static_set< Key, Capacity, Compare > &lhs, static_set< Key, Capacity, Compare > &rhs) noexcept(noexcept(lhs.swap(rhs))) -> void
	Specializes the swap algorithm for set. Swaps the contents of lhs and rhs. Calls lhs.swap(rhs).
template<typename T , size_t Capacity>
constexpr auto	swap (static_vector< T, Capacity > &lhs, static_vector< T, Capacity > &rhs) noexcept -> void
	Specializes the swap algorithm for static_vector. Swaps the contents of lhs and rhs.
template<typename T >
constexpr auto	swap (T &a, T &b) noexcept -> void
	Exchanges the given values. Swaps the values a and b. This overload does not participate in overload resolution unless etl::is_move_constructible_v<T> && etl::is_move_assignable_v<T> is true.
template<typename T > requires (etl::is_move_constructible_v<T> && etl::is_move_assignable_v<T>)
constexpr auto	swap (T &a, T &b) noexcept(etl::is_nothrow_move_constructible_v< T > &&etl::is_nothrow_move_assignable_v< T >) -> void
	Exchanges the given values. Swaps the values a and b. This overload does not participate in overload resolution unless etl::is_move_constructible_v<T> && etl::is_move_assignable_v<T> is true.
template<typename T > requires (etl::is_move_constructible_v<T> and etl::is_move_assignable_v<T>)
constexpr auto	swap (T &a, T &b) noexcept(etl::is_nothrow_move_constructible_v< T > and etl::is_nothrow_move_assignable_v< T >) -> void
	Exchanges the given values. Swaps the values a and b. This overload does not participate in overload resolution unless etl::is_move_constructible_v<T> && etl::is_move_assignable_v<T> is true.
template<typename T , etl::size_t N> requires (etl::is_swappable<T>::value)
constexpr auto	swap (T(&a)[N], T(&b)[N]) noexcept(etl::is_nothrow_swappable< T >::value) -> void
template<typename T , etl::size_t N> requires (etl::is_swappable_v<T>)
constexpr auto	swap (T(&a)[N], T(&b)[N]) noexcept(etl::is_nothrow_swappable< T >::value) -> void
template<typename ForwardIt1 , typename ForwardIt2 >
constexpr auto	swap_ranges (ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2) -> ForwardIt2
	Exchanges elements between range [first1 ,last1) and another range starting at first2.
template<typename T >
constexpr auto	tan (complex< T > const &z) -> complex< T >
template<typename T >
constexpr auto	tanh (complex< T > const &z) -> complex< T >
template<etl::size_t Pos, etl::builtin_unsigned_integer UInt>
constexpr auto	test_bit (UInt word) noexcept -> bool
	Test bit at position Pos
template<etl::builtin_unsigned_integer UInt>
constexpr auto	test_bit (UInt word, UInt pos) noexcept -> bool
	Test bit at position pos.
template<typename T >
void	test_implicit_default_constructible (T)
template<typename... Args>
constexpr auto	tie (Args &... args) noexcept -> tuple< Args &... >
template<typename Ptr >
constexpr auto	to_address (Ptr const &ptr) noexcept
	Obtain the address represented by p without forming a reference to the object pointed to by p.
template<typename T > requires (not is_function_v<T>)
constexpr auto	to_address (T *ptr) noexcept -> T *
	Obtain the address represented by p without forming a reference to the object pointed to by p.
constexpr auto	to_chars (char *, char *, bool, int=10) -> to_chars_result=delete
template<integral T> requires (not same_as<T, bool>)
constexpr auto	to_chars (char *first, char *last, T val, int base=10) -> to_chars_result
	Converts value into a character string by successively filling the range [first, last), where [first, last) is required to be a valid range.
template<etl::integral Int>
constexpr auto	to_integer (etl::byte b) noexcept -> Int
	Equivalent to: return Int(b);
template<etl::size_t Capacity>
constexpr auto	to_string (int value) noexcept -> etl::inplace_string< Capacity >
	Converts a numeric value to etl::inplace_string.
template<etl::size_t Capacity>
constexpr auto	to_string (long long value) noexcept -> etl::inplace_string< Capacity >
	Converts a numeric value to etl::inplace_string.
template<etl::size_t Capacity>
constexpr auto	to_string (long value) noexcept -> etl::inplace_string< Capacity >
	Converts a numeric value to etl::inplace_string.
template<etl::size_t Capacity>
constexpr auto	to_string (unsigned long long value) noexcept -> etl::inplace_string< Capacity >
	Converts a numeric value to etl::inplace_string.
template<etl::size_t Capacity>
constexpr auto	to_string (unsigned long value) noexcept -> etl::inplace_string< Capacity >
	Converts a numeric value to etl::inplace_string.
template<etl::size_t Capacity>
constexpr auto	to_string (unsigned value) noexcept -> etl::inplace_string< Capacity >
	Converts a numeric value to etl::inplace_string.
template<typename Enum >
constexpr auto	to_underlying (Enum e) noexcept -> underlying_type_t< Enum >
	Converts an enumeration to its underlying type.
constexpr auto	tolower (int ch) noexcept -> int
	Converts the given character to lowercase according to the character conversion rules defined by the default C locale.
constexpr auto	toupper (int ch) noexcept -> int
	Converts the given character to uppercase according to the character conversion rules defined by the default C locale.
constexpr auto	towlower (wint_t ch) noexcept -> wint_t
	Converts the given wide character to lowercase, if possible.
constexpr auto	towupper (wint_t ch) noexcept -> wint_t
	Converts the given wide character to uppercase, if possible.
template<typename InputIt , typename T , typename BinaryReductionOp , typename UnaryTransformOp >
constexpr auto	transform_reduce (InputIt first, InputIt last, T init, BinaryReductionOp reduce, UnaryTransformOp transform) -> T
	https://en.cppreference.com/w/cpp/algorithm/transform_reduce
template<typename InputIt1 , typename InputIt2 , typename T >
constexpr auto	transform_reduce (InputIt1 first1, InputIt1 last1, InputIt2 first2, T init) -> T
	https://en.cppreference.com/w/cpp/algorithm/transform_reduce
template<typename InputIt1 , typename InputIt2 , typename T , typename BinaryReductionOp , typename BinaryTransformOp >
constexpr auto	transform_reduce (InputIt1 first1, InputIt1 last1, InputIt2 first2, T init, BinaryReductionOp reduce, BinaryTransformOp transform) -> T
	https://en.cppreference.com/w/cpp/algorithm/transform_reduce
template<etl::tuple_like... Tuples>
constexpr auto	tuple_cat (Tuples &&... ts)
template<etl::size_t I, typename... Ts>
constexpr auto	unchecked_get (variant< Ts... > &&v) -> auto &&
template<etl::size_t I, typename... Ts>
constexpr auto	unchecked_get (variant< Ts... > &v) -> auto &
template<etl::size_t I, typename... Ts>
constexpr auto	unchecked_get (variant< Ts... > const &&v) -> auto const &&
template<etl::size_t I, typename... Ts>
constexpr auto	unchecked_get (variant< Ts... > const &v) -> auto const &
template<typename E >
	unexpected (E) -> unexpected< E >
template<typename InputIt , typename NoThrowForwardIt >
constexpr auto	uninitialized_copy (InputIt first, InputIt last, NoThrowForwardIt dest) -> NoThrowForwardIt
template<typename ForwardIt , typename T >
constexpr auto	uninitialized_fill (ForwardIt first, ForwardIt last, T const &value) -> void
template<typename InputIt , typename NoThrowForwardIt >
constexpr auto	uninitialized_move (InputIt first, InputIt last, NoThrowForwardIt dest) -> NoThrowForwardIt
auto	unreachable () -> void
template<typename OutputIt >
auto	vformat_to (OutputIt out, string_view fmt, format_args args) -> OutputIt
constexpr auto	wcscat (wchar_t *dest, wchar_t const *src) -> wchar_t *
	Appends a copy of the wide string pointed to by src to the end of the wide string pointed to by dest. The wide character src[0] replaces the null terminator at the end of dest. The resulting wide string is null-terminated.
constexpr auto	wcschr (wchar_t *str, int ch) -> wchar_t *
	Finds the first occurrence of the wide character ch in the wide string pointed to by str.
constexpr auto	wcschr (wchar_t const *str, int ch) -> wchar_t const *
	Finds the first occurrence of the wide character ch in the wide string pointed to by str.
constexpr auto	wcscmp (wchar_t const *lhs, wchar_t const *rhs) -> int
	Compares two null-terminated wide strings lexicographically.
constexpr auto	wcscpy (wchar_t *dest, wchar_t const *src) -> wchar_t *
	Copies the wide string pointed to by src (including the terminating null wide character) to wide character array pointed to by dest.
constexpr auto	wcscspn (wchar_t const *dest, wchar_t const *src) noexcept -> etl::size_t
	Returns the length of the maximum initial segment of the wide string pointed to by dest, that consists of only the characters not found in wide string pointed to by src.
constexpr auto	wcslen (wchar_t const *str) -> size_t
	Returns the length of a wide string, that is the number of non-null wide characters that precede the terminating null wide character.
constexpr auto	wcsncat (wchar_t *dest, wchar_t const *src, etl::size_t const count) -> wchar_t *
	Appends at most count wide characters from the wide string pointed to by src to the end of the character string pointed to by dest, stopping if the null terminator is copied. The wide character src[0] replaces the null terminator at the end of dest. The null terminator is always appended in the end (so the maximum number of wide characters the function may write is count+1).
constexpr auto	wcsncmp (wchar_t const *lhs, wchar_t const *rhs, etl::size_t count) -> int
	Compares at most count wide characters of two null-terminated wide strings. The comparison is done lexicographically.
constexpr auto	wcsncpy (wchar_t *dest, wchar_t const *src, etl::size_t const count) -> wchar_t *
	Copies at most count characters of the wide string pointed to by src (including the terminating null wide character) to wide character array pointed to by dest.
constexpr auto	wcspbrk (wchar_t *dest, wchar_t *breakset) noexcept -> wchar_t *
	Finds the first character in wide string pointed to by dest, that is also in wide string pointed to by str.
constexpr auto	wcspbrk (wchar_t const *dest, wchar_t const *breakset) noexcept -> wchar_t const *
	Finds the first character in wide string pointed to by dest, that is also in wide string pointed to by str.
constexpr auto	wcsrchr (wchar_t *str, int ch) -> wchar_t *
	Finds the last occurrence of the wide character ch in the wide string pointed to by str.
constexpr auto	wcsrchr (wchar_t const *str, int ch) -> wchar_t const *
	Finds the last occurrence of the wide character ch in the wide string pointed to by str.
constexpr auto	wcsspn (wchar_t const *dest, wchar_t const *src) noexcept -> etl::size_t
	Returns the length of the maximum initial segment of the wide string pointed to by dest, that consists of only the characters found in wide string pointed to by src.
constexpr auto	wcsstr (wchar_t *haystack, wchar_t *needle) noexcept -> wchar_t *
	Finds the first occurrence of the wide string needle in the wide string pointed to by haystack. The terminating null characters are not compared.
constexpr auto	wcsstr (wchar_t const *haystack, wchar_t const *needle) noexcept -> wchar_t const *
	Finds the first occurrence of the wide string needle in the wide string pointed to by haystack. The terminating null characters are not compared.
constexpr auto	wmemchr (wchar_t *ptr, wchar_t ch, etl::size_t count) noexcept -> wchar_t *
	Locates the first occurrence of wide character ch in the initial count wide characters of the wide character array pointed to by ptr.
constexpr auto	wmemchr (wchar_t const *ptr, wchar_t ch, etl::size_t count) noexcept -> wchar_t const *
	Locates the first occurrence of wide character ch in the initial count wide characters of the wide character array pointed to by ptr.
constexpr auto	wmemcmp (wchar_t const *lhs, wchar_t const *rhs, etl::size_t count) noexcept -> int
	Compares the first count wide characters of the wide character arrays pointed to by lhs and rhs. The comparison is done lexicographically.
constexpr auto	wmemcpy (wchar_t *dest, wchar_t const *src, etl::size_t count) noexcept -> wchar_t *
	Copies exactly count successive wide characters from the wide character array pointed to by src to the wide character array pointed to by dest. If the objects overlap, the behavior is undefined. If count is zero, the function does nothing.
constexpr auto	wmemmove (wchar_t *dest, wchar_t const *src, etl::size_t count) noexcept -> wchar_t *
	Copies exactly count successive wide characters from the wide character array pointed to by src to the wide character array pointed to by dest.
constexpr auto	wmemset (wchar_t *dest, wchar_t ch, etl::size_t count) noexcept -> wchar_t *
	Copies the wide character ch into each of the first count wide characters of the wide character array pointed to by dest.
template<typename ForwardIt , typename Predicate >
constexpr auto	adjacent_find (ForwardIt first, ForwardIt last, Predicate pred) -> ForwardIt
	Searches the range [first, last) for two consecutive equal elements. Elements are compared using the given binary predicate p.
template<typename ForwardIt >
constexpr auto	adjacent_find (ForwardIt first, ForwardIt last) -> ForwardIt
	Searches the range [first, last) for two consecutive equal elements. Elements are compared using the given binary predicate p.
template<typename InputIt , typename Predicate >
constexpr auto	all_of (InputIt first, InputIt last, Predicate p) -> bool
	Checks if unary predicate p returns true for all elements in the range [first, last).
template<typename InputIt , typename Predicate >
constexpr auto	any_of (InputIt first, InputIt last, Predicate p) -> bool
	Checks if unary predicate p returns true for at least one element in the range [first, last).
template<typename ForwardIt , typename T , typename Compare >
constexpr auto	binary_search (ForwardIt first, ForwardIt last, T const &value, Compare comp) -> bool
template<typename ForwardIt , typename T >
constexpr auto	binary_search (ForwardIt first, ForwardIt last, T const &value) -> bool
template<typename RandomIt , typename Compare >
constexpr auto	bubble_sort (RandomIt first, RandomIt last, Compare comp) -> void
	Sorts the elements in the range [first, last) in non-descending order. The order of equal elements is guaranteed to be preserved.
template<typename RandomIt >
constexpr auto	bubble_sort (RandomIt first, RandomIt last) -> void
	Sorts the elements in the range [first, last) in non-descending order. The order of equal elements is guaranteed to be preserved.
template<typename Type , typename Compare >
constexpr auto	clamp (Type const &v, Type const &lo, Type const &hi, Compare comp) -> Type const &
	If v compares less than lo, returns lo; otherwise if hi compares less than v, returns hi; otherwise returns v. Uses operator< to compare the values.
template<typename Type >
constexpr auto	clamp (Type const &v, Type const &lo, Type const &hi) noexcept -> Type const &
	If v compares less than lo, returns lo; otherwise if hi compares less than v, returns hi; otherwise returns v. Uses operator< to compare the values.
template<typename BidirIt , typename Compare >
constexpr auto	merge_sort (BidirIt first, BidirIt last, Compare comp) -> void
	Sorts the elements in the range [first, last) in non-descending order.
template<typename BidirIt >
constexpr auto	merge_sort (BidirIt first, BidirIt last) -> void
	Sorts the elements in the range [first, last) in non-descending order.
template<typename FwdIt1 , typename FwdIt2 , typename Predicate >
constexpr auto	search (FwdIt1 first, FwdIt1 last, FwdIt2 sFirst, FwdIt2 sLast, Predicate pred) -> FwdIt1
template<typename FwdIt1 , typename FwdIt2 >
constexpr auto	search (FwdIt1 first, FwdIt1 last, FwdIt2 sFirst, FwdIt2 sLast) -> FwdIt1
template<typename FwdIt , typename Searcher >
constexpr auto	search (FwdIt first, FwdIt last, Searcher const &searcher) -> FwdIt
template<typename ForwardIt , typename Size , typename ValueT , typename Predicate >
constexpr auto	search_n (ForwardIt first, ForwardIt last, Size count, ValueT const &value, Predicate pred) -> ForwardIt
	Searches the range [first, last) for the first sequence of count identical elements, each equal to the given value.
template<typename ForwardIt , typename Size , typename ValueT >
constexpr auto	search_n (ForwardIt first, ForwardIt last, Size count, ValueT const &value) -> ForwardIt
	Searches the range [first, last) for the first sequence of count identical elements, each equal to the given value.
template<typename InputIt1 , typename InputIt2 , typename OutputIt , typename Compare >
constexpr auto	set_difference (InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, OutputIt destination, Compare comp) -> OutputIt
	Copies the elements from the sorted range [first1, last1) which are not found in the sorted range [first2, last2) to the range beginning at destination. Elements are compared using the given binary comparison function comp and the ranges must be sorted with respect to the same.
template<typename InputIt1 , typename InputIt2 , typename OutputIt >
constexpr auto	set_difference (InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, OutputIt destination) -> OutputIt
	Copies the elements from the sorted range [first1, last1) which are not found in the sorted range [first2, last2) to the range beginning at destination. Elements are compared using the given binary comparison function comp and the ranges must be sorted with respect to the same.
template<typename InputIt1 , typename InputIt2 , typename OutputIt , typename Compare >
constexpr auto	set_intersection (InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, OutputIt dest, Compare comp) -> OutputIt
	Constructs a sorted range beginning at dest consisting of elements that are found in both sorted ranges [first1, last1) and [first2, last2). If some element is found m times in [first1, last1) and n times in [first2, last2), the first min(m, n) elements will be copied from the first range to the destination range. The order of equivalent elements is preserved. The resulting range cannot overlap with either of the input ranges.
template<typename InputIt1 , typename InputIt2 , typename OutputIt >
constexpr auto	set_intersection (InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, OutputIt dest) -> OutputIt
	Constructs a sorted range beginning at dest consisting of elements that are found in both sorted ranges [first1, last1) and [first2, last2). If some element is found m times in [first1, last1) and n times in [first2, last2), the first min(m, n) elements will be copied from the first range to the destination range. The order of equivalent elements is preserved. The resulting range cannot overlap with either of the input ranges.
template<typename InputIt1 , typename InputIt2 , typename OutputIt , typename Compare >
constexpr auto	set_symmetric_difference (InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, OutputIt destination, Compare comp) -> OutputIt
template<typename InputIt1 , typename InputIt2 , typename OutputIt >
constexpr auto	set_symmetric_difference (InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, OutputIt dest) -> OutputIt
template<typename InputIt1 , typename InputIt2 , typename OutputIt , typename Compare >
constexpr auto	set_union (InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, OutputIt destination, Compare comp) -> OutputIt
	Constructs a sorted union beginning at destination consisting of the set of elements present in one or both sorted ranges [first1, last1) and [first2, last2). The resulting range cannot overlap with either of the input ranges.
template<typename InputIt1 , typename InputIt2 , typename OutputIt >
constexpr auto	set_union (InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, OutputIt destination) -> OutputIt
	Constructs a sorted union beginning at destination consisting of the set of elements present in one or both sorted ranges [first1, last1) and [first2, last2). The resulting range cannot overlap with either of the input ranges.
template<typename RandomIt , typename Compare >
constexpr auto	sort (RandomIt first, RandomIt last, Compare comp) -> void
template<typename RandomIt >
constexpr auto	sort (RandomIt first, RandomIt last) -> void
template<typename RandomIt , typename Compare >
constexpr auto	stable_sort (RandomIt first, RandomIt last, Compare comp) -> void
template<typename RandomIt >
constexpr auto	stable_sort (RandomIt first, RandomIt last) -> void
template<typename InputIt , typename OutputIt , typename UnaryOp >
constexpr auto	transform (InputIt first, InputIt last, OutputIt dest, UnaryOp op) -> OutputIt
template<typename InputIt1 , typename InputIt2 , typename OutputIt , typename BinaryOp >
constexpr auto	transform (InputIt1 first1, InputIt1 last1, InputIt2 first2, OutputIt dest, BinaryOp op) -> OutputIt
template<typename ForwardIt , typename Predicate >
constexpr auto	unique (ForwardIt first, ForwardIt last, Predicate pred) -> ForwardIt
template<typename ForwardIt >
constexpr auto	unique (ForwardIt first, ForwardIt last) -> ForwardIt
template<typename InputIt , typename OutputIt , typename Predicate >
constexpr auto	unique_copy (InputIt first, InputIt last, OutputIt destination, Predicate pred) -> OutputIt
template<typename InputIt , typename OutputIt >
constexpr auto	unique_copy (InputIt first, InputIt last, OutputIt destination) -> OutputIt
template<typename ForwardIt , typename T , typename Compare >
constexpr auto	upper_bound (ForwardIt first, ForwardIt last, T const &value, Compare comp) -> ForwardIt
template<typename ForwardIt , typename T >
constexpr auto	upper_bound (ForwardIt first, ForwardIt last, T const &value) -> ForwardIt
constexpr auto	acos (float arg) noexcept -> float
constexpr auto	acosf (float arg) noexcept -> float
constexpr auto	acos (double arg) noexcept -> double
constexpr auto	acos (long double arg) noexcept -> long double
constexpr auto	acosl (long double arg) noexcept -> long double
constexpr auto	acos (integral auto arg) noexcept -> double
constexpr auto	acosh (float arg) noexcept -> float
constexpr auto	acoshf (float arg) noexcept -> float
constexpr auto	acosh (double arg) noexcept -> double
constexpr auto	acosh (long double arg) noexcept -> long double
constexpr auto	acoshl (long double arg) noexcept -> long double
constexpr auto	acosh (integral auto arg) noexcept -> double
constexpr auto	asin (float arg) noexcept -> float
constexpr auto	asinf (float arg) noexcept -> float
constexpr auto	asin (double arg) noexcept -> double
constexpr auto	asin (long double arg) noexcept -> long double
constexpr auto	asinl (long double arg) noexcept -> long double
constexpr auto	asin (integral auto arg) noexcept -> double
constexpr auto	asinh (float arg) noexcept -> float
constexpr auto	asinhf (float arg) noexcept -> float
constexpr auto	asinh (double arg) noexcept -> double
constexpr auto	asinh (long double arg) noexcept -> long double
constexpr auto	asinhl (long double arg) noexcept -> long double
constexpr auto	asinh (integral auto arg) noexcept -> double
constexpr auto	atan (float arg) noexcept -> float
constexpr auto	atanf (float arg) noexcept -> float
constexpr auto	atan (double arg) noexcept -> double
constexpr auto	atan (long double arg) noexcept -> long double
constexpr auto	atanl (long double arg) noexcept -> long double
constexpr auto	atan (integral auto arg) noexcept -> double
constexpr auto	atan2 (float x, float y) noexcept -> float
constexpr auto	atan2f (float x, float y) noexcept -> float
constexpr auto	atan2 (double x, double y) noexcept -> double
constexpr auto	atan2 (long double x, long double y) noexcept -> long double
constexpr auto	atan2l (long double x, long double y) noexcept -> long double
constexpr auto	atanh (float arg) noexcept -> float
constexpr auto	atanhf (float arg) noexcept -> float
constexpr auto	atanh (double arg) noexcept -> double
constexpr auto	atanh (long double arg) noexcept -> long double
constexpr auto	atanhl (long double arg) noexcept -> long double
constexpr auto	atanh (integral auto arg) noexcept -> double
constexpr auto	beta (double x, double y) noexcept -> double
constexpr auto	betaf (float x, float y) noexcept -> float
constexpr auto	betal (long double x, long double y) noexcept -> long double
constexpr auto	ceil (float arg) noexcept -> float
constexpr auto	ceilf (float arg) noexcept -> float
constexpr auto	ceil (double arg) noexcept -> double
constexpr auto	ceil (long double arg) noexcept -> long double
constexpr auto	ceill (long double arg) noexcept -> long double
constexpr auto	ceil (integral auto arg) noexcept -> double
constexpr auto	copysign (float mag, float sgn) -> float
constexpr auto	copysignf (float mag, float sgn) -> float
constexpr auto	copysign (double mag, double sgn) -> double
constexpr auto	copysign (long double mag, long double sgn) -> long double
constexpr auto	copysignl (long double mag, long double sgn) -> long double
constexpr auto	cos (float arg) noexcept -> float
constexpr auto	cosf (float arg) noexcept -> float
constexpr auto	cos (double arg) noexcept -> double
constexpr auto	cos (long double arg) noexcept -> long double
constexpr auto	cosl (long double arg) noexcept -> long double
constexpr auto	cos (integral auto arg) noexcept -> double
constexpr auto	cosh (float arg) noexcept -> float
constexpr auto	coshf (float arg) noexcept -> float
constexpr auto	cosh (double arg) noexcept -> double
constexpr auto	cosh (long double arg) noexcept -> long double
constexpr auto	coshl (long double arg) noexcept -> long double
constexpr auto	cosh (integral auto arg) noexcept -> double
constexpr auto	erf (float arg) noexcept -> float
constexpr auto	erff (float arg) noexcept -> float
constexpr auto	erf (double arg) noexcept -> double
constexpr auto	erf (long double arg) noexcept -> long double
constexpr auto	erfl (long double arg) noexcept -> long double
constexpr auto	erf (integral auto arg) noexcept -> double
constexpr auto	exp (float arg) noexcept -> float
constexpr auto	expf (float arg) noexcept -> float
constexpr auto	exp (double arg) noexcept -> double
constexpr auto	exp (long double arg) noexcept -> long double
constexpr auto	expl (long double arg) noexcept -> long double
constexpr auto	exp (integral auto arg) noexcept -> double
constexpr auto	fdim (float x, float y) noexcept -> float
constexpr auto	fdimf (float x, float y) noexcept -> float
constexpr auto	fdim (double x, double y) noexcept -> double
constexpr auto	fdim (long double x, long double y) noexcept -> long double
constexpr auto	fdiml (long double x, long double y) noexcept -> long double
constexpr auto	floor (float arg) noexcept -> float
constexpr auto	floorf (float arg) noexcept -> float
constexpr auto	floor (double arg) noexcept -> double
constexpr auto	floor (long double arg) noexcept -> long double
constexpr auto	floorl (long double arg) noexcept -> long double
constexpr auto	floor (integral auto arg) noexcept -> double
constexpr auto	fma (float x, float y, float z) noexcept -> float
constexpr auto	fmaf (float x, float y, float z) noexcept -> float
constexpr auto	fma (double x, double y, double z) noexcept -> double
constexpr auto	fma (long double x, long double y, long double z) noexcept -> long double
constexpr auto	fmal (long double x, long double y, long double z) noexcept -> long double
constexpr auto	fmax (float x, float y) noexcept -> float
constexpr auto	fmaxf (float x, float y) noexcept -> float
constexpr auto	fmax (double x, double y) noexcept -> double
constexpr auto	fmax (long double x, long double y) noexcept -> long double
constexpr auto	fmaxl (long double x, long double y) noexcept -> long double
constexpr auto	fmin (float x, float y) noexcept -> float
constexpr auto	fminf (float x, float y) noexcept -> float
constexpr auto	fmin (double x, double y) noexcept -> double
constexpr auto	fmin (long double x, long double y) noexcept -> long double
constexpr auto	fminl (long double x, long double y) noexcept -> long double
constexpr auto	fmod (float x, float y) noexcept -> float
constexpr auto	fmodf (float x, float y) noexcept -> float
constexpr auto	fmod (double x, double y) noexcept -> double
constexpr auto	fmod (long double x, long double y) noexcept -> long double
constexpr auto	fmodl (long double x, long double y) noexcept -> long double
constexpr auto	hypot (float x, float y) noexcept -> float
constexpr auto	hypotf (float x, float y) noexcept -> float
constexpr auto	hypot (double x, double y) noexcept -> double
constexpr auto	hypot (long double x, long double y) noexcept -> long double
constexpr auto	hypotl (long double x, long double y) noexcept -> long double
constexpr auto	hypot (float x, float y, float z) noexcept -> float
constexpr auto	hypot (double x, double y, double z) noexcept -> double
constexpr auto	hypot (long double x, long double y, long double z) noexcept -> long double
constexpr auto	log (float v) noexcept -> float
constexpr auto	logf (float v) noexcept -> float
constexpr auto	log (double v) noexcept -> double
constexpr auto	log (long double v) noexcept -> long double
constexpr auto	logl (long double v) noexcept -> long double
constexpr auto	log (integral auto arg) noexcept -> double
constexpr auto	log10 (float arg) noexcept -> float
constexpr auto	log10f (float arg) noexcept -> float
constexpr auto	log10 (double arg) noexcept -> double
constexpr auto	log10 (long double arg) noexcept -> long double
constexpr auto	log10l (long double arg) noexcept -> long double
constexpr auto	log10 (integral auto arg) noexcept -> double
constexpr auto	log1p (float v) noexcept -> float
constexpr auto	log1pf (float v) noexcept -> float
constexpr auto	log1p (double v) noexcept -> double
constexpr auto	log1p (long double v) noexcept -> long double
constexpr auto	log1pl (long double v) noexcept -> long double
constexpr auto	log1p (integral auto arg) noexcept -> double
constexpr auto	log2 (float arg) noexcept -> float
constexpr auto	log2f (float arg) noexcept -> float
constexpr auto	log2 (double arg) noexcept -> double
constexpr auto	log2 (long double arg) noexcept -> long double
constexpr auto	log2l (long double arg) noexcept -> long double
constexpr auto	log2 (integral auto arg) noexcept -> double
constexpr auto	nanf (char const *arg) noexcept -> float
constexpr auto	nan (char const *arg) noexcept -> double
constexpr auto	nanl (char const *arg) noexcept -> long double
constexpr auto	nextafter (float from, float to) noexcept -> float
constexpr auto	nextafterf (float from, float to) noexcept -> float
constexpr auto	nextafter (double from, double to) noexcept -> double
constexpr auto	round (float arg) noexcept -> float
constexpr auto	roundf (float arg) noexcept -> float
constexpr auto	round (double arg) noexcept -> double
constexpr auto	round (long double arg) noexcept -> long double
constexpr auto	roundl (long double arg) noexcept -> long double
constexpr auto	round (integral auto arg) noexcept -> double
constexpr auto	sin (float arg) noexcept -> float
constexpr auto	sinf (float arg) noexcept -> float
constexpr auto	sin (double arg) noexcept -> double
constexpr auto	sin (long double arg) noexcept -> long double
constexpr auto	sinl (long double arg) noexcept -> long double
constexpr auto	sin (integral auto arg) noexcept -> double
constexpr auto	tan (float arg) noexcept -> float
constexpr auto	tanf (float arg) noexcept -> float
constexpr auto	tan (double arg) noexcept -> double
constexpr auto	tan (long double arg) noexcept -> long double
constexpr auto	tanl (long double arg) noexcept -> long double
constexpr auto	tan (integral auto arg) noexcept -> double
constexpr auto	tanh (float arg) noexcept -> float
constexpr auto	tanhf (float arg) noexcept -> float
constexpr auto	tanh (double arg) noexcept -> double
constexpr auto	tanh (long double arg) noexcept -> long double
constexpr auto	tanhl (long double arg) noexcept -> long double
constexpr auto	tanh (integral auto arg) noexcept -> double
constexpr auto	tgamma (float arg) noexcept -> float
constexpr auto	tgammaf (float arg) noexcept -> float
constexpr auto	tgamma (double arg) noexcept -> double
constexpr auto	tgamma (long double arg) noexcept -> long double
constexpr auto	tgammal (long double arg) noexcept -> long double
constexpr auto	tgamma (integral auto arg) noexcept -> double
constexpr auto	trunc (float arg) noexcept -> float
constexpr auto	truncf (float arg) noexcept -> float
constexpr auto	trunc (double arg) noexcept -> double
constexpr auto	trunc (long double arg) noexcept -> long double
constexpr auto	truncl (long double arg) noexcept -> long double
constexpr auto	trunc (integral auto arg) noexcept -> double
auto	memchr (void *ptr, int ch, etl::size_t n) -> void *
	Converts ch to unsigned char and locates the first occurrence of that value in the initial count characters (each interpreted as unsigned char) of the object pointed to by ptr.
auto	memchr (void const *ptr, int ch, etl::size_t n) -> void const *
	Converts ch to unsigned char and locates the first occurrence of that value in the initial count characters (each interpreted as unsigned char) of the object pointed to by ptr.
constexpr auto	strchr (char const *str, int ch) -> char const *
constexpr auto	strchr (char *str, int ch) -> char *
constexpr auto	strpbrk (char const *dest, char const *breakset) noexcept -> char const *
constexpr auto	strpbrk (char *dest, char *breakset) noexcept -> char *
constexpr auto	strrchr (char const *str, int ch) noexcept -> char const *
constexpr auto	strrchr (char *str, int ch) noexcept -> char *
constexpr auto	strstr (char *haystack, char *needle) noexcept -> char *
constexpr auto	strstr (char const *haystack, char const *needle) noexcept -> char const *

Variables
template<typename T >
constexpr size_t	alignment_of_v = alignment_of<T>::value
constexpr allocator_arg_t	allocator_arg {}
	allocator_arg is a constant of type allocator_arg_t used to disambiguate, at call site, the overloads of the constructors and member functions of allocator-aware objects.
template<typename... T>
constexpr bool	always_false = false
template<typename T >
	and
constexpr auto	binary = binary_t{}
enum TETL_MAY_ALIAS	byte
	etl::byte is a distinct type that implements the concept of byte as specified in the C++ language definition.
template<typename... B>
constexpr bool	conjunction_v = conjunction<B...>::value
constexpr auto	current_implementation = implementation::freestanding
constexpr auto	current_standard = language_standard::cpp_26
	The currently configured C++ standard.
constexpr auto	destroying_delete = destroying_delete_t{}
	Tag type used to identify the destroying delete form of operator delete.
template<typename... B>
constexpr bool	disjunction_v = disjunction<B...>::value
constexpr auto	dynamic_extent = numeric_limits<etl::size_t>::max()
	etl::dynamic_extent is a constant of type etl::size_t that is used to differentiate etl::span of static and dynamic extent.
template<typename T , unsigned N = 0>
constexpr auto	extent_v = static_cast<size_t>(extent<T, N>::value)
constexpr auto	hardware_constructive_interference_size = TETL_CACHELINE_SIZE
	Minimum offset between two objects to avoid false sharing. Guaranteed to be at least alignof(max_align_t).
constexpr auto	hardware_destructive_interference_size = TETL_CACHELINE_SIZE
	Maximum size of contiguous memory to promote true sharing. Guaranteed to be at least alignof(max_align_t).
template<typename T >
constexpr bool	has_unique_object_representations_v = has_unique_object_representations<T>::value
constexpr struct etl::ignore	ignore
template<size_t I>
constexpr auto	index_v = index_constant<I>{}
template<typename T >
constexpr bool	is_abstract_v = __is_abstract(T)
template<typename T >
constexpr bool	is_aggregate_v = __is_aggregate(remove_cv_t<T>)
template<typename T >
constexpr bool	is_arithmetic_v = is_integral_v<T> or is_floating_point_v<T>
template<typename T >
constexpr bool	is_array_v = is_array<T>::value
template<typename T , typename U >
constexpr bool	is_assignable_v = __is_assignable(T, U)
template<typename Base , typename Derived >
constexpr bool	is_base_of_v = is_base_of<Base, Derived>::value
template<typename T >
constexpr auto	is_bitmask_type_v = is_bitmask_type<T>::value
template<typename T >
constexpr bool	is_bounded_array_v = is_bounded_array<T>::value
template<typename T >
constexpr bool	is_class_v = __is_class(T)
template<typename T >
constexpr bool	is_compound_v = not is_fundamental_v<T>
template<typename T >
constexpr bool	is_const_v = is_const<T>::value
template<typename T , typename... Args>
constexpr bool	is_constructible_v = is_constructible<T, Args...>::value
template<typename From , typename To >
constexpr bool	is_convertible_v = is_convertible<From, To>::value
template<typename T >
constexpr bool	is_copy_assignable_v = is_copy_assignable<T>::value
template<typename T >
constexpr bool	is_copy_constructible_v = is_copy_constructible<T>::value
template<typename T >
constexpr bool	is_default_constructible_v = is_default_constructible<T>::value
template<typename T >
constexpr auto	is_destructible_v = is_destructible<T>::value
template<typename T >
constexpr bool	is_empty_v = is_empty<T>::value
template<typename T >
constexpr bool	is_enum_v = __is_enum(T)
template<typename T >
constexpr auto	is_error_condition_enum_v = is_error_condition_enum<T>::value
template<typename T >
constexpr auto	is_etl_array = false
template<typename T , size_t Size>
constexpr auto	is_etl_array< array< T, Size > > = true
template<typename T >
constexpr bool	is_final_v = __is_final(T)
template<typename T >
constexpr bool	is_floating_point_v = is_floating_point<T>::value
template<typename T >
constexpr bool	is_function_v = is_function<T>::value
	Checks whether T is a function type. Types like etl::inplace_function, lambdas, classes with overloaded operator() and pointers to functions don't count as function types. Provides the member constant value which is equal to true, if T is a function type. Otherwise, value is equal to false.
template<typename T >
constexpr bool	is_fundamental_v = is_fundamental<T>::value
template<typename T >
constexpr auto	is_implicit_default_constructible_v = is_implicit_default_constructible<T>::value
template<typename T >
constexpr bool	is_integral_v
template<typename R , typename Fn , typename... ArgTypes>
constexpr auto	is_invocable_r_v = is_invocable_r<R, Fn, ArgTypes...>::value
template<typename Fn , typename... ArgTypes>
constexpr auto	is_invocable_v = is_invocable<Fn, ArgTypes...>::value
template<typename T >
constexpr bool	is_lvalue_reference_v = is_lvalue_reference<T>::value
template<typename T >
constexpr bool	is_member_function_pointer_v = is_member_function_pointer<T>::value
template<typename T >
constexpr bool	is_member_object_pointer_v = is_member_object_pointer<T>::value
template<typename T >
constexpr bool	is_member_pointer_v = is_member_pointer<T>::value
template<typename T >
constexpr bool	is_move_assignable_v = is_move_assignable<T>::value
template<typename T >
constexpr bool	is_move_constructible_v = is_move_constructible<T>::value
template<typename T , typename U >
constexpr bool	is_nothrow_assignable_v = is_nothrow_assignable<T, U>::value
template<typename T , typename... Args>
constexpr bool	is_nothrow_constructible_v = is_nothrow_constructible<T, Args...>::value
template<typename From , typename To >
constexpr bool	is_nothrow_convertible_v = is_nothrow_convertible<From, To>::value
template<typename T >
constexpr bool	is_nothrow_copy_assignable_v = is_nothrow_copy_assignable<T>::value
template<typename T >
constexpr bool	is_nothrow_copy_constructible_v = is_nothrow_copy_constructible<T>::value
template<typename T >
constexpr bool	is_nothrow_default_constructible_v = is_nothrow_default_constructible<T>::value
template<typename T >
constexpr bool	is_nothrow_destructible_v = is_nothrow_destructible<T>::value
template<typename T >
constexpr bool	is_nothrow_move_assignable_v = is_nothrow_move_assignable<T>::value
template<typename T >
constexpr bool	is_nothrow_move_constructible_v = is_nothrow_move_constructible<T>::value
template<typename T >
constexpr bool	is_nothrow_swappable_v = is_nothrow_swappable<T>::value
template<typename T >
constexpr bool	is_null_pointer_v = is_null_pointer<T>::value
template<typename T >
constexpr bool	is_object_v = is_object<T>::value
template<typename T >
constexpr int	is_placeholder_v = is_placeholder<T>::value
template<typename T >
constexpr bool	is_pointer_v = is_pointer<T>::value
template<typename T >
constexpr bool	is_polymorphic_v = __is_polymorphic(T)
template<typename T >
constexpr bool	is_reference_v = is_reference<T>::value
template<typename T >
constexpr bool	is_reference_wrapper_v = is_reference_wrapper<T>::value
template<typename T >
constexpr bool	is_rvalue_reference_v = is_rvalue_reference<T>::value
template<typename T , typename U >
constexpr bool	is_same_v = is_same<T, U>::value
template<typename T >
constexpr bool	is_scalar_v = is_scalar<T>::value
template<typename T >
constexpr bool	is_scoped_enum_v = is_scoped_enum<T>::value
	Checks whether T is an scoped enumeration type. Provides the member constant value which is equal to true, if T is an scoped enumeration type. Otherwise, value is equal to false. The behavior of a program that adds specializations for is_scoped_enum or is_scoped_enum_v is undefined.
template<typename T >
constexpr bool	is_signed_v = is_signed<T>::value
template<template< typename... > typename Template, typename T , typename Tag = void>
constexpr bool	is_specialized_v = is_specialized<Template, T, Tag>::value
template<typename T >
constexpr bool	is_standard_layout_v = is_standard_layout<T>::value
template<typename T >
constexpr bool	is_swappable_v = is_swappable<T>::value
template<typename T , typename U >
constexpr bool	is_swappable_with_v = is_swappable_with<T, U>::value
template<typename T >
constexpr bool	is_trivial_v = is_trivial<T>::value
template<typename T , typename U >
constexpr bool	is_trivially_assignable_v = is_trivially_assignable<T, U>::value
template<typename T , typename... Args>
constexpr bool	is_trivially_constructible_v = is_trivially_constructible<T, Args...>::value
template<typename T >
constexpr bool	is_trivially_copy_assignable_v = is_trivially_copy_assignable<T>::value
template<typename T >
constexpr bool	is_trivially_copy_constructible_v = is_trivially_copy_constructible<T>::value
template<typename T >
constexpr bool	is_trivially_copyable_v = __is_trivially_copyable(T)
template<typename T >
constexpr bool	is_trivially_default_constructible_v = is_trivially_default_constructible<T>::value
template<typename T >
constexpr bool	is_trivially_destructible_v = __has_trivial_destructor(T)
template<typename T >
constexpr bool	is_trivially_move_assignable_v = is_trivially_move_assignable<T>::value
template<typename T >
constexpr auto	is_trivially_move_constructible_v = is_trivially_move_constructible<T>::value
template<typename T >
constexpr auto	is_tuple_like = false
template<typename T >
constexpr bool	is_unbounded_array_v = is_unbounded_array<T>::value
template<typename T >
constexpr bool	is_union_v = __is_union(T)
template<typename T >
constexpr bool	is_unsigned_v = is_unsigned<T>::value
template<typename T >
constexpr bool	is_void_v = is_same_v<void, remove_cv_t<T>>
template<typename T >
constexpr bool	is_volatile_v = is_volatile<T>::value
template<typename B >
constexpr bool	negation_v = not static_cast<bool>(B::value)
template<auto V>
constexpr auto	nontype = etl::nontype_t<V>{}
constexpr auto	nothrow = etl::nothrow_t{}
	etl::nothrow is a constant of type etl::nothrow_t used to disambiguate the overloads of throwing and non-throwing allocation functions.
constexpr auto	piecewise_construct = piecewise_construct_t{}
	The constant etl::piecewise_construct is an instance of an empty struct tag type etl::piecewise_construct_t.
template<typename Type >
constexpr size_t	rank_v = rank<Type>::value
template<typename R1 , typename R2 >
constexpr bool	ratio_greater_v = ratio_greater<R1, R2>::value
template<typename R1 , typename R2 >
constexpr bool	ratio_less_equal_v = ratio_less_equal<R1, R2>::value
template<typename R1 , typename R2 >
constexpr bool	ratio_less_v = ratio_less<R1, R2>::value
template<typename R1 , typename R2 >
constexpr bool	ratio_not_equal_v = ratio_not_equal<R1, R2>::value
constexpr auto	sorted_equivalent = sorted_equivalent_t{}
constexpr auto	sorted_unique = sorted_unique_t{}
template<typename T >
constexpr auto	tuple_size_v = tuple_size<T>::value
template<typename Type , typename Alloc >
constexpr auto	uses_allocator_v = uses_allocator<Type, Alloc>::value
	If T has a member typedef allocator_type which is convertible from Alloc, the member constant value is true. Otherwise value is false.
template<typename T >
constexpr auto	variant_size_v = variant_size<T>::value

Typedef Documentation

aligned_storage_t

template<size_t Len, size_t Align = alignof(detail::aligned_storage_impl<Len>)>

using aligned_storage_t = typename aligned_storage<Len, Align>::type

aligned_union_t

template<size_t Len, typename... Types>

using aligned_union_t = typename aligned_union<Len, Types...>::type

atto

using atto = ratio<1, 1'000'000'000'000'000'000>

bool_constant

template<bool B>

using bool_constant = integral_constant<bool, B>

centi

using centi = ratio<1, 100>

clock_t

using clock_t = etl::size_t

common_reference_t

template<typename... T>

using common_reference_t = typename common_reference<T...>::type

common_type_t

template<typename... T>

using common_type_t = typename common_type<T...>::type

conditional_t

template<bool B, typename T , typename F >

using conditional_t = typename conditional<B, T, F>::type

copy_cv_t

template<typename A , typename B >

using copy_cv_t = typename copy_cv<A, B>::type

deca

using deca = ratio<10, 1>

decay_t

template<typename T >

using decay_t = typename etl::decay<T>::type

deci

using deci = ratio<1, 10>

dextents

template<typename IndexType , etl::size_t Rank>

using dextents = typename detail::dextents_impl<IndexType, etl::make_index_sequence<Rank> >::type

diff_t

template<typename Iter >

using diff_t = typename etl::iterator_traits<etl::remove_cvref_t<Iter> >::difference_type

enable_if_t

template<bool B, typename T = void>

using enable_if_t = typename enable_if<B, T>::type

exa

using exa = ratio<1'000'000'000'000'000'000, 1>

false_type

using false_type = bool_constant<false>

femto

using femto = ratio<1, 1'000'000'000'000'000>

fnv1a32

using fnv1a32 = fnv1a<etl::uint32_t, 0x01000193, 0x811c9dc5>

fnv1a64

using fnv1a64 = fnv1a<etl::uint64_t, 0x00000100000001b3, 0xcbf29ce484222325>

format_args

using format_args = basic_format_args<format_context>

format_context

using format_context = basic_format_context<back_insert_iterator<detail::fmt_buffer<char> >, char>

Provides access to formatting state consisting of the formatting arguments and the output iterator.

The first template argument is an output iterator that appends to etl::inplace_string, such as etl::back_insert_iterator<etl::inplace_string>. Implementations are encouraged to use an iterator to type-erased buffer type that supports appending to any contiguous and resizable container.

The behavior is undefined if OutputIt does not model output_iterator<const CharT&>.

https://en.cppreference.com/w/cpp/utility/format/basic_format_context

format_parse_context

using format_parse_context = basic_format_parse_context<char>

format_string

template<typename... Args>

using format_string = basic_format_string<char, type_identity_t<Args>...>

giga

using giga = ratio<1'000'000'000, 1>

hecto

using hecto = ratio<100, 1>

index_constant

template<size_t I>

using index_constant = integral_constant<size_t, I>

index_sequence

template<etl::size_t... Ints>

using index_sequence = etl::integer_sequence<etl::size_t, Ints...>

index_sequence_for

template<typename... T>

using index_sequence_for = etl::make_index_sequence<sizeof...(T)>

inplace_string

template<etl::size_t Capacity>

using inplace_string = basic_inplace_string<char, Capacity>

Typedef for a basic_inplace_string using 'char'.

inplace_u16string

template<etl::size_t Capacity>

using inplace_u16string = basic_inplace_string<char16_t, Capacity>

Typedef for a basic_inplace_string using 'char16_t'.

inplace_u32string

template<etl::size_t Capacity>

using inplace_u32string = basic_inplace_string<char32_t, Capacity>

Typedef for a basic_inplace_string using 'char32_t'.

inplace_u8string

template<etl::size_t Capacity>

using inplace_u8string = basic_inplace_string<char8_t, Capacity>

Typedef for a basic_inplace_string using 'char8_t'.

inplace_wstring

template<etl::size_t Capacity>

using inplace_wstring = basic_inplace_string<wchar_t, Capacity>

Typedef for a basic_inplace_string using 'wchar_t'.

int16_t

using int16_t = TETL_BUILTIN_INT16

Signed integer type with width of exactly 16 bits.

int32_t

using int32_t = TETL_BUILTIN_INT32

Signed integer type with width of exactly 32 bits.

int64_t

using int64_t = TETL_BUILTIN_INT64

Signed integer type with width of exactly 64 bits.

int8_t

using int8_t = TETL_BUILTIN_INT8

Signed integer type with width of exactly 8 bits.

int_fast16_t

using int_fast16_t = TETL_BUILTIN_INT16

Signed integer type with width of at least 16 bits.

int_fast32_t

using int_fast32_t = TETL_BUILTIN_INT32

Signed integer type with width of at least 32 bits.

int_fast64_t

using int_fast64_t = TETL_BUILTIN_INT64

Signed integer type with width of at least 64 bits.

int_fast8_t

using int_fast8_t = TETL_BUILTIN_INT8

Signed integer type with width of at least 8 bits.

int_least16_t

using int_least16_t = TETL_BUILTIN_INT16

Signed integer type with width of at least 16 bits.

int_least32_t

using int_least32_t = TETL_BUILTIN_INT32

Signed integer type with width of at least 32 bits.

int_least64_t

using int_least64_t = TETL_BUILTIN_INT64

Signed integer type with width of at least 64 bits.

int_least8_t

using int_least8_t = TETL_BUILTIN_INT8

Signed integer type with width of at least 8 bits.

intmax_t

using intmax_t = TETL_BUILTIN_INTMAX

Maximum-width signed integer type.

intptr_t

using intptr_t = TETL_BUILTIN_INTPTR

Signed integer type capable of holding a pointer.

is_constructible

template<typename T , typename... Args>

using is_constructible = detail::is_constructible_helper<void_t<>, T, Args...>

iter_reference_t

template<etl::detail::dereferenceable T>

using iter_reference_t = decltype(*etl::declval<T&>())

iter_rvalue_reference_t

template<etl::detail::dereferenceable T>

using iter_rvalue_reference_t = decltype(etl::ranges::iter_move(etl::declval<T&>()))

iter_value_t

template<typename T >

using iter_value_t = typename detail::iter_value<T>::type

kilo

using kilo = ratio<1'000, 1>

make_index_sequence

template<etl::size_t Size>

using make_index_sequence = etl::make_integer_sequence<etl::size_t, Size>

make_integer_sequence

template<typename T , T Size>

using make_integer_sequence = TETL_BUILTIN_INT_SEQ(T, Size)

make_signed_t

template<typename T >

using make_signed_t = typename make_signed<T>::type

make_unsigned_t

template<typename T >

using make_unsigned_t = typename make_unsigned<T>::type

mega

using mega = ratio<1'000'000, 1>

micro

using micro = ratio<1, 1'000'000>

milli

using milli = ratio<1, 1'000>

nano

using nano = ratio<1, 1'000'000'000>

new_handler

using new_handler = void (*)()

etl::new_handler is the function pointer type (pointer to function that takes no arguments and returns void), which is used by the functions etl::set_new_handler and etl::get_new_handler

nullptr_t

using nullptr_t = decltype(nullptr)

etl::nullptr_t is the type of the null pointer literal, nullptr. It is a distinct type that is not itself a pointer type or a pointer to member type.

https://en.cppreference.com/w/cpp/types/nullptr_t

peta

using peta = ratio<1'000'000'000'000'000, 1>

pico

using pico = ratio<1, 1'000'000'000'000>

ptrdiff_t

using ptrdiff_t = TETL_BUILTIN_PTRDIFF

etl::ptrdiff_t is the signed integer type of the result of subtracting two pointers.

https://en.cppreference.com/w/cpp/types/ptrdiff_t

remove_all_extents_t

template<typename T >

using remove_all_extents_t = typename remove_all_extents<T>::type

remove_const_t

template<typename T >

using remove_const_t = typename remove_const<T>::type

remove_cv_t

template<typename T >

using remove_cv_t = remove_const_t<remove_volatile_t<T> >

remove_cvref_t

template<typename T >

using remove_cvref_t = remove_cv_t<remove_reference_t<T> >

remove_extent_t

template<typename T >

using remove_extent_t = typename remove_extent<T>::type

remove_pointer_t

template<typename T >

using remove_pointer_t = typename remove_pointer<T>::type

size_t

using size_t = TETL_BUILTIN_SIZET

etl::size_t is the unsigned integer type of the result of the sizeof operator.

https://en.cppreference.com/w/cpp/types/size_t

Examples

numeric.cpp.

streamoff

using streamoff = long

streamsize

using streamsize = make_signed_t<size_t>

tera

using tera = ratio<1'000'000'000'000, 1>

time_t

using time_t = etl::size_t

Arithmetic type capable of representing times.

Although not defined, this is almost always an integral value holding the number of seconds (not counting leap seconds) since 00:00, Jan 1 1970 UTC, corresponding to POSIX time.

true_type

using true_type = bool_constant<true>

tuple_element_t

template<size_t I, typename T >

using tuple_element_t = typename tuple_element<I, T>::type

uint128_t

using uint128_t = uint128

uint16_t

using uint16_t = TETL_BUILTIN_UINT16

Unsigned integer type with width of exactly 16 bits.

uint32_t

using uint32_t = TETL_BUILTIN_UINT32

Unsigned integer type with width of exactly 32 bits.

uint64_t

using uint64_t = TETL_BUILTIN_UINT64

Unsigned integer type with width of exactly 64 bits.

uint8_t

using uint8_t = TETL_BUILTIN_UINT8

Unsigned integer type with width of exactly 8 bits.

uint_fast16_t

using uint_fast16_t = TETL_BUILTIN_UINT16

Signed integer type with width of at least 16 bits.

uint_fast32_t

using uint_fast32_t = TETL_BUILTIN_UINT32

Signed integer type with width of at least 32 bits.

uint_fast64_t

using uint_fast64_t = TETL_BUILTIN_UINT64

Signed integer type with width of at least 64 bits.

uint_fast8_t

using uint_fast8_t = TETL_BUILTIN_UINT8

Signed integer type with width of at least 8 bits.

uint_least16_t

using uint_least16_t = TETL_BUILTIN_UINT16

Signed integer type with width of at least 16 bits.

uint_least32_t

using uint_least32_t = TETL_BUILTIN_UINT32

Signed integer type with width of at least 32 bits.

uint_least64_t

using uint_least64_t = TETL_BUILTIN_UINT64

Signed integer type with width of at least 64 bits.

uint_least8_t

using uint_least8_t = TETL_BUILTIN_UINT8

Signed integer type with width of at least 8 bits.

uintmax_t

using uintmax_t = TETL_BUILTIN_UINTMAX

Maximum-width unsigned integer type.

uintptr_t

using uintptr_t = TETL_BUILTIN_UINTPTR

Unsigned integer type capable of holding a pointer.

unwrap_ref_decay_t

template<typename T >

using unwrap_ref_decay_t = typename unwrap_ref_decay<T>::type

unwrap_reference_t

template<typename T >

using unwrap_reference_t = typename unwrap_reference<T>::type

variant_alternative_t

template<size_t I, typename T >

using variant_alternative_t = typename variant_alternative<I, T>::type

wformat_args

using wformat_args = basic_format_args<wformat_context>

wformat_context

using wformat_context = basic_format_context<back_insert_iterator<detail::fmt_buffer<wchar_t> >, wchar_t>

wformat_parse_context

using wformat_parse_context = basic_format_parse_context<wchar_t>

wformat_string

template<typename... Args>

using wformat_string = basic_format_string<wchar_t, type_identity_t<Args>...>

wint_t

using wint_t = unsigned int

Enumeration Type Documentation

align_val_t

enum struct align_val_t : etl::size_t

strong

Both new-expression and delete-expression, when used with objects whose alignment requirement is greater than the default, pass that alignment requirement as an argument of type align_val_t to the selected allocation/deallocation function.

chars_format

enum struct chars_format : etl::uint8_t

strong

A BitmaskType used to specify floating-point formatting for to_chars and from_chars.

Enumerator
scientific
fixed
hex
general

errc

enum struct errc : unsigned char

strong

The scoped enumeration etl::errc defines the values of portable error conditions.

Warning

The integer values do not match POSIX

Enumerator
address_family_not_supported
address_in_use
address_not_available
already_connected
argument_list_too_long
argument_out_of_domain
bad_address
bad_file_descriptor
bad_message
broken_pipe
connection_aborted
connection_already_in_progress
connection_refused
connection_reset
cross_device_link
destination_address_required
device_or_resource_busy
directory_not_empty
executable_format_error
file_exists
file_too_large
filename_too_long
function_not_supported
host_unreachable
identifier_removed
illegal_byte_sequence
inappropriate_io_control_operation
interrupted
invalid_argument
invalid_seek
io_error
is_a_directory
message_size
network_down
network_reset
network_unreachable
no_buffer_space
no_child_process
no_link
no_lock_available
no_message_available
no_message
no_protocol_option
no_space_on_device
no_stream_resources
no_such_device_or_address
no_such_device
no_such_file_or_directory
no_such_process
not_a_directory
not_a_socket
not_a_stream
not_connected
not_enough_memory
not_supported
operation_canceled
operation_in_progress
operation_not_permitted
operation_not_supported
operation_would_block
owner_dead
permission_denied
protocol_error
protocol_not_supported
read_only_file_system
resource_deadlock_would_occur
resource_unavailable_try_again
result_out_of_range
state_not_recoverable
stream_timeout
text_file_busy
timed_out
too_many_files_open_in_system
too_many_files_open
too_many_links
too_many_symbolic_link_levels
value_too_large
wrong_protocol_type

float_denorm_style

enum float_denorm_style

Enumerator
denorm_indeterminate
denorm_absent
denorm_present

float_round_style

enum float_round_style

Enumerator
round_indeterminate
round_toward_zero
round_to_nearest
round_toward_infinity
round_toward_neg_infinity

implementation

enum struct implementation

strong

Enumerator
freestanding
hosted

language_standard

enum struct language_standard : unsigned char

strong

Enumeration for the currently selected C++ standard version. Unlike the official macro __cplusplus, these values only include the published year. This is to make the actual values smaller and therfore fit on smaller word sized chips.

Enumerator
cpp_17
cpp_20
cpp_23
cpp_26

Function Documentation

abs() [1/6]

constexpr auto abs ( double  n ) -> double

constexprnoexcept

abs() [2/6]

constexpr auto abs ( float  n ) -> float

constexprnoexcept

abs() [3/6]

constexpr auto abs ( int  n ) -> int

constexprnoexcept

Computes the absolute value of an integer number. The behavior is undefined if the result cannot be represented by the return type. If abs is called with an unsigned integral argument that cannot be converted to int by integral promotion, the program is ill-formed.

abs() [4/6]

constexpr auto abs ( long double  n ) -> long double

constexprnoexcept

abs() [5/6]

constexpr auto abs ( long long  n ) -> long long

constexprnoexcept

abs() [6/6]

constexpr auto abs ( long  n ) -> long

constexprnoexcept

addressof() [1/3]

template<typename T >
requires (is_object_v<T>)

constexpr auto addressof ( T &  arg ) -> T*

constexprnoexcept

Obtains the actual address of the object or function arg, even in presence of overloaded operator&.

addressof() [2/3]

template<typename T >
requires (not is_object_v<T>)

constexpr auto addressof ( T &  arg ) -> T*

constexprnoexcept

Obtains the actual address of the object or function arg, even in presence of overloaded operator&.

addressof() [3/3]

template<typename T >

auto addressof ( T const &&  )

delete

align()

auto align ( etl::size_t  alignment, etl::size_t  size, void *&  ptr, etl::size_t &  space  ) -> void*

inlinenoexcept

Given a pointer ptr to a buffer of size space, returns a pointer aligned by the specified alignment for size number of bytes and decreases space argument by the number of bytes used for alignment. The first aligned address is returned.

The function modifies the pointer only if it would be possible to fit the wanted number of bytes aligned by the given alignment into the buffer. If the buffer is too small, the function does nothing and returns nullptr.

Warning

The behavior is undefined if alignment is not a power of two.

apply()

template<typename F , typename Tuple >

constexpr auto apply ( F &&  f, Tuple &&  t  ) -> decltype(auto)

constexpr

as_const() [1/2]

template<typename T >

constexpr auto as_const ( T &  t ) -> add_const_t<T>&

constexprnoexcept

Forms lvalue reference to const type of t.

Examples

utility.cpp.

as_const() [2/2]

template<typename T >

constexpr auto as_const ( T const &&  ) -> void=delete

constexprdelete

assert_handler()

template<typename Assertion >

auto assert_handler

(

Assertion const &

msg

)

-> void

Examples

cassert.cpp.

atof()

constexpr auto atof ( char const *  str ) -> double

constexprnoexcept

Interprets a floating point value in a byte string pointed to by str.

atoi()

constexpr auto atoi ( char const *  str ) -> int

constexprnoexcept

Interprets an integer value in a byte string pointed to by str. Discards any whitespace characters until the first non-whitespace character is found, then takes as many characters as possible to form a valid integer number representation and converts them to an integer value.

atol()

constexpr auto atol ( char const *  str ) -> long

constexprnoexcept

Interprets an integer value in a byte string pointed to by str. Discards any whitespace characters until the first non-whitespace character is found, then takes as many characters as possible to form a valid integer number representation and converts them to an integer value.

atoll()

constexpr auto atoll ( char const *  str ) -> long long

constexprnoexcept

Interprets an integer value in a byte string pointed to by str. Discards any whitespace characters until the first non-whitespace character is found, then takes as many characters as possible to form a valid integer number representation and converts them to an integer value.

back_inserter()

template<typename Container >

constexpr auto back_inserter ( Container &  container ) -> back_insert_iterator<Container>

constexpr

back_inserter is a convenience function template that constructs a back_insert_iterator for the container c with the type deduced from the type of the argument.

bind_front()

template<typename Func , typename... BoundArgs>

constexpr auto bind_front ( Func &&  func, BoundArgs &&...  boundArgs  )

constexpr

The function template bind_front generates a forwarding call wrapper for f. Calling this wrapper is equivalent to invoking f with its first sizeof...(Args) parameters bound to args. In other words, bind_front(f, bound_args...)(call_args...) is equivalent to invoke(f, bound_args..., call_args....).

Copied implementation from paper: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0356r5.html

construct_at()

template<typename T , typename... Args, typename = decltype(::new (etl::declval<void*>()) T(etl::declval<Args>()...))>

constexpr auto construct_at ( T *  p, Args &&...  args  ) -> T*

constexpr

Creates a T object initialized with arguments args... at given address p.

cref() [1/3]

template<typename T >

constexpr auto cref ( reference_wrapper< T >  t ) -> reference_wrapper<T const>

constexprnoexcept

cref() [2/3]

template<typename T >

void cref ( T const &&  )

delete

cref() [3/3]

template<typename T >

constexpr auto cref ( T const &  t ) -> reference_wrapper<T const>

constexprnoexcept

Function templates ref and cref are helper functions that generate an object of type reference_wrapper, using template argument deduction to determine the template argument of the result. module Utility.

declval()

template<typename T >

auto declval ( ) -> add_rvalue_reference_t< T >

noexcept

destroy()

template<typename ForwardIt >

constexpr auto destroy ( ForwardIt  first, ForwardIt  last  ) -> void

constexpr

Destroys the objects in the range [first, last).

destroy_at()

template<typename T >

constexpr auto destroy_at ( T *  p ) -> void

constexpr

If T is not an array type, calls the destructor of the object pointed to by p, as if by p->~T(). If T is an array type, recursively destroys elements of *p in order, as if by calling destroy(begin(*p), end(*p)).

destroy_n()

template<typename ForwardIt , typename Size >

constexpr auto destroy_n ( ForwardIt  first, Size  n  ) -> ForwardIt

constexpr

Destroys the n objects in the range starting at first.

div() [1/3]

constexpr auto div ( int  x, int  y  ) -> div_t

constexprnoexcept

Computes both the quotient and the remainder of the division of the numerator x by the denominator y. The quotient is the result of the expression x/y. The remainder is the result of the expression xy.

div() [2/3]

constexpr auto div ( long long  x, long long  y  ) -> lldiv_t

constexprnoexcept

Computes both the quotient and the remainder of the division of the numerator x by the denominator y. The quotient is the result of the expression x/y. The remainder is the result of the expression xy.

div() [3/3]

constexpr auto div ( long  x, long  y  ) -> ldiv_t

constexprnoexcept

Computes both the quotient and the remainder of the division of the numerator x by the denominator y. The quotient is the result of the expression x/y. The remainder is the result of the expression xy.

erase() [1/2]

template<typename Char , typename Traits , etl::size_t Capacity, typename U >

constexpr auto erase ( basic_inplace_string< Char, Capacity, Traits > &  c, U const &  value  ) -> typename basic_inplace_string<Char, Capacity, Traits>::size_type

constexprnoexcept

Erases all elements that compare equal to value from the container.

erase() [2/2]

template<typename T , size_t Capacity, typename U >

constexpr auto erase ( static_vector< T, Capacity > &  c, U const &  value  ) -> typename static_vector<T, Capacity>::size_type

constexpr

erase_if() [1/3]

template<typename Char , typename Traits , etl::size_t Capacity, typename Predicate >

constexpr auto erase_if ( basic_inplace_string< Char, Capacity, Traits > &  c, Predicate  pred  ) -> typename basic_inplace_string<Char, Capacity, Traits>::size_type

constexprnoexcept

Erases all elements that satisfy the predicate pred from the container.

erase_if() [2/3]

template<typename Key , typename Container , typename Compare , typename Pred >

constexpr auto erase_if ( etl::flat_set< Key, Container, Compare > &  c, Pred  pred  ) -> typename etl::flat_set<Key, Container, Compare>::size_type

constexpr

erase_if() [3/3]

template<typename T , size_t Capacity, typename Predicate >

constexpr auto erase_if ( static_vector< T, Capacity > &  c, Predicate  pred  ) -> typename static_vector<T, Capacity>::size_type

constexpr

Erases all elements that satisfy the predicate pred from the container.

Returns

The number of erased elements.

https://en.cppreference.com/w/cpp/container/vector/erase2

exchange()

template<typename T , typename U = T>

constexpr auto exchange ( T &  obj, U &&  newValue  ) -> T

constexprnoexcept

Replaces the value of obj with new_value and returns the old value of obj.

Returns

The old value of obj.

Examples

utility.cpp.

extents()

template<typename... Integrals>
requires (etl::is_convertible_v<Integrals, etl::size_t> and ...)

extents

(

Integrals...

)

-> extents< etl::size_t, etl::size_t((Integrals(), etl::dynamic_extent))... >

fabs() [1/3]

constexpr auto fabs ( double  n ) -> double

constexprnoexcept

fabs() [2/3]

constexpr auto fabs ( float  n ) -> float

constexprnoexcept

fabs() [3/3]

constexpr auto fabs ( long double  n ) -> long double

constexprnoexcept

fabsf()

constexpr auto fabsf ( float  n ) -> float

constexprnoexcept

fabsl()

constexpr auto fabsl ( long double  n ) -> long double

constexprnoexcept

format_to()

template<typename OutputIt , typename... Args>

auto format_to	(	OutputIt	out,
		etl::string_view	fmt,
		Args const &...	args
	)		-> OutputIt

Format args according to the format string fmt, and write the result to the output iterator out.

https://en.cppreference.com/w/cpp/utility/format/format_to

format_to_n()

template<typename OutputIter , typename... Args>

auto format_to_n	(	OutputIter	out,
		diff_t< OutputIter >	n,
		etl::string_view	fmt,
		Args const &...	args
	)		-> format_to_n_result<OutputIter>

Format args according to the format string fmt, and write the result to the output iterator out. At most n characters are written.

https://en.cppreference.com/w/cpp/utility/format/format_to_n

forward() [1/2]

template<typename T >

constexpr auto forward ( remove_reference_t< T > &&  param ) -> T&&

constexprnoexcept

forward() [2/2]

template<typename T >

constexpr auto forward ( remove_reference_t< T > &  param ) -> T&&

constexprnoexcept

Forwards lvalues as either lvalues or as rvalues, depending on T. When t is a forwarding reference (a function argument that is declared as an rvalue reference to a cv-unqualified function template parameter), this overload forwards the argument to another function with the value category it had when passed to the calling function.

https://en.cppreference.com/w/cpp/utility/forward

forward_as_tuple()

template<typename... Args>

constexpr auto forward_as_tuple ( Args &&...  args ) -> etl::tuple<Args&&...>

constexprnoexcept

Constructs a tuple of references to the arguments in args suitable for forwarding as an argument to a function. The tuple has rvalue reference data members when rvalues are used as arguments, and otherwise has lvalue reference data members.

forward_like()

template<typename T , typename U >

constexpr auto forward_like ( U &&  x ) -> auto&&

constexprnoexcept

from_chars()

template<integral Int>
requires (not same_as<Int, bool>)

constexpr auto from_chars ( char const *  first, char const *  last, Int &  value, int  base = 10  ) -> from_chars_result

constexpr

Analyzes the character sequence [first,last) for a pattern described below. If no characters match the pattern or if the value obtained by parsing the matched characters is not representable in the type of value, value is unmodified, otherwise the characters matching the pattern are interpreted as a text representation of an arithmetic value, which is stored in value.

front_inserter()

template<typename Container >

constexpr auto front_inserter ( Container &  c ) -> front_insert_iterator<Container>

constexpr

front_inserter is a convenience function template that constructs a front_insert_iterator for the container c with the type deduced from the type of the argument.

function_ref()

template<typename R , typename... Args>

function_ref

(

R(*)(Args...)

)

-> function_ref< R(Args...)>

get() [1/12]

template<size_t I, typename X >

constexpr auto get ( complex< X > &&  z ) -> X&&

constexprnoexcept

get() [2/12]

template<size_t I, typename X >

constexpr auto get ( complex< X > &  z ) -> X&

constexprnoexcept

get() [3/12]

template<size_t I, typename X >

constexpr auto get ( complex< X > const &&  z ) -> X const&&

constexprnoexcept

get() [4/12]

template<size_t I, typename X >

constexpr auto get ( complex< X > const &  z ) -> X const&

constexprnoexcept

get() [5/12]

template<size_t I, typename T1 , typename T2 >

constexpr auto get ( pair< T1, T2 > &&  p ) -> tuple_element_t<I, pair<T1, T2>>&&

constexprnoexcept

Extracts an element from the pair using tuple-like interface.

The index-based overloads (1-4) fail to compile if the index I is neither 0 nor 1. See Alisdar Meredith talk "Recreational C++" 35:00 to 46:00. https://youtu.be/ovxNM865WaU

get() [6/12]

template<size_t I, typename T1 , typename T2 >

constexpr auto get ( pair< T1, T2 > &  p ) -> tuple_element_t<I, pair<T1, T2>>&

constexprnoexcept

Extracts an element from the pair using tuple-like interface.

The index-based overloads (1-4) fail to compile if the index I is neither 0 nor 1. See Alisdar Meredith talk "Recreational C++" 35:00 to 46:00. https://youtu.be/ovxNM865WaU

get() [7/12]

template<size_t I, typename T1 , typename T2 >

constexpr auto get ( pair< T1, T2 > const &&  p ) -> tuple_element_t<I, pair<T1, T2>> const&&

constexprnoexcept

Extracts an element from the pair using tuple-like interface.

The index-based overloads (1-4) fail to compile if the index I is neither 0 nor 1. See Alisdar Meredith talk "Recreational C++" 35:00 to 46:00. https://youtu.be/ovxNM865WaU

get() [8/12]

template<size_t I, typename T1 , typename T2 >

constexpr auto get ( pair< T1, T2 > const &  p ) -> tuple_element_t<I, pair<T1, T2>> const&

constexprnoexcept

Extracts an element from the pair using tuple-like interface.

The index-based overloads (1-4) fail to compile if the index I is neither 0 nor 1. See Alisdar Meredith talk "Recreational C++" 35:00 to 46:00. https://youtu.be/ovxNM865WaU

get() [9/12]

template<etl::size_t I, typename... Ts>

constexpr auto get ( tuple< Ts... > &&  t ) -> auto&&

constexpr

get() [10/12]

template<etl::size_t I, typename... Ts>

constexpr auto get ( tuple< Ts... > &  t ) -> auto&

constexpr

get() [11/12]

template<etl::size_t I, typename... Ts>

constexpr auto get ( tuple< Ts... > const &&  t ) -> auto const&&

constexpr

get() [12/12]

template<etl::size_t I, typename... Ts>

constexpr auto get ( tuple< Ts... > const &  t ) -> auto const&

constexpr

get_if() [1/2]

template<typename T , typename... Types>

constexpr auto get_if ( variant< Types... > *  pv ) -> add_pointer_t< T >

constexprnoexcept

get_if() [2/2]

template<typename T , typename... Types>

constexpr auto get_if ( variant< Types... > const *  pv ) -> add_pointer_t< T const >

constexprnoexcept

idiv()

template<integral Int>

constexpr auto idiv ( Int  x, Int  y  ) -> idiv_result<Int>

constexprnoexcept

ignore_unused()

template<typename... Types>

constexpr auto ignore_unused ( Types &&  ... ) -> void

constexpr

Explicitly ignore arguments or variables.

auto main(int argc, char** argv) -> int
{
  etl::ignore_unused(argc, argv);
  return 0;
}

ilog2()

template<integral Int>

constexpr auto ilog2 ( Int  x ) -> Int

constexprnoexcept

imaxdiv()

constexpr auto imaxdiv ( intmax_t  x, intmax_t  y  ) -> imaxdiv_t

constexprnoexcept

Computes both the quotient and the remainder of the division of the numerator x by the denominator y. The quotient is the result of the expression x/y. The remainder is the result of the expression xy.

invoke()

template<typename F , typename... Args>

constexpr auto invoke ( F &&  f, Args &&...  args  ) -> invoke_result_t<F, Args...>

constexpr

Todo:

Add noexcept(is_nothrow_invocable_v<F, Args...>)

invoke_r()

template<typename R , typename F , typename... Args>
requires (etl::is_invocable_r_v<R, F, Args...>)

constexpr auto invoke_r ( F &&  f, Args &&...  args  ) -> R

constexpr

Todo:

Add noexcept(is_nothrow_invocable_r_v<R, F, Args...>)

ipow() [1/2]

template<auto Base>

constexpr auto ipow ( decltype(Base)  exponent ) -> decltype(Base)

constexprnoexcept

ipow() [2/2]

template<integral Int>

constexpr auto ipow ( Int  base, Int  exponent  ) -> Int

constexprnoexcept

is_constant_evaluated()

constexpr auto is_constant_evaluated ( ) -> bool

constexprnoexcept

Detects whether the function call occurs within a constant-evaluated context. Returns true if the evaluation of the call occurs within the evaluation of an expression or conversion that is manifestly constant-evaluated; otherwise returns false.

https://en.cppreference.com/w/cpp/types/is_constant_evaluated

is_freestanding()

consteval auto is_freestanding ( ) -> bool

noexcept

is_hosted()

consteval auto is_hosted ( ) -> bool

noexcept

isfinite()

constexpr auto isfinite ( half  arg ) -> bool

constexprnoexcept

isinf()

constexpr auto isinf ( half  arg ) -> bool

constexprnoexcept

isnan()

constexpr auto isnan ( half  arg ) -> bool

constexprnoexcept

isnormal()

constexpr auto isnormal ( half  arg ) -> bool

constexprnoexcept

labs()

constexpr auto labs ( long  n ) -> long

constexprnoexcept

Computes the absolute value of an integer number. The behavior is undefined if the result cannot be represented by the return type. If abs is called with an unsigned integral argument that cannot be converted to int by integral promotion, the program is ill-formed.

ldiv()

constexpr auto ldiv ( long  x, long  y  ) -> ldiv_t

constexprnoexcept

Computes both the quotient and the remainder of the division of the numerator x by the denominator y. The quotient is the result of the expression x/y. The remainder is the result of the expression xy.

llabs()

constexpr auto llabs ( long long  n ) -> long long

constexprnoexcept

Computes the absolute value of an integer number. The behavior is undefined if the result cannot be represented by the return type. If abs is called with an unsigned integral argument that cannot be converted to int by integral promotion, the program is ill-formed.

lldiv()

constexpr auto lldiv ( long long  x, long long  y  ) -> lldiv_t

constexprnoexcept

Computes both the quotient and the remainder of the division of the numerator x by the denominator y. The quotient is the result of the expression x/y. The remainder is the result of the expression xy.

make_format_args()

template<typename Context = etl::format_context, typename... Args>

auto make_format_args

(

Args &&...

args

)

-> detail::format_arg_store<Context, Args...>

make_from_tuple()

template<typename T , typename Tuple >

constexpr auto make_from_tuple ( Tuple &&  t ) -> T

constexpr

make_pair()

template<typename T1 , typename T2 >

constexpr auto make_pair ( T1 &&  t, T2 &&  u  ) -> pair<decay_t<T1>, decay_t<T2>>

constexpr

Creates a etl::pair object, deducing the target type from the types of arguments.

The deduced types V1 and V2 are etl::decay<T1>::type and etl::decay<T2>::type (the usual type transformations applied to arguments of functions passed by value).

https://en.cppreference.com/w/cpp/utility/pair/make_pair

Examples

utility.cpp.

make_reverse_iterator()

template<typename Iter >

constexpr auto make_reverse_iterator ( Iter  i ) -> etl::reverse_iterator<Iter>

constexprnoexcept

Convenience function template that constructs a etl::reverse_iterator for the given iterator i (which must be a LegacyBidirectionalIterator) with the type deduced from the type of the argument.

make_tuple()

template<typename... Args>

constexpr auto make_tuple ( Args &&...  args )

constexpr

Creates a tuple object, deducing the target type from the types of arguments.

make_wformat_args()

template<typename... Args>

auto make_wformat_args

(

Args &&...

args

)

-> detail::format_arg_store<wformat_context, Args...>

mdspan() [1/7]

template<typename CArray >
requires (is_array_v<CArray> && rank_v<CArray> == 1)

mdspan

(

CArray &

)

-> mdspan< remove_all_extents_t< CArray >, extents< size_t, extent_v< CArray, 0 > > >

mdspan() [2/7]

template<typename ElementType , typename IndexType , size_t... ExtentsPack>

mdspan	(	ElementType *	,
		extents< IndexType, ExtentsPack... > const &
	)		-> mdspan< ElementType, extents< IndexType, ExtentsPack... > >

mdspan() [3/7]

template<typename ElementType , typename... Integrals>
requires ((is_convertible_v<Integrals, size_t> && ...) && sizeof...(Integrals) > 0)

mdspan ( ElementType *  , Integrals...    ) -> mdspan< ElementType, dextents< size_t, sizeof...(Integrals)> >

explicit

mdspan() [4/7]

template<typename ElementType , typename MappingType >

mdspan	(	ElementType *	,
		MappingType const &
	)		-> mdspan< ElementType, typename MappingType::extents_type, typename MappingType::layout_type >

mdspan() [5/7]

template<class ElementType , class Extents , class Layout , class Container >

mdspan

(

mdarray< ElementType, Extents, Layout, Container >

)

-> mdspan< typename decltype(declval< mdarray< ElementType, Extents, Layout, Container > >().to_mdspan())::element_type, typename decltype(declval< mdarray< ElementType, Extents, Layout, Container > >().to_mdspan())::extens_type, typename decltype(declval< mdarray< ElementType, Extents, Layout, Container > >().to_mdspan())::layout_type, typename decltype(declval< mdarray< ElementType, Extents, Layout, Container > >().to_mdspan())::accessor_type >

mdspan() [6/7]

template<typename Pointer >
requires (is_pointer_v<remove_reference_t<Pointer>>)

mdspan

(

Pointer &&

)

-> mdspan< remove_pointer_t< remove_reference_t< Pointer > >, extents< size_t > >

mdspan() [7/7]

template<typename MappingType , typename AccessorType >

mdspan	(	typename AccessorType::data_handle_type const &	,
		MappingType const &	,
		AccessorType const &
	)		-> mdspan< typename AccessorType::element_type, typename MappingType::extents_type, typename MappingType::layout_type, AccessorType >

mismatch() [1/3]

template<typename InputIt1 , typename InputIt2 >

constexpr auto mismatch ( InputIt1  first1, InputIt1  last1, InputIt2  first2  ) -> pair<InputIt1, InputIt2>

constexpr

mismatch() [2/3]

template<typename InputIt1 , typename InputIt2 >

constexpr auto mismatch ( InputIt1  first1, InputIt1  last1, InputIt2  first2, InputIt2  last2  ) -> pair<InputIt1, InputIt2>

constexpr

mismatch() [3/3]

template<typename InputIt1 , typename InputIt2 , typename Predicate >

constexpr auto mismatch ( InputIt1  first1, InputIt1  last1, InputIt2  first2, InputIt2  last2, Predicate  pred  ) -> pair<InputIt1, InputIt2>

constexpr

move()

template<typename T >

constexpr auto move ( T &&  t ) -> etl::remove_reference_t<T>&&

constexprnoexcept

move is used to indicate that an object t may be "moved from", i.e. allowing the efficient transfer of resources from t to another object. In particular, move produces an xvalue expression that identifies its argument t. It is exactly equivalent to a static_cast to an rvalue reference type.

Returns

static_cast<remove_reference_t<T>&&>(t)

move_if_noexcept()

template<typename T >

constexpr auto move_if_noexcept ( T &  x ) -> etl::conditional_t<!etl::is_nothrow_move_constructible_v<T> and etl::is_copy_constructible_v<T>, T const&, T&&>

constexprnoexcept

Conditionally convert a value to an rvalue.

Same as etl::move unless the type's move constructor could throw and the type is copyable, in which case an lvalue-reference is returned instead.

not_fn() [1/2]

template<auto ConstFn>

constexpr auto not_fn ( ) -> detail::stateless_not_fn<ConstFn>

constexprnoexcept

not_fn() [2/2]

template<typename F >

constexpr auto not_fn ( F &&  f ) -> detail::not_fn_t<etl::decay_t<F>>

constexpr

nth_element()

template<typename RandomIt >

constexpr auto nth_element ( RandomIt  first, RandomIt  nth, RandomIt  last  ) -> void

constexpr

operator!=() [1/10]

template<typename Char , typename Traits , etl::size_t Capacity>

constexpr auto operator!= ( Char const *  lhs, etl::basic_inplace_string< Char, Capacity, Traits > const &  rhs  ) -> bool

constexprnoexcept

Compares the contents of a string with another string or a null-terminated array of Char.

Two strings are equal if both the size of lhs and rhs are equal and each character in lhs has equivalent character in rhs at the same position.

operator!=() [2/10]

template<typename Char , typename Traits , etl::size_t Capacity1>

constexpr auto operator!= ( etl::basic_inplace_string< Char, Capacity1, Traits > const &  lhs, Char const *  rhs  ) -> bool

constexprnoexcept

Compares the contents of a string with another string or a null-terminated array of Char.

Two strings are equal if both the size of lhs and rhs are equal and each character in lhs has equivalent character in rhs at the same position.

operator!=() [3/10]

template<typename Char , typename Traits , etl::size_t Capacity1, etl::size_t Capacity2>

constexpr auto operator!= ( etl::basic_inplace_string< Char, Capacity1, Traits > const &  lhs, etl::basic_inplace_string< Char, Capacity2, Traits > const &  rhs  ) -> bool

constexprnoexcept

Compares the contents of a string with another string or a null-terminated array of Char.

Two strings are equal if both the size of lhs and rhs are equal and each character in lhs has equivalent character in rhs at the same position.

operator!=() [4/10]

template<typename Iter1 , typename Iter2 >

constexpr auto operator!= ( etl::reverse_iterator< Iter1 > const &  lhs, etl::reverse_iterator< Iter2 > const &  rhs  ) -> bool

constexpr

Compares the underlying iterators. Inverse comparisons are applied in order to take into account that the iterator order is reversed.

operator!=() [5/10]

template<typename R , typename... Args, size_t Capacity, size_t Alignment>

constexpr auto operator!= ( inplace_function< R(Args...), Capacity, Alignment > const &  f, nullptr_t    ) -> bool

constexprnoexcept

Compares a etl::inplace_function with a null pointer. Empty functions (that is, functions without a callable target) compare equal, non-empty functions compare non-equal.

operator!=() [6/10]

template<typename Rhs , Rhs R, typename Lhs , Lhs L>

constexpr auto operator!= ( integral_constant< Rhs, R >  , integral_constant< Lhs, L >    ) -> integral_constant<bool, L != R>

constexpr

operator!=() [7/10]

constexpr auto operator!= ( language_standard  lhs, language_standard  rhs  ) -> bool

constexprnoexcept

operator!=() [8/10]

template<typename R , typename... Args, size_t Capacity, size_t Alignment>

constexpr auto operator!= ( nullptr_t  , inplace_function< R(Args...), Capacity, Alignment > const &  f  ) -> bool

constexprnoexcept

Compares a etl::inplace_function with a null pointer. Empty functions (that is, functions without a callable target) compare equal, non-empty functions compare non-equal.

operator!=() [9/10]

template<typename Key , size_t Capacity, typename Comp >

constexpr auto operator!= ( static_set< Key, Capacity, Comp > const &  lhs, static_set< Key, Capacity, Comp > const &  rhs  ) -> bool

constexpr

Compares the contents of two sets.

Checks if the contents of lhs and rhs are equal, that is, they have the same number of elements and each element in lhs compares equal with the element in rhs at the same position.

operator!=() [10/10]

template<typename T , size_t Capacity>

constexpr auto operator!= ( static_vector< T, Capacity > const &  lhs, static_vector< T, Capacity > const &  rhs  ) -> bool

constexprnoexcept

operator&() [1/2]

TETL_ALWAYS_INLINE constexpr auto operator& ( etl::byte  lhs, etl::byte  rhs  ) -> etl::byte

constexprnoexcept

Equivalent to: return byte(static_cast<unsigned int>(lhs) & static_cast<unsigned int>(rhs));

operator&() [2/2]

template<bitmask_type T>

constexpr auto operator& ( T  x, T  y  ) -> T

constexpr

operator&=() [1/2]

TETL_ALWAYS_INLINE constexpr auto operator&= ( etl::byte &  lhs, etl::byte  rhs  ) -> etl::byte&

constexprnoexcept

Equivalent to: return lhs = lhs & rhs;

operator&=() [2/2]

template<bitmask_type T>

constexpr auto operator&= ( T &  x, T  y  ) -> T const&

constexprnoexcept

operator*() [1/3]

template<typename T >

constexpr auto operator* ( complex< T > const &  lhs, complex< T > const &  rhs  ) -> complex<T>

constexpr

operator*() [2/3]

template<typename T >

constexpr auto operator* ( complex< T > const &  lhs, T const &  rhs  ) -> complex<T>

constexpr

operator*() [3/3]

template<typename T >

constexpr auto operator* ( T const &  lhs, complex< T > const &  rhs  ) -> complex<T>

constexpr

operator+() [1/11]

template<typename Char , typename Traits , size_t Capacity>

constexpr auto operator+ ( basic_inplace_string< Char, Capacity, Traits > const &  lhs, Char const *  rhs  ) -> basic_inplace_string<Char, Capacity, Traits>

constexprnoexcept

Returns a string containing characters from lhs followed by the characters from rhs.

operator+() [2/11]

template<typename Char , typename Traits , size_t Capacity>

constexpr auto operator+ ( basic_inplace_string< Char, Capacity, Traits > const &  lhs, Char  rhs  ) -> basic_inplace_string<Char, Capacity, Traits>

constexprnoexcept

Returns a string containing characters from lhs followed by the characters from rhs.

operator+() [3/11]

template<typename Char , typename Traits , size_t Capacity1, size_t Capacity2>

constexpr auto operator+ ( basic_inplace_string< Char, Capacity1, Traits > const &  lhs, basic_inplace_string< Char, Capacity2, Traits > const &  rhs  ) -> basic_inplace_string<Char, Capacity1, Traits>

constexprnoexcept

Returns a string containing characters from lhs followed by the characters from rhs.

operator+() [4/11]

template<typename Char , typename Traits , size_t Capacity>

constexpr auto operator+ ( Char const *  lhs, basic_inplace_string< Char, Capacity, Traits > const &  rhs  ) -> basic_inplace_string<Char, Capacity, Traits>

constexprnoexcept

Returns a string containing characters from lhs followed by the characters from rhs.

operator+() [5/11]

template<typename Char , typename Traits , size_t Capacity>

constexpr auto operator+ ( Char  lhs, basic_inplace_string< Char, Capacity, Traits > const &  rhs  ) -> basic_inplace_string<Char, Capacity, Traits>

constexprnoexcept

Returns a string containing characters from lhs followed by the characters from rhs.

operator+() [6/11]

template<typename T >

constexpr auto operator+ ( complex< T > const &  lhs, complex< T > const &  rhs  ) -> complex<T>

constexpr

operator+() [7/11]

template<typename T >

constexpr auto operator+ ( complex< T > const &  lhs, T const &  rhs  ) -> complex<T>

constexpr

operator+() [8/11]

template<typename T >

constexpr auto operator+ ( complex< T > const &  val ) -> complex<T>

constexpr

operator+() [9/11]

template<typename Rhs , Rhs R, typename Lhs , Lhs L>

constexpr auto operator+ ( integral_constant< Rhs, R >  , integral_constant< Lhs, L >    ) -> integral_constant<decltype(L + R), L + R>

constexpr

operator+() [10/11]

template<typename T >

constexpr auto operator+ ( T const &  lhs, complex< T > const &  rhs  ) -> complex<T>

constexpr

operator+() [11/11]

template<typename Iter >

constexpr auto operator+ ( typename reverse_iterator< Iter >::difference_type  n, reverse_iterator< Iter > const &  it  ) -> reverse_iterator<Iter>

constexprnoexcept

Returns the iterator it incremented by n.

operator-() [1/5]

template<typename T >

constexpr auto operator- ( complex< T > const &  lhs, complex< T > const &  rhs  ) -> complex<T>

constexpr

operator-() [2/5]

template<typename T >

constexpr auto operator- ( complex< T > const &  lhs, T const &  rhs  ) -> complex<T>

constexpr

operator-() [3/5]

template<typename T >

constexpr auto operator- ( complex< T > const &  val ) -> complex<T>

constexpr

operator-() [4/5]

template<typename Iterator1 , typename Iterator2 >

constexpr auto operator- ( reverse_iterator< Iterator1 > const &  lhs, reverse_iterator< Iterator2 > const &  rhs  ) -> decltype(rhs.base() - lhs.base())

constexprnoexcept

Returns the distance between two iterator adaptors.

operator-() [5/5]

template<typename T >

constexpr auto operator- ( T const &  lhs, complex< T > const &  rhs  ) -> complex<T>

constexpr

operator/() [1/3]

template<typename T >

constexpr auto operator/ ( complex< T > const &  lhs, complex< T > const &  rhs  ) -> complex<T>

constexpr

operator/() [2/3]

template<typename T >

constexpr auto operator/ ( complex< T > const &  lhs, T const &  rhs  ) -> complex<T>

constexpr

operator/() [3/3]

template<typename T >

constexpr auto operator/ ( T const &  lhs, complex< T > const &  rhs  ) -> complex<T>

constexpr

operator<() [1/11]

template<typename Char , typename Traits >

constexpr auto operator< ( basic_string_view< Char, Traits >  lhs, basic_string_view< Char, Traits >  rhs  ) -> bool

constexprnoexcept

Compares two views. All comparisons are done via the compare() member function (which itself is defined in terms of Traits::compare()):

The ordering comparisons are done lexicographically – the comparison is performed by a function equivalent to lexicographical_compare.

operator<() [2/11]

template<typename Char , typename Traits , int = 2>

constexpr auto operator< ( basic_string_view< Char, Traits >  lhs, type_identity_t< basic_string_view< Char, Traits > >  rhs  ) -> bool

constexprnoexcept

operator<() [3/11]

template<typename Char , typename Traits , etl::size_t Capacity1>

constexpr auto operator< ( Char const *  lhs, etl::basic_inplace_string< Char, Capacity1, Traits > const &  rhs  ) -> bool

constexprnoexcept

Compares the contents of a string with another string or a null-terminated array of Char.

The ordering comparisons are done lexicographically.

operator<() [4/11]

template<typename Char , typename Traits , etl::size_t Capacity1>

constexpr auto operator< ( etl::basic_inplace_string< Char, Capacity1, Traits > const &  lhs, Char const *  rhs  ) -> bool

constexprnoexcept

Compares the contents of a string with another string or a null-terminated array of Char.

The ordering comparisons are done lexicographically.

operator<() [5/11]

template<typename Char , typename Traits , etl::size_t Capacity1, etl::size_t Capacity2>

constexpr auto operator< ( etl::basic_inplace_string< Char, Capacity1, Traits > const &  lhs, etl::basic_inplace_string< Char, Capacity2, Traits > const &  rhs  )

constexprnoexcept

Compares the contents of a string with another string or a null-terminated array of Char.

The ordering comparisons are done lexicographically.

operator<() [6/11]

template<typename Iter1 , typename Iter2 >

constexpr auto operator< ( etl::reverse_iterator< Iter1 > const &  lhs, etl::reverse_iterator< Iter2 > const &  rhs  ) -> bool

constexpr

Compares the underlying iterators. Inverse comparisons are applied in order to take into account that the iterator order is reversed.

operator<() [7/11]

constexpr auto operator< ( language_standard  lhs, language_standard  rhs  ) -> bool

constexprnoexcept

operator<() [8/11]

template<typename T1 , typename T2 >

constexpr auto operator< ( pair< T1, T2 > const &  lhs, pair< T1, T2 > const &  rhs  ) -> bool

constexpr

Compares lhs and rhs lexicographically by operator<, that is, compares the first elements and only if they are equivalent, compares the second elements.

operator<() [9/11]

template<typename Key , size_t Capacity, typename Comp >

constexpr auto operator< ( static_set< Key, Capacity, Comp > const &  lhs, static_set< Key, Capacity, Comp > const &  rhs  ) -> bool

constexpr

Compares the contents of two sets.

Compares the contents of lhs and rhs lexicographically. The comparison is performed by a function equivalent to lexicographical_compare. This comparison ignores the set's ordering Compare.

operator<() [10/11]

template<typename T , size_t Capacity>

constexpr auto operator< ( static_vector< T, Capacity > const &  lhs, static_vector< T, Capacity > const &  rhs  ) -> bool

constexprnoexcept

Compares the contents of two vectors.

Compares the contents of lhs and rhs lexicographically. The comparison is performed by a function equivalent to lexicographical_compare.

operator<() [11/11]

template<typename Char , typename Traits , int = 1>

constexpr auto operator< ( type_identity_t< basic_string_view< Char, Traits > >  lhs, basic_string_view< Char, Traits >  rhs  ) -> bool

constexprnoexcept

operator<<()

template<etl::integral Int>

TETL_ALWAYS_INLINE constexpr auto operator<< ( etl::byte  b, Int  shift  ) -> etl::byte

constexprnoexcept

Equivalent to: return etl::byte(static_cast<unsigned int>(b) << shift);

operator<<=()

template<etl::integral Int>

TETL_ALWAYS_INLINE constexpr auto operator<<= ( etl::byte &  b, Int  shift  ) -> etl::byte&

constexprnoexcept

Equivalent to: return b = b << shift;

operator<=() [1/11]

template<typename Char , typename Traits >

constexpr auto operator<= ( basic_string_view< Char, Traits >  lhs, basic_string_view< Char, Traits >  rhs  ) -> bool

constexprnoexcept

Compares two views. All comparisons are done via the compare() member function (which itself is defined in terms of Traits::compare()):

The ordering comparisons are done lexicographically – the comparison is performed by a function equivalent to lexicographical_compare.

operator<=() [2/11]

template<typename Char , typename Traits , int = 2>

constexpr auto operator<= ( basic_string_view< Char, Traits >  lhs, type_identity_t< basic_string_view< Char, Traits > >  rhs  ) -> bool

constexprnoexcept

operator<=() [3/11]

template<typename Char , typename Traits , etl::size_t Capacity1>

constexpr auto operator<= ( Char const *  lhs, etl::basic_inplace_string< Char, Capacity1, Traits > const &  rhs  ) -> bool

constexprnoexcept

Compares the contents of a string with another string or a null-terminated array of Char.

The ordering comparisons are done lexicographically.

operator<=() [4/11]

template<typename Char , typename Traits , etl::size_t Capacity1>

constexpr auto operator<= ( etl::basic_inplace_string< Char, Capacity1, Traits > const &  lhs, Char const *  rhs  ) -> bool

constexprnoexcept

Compares the contents of a string with another string or a null-terminated array of Char.

The ordering comparisons are done lexicographically.

operator<=() [5/11]

template<typename Char , typename Traits , etl::size_t Capacity1, etl::size_t Capacity2>

constexpr auto operator<= ( etl::basic_inplace_string< Char, Capacity1, Traits > const &  lhs, etl::basic_inplace_string< Char, Capacity2, Traits > const &  rhs  )

constexprnoexcept

Compares the contents of a string with another string or a null-terminated array of Char.

The ordering comparisons are done lexicographically.

operator<=() [6/11]

template<typename Iter1 , typename Iter2 >

constexpr auto operator<= ( etl::reverse_iterator< Iter1 > const &  lhs, etl::reverse_iterator< Iter2 > const &  rhs  ) -> bool

constexpr

Compares the underlying iterators. Inverse comparisons are applied in order to take into account that the iterator order is reversed.

operator<=() [7/11]

constexpr auto operator<= ( language_standard  lhs, language_standard  rhs  ) -> bool

constexprnoexcept

operator<=() [8/11]

template<typename T1 , typename T2 >

constexpr auto operator<= ( pair< T1, T2 > const &  lhs, pair< T1, T2 > const &  rhs  ) -> bool

constexpr

Compares lhs and rhs lexicographically by operator<, that is, compares the first elements and only if they are equivalent, compares the second elements.

operator<=() [9/11]

template<typename Key , size_t Capacity, typename Comp >

constexpr auto operator<= ( static_set< Key, Capacity, Comp > const &  lhs, static_set< Key, Capacity, Comp > const &  rhs  ) -> bool

constexpr

Compares the contents of two sets.

Compares the contents of lhs and rhs lexicographically. The comparison is performed by a function equivalent to lexicographical_compare. This comparison ignores the set's ordering Compare.

operator<=() [10/11]

template<typename T , size_t Capacity>

constexpr auto operator<= ( static_vector< T, Capacity > const &  lhs, static_vector< T, Capacity > const &  rhs  ) -> bool

constexprnoexcept

operator<=() [11/11]

template<typename Char , typename Traits , int = 1>

constexpr auto operator<= ( type_identity_t< basic_string_view< Char, Traits > >  lhs, basic_string_view< Char, Traits >  rhs  ) -> bool

constexprnoexcept

operator==() [1/15]

template<typename Char , typename Traits >

constexpr auto operator== ( basic_string_view< Char, Traits >  lhs, type_identity_t< basic_string_view< Char, Traits > >  rhs  ) -> bool

constexprnoexcept

Compares two views. All comparisons are done via the compare() member function (which itself is defined in terms of Traits::compare()):

Two views are equal if both the size of lhs and rhs are equal and each character in lhs has an equivalent character in rhs at the same position.

operator==() [2/15]

template<typename Char , typename Traits , etl::size_t Capacity>

constexpr auto operator== ( Char const *  lhs, etl::basic_inplace_string< Char, Capacity, Traits > const &  rhs  ) -> bool

constexprnoexcept

Compares the contents of a string with another string or a null-terminated array of Char.

Two strings are equal if both the size of lhs and rhs are equal and each character in lhs has equivalent character in rhs at the same position.

operator==() [3/15]

template<typename Char , typename Traits , etl::size_t Capacity>

constexpr auto operator== ( etl::basic_inplace_string< Char, Capacity, Traits > const &  lhs, Char const *  rhs  ) -> bool

constexprnoexcept

Compares the contents of a string with another string or a null-terminated array of Char.

Two strings are equal if both the size of lhs and rhs are equal and each character in lhs has equivalent character in rhs at the same position.

operator==() [4/15]

template<typename Char , typename Traits , etl::size_t Capacity1, etl::size_t Capacity2>

constexpr auto operator== ( etl::basic_inplace_string< Char, Capacity1, Traits > const &  lhs, etl::basic_inplace_string< Char, Capacity2, Traits > const &  rhs  ) -> bool

constexprnoexcept

Compares the contents of a string with another string or a null-terminated array of Char.

Two strings are equal if both the size of lhs and rhs are equal and each character in lhs has equivalent character in rhs at the same position.

operator==() [5/15]

template<typename Iter1 , typename Iter2 >

constexpr auto operator== ( etl::reverse_iterator< Iter1 > const &  lhs, etl::reverse_iterator< Iter2 > const &  rhs  ) -> bool

constexpr

Compares the underlying iterators. Inverse comparisons are applied in order to take into account that the iterator order is reversed.

operator==() [6/15]

template<typename R , typename... Args, size_t Capacity, size_t Alignment>

constexpr auto operator== ( inplace_function< R(Args...), Capacity, Alignment > const &  f, nullptr_t    ) -> bool

constexprnoexcept

Compares a etl::inplace_function with a null pointer. Empty functions (that is, functions without a callable target) compare equal, non-empty functions compare non-equal.

operator==() [7/15]

template<typename Rhs , Rhs R, typename Lhs , Lhs L>

constexpr auto operator== ( integral_constant< Rhs, R >  , integral_constant< Lhs, L >    ) -> integral_constant<bool, L == R>

constexpr

operator==() [8/15]

constexpr auto operator== ( language_standard  lhs, language_standard  rhs  ) -> bool

constexprnoexcept

Compares language_standards.

operator==() [9/15]

template<typename R , typename... Args, size_t Capacity, size_t Alignment>

constexpr auto operator== ( nullptr_t  , inplace_function< R(Args...), Capacity, Alignment > const &  f  ) -> bool

constexprnoexcept

Compares a etl::inplace_function with a null pointer. Empty functions (that is, functions without a callable target) compare equal, non-empty functions compare non-equal.

operator==() [10/15]

template<typename T1 , typename T2 >

constexpr auto operator== ( pair< T1, T2 > const &  lhs, pair< T1, T2 > const &  rhs  ) -> bool

constexpr

Tests if both elements of lhs and rhs are equal, that is, compares lhs.first with rhs.first and lhs.second with rhs.second.

operator==() [11/15]

template<typename Key , size_t Capacity, typename Comp >

constexpr auto operator== ( static_set< Key, Capacity, Comp > const &  lhs, static_set< Key, Capacity, Comp > const &  rhs  ) -> bool

constexpr

Compares the contents of two sets.

Checks if the contents of lhs and rhs are equal, that is, they have the same number of elements and each element in lhs compares equal with the element in rhs at the same position.

operator==() [12/15]

template<typename T , size_t Capacity>

constexpr auto operator== ( static_vector< T, Capacity > const &  lhs, static_vector< T, Capacity > const &  rhs  ) -> bool

constexprnoexcept

Compares the contents of two vectors.

Checks if the contents of lhs and rhs are equal, that is, they have the same number of elements and each element in lhs compares equal with the element in rhs at the same position.

operator==() [13/15]

template<typename CharT , CharT... Chars>

constexpr auto operator== ( string_constant< CharT, Chars... >  , string_constant< CharT, Chars... >    ) -> bool

constexprnoexcept

operator==() [14/15]

template<typename CharT , CharT... CharsL, CharT... CharsR>

constexpr auto operator== ( string_constant< CharT, CharsL... >  , string_constant< CharT, CharsR... >    ) -> bool

constexprnoexcept

operator==() [15/15]

template<typename... Ts, typename... Us>
requires (sizeof...(Ts) == sizeof...(Us))

constexpr auto operator== ( tuple< Ts... > const &  lhs, tuple< Us... > const &  rhs  ) -> bool

constexpr

operator>() [1/11]

template<typename Char , typename Traits >

constexpr auto operator> ( basic_string_view< Char, Traits >  lhs, basic_string_view< Char, Traits >  rhs  ) -> bool

constexprnoexcept

Compares two views. All comparisons are done via the compare() member function (which itself is defined in terms of Traits::compare()):

The ordering comparisons are done lexicographically – the comparison is performed by a function equivalent to lexicographical_compare.

operator>() [2/11]

template<typename Char , typename Traits , int = 2>

constexpr auto operator> ( basic_string_view< Char, Traits >  lhs, type_identity_t< basic_string_view< Char, Traits > >  rhs  ) -> bool

constexprnoexcept

operator>() [3/11]

template<typename Char , typename Traits , etl::size_t Capacity1>

constexpr auto operator> ( Char const *  lhs, etl::basic_inplace_string< Char, Capacity1, Traits > const &  rhs  ) -> bool

constexprnoexcept

Compares the contents of a string with another string or a null-terminated array of Char.

The ordering comparisons are done lexicographically.

operator>() [4/11]

template<typename Char , typename Traits , etl::size_t Capacity1>

constexpr auto operator> ( etl::basic_inplace_string< Char, Capacity1, Traits > const &  lhs, Char const *  rhs  ) -> bool

constexprnoexcept

Compares the contents of a string with another string or a null-terminated array of Char.

The ordering comparisons are done lexicographically.

operator>() [5/11]

template<typename Char , typename Traits , etl::size_t Capacity1, etl::size_t Capacity2>

constexpr auto operator> ( etl::basic_inplace_string< Char, Capacity1, Traits > const &  lhs, etl::basic_inplace_string< Char, Capacity2, Traits > const &  rhs  )

constexprnoexcept

Compares the contents of a string with another string or a null-terminated array of Char.

The ordering comparisons are done lexicographically.

operator>() [6/11]

template<typename Iter1 , typename Iter2 >

constexpr auto operator> ( etl::reverse_iterator< Iter1 > const &  lhs, etl::reverse_iterator< Iter2 > const &  rhs  ) -> bool

constexpr

Compares the underlying iterators. Inverse comparisons are applied in order to take into account that the iterator order is reversed.

operator>() [7/11]

constexpr auto operator> ( language_standard  lhs, language_standard  rhs  ) -> bool

constexprnoexcept

operator>() [8/11]

template<typename T1 , typename T2 >

constexpr auto operator> ( pair< T1, T2 > const &  lhs, pair< T1, T2 > const &  rhs  ) -> bool

constexpr

Compares lhs and rhs lexicographically by operator<, that is, compares the first elements and only if they are equivalent, compares the second elements.

operator>() [9/11]

template<typename Key , size_t Capacity, typename Comp >

constexpr auto operator> ( static_set< Key, Capacity, Comp > const &  lhs, static_set< Key, Capacity, Comp > const &  rhs  ) -> bool

constexpr

Compares the contents of two sets.

Compares the contents of lhs and rhs lexicographically. The comparison is performed by a function equivalent to lexicographical_compare. This comparison ignores the set's ordering Compare.

operator>() [10/11]

template<typename T , size_t Capacity>

constexpr auto operator> ( static_vector< T, Capacity > const &  lhs, static_vector< T, Capacity > const &  rhs  ) -> bool

constexprnoexcept

operator>() [11/11]

template<typename Char , typename Traits , int = 1>

constexpr auto operator> ( type_identity_t< basic_string_view< Char, Traits > >  lhs, basic_string_view< Char, Traits >  rhs  ) -> bool

constexprnoexcept

operator>=() [1/11]

template<typename Char , typename Traits >

constexpr auto operator>= ( basic_string_view< Char, Traits >  lhs, basic_string_view< Char, Traits >  rhs  ) -> bool

constexprnoexcept

Compares two views. All comparisons are done via the compare() member function (which itself is defined in terms of Traits::compare()):

The ordering comparisons are done lexicographically – the comparison is performed by a function equivalent to lexicographical_compare.

operator>=() [2/11]

template<typename Char , typename Traits , int = 2>

constexpr auto operator>= ( basic_string_view< Char, Traits >  lhs, type_identity_t< basic_string_view< Char, Traits > >  rhs  ) -> bool

constexprnoexcept

operator>=() [3/11]

template<typename Char , typename Traits , etl::size_t Capacity>

constexpr auto operator>= ( Char const *  lhs, etl::basic_inplace_string< Char, Capacity, Traits > const &  rhs  ) -> bool

constexprnoexcept

Compares the contents of a string with another string or a null-terminated array of Char.

The ordering comparisons are done lexicographically.

operator>=() [4/11]

template<typename Char , typename Traits , etl::size_t Capacity>

constexpr auto operator>= ( etl::basic_inplace_string< Char, Capacity, Traits > const &  lhs, Char const *  rhs  ) -> bool

constexprnoexcept

Compares the contents of a string with another string or a null-terminated array of Char.

The ordering comparisons are done lexicographically.

operator>=() [5/11]

template<typename Char , typename Traits , etl::size_t Capacity1, etl::size_t Capacity2>

constexpr auto operator>= ( etl::basic_inplace_string< Char, Capacity1, Traits > const &  lhs, etl::basic_inplace_string< Char, Capacity2, Traits > const &  rhs  )

constexprnoexcept

Compares the contents of a string with another string or a null-terminated array of Char.

The ordering comparisons are done lexicographically.

operator>=() [6/11]

template<typename Iter1 , typename Iter2 >

constexpr auto operator>= ( etl::reverse_iterator< Iter1 > const &  lhs, etl::reverse_iterator< Iter2 > const &  rhs  ) -> bool

constexpr

Compares the underlying iterators. Inverse comparisons are applied in order to take into account that the iterator order is reversed.

operator>=() [7/11]

constexpr auto operator>= ( language_standard  lhs, language_standard  rhs  ) -> bool

constexprnoexcept

operator>=() [8/11]

template<typename T1 , typename T2 >

constexpr auto operator>= ( pair< T1, T2 > const &  lhs, pair< T1, T2 > const &  rhs  ) -> bool

constexpr

Compares lhs and rhs lexicographically by operator<, that is, compares the first elements and only if they are equivalent, compares the second elements.

operator>=() [9/11]

template<typename Key , size_t Capacity, typename Comp >

constexpr auto operator>= ( static_set< Key, Capacity, Comp > const &  lhs, static_set< Key, Capacity, Comp > const &  rhs  ) -> bool

constexpr

Compares the contents of two sets.

Compares the contents of lhs and rhs lexicographically. The comparison is performed by a function equivalent to lexicographical_compare. This comparison ignores the set's ordering Compare.

operator>=() [10/11]

template<typename T , size_t Capacity>

constexpr auto operator>= ( static_vector< T, Capacity > const &  lhs, static_vector< T, Capacity > const &  rhs  ) -> bool

constexprnoexcept

operator>=() [11/11]

template<typename Char , typename Traits , int = 1>

constexpr auto operator>= ( type_identity_t< basic_string_view< Char, Traits > >  lhs, basic_string_view< Char, Traits >  rhs  ) -> bool

constexprnoexcept

operator>>()

template<etl::integral Int>

TETL_ALWAYS_INLINE constexpr auto operator>> ( etl::byte  b, Int  shift  ) -> etl::byte

constexprnoexcept

Equivalent to: return etl::byte(static_cast<unsigned int>(b) >> shift);

operator>>=()

template<etl::integral Int>

TETL_ALWAYS_INLINE constexpr auto operator>>= ( etl::byte &  b, Int  shift  ) -> etl::byte&

constexprnoexcept

Equivalent to: return b = b >> shift;

operator^() [1/2]

TETL_ALWAYS_INLINE constexpr auto operator^ ( etl::byte  lhs, etl::byte  rhs  ) -> etl::byte

constexprnoexcept

Equivalent to: return byte(static_cast<unsigned int>(lhs) ^ static_cast<unsigned int>(rhs));

operator^() [2/2]

template<bitmask_type T>

constexpr auto operator^ ( T  x, T  y  ) -> T

constexpr

operator^=() [1/2]

TETL_ALWAYS_INLINE constexpr auto operator^= ( etl::byte &  lhs, etl::byte  rhs  ) -> etl::byte&

constexprnoexcept

Equivalent to: return lhs = lhs ^ rhs;

operator^=() [2/2]

template<bitmask_type T>

constexpr auto operator^= ( T &  x, T  y  ) -> T const&

constexprnoexcept

operator|() [1/2]

TETL_ALWAYS_INLINE constexpr auto operator| ( etl::byte  lhs, etl::byte  rhs  ) -> etl::byte

constexprnoexcept

Equivalent to: return byte(static_cast<unsigned int>(lhs) | static_cast<unsigned int>(rhs));

operator|() [2/2]

template<bitmask_type T>

constexpr auto operator| ( T  x, T  y  ) -> T

constexpr

operator|=() [1/2]

TETL_ALWAYS_INLINE constexpr auto operator|= ( etl::byte &  lhs, etl::byte  rhs  ) -> etl::byte&

constexprnoexcept

Equivalent to: return lhs = lhs | rhs;

operator|=() [2/2]

template<bitmask_type T>

constexpr auto operator|= ( T &  x, T  y  ) -> T const&

constexprnoexcept

operator~() [1/2]

TETL_ALWAYS_INLINE constexpr auto operator~ ( etl::byte  b ) -> etl::byte

constexprnoexcept

Equivalent to: return byte(~static_cast<unsigned int>(b));

operator~() [2/2]

template<bitmask_type T>

constexpr auto operator~ ( T  x ) -> T

constexpr

overload()

template<typename... Functor>

overload

(

Functor...

)

-> overload< Functor... >

pair()

template<typename T1 , typename T2 >

pair	(	T1	,
		T2
	)		-> pair< T1, T2 >

partial_sort()

template<typename RandomIt >

constexpr auto partial_sort ( RandomIt  first, RandomIt  middle, RandomIt  last  ) -> void

constexpr

raise()

template<typename Exception >

TETL_NO_INLINE TETL_COLD auto raise	(	char const *	msg,
		etl::source_location const	loc = etl::source_location::current()
	)		-> void

ref() [1/2]

template<typename T >

constexpr auto ref ( reference_wrapper< T >  t ) -> reference_wrapper<T>

constexprnoexcept

Function templates ref and cref are helper functions that generate an object of type reference_wrapper, using template argument deduction to determine the template argument of the result.

ref() [2/2]

template<typename T >

constexpr auto ref ( T &  t ) -> reference_wrapper<T>

constexprnoexcept

Function templates ref and cref are helper functions that generate an object of type reference_wrapper, using template argument deduction to determine the template argument of the result.

reference_wrapper()

template<typename T >

reference_wrapper

(

T &

)

-> reference_wrapper< T >

scope_exit()

template<typename FuncT >

scope_exit

(

FuncT

)

-> scope_exit< decay_t< FuncT > >

signbit()

constexpr auto signbit ( half  arg ) -> bool

constexprnoexcept

span() [1/4]

template<typename Type , size_t Size>

span

(

array< Type, Size > &

)

-> span< Type, Size >

span() [2/4]

template<typename Type , size_t Size>

span

(

array< Type, Size > const &

)

-> span< Type const, Size >

span() [3/4]

template<typename Type , size_t Extent>

span

(

c_array< Type, Extent > &

)

-> span< Type, Extent >

span() [4/4]

template<ranges::range R>

span

(

R &&

)

-> span< remove_reference_t< ranges::range_reference_t< R > > >

stack()

template<typename Container >

stack

(

Container

)

-> stack< typename Container::value_type, Container >

stoi()

constexpr auto stoi ( etl::string_view  str, etl::size_t *  pos = nullptr, int  base = 10  ) -> int

constexpr

Interprets a signed integer value in the string str.

Parameters

str	The string to convert.
pos	Address of an integer to store the number of characters processed.
base	The number base.

Returns

Integer value corresponding to the content of str.

stol()

constexpr auto stol ( etl::string_view  str, etl::size_t *  pos = nullptr, int  base = 10  ) -> long

constexpr

Interprets a signed integer value in the string str.

Parameters

str	The string to convert.
pos	Address of an integer to store the number of characters processed.
base	The number base.

Returns

Integer value corresponding to the content of str.

stoll()

constexpr auto stoll ( etl::string_view  str, etl::size_t *  pos = nullptr, int  base = 10  ) -> long long

constexpr

Interprets a signed integer value in the string str.

Parameters

str	The string to convert.
pos	Address of an integer to store the number of characters processed.
base	The number base.

Returns

Integer value corresponding to the content of str.

stoul()

constexpr auto stoul ( etl::string_view  str, etl::size_t *  pos = nullptr, int  base = 10  ) -> unsigned long

constexpr

Interprets a signed integer value in the string str.

Parameters

str	The string to convert.
pos	Address of an integer to store the number of characters processed.
base	The number base.

Returns

Integer value corresponding to the content of str.

stoull()

constexpr auto stoull ( etl::string_view  str, etl::size_t *  pos = nullptr, int  base = 10  ) -> unsigned long long

constexpr

Interprets a signed integer value in the string str.

Parameters

str	The string to convert.
pos	Address of an integer to store the number of characters processed.
base	The number base.

Returns

Integer value corresponding to the content of str.

strided_slice()

template<typename OffsetType , typename ExtentType , typename StrideType >

strided_slice	(	OffsetType	,
		ExtentType	,
		StrideType
	)		-> strided_slice< OffsetType, ExtentType, StrideType >

strtod()

constexpr auto strtod ( char const *  str, char const **  last = nullptr  ) -> double

constexprnoexcept

Interprets a floating point value in a byte string pointed to by str.

Parameters

str	Pointer to the null-terminated byte string to be interpreted.
last	Pointer to a pointer to character.

Returns

Floating point value corresponding to the contents of str on success. If the converted value falls out of range of corresponding return type, range error occurs and HUGE_VAL, HUGE_VALF or HUGE_VALL is returned. If no conversion can be performed, 0 is returned and *last is set to str.

strtof()

constexpr auto strtof ( char const *  str, char const **  last = nullptr  ) -> float

constexprnoexcept

Interprets a floating point value in a byte string pointed to by str.

Parameters

str	Pointer to the null-terminated byte string to be interpreted.
last	Pointer to a pointer to character.

Returns

Floating point value corresponding to the contents of str on success. If the converted value falls out of range of corresponding return type, range error occurs and HUGE_VAL, HUGE_VALF or HUGE_VALL is returned. If no conversion can be performed, 0 is returned and *last is set to str.

strtol()

constexpr auto strtol ( char const *  str, char const **  last, int  base  ) -> long

constexprnoexcept

Interprets an integer value in a byte string pointed to by str.

https://en.cppreference.com/w/cpp/string/byte/strtol

strtold()

constexpr auto strtold ( char const *  str, char const **  last = nullptr  ) -> long double

constexprnoexcept

Interprets a floating point value in a byte string pointed to by str.

Parameters

str	Pointer to the null-terminated byte string to be interpreted.
last	Pointer to a pointer to character.

Returns

Floating point value corresponding to the contents of str on success. If the converted value falls out of range of corresponding return type, range error occurs and HUGE_VAL, HUGE_VALF or HUGE_VALL is returned. If no conversion can be performed, 0 is returned and *last is set to str.

strtoll()

constexpr auto strtoll ( char const *  str, char const **  last, int  base  ) -> long long

constexprnoexcept

Interprets an integer value in a byte string pointed to by str.

https://en.cppreference.com/w/cpp/string/byte/strtol

strtoul()

constexpr auto strtoul ( char const *  str, char const **  last, int  base  ) -> unsigned long

constexprnoexcept

Interprets an integer value in a byte string pointed to by str.

https://en.cppreference.com/w/cpp/string/byte/strtoul

strtoull()

constexpr auto strtoull ( char const *  str, char const **  last, int  base  ) -> unsigned long long

constexprnoexcept

Interprets an integer value in a byte string pointed to by str.

https://en.cppreference.com/w/cpp/string/byte/strtoul

submdspan_extents()

template<typename IndexT , etl::size_t... Extents, typename... SliceSpecifiers>
requires (sizeof...(slices) == etl::extents<IndexT, Extents...>::rank())

constexpr auto submdspan_extents ( etl::extents< IndexT, Extents... > const &  ext, SliceSpecifiers...  slices  )

constexpr

swap() [1/11]

template<typename Char , typename Traits , etl::size_t Capacity>

constexpr auto swap ( etl::basic_inplace_string< Char, Capacity, Traits > &  lhs, etl::basic_inplace_string< Char, Capacity, Traits > &  rhs  ) -> void

constexprnoexcept

Specializes the etl::swap algorithm for etl::basic_inplace_string. Swaps the contents of lhs and rhs. Equivalent to lhs.swap(rhs).

swap() [2/11]

template<typename R , typename... Args, size_t Capacity, size_t Alignment>

auto swap ( inplace_function< R(Args...), Capacity, Alignment > &  lhs, inplace_function< R(Args...), Capacity, Alignment > &  rhs  ) -> void

noexcept

Overloads the etl::swap algorithm for etl::inplace_function. Exchanges the state of lhs with that of rhs. Effectively calls lhs.swap(rhs).

Examples

utility.cpp.

swap() [3/11]

template<typename T1 , typename T2 >

constexpr auto swap ( pair< T1, T2 > &  lhs, pair< T1, T2 > &  rhs  ) -> void

constexprnoexcept

Swaps the contents of x and y. Equivalent to x.swap(y).

swap() [4/11]

template<typename T , typename C >
requires (is_swappable_v<C>)

constexpr auto swap ( stack< T, C > &  lhs, stack< T, C > &  rhs  ) -> void

constexprnoexcept

Specializes the swap algorithm for stack. Swaps the contents of lhs and rhs. This overload only participates in overload resolution if is_swappable<C>::value is true.

swap() [5/11]

template<typename Key , size_t Capacity, typename Compare >

constexpr auto swap ( static_set< Key, Capacity, Compare > &  lhs, static_set< Key, Capacity, Compare > &  rhs  ) -> void

constexprnoexcept

Specializes the swap algorithm for set. Swaps the contents of lhs and rhs. Calls lhs.swap(rhs).

swap() [6/11]

template<typename T , size_t Capacity>

constexpr auto swap ( static_vector< T, Capacity > &  lhs, static_vector< T, Capacity > &  rhs  ) -> void

constexprnoexcept

Specializes the swap algorithm for static_vector. Swaps the contents of lhs and rhs.

swap() [7/11]

template<typename T >

constexpr auto swap ( T &  a, T &  b  ) const -> void

constexprnoexcept

Exchanges the given values. Swaps the values a and b. This overload does not participate in overload resolution unless etl::is_move_constructible_v<T> && etl::is_move_assignable_v<T> is true.

https://en.cppreference.com/w/cpp/algorithm/swap

swap() [8/11]

template<typename T >
requires (etl::is_move_constructible_v<T> && etl::is_move_assignable_v<T>)

constexpr auto swap ( T &  a, T &  b  ) const -> void

constexprnoexcept

Exchanges the given values. Swaps the values a and b. This overload does not participate in overload resolution unless etl::is_move_constructible_v<T> && etl::is_move_assignable_v<T> is true.

https://en.cppreference.com/w/cpp/algorithm/swap

swap() [9/11]

template<typename T >
requires (etl::is_move_constructible_v<T> and etl::is_move_assignable_v<T>)

constexpr auto swap ( T &  a, T &  b  ) -> void

constexprnoexcept

Exchanges the given values. Swaps the values a and b. This overload does not participate in overload resolution unless etl::is_move_constructible_v<T> && etl::is_move_assignable_v<T> is true.

https://en.cppreference.com/w/cpp/algorithm/swap

swap() [10/11]

template<typename T , etl::size_t N>
requires (etl::is_swappable<T>::value)

constexpr auto swap ( T(&)  a[N], T(&)  b[N]  ) -> void

constexprnoexcept

swap() [11/11]

template<typename T , etl::size_t N>
requires (etl::is_swappable_v<T>)

constexpr auto swap ( T(&)  a[N], T(&)  b[N]  ) -> void

constexprnoexcept

test_implicit_default_constructible()

template<typename T >

void test_implicit_default_constructible

(

T

)

tie()

template<typename... Args>

constexpr auto tie ( Args &...  args ) -> tuple<Args&...>

constexprnoexcept

to_address() [1/2]

template<typename Ptr >

constexpr auto to_address ( Ptr const &  ptr )

constexprnoexcept

Obtain the address represented by p without forming a reference to the object pointed to by p.

Fancy pointer overload: If the expression pointer_traits<Ptr>::to_address(p) is well-formed, returns the result of that expression. Otherwise, returns to_address(p.operator->()).

to_address() [2/2]

template<typename T >
requires (not is_function_v<T>)

constexpr auto to_address ( T *  ptr ) -> T*

constexprnoexcept

Obtain the address represented by p without forming a reference to the object pointed to by p.

Raw pointer overload: If T is a function type, the program is ill-formed. Otherwise, returns p unmodified.

to_chars() [1/2]

constexpr auto to_chars ( char *  , char *  , bool  , int  = 10  ) -> to_chars_result=delete

constexprdelete

to_chars() [2/2]

template<integral T>
requires (not same_as<T, bool>)

constexpr auto to_chars ( char *  first, char *  last, T  val, int  base = 10  ) -> to_chars_result

constexpr

Converts value into a character string by successively filling the range [first, last), where [first, last) is required to be a valid range.

Integer formatters: value is converted to a string of digits in the given base (with no redundant leading zeroes). Digits in the range 10..35 (inclusive) are represented as lowercase characters a..z. If value is less than zero, the representation starts with a minus sign. The library provides overloads for all signed and unsigned integer types and for the type char as the type of the parameter value.

to_integer()

template<etl::integral Int>

constexpr auto to_integer ( etl::byte  b ) -> Int

constexprnoexcept

Equivalent to: return Int(b);

to_string() [1/6]

template<etl::size_t Capacity>

constexpr auto to_string ( int  value ) -> etl::inplace_string<Capacity>

constexprnoexcept

Converts a numeric value to etl::inplace_string.

to_string() [2/6]

template<etl::size_t Capacity>

constexpr auto to_string ( long long  value ) -> etl::inplace_string<Capacity>

constexprnoexcept

Converts a numeric value to etl::inplace_string.

to_string() [3/6]

template<etl::size_t Capacity>

constexpr auto to_string ( long  value ) -> etl::inplace_string<Capacity>

constexprnoexcept

Converts a numeric value to etl::inplace_string.

to_string() [4/6]

template<etl::size_t Capacity>

constexpr auto to_string ( unsigned long long  value ) -> etl::inplace_string<Capacity>

constexprnoexcept

Converts a numeric value to etl::inplace_string.

to_string() [5/6]

template<etl::size_t Capacity>

constexpr auto to_string ( unsigned long  value ) -> etl::inplace_string<Capacity>

constexprnoexcept

Converts a numeric value to etl::inplace_string.

to_string() [6/6]

template<etl::size_t Capacity>

constexpr auto to_string ( unsigned  value ) -> etl::inplace_string<Capacity>

constexprnoexcept

Converts a numeric value to etl::inplace_string.

to_underlying()

template<typename Enum >

constexpr auto to_underlying ( Enum  e ) -> underlying_type_t<Enum>

constexprnoexcept

Converts an enumeration to its underlying type.

https://en.cppreference.com/w/cpp/utility/to_underlying

tuple_cat()

template<etl::tuple_like... Tuples>

constexpr auto tuple_cat ( Tuples &&...  ts )

constexpr

unchecked_get() [1/4]

template<etl::size_t I, typename... Ts>

constexpr auto unchecked_get ( variant< Ts... > &&  v ) -> auto &&

related

unchecked_get() [2/4]

template<etl::size_t I, typename... Ts>

constexpr auto unchecked_get ( variant< Ts... > &  v ) -> auto &

related

unchecked_get() [3/4]

template<etl::size_t I, typename... Ts>

constexpr auto unchecked_get ( variant< Ts... > const &&  v ) -> auto const &&

related

unchecked_get() [4/4]

template<etl::size_t I, typename... Ts>

constexpr auto unchecked_get ( variant< Ts... > const &  v ) -> auto const &

related

unexpected()

template<typename E >

unexpected

(

E

)

-> unexpected< E >

uninitialized_copy()

template<typename InputIt , typename NoThrowForwardIt >

constexpr auto uninitialized_copy ( InputIt  first, InputIt  last, NoThrowForwardIt  dest  ) -> NoThrowForwardIt

constexpr

uninitialized_fill()

template<typename ForwardIt , typename T >

constexpr auto uninitialized_fill ( ForwardIt  first, ForwardIt  last, T const &  value  ) -> void

constexpr

uninitialized_move()

template<typename InputIt , typename NoThrowForwardIt >

constexpr auto uninitialized_move ( InputIt  first, InputIt  last, NoThrowForwardIt  dest  ) -> NoThrowForwardIt

constexpr

unreachable()

auto unreachable ( ) -> void

inline

vformat_to()

template<typename OutputIt >

auto vformat_to	(	OutputIt	out,
		string_view	fmt,
		format_args	args
	)		-> OutputIt

wcscat()

constexpr auto wcscat ( wchar_t *  dest, wchar_t const *  src  ) -> wchar_t*

constexpr

Appends a copy of the wide string pointed to by src to the end of the wide string pointed to by dest. The wide character src[0] replaces the null terminator at the end of dest. The resulting wide string is null-terminated.

The behavior is undefined if the destination array is not large enough for the contents of both src and dest and the terminating null character. The behavior is undefined if the strings overlap.

wcschr() [1/2]

constexpr auto wcschr ( wchar_t *  str, int  ch  ) -> wchar_t*

constexpr

Finds the first occurrence of the wide character ch in the wide string pointed to by str.

https://en.cppreference.com/w/cpp/string/wide/wcschr

wcschr() [2/2]

constexpr auto wcschr ( wchar_t const *  str, int  ch  ) -> wchar_t const*

constexpr

Finds the first occurrence of the wide character ch in the wide string pointed to by str.

https://en.cppreference.com/w/cpp/string/wide/wcschr

wcscmp()

constexpr auto wcscmp ( wchar_t const *  lhs, wchar_t const *  rhs  ) -> int

constexpr

Compares two null-terminated wide strings lexicographically.

The sign of the result is the sign of the difference between the values of the first pair of wide characters that differ in the strings being compared.

The behavior is undefined if lhs or rhs are not pointers to null-terminated wide strings.

wcscpy()

constexpr auto wcscpy ( wchar_t *  dest, wchar_t const *  src  ) -> wchar_t*

constexpr

Copies the wide string pointed to by src (including the terminating null wide character) to wide character array pointed to by dest.

The behavior is undefined if the dest array is not large enough. The behavior is undefined if the strings overlap.

Returns

dest

wcscspn()

constexpr auto wcscspn ( wchar_t const *  dest, wchar_t const *  src  ) -> etl::size_t

constexprnoexcept

Returns the length of the maximum initial segment of the wide string pointed to by dest, that consists of only the characters not found in wide string pointed to by src.

https://en.cppreference.com/w/cpp/string/wide/wcscspn

wcslen()

constexpr auto wcslen ( wchar_t const *  str ) -> size_t

constexpr

Returns the length of a wide string, that is the number of non-null wide characters that precede the terminating null wide character.

wcsncat()

constexpr auto wcsncat ( wchar_t *  dest, wchar_t const *  src, etl::size_t const  count  ) -> wchar_t*

constexpr

Appends at most count wide characters from the wide string pointed to by src to the end of the character string pointed to by dest, stopping if the null terminator is copied. The wide character src[0] replaces the null terminator at the end of dest. The null terminator is always appended in the end (so the maximum number of wide characters the function may write is count+1).

The destination byte string must have enough space for the contents of both dest and src plus the terminating null character, except that the size of src is limited to count. The behavior is undefined if the strings overlap.

wcsncmp()

constexpr auto wcsncmp ( wchar_t const *  lhs, wchar_t const *  rhs, etl::size_t  count  ) -> int

constexpr

Compares at most count wide characters of two null-terminated wide strings. The comparison is done lexicographically.

The sign of the result is the sign of the difference between the values of the first pair of wide characters that differ in the strings being compared.

The behavior is undefined if lhs or rhs are not pointers to null-terminated strings.

wcsncpy()

constexpr auto wcsncpy ( wchar_t *  dest, wchar_t const *  src, etl::size_t const  count  ) -> wchar_t*

constexpr

Copies at most count characters of the wide string pointed to by src (including the terminating null wide character) to wide character array pointed to by dest.

If count is reached before the entire string src was copied, the resulting character array is not null-terminated. If, after copying the terminating null character from src, count is not reached, additional null characters are written to dest until the total of count characters have been written. If the strings overlap, the behavior is undefined.

Returns

dest

wcspbrk() [1/2]

constexpr auto wcspbrk ( wchar_t *  dest, wchar_t *  breakset  ) -> wchar_t*

constexprnoexcept

Finds the first character in wide string pointed to by dest, that is also in wide string pointed to by str.

https://en.cppreference.com/w/cpp/string/wide/wcspbrk

wcspbrk() [2/2]

constexpr auto wcspbrk ( wchar_t const *  dest, wchar_t const *  breakset  ) -> wchar_t const*

constexprnoexcept

Finds the first character in wide string pointed to by dest, that is also in wide string pointed to by str.

https://en.cppreference.com/w/cpp/string/wide/wcspbrk

wcsrchr() [1/2]

constexpr auto wcsrchr ( wchar_t *  str, int  ch  ) -> wchar_t*

constexpr

Finds the last occurrence of the wide character ch in the wide string pointed to by str.

https://en.cppreference.com/w/cpp/string/wide/wcsrchr

wcsrchr() [2/2]

constexpr auto wcsrchr ( wchar_t const *  str, int  ch  ) -> wchar_t const*

constexpr

Finds the last occurrence of the wide character ch in the wide string pointed to by str.

https://en.cppreference.com/w/cpp/string/wide/wcsrchr

wcsspn()

constexpr auto wcsspn ( wchar_t const *  dest, wchar_t const *  src  ) -> etl::size_t

constexprnoexcept

Returns the length of the maximum initial segment of the wide string pointed to by dest, that consists of only the characters found in wide string pointed to by src.

https://en.cppreference.com/w/cpp/string/wide/wcsspn

wcsstr() [1/2]

constexpr auto wcsstr ( wchar_t *  haystack, wchar_t *  needle  ) -> wchar_t*

constexprnoexcept

Finds the first occurrence of the wide string needle in the wide string pointed to by haystack. The terminating null characters are not compared.

https://en.cppreference.com/w/cpp/string/wide/wcspbrk

wcsstr() [2/2]

constexpr auto wcsstr ( wchar_t const *  haystack, wchar_t const *  needle  ) -> wchar_t const*

constexprnoexcept

Finds the first occurrence of the wide string needle in the wide string pointed to by haystack. The terminating null characters are not compared.

https://en.cppreference.com/w/cpp/string/wide/wcspbrk

wmemchr() [1/2]

constexpr auto wmemchr ( wchar_t *  ptr, wchar_t  ch, etl::size_t  count  ) -> wchar_t*

constexprnoexcept

Locates the first occurrence of wide character ch in the initial count wide characters of the wide character array pointed to by ptr.

If count is zero, the function returns a null pointer.

https://en.cppreference.com/w/cpp/string/wide/wmemchr

wmemchr() [2/2]

constexpr auto wmemchr ( wchar_t const *  ptr, wchar_t  ch, etl::size_t  count  ) -> wchar_t const*

constexprnoexcept

Locates the first occurrence of wide character ch in the initial count wide characters of the wide character array pointed to by ptr.

If count is zero, the function returns a null pointer.

https://en.cppreference.com/w/cpp/string/wide/wmemchr

wmemcmp()

constexpr auto wmemcmp ( wchar_t const *  lhs, wchar_t const *  rhs, etl::size_t  count  ) -> int

constexprnoexcept

Compares the first count wide characters of the wide character arrays pointed to by lhs and rhs. The comparison is done lexicographically.

The sign of the result is the sign of the difference between the values of the first pair of wide characters that differ in the arrays being compared. If count is zero, the function does nothing.

https://en.cppreference.com/w/cpp/string/wide/wmemcmp

wmemcpy()

constexpr auto wmemcpy ( wchar_t *  dest, wchar_t const *  src, etl::size_t  count  ) -> wchar_t*

constexprnoexcept

Copies exactly count successive wide characters from the wide character array pointed to by src to the wide character array pointed to by dest. If the objects overlap, the behavior is undefined. If count is zero, the function does nothing.

https://en.cppreference.com/w/cpp/string/wide/wmemcpy

wmemmove()

constexpr auto wmemmove ( wchar_t *  dest, wchar_t const *  src, etl::size_t  count  ) -> wchar_t*

constexprnoexcept

Copies exactly count successive wide characters from the wide character array pointed to by src to the wide character array pointed to by dest.

If count is zero, the function does nothing. The arrays may overlap: copying takes place as if the wide characters were copied to a temporary wide character array and then copied from the temporary array to dest. This function is not locale-sensitive and pays no attention to the values of the wchar_t objects it copies: nulls as well as invalid characters are copied too.

https://en.cppreference.com/w/cpp/string/wide/wmemmove

wmemset()

constexpr auto wmemset ( wchar_t *  dest, wchar_t  ch, etl::size_t  count  ) -> wchar_t*

constexprnoexcept

Copies the wide character ch into each of the first count wide characters of the wide character array pointed to by dest.

If overflow occurs, the behavior is undefined. If count is zero, the function does nothing.

https://en.cppreference.com/w/cpp/string/wide/wmemset

Variable Documentation

alignment_of_v

template<typename T >

constexpr size_t alignment_of_v = alignment_of<T>::value

inlineconstexpr

allocator_arg

constexpr allocator_arg_t allocator_arg {}

inlineconstexpr

allocator_arg is a constant of type allocator_arg_t used to disambiguate, at call site, the overloads of the constructors and member functions of allocator-aware objects.

always_false

template<typename... T>

constexpr bool always_false = false

constexpr

and

template<typename T >

and

Initial value:

{
        { a - b } -> etl::integral

binary

constexpr auto binary = binary_t{}

inlineconstexpr

byte

enum TETL_MAY_ALIAS byte

strong

etl::byte is a distinct type that implements the concept of byte as specified in the C++ language definition.

Like char and unsigned char, it can be used to access raw memory occupied by other objects, but unlike those types, it is not a character type and is not an arithmetic type. A byte is only a collection of bits, and the only operators defined for it are the bitwise ones.

https://en.cppreference.com/w/cpp/types/byte

conjunction_v

template<typename... B>

constexpr bool conjunction_v = conjunction<B...>::value

inlineconstexpr

current_implementation

constexpr auto current_implementation = implementation::freestanding

inlineconstexpr

current_standard

constexpr auto current_standard = language_standard::cpp_26

inlineconstexpr

The currently configured C++ standard.

destroying_delete

constexpr auto destroying_delete = destroying_delete_t{}

inlineconstexpr

Tag type used to identify the destroying delete form of operator delete.

disjunction_v

template<typename... B>

constexpr bool disjunction_v = disjunction<B...>::value

inlineconstexpr

extent_v

template<typename T , unsigned N = 0>

constexpr auto extent_v = static_cast<size_t>(extent<T, N>::value)

inlineconstexpr

hardware_constructive_interference_size

constexpr auto hardware_constructive_interference_size = TETL_CACHELINE_SIZE

constexpr

Minimum offset between two objects to avoid false sharing. Guaranteed to be at least alignof(max_align_t).

hardware_destructive_interference_size

constexpr auto hardware_destructive_interference_size = TETL_CACHELINE_SIZE

constexpr

Maximum size of contiguous memory to promote true sharing. Guaranteed to be at least alignof(max_align_t).

has_unique_object_representations_v

template<typename T >

constexpr bool has_unique_object_representations_v = has_unique_object_representations<T>::value

inlineconstexpr

ignore

constexpr struct etl::ignore ignore

index_v

template<size_t I>

constexpr auto index_v = index_constant<I>{}

inlineconstexpr

is_abstract_v

template<typename T >

constexpr bool is_abstract_v = __is_abstract(T)

inlineconstexpr

is_aggregate_v

template<typename T >

constexpr bool is_aggregate_v = __is_aggregate(remove_cv_t<T>)

inlineconstexpr

is_arithmetic_v

template<typename T >

constexpr bool is_arithmetic_v = is_integral_v<T> or is_floating_point_v<T>

inlineconstexpr

is_array_v

template<typename T >

constexpr bool is_array_v = is_array<T>::value

inlineconstexpr

is_assignable_v

template<typename T , typename U >

constexpr bool is_assignable_v = __is_assignable(T, U)

inlineconstexpr

is_base_of_v

template<typename Base , typename Derived >

constexpr bool is_base_of_v = is_base_of<Base, Derived>::value

inlineconstexpr

is_bitmask_type_v

template<typename T >

constexpr auto is_bitmask_type_v = is_bitmask_type<T>::value

inlineconstexpr

is_bounded_array_v

template<typename T >

constexpr bool is_bounded_array_v = is_bounded_array<T>::value

inlineconstexpr

is_class_v

template<typename T >

constexpr bool is_class_v = __is_class(T)

inlineconstexpr

is_compound_v

template<typename T >

constexpr bool is_compound_v = not is_fundamental_v<T>

inlineconstexpr

is_const_v

template<typename T >

constexpr bool is_const_v = is_const<T>::value

inlineconstexpr

Examples

utility.cpp.

is_constructible_v

template<typename T , typename... Args>

constexpr bool is_constructible_v = is_constructible<T, Args...>::value

inlineconstexpr

is_convertible_v

template<typename From , typename To >

constexpr bool is_convertible_v = is_convertible<From, To>::value

inlineconstexpr

is_copy_assignable_v

template<typename T >

constexpr bool is_copy_assignable_v = is_copy_assignable<T>::value

inlineconstexpr

is_copy_constructible_v

template<typename T >

constexpr bool is_copy_constructible_v = is_copy_constructible<T>::value

inlineconstexpr

is_default_constructible_v

template<typename T >

constexpr bool is_default_constructible_v = is_default_constructible<T>::value

inlineconstexpr

is_destructible_v

template<typename T >

constexpr auto is_destructible_v = is_destructible<T>::value

inlineconstexpr

is_empty_v

template<typename T >

constexpr bool is_empty_v = is_empty<T>::value

inlineconstexpr

is_enum_v

template<typename T >

constexpr bool is_enum_v = __is_enum(T)

inlineconstexpr

is_error_condition_enum_v

template<typename T >

constexpr auto is_error_condition_enum_v = is_error_condition_enum<T>::value

inlineconstexpr

is_etl_array

template<typename T >

constexpr auto is_etl_array = false

inlineconstexpr

is_etl_array< array< T, Size > >

template<typename T , size_t Size>

constexpr auto is_etl_array< array< T, Size > > = true

inlineconstexpr

is_final_v

template<typename T >

constexpr bool is_final_v = __is_final(T)

inlineconstexpr

is_floating_point_v

template<typename T >

constexpr bool is_floating_point_v = is_floating_point<T>::value

inlineconstexpr

is_function_v

template<typename T >

constexpr bool is_function_v = is_function<T>::value

inlineconstexpr

Checks whether T is a function type. Types like etl::inplace_function, lambdas, classes with overloaded operator() and pointers to functions don't count as function types. Provides the member constant value which is equal to true, if T is a function type. Otherwise, value is equal to false.

The behavior of a program that adds specializations for is_function or is_function_v is undefined.

is_fundamental_v

template<typename T >

constexpr bool is_fundamental_v = is_fundamental<T>::value

inlineconstexpr

is_implicit_default_constructible_v

template<typename T >

constexpr auto is_implicit_default_constructible_v = is_implicit_default_constructible<T>::value

inlineconstexpr

is_integral_v

template<typename T >

constexpr bool is_integral_v

inlineconstexpr

Initial value:

= mpl::contains_v<
    remove_cv_t<T>,
    mpl::list<
        bool,
        char,
        signed char,
        unsigned char,
        wchar_t,
        char8_t,
        char16_t,
        char32_t,
        short,
        unsigned short,
        int,
        unsigned int,
        long,
        unsigned long,
        long long,
        unsigned long long
    >
>

is_invocable_r_v

template<typename R , typename Fn , typename... ArgTypes>

constexpr auto is_invocable_r_v = is_invocable_r<R, Fn, ArgTypes...>::value

inlineconstexpr

is_invocable_v

template<typename Fn , typename... ArgTypes>

constexpr auto is_invocable_v = is_invocable<Fn, ArgTypes...>::value

inlineconstexpr

is_lvalue_reference_v

template<typename T >

constexpr bool is_lvalue_reference_v = is_lvalue_reference<T>::value

inlineconstexpr

is_member_function_pointer_v

template<typename T >

constexpr bool is_member_function_pointer_v = is_member_function_pointer<T>::value

inlineconstexpr

is_member_object_pointer_v

template<typename T >

constexpr bool is_member_object_pointer_v = is_member_object_pointer<T>::value

inlineconstexpr

is_member_pointer_v

template<typename T >

constexpr bool is_member_pointer_v = is_member_pointer<T>::value

inlineconstexpr

is_move_assignable_v

template<typename T >

constexpr bool is_move_assignable_v = is_move_assignable<T>::value

inlineconstexpr

is_move_constructible_v

template<typename T >

constexpr bool is_move_constructible_v = is_move_constructible<T>::value

inlineconstexpr

is_nothrow_assignable_v

template<typename T , typename U >

constexpr bool is_nothrow_assignable_v = is_nothrow_assignable<T, U>::value

inlineconstexpr

is_nothrow_constructible_v

template<typename T , typename... Args>

constexpr bool is_nothrow_constructible_v = is_nothrow_constructible<T, Args...>::value

inlineconstexpr

is_nothrow_convertible_v

template<typename From , typename To >

constexpr bool is_nothrow_convertible_v = is_nothrow_convertible<From, To>::value

inlineconstexpr

is_nothrow_copy_assignable_v

template<typename T >

constexpr bool is_nothrow_copy_assignable_v = is_nothrow_copy_assignable<T>::value

inlineconstexpr

is_nothrow_copy_constructible_v

template<typename T >

constexpr bool is_nothrow_copy_constructible_v = is_nothrow_copy_constructible<T>::value

inlineconstexpr

is_nothrow_default_constructible_v

template<typename T >

constexpr bool is_nothrow_default_constructible_v = is_nothrow_default_constructible<T>::value

inlineconstexpr

is_nothrow_destructible_v

template<typename T >

constexpr bool is_nothrow_destructible_v = is_nothrow_destructible<T>::value

inlineconstexpr

is_nothrow_move_assignable_v

template<typename T >

constexpr bool is_nothrow_move_assignable_v = is_nothrow_move_assignable<T>::value

inlineconstexpr

is_nothrow_move_constructible_v

template<typename T >

constexpr bool is_nothrow_move_constructible_v = is_nothrow_move_constructible<T>::value

inlineconstexpr

is_nothrow_swappable_v

template<typename T >

constexpr bool is_nothrow_swappable_v = is_nothrow_swappable<T>::value

inlineconstexpr

is_null_pointer_v

template<typename T >

constexpr bool is_null_pointer_v = is_null_pointer<T>::value

inlineconstexpr

is_object_v

template<typename T >

constexpr bool is_object_v = is_object<T>::value

inlineconstexpr

is_placeholder_v

template<typename T >

constexpr int is_placeholder_v = is_placeholder<T>::value

inlineconstexpr

is_pointer_v

template<typename T >

constexpr bool is_pointer_v = is_pointer<T>::value

inlineconstexpr

is_polymorphic_v

template<typename T >

constexpr bool is_polymorphic_v = __is_polymorphic(T)

inlineconstexpr

is_reference_v

template<typename T >

constexpr bool is_reference_v = is_reference<T>::value

inlineconstexpr

is_reference_wrapper_v

template<typename T >

constexpr bool is_reference_wrapper_v = is_reference_wrapper<T>::value

inlineconstexpr

is_rvalue_reference_v

template<typename T >

constexpr bool is_rvalue_reference_v = is_rvalue_reference<T>::value

inlineconstexpr

is_scalar_v

template<typename T >

constexpr bool is_scalar_v = is_scalar<T>::value

inlineconstexpr

is_scoped_enum_v

template<typename T >

constexpr bool is_scoped_enum_v = is_scoped_enum<T>::value

inlineconstexpr

Checks whether T is an scoped enumeration type. Provides the member constant value which is equal to true, if T is an scoped enumeration type. Otherwise, value is equal to false. The behavior of a program that adds specializations for is_scoped_enum or is_scoped_enum_v is undefined.

https://en.cppreference.com/w/cpp/types/is_scoped_enum

is_signed_v

template<typename T >

constexpr bool is_signed_v = is_signed<T>::value

inlineconstexpr

is_specialized_v

template<template< typename... > typename Template, typename T , typename Tag = void>

constexpr bool is_specialized_v = is_specialized<Template, T, Tag>::value

inlineconstexpr

is_standard_layout_v

template<typename T >

constexpr bool is_standard_layout_v = is_standard_layout<T>::value

inlineconstexpr

is_swappable_v

template<typename T >

constexpr bool is_swappable_v = is_swappable<T>::value

inlineconstexpr

is_swappable_with_v

template<typename T , typename U >

constexpr bool is_swappable_with_v = is_swappable_with<T, U>::value

inlineconstexpr

is_trivial_v

template<typename T >

constexpr bool is_trivial_v = is_trivial<T>::value

inlineconstexpr

is_trivially_assignable_v

template<typename T , typename U >

constexpr bool is_trivially_assignable_v = is_trivially_assignable<T, U>::value

inlineconstexpr

is_trivially_constructible_v

template<typename T , typename... Args>

constexpr bool is_trivially_constructible_v = is_trivially_constructible<T, Args...>::value

inlineconstexpr

is_trivially_copy_assignable_v

template<typename T >

constexpr bool is_trivially_copy_assignable_v = is_trivially_copy_assignable<T>::value

inlineconstexpr

is_trivially_copy_constructible_v

template<typename T >

constexpr bool is_trivially_copy_constructible_v = is_trivially_copy_constructible<T>::value

inlineconstexpr

is_trivially_copyable_v

template<typename T >

constexpr bool is_trivially_copyable_v = __is_trivially_copyable(T)

inlineconstexpr

is_trivially_default_constructible_v

template<typename T >

constexpr bool is_trivially_default_constructible_v = is_trivially_default_constructible<T>::value

inlineconstexpr

is_trivially_destructible_v

template<typename T >

constexpr bool is_trivially_destructible_v = __has_trivial_destructor(T)

inlineconstexpr

is_trivially_move_assignable_v

template<typename T >

constexpr bool is_trivially_move_assignable_v = is_trivially_move_assignable<T>::value

inlineconstexpr

is_trivially_move_constructible_v

template<typename T >

constexpr auto is_trivially_move_constructible_v = is_trivially_move_constructible<T>::value

inlineconstexpr

is_tuple_like

template<typename T >

constexpr auto is_tuple_like< etl::tuple< Ts... > > = false

related

is_unbounded_array_v

template<typename T >

constexpr bool is_unbounded_array_v = is_unbounded_array<T>::value

inlineconstexpr

is_union_v

template<typename T >

constexpr bool is_union_v = __is_union(T)

inlineconstexpr

is_unsigned_v

template<typename T >

constexpr bool is_unsigned_v = is_unsigned<T>::value

inlineconstexpr

is_void_v

template<typename T >

constexpr bool is_void_v = is_same_v<void, remove_cv_t<T>>

inlineconstexpr

is_volatile_v

template<typename T >

constexpr bool is_volatile_v = is_volatile<T>::value

inlineconstexpr

negation_v

template<typename B >

constexpr bool negation_v = not static_cast<bool>(B::value)

inlineconstexpr

nontype

template<auto V>

constexpr auto nontype = etl::nontype_t<V>{}

inlineconstexpr

nothrow

constexpr auto nothrow = etl::nothrow_t{}

inlineconstexpr

etl::nothrow is a constant of type etl::nothrow_t used to disambiguate the overloads of throwing and non-throwing allocation functions.

piecewise_construct

constexpr auto piecewise_construct = piecewise_construct_t{}

inlineconstexpr

The constant etl::piecewise_construct is an instance of an empty struct tag type etl::piecewise_construct_t.

rank_v

template<typename Type >

constexpr size_t rank_v = rank<Type>::value

inlineconstexpr

sorted_equivalent

constexpr auto sorted_equivalent = sorted_equivalent_t{}

inlineconstexpr

sorted_unique

constexpr auto sorted_unique = sorted_unique_t{}

inlineconstexpr

tuple_size_v

template<typename T >

constexpr auto tuple_size_v = tuple_size<T>::value

inlineconstexpr

uses_allocator_v

template<typename Type , typename Alloc >

constexpr auto uses_allocator_v = uses_allocator<Type, Alloc>::value

inlineconstexpr

If T has a member typedef allocator_type which is convertible from Alloc, the member constant value is true. Otherwise value is false.

variant_size_v

template<typename T >

constexpr auto variant_size_v = variant_size<T>::value

inlineconstexpr