kumi Namespace Reference

Main KUMI namespace. More...

Detailed Description

Main KUMI namespace.

Classes
struct	all_unique_names
	Checks if a parameter pack only contains distinct kumi::field_member names. Evaluates to false if no type is a kumi::field_member. More...
struct	all_uniques
	Checks if a parameter pack only contains distinct types. More...
class	as
	Lightweight type-wrapper. More...
struct	as_tuple
	Generate a kumi::tuple type from a type. More...
class	boolean_and
	A type representing the logical and monoid and it's associated identity. The identity of the boolean_and is true. More...
class	boolean_or
	A type representing the logical or monoid and it's associated identity. The identity of boolean_or is false. More...
class	boolean_xor
	A type representing the logical xor monoid and it's associated identity. The identity of boolean_xor is false. More...
struct	element
	Provides indexed access to the types of the elements of a kumi::product_type. More...
class	field_capture
	Named wrapper over a type. More...
class	field_name
	Named wrapper used to instantiate a kumi::field_capture. More...
struct	index_t
	Integral constant type. More...
class	indexes_t
	Compile time tuple of index used to pass several indexes_t as NTTP. More...
struct	is_homogeneous
	Detects if a given kwk::product_type instance is homogeneous. More...
struct	is_product_type
	Opt-in traits for types behaving like a kumi::product_type. More...
struct	is_record_type
	Opt-in traits for types behaving like a kumi::product_type. More...
struct	member
	Computes the return type of a call to kumi::get. More...
class	numeric_add
	A type representing the addition monoid with it's associated identity. The identity of the addition is 0. More...
class	numeric_prod
	A type representing the multiplication monoid with it's associated identity. The identity of the multiplication is 1. More...
struct	raw_element
	Provides indexed access to the types of the elements of a kumi::product_type and unwraps the returned field_capture for kumi::record_type. More...
struct	raw_member
	Computes the return type of a call to kumi::get on a kumi::tuple and unwrap the field_capture returned by kumi::get on a kumi::record. More...
class	record
	Fixed-size collection of heterogeneous fields necessarily named, names are unique. More...
struct	size
	Computes the number of elements of a kumi::product_type. More...
class	str
	Static string used to create named fields. More...
class	tuple
	Fixed-size collection of heterogeneous values. More...
class	unit
	A type representing the product of no type also called the unit type. More...

Concepts
concept	std_tuple_compatible
	Concept specifying a type is a standard tuple-like type.
concept	product_type
	Concept specifying a type follows the Product Type semantic.
concept	record_type
	Concept specifying a type follows the Record Type semantic.
concept	sized_product_type
	Concept specifying a type follows the Product Type semantic and has a known size.
concept	sized_product_type_or_more
	Concept specifying a type follows the Product Type semantic and has a size lower bound.
concept	empty_product_type
	Concept specifying a type follows the Product Type semantic and is empty.
concept	non_empty_product_type
	Concept specifying a type follows the Product Type semantic and is non-empty.
concept	index_map
	Concept specifying if a type can be used as sequence of indexes in algorithms.
concept	indexer
	Concept specifying if a type is suitable as an index.
concept	homogeneous_product_type
	Concept specifying is Product Type which types are all the same.
concept	equality_comparable
	Concept specifying if a type is comparable for each of its components.
concept	has_named_fields
	Concept specifying if parameter pack containes a kumi::field_capture.
concept	is_fully_named
	Concept specifying if parameter pack contains only kumi::field_captures.
concept	uniquely_typed
	Concept specifying if a parameter pack only holds unique types.
concept	uniquely_named
	Concept specifying if a parameter pack only holds unique kumi::field_capture names.
concept	entirely_uniquely_named
	Concept specifying if a parameter pack only holds kumi::field_captures each of their each of their names are unique!
concept	contains_type
	Concept specifying if a Type is present in a parameter pack.
concept	contains_field
	Concept specifying if a kumi::field_capture with name Name is present in a parameter pack.
