Algorithms Library: Traits

Types

Member Types	Definition
common_comparison_category	A type trait equivalent to the `std::equality_comparable` concept. ^(using)
common_comparison_category_t	A type trait equivalent to the `std::equality_comparable` concept. ^(using)
is_assignable_from	A type trait equivalent to the `std::assignable_from` concept. ^(using)
is_bidirectional_iterator	A type trait equivalent to the `std::bidirectional_iterator` concept. ^(using)
is_constructible_from	A type trait equivalent to the `std::constructible_from` concept. ^(using)
is_convertible_to	A type trait equivalent to the `std::convertible_to` concept. ^(using)
is_copyable	A type trait equivalent to the `std::copyable` concept. ^(using)
is_default_initializable	A type trait equivalent to the `std::default_initializable` concept. ^(using)
is_derived_from	A type trait equivalent to the `derived_from` concept. ^(using)
is_equality_comparable	A type trait equivalent to the `std::equality_comparable` concept. ^(using)
is_equality_comparable_with	A type trait equivalent to the `std::equality_comparable_with` concept. ^(using)
is_forward_iterator	A type trait equivalent to the `std::forward_iterator` concept. ^(using)
is_incrementable	A type trait equivalent to the `std::incrementable` concept. ^(using)
is_indirectly_binary_invocable	Determine if a function can be invoke with the value type of both iterators. ^(using)
is_indirectly_readable	A type trait equivalent to the `std::indirectly_readable` concept. ^(using)
is_indirectly_unary_invocable	A type trait equivalent to the `std::indirectly_unary_invocable` concept. ^(using)
is_input_iterator	A type trait equivalent to the `std::input_iterator` concept. ^(using)
is_input_or_output_iterator	A type trait equivalent to the `std::is_input_or_output_iterator` concept. ^(using)
is_input_range	A type trait equivalent to the `std::input_range` concept. ^(using)
is_movable	A type trait equivalent to the `std::movable` concept. ^(using)
is_move_constructible	A type trait equivalent to the `std::move_constructible` concept. ^(using)
is_random_access_iterator	A type trait equivalent to the `std::random_access_iterator` concept. ^(using)
is_range	A type trait equivalent to the `std::range` concept. ^(using)
is_regular	A type trait equivalent to the `std::regular` concept. ^(using)
is_semiregular	A type trait equivalent to the `std::semiregular` concept. ^(using)
is_sentinel_for	A type trait equivalent to the `std::sentinel_for` concept. ^(using)
is_swappable	A type trait equivalent to the `std::swappable` concept. ^(using)
is_three_way_comparable	A type trait equivalent to the `std::equality_comparable` concept. ^(using)
is_three_way_comparable_with	A type trait equivalent to the `std::equality_comparable_with` concept. ^(using)
is_totally_ordered	A type trait equivalent to the `std::totally_ordered` concept. ^(using)
is_totally_ordered_with	A type trait equivalent to the `std::totally_ordered_with` concept. ^(using)
is_weakly_incrementable	A type trait equivalent to the `std::weakly_incrementable` concept. ^(using)
iter_difference	A type trait equivalent to `std::iter_difference` ^(using)
iter_difference_t	A type trait equivalent to `std::iter_difference` ^(using)
iter_reference	A type trait equivalent to `std::iter_reference` ^(using)
iter_reference_t	A type trait equivalent to `std::iter_reference` ^(using)
iter_rvalue_reference	A type trait equivalent to `std::iter_rvalue_reference` ^(using)
iter_rvalue_reference_t	A type trait equivalent to `std::iter_rvalue_reference` ^(using)
iter_value	A type trait equivalent to `std::iter_value` ^(using)
iter_value_t	A type trait equivalent to `std::iter_value` ^(using)
iterator	A type trait equivalent to the `std::iterator` trait. ^(using)
iterator_t	A type trait equivalent to the `std::iterator` trait. ^(using)
range_value	A type trait equivalent to `std::range_value` ^(using)
range_value_t	A type trait equivalent to `std::range_value` ^(using)
remove_cvref	A type trait equivalent to `std::remove_cvref` ^(using)
remove_cvref_t	A type trait equivalent to `std::remove_cvref` ^(using)

