In addition to being available via inclusion of the <ranges>
header, the customization point objects in [range.access] are
available when <iterator> is included.

The expression
ranges::begin(E) for some subexpression E is
expression-equivalent to:

- Otherwise, if E is an lvalue, decay-copy(E.begin()) if it is a valid expression and its type I models Iterator.
- Otherwise, decay-copy(begin(E)) if it is a valid expression and its type I models Iterator with overload resolution performed in a context that includes the declarations:
template<class T> void begin(T&&) = delete; template<class T> void begin(initializer_list<T>&&) = delete;

and does not include a declaration of ranges::begin. - Otherwise, ranges::begin(E) is ill-formed.

The expression
ranges::end(E) for some subexpression E is
expression-equivalent to:

- Otherwise, if E is an lvalue, decay-copy(E.end()) if it is a valid expression and its type S models Sentinel<decltype(ranges::begin(E))>.
- Otherwise, decay-copy(end(E)) if it is a valid expression and its type S models Sentinel<decltype(ranges::begin(E))> with overload resolution performed in a context that includes the declarations:
template<class T> void end(T&&) = delete; template<class T> void end(initializer_list<T>&&) = delete;

and does not include a declaration of ranges::end. - Otherwise, ranges::end(E) is ill-formed.

The expression
ranges::cend(E) for some subexpression E of type T
is expression-equivalent to:

- Otherwise, ranges::end(static_cast<const T&&>(E)).

The expression
ranges::rbegin(E) for some subexpression E is
expression-equivalent to:

- If E is an lvalue, decay-copy(E.rbegin()) if it is a valid expression and its type I models Iterator.
- Otherwise, decay-copy(rbegin(E)) if it is a valid expression and its type I models Iterator with overload resolution performed in a context that includes the declaration:
template<class T> void rbegin(T&&) = delete;

and does not include a declaration of ranges::rbegin. - Otherwise, make_reverse_iterator(ranges::end(E)) if both ranges::begin(E) and ranges::end(E) are valid expressions of the same type I which models BidirectionalIterator.
- Otherwise, ranges::rbegin(E) is ill-formed.

The expression
ranges::rend(E) for some subexpression E is
expression-equivalent to:

- If E is an lvalue, decay-copy(E.rend()) if it is a valid expression and its type S models Sentinel<decltype(ranges::rbegin(E))>.
- Otherwise, decay-copy(rend(E)) if it is a valid expression and its type S models Sentinel<decltype(ranges::rbegin(E))> with overload resolution performed in a context that includes the declaration:
template<class T> void rend(T&&) = delete;

and does not include a declaration of ranges::rend. - Otherwise, make_reverse_iterator(ranges::begin(E)) if both ranges::begin(E) and ranges::end(E) are valid expressions of the same type I which models BidirectionalIterator.
- Otherwise, ranges::rend(E) is ill-formed.

The expression
ranges::size(E) for some subexpression E with type
T is expression-equivalent to:

- Otherwise, if disable_sized_range<remove_cv_t<T>> ([range.sized]) is false:
- decay-copy(E.size()) if it is a valid expression and its type I models Integral.
- Otherwise, decay-copy(size(E))
if it is a valid expression and its type I
models Integral
with overload resolution performed in a context that includes
the declaration:
template<class T> void size(T&&) = delete;

and does not include a declaration of ranges::size.

- Otherwise, (ranges::end(E) - ranges::begin(E)) if it is a valid expression and the types I and S of ranges::begin(E) and ranges::end(E) (respectively) model both SizedSentinel<S, I> ([iterator.concept.sizedsentinel]) and ForwardIterator<I>.However, E is evaluated only once.
- Otherwise, ranges::size(E) is ill-formed.

The expression
ranges::empty(E) for some subexpression E is
expression-equivalent to:

- bool((E).empty()) if it is a valid expression.
- Otherwise, (ranges::size(E) == 0) if it is a valid expression.
- Otherwise, EQ, where EQ is bool(ranges::begin(E) == ranges::end(E)) except that E is only evaluated once, if EQ is a valid expression and the type of ranges::begin(E) models ForwardIterator.
- Otherwise, ranges::empty(E) is ill-formed.

The expression
ranges::data(E) for some subexpression E is
expression-equivalent to: