[range.access] - C++20 → C++23

Files changed (1) hide show

tmp/tmpn4nzvla6/{from.md → to.md} +118 -128

tmp/tmpn4nzvla6/{from.md → to.md} RENAMED Viewed

@@ -1,12 +1,14 @@
 ## Range access <a id="range.access">[[range.access]]</a>
 In addition to being available via inclusion of the `<ranges>` header,
 the customization point objects in [[range.access]] are available when
 `<iterator>` is included.
-Within this subclause, the *reified object* of a subexpression `E`
 denotes
 - the same object as `E` if `E` is a glvalue, or
 - the result of applying the temporary materialization conversion
   [[conv.rval]] to `E` otherwise.
@@ -19,31 +21,23 @@ The name `ranges::begin` denotes a customization point object
 Given a subexpression `E` with type `T`, let `t` be an lvalue that
 denotes the reified object for `E`. Then:
 - If `E` is an rvalue and `enable_borrowed_range<remove_cv_t<T>>` is
   `false`, `ranges::begin(E)` is ill-formed.
-- Otherwise, if `T` is an array type [[basic.compound]] and
   `remove_all_extents_t<T>` is an incomplete type, `ranges::begin(E)` is
   ill-formed with no diagnostic required.
 - Otherwise, if `T` is an array type, `ranges::begin(E)` is
   expression-equivalent to `t + 0`.
-- Otherwise, if `decay-copy(t.begin())` is a valid expression whose type
   models `input_or_output_iterator`, `ranges::begin(E)` is
-  expression-equivalent to `decay-copy(t.begin())`.
-- Otherwise, if `T` is a class or enumeration type and
- `decay-copy(begin(t))` is a valid expression whose type models
-  `input_or_output_iterator` with overload resolution performed in a
- context in which unqualified lookup for `begin` finds only the
- declarations
-  ``` cpp
-  void begin(auto&) = delete;
-  void begin(const auto&) = delete;
-  ```
-  then `ranges::begin(E)` is expression-equivalent to
-  `decay-copy(begin(t))` with overload resolution performed in the above
-  context.
 - Otherwise, `ranges::begin(E)` is ill-formed.
 [*Note 1*: Diagnosable ill-formed cases above result in substitution
 failure when `ranges::begin(E)` appears in the immediate context of a
 template instantiation. — *end note*]
@@ -59,32 +53,25 @@ The name `ranges::end` denotes a customization point object
 Given a subexpression `E` with type `T`, let `t` be an lvalue that
 denotes the reified object for `E`. Then:
 - If `E` is an rvalue and `enable_borrowed_range<remove_cv_t<T>>` is
   `false`, `ranges::end(E)` is ill-formed.
-- Otherwise, if `T` is an array type [[basic.compound]] and
   `remove_all_extents_t<T>` is an incomplete type, `ranges::end(E)` is
   ill-formed with no diagnostic required.
 - Otherwise, if `T` is an array of unknown bound, `ranges::end(E)` is
   ill-formed.
 - Otherwise, if `T` is an array, `ranges::end(E)` is
   expression-equivalent to `t + extent_v<T>`.
-- Otherwise, if `decay-copy(t.end())` is a valid expression whose type
- models `sentinel_for<iterator_t<T>>` then `ranges::end(E)` is
-  expression-equivalent to `decay-copy(t.end())`.
-- Otherwise, if `T` is a class or enumeration type and
- `decay-copy(end(t))` is a valid expression whose type models
-  `sentinel_for<iterator_t<T>>` with overload resolution performed in a
- context in which unqualified lookup for `end` finds only the
- declarations
-  ``` cpp
-  void end(auto&) = delete;
-  void end(const auto&) = delete;
-  ```
-  then `ranges::end(E)` is expression-equivalent to `decay-copy(end(t))`
-  with overload resolution performed in the above context.
 - Otherwise, `ranges::end(E)` is ill-formed.
 [*Note 1*: Diagnosable ill-formed cases above result in substitution
 failure when `ranges::end(E)` appears in the immediate context of a
 template instantiation. — *end note*]