Attributes

Member Attributes	Description
is_assignable_from_v	A type trait equivalent to the `std::assignable_from` concept. ^{(public variable template)}
is_bidirectional_iterator_v	A type trait equivalent to the `std::bidirectional_iterator` concept. ^{(public variable template)}
is_constructible_from_v	A type trait equivalent to the `std::constructible_from` concept. ^{(public variable template)}
is_convertible_to_v	A type trait equivalent to the `std::convertible_to` concept. ^{(public variable template)}
is_copyable_v	A type trait equivalent to the `std::copyable` concept. ^{(public variable template)}
is_default_initializable_v	A type trait equivalent to the `std::default_initializable` concept. ^{(public variable template)}
is_derived_from_v	A type trait equivalent to the `derived_from` concept. ^{(public variable template)}
is_equality_comparable_v	A type trait equivalent to the `std::equality_comparable` concept. ^{(public variable template)}
is_equality_comparable_with_v	A type trait equivalent to the `std::equality_comparable_with` concept. ^{(public variable template)}
is_forward_iterator_v	A type trait equivalent to the `std::forward_iterator` concept. ^{(public variable template)}
is_incrementable_v	A type trait equivalent to the `std::incrementable` concept. ^{(public variable template)}
is_indirectly_binary_invocable_v	Determine if a function can be invoke with the value type of both iterators. ^{(public variable template)}
is_indirectly_readable_v	A type trait equivalent to the `std::indirectly_readable` concept. ^{(public variable template)}
is_indirectly_unary_invocable_v	A type trait equivalent to the `std::indirectly_unary_invocable` concept. ^{(public variable template)}
is_input_iterator_v	A type trait equivalent to the `std::input_iterator` concept. ^{(public variable template)}
is_input_or_output_iterator_v	A type trait equivalent to the `std::is_input_or_output_iterator` concept. ^{(public variable template)}
is_input_range_v	A type trait equivalent to the `std::input_range` concept. ^{(public variable template)}
is_movable_v	A type trait equivalent to the `std::movable` concept. ^{(public variable template)}
is_move_constructible_v	A type trait equivalent to the `std::move_constructible` concept. ^{(public variable template)}
is_random_access_iterator_v	A type trait equivalent to the `std::random_access_iterator` concept. ^{(public variable template)}
is_range_v	A type trait equivalent to the `std::range` concept. ^{(public variable template)}
is_regular_v	A type trait equivalent to the `std::regular` concept. ^{(public variable template)}
is_semiregular_v	A type trait equivalent to the `std::semiregular` concept. ^{(public variable template)}
is_sentinel_for_v	A type trait equivalent to the `std::sentinel_for` concept. ^{(public variable template)}
is_swappable_v	A type trait equivalent to the `std::swappable` concept. ^{(public variable template)}
is_three_way_comparable_v	A type trait equivalent to the `std::equality_comparable` concept. ^{(public variable template)}
is_three_way_comparable_with_v	A type trait equivalent to the `std::equality_comparable_with` concept. ^{(public variable template)}
is_totally_ordered_v	A type trait equivalent to the `std::totally_ordered` concept. ^{(public variable template)}
is_totally_ordered_with_v	A type trait equivalent to the `std::totally_ordered_with` concept. ^{(public variable template)}
is_weakly_incrementable_v	A type trait equivalent to the `std::weakly_incrementable` concept. ^{(public variable template)}

Types

using common_comparison_category

^{Defined in header <futures/algorithm/traits/common_comparison_category.hpp>}

template <class... Ts>
using common_comparison_category = 
    std::common_comparison_category< Ts... >;

A type trait equivalent to the std::equality_comparable concept.

See Also: std::three_way_comparable

using common_comparison_category_t

^{Defined in header <futures/algorithm/traits/common_comparison_category.hpp>}

template <class... Ts>
using common_comparison_category_t = 
    typename common_comparison_category< Ts... >::type;

A type trait equivalent to the std::equality_comparable concept.

See Also: std::three_way_comparable

using is_assignable_from

^{Defined in header <futures/algorithm/traits/is_assignable_from.hpp>}

