Iterator Concepts
Iterator

## Description

Iterator concepts.

## Classes

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

## Typedefs

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 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 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

concept() | ranges::contiguous_iterator_ (I)
concept() | ranges::indirect_binary_predicate_impl_ (F, I1, I2)
concept() | ranges::indirect_relation_ (F, I1, I2)
concept() | ranges::indirect_strict_weak_order_ (F, I1, I2)
concept() | ranges::indirect_unary_predicate_ (F, I)
concept() | ranges::indirectly_copyable_ (I, O)
concept() | ranges::indirectly_copyable_storable_ (I, O)
concept() | ranges::indirectly_movable_ (I, O)
concept() | ranges::indirectly_movable_storable_ (I, O)
concept() | ranges::indirectly_regular_unary_invocable_ (F, I)
concept() | ranges::input_or_output_iterator_ (I)
concept() | ranges::projected_indirect_relation_ (C, I1, P1, I2, P2)
concept() | ranges::projected_indirect_strict_weak_order_ (C, I1, P1, I2, P2)
concept() | ranges::readable_ (I)
concept() | ranges::sized_sentinel_for_ (S, I)
concept() | ranges::weakly_incrementable_ (I)
concept() | ranges::with_category_ (I, Tag)

## Variables

concept() indirectly_writable< O, iter_value_t< I > const & > &&copyable< iter_value_t< I > > &&constructible_from< iter_value_t< I >, iter_reference_t< I > > && | ranges::assignable_from< iter_value_t< I > &, iter_reference_t< I > >
concept() indirectly_writable< O, iter_value_t< I > > &&movable< iter_value_t< I > > &&constructible_from< iter_value_t< I >, iter_rvalue_reference_t< I > > && | ranges::assignable_from< iter_value_t< I > &, iter_rvalue_reference_t< I > >
template<typename I >
concept | ranges::bidirectional_iterator
template<typename I >
concept | ranges::bidirectional_iterator__requires_ = CPP_REQUIRES_requires ` (I i) ( --i, i--, concepts::requires_<same_as<I&, decltype(--i)>>, concepts::requires_<same_as<I, decltype(i--)>> )
concept() regular_invocable< F &, iter_value_t< I > & > &&regular_invocable< F &, iter_reference_t< I > > &&regular_invocable< F &, iter_common_reference_t< I > > && | ranges::common_reference_with< invoke_result_t< F &, iter_value_t< I > & >, invoke_result_t< F &, iter_reference_t< I > > >

concept() same_as< iter_reference_t< I const >, iter_reference_t< I > > &&same_as< iter_rvalue_reference_t< I const >, iter_rvalue_reference_t< I > > &&common_reference_with< iter_reference_t< I > &&, iter_value_t< I > & > &&common_reference_with< iter_reference_t< I > &&, iter_rvalue_reference_t< I > && > &&

ranges::common_reference_with< iter_rvalue_reference_t< I > &&, iter_value_t< I > const & >

template<typename I >
concept | ranges::contiguous_iterator
template<typename I >
concept | ranges::forward_iterator
template<typename I >
concept | ranges::incrementable
template<typename I >
concept | ranges::incrementable__requires_ = CPP_REQUIRES_requires ` (I i) ( concepts::requires_<same_as<I, decltype(i++)>> )
template<typename F , typename I1 , typename I2 >
concept | ranges::indirect_binary_predicate_
template<typename F , typename I1 , typename I2 = I1>
concept | ranges::indirect_relation
concept() | ranges::indirect_relation< C, projected< I1, P1 >, projected< I2, P2 > >
template<typename F , typename I1 , typename I2 = I1>
concept | ranges::indirect_strict_weak_order
concept() | ranges::indirect_strict_weak_order< C, projected< I1, P1 >, projected< I2, P2 > >
template<typename F , typename I >
concept | ranges::indirect_unary_predicate
template<typename I1 , typename I2 , typename C , typename P1 = identity, typename P2 = identity>
concept | ranges::indirectly_comparable
template<typename I , typename O >
concept | ranges::indirectly_copyable
template<typename I , typename O >
concept | ranges::indirectly_copyable_storable
template<typename I , typename O >
concept | ranges::indirectly_movable
template<typename I , typename O >
concept | ranges::indirectly_movable_storable
template<typename I >
concept | ranges::indirectly_readable
template<typename F , typename I >
concept | ranges::indirectly_regular_unary_invocable
template<typename I1 , typename I2 = I1>
concept | ranges::indirectly_swappable
template<typename I1 , typename I2 >
concept | ranges::indirectly_swappable__requires_ = CPP_REQUIRES_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) )
template<typename F , typename I >
concept | ranges::indirectly_unary_invocable
template<typename O , typename T >
concept | ranges::indirectly_writable
concept() | ranges::indirectly_writable< O, iter_reference_t< I > >
concept() | ranges::indirectly_writable< O, iter_rvalue_reference_t< I > >
template<typename I >
concept | ranges::input_iterator
template<typename I >
concept | ranges::input_or_output_iterator
template<typename I1 , typename I2 , typename Out , typename C = less, typename P1 = identity, typename P2 = identity>
concept | ranges::mergeable
template<typename Out , typename T >
concept | ranges::output_iterator
template<typename Out , typename T >
concept | ranges::output_iterator__requires_ = CPP_REQUIRES_requires ` (Out o, T && t) ( *o++ = (T &&) t )
template<typename I >
concept | ranges::permutable
concept() predicate< F &, iter_value_t< I > & > &&predicate< F &, iter_reference_t< I > > && | ranges::predicate< F &, iter_common_reference_t< I > >
concept() predicate< F &, iter_value_t< I1 > &, iter_value_t< I2 > & > &&predicate< F &, iter_value_t< I1 > &, iter_reference_t< I2 > > &&predicate< F &, iter_reference_t< I1 >, iter_value_t< I2 > & > &&predicate< F &, iter_reference_t< I1 >, iter_reference_t< I2 > > && | ranges::predicate< F &, iter_common_reference_t< I1 >, iter_common_reference_t< I2 > >
template<typename I >
concept | ranges::random_access_iterator
template<typename I >

concept

ranges::random_access_iterator__requires_ = CPP_REQUIRES_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>>> )

template<typename I >
constexpr bool | ranges::readable
concept() relation< F &, iter_value_t< I1 > &, iter_value_t< I2 > & > &&relation< F &, iter_value_t< I1 > &, iter_reference_t< I2 > > &&relation< F &, iter_reference_t< I1 >, iter_value_t< I2 > & > &&relation< F &, iter_reference_t< I1 >, iter_reference_t< I2 > > && | ranges::relation< F &, iter_common_reference_t< I1 >, iter_common_reference_t< I2 > >
template<typename S , typename I >
concept | ranges::sentinel_for
concept() !disable_sized_sentinel< std::remove_cv_t< S >, std::remove_cv_t< I > > && | ranges::sentinel_for< S, I >
template<typename S , typename I >
concept | ranges::sized_sentinel_for
template<typename S , typename I >
concept | ranges::sized_sentinel_for__requires_ = CPP_REQUIRES_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)>> )
template<typename I , typename C = less, typename P = identity>
concept | ranges::sortable
concept() strict_weak_order< F &, iter_value_t< I1 > &, iter_value_t< I2 > & > &&strict_weak_order< F &, iter_value_t< I1 > &, iter_reference_t< I2 > > &&strict_weak_order< F &, iter_reference_t< I1 >, iter_value_t< I2 > & > &&strict_weak_order< F &, iter_reference_t< I1 >, iter_reference_t< I2 > > && | ranges::strict_weak_order< F &, iter_common_reference_t< I1 >, iter_common_reference_t< I2 > >
template<typename I >
concept | ranges::weakly_incrementable
template<typename I >
concept | ranges::weakly_incrementable__requires_ = CPP_REQUIRES_requires ` (I i) ( ++i, i++, concepts::requires_<same_as<I&, decltype(++i)>> )
template<typename O , typename T >
constexpr bool | ranges::writable
template<typename O , typename T >
concept | ranges::writable__requires_ = CPP_REQUIRES_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 )

