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

Files changed (1) hide show

tmp/tmpgcsmfwjj/{from.md → to.md} +71 -37

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

@@ -1,10 +1,10 @@
 ## Range requirements <a id="range.req">[[range.req]]</a>
 ### General <a id="range.req.general">[[range.req.general]]</a>
-Ranges are an abstraction that allow a C++ program to operate on
 elements of data structures uniformly. Calling `ranges::begin` on a
 range returns an object whose type models `input_or_output_iterator`
 [[iterator.concept.iterator]]. Calling `ranges::end` on a range returns
 an object whose type `S`, together with the type `I` of the object
 returned by `ranges::begin`, models `sentinel_for<S, I>`. The library
@@ -14,11 +14,11 @@ of sequences.
 The `range` concept requires that `ranges::begin` and `ranges::end`
 return an iterator and a sentinel, respectively. The `sized_range`
 concept refines `range` with the requirement that `ranges::size` be
 amortized 𝑂(1). The `view` concept specifies requirements on a `range`
-type with constant-time destruction and move operations.
 Several refinements of `range` group requirements that arise frequently
 in concepts and algorithms. Common ranges are ranges for which
 `ranges::begin` and `ranges::end` return objects of the same type.
 Random access ranges are ranges for which `ranges::begin` returns a type
@@ -54,37 +54,37 @@ Given an expression `t` such that `decltype((t))` is `T&`, `T` models
   time and non-modifying, and
 - if the type of `ranges::begin(t)` models `forward_iterator`,
   `ranges::begin(t)` is equality-preserving.
 [*Note 1*: Equality preservation of both `ranges::begin` and
-`ranges::end` enables passing a `range` whose iterator type models
 `forward_iterator` to multiple algorithms and making multiple passes
 over the range by repeated calls to `ranges::begin` and `ranges::end`.
 Since `ranges::begin` is not required to be equality-preserving when the
-return type does not model `forward_iterator`, repeated calls might not
-return equal values or might not be well-defined; `ranges::begin` should
-be called at most once for such a range. — *end note*]
 ``` cpp
 template<class T>
   concept borrowed_range =
-    range<T> &&
-      (is_lvalue_reference_v<T> || enable_borrowed_range<remove_cvref_t<T>>);
 ```
-Given an expression `E` such that `decltype((E))` is `T`, `T` models
-`borrowed_range` only if the validity of iterators obtained from the
-object denoted by `E` is not tied to the lifetime of that object.
 [*Note 2*: Since the validity of iterators is not tied to the lifetime
-of an object whose type models `borrowed_range`, a function can accept
-arguments of such a type by value and return iterators obtained from it
-without danger of dangling. — *end note*]
 ``` cpp
 template<class>
- inline constexpr bool enable_borrowed_range = false;
 ```
 *Remarks:* Pursuant to [[namespace.std]], users may specialize
 `enable_borrowed_range` for cv-unqualified program-defined types. Such
 specializations shall be usable in constant expressions [[expr.const]]
@@ -109,30 +109,29 @@ number of elements in the range can be determined in amortized constant
 time using `ranges::size`.
 ``` cpp
 template<class T>
   concept sized_range =
-    range<T> &&
-    requires(T& t) { ranges::size(t); };
 ```
 Given an lvalue `t` of type `remove_reference_t<T>`, `T` models
 `sized_range` only if
 - `ranges::size(t)` is amortized 𝑂(1), does not modify `t`, and is equal
-  to `ranges::distance(t)`, and
 - if `iterator_t<T>` models `forward_iterator`, `ranges::size(t)` is
   well-defined regardless of the evaluation of `ranges::begin(t)`.
   \[*Note 1*: `ranges::size(t)` is otherwise not required to be
-  well-defined after evaluating `ranges::begin(t)`. For example,
-  `ranges::size(t)` might be well-defined for a `sized_range` whose
-  iterator type does not model `forward_iterator` only if evaluated
-  before the first call to `ranges::begin(t)`. — *end note*]
 ``` cpp
 template<class>
- inline constexpr bool disable_sized_range = false;
 ```
 *Remarks:* Pursuant to [[namespace.std]], users may specialize
 `disable_sized_range` for cv-unqualified program-defined types. Such
 specializations shall be usable in constant expressions [[expr.const]]
@@ -143,51 +142,66 @@ library that satisfy but do not in fact model
 `sized_range`. — *end note*]
 ### Views <a id="range.view">[[range.view]]</a>
 The `view` concept specifies the requirements of a `range` type that has
-constant time move construction, move assignment, and destruction; that
-is, the cost of these operations is independent of the number of
-elements in the `view`.
 ``` cpp
 template<class T>
   concept view =
-    range<T> && movable<T> && default_initializable<T> && enable_view<T>;
 ```
 `T` models `view` only if:
 - `T` has 𝑂(1) move construction; and
