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) 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 >, detail::if_then_t< contiguous_iterator< Rng >, ranges::contiguous_iterator_tag, detail::if_then_t< random_access_iterator< Rng >, std::random_access_iterator_tag, detail::if_then_t< bidirectional_iterator< Rng >, std::bidirectional_iterator_tag, detail::if_then_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 >, detail::if_then_t< sized_sentinel_for< S, I >, sized_sentinel_tag, sentinel_tag > >

## Variables

template<typename I >
concept | ranges::bidirectional_iterator
template<typename I >
concept | ranges::contiguous_iterator
template<typename I >
concept | ranges::contiguous_iterator_ = std::is_lvalue_reference<iter_reference_t<I>>::value && same_as<iter_value_t<I>, uncvref_t<iter_reference_t<I>>> && derived_from<detail::iter_concept_t<I>, ranges::contiguous_iterator_tag>
template<typename I >
concept | ranges::forward_iterator
template<typename I >
concept i | ranges::i = n
template<typename I >
concept | ranges::incrementable
template<typename F , typename I1 , typename I2 >
concept | ranges::indirect_binary_predicate_
template<typename F , typename I1 , typename I2 >
concept | ranges::indirect_binary_predicate_frag_ = 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>> && predicate<F &, iter_common_reference_t<I1>, iter_common_reference_t<I2>>
template<typename F , typename I1 , typename I2 = I1>
concept | ranges::indirect_relation
template<typename F , typename I1 , typename I2 >
concept | ranges::indirect_relation_ = 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>> && relation<F &, iter_common_reference_t<I1>, iter_common_reference_t<I2>>
template<typename F , typename I1 , typename I2 = I1>
concept | ranges::indirect_strict_weak_order
template<typename F , typename I1 , typename I2 >
concept | ranges::indirect_strict_weak_order_ = 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>> && strict_weak_order<F &, iter_common_reference_t<I1>, iter_common_reference_t<I2>>
template<typename F , typename I >
concept | ranges::indirect_unary_predicate
template<typename F , typename I >
concept | ranges::indirect_unary_predicate_ = predicate<F &, iter_value_t<I> &> && predicate<F &, iter_reference_t<I>> && predicate<F &, iter_common_reference_t<I>>
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_ = writable<O, iter_reference_t<I>>
template<typename I , typename O >
concept | ranges::indirectly_copyable_storable
template<typename I , typename O >
concept | ranges::indirectly_copyable_storable_ = writable<O, iter_value_t<I> const &> && copyable<iter_value_t<I>> && constructible_from<iter_value_t<I>, iter_reference_t<I>> && assignable_from<iter_value_t<I> &, iter_reference_t<I>>
template<typename I , typename O >
concept | ranges::indirectly_movable
template<typename I , typename O >
concept | ranges::indirectly_movable_ = writable<O, iter_rvalue_reference_t<I>>
template<typename I , typename O >
concept | ranges::indirectly_movable_storable
template<typename I , typename O >
concept | ranges::indirectly_movable_storable_ = writable<O, iter_value_t<I>> && movable<iter_value_t<I>> && constructible_from<iter_value_t<I>, iter_rvalue_reference_t<I>> && assignable_from<iter_value_t<I> &, iter_rvalue_reference_t<I>>
template<typename F , typename I >
concept | ranges::indirectly_regular_unary_invocable
template<typename F , typename I >
concept | ranges::indirectly_regular_unary_invocable_ = regular_invocable<F &, iter_value_t<I> &> && regular_invocable<F &, iter_reference_t<I>> && regular_invocable<F &, iter_common_reference_t<I>> && common_reference_with< invoke_result_t<F &, iter_value_t<I> &>, invoke_result_t<F &, iter_reference_t<I>>>
template<typename I1 , typename I2 = I1>
concept | ranges::indirectly_swappable
template<typename F , typename I >
concept | ranges::indirectly_unary_invocable
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 I >
concept i | ranges::n
template<typename Out , typename T >
concept | ranges::output_iterator
template<typename I >
concept | ranges::permutable
template<typename C , typename I1 , typename P1 , typename I2 , typename P2 >
concept | ranges::projected_indirect_relation_ = indirect_relation<C, projected<I1, P1>, projected<I2, P2>>
template<typename C , typename I1 , typename P1 , typename I2 , typename P2 >
concept | ranges::projected_indirect_strict_weak_order_ = indirect_strict_weak_order<C, projected<I1, P1>, projected<I2, P2>>
template<typename I >
concept | ranges::random_access_iterator
template<typename I >
concept | ranges::readable
template<typename I >
concept | ranges::readable_ = common_reference_with<iter_reference_t<I> &&, iter_value_t<I> &> && common_reference_with<iter_reference_t<I> &&, iter_rvalue_reference_t<I> &&> && common_reference_with<iter_rvalue_reference_t<I> &&, iter_value_t<I> const &>
template<typename S , typename I >
concept | ranges::sentinel_for
template<typename S , typename I >
concept | ranges::sized_sentinel_for
template<typename I , typename C = less, typename P = identity>
concept | ranges::sortable
template<typename I >
concept | ranges::weakly_incrementable
template<typename I >
concept | ranges::weakly_incrementable_ = concepts::type<iter_difference_t<I>> && detail::signed_integer_like_<iter_difference_t<I>>
template<typename I , typename Tag >
concept | ranges::with_category_ = derived_from<detail::iter_concept_t<I>, Tag>
template<typename Out , typename T >
concept | ranges::writable

## Variable Documentation

