Functional

Function and function object utilities. More...

Namespaces
namespace	ranges::cpp20

Concepts
concept	ranges::invocable_
	The invocable_ concept.
concept	ranges::invocable
	The invocable concept.
concept	ranges::regular_invocable
	The regular_invocable concept.
concept	ranges::predicate_
	The predicate_ concept.
concept	ranges::predicate
	The predicate concept.
concept	ranges::relation
	The relation concept.
concept	ranges::strict_weak_order
	The strict_weak_order concept.

Classes
struct	ranges::plus
struct	ranges::minus
struct	ranges::multiplies
struct	ranges::bitwise_or
struct	ranges::convert_to< T >
struct	ranges::coerce< T >
struct	ranges::coerce< T const >
struct	ranges::coerce< T & >
struct	ranges::coerce< T && >
struct	ranges::bind_element< T >
struct	ranges::bind_element< std::reference_wrapper< T > >
struct	ranges::bind_element< reference_wrapper< T > >
struct	ranges::protector< Bind >
struct	ranges::protect_fn
struct	ranges::equal_to
struct	ranges::not_equal_to
struct	ranges::less
struct	ranges::less_equal
struct	ranges::greater_equal
struct	ranges::greater
struct	ranges::composed< Second, First >
struct	ranges::compose_fn
struct	ranges::identity
struct	ranges::indirected< Fn >
struct	ranges::indirect_fn
struct	ranges::invoke_fn
struct	ranges::invoke_result< Fun, Args >
struct	ranges::logical_negate< FD >
struct	ranges::not_fn_fn
struct	ranges::transformed< Fn1, Fn2 >
struct	ranges::on_fn
struct	ranges::overloaded< Ts >
struct	ranges::overloaded<>
struct	ranges::overloaded< First, Rest... >
struct	ranges::overload_fn
struct	ranges::make_pipeable_fn
struct	ranges::pipeable_access
struct	ranges::pipeable_base
struct	ranges::reference_wrapper< T >
struct	ranges::ref_fn
struct	ranges::unwrap_reference_fn

Typedefs
template<typename T>
using	ranges::bind_element_t = meta::_t<bind_element<T>>
template<typename T>
using	ranges::is_reference_wrapper = meta::bool_<is_reference_wrapper_v<T>>
template<typename Fun, typename... Args>
using	ranges::invoke_result_t
template<typename T>
using	ranges::is_pipeable = meta::bool_<is_pipeable_v<T>>
template<typename T>
using	ranges::ref_t = decltype(ref(std::declval<T>()))
template<typename T>
using	ranges::unwrap_reference_t = decltype(unwrap_reference(std::declval<T>()))

Functions
template<typename T, typename U = meta::if_< std::is_lvalue_reference<T>, std::reference_wrapper<meta::_t<std::remove_reference<T>>>, T &&>>
U	ranges::bind_forward (meta::_t< std::remove_reference< T > > &t) noexcept
template<typename T>
T &&	ranges::bind_forward (meta::_t< std::remove_reference< T > > &&t) noexcept
template<typename Fun, typename... Args>
	ranges::CPP_requires (invocable_, requires(Fun &&fn)(invoke((Fun &&) fn, std::declval< Args >()...)))
template<typename Fun, typename... Args>
	ranges::CPP_requires (predicate_, requires(Fun &&fn)(concepts::requires_< convertible_to< decltype(invoke((Fun &&) fn, std::declval< Args >()...)), bool > >))

Variables
template<typename Fun, typename... Args>
CPP_concept	ranges::invocable
template<typename Fun, typename... Args>
CPP_concept	ranges::regular_invocable
template<typename Fun, typename... Args>
CPP_concept	ranges::predicate
template<typename R, typename T, typename U>
CPP_concept	ranges::relation
template<typename R, typename T, typename U>
CPP_concept	ranges::strict_weak_order
template<typename T>
RANGES_INLINE_VAR constexpr bool	ranges::is_reference_wrapper_v
template<typename Fn, typename... Args>
RANGES_INLINE_VAR constexpr bool	ranges::is_invocable_v
template<typename Fn, typename... Args>
RANGES_INLINE_VAR constexpr bool	ranges::is_nothrow_invocable_v
template<typename T>
RANGES_INLINE_VAR constexpr bool	ranges::is_pipeable_v = META_IS_BASE_OF(pipeable_base, T)
template<typename T>
RANGES_INLINE_VAR constexpr bool	ranges::is_pipeable_v< T & >
template<typename T>
RANGES_INLINE_VAR constexpr bool	ranges::is_pipeable_v< T && >

Detailed Description

Function and function object utilities.

Typedef Documentation

invoke_result_t

template<typename Fun, typename... Args>

using ranges::invoke_result_t

Initial value:

 
        decltype(invoke(std::declval<Fun>(), std::declval<Args>()...))

ref_t

template<typename T>

using ranges::ref_t = decltype(ref(std::declval<T>()))

See also

ref_fn

unwrap_reference_t

template<typename T>

using ranges::unwrap_reference_t = decltype(unwrap_reference(std::declval<T>()))

See also

unwrap_reference_fn

Variable Documentation

invocable

template<typename Fun, typename... Args>

CPP_concept ranges::invocable

Initial value:

=
        CPP_requires_ref(ranges::invocable_, Fun, Args...)

is_invocable_v

template<typename Fn, typename... Args>

RANGES_INLINE_VAR constexpr bool ranges::is_invocable_v

constexpr

Initial value:

=
        meta::is_trait<invoke_result<Fn, Args...>>::value

is_nothrow_invocable_v

template<typename Fn, typename... Args>

RANGES_INLINE_VAR constexpr bool ranges::is_nothrow_invocable_v

constexpr

Initial value:

=
        detail::is_nothrow_invocable_impl_<is_invocable_v<Fn, Args...>>::template apply<
            Fn, Args...>()

is_pipeable_v< T & >

template<typename T>

RANGES_INLINE_VAR constexpr bool ranges::is_pipeable_v< T & >

constexpr

Initial value:

= META_IS_BASE_OF(pipeable_base,
                                                                          T)

is_pipeable_v< T && >

template<typename T>

RANGES_INLINE_VAR constexpr bool ranges::is_pipeable_v< T && >

constexpr

Initial value:

= META_IS_BASE_OF(pipeable_base,
                                                                           T)

is_reference_wrapper_v

template<typename T>

RANGES_INLINE_VAR constexpr bool ranges::is_reference_wrapper_v

constexpr

Initial value:

=
        detail::is_reference_wrapper_v<detail::decay_t<T>>

predicate

template<typename Fun, typename... Args>

CPP_concept ranges::predicate

Initial value:

=
        regular_invocable<Fun, Args...> &&
        CPP_requires_ref(ranges::predicate_, Fun, Args...)

regular_invocable

template<typename Fun, typename... Args>

CPP_concept ranges::regular_invocable

Initial value:

=
        invocable<Fun, Args...>

relation

template<typename R, typename T, typename U>

CPP_concept ranges::relation

Initial value:

=
        predicate<R, T, T> &&
        predicate<R, U, U> &&
        predicate<R, T, U> &&
        predicate<R, U, T>

strict_weak_order

template<typename R, typename T, typename U>

CPP_concept ranges::strict_weak_order

Initial value:

=
        relation<R, T, U>