concept	equivalent
	Concept specifying if two types have matching named fields.
concept	named_equality_comparable
	Concept specifying if two product types are comparable by matching name.
concept	follows_same_semantic
	Concept specifying if a pack of types follows the same semantic.
concept	compatible_product_types
	Concept specifying if two product types are compatibles.
concept	monoid
	Concept specifying a type is a Monoid

Functions
template<product_type T>
constexpr auto	all_of (T &&ts) noexcept
	Computes the reduction of a tuple over the && operator.
template<typename Pred , product_type T>
constexpr auto	all_of (T &&ts, Pred p) noexcept
	Checks if unary predicate p returns true for all elements in the value t.
template<product_type T>
constexpr auto	all_unique (T &&t)
	Return the product type containing the values of the first occurence of each type in the input product type.
template<product_type T>
constexpr auto	any_of (T &&ts) noexcept
	Computes the reduction of a tuple over the || operator.
template<typename Pred , product_type T>
constexpr auto	any_of (T &&ts, Pred p) noexcept
	Checks if unary predicate p returns true for any elements in the value t.
template<typename Function , product_type Tuple> requires _::supports_apply<Function, Tuple>
constexpr decltype(auto)	apply (Function &&f, Tuple &&t) noexcept(_::supports_nothrow_apply< Function &&, Tuple && >)
	Invoke the Callable object f with a product_type of arguments. f is applied on the values if the given product_type is a kumi::record.
template<product_type T>
auto	as_flat_ptr (T &&t) noexcept
	Convert a kumi::product_type to a flat product type of pointers to each its components.
template<product_type Tuple> requires ( size_v<Tuple> != 0)
constexpr decltype(auto)	back (Tuple &&t)
	Retrieves the back of a tuple.
template<product_type T>
constexpr auto	bit_and (T &&t)
	Computes the bitwise AND of all elements.
template<product_type T, typename Value >
constexpr auto	bit_and (T &&t, Value init)
	Computes the bitwise AND of all elements.
template<product_type T>
constexpr auto	bit_or (T &&t)
	Computes the bitwise OR of all elements.
template<product_type T, typename Value >
constexpr auto	bit_or (T &&t, Value init)
	Computes the bitwise OR of all elements.
template<product_type T>
constexpr auto	bit_xor (T &&t)
	Computes the bitwise XOR of all elements.
template<product_type T, typename Value >
constexpr auto	bit_xor (T &&t, Value init)
	Computes the bitwise XOR of all elements.
template<product_type... Ts> requires ( follows_same_semantic<Ts...> )
constexpr auto	cartesian_product (Ts &&... ts)
	Return the Cartesian Product of all elements of its arguments product types.
template<product_type... Ts> requires ( follows_same_semantic<Ts...> )
constexpr auto	cat (Ts &&... ts)
	Concatenates product types in a single one.
template<std::size_t N, product_type T> requires ( N > 0 && N <= size_v<T> )
constexpr auto	chunks (T &&t)
	Creates a kumi::tuple of product_types, each containing N consecutive elements from t. Chunks starts at 0 and advance by N element each time.
template<product_type... Ts>
constexpr auto	common_product_type (Ts...)
	Extracts the common product_type of a parameter pack, if all the types are record then it returns an empty record, otherwise returns an empty kumi::tuple
template<product_type T>
constexpr std::size_t	count (T &&ts) noexcept
	Counts the number of elements of t not equivalent to false.
template<typename Pred , product_type T>
constexpr std::size_t	count_if (T &&ts, Pred p) noexcept
	Counts the number of elements of t satisfying predicates p.
template<typename Function , product_type T, typename Value >
constexpr auto	exclusive_scan_left (Function &&f, T &&t, Value init)
	Computes the exclusive prefix scan of all elements of a product type using a tail recursive call.
template<monoid M, sized_product_type_or_more< 1 > T>
constexpr auto	exclusive_scan_left (M &&m, T &&t)
	Computes the exclusive prefix scan of all elements of a product type using a tail recursive call.
template<typename Function , product_type T, typename Value >
constexpr auto	exclusive_scan_right (Function &&f, T &&t, Value init)
	Computes the exclusive suffix scan of all elements of a product type using a tail recursive call.
template<monoid M, sized_product_type_or_more< 1 > T>
constexpr auto	exclusive_scan_right (M &&m, T &&t)
	Computes the exclusive suffix scan of all elements of a product type using a non-tail recursive call.
template<std::size_t I0, product_type Tuple> requires ( I0 <= size_v<Tuple>)
constexpr auto	extract (Tuple &&t, index_t< I0 > i0) noexcept
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<std::size_t I0, std::size_t I1, product_type Tuple> requires ( (I0 <= size_v<Tuple>) && (I1 <= size_v<Tuple>) )
constexpr auto	extract (Tuple &&t, index_t< I0 > i0, index_t< I1 > i1) noexcept
	Extracts a sub-tuple from a product type.
template<std::size_t N, typename T >
constexpr auto	fill (T const &v) noexcept
	Creates a kumi::tuple containing N copies of v.
template<template< typename > typename Pred, product_type T>
constexpr auto	filter (T &&t) noexcept
	Filters a product type over a predicate.
template<template< typename > typename Pred, product_type T>
constexpr auto	filter_not (T &&t) noexcept
	Filters a product type over a predicate.
template<product_type T>
constexpr auto	flatten (T &&t)
	Converts a product type of product types into a product type of all elements.
template<product_type T>
constexpr auto	flatten_all (T &&t)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<product_type T, typename Func >
constexpr auto	flatten_all (T &&t, Func &&f)
	Recursively converts a product type of product types into a product type of all elements.
template<typename Function , sized_product_type_or_more< 1 > T>
constexpr auto	fold_left (Function f, T &&t)
	Computes the generalized associative combination of all elements using a tail recursive call.
template<typename Function , product_type T, typename Value >
constexpr auto	fold_left (Function f, T &&t, Value init)
	Computes the generalized combination of all elements using a tail recursive call.
template<typename Function , sized_product_type_or_more< 1 > T>
constexpr auto	fold_right (Function f, T &&t)
	Computes the generalized associative combinationof all elements using a non-tail recursive call.
template<typename Function , product_type T, typename Value >
constexpr auto	fold_right (Function f, T &&t, Value init)
	Computes the generalized combination of all elements using a non-tail recursive call.
template<typename Function , product_type Tuple, product_type... Tuples> requires ( (compatible_product_types<Tuple, Tuples...>) && (_::supports_call<Function&, Tuple, Tuples...>))
constexpr void	for_each (Function f, Tuple &&t, Tuples &&... ts)
	Applies the Callable object f on each element of a kumi::product_type. f is applied on the values if the given product_type is a kumi::record.
template<typename Function , record_type Tuple, record_type... Tuples> requires ( compatible_product_types<std::remove_cvref_t<Tuple>, std::remove_cvref_t<Tuples>...> )
constexpr void	for_each_field (Function f, Tuple &&t, Tuples &&... ts)
	Applies the Callable object f on each element of a kumi::record_type and its field.
template<typename Function , product_type Tuple, product_type... Tuples> requires ( !record_type<Tuple> && (!record_type<Tuples> && ...) )
constexpr void	for_each_index (Function f, Tuple &&t, Tuples &&... ts)
	Applies the Callable object f on each element of a kumi::product_type and its index.
template<record_type Type, typename... Ts> requires ( equivalent<Type, record<Ts...>> )
constexpr auto	from_record (record< Ts... > const &r)
	Converts a kumi::record to an instance of a type that models kumi::record_type.
template<typename Type , typename... Ts> requires (!product_type<Type> && _::implicit_constructible<Type, Ts...>)
constexpr auto	from_tuple (tuple< Ts... > const &t)
	Converts a kumi::tuple to an instance of an arbitrary type.