template <class LHS, class RHS>
using is_assignable_from = 
    std::bool_constant< std::assignable_from< LHS, RHS > >;

A type trait equivalent to the std::assignable_from concept.

See Also: std::assignable_from

using is_bidirectional_iterator

^{Defined in header <futures/algorithm/traits/is_bidirectional_iterator.hpp>}

template <class T>
using is_bidirectional_iterator = 
    std::bool_constant< std::bidirectional_iterator< T > >;

A type trait equivalent to the std::bidirectional_iterator concept.

See Also: std::bidirectional_iterator

using is_constructible_from

^{Defined in header <futures/algorithm/traits/is_constructible_from.hpp>}

template <class T, class... Args>
using is_constructible_from = 
    /* see below */;

A type trait equivalent to the std::constructible_from concept.

See Also: std::constructible_from

using is_convertible_to

^{Defined in header <futures/algorithm/traits/is_convertible_to.hpp>}

template <class From, class To>
using is_convertible_to = 
    std::bool_constant< std::convertible_to< From, To > >;

A type trait equivalent to the std::convertible_to concept.

See Also: std::convertible_to

using is_copyable

^{Defined in header <futures/algorithm/traits/is_copyable.hpp>}

template <class T>
using is_copyable = std::bool_constant< std::copyable< T > >;

A type trait equivalent to the std::copyable concept.

See Also: std::copyable

using is_default_initializable

^{Defined in header <futures/algorithm/traits/is_default_initializable.hpp>}

template <class T>
using is_default_initializable = 
    std::bool_constant< std::default_initializable< T > >;

A type trait equivalent to the std::default_initializable concept.

See Also: std::default_initializable

using is_derived_from

^{Defined in header <futures/algorithm/traits/is_derived_from.hpp>}

template <class Derived, class Base>
using is_derived_from = 
    std::bool_constant< derived_from< Derived, Base > >;

A type trait equivalent to the derived_from concept.

See Also: std::derived_from

using is_equality_comparable

^{Defined in header <futures/algorithm/traits/is_equality_comparable.hpp>}

template <class T>
using is_equality_comparable = 
    std::bool_constant< std::equality_comparable< T > >;

A type trait equivalent to the std::equality_comparable concept.

See Also: std::equality_comparable

using is_equality_comparable_with

^{Defined in header <futures/algorithm/traits/is_equality_comparable_with.hpp>}

template <class T, class U>
using is_equality_comparable_with = 
    std::bool_constant< std::equality_comparable_with< T, U > >;

A type trait equivalent to the std::equality_comparable_with concept.

See Also: std::equality_comparable_with

using is_forward_iterator

^{Defined in header <futures/algorithm/traits/is_forward_iterator.hpp>}

template <class T>
using is_forward_iterator = 
    std::bool_constant< std::forward_iterator< T > >;

A type trait equivalent to the std::forward_iterator concept.

See Also: std::forward_iterator

using is_incrementable

^{Defined in header <futures/algorithm/traits/is_incrementable.hpp>}

template <class I>
using is_incrementable = 
    std::bool_constant< std::incrementable< I > >;

A type trait equivalent to the std::incrementable concept.

See Also: std::incrementable

using is_indirectly_binary_invocable

^{Defined in header <futures/algorithm/traits/is_indirectly_binary_invocable.hpp>}

template <class F, class I1, class I2>
using is_indirectly_binary_invocable = /* see below */;

Determine if a function can be invoke with the value type of both iterators.

using is_indirectly_readable

^{Defined in header <futures/algorithm/traits/is_indirectly_readable.hpp>}

template <class T>
using is_indirectly_readable = 
    std::bool_constant< std::indirectly_readable< T > >;

A type trait equivalent to the std::indirectly_readable concept.

See Also: std::indirectly_readable

using is_indirectly_unary_invocable

^{Defined in header <futures/algorithm/traits/is_indirectly_unary_invocable.hpp>}

template <class F, class I>
using is_indirectly_unary_invocable = 
    std::bool_constant< std::indirectly_unary_invocable< F, I > >;

A type trait equivalent to the std::indirectly_unary_invocable concept.

using is_input_iterator

^{Defined in header <futures/algorithm/traits/is_input_iterator.hpp>}