@@ -94,31 +81,39 @@ template instantiation. — *end note*]
 `sentinel_for<S, I>`. — *end note*]
 ### `ranges::cbegin` <a id="range.access.cbegin">[[range.access.cbegin]]</a>
 The name `ranges::cbegin` denotes a customization point object
-[[customization.point.object]]. The expression `ranges::{}cbegin(E)` for
-a subexpression `E` of type `T` is expression-equivalent to:
-- `ranges::begin(static_cast<const T&>(E))` if `E` is an lvalue.
-- Otherwise, `ranges::begin(static_cast<const T&&>(E))`.
 [*Note 1*: Whenever `ranges::cbegin(E)` is a valid expression, its type
-models `input_or_output_iterator`. — *end note*]
 ### `ranges::cend` <a id="range.access.cend">[[range.access.cend]]</a>
 The name `ranges::cend` denotes a customization point object
-[[customization.point.object]]. The expression `ranges::cend(E)` for a
-subexpression `E` of type `T` is expression-equivalent to:
-- `ranges::end(static_cast<const T&>(E))` if `E` is an lvalue.
-- Otherwise, `ranges::end(static_cast<const T&&>(E))`.
 [*Note 1*: Whenever `ranges::cend(E)` is a valid expression, the types
-`S` and `I` of `ranges::cend(E)` and `ranges::cbegin(E)` model
-`sentinel_for<S, I>`. — *end note*]
 ### `ranges::rbegin` <a id="range.access.rbegin">[[range.access.rbegin]]</a>
 The name `ranges::rbegin` denotes a customization point object
 [[customization.point.object]].
@@ -126,29 +121,21 @@ The name `ranges::rbegin` denotes a customization point object
 Given a subexpression `E` with type `T`, let `t` be an lvalue that
 denotes the reified object for `E`. Then:
 - If `E` is an rvalue and `enable_borrowed_range<remove_cv_t<T>>` is
   `false`, `ranges::rbegin(E)` is ill-formed.
-- Otherwise, if `T` is an array type [[basic.compound]] and
   `remove_all_extents_t<T>` is an incomplete type, `ranges::rbegin(E)`
   is ill-formed with no diagnostic required.
-- Otherwise, if `decay-copy(t.rbegin())` is a valid expression whose
- type models `input_or_output_iterator`, `ranges::rbegin(E)` is
-  expression-equivalent to `decay-copy(t.rbegin())`.
-- Otherwise, if `T` is a class or enumeration type and
- `decay-copy(rbegin(t))` is a valid expression whose type models
-  `input_or_output_iterator` with overload resolution performed in a
- context in which unqualified lookup for `rbegin` finds only the
- declarations
-  ``` cpp
-  void rbegin(auto&) = delete;
-  void rbegin(const auto&) = delete;
-  ```
-  then `ranges::rbegin(E)` is expression-equivalent to
-  `decay-copy(rbegin(t))` with overload resolution performed in the
-  above context.
 - Otherwise, if both `ranges::begin(t)` and `ranges::end(t)` are valid
   expressions of the same type which models `bidirectional_iterator`
   [[iterator.concept.bidir]], `ranges::rbegin(E)` is
   expression-equivalent to `make_reverse_iterator(ranges::end(t))`.
 - Otherwise, `ranges::rbegin(E)` is ill-formed.
@@ -168,30 +155,22 @@ The name `ranges::rend` denotes a customization point object
 Given a subexpression `E` with type `T`, let `t` be an lvalue that
 denotes the reified object for `E`. Then:
 - If `E` is an rvalue and `enable_borrowed_range<remove_cv_t<T>>` is
   `false`, `ranges::rend(E)` is ill-formed.
-- Otherwise, if `T` is an array type [[basic.compound]] and
   `remove_all_extents_t<T>` is an incomplete type, `ranges::rend(E)` is
   ill-formed with no diagnostic required.