## bidirectional_iterator

template<typename I >

concept ranges::bidirectional_iterator

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

Initial value:
=
requires( I i )
(
--i,
i--,
concepts::requires_<same_as<I&, decltype(--i)>>,
concepts::requires_<same_as<I, decltype(i--)>>
) &&
forward_iterator<I> &&
ranges::with_category_ < I, std::bidirectional_iterator_tag >
meta::requires
requires(sizeof...(Ts) > 0) using lambda
For creating anonymous Invocables.

## contiguous_iterator

template<typename I >

concept ranges::contiguous_iterator

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

Initial value:
=
random_access_iterator<I> &&
ranges::contiguous_iterator_ < 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_ < 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> &&
requires( I i )
(
concepts::requires_<same_as<I, decltype(i++)>>
)
meta::requires
requires(sizeof...(Ts) > 0) using lambda
For creating anonymous Invocables.

## indirect_binary_predicate_

template<typename F , typename I1 , typename I2 >

concept ranges::indirect_binary_predicate_

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

Initial value:
=
readable<I1> && readable<I2> &&
copy_constructible<F> &&
ranges::indirect_binary_predicate_frag_ < 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:
=
readable<I1> && readable<I2> &&
copy_constructible<F> &&
ranges::indirect_relation_ < 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:
=
readable<I1> && readable<I2> &&
copy_constructible<F> &&
ranges::indirect_strict_weak_order_ < F, I1, I2 >

## indirect_unary_predicate

template<typename F , typename I >

concept ranges::indirect_unary_predicate

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

Initial value:
=
readable<I> &&
copy_constructible<F> &&
ranges::indirect_unary_predicate_ < 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_ < C, I1, P1, I2, P2 >

## indirectly_copyable

template<typename I , typename O >

concept ranges::indirectly_copyable

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

Initial value:
=
readable<I> && ranges::indirectly_copyable_ < 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_ < I, O >

## indirectly_movable

template<typename I , typename O >

concept ranges::indirectly_movable

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

Initial value:
=
readable<I> && ranges::indirectly_movable_ < 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_ < I, O >

## indirectly_regular_unary_invocable

template<typename F , typename I >

concept ranges::indirectly_regular_unary_invocable

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

Initial value:
=
readable<I> &&
copy_constructible<F> &&
ranges::indirectly_regular_unary_invocable_ < F, I >

## indirectly_swappable

template<typename I1 , typename I2 = I1>

concept ranges::indirectly_swappable

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

Initial value:
=
readable<I1> && readable<I2> &&
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)
)
iter_swap
constexpr _iter_swap_::fn iter_swap
Definition: access.hpp:253
meta::requires
requires(sizeof...(Ts) > 0) using lambda
For creating anonymous Invocables.

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

## input_iterator

template<typename I >

concept ranges::input_iterator

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

Initial value:
=
input_or_output_iterator<I> && readable<I> &&
ranges::with_category_ < 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> &&
detail::dereferenceable_<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_ < 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> && writable<Out, T> &&
requires( Out o , T && t )
(
*o++ = ((decltype( t )&&) t )
)
meta::requires
requires(sizeof...(Ts) > 0) using lambda
For creating anonymous Invocables.

## 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:
=
requires( CPP_arg_2 i + n ( (I) i ), CPP_arg_2 i + n ( (iter_difference_t< I >) n ), CPP_arg_2 i + n ( (iter_reference_t< I >&) )) n + i
meta::requires
requires(sizeof...(Ts) > 0) using lambda
For creating anonymous Invocables.

## readable

template<typename I >

concept ranges::readable

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

Initial value:
=
requires( uncvref_t<I> const i , uncvref_t<I> j )
(
concepts::requires_<same_as<iter_reference_t<decltype(i)>,
iter_reference_t<decltype(j)>>>,
concepts::requires_<same_as<iter_rvalue_reference_t<decltype(i)>,
iter_rvalue_reference_t<decltype(j)>>>
) &&
readable_ < uncvref_t<I> >
meta::requires
requires(sizeof...(Ts) > 0) using lambda
For creating anonymous Invocables.

## 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:
=
requires( S const & s , I const & i )
(
s - i,
i - s,
concepts::requires_<same_as<iter_difference_t<decltype(i)>, decltype(s - i)>>,
concepts::requires_<same_as<iter_difference_t<decltype(i)>, decltype(i - s)>>
) &&
bool(!defer::is_true<disable_sized_sentinel<std::remove_cv_t<S>,
std::remove_cv_t<I>>> &&
defer::sentinel_for<S, I>)
meta::requires
requires(sizeof...(Ts) > 0) using lambda
For creating anonymous Invocables.

## 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_ < 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_ < I > &&
requires( I i )
(
++i,
i++,
concepts::requires_<same_as<I&, decltype(++i)>>
)
meta::requires
requires(sizeof...(Ts) > 0) using lambda
For creating anonymous Invocables.

## writable

template<typename Out , typename T >

concept ranges::writable

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

Initial value:
=
requires( Out && o , T && t )
(
*o = ((decltype( t )&&) t ),
*((decltype( o )&&) o ) = ((decltype( t )&&) t ),
const_cast<iter_reference_t<decltype(o)> const &&>(*o) = ((decltype( t )&&) t ),
const_cast<iter_reference_t<decltype(o)> const &&>(*((decltype( o )&&) o )) = ((decltype( t )&&) t )
)
meta::requires
requires(sizeof...(Ts) > 0) using lambda
For creating anonymous Invocables.