template<product_type Tuple> requires ( size_v<Tuple> != 0)
constexpr decltype(auto)	front (Tuple &&t)
	Retrieves the front of a tuple.
template<std::size_t N, typename Function >
constexpr auto	generate (Function const &f) noexcept
	Creates a kumi::tuple containing N applications of the f Callable.
template<typename Function , product_type T, typename Value >
constexpr auto	inclusive_scan_left (Function &&f, T &&t, Value init)
	Computes the inclusive prefix scan of all elements of a product type using a tail recursive call.
template<monoid M, sized_product_type_or_more< 1 > T>
constexpr auto	inclusive_scan_left (M &&m, T &&t)
	Computes the inclusive prefix scan of all elements of a product type using a tail recursive call.
template<typename Function , product_type T, typename Value >
constexpr auto	inclusive_scan_right (Function &&f, T &&t, Value init)
	Computes the inclusive suffix scan of all elements of a product type using a non-tail recursive call.
template<monoid M, sized_product_type_or_more< 1 > T>
constexpr auto	inclusive_scan_right (M &&m, T &&t)
	Computes the inclusive suffix scan of all elements of a product type using a non-tail recursive call.
template<indexer... Ts>
consteval auto	indexes (Ts... ts) noexcept
	Creates a kumi::indexes object, deducing the target type from the types of arguments.
template<indexer... Ts>
KUMI_CUDA	indexes_t (Ts...) -> indexes_t< Ts... >
	kumi::indexes_t deduction guide
template<product_type S1, sized_product_type< size_v< S1 > > S2, typename T > requires ( compatible_product_types<S1, S2> )
constexpr auto	inner_product (S1 &&s1, S2 &&s2, T init) noexcept
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<product_type S1, sized_product_type< size_v< S1 > > S2, typename T , typename Sum , typename Prod > requires ( compatible_product_types<S1, S2> )
constexpr auto	inner_product (S1 &&s1, S2 &&s2, T init, Sum sum, Prod prod) noexcept
	Computes inner product (i.e. sum of products)
template<std::size_t N, typename T >
constexpr auto	iota (T v) noexcept
	Creates a kumi::tuple containing an increasing ramp of values.
template<typename Pred , product_type Tuple>
constexpr auto	locate (Tuple &&t, Pred p) noexcept
	Return the index of a value which type satisfies a given predicate.
template<product_type Tuple, typename Function , sized_product_type< size_v< Tuple > >... Tuples> requires ( compatible_product_types<Tuple, Tuples...> && _::supports_call<Function, Tuple&&, Tuples&&...> )
constexpr auto	map (Function f, Tuple &&t0, Tuples &&...others)
	Apply the Callable object f on each tuples' elements.
template<record_type Tuple, typename Function , sized_product_type< size< Tuple >::value >... Tuples> requires ( compatible_product_types<Tuple, Tuples...> )
constexpr auto	map_field (Function f, Tuple &&t0, Tuples &&...others)
	Apply the Callable object f on each records' elements and their field names.
template<product_type Tuple, typename Function , sized_product_type< size_v< Tuple > >... Tuples> requires (!record_type<Tuple> && (!record_type<Tuples> && ...))
constexpr auto	map_index (Function f, Tuple &&t0, Tuples &&...others)
	Apply the Callable object f on each tuples' elements and their indexes.
template<product_type T, monoid M, typename Function >
constexpr auto	map_reduce (Function &&f, M &&m, T &&t)
	Performs a tree-like reduction of all elements of a product type. The given map function is applied before excution the reduction to each element of the input.
template<monoid M, product_type T, typename Function , typename Value >
constexpr auto	map_reduce (Function &&f, M &&m, T &&t, Value init)
	Performs a tree-like reduction of all elements of a product type. The given map function is applied before excution the reduction to each element of the input.
template<product_type T>
constexpr auto	max (T &&t) noexcept
	Computes the maximum value all elements of t.
template<product_type T, typename F >
constexpr auto	max (T &&t, F f) noexcept
	Computes the maximum value of applications of f to all elements of t.
