sl::concepts Namespace Reference

Concepts
concept	right_shiftable_with
	Determines whether two types can be used in operator >> statements.
concept	right_shiftable_with_r
	Determines whether two types can be used in operator >> statements and checks if the return type is convertible to the expected.
concept	right_shiftable
	Determines whether the given type can be used on both sides of operator >> statements.
concept	right_shiftable_r
	Determines whether the given type can be used on both sides of operator >> statements and checks if the return type is convertible to the expected.
concept	left_shiftable_with
	Determines whether two types can be used in operator << statements.
concept	left_shiftable_with_r
	Determines whether two types can be used in operator << statements and checks if the return type is convertible to the expected.
concept	left_shiftable
	Determines whether the given type can be used on both sides of operator << statements.
concept	left_shiftable_r
	Determines whether the given type can be used on both sides of operator << statements and checks if the return type is convertible to the expected.
concept	bidirectional_shiftable_with
	Determines whether two types can be used in operator >> and operator << statements.
concept	bidirectional_shiftable_with_r
	Determines whether two types can be used in operator >> and operator << statements and checks if the return type is convertible to the expected.
concept	bidirectional_shiftable
	Determines whether the given type can be used on both sides of operator << and operator >> statements.
concept	bidirectional_shiftable_r
	Determines whether the given type can be used on both sides of operator >> and operator << statements and checks if the return type is convertible to the expected.
concept	right_shift_assignable_with
	Determines whether two types can be used in operator >>= statements.
concept	right_shift_assignable_with_r
	Determines whether two types can be used in operator >>= statements and checks if the return type is convertible to the expected.
concept	right_shift_assignable
	Determines whether the given type can be used on both sides of operator >>= statements.
concept	right_shift_assignable_r
	Determines whether the given type can be used on both sides of operator >>= statements and checks if the return type is convertible to the expected.
concept	left_shift_assignable_with
	Determines whether two types can be used in operator <<= statements.
concept	left_shift_assignable_with_r
	Determines whether two types can be used in operator <<= statements and checks if the return type is convertible to the expected.
concept	left_shift_assignable
	Determines whether the given type can be used on both sides of operator <<= statements.
concept	left_shift_assignable_r
	Determines whether the given type can be used on both sides of operator <<= statements and checks if the return type is convertible to the expected.
concept	bidirectional_shift_assignable_with
	Determines whether two types can be used in operator >>= and operator <<= statements.
concept	bidirectional_shift_assignable_with_r
	Determines whether two types can be used in operator >>= and operator <<= statements and checks if the return type is convertible to the expected.
concept	bidirectional_shift_assignable
	Determines whether the given type can be used on both sides of operator <<= and operator >>= statements.
concept	bidirectional_shift_assignable_r
	Determines whether the given type can be used on both sides of operator <<= and operator >>= statements and checks if the return type is convertible to the expected.
concept	fully_shiftable_with
	Determines whether two types can be used in operator <<, >>, <<= and >>= statements.
concept	fully_shiftable_with_r
	Determines whether two types can be used in operator <<, >>, <<= and >>= statements and checks if the return types are convertible to the expected ones.
concept	fully_shiftable
	Determines whether the given type can be used on both sides of operator <<, >>, <<= and >>= statements.
concept	fully_shiftable_r
	Determines whether the given type can be used on both sides of operator <<, >>, <<= and >>= statements and checks if the return types are convertible to the expected ones.
concept	complemented
	Determines whether a type can be used in operator ~ expression.
concept	complemented_r
	Determines whether a type can be used in operator ~ expression and if the return type is convertible to the expected one.
concept	conjunctive_with
	Determines whether two types can be used in operator & expressions.
concept	conjunctive_with_r
	Determines whether two types can be used in operator & expressions and if the return type is convertible to the expected one.
concept	conjunctive
	Determines whether a type can be used on both sides of operator & expressions.
concept	conjunctive_r
	Determines whether a type can be used on both sides of operator & expressions and if the return type is convertible to the expected one.
concept	conjunctive_assign_with
	Determines whether two types can be used in operator &= expressions.
concept	conjunctive_assign_with_r
	Determines whether two types can be used in operator &= expressions and if the return type is convertible to the expected one.
