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...
class	builder
	Helper structure to build the correct output product_type. If the provided Product type is a not a record_type the builder will output a tuple otherwise a record. More...
struct	common_product_type
	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. As we are unable to compute the Least Restrictive Subtypes of a pack, this trait should be specialized for each case one would want to write. More...
struct	container_size
	Returns the number of elements of a kumi::static_container. More...
struct	container_type
	Provides access to the type of the elements of a kumi::static_container. 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
	Detects if a type follows the tuple protocol. More...
struct	is_record_type
	Opt-in traits for types behaving like a kumi::product_type. More...
struct	is_static_container
	Traits detecting types behaving like a kumi::static_container. 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...

Functions
template<concepts::product_type T>
constexpr auto	all_of (T &&ts) noexcept
	Computes the reduction of a tuple over the && operator.
template<typename Pred , concepts::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<concepts::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<concepts::product_type T>
constexpr auto	any_of (T &&ts) noexcept
	Computes the reduction of a tuple over the || operator.
template<typename Pred , concepts::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 , concepts::product_type T> requires _::supports_apply<Function, T>
constexpr decltype(auto)	apply (Function &&f, T &&t) noexcept(_::supports_nothrow_apply< Function &&, T && >)
	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<concepts::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<concepts::product_type Tuple> requires (size_v<Tuple> != 0)
constexpr decltype(auto)	back (Tuple &&t)
	Retrieves the back of a tuple.
template<concepts::product_type T>
constexpr auto	bit_and (T &&t)
	Computes the bitwise AND of all elements.
template<concepts::product_type T, typename Value >
constexpr auto	bit_and (T &&t, Value init)
	Computes the bitwise AND of all elements.
template<concepts::product_type T>
constexpr auto	bit_or (T &&t)
	Computes the bitwise OR of all elements.
template<concepts::product_type T, typename Value >
constexpr auto	bit_or (T &&t, Value init)
	Computes the bitwise OR of all elements.
template<concepts::product_type T>
constexpr auto	bit_xor (T &&t)
	Computes the bitwise XOR of all elements.
template<concepts::product_type T, typename Value >
constexpr auto	bit_xor (T &&t, Value init)
	Computes the bitwise XOR of all elements.
template<concepts::product_type... Ts> requires (concepts::follows_same_semantic<Ts...>)
constexpr auto	cartesian_product (Ts &&... ts)
	Return the Cartesian Product of all elements of its arguments product types.
template<concepts::product_type... Ts> requires (concepts::follows_same_semantic<Ts...>)
constexpr auto	cat (Ts &&... ts)
	Concatenates product types in a single one.
template<std::size_t N, concepts::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<concepts::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 , concepts::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 , concepts::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<concepts::monoid M, concepts::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 , concepts::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<concepts::monoid M, concepts::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, concepts::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, concepts::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<typename T >
constexpr decltype(auto)	field_value_of (T &&t) noexcept
	Extracts the value from a kumi::field_capture or returns the parameter.
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, concepts::product_type T>
constexpr auto	filter (T &&t) noexcept
	Filters a product type over a predicate.
template<template< typename > typename Pred, concepts::product_type T>
constexpr auto	filter_not (T &&t) noexcept
	Filters a product type over a predicate.
template<concepts::product_type T>
constexpr auto	flatten (T &&t)
	Converts a product type of product types into a product type of all elements.
