Horizon
Classes | Typedefs | Functions | Variables
Iterator Concepts

Iterator concepts. More...

Classes

struct  ranges::incrementable_traits< detail::projected_< I, Proj > >
 
struct  ranges::sentinel_tag
 
struct  ranges::sized_sentinel_tag
 

Typedefs

template<typename Rng >
using ranges::iterator_tag_of = std::enable_if_t< input_iterator< Rng >, meta::conditional_t< contiguous_iterator< Rng >, ranges::contiguous_iterator_tag, meta::conditional_t< random_access_iterator< Rng >, std::random_access_iterator_tag, meta::conditional_t< bidirectional_iterator< Rng >, std::bidirectional_iterator_tag, meta::conditional_t< forward_iterator< Rng >, std::forward_iterator_tag, std::input_iterator_tag > >> >>
 
template<typename Fun , typename... Is>
using ranges::indirect_result_t = detail::enable_if_t<(bool) and_v<(bool) indirectly_readable< Is >... >, invoke_result_t< Fun, iter_reference_t< Is >... > >
 
template<typename I , typename Proj >
using ranges::projected = typename detail::select_projected_< Proj >::template apply< I >
 
template<typename S , typename I >
using ranges::sentinel_tag_of = std::enable_if_t< sentinel_for< S, I >, meta::conditional_t< sized_sentinel_for< S, I >, sized_sentinel_tag, sentinel_tag > >
 