## Variable Documentation

## bidirectional_iterator

template<typename I >

concept ranges::bidirectional_iterator

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

Initial value:
=
forward_iterator<I> &&
ranges::bidirectional_iterator__requires_ < I > &&
ranges::with_category__concept_ < I, std::bidirectional_iterator_tag >

## contiguous_iterator

template<typename I >

concept ranges::contiguous_iterator

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

Initial value:
=
random_access_iterator<I> &&
ranges::contiguous_iterator__concept_ < I >

## forward_iterator

template<typename I >

concept ranges::forward_iterator

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

Initial value:
=
input_iterator<I> &&
incrementable<I> &&
sentinel_for<I, I> &&
ranges::with_category__concept_ < I, std::forward_iterator_tag >

## incrementable

template<typename I >

concept ranges::incrementable

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

Initial value:
=
regular<I> &&
weakly_incrementable<I> &&
ranges::incrementable__requires_ < I >

## indirect_binary_predicate_

template<typename F , typename I1 , typename I2 >

concept ranges::indirect_binary_predicate_

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

Initial value:
=
indirectly_readable<I1> && indirectly_readable<I2> &&
copy_constructible<F> &&
ranges::indirect_binary_predicate_impl__concept_ < F, I1, I2 >

## indirect_relation

template<typename F , typename I1 , typename I2 = I1>

concept ranges::indirect_relation

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

Initial value:
=
indirectly_readable<I1> && indirectly_readable<I2> &&
copy_constructible<F> &&
ranges::indirect_relation__concept_ < F, I1, I2 >

## indirect_strict_weak_order

template<typename F , typename I1 , typename I2 = I1>

concept ranges::indirect_strict_weak_order

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

Initial value:
=
indirectly_readable<I1> && indirectly_readable<I2> &&
copy_constructible<F> &&
ranges::indirect_strict_weak_order__concept_ < F, I1, I2 >

## indirect_unary_predicate

template<typename F , typename I >

concept ranges::indirect_unary_predicate

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

Initial value:
=
indirectly_readable<I> &&
copy_constructible<F> &&
ranges::indirect_unary_predicate__concept_ < F, I >