template<concepts::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<concepts::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 , concepts::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 , concepts::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 , concepts::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 , concepts::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 , concepts::product_type Tuple, concepts::product_type... Tuples> requires ((concepts::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 , concepts::record_type Tuple, concepts::record_type... Tuples> requires (concepts::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 , concepts::product_type Tuple, concepts::product_type... Tuples> requires (!concepts::record_type<Tuple> && (!concepts::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<concepts::record_type Type, typename... Ts> requires (concepts::equivalent<typename _::as_tuple<Type, std::make_index_sequence<size_v<Type>>>::type, tuple<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 (!concepts::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<concepts::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 , concepts::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<concepts::monoid M, concepts::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 , concepts::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<concepts::monoid M, concepts::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<concepts::indexer... Ts>
consteval auto	indexes (Ts... ts) noexcept
	Creates a kumi::indexes object, deducing the target type from the types of arguments.
template<concepts::indexer... Ts>
KUMI_CUDA	indexes_t (Ts...) -> indexes_t< Ts... >
	kumi::indexes_t deduction guide
template<concepts::product_type S1, concepts::sized_product_type< size_v< S1 > > S2, typename T > requires (concepts::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<concepts::product_type S1, concepts::sized_product_type< size_v< S1 > > S2, typename T , typename Sum , typename Prod > requires (concepts::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<typename C , typename... Ts> requires (std::is_invocable<C, Ts...>::value)
constexpr decltype(auto)	invoke (C &&c, Ts &&... ts) noexcept(std::is_nothrow_invocable< C, Ts... >::value)
	Invoke the Callable object c with a pack of arguments.
template<typename R , typename C , typename... Ts> requires (std::is_invocable_r<R, C, Ts...>::value)
constexpr R	invoke_r (C &&c, Ts &&... ts) noexcept(std::is_nothrow_invocable_r< R, C, Ts... >::value)
	Invoke the Callable object c with a pack of arguments with return type R.
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 , concepts::product_type Tuple>
constexpr auto	locate (Tuple &&t, Pred p) noexcept
	Return the index of a value which type satisfies a given predicate.
template<concepts::product_type Tuple, typename Function , concepts::sized_product_type< size_v< Tuple > >... Tuples> requires (concepts::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<concepts::record_type Tuple, typename Function , concepts::sized_product_type< size< Tuple >::value >... Tuples> requires (concepts::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<concepts::product_type Tuple, typename Function , concepts::sized_product_type< size_v< Tuple > >... Tuples> requires (!concepts::record_type<Tuple> && (!concepts::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<concepts::product_type T, concepts::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<concepts::monoid M, concepts::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<concepts::product_type T>
constexpr auto	max (T &&t) noexcept
	Computes the maximum value all elements of t.
template<concepts::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<concepts::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<typename Target , concepts::product_type T>
constexpr auto	member_cast (T &&t)
	Converts a product_type<Ts...> to an instance of a product_type<Target...>
template<concepts::product_type T>
constexpr auto	members_of (as< T >) noexcept
	Extracts the names of the fields of a kumi::product_type.
template<concepts::product_type T>
constexpr auto	min (T &&t) noexcept
	Computes the minimum value all elements of t.
template<concepts::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<concepts::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<typename T >
constexpr auto	name_of (as< T >) noexcept
	Extracts the name from a kumi::field_capture or returns the parameter.
template<concepts::product_type Tuple>
constexpr bool	none_of (Tuple &&ts) noexcept
	Checks no elements of a tuple are true.
template<typename Pred , concepts::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, concepts::product_type T>
constexpr auto	partition (T &&t) noexcept
	Partition a product type over a predicate.
template<concepts::product_type Tuple>
constexpr auto	pop_back (Tuple &&t)
	Remove the last (if any) element of a kumi::product_type.
template<concepts::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<concepts::product_type T>
constexpr auto	prod (T &&t)
	Computes the product of all elements.
template<concepts::product_type T, typename Value >
constexpr auto	prod (T &&t, Value init)
	Computes the product of all elements.
template<concepts::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<concepts::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<concepts::monoid M, concepts::product_type T>
constexpr auto	reduce (M &&m, T &&t)
	Performs a tree-like reduction of all elements of a product type.
template<concepts::monoid M, concepts::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<concepts::index_map auto Indexes, concepts::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, concepts::product_type T> requires ((Idx < size_v<T>) && ...)
constexpr auto	reorder (T &&t)
	Reorder elements of a kumi::product_type.
template<field_name... Name, concepts::product_type Tuple> requires (requires { get<Name>(std::declval<Tuple>()); } && ...)
constexpr auto	reorder_fields (Tuple &&t)
	Reorder elements of a kumi::record.
template<concepts::product_type Tuple>
constexpr auto	reverse (Tuple &&t)
	Reverse elements of a kumi::product_type.
template<std::size_t R, concepts::product_type T>
constexpr auto	rotate_left (T &&t)
	Rotates the element of a product type R positions to the left, wrapping around when getting to the beginning.
template<std::size_t R, concepts::product_type T>
constexpr auto	rotate_right (T &&t)
	Rotates the element of a product type R positions to the right, wrapping around when getting to the end.
template<std::size_t I0, concepts::product_type Tuple> requires (I0 <= size_v<Tuple>)
constexpr auto	split (Tuple &&t, index_t< I0 > i0) noexcept
	Split a tuple into two.
template<concepts::product_type T>
constexpr auto	sum (T &&t)
	Computes the sum of all elements.
template<concepts::product_type T, typename Value >
constexpr auto	sum (T &&t, Value init)
	Computes the sum of all elements.
template<concepts::record_type Type>
constexpr auto	to_record (Type &&r)
	Converts a kumi::record_type to an instance kumi::record.
template<concepts::product_type Type>
constexpr auto	to_tuple (Type &&t)
	Converts a kumi::product_type to an instance kumi::tuple.
template<concepts::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<concepts::product_type T>
constexpr auto	unique (T &&t)
	Returns a product type with consecutive duplicate types removed (pairwise uniqueness).
template<concepts::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, concepts::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<concepts::product_type T0, concepts::sized_product_type< size_v< T0 > >... Ts> requires (concepts::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<concepts::product_type T0, concepts::product_type... Ts> requires (concepts::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<concepts::product_type T0, concepts::product_type... Ts> requires (concepts::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 (concepts::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 (concepts::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 (concepts::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, concepts::record_type R> requires (!(_::named_get_compliant<Name, R>()))
constexpr auto	get (R &&r)=delete
	Improves diagnostic for non present name.
template<typename U , concepts::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 (concepts::uniquely_named<Ts...> && concepts::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 (concepts::uniquely_named<Ts...> && concepts::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 (concepts::uniquely_named<Ts...> && concepts::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, concepts::product_type T> requires (!concepts::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 (concepts::uniquely_typed<Ts...> && concepts::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 (concepts::uniquely_typed<Ts...> && concepts::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 (concepts::uniquely_typed<Ts...> && concepts::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 , concepts::product_type T> requires (!concepts::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.