concept	conjunctive_assign
	Determines whether a type can be used on both sides of operator &= expressions.
concept	conjunctive_assign_r
	Determines whether a type can be used on both sides of operator &= expressions and if the return type is convertible to the expected one.
concept	disjunctive_with
	Determines whether two types can be used in operator | expressions.
concept	disjunctive_with_r
	Determines whether two types can be used in operator | expressions and if the return type is convertible to the expected one.
concept	disjunctive
	Determines whether a type can be used on both sides of operator | expressions.
concept	disjunctive_r
	Determines whether a type can be used on both sides of operator | expressions and if the return type is convertible to the expected one.
concept	disjunctive_assign_with
	Determines whether two types can be used in operator |= expressions.
concept	disjunctive_assign_with_r
	Determines whether two types can be used in operator |= expressions and if the return type is convertible to the expected one.
concept	disjunctive_assign
	Determines whether a type can be used on both sides of operator |= expressions.
concept	disjunctive_assign_r
	Determines whether a type can be used on both sides of operator |= expressions and if the return type is convertible to the expected one.
concept	exclusive_disjunctive_with
	Determines whether two types can be used in operator ^ expressions.
concept	exclusive_disjunctive_with_r
	Determines whether two types can be used in operator ^ expressions and if the return type is convertible to the expected one.
concept	exclusive_disjunctive
	Determines whether a type can be used on both sides of operator ^ expressions.
concept	exclusive_disjunctive_r
	Determines whether a type can be used on both sides of operator ^ expressions and if the return type is convertible to the expected one.
concept	exclusive_disjunctive_assign_with
	Determines whether two types can be used in operator ^= expressions.
concept	exclusive_disjunctive_assign_with_r
	Determines whether two types can be used in operator ^= expressions and if the return type is convertible to the expected one.
concept	exclusive_disjunctive_assign
	Determines whether a type can be used on both sides of operator ^= expressions.
concept	exclusive_disjunctive_assign_r
	Determines whether a type can be used on both sides of operator ^= expressions and if the return type is convertible to the expected one.
concept	logically_combinable_with
	Determines whether two types can be used in operator &, | amd ^ expressions.
concept	logically_combinable_with_r
	Determines whether two types can be used in operator &, | amd ^ expressions and if the return type is convertible to the expected one.
concept	logically_combinable
	Determines whether a type can be used on both sides of operator &, | and ^ expressions.
concept	logically_combinable_r
	Determines whether a type can be used on both sides of operator &, | and ^ expressions and if the return type is convertible to the expected one.
concept	logically_assignable_with
	Determines whether two types can be used in operator &=, |= and ^= expressions.
concept	logically_assignable_with_r
	Determines whether two types can be used in operator &=, |= and ^= expressions and if the return type is convertible to the expected one.
concept	logically_assignable
	Determines whether a type can be used on both sides of operator &=, |= and ^= expressions.
concept	logically_assignable_r
	Determines whether a type can be used on both sides of operator &=, |= and ^= expressions and if the return type is convertible to the expected one.
concept	fully_logical_with
	Determines whether two types can be used in operator &, |, ^, &=, |=, ^= and ~ expressions.
concept	fully_logical_with_r
	Determines whether two types can be used in operator &, |, ^, &=, |=, ^= and ~ expressions and if the return types are convertible to the expected ones.
concept	fully_logical
	Determines whether a type can be used on both sides of operator &, |, ^, &=, |=, ^= and ~ expressions.
concept	fully_logical_r
	Determines whether a type can be used on both sides of operator &, |, ^, &=, |=, ^= and ~ expressions and if the return types are convertible to the expected ones.
concept	invertible
concept	invertible_r
concept	dereferencable
	Determines whether a type can be used in unary operator * expressions.
concept	dereferencable_r
	Determines whether a type can be used in unary operator * expressions and if the return type is convertible to the expected one.
concept	arrow_dereferencable
	Determines whether a type can be used in operator -> expressions.
concept	arrow_dereferencable_r
	Determines whether a type can be used in operator -> expressions and if the return type is convertible to the expected one.
concept	index_dereferencable
	Determines whether a type can be used in operator [] expressions.
concept	index_dereferencable_r
	Determines whether a type can be used in operator -> expressions and if the return type is convertible to the expected one.
