Range-v3 Range algorithms, views, and actions for the Standard Library |

Classes | Typedefs | Functions | Variables
Functional

## Description

Function and function object utilities.

## 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::compare_three_way
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 {}
constexpr indirect_fn | ranges::indirect {}
template<typename Fun , typename... Args>
concept | ranges::invocable__requires_
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 = __is_base_of(pipeable_base, T)
template<typename T >
constexpr bool | ranges::is_pipeable_v< T & > = __is_base_of(pipeable_base, T)
template<typename T >
constexpr bool | ranges::is_pipeable_v< T && > = __is_base_of(pipeable_base, 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::predicate__requires_
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::regular_invocable
template<typename R , typename T , typename U >
concept | ranges::relation
template<typename R , typename T , typename U >
concept | ranges::strict_weak_order
constexpr unwrap_reference_fn | ranges::unwrap_reference {}

## Variable Documentation

## ◆ compose

constexpr compose_fn ranges::compose {}
| constexpr

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

See also
  `compose_fn`

## ◆ indirect

constexpr indirect_fn ranges::indirect {}
| related

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

See also
  `indirect_fn`

Referenced by ranges::take_while_view().

## ◆ invocable__requires_

template<typename Fun , typename... Args>

concept ranges::invocable__requires_

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

Initial value:
= CPP_REQUIRES_requires `(Fun && fn)
template<typename Fun, typename... Args>
concept invocable =
ranges::invocable__requires_<Fun, Args...>

## ◆ 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_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`

## ◆ predicate__requires_

template<typename Fun , typename... Args>

concept ranges::predicate__requires_

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

Initial value:
= CPP_REQUIRES_requires `(Fun && fn)
template<typename Fun, typename... Args>
concept predicate =
regular_invocable<Fun, Args...> &&
ranges::predicate__requires_<Fun, Args...>

## ◆ 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`

Referenced by ranges::partial_sort(), and ranges::partial_sort_copy().

## ◆ regular_invocable

template<typename Fun , typename... Args>

concept ranges::regular_invocable

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

Initial value:
=
invocable<Fun, Args...>

## ◆ relation

template<typename R , typename T , typename U >

concept ranges::relation

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

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 >

concept ranges::strict_weak_order

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

Initial value:
=
relation<R, T, U>

## ◆ unwrap_reference

constexpr unwrap_reference_fn ranges::unwrap_reference {}
| constexpr

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

See also
  `unwrap_reference_fn`

Referenced by ranges::common_pair< F, S >::common_pair(), ranges::push_back(), and ranges::push_front().

meta::is_trait
bool_< is_trait_v< T > > is_trait
An alias for std::true_type if T::type exists and names a type; otherwise, it's an alias for std::fal...
Definition: meta.hpp:574
meta::apply
_t< extension::apply< Fn, L > > apply
Applies the invocable Fn using the types in the type list L as arguments.
Definition: meta.hpp:831