template <class T>
using is_input_iterator = 
    std::bool_constant< std::input_iterator< T > >;

A type trait equivalent to the std::input_iterator concept.

See Also: std::input_iterator

using is_input_or_output_iterator

^{Defined in header <futures/algorithm/traits/is_input_or_output_iterator.hpp>}

template <class T>
using is_input_or_output_iterator = 
    std::bool_constant< std::is_input_or_output_iterator< T > >;

A type trait equivalent to the std::is_input_or_output_iterator concept.

using is_input_range

^{Defined in header <futures/algorithm/traits/is_input_range.hpp>}

template <class T>
using is_input_range = std::bool_constant< std::is_input_range< T > >;

A type trait equivalent to the std::input_range concept.

See Also: std::ranges::input_range

using is_movable

^{Defined in header <futures/algorithm/traits/is_movable.hpp>}

template <class T>
using is_movable = std::bool_constant< std::movable< T > >;

A type trait equivalent to the std::movable concept.

See Also: std::movable

using is_move_constructible

^{Defined in header <futures/algorithm/traits/is_move_constructible.hpp>}

template <class T>
using is_move_constructible = 
    std::bool_constant< std::move_constructible< T > >;

A type trait equivalent to the std::move_constructible concept.

See Also: std::move_constructible

using is_random_access_iterator

^{Defined in header <futures/algorithm/traits/is_random_access_iterator.hpp>}

template <class T>
using is_random_access_iterator = 
    std::bool_constant< std::random_access_iterator< T > >;

A type trait equivalent to the std::random_access_iterator concept.

See Also: std::random_access_iterator

using is_range

^{Defined in header <futures/algorithm/traits/is_range.hpp>}

template <class T>
using is_range = std::bool_constant< std::range< T > >;

A type trait equivalent to the std::range concept.

See Also: std::ranges::range

using is_regular

^{Defined in header <futures/algorithm/traits/is_regular.hpp>}

template <class T>
using is_regular = std::bool_constant< std::regular< T > >;

A type trait equivalent to the std::regular concept.

See Also: std::regular

using is_semiregular

^{Defined in header <futures/algorithm/traits/is_semiregular.hpp>}

template <class T>
using is_semiregular = std::bool_constant< std::semiregular< T > >;

A type trait equivalent to the std::semiregular concept.

See Also: std::semiregular

using is_sentinel_for

^{Defined in header <futures/algorithm/traits/is_sentinel_for.hpp>}

template <class S, class I>
using is_sentinel_for = 
    std::bool_constant< std::sentinel_for< S, I > >;

A type trait equivalent to the std::sentinel_for concept.

See Also: std::sentinel_for

using is_swappable

^{Defined in header <futures/algorithm/traits/is_swappable.hpp>}

template <class T>
using is_swappable = std::bool_constant< std::swappable< T > >;

A type trait equivalent to the std::swappable concept.

See Also: std::swappable

using is_three_way_comparable

^{Defined in header <futures/algorithm/traits/is_three_way_comparable.hpp>}

template <class T, class Cat = std::partial_ordering>
using is_three_way_comparable = 
    std::bool_constant< std::three_way_comparable< T, Cat > >;

A type trait equivalent to the std::equality_comparable concept.

See Also: std::three_way_comparable

using is_three_way_comparable_with

^{Defined in header <futures/algorithm/traits/is_three_way_comparable_with.hpp>}

template <class T, class U, class Cat = std::partial_ordering>
using is_three_way_comparable_with = 
    std::bool_constant< std::three_way_comparable_with< T, U, Cat > >;

A type trait equivalent to the std::equality_comparable_with concept.

See Also: std::three_way_comparable

using is_totally_ordered

^{Defined in header <futures/algorithm/traits/is_totally_ordered.hpp>}

template <class T>
using is_totally_ordered = 
    std::bool_constant< std::totally_ordered< T > >;

A type trait equivalent to the std::totally_ordered concept.

See Also: std::totally_ordered

using is_totally_ordered_with

^{Defined in header <futures/algorithm/traits/is_totally_ordered_with.hpp>}

