Functional

Function and function object utilities. More...

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

Typedefs
template<typename T >
using	ranges::bind_element_t = meta::_t< bind_element< T > >
template<typename Fun , typename... Args>
using	ranges::invoke_result_t = decltype(invoke(std::declval< Fun >(), std::declval< Args >()...))
template<typename T >
using	ranges::is_pipeable = meta::bool_< is_pipeable_v< T > >
template<typename T >
using	ranges::is_reference_wrapper = meta::bool_< is_reference_wrapper_v< T > >
using	ranges::ordered_less = less
template<typename >
using	ranges::pipeable = pipeable_base
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 >
T &&	ranges::bind_forward (meta::_t< std::remove_reference< T >> &&t) noexcept
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

Variables
constexpr compose_fn	ranges::compose {}
template<typename Fun , typename... Args>
concept	ranges::iinvocable
	\concept invocable More...
constexpr indirect_fn	ranges::indirect {}
template<typename Fun , typename... Args>
concept	ranges::invocable_ = requires( Fun && fn ) { invoke((Fun &&) fn, std::declval<Args>()...) ; }
	\concept invocable_ More...
constexpr invoke_fn	ranges::invoke {}
template<typename Fn , typename... Args>
constexpr bool	ranges::is_invocable_v
template<typename Fn , typename... Args>
constexpr bool	ranges::is_nothrow_invocable_v
template<typename T >
constexpr bool	ranges::is_pipeable_v = std::is_base_of< pipeable_base, T >::value
template<typename T >
constexpr bool	ranges::is_pipeable_v< T & >
template<typename T >
constexpr bool	ranges::is_pipeable_v< T && >
template<typename T >
constexpr bool	ranges::is_reference_wrapper_v
constexpr make_pipeable_fn	ranges::make_pipeable {}
constexpr not_fn_fn	ranges::not_fn {}
constexpr on_fn	ranges::on {}
constexpr overload_fn	ranges::overload {}
template<typename Fun , typename... Args>
concept	ranges::ppredicate
	\concept predicate More...
template<typename Fun , typename... Args>
concept	ranges::predicate_ = requires( Fun && fn ) { concepts::requires_< convertible_to< decltype(invoke((Fun &&) fn, std::declval<Args>()...)), bool>> ; }
	\concept predicate_ More...
constexpr protect_fn	ranges::protect {}
	Protect a callable so that it can be safely used in a bind expression without accidentally becoming a "nested" bind. More...
constexpr ref_fn	ranges::ref {}
template<typename Fun , typename... Args>
concept	ranges::rregular_invocable
	\concept regular_invocable More...
template<typename R , typename T , typename U >
concept	ranges::rrelation
	\concept relation More...
template<typename R , typename T , typename U >
concept	ranges::sstrict_weak_order
	\concept strict_weak_order More...
constexpr unwrap_reference_fn	ranges::unwrap_reference {}

Detailed Description

Function and function object utilities.

Variable Documentation

compose

constexpr compose_fn ranges::compose {}

constexpr

#include <range/v3/functional/compose.hpp>

See also

compose_fn

iinvocable

template<typename Fun , typename... Args>

concept ranges::iinvocable

#include <range/v3/functional/concepts.hpp>

Initial value:

=
         ranges::invocable_ < Fun, Args... >

\concept invocable

The invocable concept

indirect

constexpr indirect_fn ranges::indirect {}

constexpr

#include <range/v3/functional/indirect.hpp>

See also

indirect_fn

invocable_

template<typename Fun , typename... Args>

concept ranges::invocable_ = requires( Fun && fn ) { invoke((Fun &&) fn, std::declval<Args>()...) ; }

#include <range/v3/functional/concepts.hpp>

\concept invocable_

The invocable_ concept

is_invocable_v

template<typename Fn , typename... Args>

constexpr bool ranges::is_invocable_v

constexpr

#include <range/v3/functional/invoke.hpp>

Initial value:

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

is_nothrow_invocable_v

template<typename Fn , typename... Args>

constexpr bool ranges::is_nothrow_invocable_v

constexpr

#include <range/v3/functional/invoke.hpp>

Initial value:

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

is_pipeable_v< T & >

template<typename T >

constexpr bool ranges::is_pipeable_v< T & >

constexpr

#include <range/v3/functional/pipeable.hpp>

Initial value:

= 
std::is_base_of< pipeable_base,                                                                           T >::value

is_pipeable_v< T && >

template<typename T >

constexpr bool ranges::is_pipeable_v< T && >

constexpr

#include <range/v3/functional/pipeable.hpp>

Initial value:

= 
std::is_base_of< pipeable_base,                                                                            T >::value

is_reference_wrapper_v

template<typename T >

constexpr bool ranges::is_reference_wrapper_v

constexpr

#include <range/v3/functional/invoke.hpp>

Initial value:

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

make_pipeable

constexpr make_pipeable_fn ranges::make_pipeable {}

constexpr

#include <range/v3/functional/pipeable.hpp>

See also

make_pipeable_fn

not_fn

constexpr not_fn_fn ranges::not_fn {}

constexpr

#include <range/v3/functional/not_fn.hpp>

See also

not_fn_fn

on

constexpr on_fn ranges::on {}

constexpr

#include <range/v3/functional/on.hpp>

See also

on_fn

overload

constexpr overload_fn ranges::overload {}

constexpr

#include <range/v3/functional/overload.hpp>

See also

overload_fn

ppredicate

template<typename Fun , typename... Args>

concept ranges::ppredicate

#include <range/v3/functional/concepts.hpp>

Initial value:

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

\concept predicate

The predicate concept

predicate_

template<typename Fun , typename... Args>

concept ranges::predicate_ = requires( Fun && fn ) { concepts::requires_< convertible_to< decltype(invoke((Fun &&) fn, std::declval<Args>()...)), bool>> ; }

#include <range/v3/functional/concepts.hpp>

\concept predicate_

The predicate_ concept

protect

constexpr protect_fn ranges::protect {}

constexpr

#include <range/v3/functional/bind.hpp>

Protect a callable so that it can be safely used in a bind expression without accidentally becoming a "nested" bind.

See also

protect_fn

ref

constexpr ref_fn ranges::ref {}

related

#include <range/v3/functional/reference_wrapper.hpp>

See also

ref_fn

rregular_invocable

template<typename Fun , typename... Args>

concept ranges::rregular_invocable

#include <range/v3/functional/concepts.hpp>

Initial value:

=
        invocable<Fun, Args...>

\concept regular_invocable

The regular_invocable concept

rrelation

template<typename R , typename T , typename U >

concept ranges::rrelation

#include <range/v3/functional/concepts.hpp>

Initial value:

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

\concept relation

The relation concept

sstrict_weak_order

template<typename R , typename T , typename U >

concept ranges::sstrict_weak_order

#include <range/v3/functional/concepts.hpp>

Initial value:

=
        relation<R, T, U>

\concept strict_weak_order

The strict_weak_order concept

unwrap_reference

constexpr unwrap_reference_fn ranges::unwrap_reference {}

constexpr

#include <range/v3/functional/reference_wrapper.hpp>

See also

unwrap_reference_fn