template<product_type T, typename F >
constexpr auto	max_flat (T &&t, F f) noexcept
	Computes the maximum value of applications of f to all elements of kumi::flatten_all(t).
template<product_type T>
constexpr auto	members_of (as< T >) noexcept
	Extracts the names of the fields of a kumi::product_type.
template<product_type T>
constexpr auto	min (T &&t) noexcept
	Computes the minimum value all elements of t.
template<product_type T, typename F >
constexpr auto	min (T &&t, F f) noexcept
	Computes the minimum value of applications of f to all elements of t.
template<product_type T, typename F >
constexpr auto	min_flat (T &&t, F f) noexcept
	Computes the minimum value of applications of f to all elements of kumi::flatten_all(t).
template<product_type Tuple>
constexpr bool	none_of (Tuple &&ts) noexcept
	Checks no elements of a tuple are true.
template<typename Pred , product_type Tuple>
constexpr bool	none_of (Tuple &&ts, Pred p) noexcept
	Checks if unary predicate p returns true for no elements in the value t.
template<char... c>
constexpr auto	operator""_c () noexcept
	Forms a integral constant literal of the desired value.
template<kumi::str ID>
constexpr auto	operator""_f () noexcept
	Forms a constant string literal of the desired value.
template<template< typename > typename Pred, product_type T>
constexpr auto	partition (T &&t) noexcept
	Partition a product type over a predicate.
template<product_type Tuple>
constexpr auto	pop_back (Tuple &&t)
	Remove the last (if any) element of a kumi::product_type.
template<product_type Tuple>
constexpr auto	pop_front (Tuple &&t)
	Remove the first (if any) element of a kumi::product_type.
template<template< class > class Pred>
constexpr auto	predicate () noexcept
	Convert a unary template meta-program in a running predicate.
template<product_type T>
constexpr auto	prod (T &&t)
	Computes the product of all elements.
template<product_type T, typename Value >
constexpr auto	prod (T &&t, Value init)
	Computes the product of all elements.
template<product_type Tuple, typename T >
constexpr auto	push_back (Tuple &&t, T &&v)
	Constructs a tuple by adding a value v at the end of t.
template<product_type Tuple, typename T >
constexpr auto	push_front (Tuple &&t, T &&v)
	Constructs a tuple by adding a value v at the beginning of t.
template<monoid M, product_type T>
constexpr auto	reduce (M &&m, T &&t)
	Performs a tree-like reduction of all elements of a product type.
template<monoid M, product_type T, typename Value >
constexpr auto	reduce (M &&m, T &&t, Value init)
	Performs a tree-like reduction of all elements of a product type.
template<index_map auto Indexes, product_type T> requires ( _::in_bound_indexes<Indexes, T>() )
constexpr auto	reindex (T &&t)
	Reindex elements of a kumi::product_type.
template<std::size_t... Idx, product_type T> requires ((Idx < size_v<T>) && ...)
constexpr auto	reorder (T &&t)
	Reorder elements of a kumi::product_type.
template<field_name... Name, product_type Tuple> requires ( requires { get<Name>(std::declval<Tuple>()); } && ... )
constexpr auto	reorder_fields (Tuple &&t)
	Reorder elements of a kumi::record.
template<product_type Tuple>
constexpr auto	reverse (Tuple &&t)
	Reverse elements of a kumi::product_type.
template<std::size_t I0, product_type Tuple> requires (I0 <= size_v<Tuple>)
constexpr auto	split (Tuple &&t, index_t< I0 > i0) noexcept
	Split a tuple into two.
template<product_type T>
constexpr auto	sum (T &&t)
	Computes the sum of all elements.
template<product_type T, typename Value >
constexpr auto	sum (T &&t, Value init)
	Computes the sum of all elements.
template<record_type Type>
constexpr auto	to_record (Type &&r)
	Converts a kumi::record_type to an instance kumi::record.
template<product_type Type>
constexpr auto	to_tuple (Type &&t)
	Converts a kumi::product_type to an instance kumi::tuple.
