Namespaces
namespace	function_ns
namespace	function_ref_ns
namespace	curry_ns
namespace	curry_back_ns
namespace	monad
namespace	pipeline
namespace	proj_ns
namespace	tag_invoke_detail
namespace	tag_invoke_ns

Classes
struct	AsBool
struct	BetweenExclusive
struct	BetweenInclusive
struct	BitAnd
struct	Compare
struct	CompareBackwards
struct	Dereference
struct	Equal
struct	EqualOrGreater
struct	EqualOrLess
class	Generator
struct	Greater
struct	Identity
struct	Less
struct	Minus
struct	Multiplies
struct	NotEqual
struct	Plus
class	Function
class	FunctionRef
struct	Curry
struct	CurryBack

Functions
template<typename F, typename... Args> requires (concepts::ConstructibleFrom<meta::Decay<F>, F> && (concepts::ConstructibleFrom<meta::Decay<Args>, Args> && ...))
constexpr auto	bind_back (F &&f, Args &&... args)
template<typename F, typename... Args> requires (concepts::ConstructibleFrom<meta::Decay<F>, F> && (concepts::ConstructibleFrom<meta::Decay<Args>, Args> && ...))
constexpr auto	bind_front (F &&f, Args &&... args)
template<typename F> requires (concepts::ConstructibleFrom<meta::Decay<F>, F>)
constexpr auto	chain (F &&f)
template<typename F, typename G, typename... Fs> requires (concepts::ConstructibleFrom<meta::Decay<F>, F> && concepts::ConstructibleFrom<meta::Decay<G>, G> && (concepts::ConstructibleFrom<meta::Decay<Fs>, Fs> && ...))
constexpr auto	chain (F &&f, G &&g, Fs &&... rest)
template<typename F> requires (concepts::ConstructibleFrom<meta::Decay<F>, F>)
constexpr auto	compose (F &&f)
template<typename F, typename G, typename... Fs> requires (concepts::ConstructibleFrom<meta::Decay<F>, F> && concepts::ConstructibleFrom<meta::Decay<G>, G> && (concepts::ConstructibleFrom<meta::Decay<Fs>, Fs> && ...))
constexpr auto	compose (F &&f, G &&g, Fs &&... rest)
template<concepts::DecayConstructible F>
constexpr auto	flip (F &&function)
template<concepts::DecayConstructible F>
constexpr auto	not_fn (F &&function)
template<typename F> requires (concepts::ConstructibleFrom<meta::Decay<F>, F>)
constexpr auto	piped (F &&function)
template<size_t count, typename F>
constexpr void	template_for (F &&function)

Variables
constexpr auto	as_bool = AsBool {}
constexpr auto	between_exclusive = BetweenExclusive {}
constexpr auto	between_inclusive = BetweenInclusive {}
constexpr auto	bit_and = function::curry_back(BitAnd {}, meta::c_<2ZU>)
constexpr auto	compare = function::curry_back(Compare {}, meta::c_<2ZU>)
constexpr auto	compare_backwards = function::curry_back(CompareBackwards {}, meta::c_<2ZU>)
template<concepts::LanguageFunction T, concepts::Allocator Alloc = platform::DefaultAllocator>
constexpr auto	make_function = function_ns::MakeFunction<T, Alloc> {}
constexpr auto	curry = curry_ns::CurryFunction {}
constexpr auto	curry_back = curry_back_ns::CurryBackFunction {}
constexpr auto	dereference = Dereference {}
constexpr auto	equal = curry_back(Equal {}, meta::c_<2ZU>)
constexpr auto	equal_or_greater = curry_back(EqualOrGreater {}, meta::c_<2ZU>)
constexpr auto	equal_or_less = curry_back(EqualOrLess {}, meta::c_<2ZU>)
constexpr auto	greater = curry_back(Greater {}, meta::c_<2ZU>)
constexpr auto	identity = Identity {}
template<typename R, usize max_index>
constexpr auto	index_dispatch = detail::IndexDispatch<R, max_index> {}
constexpr auto	into_void = detail::IntoVoidFunction {}
constexpr auto	invoke = function::detail::InvokeFunction {}
template<typename R>
constexpr auto	invoke_r = function::detail::InvokeRFunction<R> {}
constexpr auto	less = curry_back(Less {}, meta::c_<2ZU>)
template<typename T>
constexpr auto	make_deferred = detail::MakeDeferredFunction<T> {}
	Creates a deferred function object.