-- Otherwise, if `decay-copy(t.rend())` is a valid expression whose type
- models `sentinel_for<decltype(ranges::rbegin(E))>` then
- `ranges::rend(E)` is expression-equivalent to
-  `decay-copy(t.rend({}))`.
-- Otherwise, if `T` is a class or enumeration type and
-  `decay-copy(rend(t))` is a valid expression whose type models
-  `sentinel_for<decltype(ranges::rbegin(E))>` with overload resolution
- performed in a context in which unqualified lookup for `rend` finds
- only the declarations
-  ``` cpp
-  void rend(auto&) = delete;
-  void rend(const auto&) = delete;
-  ```
-  then `ranges::rend(E)` is expression-equivalent to
-  `decay-copy(rend(t))` with overload resolution performed in the above
-  context.
 - Otherwise, if both `ranges::begin(t)` and `ranges::end(t)` are valid
   expressions of the same type which models `bidirectional_iterator`
   [[iterator.concept.bidir]], then `ranges::rend(E)` is
   expression-equivalent to `make_reverse_iterator(ranges::begin(t))`.
 - Otherwise, `ranges::rend(E)` is ill-formed.
@@ -199,67 +178,69 @@ denotes the reified object for `E`. Then:
 [*Note 1*: Diagnosable ill-formed cases above result in substitution
 failure when `ranges::rend(E)` appears in the immediate context of a
 template instantiation. — *end note*]
 [*Note 2*: Whenever `ranges::rend(E)` is a valid expression, the types
-`S` and `I` of `ranges::rend(E)` and `ranges::rbegin(E)` model
-`sentinel_for<S, I>`. — *end note*]
 ### `ranges::crbegin` <a id="range.access.crbegin">[[range.access.crbegin]]</a>
 The name `ranges::crbegin` denotes a customization point object
-[[customization.point.object]]. The expression `ranges::{}crbegin(E)`
-for a subexpression `E` of type `T` is expression-equivalent to:
-- `ranges::{}rbegin(static_cast<const T&>(E))` if `E` is an lvalue.
-- Otherwise, `ranges::rbegin(static_cast<const T&&>(E))`.
 [*Note 1*: Whenever `ranges::crbegin(E)` is a valid expression, its
-type models `input_or_output_iterator`. — *end note*]
 ### `ranges::crend` <a id="range.access.crend">[[range.access.crend]]</a>
 The name `ranges::crend` denotes a customization point object
-[[customization.point.object]]. The expression `ranges::{}crend(E)` for
-a subexpression `E` of type `T` is expression-equivalent to:
-- `ranges::rend(static_cast<const T&>(E))` if `E` is an lvalue.
-- Otherwise, `ranges::rend(static_cast<const T&&>(E))`.
 [*Note 1*: Whenever `ranges::crend(E)` is a valid expression, the types
-`S` and `I` of `ranges::crend(E)` and `ranges::crbegin(E)` model
-`sentinel_for<S, I>`. — *end note*]
 ### `ranges::size` <a id="range.prim.size">[[range.prim.size]]</a>
 The name `ranges::size` denotes a customization point object
 [[customization.point.object]].
 Given a subexpression `E` with type `T`, let `t` be an lvalue that
 denotes the reified object for `E`. Then:
-- If `T` is an array of unknown bound [[dcl.array]], `ranges::size(E)`
-  is ill-formed.
 - Otherwise, if `T` is an array type, `ranges::size(E)` is
-  expression-equivalent to `decay-copy(extent_v<T>)`.
 - Otherwise, if `disable_sized_range<remove_cv_t<T>>` [[range.sized]] is
-  `false` and `decay-copy(t.size())` is a valid expression of
- integer-like type [[iterator.concept.winc]], `ranges::size(E)` is
-  expression-equivalent to `decay-copy(t.size())`.
 - Otherwise, if `T` is a class or enumeration type,