concept	negate
	Determines whether a type can be used in operator - expression.
concept	negate_r
	Determines whether a type can be used in operator - expression and if the return type is convertible to the expected one.
concept	plus_with
	Determines whether two types can be used in operator + expressions.
concept	plus_with_r
	Determines whether two types can be used in operator + expressions and if the return type is convertible to the expected one.
concept	plus
	Determines whether a type can be used on both sides of operator + expressions.
concept	plus_r
	Determines whether a type can be used on both sides of operator + expressions and if the return type is convertible to the expected one.
concept	plus_assign_with
	Determines whether two types can be used in operator += expressions.
concept	plus_assign_with_r
	Determines whether two types can be used in operator += expressions and if the return type is convertible to the expected one.
concept	plus_assign
	Determines whether a type can be used on both sides of operator += expressions.
concept	plus_assign_r
	Determines whether a type can be used on both sides of operator += expressions and if the return type is convertible to the expected one.
concept	minus_with
	Determines whether two types can be used in operator - expressions.
concept	minus_with_r
	Determines whether two types can be used in operator - expressions and if the return type is convertible to the expected one.
concept	minus
	Determines whether a type can be used on both sides of operator - expressions.
concept	minus_r
	Determines whether a type can be used on both sides of operator - expressions and if the return type is convertible to the expected one.
concept	minus_assign_with
	Determines whether two types can be used in operator -= expressions.
concept	minus_assign_with_r
	Determines whether two types can be used in operator -= expressions and if the return type is convertible to the expected one.
concept	minus_assign
	Determines whether a type can be used on both sides of operator -= expressions.
concept	minus_assign_r
	Determines whether a type can be used on both sides of operator -= expressions and if the return type is convertible to the expected one.
concept	multiplies_with
	Determines whether two types can be used in operator * expressions.
concept	multiplies_with_r
	Determines whether two types can be used in operator * expressions and if the return type is convertible to the expected one.
concept	multiplies
	Determines whether a type can be used on both sides of operator * expressions.
concept	multiplies_r
	Determines whether a type can be used on both sides of operator * expressions and if the return type is convertible to the expected one.
concept	multiplies_assign_with
	Determines whether two types can be used in operator *= expressions.
concept	multiplies_assign_with_r
	Determines whether two types can be used in operator *= expressions and if the return type is convertible to the expected one.
concept	multiplies_assign
	Determines whether a type can be used on both sides of operator *= expressions.
concept	multiplies_assign_r
	Determines whether a type can be used on both sides of operator *= expressions and if the return type is convertible to the expected one.
concept	divides_with
	Determines whether two types can be used in operator / expressions.
concept	divides_with_r
	Determines whether two types can be used in operator / expressions and if the return type is convertible to the expected one.
concept	divides
	Determines whether a type can be used on both sides of operator / expressions.
concept	divides_r
	Determines whether a type can be used on both sides of operator / expressions and if the return type is convertible to the expected one.
concept	divides_assign_with
	Determines whether two types can be used in operator /= expressions.
concept	divides_assign_with_r
	Determines whether two types can be used in operator /= expressions and if the return type is convertible to the expected one.
concept	divides_assign
	Determines whether a type can be used on both sides of operator /= expressions.
concept	divides_assign_r
	Determines whether a type can be used on both sides of operator /= expressions and if the return type is convertible to the expected one.
concept	modulus_with
	Determines whether two types can be used in operator % expressions.
concept	modulus_with_r
	Determines whether two types can be used in operator % expressions and if the return type is convertible to the expected one.
concept	modulus
	Determines whether a type can be used on both sides of operator % expressions.
concept	modulus_r
	Determines whether a type can be used on both sides of operator % expressions and if the return type is convertible to the expected one.
concept	modulus_assign_with
	Determines whether two types can be used in operator %= expressions.
concept	modulus_assign_with_r
	Determines whether two types can be used in operator %= expressions and if the return type is convertible to the expected one.
concept	modulus_assign
	Determines whether a type can be used on both sides of operator %= expressions.
concept	modulus_assign_r
	Determines whether a type can be used on both sides of operator %= expressions and if the return type is convertible to the expected one.
concept	arithmetically_combinable_with
	Determines whether two types can be used in operator +, -, * and / expressions.