-- `T` has 𝑂(1) move assignment; and
-- `T` has 𝑂(1) destruction; and
 - `copy_constructible<T>` is `false`, or `T` has 𝑂(1) copy construction;
   and
-- `copyable<T>` is `false`, or `T` has 𝑂(1) copy assignment.
 [*Example 1*:
-Examples of `view`s are:
 - A `range` type that wraps a pair of iterators.
 - A `range` type that holds its elements by `shared_ptr` and shares
   ownership with all its copies.
 - A `range` type that generates its elements on demand.
-Most containers [[containers]] are not views since destruction of the
-container destroys the elements, which cannot be done in constant time.
 — *end example*]
 Since the difference between `range` and `view` is largely semantic, the
 two are differentiated with the help of `enable_view`.
 ``` cpp
 template<class T>
- inline constexpr bool enable_view = derived_from<T, view_base>;
 ```
 *Remarks:* Pursuant to [[namespace.std]], users may specialize
 `enable_view` to `true` for cv-unqualified program-defined types which
 model `view`, and `false` for types which do not. Such specializations
 shall be usable in constant expressions [[expr.const]] and have type
 `const bool`.
@@ -220,11 +234,11 @@ template<class T>
   concept random_access_range =
     bidirectional_range<T> && random_access_iterator<iterator_t<T>>;
 ```
 `contiguous_range` additionally requires that the `ranges::data`
-customization point [[range.prim.data]] is usable with the range.
 ``` cpp
 template<class T>
   concept contiguous_range =
     random_access_range<T> && contiguous_iterator<iterator_t<T>> &&
@@ -247,14 +261,34 @@ which `ranges::begin` and `ranges::end` return objects of the same type.
 template<class T>
   concept common_range =
     range<T> && same_as<iterator_t<T>, sentinel_t<T>>;
 ```
 The `viewable_range` concept specifies the requirements of a `range`
-type that can be converted to a `view` safely.
 ``` cpp
 template<class T>
   concept viewable_range =
-    range<T> && (borrowed_range<T> || view<remove_cvref_t<T>>);
 ```

 ## Range requirements <a id="range.req">[[range.req]]</a>
 ### General <a id="range.req.general">[[range.req.general]]</a>
+Ranges are an abstraction that allows a C++ program to operate on
 elements of data structures uniformly. Calling `ranges::begin` on a
 range returns an object whose type models `input_or_output_iterator`
 [[iterator.concept.iterator]]. Calling `ranges::end` on a range returns
 an object whose type `S`, together with the type `I` of the object
 returned by `ranges::begin`, models `sentinel_for<S, I>`. The library
 The `range` concept requires that `ranges::begin` and `ranges::end`
 return an iterator and a sentinel, respectively. The `sized_range`
 concept refines `range` with the requirement that `ranges::size` be
 amortized 𝑂(1). The `view` concept specifies requirements on a `range`
+type to provide operations with predictable complexity.
 Several refinements of `range` group requirements that arise frequently
 in concepts and algorithms. Common ranges are ranges for which
 `ranges::begin` and `ranges::end` return objects of the same type.
 Random access ranges are ranges for which `ranges::begin` returns a type
   time and non-modifying, and
 - if the type of `ranges::begin(t)` models `forward_iterator`,
   `ranges::begin(t)` is equality-preserving.
 [*Note 1*: Equality preservation of both `ranges::begin` and
+`ranges::end` enables passing a range whose iterator type models
 `forward_iterator` to multiple algorithms and making multiple passes
 over the range by repeated calls to `ranges::begin` and `ranges::end`.
 Since `ranges::begin` is not required to be equality-preserving when the
+return type does not model `forward_iterator`, it is possible for
+repeated calls to not return equal values or to not be
+well-defined. — *end note*]
 ``` cpp
 template<class T>
   concept borrowed_range =
+    range<T> && (is_lvalue_reference_v<T> || enable_borrowed_range<remove_cvref_t<T>>);
 ```
+Let `U` be `remove_reference_t<T>` if `T` is an rvalue reference type,
+and `T` otherwise. Given a variable `u` of type `U`, `T` models
+`borrowed_range` only if the validity of iterators obtained from `u` is
+not tied to the lifetime of that variable.
 [*Note 2*: Since the validity of iterators is not tied to the lifetime
+of a variable whose type models `borrowed_range`, a function with a
+parameter of such a type can return iterators obtained from it without
+danger of dangling. — *end note*]
 ``` cpp
 template<class>
+  constexpr bool enable_borrowed_range = false;
 ```
 *Remarks:* Pursuant to [[namespace.std]], users may specialize
 `enable_borrowed_range` for cv-unqualified program-defined types. Such
 specializations shall be usable in constant expressions [[expr.const]]
 time using `ranges::size`.
 ``` cpp
 template<class T>
   concept sized_range =