-  `disable_sized_range<remove_cv_t<T>>` is `false` and
- `decay-copy(size(t))` is a valid expression of integer-like type with
- overload resolution performed in a context in which unqualified lookup
- for `size` finds only the declarations
- ``` cpp
-  void size(auto&) = delete;
-  void size(const auto&) = delete;
-  ```
-  then `ranges::size(E)` is expression-equivalent to
-  `decay-copy(size(t))` with overload resolution performed in the above
-  context.
 - Otherwise, if `to-unsigned-like(ranges::end(t) - ranges::begin(t))`
   [[ranges.syn]] is a valid expression and the types `I` and `S` of
   `ranges::begin(t)` and `ranges::end(t)` (respectively) model both
   `sized_sentinel_for<S, I>` [[iterator.concept.sizedsentinel]] and
   `forward_iterator<I>`, then `ranges::size(E)` is expression-equivalent
@@ -274,26 +255,28 @@ template instantiation. — *end note*]
 is integer-like. — *end note*]
 ### `ranges::ssize` <a id="range.prim.ssize">[[range.prim.ssize]]</a>
 The name `ranges::ssize` denotes a customization point object
-[[customization.point.object]]. The expression `ranges::ssize({}E)` for
-a subexpression `E` of type `T` is expression-equivalent to:
-- If `range_difference_t<T>` has width less than `ptrdiff_t`,
- `static_cast<ptrdiff_t>(ranges::{}size(E))`.
-- Otherwise, `static_cast<range_difference_t<T>>(ranges::size(E))`.
 ### `ranges::empty` <a id="range.prim.empty">[[range.prim.empty]]</a>
 The name `ranges::empty` denotes a customization point object
 [[customization.point.object]].
-Given a subexpression `ranges::empty(E)` with type `T`, let `t` be an
-lvalue that denotes the reified object for `E`. Then:
-- If `T` is an array of unknown bound [[basic.compound]],
   `ranges::empty(E)` is ill-formed.
 - Otherwise, if `bool(t.empty())` is a valid expression,
   `ranges::empty(E)` is expression-equivalent to `bool(t.empty())`.
 - Otherwise, if `(ranges::size(t) == 0)` is a valid expression,
   `ranges::empty(E)` is expression-equivalent to
@@ -319,19 +302,19 @@ The name `ranges::data` denotes a customization point object
 Given a subexpression `E` with type `T`, let `t` be an lvalue that
 denotes the reified object for `E`. Then:
 - If `E` is an rvalue and `enable_borrowed_range<remove_cv_t<T>>` is
   `false`, `ranges::data(E)` is ill-formed.
-- Otherwise, if `T` is an array type [[basic.compound]] and
   `remove_all_extents_t<T>` is an incomplete type, `ranges::data(E)` is
   ill-formed with no diagnostic required.
-- Otherwise, if `decay-copy(t.data())` is a valid expression of pointer
- to object type, `ranges::data(E)` is expression-equivalent to
-  `decay-copy(t.data())`.
 - Otherwise, if `ranges::begin(t)` is a valid expression whose type
   models `contiguous_iterator`, `ranges::data(E)` is
-  expression-equivalent to `to_address(ranges::begin(E))`.
 - Otherwise, `ranges::data(E)` is ill-formed.
 [*Note 1*: Diagnosable ill-formed cases above result in substitution
 failure when `ranges::data(E)` appears in the immediate context of a
 template instantiation. — *end note*]
@@ -339,15 +322,22 @@ template instantiation. — *end note*]
 [*Note 2*: Whenever `ranges::data(E)` is a valid expression, it has
 pointer to object type. — *end note*]
 ### `ranges::cdata` <a id="range.prim.cdata">[[range.prim.cdata]]</a>
 The name `ranges::cdata` denotes a customization point object