template <class T, class U>
using is_totally_ordered_with = 
    std::bool_constant< std::totally_ordered_with< T, U > >;

A type trait equivalent to the std::totally_ordered_with concept.

See Also: std::totally_ordered

using is_weakly_incrementable

^{Defined in header <futures/algorithm/traits/is_weakly_incrementable.hpp>}

template <class I>
using is_weakly_incrementable = 
    std::bool_constant< std::weakly_incrementable< T > >;

A type trait equivalent to the std::weakly_incrementable concept.

See Also: std::weakly_incrementable

using iter_difference

^{Defined in header <futures/algorithm/traits/iter_difference.hpp>}

template <class T>
using iter_difference = std::iter_difference;

A type trait equivalent to std::iter_difference

See Also: std::iter_difference

using iter_difference_t

^{Defined in header <futures/algorithm/traits/iter_difference.hpp>}

template <class T>
using iter_difference_t = typename iter_difference< T >::type;

A type trait equivalent to std::iter_difference

See Also: std::iter_difference

using iter_reference

^{Defined in header <futures/algorithm/traits/iter_reference.hpp>}

template <class T>
using iter_reference = std::iter_reference;

A type trait equivalent to std::iter_reference

See Also: std::iter_reference

using iter_reference_t

^{Defined in header <futures/algorithm/traits/iter_reference.hpp>}

template <class T>
using iter_reference_t = typename iter_reference< T >::type;

A type trait equivalent to std::iter_reference

See Also: std::iter_reference

using iter_rvalue_reference

^{Defined in header <futures/algorithm/traits/iter_rvalue_reference.hpp>}

template <class T>
using iter_rvalue_reference = std::iter_rvalue_reference;

A type trait equivalent to std::iter_rvalue_reference

See Also: std::iter_rvalue_reference

using iter_rvalue_reference_t

^{Defined in header <futures/algorithm/traits/iter_rvalue_reference.hpp>}

template <class T>
using iter_rvalue_reference_t = 
    typename iter_rvalue_reference< T >::type;

A type trait equivalent to std::iter_rvalue_reference

See Also: std::iter_rvalue_reference

using iter_value

^{Defined in header <futures/algorithm/traits/iter_value.hpp>}

template <class T>
using iter_value = std::iter_value;

A type trait equivalent to std::iter_value

See Also: std::iter_value

using iter_value_t

^{Defined in header <futures/algorithm/traits/iter_value.hpp>}

template <class T>
using iter_value_t = typename iter_value< T >::type;

A type trait equivalent to std::iter_value

See Also: std::iter_value

using iterator

^{Defined in header <futures/algorithm/traits/iterator.hpp>}

template <class T>
using iterator = std::iterator< R >;

A type trait equivalent to the std::iterator trait.

See Also: std::ranges::iterator_t

using iterator_t

^{Defined in header <futures/algorithm/traits/iterator.hpp>}

template <class T>
using iterator_t = typename iterator< T >::type;

A type trait equivalent to the std::iterator trait.

See Also: std::ranges::iterator_t

using range_value

^{Defined in header <futures/algorithm/traits/range_value.hpp>}

template <class R>
using range_value = std::range_value< R >;

A type trait equivalent to std::range_value

See Also: std::ranges::iterator_t

using range_value_t

^{Defined in header <futures/algorithm/traits/range_value.hpp>}

template <class R>
using range_value_t = typename range_value< R >::type;

A type trait equivalent to std::range_value

See Also: std::ranges::iterator_t

using remove_cvref

^{Defined in header <futures/algorithm/traits/remove_cvref.hpp>}

template <class T>
using remove_cvref = std::remove_cvref< T >;

A type trait equivalent to std::remove_cvref

See Also: std::remove_cvref

using remove_cvref_t

^{Defined in header <futures/algorithm/traits/remove_cvref.hpp>}

template <class T>
using remove_cvref_t = typename remove_cvref< T >::type;

A type trait equivalent to std::remove_cvref

See Also: std::remove_cvref

Attributes

variable is_assignable_from_v

^{Defined in header <futures/algorithm/traits/is_assignable_from.hpp>}

constexpr bool is_assignable_from_v = is_assignable_from<LHS, RHS>::value;

