Horizon
Loading...
Searching...
No Matches
Namespaces | Concepts | Classes | Typedefs | Functions | Variables
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 = decltype(invoke(std::declval< Fun >(), std::declval< Args >()...))
 
template<typename T >
using ranges::is_pipeable = meta::bool_< is_pipeable_v< T > >
 
using ranges::instead = 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 , typename U = meta::if_< std::is_lvalue_reference<T>, std::reference_wrapper<meta::_t<std::remove_reference<T>>>, T &&>>
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

◆ ref_t

template<typename T >
using ranges::ref_t = typedef decltype(ref(std::declval<T>()))
See also
ref_fn

◆ unwrap_reference_t

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

Variable Documentation

◆ invocable

template<typename Fun , typename... Args>
CPP_concept ranges::invocable
Initial value:
=
CPP_requires_ref(ranges::invocable_, Fun, Args...)
The invocable_ concept.

◆ 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...)
The predicate_ concept.
The regular_invocable concept.

◆ regular_invocable

template<typename Fun , typename... Args>
CPP_concept ranges::regular_invocable
Initial value:
=
invocable<Fun, Args...>
The invocable concept.

◆ relation

template<typename R , typename T , typename U >
CPP_concept ranges::relation

◆ strict_weak_order

template<typename R , typename T , typename U >
CPP_concept ranges::strict_weak_order
Initial value:
=
The relation concept.