-[[customization.point.object]]. The expression `ranges::{}cdata(E)` for
-a subexpression `E` of type `T` is expression-equivalent to:
-- `ranges::data(static_cast<const T&>(E))` if `E` is an lvalue.
-- Otherwise, `ranges::data(static_cast<const T&&>(E))`.
 [*Note 1*: Whenever `ranges::cdata(E)` is a valid expression, it has
-pointer to object type. — *end note*]

 ## Range access <a id="range.access">[[range.access]]</a>
+### General <a id="range.access.general">[[range.access.general]]</a>
 In addition to being available via inclusion of the `<ranges>` header,
 the customization point objects in [[range.access]] are available when
 `<iterator>` is included.
+Within [[range.access]], the *reified object* of a subexpression `E`
 denotes
 - the same object as `E` if `E` is a glvalue, or
 - the result of applying the temporary materialization conversion
   [[conv.rval]] to `E` otherwise.
 Given a subexpression `E` with type `T`, let `t` be an lvalue that
 denotes the reified object for `E`. Then:
 - If `E` is an rvalue and `enable_borrowed_range<remove_cv_t<T>>` is
   `false`, `ranges::begin(E)` is ill-formed.
+- Otherwise, if `T` is an array type [[term.array.type]] and
   `remove_all_extents_t<T>` is an incomplete type, `ranges::begin(E)` is
   ill-formed with no diagnostic required.
 - Otherwise, if `T` is an array type, `ranges::begin(E)` is
   expression-equivalent to `t + 0`.
+- Otherwise, if `auto(t.begin())` is a valid expression whose type
   models `input_or_output_iterator`, `ranges::begin(E)` is
+  expression-equivalent to `auto(t.begin())`.
+- Otherwise, if `T` is a class or enumeration type and `auto(begin(t))`
+  is a valid expression whose type models `input_or_output_iterator`
+ where the meaning of `begin` is established as-if by performing
+ argument-dependent lookup only [[basic.lookup.argdep]], then
+ `ranges::begin(E)` is expression-equivalent to that expression.
 - Otherwise, `ranges::begin(E)` is ill-formed.
 [*Note 1*: Diagnosable ill-formed cases above result in substitution
 failure when `ranges::begin(E)` appears in the immediate context of a
 template instantiation. — *end note*]
 Given a subexpression `E` with type `T`, let `t` be an lvalue that
 denotes the reified object for `E`. Then:
 - If `E` is an rvalue and `enable_borrowed_range<remove_cv_t<T>>` is
   `false`, `ranges::end(E)` is ill-formed.
+- Otherwise, if `T` is an array type [[term.array.type]] and
   `remove_all_extents_t<T>` is an incomplete type, `ranges::end(E)` is
   ill-formed with no diagnostic required.
 - Otherwise, if `T` is an array of unknown bound, `ranges::end(E)` is
   ill-formed.
 - Otherwise, if `T` is an array, `ranges::end(E)` is
   expression-equivalent to `t + extent_v<T>`.
+- Otherwise, if `auto(t.end())` is a valid expression whose type models
+  `sentinel_for<iterator_t<T>>` then `ranges::end(E)` is
+  expression-equivalent to `auto(t.end())`.
+- Otherwise, if `T` is a class or enumeration type and `auto(end(t))` is
+  a valid expression whose type models `sentinel_for<iterator_t<T>>`
+ where the meaning of `end` is established as-if by performing
+ argument-dependent lookup only [[basic.lookup.argdep]], then
+ `ranges::end(E)` is expression-equivalent to that expression.
 - Otherwise, `ranges::end(E)` is ill-formed.
 [*Note 1*: Diagnosable ill-formed cases above result in substitution
 failure when `ranges::end(E)` appears in the immediate context of a
 template instantiation. — *end note*]
 `sentinel_for<S, I>`. — *end note*]
 ### `ranges::cbegin` <a id="range.access.cbegin">[[range.access.cbegin]]</a>
 The name `ranges::cbegin` denotes a customization point object