template<product_type T> requires ( _::supports_transpose<T> )
constexpr auto	transpose (T &&t)
	Transpose a product type of product types by shifting elements in their transposed position always returning a tuple as the external product type.
template<product_type T>
constexpr auto	unique (T &&t)
	Returns a product type with consecutive duplicate types removed (pairwise uniqueness).
template<product_type T>
constexpr auto	values_of (T &&t) noexcept
	Extracts the values of the fields of a kumi::product_type.
template<std::size_t N, product_type T> requires ( N > 0 && N <= size_v<T> )
constexpr auto	windows (T &&t)
	Creates a kumi::tuple of product_types, each containing N consecutive elements from t. Windows starts at 0 and advance by 1 element each time.
template<product_type T0, sized_product_type< size_v< T0 > >... Ts> requires ( follows_same_semantic<T0, Ts...> )
constexpr auto	zip (T0 &&t0, Ts &&... ts)
	Constructs a tuple where the ith element is the prduct type of all ith elements of ts...
template<product_type T0, product_type... Ts> requires ( follows_same_semantic<T0,Ts...>)
constexpr auto	zip_max (T0 &&t0, Ts &&...ts)
	Constructs a tuple where the ith element is the product type of all ith elements of ts...
template<product_type T0, product_type... Ts> requires ( follows_same_semantic<T0, Ts...> )
constexpr auto	zip_min (T0 &&t0, Ts &&...ts)
	Constructs a tuple where the ith element is the prudct type of all ith elements of ts...
Record Deduction Guides
template<typename... Ts>
KUMI_CUDA	record (Ts &&...) -> record< std::unwrap_ref_decay_t< Ts >... >
	kumi::record deduction guide
Record construction
template<str... Fields, typename... Ts> requires ( sizeof...(Fields) == sizeof...(Ts) )
constexpr auto	tie (Ts &... ts) -> record< field_capture< Fields, Ts & >... >
	Creates a kumi::record of lvalue references to its arguments.
Accessors
template<std::size_t I, typename... Ts> requires ( I < sizeof...(Ts) )
constexpr decltype(auto)	get (record< Ts... > &&r) noexcept
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<std::size_t I, typename... Ts> requires ( I < sizeof...(Ts) )
constexpr decltype(auto)	get (record< Ts... > const &r) noexcept
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<std::size_t I, typename... Ts> requires ( I < sizeof...(Ts) )
constexpr decltype(auto)	get (record< Ts... > const &&r) noexcept
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<std::integral auto I, typename... Ts> requires ((I >= sizeof...(Ts))|| (I < 0))
constexpr auto	get (record< Ts... > &t)=delete
	Improves diagnostic for out of bounds index.
template<std::integral auto I, typename... Ts> requires ((I >= sizeof...(Ts)) || (I < 0))
constexpr auto	get (record< Ts... > const &t)=delete
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<std::integral auto I, typename... Ts> requires ((I >= sizeof...(Ts)) || (I < 0))
constexpr auto	get (record< Ts... > &&t)=delete
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<std::integral auto I, typename... Ts> requires ((I >= sizeof...(Ts)) || (I < 0))
constexpr auto	get (record< Ts... > const &&t)=delete
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<str Name, typename... Ts> requires ( contains_field<Name, Ts...> )
constexpr decltype(auto)	get (record< Ts... > &&r) noexcept
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<str Name, typename... Ts> requires ( contains_field<Name, Ts...> )
constexpr decltype(auto)	get (record< Ts... > const &r) noexcept
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<str Name, typename... Ts> requires ( contains_field<Name, Ts...> )
constexpr decltype(auto)	get (record< Ts... > const &&r) noexcept
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<str Name, record_type R> requires (!(_::named_get_compliant<Name, R>()))
constexpr auto	get (R &&r)=delete
	Improves diagnostic for non present name.
template<typename U , record_type T>
constexpr auto	get (T &&t)=delete
	No get<type> on records.