constexpr auto	minus = function::curry_back(Minus {}, meta::c_<2ZU>)
constexpr auto	multiplies = function::curry_back(Multiplies {}, meta::c_<2ZU>)
constexpr auto	not_equal = curry_back(NotEqual {}, meta::c_<2ZU>)
constexpr auto	overload = detail::OverloadFunction {}
constexpr auto	plus = function::curry_back(Plus {}, meta::c_<2ZU>)
constexpr auto	proj = di::curry(proj_ns::ProjFunction {}, c_<2ZU>)
constexpr tag_invoke_detail::TagInvokeFn	tag_invoke {}
constexpr auto	uncurry = detail::UncurryFunction {}
template<typename Seq>
constexpr auto	unpack = detail::UnpackFunction<Seq> {}
constexpr auto	value = detail::ValueFunction {}
constexpr auto	ycombinator = detail::YCombinatorFunction {}

Function Documentation

◆ bind_back()

template<typename F, typename... Args>
requires (concepts::ConstructibleFrom<meta::Decay<F>, F> && (concepts::ConstructibleFrom<meta::Decay<Args>, Args> && ...))

auto di::function::bind_back	(	F &&	f,
		Args &&...	args )

constexpr

◆ bind_front()

template<typename F, typename... Args>
requires (concepts::ConstructibleFrom<meta::Decay<F>, F> && (concepts::ConstructibleFrom<meta::Decay<Args>, Args> && ...))

auto di::function::bind_front	(	F &&	f,
		Args &&...	args )

constexpr

◆ chain() [1/2]

template<typename F>
requires (concepts::ConstructibleFrom<meta::Decay<F>, F>)

auto di::function::chain ( F && f )

constexpr

◆ chain() [2/2]

template<typename F, typename G, typename... Fs>
requires (concepts::ConstructibleFrom<meta::Decay<F>, F> && concepts::ConstructibleFrom<meta::Decay<G>, G> && (concepts::ConstructibleFrom<meta::Decay<Fs>, Fs> && ...))

auto di::function::chain	(	F &&	f,
		G &&	g,
		Fs &&...	rest )

constexpr

◆ compose() [1/2]

template<typename F>
requires (concepts::ConstructibleFrom<meta::Decay<F>, F>)

auto di::function::compose ( F && f )

constexpr

◆ compose() [2/2]

template<typename F, typename G, typename... Fs>
requires (concepts::ConstructibleFrom<meta::Decay<F>, F> && concepts::ConstructibleFrom<meta::Decay<G>, G> && (concepts::ConstructibleFrom<meta::Decay<Fs>, Fs> && ...))

auto di::function::compose	(	F &&	f,
		G &&	g,
		Fs &&...	rest )

constexpr

◆ flip()

template<concepts::DecayConstructible F>

auto di::function::flip ( F && function )

constexpr

◆ not_fn()

template<concepts::DecayConstructible F>

auto di::function::not_fn ( F && function )

constexpr

◆ piped()

template<typename F>
requires (concepts::ConstructibleFrom<meta::Decay<F>, F>)

auto di::function::piped ( F && function )

constexpr

◆ template_for()

template<size_t count, typename F>

void di::function::template_for ( F && function )

constexpr

Variable Documentation

◆ as_bool

auto di::function::as_bool = AsBool {}

inlineconstexpr

◆ between_exclusive

auto di::function::between_exclusive = BetweenExclusive {}

inlineconstexpr

◆ between_inclusive

auto di::function::between_inclusive = BetweenInclusive {}

inlineconstexpr

◆ bit_and

auto di::function::bit_and = function::curry_back(BitAnd {}, meta::c_<2ZU>)

inlineconstexpr

◆ compare

auto di::function::compare = function::curry_back(Compare {}, meta::c_<2ZU>)

inlineconstexpr

◆ compare_backwards

auto di::function::compare_backwards = function::curry_back(CompareBackwards {}, meta::c_<2ZU>)

inlineconstexpr

◆ curry

auto di::function::curry = curry_ns::CurryFunction {}