+[[customization.point.object]]. Given a subexpression `E` with type `T`,
+let `t` be an lvalue that denotes the reified object for `E`. Then:
+- If `E` is an rvalue and `enable_borrowed_range<remove_cv_t<T>>` is
+  `false`, `ranges::cbegin(E)` is ill-formed.
+- Otherwise, let `U` be `ranges::begin(possibly-const-range(t))`.
+  `ranges::cbegin(E)` is expression-equivalent to
+  `const_iterator<decltype(U)>(U)`.
 [*Note 1*: Whenever `ranges::cbegin(E)` is a valid expression, its type
+models `input_or_output_iterator` and
+`constant-iterator`. — *end note*]
 ### `ranges::cend` <a id="range.access.cend">[[range.access.cend]]</a>
 The name `ranges::cend` denotes a customization point object
+[[customization.point.object]]. Given a subexpression `E` with type `T`,
+let `t` be an lvalue that denotes the reified object for `E`. Then:
+- If `E` is an rvalue and `enable_borrowed_range<remove_cv_t<T>>` is
+  `false`, `ranges::cend(E)` is ill-formed.
+- Otherwise, let `U` be `ranges::end(possibly-const-range(t))`.
+  `ranges::cend(E)` is expression-equivalent to
+  `const_sentinel<decltype(U)>(U)`.
 [*Note 1*: Whenever `ranges::cend(E)` is a valid expression, the types
+`S` and `I` of the expressions `ranges::cend(E)` and `ranges::cbegin(E)`
+model `sentinel_for<S, I>`. If `S` models `input_iterator`, then `S`
+also models *`constant-iterator`*. — *end note*]
 ### `ranges::rbegin` <a id="range.access.rbegin">[[range.access.rbegin]]</a>
 The name `ranges::rbegin` denotes a customization point object
 [[customization.point.object]].
 Given a subexpression `E` with type `T`, let `t` be an lvalue that
 denotes the reified object for `E`. Then:
 - If `E` is an rvalue and `enable_borrowed_range<remove_cv_t<T>>` is
   `false`, `ranges::rbegin(E)` is ill-formed.
+- Otherwise, if `T` is an array type [[term.array.type]] and
   `remove_all_extents_t<T>` is an incomplete type, `ranges::rbegin(E)`
   is ill-formed with no diagnostic required.
+- Otherwise, if `auto(t.rbegin())` is a valid expression whose type
+  models `input_or_output_iterator`, `ranges::rbegin(E)` is
+  expression-equivalent to `auto(t.rbegin())`.
+- Otherwise, if `T` is a class or enumeration type and `auto(rbegin(t))`
+  is a valid expression whose type models `input_or_output_iterator`
+ where the meaning of `rbegin` is established as-if by performing
+ argument-dependent lookup only [[basic.lookup.argdep]], then
+ `ranges::rbegin(E)` is expression-equivalent to that expression.
 - Otherwise, if both `ranges::begin(t)` and `ranges::end(t)` are valid
   expressions of the same type which models `bidirectional_iterator`
   [[iterator.concept.bidir]], `ranges::rbegin(E)` is
   expression-equivalent to `make_reverse_iterator(ranges::end(t))`.
 - Otherwise, `ranges::rbegin(E)` is ill-formed.
 Given a subexpression `E` with type `T`, let `t` be an lvalue that
 denotes the reified object for `E`. Then:
 - If `E` is an rvalue and `enable_borrowed_range<remove_cv_t<T>>` is
   `false`, `ranges::rend(E)` is ill-formed.
+- Otherwise, if `T` is an array type [[term.array.type]] and
   `remove_all_extents_t<T>` is an incomplete type, `ranges::rend(E)` is
   ill-formed with no diagnostic required.
