Namespaces
namespace	curry_back_ns

namespace	curry_ns

namespace	detail

namespace	function_ns

namespace	function_ref_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	Curry

struct	CurryBack

struct	Dereference

struct	Equal

struct	EqualOrGreater

struct	EqualOrLess

class	Function

class	FunctionRef

class	Generator

struct	Greater

struct	Identity

struct	Less

struct	Minus

struct	Multiplies

struct	NotEqual

struct	Plus

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