Functions

 ranges::template (typename I)(concept(readable_)(I)
 \concept readable_ More...
 
template<typename O , typename T >
 ranges::CPP_requires (writable_, requires(O &&o, T &&t)(*o=(T &&) t, *(O &&) o=(T &&) t, const_cast< iter_reference_t< O > const && >(*o)=(T &&) t, const_cast< iter_reference_t< O > const && >(*(O &&) o)=(T &&) t))
 \concept writable_ More...
 
template<typename I >
 ranges::CPP_requires (weakly_incrementable_, requires(I i)(++i, i++, concepts::requires_< same_as< I &, decltype(++i)>>))
 \concept weakly_incrementable_ More...
 
template<typename I >
 ranges::CPP_requires (incrementable_, requires(I i)(concepts::requires_< same_as< I, decltype(i++)>>))
 \concept incrementable_ More...
 
template<typename S , typename I >
 ranges::CPP_requires (sized_sentinel_for_, requires(S const &s, I const &i)(s - i, i - s, concepts::requires_< same_as< iter_difference_t< I >, decltype(s - i)>>, concepts::requires_< same_as< iter_difference_t< I >, decltype(i - s)>>))
 \concept sized_sentinel_for_ More...
 
 ranges::template (typename S, typename I)(concept(sized_sentinel_for_)(S
 \concept sized_sentinel_for_ More...
 
template<typename Out , typename T >
 ranges::CPP_requires (output_iterator_, requires(Out o, T &&t)(*o++=(T &&) t))
 \concept output_iterator_ More...
 
 ranges::template (typename I, typename Tag)(concept(with_category_)(I
 \concept with_category_ More...
 
template<typename I >
 ranges::CPP_requires (bidirectional_iterator_, requires(I i)(--i, i--, concepts::requires_< same_as< I &, decltype(--i)>>, concepts::requires_< same_as< I, decltype(i--)>>))
 \concept bidirectional_iterator_ More...
 
template<typename I >
 ranges::CPP_requires (random_access_iterator_, requires(I i, iter_difference_t< I > n)(i+n, n+i, i - n, i+=n, i -=n, concepts::requires_< same_as< decltype(i+n), I >>, concepts::requires_< same_as< decltype(n+i), I >>, concepts::requires_< same_as< decltype(i - n), I >>, concepts::requires_< same_as< decltype(i+=n), I & >>, concepts::requires_< same_as< decltype(i -=n), I & >>, concepts::requires_< same_as< decltype(i[n]), iter_reference_t< I >>>))
 \concept random_access_iterator_ More...
 
 ranges::template (typename F, typename I)(concept(indirectly_regular_unary_invocable_)(F
 \concept indirectly_regular_unary_invocable_ More...
 
 ranges::template (typename F, typename I1, typename I2)(concept(indirect_binary_predicate_impl_)(F
 \concept indirect_binary_predicate_impl_ More...
 
 ranges::template (typename I, typename O)(concept(indirectly_movable_)(I
 \concept indirectly_movable_ More...
 
template<typename I1 , typename I2 >
 ranges::CPP_requires (indirectly_swappable_, requires(I1 const i1, I2 const i2)(ranges::iter_swap(i1, i2), ranges::iter_swap(i1, i1), ranges::iter_swap(i2, i2), ranges::iter_swap(i2, i1)))
 \concept indirectly_swappable_ More...
 
 ranges::template (typename C, typename I1, typename P1, typename I2, typename P2)(concept(projected_indirect_relation_)(C
 \concept projected_indirect_relation_ More...
 

Variables

same_as< iter_reference_t< I const >, iter_reference_t< I > > AND same_as< iter_rvalue_reference_t< I const >, iter_rvalue_reference_t< I > > AND common_reference_with< iter_reference_t< I > &&, iter_value_t< I > & > AND common_reference_with< iter_reference_t< I > &&, iter_rvalue_reference_t< I > && > AND ranges::common_reference_with< iter_rvalue_reference_t< I > &&, iter_value_t< I > const & >
 
template<typename I >
CPP_concept ranges::indirectly_readable
 \concept indirectly_readable More...
 
template<typename I >
constexpr RANGES_INLINE_VAR bool ranges::readable
 
template<typename O , typename T >
CPP_concept ranges::indirectly_writable
 \concept indirectly_writable More...
 
template<typename O , typename T >
constexpr RANGES_INLINE_VAR bool ranges::writable
 
template<typename I >
CPP_concept ranges::weakly_incrementable
 \concept weakly_incrementable More...
 
template<typename I >
CPP_concept ranges::incrementable
 \concept incrementable More...
 
template<typename I >
CPP_concept ranges::input_or_output_iterator
 \concept input_or_output_iterator More...
 
template<typename S , typename I >
CPP_concept ranges::sentinel_for
 \concept sentinel_for More...
 
 ranges::I
 
!disable_sized_sentinel< std::remove_cv_t< S >, std::remove_cv_t< I > > AND ranges::sentinel_for< S, I >
 
template<typename S , typename I >
CPP_concept ranges::sized_sentinel_for
 \concept sized_sentinel_for More...
 
template<typename Out , typename T >
CPP_concept ranges::output_iterator
 \concept output_iterator More...
 
 ranges::Tag
 
template<typename I >
CPP_concept ranges::input_iterator
 \concept input_iterator More...
 
template<typename I >
CPP_concept ranges::forward_iterator
 \concept forward_iterator More...
 
template<typename I >
CPP_concept ranges::bidirectional_iterator
 \concept bidirectional_iterator More...
 
template<typename I >
CPP_concept ranges::random_access_iterator
 \concept random_access_iterator More...
 
template<typename I >
CPP_concept ranges::contiguous_iterator
 \concept contiguous_iterator More...
 
template<typename F , typename I >
CPP_concept ranges::indirectly_unary_invocable
 \concept indirectly_unary_invocable More...
 
regular_invocable< F &, iter_value_t< I > & > AND regular_invocable< F &, iter_reference_t< I > > AND regular_invocable< F &, iter_common_reference_t< I > > AND ranges::common_reference_with< invoke_result_t< F &, iter_value_t< I > & >, invoke_result_t< F &, iter_reference_t< I > > >
 
template<typename F , typename I >
CPP_concept ranges::indirectly_regular_unary_invocable
 \concept indirectly_regular_unary_invocable More...
 
predicate< F &, iter_value_t< I > & > AND predicate< F &, iter_reference_t< I > > AND ranges::predicate< F &, iter_common_reference_t< I > >
 
template<typename F , typename I >
CPP_concept ranges::indirect_unary_predicate
 \concept indirect_unary_predicate More...
 
 ranges::I2
 
predicate< F &, iter_value_t< I1 > &, iter_value_t< I2 > & > AND predicate< F &, iter_value_t< I1 > &, iter_reference_t< I2 > > AND predicate< F &, iter_reference_t< I1 >, iter_value_t< I2 > & > AND predicate< F &, iter_reference_t< I1 >, iter_reference_t< I2 > > AND ranges::predicate< F &, iter_common_reference_t< I1 >, iter_common_reference_t< I2 > >
 
template<typename F , typename I1 , typename I2 >
CPP_concept ranges::indirect_binary_predicate_
 \concept indirect_binary_predicate_ More...
 
relation< F &, iter_value_t< I1 > &, iter_value_t< I2 > & > AND relation< F &, iter_value_t< I1 > &, iter_reference_t< I2 > > AND relation< F &, iter_reference_t< I1 >, iter_value_t< I2 > & > AND relation< F &, iter_reference_t< I1 >, iter_reference_t< I2 > > AND ranges::relation< F &, iter_common_reference_t< I1 >, iter_common_reference_t< I2 > >
 
template<typename F , typename I1 , typename I2 = I1>
CPP_concept ranges::indirect_relation
 \concept indirect_relation More...
 
strict_weak_order< F &, iter_value_t< I1 > &, iter_value_t< I2 > & > AND strict_weak_order< F &, iter_value_t< I1 > &, iter_reference_t< I2 > > AND strict_weak_order< F &, iter_reference_t< I1 >, iter_value_t< I2 > & > AND strict_weak_order< F &, iter_reference_t< I1 >, iter_reference_t< I2 > > AND ranges::strict_weak_order< F &, iter_common_reference_t< I1 >, iter_common_reference_t< I2 > >
 
template<typename F , typename I1 , typename I2 = I1>
CPP_concept ranges::indirect_strict_weak_order
 \concept indirect_strict_weak_order More...
 
 ranges::indirectly_writable< O, iter_rvalue_reference_t< I > >
 
template<typename I , typename O >
CPP_concept ranges::indirectly_movable
 \concept indirectly_movable More...
 
indirectly_writable< O, iter_value_t< I > > AND movable< iter_value_t< I > > AND constructible_from< iter_value_t< I >, iter_rvalue_reference_t< I > > AND ranges::assignable_from< iter_value_t< I > &, iter_rvalue_reference_t< I > >
 
template<typename I , typename O >
CPP_concept ranges::indirectly_movable_storable
 \concept indirectly_movable_storable More...
 
 ranges::indirectly_writable< O, iter_reference_t< I > >
 
template<typename I , typename O >
CPP_concept ranges::indirectly_copyable
 \concept indirectly_copyable More...
 
indirectly_writable< O, iter_value_t< I > const & > AND copyable< iter_value_t< I > > AND constructible_from< iter_value_t< I >, iter_reference_t< I > > AND ranges::assignable_from< iter_value_t< I > &, iter_reference_t< I > >
 
template<typename I , typename O >
CPP_concept ranges::indirectly_copyable_storable
 \concept indirectly_copyable_storable More...
 
template<typename I1 , typename I2 = I1>
CPP_concept ranges::indirectly_swappable
 \concept indirectly_swappable More...
 
 ranges::P2
 
 ranges::indirect_relation< C, projected< I1, P1 >, projected< I2, P2 > >
 
template<typename I1 , typename I2 , typename C , typename P1 = identity, typename P2 = identity>
CPP_concept ranges::indirectly_comparable
 \concept indirectly_comparable More...
 
template<typename I >
CPP_concept ranges::permutable
 \concept permutable More...
 
 ranges::indirect_strict_weak_order< C, projected< I1, P1 >, projected< I2, P2 > >
 
template<typename I1 , typename I2 , typename Out , typename C = less, typename P1 = identity, typename P2 = identity>
CPP_concept ranges::mergeable
 
template<typename I , typename C = less, typename P = identity>
CPP_concept ranges::sortable
 \concept sortable More...
 

Detailed Description

Iterator concepts.

Function Documentation

◆ CPP_requires() [1/8]

template<typename I >
ranges::CPP_requires ( bidirectional_iterator_  ,
requires(I i)(--i, i--, concepts::requires_< same_as< I &, decltype(--i)>>, concepts::requires_< same_as< I, decltype(i--)>>)   
)

\concept bidirectional_iterator_

The bidirectional_iterator_ concept

◆ CPP_requires() [2/8]

template<typename I >
ranges::CPP_requires ( incrementable_  ,
requires(I i)(concepts::requires_< same_as< I, decltype(i++)>>)   
)

\concept incrementable_

The incrementable_ concept

◆ CPP_requires() [3/8]

template<typename I1 , typename I2 >
ranges::CPP_requires ( indirectly_swappable_  ,
requires(I1 const i1, I2 const i2)(ranges::iter_swap(i1, i2), ranges::iter_swap(i1, i1), ranges::iter_swap(i2, i2), ranges::iter_swap(i2, i1))   
)

\concept indirectly_swappable_

The indirectly_swappable_ concept

◆ CPP_requires() [4/8]

template<typename Out , typename T >
ranges::CPP_requires ( output_iterator_  ,
requires(Out o, T &&t)(*++=&&T  t 
)

\concept output_iterator_

The output_iterator_ concept

◆ CPP_requires() [5/8]

template<typename I >
ranges::CPP_requires ( random_access_iterator_  ,
requires(I i, iter_difference_t< I > n)(i+n, n+i, i - n, i+=n, i -=n, concepts::requires_< same_as< decltype(i+n), I >>, concepts::requires_< same_as< decltype(n+i), I >>, concepts::requires_< same_as< decltype(i - n), I >>, concepts::requires_< same_as< decltype(i+=n), I & >>, concepts::requires_< same_as< decltype(i -=n), I & >>, concepts::requires_< same_as< decltype(i[n]), iter_reference_t< I >>>)   
)

\concept random_access_iterator_

The random_access_iterator_ concept

◆ CPP_requires() [6/8]

template<typename S , typename I >
ranges::CPP_requires ( sized_sentinel_for_  ,
requires(S const &s, I const &i)(s - i, i - s, concepts::requires_< same_as< iter_difference_t< I >, decltype(s - i)>>, concepts::requires_< same_as< iter_difference_t< I >, decltype(i - s)>>)   
)

\concept sized_sentinel_for_

The sized_sentinel_for_ concept

◆ CPP_requires() [7/8]

template<typename I >
ranges::CPP_requires ( weakly_incrementable_  ,
requires(I i)(++i, i++, concepts::requires_< same_as< I &, decltype(++i)>>)   
)

\concept weakly_incrementable_

The weakly_incrementable_ concept

◆ CPP_requires() [8/8]

template<typename O , typename T >
ranges::CPP_requires ( writable_  ,
requires(O &&o, T &&t)(*=&&T  t,
*(O &&)  o = (T &&) t,
const_cast< iter_reference_t< O > const && > *  o = (T &&) t,
const_cast< iter_reference_t< O > const && >  *(O &&) o = (T &&) t 
)

\concept writable_

The writable_ concept

◆ template() [1/7]

ranges::template ( typename C  ,
typename I1  ,
typename P1  ,
typename I2  ,
typename P2   
)

\concept projected_indirect_relation_

\concept projected_indirect_strict_weak_order_

The projected_indirect_relation_ concept

The projected_indirect_strict_weak_order_ concept

◆ template() [2/7]

ranges::template ( typename F  ,
typename I   
)

\concept indirectly_regular_unary_invocable_

\concept indirect_unary_predicate_

The indirectly_regular_unary_invocable_ concept

The indirect_unary_predicate_ concept

◆ template() [3/7]

ranges::template ( typename F  ,
typename I1  ,
typename I2   
)

\concept indirect_binary_predicate_impl_

\concept indirect_strict_weak_order_

\concept indirect_relation_

The indirect_binary_predicate_impl_ concept

The indirect_relation_ concept

The indirect_strict_weak_order_ concept

◆ template() [4/7]

ranges::template ( typename I  )

\concept readable_

\concept contiguous_iterator_

\concept input_or_output_iterator_

\concept weakly_incrementable_

The readable_ concept

The weakly_incrementable_ concept

The input_or_output_iterator_ concept

The contiguous_iterator_ concept

◆ template() [5/7]

ranges::template ( typename I  ,
typename O   
)

\concept indirectly_movable_

\concept indirectly_copyable_storable_

\concept indirectly_copyable_

\concept indirectly_movable_storable_

The indirectly_movable_ concept

The indirectly_movable_storable_ concept

The indirectly_copyable_ concept

The indirectly_copyable_storable_ concept

◆ template() [6/7]

ranges::template ( typename I  ,
typename Tag   
)

\concept with_category_

The with_category_ concept

◆ template() [7/7]

ranges::template ( typename S  ,
typename I   
)

\concept sized_sentinel_for_

The sized_sentinel_for_ concept

Variable Documentation

◆ bidirectional_iterator

template<typename I >
CPP_concept ranges::bidirectional_iterator
Initial value:
=
forward_iterator<I> &&
CPP_requires_ref(ranges::bidirectional_iterator_, I) &&
CPP_concept_ref(ranges::with_category_, I, std::bidirectional_iterator_tag)

\concept bidirectional_iterator

The bidirectional_iterator concept

◆ contiguous_iterator

template<typename I >
CPP_concept ranges::contiguous_iterator
Initial value:
=
random_access_iterator<I> &&
CPP_concept_ref(ranges::contiguous_iterator_, I)

\concept contiguous_iterator

The contiguous_iterator concept

◆ forward_iterator

template<typename I >
CPP_concept ranges::forward_iterator
Initial value:
=
input_iterator<I> &&
incrementable<I> &&
sentinel_for<I, I> &&
CPP_concept_ref(ranges::with_category_, I, std::forward_iterator_tag)

\concept forward_iterator

The forward_iterator concept

◆ incrementable

template<typename I >
CPP_concept ranges::incrementable
Initial value:
=
regular<I> &&
weakly_incrementable<I> &&
CPP_requires_ref(ranges::incrementable_, I)

\concept incrementable

The incrementable concept

◆ indirect_binary_predicate_

template<typename F , typename I1 , typename I2 >
CPP_concept ranges::indirect_binary_predicate_
Initial value:
=
indirectly_readable<I1> && indirectly_readable<I2> &&
copy_constructible<F> &&
CPP_concept_ref(ranges::indirect_binary_predicate_impl_, F, I1, I2)

\concept indirect_binary_predicate_

The indirect_binary_predicate_ concept

◆ indirect_relation

template<typename F , typename I1 , typename I2 = I1>
CPP_concept ranges::indirect_relation
Initial value:
=
indirectly_readable<I1> && indirectly_readable<I2> &&
copy_constructible<F> &&
CPP_concept_ref(ranges::indirect_relation_, F, I1, I2)

\concept indirect_relation

The indirect_relation concept

◆ indirect_strict_weak_order

template<typename F , typename I1 , typename I2 = I1>
CPP_concept ranges::indirect_strict_weak_order
Initial value:
=
indirectly_readable<I1> && indirectly_readable<I2> &&
copy_constructible<F> &&
CPP_concept_ref(ranges::indirect_strict_weak_order_, F, I1, I2)

\concept indirect_strict_weak_order

The indirect_strict_weak_order concept

◆ indirect_unary_predicate

template<typename F , typename I >
CPP_concept ranges::indirect_unary_predicate
Initial value:
=
indirectly_readable<I> &&
copy_constructible<F> &&
CPP_concept_ref(ranges::indirect_unary_predicate_, F, I)

\concept indirect_unary_predicate

The indirect_unary_predicate concept

◆ indirectly_comparable

template<typename I1 , typename I2 , typename C , typename P1 = identity, typename P2 = identity>
CPP_concept ranges::indirectly_comparable
Initial value:
=
CPP_concept_ref(ranges::projected_indirect_relation_, C, I1, P1, I2, P2)

\concept indirectly_comparable

The indirectly_comparable concept

◆ indirectly_copyable

template<typename I , typename O >
CPP_concept ranges::indirectly_copyable
Initial value:
=
indirectly_readable<I> && CPP_concept_ref(ranges::indirectly_copyable_, I, O)

\concept indirectly_copyable

The indirectly_copyable concept

◆ indirectly_copyable_storable

template<typename I , typename O >
CPP_concept ranges::indirectly_copyable_storable
Initial value:
=
indirectly_copyable<I, O> &&
CPP_concept_ref(ranges::indirectly_copyable_storable_, I, O)

\concept indirectly_copyable_storable

The indirectly_copyable_storable concept

◆ indirectly_movable

template<typename I , typename O >
CPP_concept ranges::indirectly_movable
Initial value:
=
indirectly_readable<I> && CPP_concept_ref(ranges::indirectly_movable_, I, O)

\concept indirectly_movable

The indirectly_movable concept

◆ indirectly_movable_storable

template<typename I , typename O >
CPP_concept ranges::indirectly_movable_storable
Initial value:
=
indirectly_movable<I, O> &&
CPP_concept_ref(ranges::indirectly_movable_storable_, I, O)

\concept indirectly_movable_storable

The indirectly_movable_storable concept

◆ indirectly_readable

template<typename I >
CPP_concept ranges::indirectly_readable
Initial value:
=
CPP_concept_ref(ranges::readable_, uncvref_t<I>)

\concept indirectly_readable

The indirectly_readable concept

◆ indirectly_regular_unary_invocable

template<typename F , typename I >
CPP_concept ranges::indirectly_regular_unary_invocable
Initial value:
=
indirectly_readable<I> &&
copy_constructible<F> &&
CPP_concept_ref(ranges::indirectly_regular_unary_invocable_, F, I)

\concept indirectly_regular_unary_invocable

The indirectly_regular_unary_invocable concept

◆ indirectly_swappable

template<typename I1 , typename I2 = I1>
CPP_concept ranges::indirectly_swappable
Initial value:
=
indirectly_readable<I1> &&
indirectly_readable<I2> &&
CPP_requires_ref(ranges::indirectly_swappable_, I1, I2)

\concept indirectly_swappable

The indirectly_swappable concept

◆ indirectly_unary_invocable

template<typename F , typename I >
CPP_concept ranges::indirectly_unary_invocable
Initial value:
=
detail::indirectly_unary_invocable_<F, I> &&
copy_constructible<F>

\concept indirectly_unary_invocable

The indirectly_unary_invocable concept

◆ indirectly_writable

template<typename O , typename T >
CPP_concept ranges::indirectly_writable
Initial value:
=
CPP_requires_ref(ranges::writable_, O, T)

\concept indirectly_writable

The indirectly_writable concept

◆ input_iterator

template<typename I >
CPP_concept ranges::input_iterator
Initial value:
=
input_or_output_iterator<I> &&
indirectly_readable<I> &&
CPP_concept_ref(ranges::with_category_, I, std::input_iterator_tag)

\concept input_iterator

The input_iterator concept

◆ input_or_output_iterator

template<typename I >
CPP_concept ranges::input_or_output_iterator
Initial value:
=
weakly_incrementable<I> &&
CPP_concept_ref(ranges::input_or_output_iterator_, I)

\concept input_or_output_iterator

The input_or_output_iterator concept

◆ mergeable

template<typename I1 , typename I2 , typename Out , typename C = less, typename P1 = identity, typename P2 = identity>
CPP_concept ranges::mergeable
Initial value:
=
input_iterator<I1> &&
input_iterator<I2> &&
weakly_incrementable<Out> &&
indirectly_copyable<I1, Out> &&
indirectly_copyable<I2, Out> &&
CPP_concept_ref(ranges::projected_indirect_strict_weak_order_, C, I1, P1, I2, P2)

◆ output_iterator

template<typename Out , typename T >
indirect_semigroup< projected< projected< I, detail::as_value_type_t< I > >, P >, BOp > AND ranges::output_iterator< O, iter_value_t< projected< projected< I, detail::as_value_type_t< I > >, P > > const & >
Initial value:
=
input_or_output_iterator<Out> &&
indirectly_writable<Out, T> &&
CPP_requires_ref(ranges::output_iterator_, Out, T)

\concept output_iterator

The output_iterator concept

◆ permutable

template<typename I >
CPP_concept ranges::permutable
Initial value:
=
forward_iterator<I> &&
indirectly_swappable<I, I> &&
indirectly_movable_storable<I, I>

\concept permutable

The permutable concept

◆ random_access_iterator

template<typename I >
CPP_concept ranges::random_access_iterator
Initial value:
=
bidirectional_iterator<I> &&
totally_ordered<I> &&
sized_sentinel_for<I, I> &&
CPP_requires_ref(ranges::random_access_iterator_, I) &&
CPP_concept_ref(ranges::with_category_, I, std::random_access_iterator_tag)

\concept random_access_iterator

The random_access_iterator concept

◆ readable

template<typename I >
constexpr RANGES_INLINE_VAR bool ranges::readable
constexpr
Initial value:
=
indirectly_readable<I>

◆ sentinel_for

template<typename S , typename I >
CPP_concept ranges::sentinel_for
Initial value:
=
semiregular<S> &&
input_or_output_iterator<I> &&
detail::weakly_equality_comparable_with_<S, I>

\concept sentinel_for

The sentinel_for concept

◆ sized_sentinel_for

template<typename S , typename I >
CPP_concept ranges::sized_sentinel_for
Initial value:
=
CPP_concept_ref(sized_sentinel_for_, S, I) &&
CPP_requires_ref(ranges::sized_sentinel_for_, S, I)

\concept sized_sentinel_for

The sized_sentinel_for concept

◆ sortable

template<typename I , typename C = less, typename P = identity>
CPP_concept ranges::sortable
Initial value:
=
permutable<I> &&
CPP_concept_ref(ranges::projected_indirect_strict_weak_order_, C, I, P, I, P)

\concept sortable

The sortable concept

◆ weakly_incrementable

template<typename I >
CPP_concept ranges::weakly_incrementable
Initial value:
=
copyable<I> &&
CPP_requires_ref(ranges::weakly_incrementable_, I) &&
CPP_concept_ref(ranges::weakly_incrementable_, I)

\concept weakly_incrementable

The weakly_incrementable concept

◆ writable

template<typename O , typename T >
constexpr RANGES_INLINE_VAR bool ranges::writable
constexpr
Initial value:
=
indirectly_writable<O, T>