+- Otherwise, if `auto(t.rend())` is a valid expression whose type models
+  `sentinel_for<decltype({}ranges::rbegin(E))>` then `ranges::rend(E)`
+  is expression-equivalent to `auto(t.rend())`.
+- Otherwise, if `T` is a class or enumeration type and `auto(rend(t))`
+ is a valid expression whose type models
+  `sentinel_for<decltype(ranges::rbegin(E))>` where the meaning of
+  `rend` is established as-if by performing argument-dependent lookup
+ only [[basic.lookup.argdep]], then `ranges::rend(E)` is
+ expression-equivalent to that expression.
 - Otherwise, if both `ranges::begin(t)` and `ranges::end(t)` are valid
   expressions of the same type which models `bidirectional_iterator`
   [[iterator.concept.bidir]], then `ranges::rend(E)` is
   expression-equivalent to `make_reverse_iterator(ranges::begin(t))`.
 - Otherwise, `ranges::rend(E)` is ill-formed.
 [*Note 1*: Diagnosable ill-formed cases above result in substitution
 failure when `ranges::rend(E)` appears in the immediate context of a
 template instantiation. — *end note*]
 [*Note 2*: Whenever `ranges::rend(E)` is a valid expression, the types
+`S` and `I` of the expressions `ranges::rend(E)` and `ranges::rbegin(E)`
+model `sentinel_for<S, I>`. — *end note*]
 ### `ranges::crbegin` <a id="range.access.crbegin">[[range.access.crbegin]]</a>
 The name `ranges::crbegin` denotes a customization point object
+[[customization.point.object]]. Given a subexpression `E` with type `T`,
+let `t` be an lvalue that denotes the reified object for `E`. Then:
+- If `E` is an rvalue and `enable_borrowed_range<remove_cv_t<T>>` is
+  `false`, `ranges::crbegin(E)` is ill-formed.
+- Otherwise, let `U` be `ranges::rbegin(possibly-const-range(t))`.
+  `ranges::crbegin(E)` is expression-equivalent to
+  `const_iterator<decltype(U)>(U)`.
 [*Note 1*: Whenever `ranges::crbegin(E)` is a valid expression, its
+type models `input_or_output_iterator` and
+`constant-iterator`. — *end note*]
 ### `ranges::crend` <a id="range.access.crend">[[range.access.crend]]</a>
 The name `ranges::crend` denotes a customization point object
+[[customization.point.object]]. Given a subexpression `E` with type `T`,
+let `t` be an lvalue that denotes the reified object for `E`. Then:
+- If `E` is an rvalue and `enable_borrowed_range<remove_cv_t<T>>` is
+  `false`, `ranges::crend(E)` is ill-formed.
+- Otherwise, let `U` be `ranges::rend(possibly-const-range(t))`.
+  `ranges::crend(E)` is expression-equivalent to
+  `const_sentinel<decltype(U)>(U)`.
 [*Note 1*: Whenever `ranges::crend(E)` is a valid expression, the types
+`S` and `I` of the expressions `ranges::crend(E)` and
+`ranges::crbegin(E)` model `sentinel_for<S, I>`. If `S` models
+`input_iterator`, then `S` also models
+*`constant-iterator`*. — *end note*]
 ### `ranges::size` <a id="range.prim.size">[[range.prim.size]]</a>
 The name `ranges::size` denotes a customization point object
 [[customization.point.object]].
 Given a subexpression `E` with type `T`, let `t` be an lvalue that
 denotes the reified object for `E`. Then:
+- If `T` is an array of unknown bound [[term.array.type]],
+ `ranges::size(E)` is ill-formed.
 - Otherwise, if `T` is an array type, `ranges::size(E)` is
+  expression-equivalent to `auto(extent_v<T>)`.
 - Otherwise, if `disable_sized_range<remove_cv_t<T>>` [[range.sized]] is
+  `false` and `auto(t.size())` is a valid expression of integer-like
+  type [[iterator.concept.winc]], `ranges::size(E)` is
+  expression-equivalent to `auto({}t.size())`.
 - Otherwise, if `T` is a class or enumeration type,