+    range<T> && requires(T& t) { ranges::size(t); };
 ```
 Given an lvalue `t` of type `remove_reference_t<T>`, `T` models
 `sized_range` only if
 - `ranges::size(t)` is amortized 𝑂(1), does not modify `t`, and is equal
+  to `ranges::distance(ranges::begin(t), ranges::end(t))`, and
 - if `iterator_t<T>` models `forward_iterator`, `ranges::size(t)` is
   well-defined regardless of the evaluation of `ranges::begin(t)`.
   \[*Note 1*: `ranges::size(t)` is otherwise not required to be
+  well-defined after evaluating `ranges::begin(t)`. For example, it is
+ possible for `ranges::size(t)` to be well-defined for a `sized_range`
+ whose iterator type does not model `forward_iterator` only if
+ evaluated before the first call to `ranges::begin(t)`. — *end note*]
 ``` cpp
 template<class>
+  constexpr bool disable_sized_range = false;
 ```
 *Remarks:* Pursuant to [[namespace.std]], users may specialize
 `disable_sized_range` for cv-unqualified program-defined types. Such
 specializations shall be usable in constant expressions [[expr.const]]
 `sized_range`. — *end note*]
 ### Views <a id="range.view">[[range.view]]</a>
 The `view` concept specifies the requirements of a `range` type that has
+the semantic properties below, which make it suitable for use in
+constructing range adaptor pipelines [[range.adaptors]].
 ``` cpp
 template<class T>
   concept view =
+    range<T> && movable<T> && enable_view<T>;
 ```
 `T` models `view` only if:
 - `T` has 𝑂(1) move construction; and
+- move assignment of an object of type `T` is no more complex than
+  destruction followed by move construction; and
+- if N copies and/or moves are made from an object of type `T` that
+  contained M elements, then those N objects have 𝑂(N+M) destruction;
+  and
 - `copy_constructible<T>` is `false`, or `T` has 𝑂(1) copy construction;
   and
+- `copyable<T>` is `false`, or copy assignment of an object of type `T`
+  is no more complex than destruction followed by copy construction.
+[*Note 1*: The constraints on copying and moving imply that a
+moved-from object of type `T` has 𝑂(1) destruction. — *end note*]
 [*Example 1*:
+Examples of views are:
 - A `range` type that wraps a pair of iterators.
 - A `range` type that holds its elements by `shared_ptr` and shares
   ownership with all its copies.
 - A `range` type that generates its elements on demand.
+A container such as `vector<string>` does not meet the semantic
+requirements of `view` since copying the container copies all of the
+elements, which cannot be done in constant time.
 — *end example*]
 Since the difference between `range` and `view` is largely semantic, the
 two are differentiated with the help of `enable_view`.
 ``` cpp
 template<class T>
+  constexpr bool is-derived-from-view-interface = see belownc;            // exposition only
+template<class T>
+  constexpr bool enable_view =
+    derived_from<T, view_base> || is-derived-from-view-interface<T>;
 ```
+For a type `T`, *`is-derived-from-view-interface`*`<T>` is `true` if and
+only if `T` has exactly one public base class `view_interface<U>` for
+some type `U` and `T` has no base classes of type `view_interface<V>`
+for any other type `V`.
 *Remarks:* Pursuant to [[namespace.std]], users may specialize
 `enable_view` to `true` for cv-unqualified program-defined types which
 model `view`, and `false` for types which do not. Such specializations
 shall be usable in constant expressions [[expr.const]] and have type
 `const bool`.
   concept random_access_range =
     bidirectional_range<T> && random_access_iterator<iterator_t<T>>;
 ```
 `contiguous_range` additionally requires that the `ranges::data`
+customization point object [[range.prim.data]] is usable with the range.
 ``` cpp
 template<class T>
   concept contiguous_range =
     random_access_range<T> && contiguous_iterator<iterator_t<T>> &&
 template<class T>
   concept common_range =
     range<T> && same_as<iterator_t<T>, sentinel_t<T>>;
 ```
+``` cpp
+template<class R>
+  constexpr bool is-initializer-list = see below;               // exposition only
+```
+For a type `R`, *`is-initializer-list`*`<R>` is `true` if and only if
+`remove_cvref_t<R>` is a specialization of `initializer_list`.
 The `viewable_range` concept specifies the requirements of a `range`
+type that can be converted to a view safely.
 ``` cpp
 template<class T>
   concept viewable_range =
+    range<T> &&
+    ((view<remove_cvref_t<T>> && constructible_from<remove_cvref_t<T>, T>) ||
+     (!view<remove_cvref_t<T>> &&
+      (is_lvalue_reference_v<T> || (movable<remove_reference_t<T>> && !is-initializer-list<T>))));
+```
+The `constant_range` concept specifies the requirements of a `range`
+type whose elements are not modifiable.
+``` cpp
+template<class T>
+  concept constant_range =
+    input_range<T> && constant-iterator<iterator_t<T>>;
 ```

Diff to HTML by rtfpessoa