## indirectly_comparable

template<typename I1 , typename I2 , typename C , typename P1 = identity, typename P2 = identity>

concept ranges::indirectly_comparable

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

Initial value:
=
ranges::projected_indirect_relation__concept_ < C, I1, P1, I2, P2 >

## indirectly_copyable

template<typename I , typename O >

concept ranges::indirectly_copyable

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

Initial value:
=
indirectly_readable<I> && ranges::indirectly_copyable__concept_ < I, O >

## indirectly_copyable_storable

template<typename I , typename O >

concept ranges::indirectly_copyable_storable

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

Initial value:
=
indirectly_copyable<I, O> &&
ranges::indirectly_copyable_storable__concept_ < I, O >

## indirectly_movable

template<typename I , typename O >

concept ranges::indirectly_movable

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

Initial value:
=
indirectly_readable<I> && ranges::indirectly_movable__concept_ < I, O >

## indirectly_movable_storable

template<typename I , typename O >

concept ranges::indirectly_movable_storable

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

Initial value:
=
indirectly_movable<I, O> &&
ranges::indirectly_movable_storable__concept_ < I, O >

## indirectly_readable

template<typename I >

concept ranges::indirectly_readable

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

Initial value:
=
ranges::readable__concept_ < uncvref_t<I> >

## indirectly_regular_unary_invocable

template<typename F , typename I >

concept ranges::indirectly_regular_unary_invocable

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

Initial value:
=
indirectly_readable<I> &&
copy_constructible<F> &&
ranges::indirectly_regular_unary_invocable__concept_ < F, I >

## indirectly_swappable

template<typename I1 , typename I2 = I1>

concept ranges::indirectly_swappable

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

Initial value:
=
indirectly_readable<I1> &&
indirectly_readable<I2> &&
ranges::indirectly_swappable__requires_ < I1, I2 >

## indirectly_unary_invocable

template<typename F , typename I >

concept ranges::indirectly_unary_invocable

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

Initial value:
=
detail::indirectly_unary_invocable_<F, I> &&
copy_constructible<F>

## indirectly_writable

template<typename O , typename T >

concept ranges::indirectly_writable

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

Initial value:
=
ranges::writable__requires_ < O, T >

## input_iterator

template<typename I >

concept ranges::input_iterator

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

Initial value:
=
input_or_output_iterator<I> &&
indirectly_readable<I> &&
ranges::with_category__concept_ < I, std::input_iterator_tag >

## input_or_output_iterator

template<typename I >

concept ranges::input_or_output_iterator

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

Initial value:
=
weakly_incrementable<I> &&
ranges::input_or_output_iterator__concept_ < I >

## mergeable

template<typename I1 , typename I2 , typename Out , typename C = less, typename P1 = identity, typename P2 = identity>

concept ranges::mergeable

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

Initial value:
=
input_iterator<I1> &&
input_iterator<I2> &&
weakly_incrementable<Out> &&
indirectly_copyable<I1, Out> &&
indirectly_copyable<I2, Out> &&
ranges::projected_indirect_strict_weak_order__concept_ < C, I1, P1, I2, P2 >

## output_iterator

template<typename Out , typename T >

concept ranges::output_iterator

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

Initial value:
=
input_or_output_iterator<Out> &&
indirectly_writable<Out, T> &&
ranges::output_iterator__requires_ < Out, T >

## permutable

template<typename I >

concept ranges::permutable

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

Initial value:
=
forward_iterator<I> &&
indirectly_swappable<I, I> &&
indirectly_movable_storable<I, I>

## random_access_iterator

template<typename I >

concept ranges::random_access_iterator

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

Initial value:
=
bidirectional_iterator<I> &&
totally_ordered<I> &&
sized_sentinel_for<I, I> &&
ranges::random_access_iterator__requires_ < I > &&
ranges::with_category__concept_ < I, std::random_access_iterator_tag >

## readable

template<typename I >

constexpr bool ranges::readable

constexpr

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

Initial value:
=
indirectly_readable<I>

## sentinel_for

template<typename S , typename I >

concept ranges::sentinel_for

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

Initial value:
=
semiregular<S> &&
input_or_output_iterator<I> &&
detail::weakly_equality_comparable_with_<S, I>

## sized_sentinel_for

template<typename S , typename I >

concept ranges::sized_sentinel_for

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

Initial value:
=
sized_sentinel_for__concept_ < S, I > &&
ranges::sized_sentinel_for__requires_ < S, I >

## sortable

template<typename I , typename C = less, typename P = identity>

concept ranges::sortable

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

Initial value:
=
permutable<I> &&
ranges::projected_indirect_strict_weak_order__concept_ < C, I, P, I, P >

## weakly_incrementable

template<typename I >

concept ranges::weakly_incrementable

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

Initial value:
=
semiregular<I> &&
ranges::weakly_incrementable__requires_ < I > &&
ranges::weakly_incrementable__concept_ < I >

## writable

template<typename O , typename T >

constexpr bool ranges::writable

constexpr

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

Initial value:
=
indirectly_writable<O, T>