+  `disable_sized_range<remove_cv_t<T>>` is `false` and `auto(size(t))`
+  is a valid expression of integer-like type where the meaning of `size`
+ is established as-if by performing argument-dependent lookup only
+ [[basic.lookup.argdep]], then `ranges::size(E)` is
+ expression-equivalent to that expression.
 - Otherwise, if `to-unsigned-like(ranges::end(t) - ranges::begin(t))`
   [[ranges.syn]] is a valid expression and the types `I` and `S` of
   `ranges::begin(t)` and `ranges::end(t)` (respectively) model both
   `sized_sentinel_for<S, I>` [[iterator.concept.sizedsentinel]] and
   `forward_iterator<I>`, then `ranges::size(E)` is expression-equivalent
 is integer-like. — *end note*]
 ### `ranges::ssize` <a id="range.prim.ssize">[[range.prim.ssize]]</a>
 The name `ranges::ssize` denotes a customization point object
+[[customization.point.object]].
+Given a subexpression `E` with type `T`, let `t` be an lvalue that
+denotes the reified object for `E`. If `ranges::size(t)` is ill-formed,
+`ranges::ssize(E)` is ill-formed. Otherwise let `D` be
+`make-signed-like-t<decltype(ranges::{}size(t))>`, or `ptrdiff_t` if it
+is wider than that type; `ranges::ssize(E)` is expression-equivalent to
+`static_cast<D>(ranges::size(t))`.
 ### `ranges::empty` <a id="range.prim.empty">[[range.prim.empty]]</a>
 The name `ranges::empty` denotes a customization point object
 [[customization.point.object]].
+Given a subexpression `E` with type `T`, let `t` be an lvalue that
+denotes the reified object for `E`. Then:
+- If `T` is an array of unknown bound [[term.array.type]],
   `ranges::empty(E)` is ill-formed.
 - Otherwise, if `bool(t.empty())` is a valid expression,
   `ranges::empty(E)` is expression-equivalent to `bool(t.empty())`.
 - Otherwise, if `(ranges::size(t) == 0)` is a valid expression,
   `ranges::empty(E)` is expression-equivalent to
 Given a subexpression `E` with type `T`, let `t` be an lvalue that
 denotes the reified object for `E`. Then:
 - If `E` is an rvalue and `enable_borrowed_range<remove_cv_t<T>>` is
   `false`, `ranges::data(E)` is ill-formed.
+- Otherwise, if `T` is an array type [[term.array.type]] and
   `remove_all_extents_t<T>` is an incomplete type, `ranges::data(E)` is
   ill-formed with no diagnostic required.
+- Otherwise, if `auto(t.data())` is a valid expression of pointer to
+  object type, `ranges::data(E)` is expression-equivalent to
+  `auto(t.data())`.
 - Otherwise, if `ranges::begin(t)` is a valid expression whose type
   models `contiguous_iterator`, `ranges::data(E)` is
+  expression-equivalent to `to_address(ranges::begin(t))`.
 - Otherwise, `ranges::data(E)` is ill-formed.
 [*Note 1*: Diagnosable ill-formed cases above result in substitution
 failure when `ranges::data(E)` appears in the immediate context of a
 template instantiation. — *end note*]
 [*Note 2*: Whenever `ranges::data(E)` is a valid expression, it has
 pointer to object type. — *end note*]
 ### `ranges::cdata` <a id="range.prim.cdata">[[range.prim.cdata]]</a>
+``` cpp
+template<class T>
+constexpr auto as-const-pointer(const T* p) { return p; }   // exposition only
+```
 The name `ranges::cdata` denotes a customization point object
+[[customization.point.object]]. Given a subexpression `E` with type `T`,
+let `t` be an lvalue that denotes the reified object for `E`. Then:
+- If `E` is an rvalue and `enable_borrowed_range<remove_cv_t<T>>` is
+  `false`, `ranges::cdata(E)` is ill-formed.
+- Otherwise, `ranges::cdata(E)` is expression-equivalent to
+  `as-const-pointer(ranges::data(possibly-const-range(t)))`.
 [*Note 1*: Whenever `ranges::cdata(E)` is a valid expression, it has
+pointer to constant object type. — *end note*]

Diff to HTML by rtfpessoa