template<std::size_t I, typename... Ts> requires ( I < sizeof...(Ts) )
constexpr decltype(auto)	get (tuple< Ts... > &&arg) noexcept
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<std::size_t I, typename... Ts> requires ( I < sizeof...(Ts) )
constexpr decltype(auto)	get (tuple< Ts... > const &arg) noexcept
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<std::size_t I, typename... Ts> requires ( I < sizeof...(Ts) )
constexpr decltype(auto)	get (tuple< Ts... > const &&arg) noexcept
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<std::integral auto I, typename... Ts> requires ((I >= sizeof...(Ts))|| (I < 0))
constexpr auto	get (tuple< Ts... > &t)=delete
	Improves diagnostic for out of bounds index.
template<std::integral auto I, typename... Ts> requires ((I >= sizeof...(Ts)) || (I < 0))
constexpr auto	get (tuple< Ts... > const &t)=delete
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<std::integral auto I, typename... Ts> requires ((I >= sizeof...(Ts)) || (I < 0))
constexpr auto	get (tuple< Ts... > &&t)=delete
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<std::integral auto I, typename... Ts> requires ((I >= sizeof...(Ts)) || (I < 0))
constexpr auto	get (tuple< Ts... > const &&t)=delete
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<str Name, typename... Ts> requires ( uniquely_named<Ts...> && contains_field<Name, Ts...> )
constexpr decltype(auto)	get (tuple< Ts... > &&t) noexcept
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<str Name, typename... Ts> requires ( uniquely_named<Ts...> && contains_field<Name, Ts...> )
constexpr decltype(auto)	get (tuple< Ts... > const &t) noexcept
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<str Name, typename... Ts> requires ( uniquely_named<Ts...> && contains_field<Name, Ts...> )
constexpr decltype(auto)	get (tuple< Ts... > const &&t) noexcept
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<str Name, product_type T> requires (!record_type<T> && !(_::named_get_compliant<Name, T>()))
constexpr auto	get (T &&t)=delete
	Improves diagnostic for non present name.
template<typename T , typename... Ts> requires ( uniquely_typed<Ts...> && contains_type<T, Ts...> )
constexpr decltype(auto)	get (tuple< Ts... > &&t) noexcept
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename T , typename... Ts> requires ( uniquely_typed<Ts...> && contains_type<T, Ts...> )
constexpr decltype(auto)	get (tuple< Ts... > const &t) noexcept
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename T , typename... Ts> requires ( uniquely_typed<Ts...> && contains_type<T, Ts...> )
constexpr decltype(auto)	get (tuple< Ts... > const &&t) noexcept
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename U , product_type T> requires (!record_type<T> && !(_::typed_get_compliant<U,T>()))
constexpr auto	get (T &&t)=delete
	Improves diagnostic for non present type.
Tuple Deduction Guides
template<typename... Ts>
KUMI_CUDA	tuple (Ts &&...) -> tuple< std::unwrap_ref_decay_t< Ts >... >
	kumi::tuple deduction guide
Tuple construction
template<typename... Ts>
constexpr auto	tie (Ts &...ts) -> tuple< Ts &... >
	Creates a kumi::tuple of lvalue references to its arguments.
template<typename... Ts>
constexpr auto	make_tuple (Ts &&...ts) -> tuple< std::unwrap_ref_decay_t< Ts >... >
	Creates a tuple object, deducing the target type from the types of arguments.

Variables
template<str ID>
constexpr auto	field = field_name<ID>{}
	Forms a constant kumi::field_name of the desired ID.
template<std::size_t N>
constexpr index_t< N > const	index = {}
	Inline integral constant value for kumi::index_t.
template<typename T >
constexpr bool	is_field_capture_v = requires { T::is_field_capture; }
	Checks if a type is a kumi::field_capture.
template<typename T >
constexpr auto	is_index_map_v = requires { T::is_index_map; }
	Checks if a type can be used as a kumi::index_map.
constexpr unit	none = {}
	Inline constant representing a kumi::unit.