inlineconstexpr

◆ curry_back

auto di::function::curry_back = curry_back_ns::CurryBackFunction {}

inlineconstexpr

◆ dereference

auto di::function::dereference = Dereference {}

inlineconstexpr

◆ equal

auto di::function::equal = curry_back(Equal {}, meta::c_<2ZU>)

inlineconstexpr

◆ equal_or_greater

auto di::function::equal_or_greater = curry_back(EqualOrGreater {}, meta::c_<2ZU>)

inlineconstexpr

◆ equal_or_less

auto di::function::equal_or_less = curry_back(EqualOrLess {}, meta::c_<2ZU>)

inlineconstexpr

◆ greater

auto di::function::greater = curry_back(Greater {}, meta::c_<2ZU>)

inlineconstexpr

◆ identity

auto di::function::identity = Identity {}

inlineconstexpr

◆ index_dispatch

template<typename R, usize max_index>

auto di::function::index_dispatch = detail::IndexDispatch<R, max_index> {}

inlineconstexpr

◆ into_void

auto di::function::into_void = detail::IntoVoidFunction {}

inlineconstexpr

◆ invoke

auto di::function::invoke = function::detail::InvokeFunction {}

inlineconstexpr

◆ invoke_r

template<typename R>

auto di::function::invoke_r = function::detail::InvokeRFunction<R> {}

inlineconstexpr

◆ less

auto di::function::less = curry_back(Less {}, meta::c_<2ZU>)

inlineconstexpr

◆ make_deferred

template<typename T>

auto di::function::make_deferred = detail::MakeDeferredFunction<T> {}

constexpr

Creates a deferred function object.

Template Parameters

T	The type of the object to be constructed.

Parameters

args	The arguments to be forwarded to the constructor of the object.

Returns: An invocable which produces a value or type T.

This function is useful for creating immovable or expensive objects. By only storing the constructor arguments, the object can be constructed at a later time.

◆ make_function

template<concepts::LanguageFunction T, concepts::Allocator Alloc = platform::DefaultAllocator>

auto di::function::make_function = function_ns::MakeFunction<T, Alloc> {}

inlineconstexpr

◆ minus

auto di::function::minus = function::curry_back(Minus {}, meta::c_<2ZU>)

inlineconstexpr

◆ multiplies

auto di::function::multiplies = function::curry_back(Multiplies {}, meta::c_<2ZU>)

inlineconstexpr

◆ not_equal

auto di::function::not_equal = curry_back(NotEqual {}, meta::c_<2ZU>)

inlineconstexpr

◆ overload

auto di::function::overload = detail::OverloadFunction {}

inlineconstexpr

◆ plus

auto di::function::plus = function::curry_back(Plus {}, meta::c_<2ZU>)

inlineconstexpr

◆ proj

auto di::function::proj = di::curry(proj_ns::ProjFunction {}, c_<2ZU>)

inlineconstexpr

◆ uncurry

auto di::function::uncurry = detail::UncurryFunction {}

inlineconstexpr

◆ unpack

template<typename Seq>

auto di::function::unpack = detail::UnpackFunction<Seq> {}

inlineconstexpr

◆ value

auto di::function::value = detail::ValueFunction {}

inlineconstexpr

◆ ycombinator

auto di::function::ycombinator = detail::YCombinatorFunction {}

inlineconstexpr

Namespaces

Classes

Functions

Variables

Function Documentation

◆ bind_back()

◆ bind_front()

◆ chain() [1/2]

◆ chain() [2/2]

◆ compose() [1/2]

◆ compose() [2/2]

◆ flip()

◆ not_fn()

◆ piped()

◆ template_for()

Variable Documentation

◆ as_bool

◆ between_exclusive

◆ between_inclusive

◆ bit_and

◆ compare

◆ compare_backwards

◆ curry

◆ curry_back

◆ dereference

◆ equal

◆ equal_or_greater

◆ equal_or_less

◆ greater

◆ identity

◆ index_dispatch

◆ into_void

◆ invoke

◆ invoke_r

◆ less

◆ make_deferred

◆ make_function

◆ minus

◆ multiplies

◆ not_equal

◆ overload

◆ plus

◆ proj

◆ uncurry

◆ unpack

◆ value

◆ ycombinator