A type trait equivalent to the std::assignable_from concept.

See Also: std::assignable_from

variable is_bidirectional_iterator_v

^{Defined in header <futures/algorithm/traits/is_bidirectional_iterator.hpp>}

constexpr bool is_bidirectional_iterator_v = is_bidirectional_iterator<
        I>::value;

A type trait equivalent to the std::bidirectional_iterator concept.

See Also: std::bidirectional_iterator

variable is_constructible_from_v

^{Defined in header <futures/algorithm/traits/is_constructible_from.hpp>}

constexpr bool is_constructible_from_v = is_constructible_from<T>::value;

A type trait equivalent to the std::constructible_from concept.

See Also: std::constructible_from

variable is_convertible_to_v

^{Defined in header <futures/algorithm/traits/is_convertible_to.hpp>}

constexpr bool is_convertible_to_v = is_convertible_to<From, To>::value;

A type trait equivalent to the std::convertible_to concept.

See Also: std::convertible_to

variable is_copyable_v

^{Defined in header <futures/algorithm/traits/is_copyable.hpp>}

constexpr bool is_copyable_v = is_copyable<T>::value;

A type trait equivalent to the std::copyable concept.

See Also: std::copyable

variable is_default_initializable_v

^{Defined in header <futures/algorithm/traits/is_default_initializable.hpp>}

constexpr bool is_default_initializable_v = is_default_initializable<
        T>::value;

A type trait equivalent to the std::default_initializable concept.

See Also: std::default_initializable

variable is_derived_from_v

^{Defined in header <futures/algorithm/traits/is_derived_from.hpp>}

constexpr bool is_derived_from_v = is_derived_from<Derived, Base>::value;

A type trait equivalent to the derived_from concept.

See Also: std::derived_from

variable is_equality_comparable_v

^{Defined in header <futures/algorithm/traits/is_equality_comparable.hpp>}

constexpr bool is_equality_comparable_v = is_equality_comparable<T>::value;

A type trait equivalent to the std::equality_comparable concept.

See Also: std::equality_comparable

variable is_equality_comparable_with_v

^{Defined in header <futures/algorithm/traits/is_equality_comparable_with.hpp>}

constexpr bool is_equality_comparable_with_v = is_equality_comparable_with<T, U>::value;

A type trait equivalent to the std::equality_comparable_with concept.

See Also: std::equality_comparable_with

variable is_forward_iterator_v

^{Defined in header <futures/algorithm/traits/is_forward_iterator.hpp>}

constexpr bool is_forward_iterator_v = is_forward_iterator<I>::value;

A type trait equivalent to the std::forward_iterator concept.

See Also: std::forward_iterator

variable is_incrementable_v

^{Defined in header <futures/algorithm/traits/is_incrementable.hpp>}

constexpr bool is_incrementable_v = is_incrementable<I>::value;

A type trait equivalent to the std::incrementable concept.

See Also: std::incrementable

variable is_indirectly_binary_invocable_v

^{Defined in header <futures/algorithm/traits/is_indirectly_binary_invocable.hpp>}

constexpr bool is_indirectly_binary_invocable_v = is_indirectly_binary_invocable<F, I1, I2>::value;

Determine if a function can be invoke with the value type of both iterators.

variable is_indirectly_readable_v

^{Defined in header <futures/algorithm/traits/is_indirectly_readable.hpp>}

constexpr bool is_indirectly_readable_v = is_indirectly_readable<T>::value;

A type trait equivalent to the std::indirectly_readable concept.

See Also: std::indirectly_readable

variable is_indirectly_unary_invocable_v

^{Defined in header <futures/algorithm/traits/is_indirectly_unary_invocable.hpp>}

constexpr bool is_indirectly_unary_invocable_v = is_indirectly_unary_invocable<F, I>::value;

A type trait equivalent to the std::indirectly_unary_invocable concept.

variable is_input_iterator_v

^{Defined in header <futures/algorithm/traits/is_input_iterator.hpp>}

constexpr bool is_input_iterator_v = is_input_iterator<T>::value;

A type trait equivalent to the std::input_iterator concept.

See Also: std::input_iterator

variable is_input_or_output_iterator_v