concept	arithmetically_combinable_with_r
	Determines whether two types can be used in operator +, -, * and / expressions and if the return type is convertible to the expected one.
concept	arithmetically_combinable
	Determines whether a type can be used on both sides of operator +, -, * and / expressions.
concept	arithmetically_combinable_r
	Determines whether a type can be used on both sides of operator +, -, * and / expressions and if the return type is convertible to the expected one.
concept	arithmetically_assignable_with
	Determines whether two types can be used in operator +=, -=, *= and /= expressions.
concept	arithmetically_assignable_with_r
	Determines whether two types can be used in operator +=, -=, *= and /= expressions and if the return type is convertible to the expected one.
concept	arithmetically_assignable
	Determines whether a type can be used on both sides of operator +=, -=, *= and /= expressions.
concept	arithmetically_assignable_r
	Determines whether a type can be used on both sides of operator +=, -=, *= and /= expressions and if the return type is convertible to the expected one.
concept	fully_arithmetical_with
	Determines whether two types can be used in operator +, -, *, /, +=, -=, *=, /= and unary - expressions.
concept	fully_arithmetical_with_r
	Determines whether two types can be used in operator +, -, *, /, +=, -=, *=, /= and unary - expressions and if the return types are convertible to the expected ones.
concept	fully_arithmetical
	Determines whether a type can be used on both sides of operator +, -, *, /, +=, -=, *=, /= and unary - expressions.
concept	fully_arithmetical_r
	Determines whether a type can be used on both sides of operator +, -, *, /, +=, -=, *=, /= and unary - expressions and if the return types are convertible to the expected ones.
concept	pointer
	Checks whether the T denotes a (possibly cv-qualified) pointer type.
concept	reference
	Checks whether the T denotes a reference type.
concept	decayed
	Checks whether the T denotes a decayed type.
concept	unqualified
	Checks whether the T denotes an unqualified type.
concept	not_same_as
	Checks whether the left-hand-side type is unequal to the right-hand-side type.
concept	initializes
	Checks whether the target type is constructible from the source type.
concept	assignable_to
	Checks whether the target type is assignable from the source type.
concept	weakly_equality_comparable
	Checks whether the given type is comparable via operator == and !=.
concept	nothrow_weakly_equality_comparable
	Checks whether the given type is comparable via operator == and != and has noexcept specifier.
concept	weakly_equality_comparable_with
	Checks whether a symmetrical set of operators == and != to compare both types with each other exists.
concept	nothrow_weakly_equality_comparable_with
	Checks whether a symmetrical set of operators == and != to compare both types with each other exists and has noexcept specifier.
concept	comparison_category
	Checks whether the given type denotes a common stl comparison category.
concept	explicitly_convertible_to
	Checks whether a type is explicit convertible to another.
concept	nothrow_explicitly_convertible_to
	Checks whether a type is explicit convertible to another and does not throw.
concept	weakly_three_way_comparable
	Checks whether the given type is comparable <=> with the minimal comparison category. This also implies equality comparable.
concept	nothrow_weakly_three_way_comparable
	Checks whether the given type is comparable <=> with the minimal comparison category and noexcept specifier. This also implies equality comparable.
concept	weakly_three_way_comparable_with
	Checks whether a symmetrical set of operator <=> to compare both types with each other exists.
concept	nothrow_weakly_three_way_comparable_with
	Checks whether a symmetrical set of operator <=> to compare both types with each other with noexcept specifier exists.
concept	unique_types
	Checks whether each given type appears only once in the template argument pack.
concept	tuple
	Determines whether a type can be used as a tuple-like.
concept	applicable
	Determines whether the function is invocable with the elements of the given tuple.
concept	nothrow_applicable
	Determines whether the function is invocable with the elements of the given tuple without throwing.
concept	type_list
	Determines whether a type satisfies the requirements of a type-list.
concept	populated_type_list
	Determines whether a type is a type-list and contains elements.

Variables
template<class T , class... TArgs>
constexpr bool	are_types_unique_v = (!std::same_as<T, TArgs> && ...) && are_types_unique_v<TArgs...>
	Trait for determining if all types of a parameter pack are unique.
template<class T >
constexpr bool	are_types_unique_v< T > = true
	Trait overload for single type parameter packs. Returns always true.