^{Defined in header <futures/algorithm/traits/is_input_or_output_iterator.hpp>}

constexpr bool is_input_or_output_iterator_v = is_input_or_output_iterator<
        T>::value;

A type trait equivalent to the std::is_input_or_output_iterator concept.

variable is_input_range_v

^{Defined in header <futures/algorithm/traits/is_input_range.hpp>}

bool constexpr is_input_range_v = is_input_range<T>::value;

A type trait equivalent to the std::input_range concept.

See Also: std::ranges::input_range

variable is_movable_v

^{Defined in header <futures/algorithm/traits/is_movable.hpp>}

constexpr bool is_movable_v = is_movable<T>::value;

A type trait equivalent to the std::movable concept.

See Also: std::movable

variable is_move_constructible_v

^{Defined in header <futures/algorithm/traits/is_move_constructible.hpp>}

constexpr bool is_move_constructible_v = is_move_constructible<T>::value;

A type trait equivalent to the std::move_constructible concept.

See Also: std::move_constructible

variable is_random_access_iterator_v

^{Defined in header <futures/algorithm/traits/is_random_access_iterator.hpp>}

constexpr bool is_random_access_iterator_v = is_random_access_iterator<
        I>::value;

A type trait equivalent to the std::random_access_iterator concept.

See Also: std::random_access_iterator

variable is_range_v

^{Defined in header <futures/algorithm/traits/is_range.hpp>}

constexpr bool is_range_v = is_range<T>::value;

A type trait equivalent to the std::range concept.

See Also: std::ranges::range

variable is_regular_v

^{Defined in header <futures/algorithm/traits/is_regular.hpp>}

constexpr bool is_regular_v = is_regular<T>::value;

A type trait equivalent to the std::regular concept.

See Also: std::regular

variable is_semiregular_v

^{Defined in header <futures/algorithm/traits/is_semiregular.hpp>}

constexpr bool is_semiregular_v = is_semiregular<T>::value;

A type trait equivalent to the std::semiregular concept.

See Also: std::semiregular

variable is_sentinel_for_v

^{Defined in header <futures/algorithm/traits/is_sentinel_for.hpp>}

constexpr bool is_sentinel_for_v = is_sentinel_for<S, I>::value;

A type trait equivalent to the std::sentinel_for concept.

See Also: std::sentinel_for

variable is_swappable_v

^{Defined in header <futures/algorithm/traits/is_swappable.hpp>}

constexpr bool is_swappable_v = is_swappable<T>::value;

A type trait equivalent to the std::swappable concept.

See Also: std::swappable

variable is_three_way_comparable_v

^{Defined in header <futures/algorithm/traits/is_three_way_comparable.hpp>}

constexpr bool is_three_way_comparable_v = is_three_way_comparable<T>::value;

A type trait equivalent to the std::equality_comparable concept.

See Also: std::three_way_comparable

variable is_three_way_comparable_with_v

^{Defined in header <futures/algorithm/traits/is_three_way_comparable_with.hpp>}

constexpr bool is_three_way_comparable_with_v = is_three_way_comparable_with<T, U>::value;

A type trait equivalent to the std::equality_comparable_with concept.

See Also: std::three_way_comparable

variable is_totally_ordered_v

^{Defined in header <futures/algorithm/traits/is_totally_ordered.hpp>}

constexpr bool is_totally_ordered_v = is_totally_ordered<T>::value;

A type trait equivalent to the std::totally_ordered concept.

See Also: std::totally_ordered

variable is_totally_ordered_with_v

^{Defined in header <futures/algorithm/traits/is_totally_ordered_with.hpp>}

constexpr bool is_totally_ordered_with_v = is_totally_ordered_with<T, U>::
        value;

A type trait equivalent to the std::totally_ordered_with concept.

See Also: std::totally_ordered

variable is_weakly_incrementable_v

^{Defined in header <futures/algorithm/traits/is_weakly_incrementable.hpp>}

constexpr bool is_weakly_incrementable_v = is_weakly_incrementable<I>::value;

A type trait equivalent to the std::weakly_incrementable concept.

See Also: std::weakly_incrementable

_{Updated on 2023-01-04}