[coro.generator] - C++20 → C++23

Files changed (1) hide show

tmp/tmpel_i1v3a/{from.md → to.md} +676 -0

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

	@@ -0,0 +1,676 @@

+## Range generators <a id="coro.generator">[[coro.generator]]</a>
+### Overview <a id="coroutine.generator.overview">[[coroutine.generator.overview]]</a>
+Class template `generator` presents a view of the elements yielded by
+the evaluation of a coroutine.
+A `generator` generates a sequence of elements by repeatedly resuming
+the coroutine from which it was returned. Elements of the sequence are
+produced by the coroutine each time a `co_yield` statement is evaluated.
+When the `co_yield` statement is of the form `co_yield elements_of(r)`,
+each element of the range `r` is successively produced as an element of
+the sequence.
+[*Example 1*:
+``` cpp
+generator<int> ints(int start = 0) {
+  while (true)
+    co_yield start++;
+}
+void f() {
+  for (auto i : ints() | views::take(3))
+    cout << i << ' ';       // prints 0 1 2
+}
+```
+— *end example*]
+### Header `<generator>` synopsis <a id="generator.syn">[[generator.syn]]</a>
+``` cpp
+namespace std {
+  // [coro.generator.class], class template generator
+  template<class Ref, class V = void, class Allocator = void>
+    class generator;
+  namespace pmr {
+    template<class R, class V = void>
+      using generator = std::generator<R, V, polymorphic_allocator<>>;
+  }
+}
+```
+### Class template `generator` <a id="coro.generator.class">[[coro.generator.class]]</a>
+``` cpp
+namespace std {
+  template<class Ref, class V = void, class Allocator = void>
+  class generator : public ranges::view_interface<generator<Ref, V, Allocator>> {
+  private:
+    using value = conditional_t<is_void_v<V>, remove_cvref_t<Ref>, V>;  // exposition only
+    using reference = conditional_t<is_void_v<V>, Ref&&, Ref>;          // exposition only
+    // [coro.generator.iterator], class generator::iterator
+    class iterator;                                                     // exposition only
+  public:
+    using yielded =
+      conditional_t<is_reference_v<reference>, reference, const reference&>;
+    // [coro.generator.promise], class generator::promise_type
+    class promise_type;
+    generator(const generator&) = delete;
+    generator(generator&& other) noexcept;
+    ~generator();
+    generator& operator=(generator other) noexcept;
+    iterator begin();
+    default_sentinel_t end() const noexcept;
+  private:
+    coroutine_handle<promise_type> coroutine_ = nullptr;  // exposition only
+    unique_ptr<stack<coroutine_handle<>>> active_;        // exposition only
+  };
+}
+```
+*Mandates:*
+- If `Allocator` is not `void`, `allocator_traits<Allocator>::pointer`
+  is a pointer type.
+- *`value`* is a cv-unqualified object type.
+- *`reference`* is either a reference type, or a cv-unqualified object
+  type that models `copy_constructible`.
+- Let `RRef` denote `remove_reference_t<reference>&&` if *`reference`*
+  is a reference type, and *`reference`* otherwise. Each of:
+  - `common_reference_with<reference&&, value&>`,
+  - `common_reference_with<reference&&, RRef&&>`, and
+  - `\texttt{common_reference_with}<RRef&&, const \exposid{value}&>`
+  is modeled.
+  \[*Note 1*: These requirements ensure the exposition-only *`iterator`*
+  type can model `indirectly_readable` and thus
+  `input_iterator`. — *end note*]
+If `Allocator` is not `void`, it shall meet the *Cpp17Allocator*
+requirements.
+Specializations of `generator` model `view` and `input_range`.
+The behavior of a program that adds a specialization for `generator` is
+undefined.
+### Members <a id="coro.generator.members">[[coro.generator.members]]</a>
+``` cpp
+generator(generator&& other) noexcept;
+```
+*Effects:* Initializes *coroutine\_* with
+`exchange(other.`*`coroutine_`*`, {})` and *active\_* with
+`exchange(other.active_, nullptr)`.
+[*Note 1*: Iterators previously obtained from `other` are not
+invalidated; they become iterators into `*this`. — *end note*]
+``` cpp
+~generator();
+```
+*Effects:* Equivalent to:
+``` cpp
+if (coroutine_) {
+  coroutine_.destroy();
+}
+```
+[*Note 2*: Ownership of recursively yielded generators is held in
+awaitable objects in the coroutine frame of the yielding generator, so
+destroying the root generator effectively destroys the entire stack of
+yielded generators. — *end note*]
+``` cpp
+generator& operator=(generator other) noexcept;
+```
+*Effects:* Equivalent to:
+``` cpp
+swap(coroutine_, other.coroutine_);
+swap(active_, other.active_);
+```
+*Returns:* `*this`.
+[*Note 3*: Iterators previously obtained from `other` are not
+invalidated; they become iterators into `*this`. — *end note*]
+``` cpp
+iterator begin();
+```
+*Preconditions:* *coroutine\_* refers to a coroutine suspended at its
+initial suspend point [[dcl.fct.def.coroutine]].
+*Effects:* Pushes *coroutine\_* into `*`*`active_`*, then evaluates
+*`coroutine_`*`.resume()`.
+*Returns:* An *iterator* object whose member *coroutine\_* refers to the
+same coroutine as does *coroutine\_*.
+[*Note 4*: A program that calls `begin` more than once on the same
+generator has undefined behavior. — *end note*]
+``` cpp
+default_sentinel_t end() const noexcept;
+```
+*Returns:* `default_sentinel`.
+### Class `generator::promise_type` <a id="coro.generator.promise">[[coro.generator.promise]]</a>
+``` cpp
+namespace std {
+  template<class Ref, class V, class Allocator>
+  class generator<Ref, V, Allocator>::promise_type {
+  public:
+    generator get_return_object() noexcept;
+    suspend_always initial_suspend() const noexcept { return {}; }
+    auto final_suspend() noexcept;
+    suspend_always yield_value(yielded val) noexcept;
+    auto yield_value(const remove_reference_t<yielded>& lval)
+      requires is_rvalue_reference_v<yielded> &&
+        constructible_from<remove_cvref_t<yielded>, const remove_reference_t<yielded>&>;
+    template<class R2, class V2, class Alloc2, class Unused>
+      requires same_as<typename generator<R2, V2, Alloc2>::yielded, yielded>
+        auto yield_value(ranges::elements_of<generator<R2, V2, Alloc2>&&, Unused> g) noexcept;
+    template<ranges::input_range R, class Alloc>
+      requires convertible_to<ranges::range_reference_t<R>, yielded>
+        auto yield_value(ranges::elements_of<R, Alloc> r) noexcept;
+    void await_transform() = delete;
+    void return_void() const noexcept {}
+    void unhandled_exception();
+    void* operator new(size_t size)
+      requires same_as<Allocator, void> || default_initializable<Allocator>;
+    template<class Alloc, class... Args>
+      requires same_as<Allocator, void> || convertible_to<const Alloc&, Allocator>
+        void* operator new(size_t size, allocator_arg_t, const Alloc& alloc, const Args&...);
+    template<class This, class Alloc, class... Args>
+      requires same_as<Allocator, void> || convertible_to<const Alloc&, Allocator>
+        void* operator new(size_t size, const This&, allocator_arg_t, const Alloc& alloc,
+                           const Args&...);
+    void operator delete(void* pointer, size_t size) noexcept;
+  private:
+    add_pointer_t<yielded> value_ = nullptr;    // exposition only
+    exception_ptr except_;                      // exposition only
+  };
+}
+```
+``` cpp
+generator get_return_object() noexcept;
+```
+*Returns:* A `generator` object whose member *coroutine\_* is
+`coroutine_handle<promise_type>::from_promise(*this)`, and whose member
+*active\_* points to an empty stack.
+``` cpp
+auto final_suspend() noexcept;
+```
+*Preconditions:* A handle referring to the coroutine whose promise
+object is `*this` is at the top of `*`*`active_`* of some `generator`
+object `x`. This function is called by that coroutine upon reaching its
+final suspend point [[dcl.fct.def.coroutine]].
+*Returns:* An awaitable object of unspecified type [[expr.await]] whose
+member functions arrange for the calling coroutine to be suspended, pop
+the coroutine handle from the top of `*x.`*`active_`*, and resume
+execution of the coroutine referred to by `x.`*`active_`*`->top()` if
+`*x.`*`active_`* is not empty. If it is empty, control flow returns to
+the current coroutine caller or resumer [[dcl.fct.def.coroutine]].
+``` cpp
+suspend_always yield_value(yielded val) noexcept;
+```
+*Effects:* Equivalent to *`value_`*` = addressof(val)`.
+*Returns:* `{}`.
+``` cpp
+auto yield_value(const remove_reference_t<yielded>& lval)
+  requires is_rvalue_reference_v<yielded> &&
+    constructible_from<remove_cvref_t<yielded>, const remove_reference_t<yielded>&>;
+```
+*Preconditions:* A handle referring to the coroutine whose promise
+object is `*this` is at the top of `*`*`active_`* of some `generator`
+object.
+*Returns:* An awaitable object of an unspecified type [[expr.await]]
+that stores an object of type `remove_cvref_t<yielded>`
+direct-non-list-initialized with `lval`, whose member functions arrange
+for *value\_* to point to that stored object and then suspend the
+coroutine.
+*Throws:* Any exception thrown by the initialization of the stored
+object.
+*Remarks:* A *yield-expression* that calls this function has type `void`
+[[expr.yield]].
+``` cpp
+template<class R2, class V2, class Alloc2, class Unused>
+  requires same_as<typename generator<R2, V2, Alloc2>::yielded, yielded>
+  auto yield_value(ranges::elements_of<generator<R2, V2, Alloc2>&&, Unused> g) noexcept;
+```
+*Preconditions:* A handle referring to the coroutine whose promise
+object is `*this` is at the top of `*`*`active_`* of some `generator`
+object `x`. The coroutine referred to by `g.range.`*`coroutine_`* is
+suspended at its initial suspend point.
+*Returns:* An awaitable object of an unspecified type [[expr.await]]
+into which `g.range` is moved, whose member `await_ready` returns
+`false`, whose member `await_suspend` pushes
+`g.range.`\textit{coroutine\_} into `*x.`*`active_`* and resumes
+execution of the coroutine referred to by `g.range.`*`coroutine_`*, and
+whose member `await_resume` evaluates `rethrow_exception(`*`except_`*`)`
+if `bool(`*`except_`*`)` is `true`. If `bool(`*`except_`*`)` is `false`,
+the `await_resume` member has no effects.
+*Remarks:* A *yield-expression* that calls this function has type `void`
+[[expr.yield]].
+``` cpp
+template<ranges::input_range R, class Alloc>
+  requires convertible_to<ranges::range_reference_t<R>, yielded>
+  auto yield_value(ranges::elements_of<R, Alloc> r) noexcept;
+```
+*Effects:* Equivalent to:
+``` cpp
+auto nested = [](allocator_arg_t, Alloc, ranges::iterator_t<R> i, ranges::sentinel_t<R> s)
+  -> generator<yielded, ranges::range_value_t<R>, Alloc> {
+    for (; i != s; ++i) {
+      co_yield static_cast<yielded>(*i);
+    }
+  };
+return yield_value(ranges::elements_of(nested(
+  allocator_arg, r.allocator, ranges::begin(r.range), ranges::end(r.range))));
+```
+[*Note 1*: A *yield-expression* that calls this function has type
+`void` [[expr.yield]]. — *end note*]
+``` cpp
+void unhandled_exception();
+```
+*Preconditions:* A handle referring to the coroutine whose promise
+object is `*this` is at the top of `*`*`active_`* of some `generator`
+object `x`.
+*Effects:* If the handle referring to the coroutine whose promise object
+is `*this` is the sole element of `*x.`*`active_`*, equivalent to
+`throw`, otherwise, assigns `current_exception()` to *except\_*.
+``` cpp
+void* operator new(size_t size)
+  requires same_as<Allocator, void> || default_initializable<Allocator>;
+template<class Alloc, class... Args>
+  requires same_as<Allocator, void> || convertible_to<const Alloc&, Allocator>
+  void* operator new(size_t size, allocator_arg_t, const Alloc& alloc, const Args&...);
+template<class This, class Alloc, class... Args>
+  requires same_as<Allocator, void> || convertible_to<const Alloc&, Allocator>
+  void* operator new(size_t size, const This&, allocator_arg_t, const Alloc& alloc,
+                     const Args&...);
+```
+Let `A` be
+- `Allocator`, if it is not `void`,
+- `Alloc` for the overloads with a template parameter `Alloc`, or
+- `allocator<void>` otherwise.
+Let `B` be `allocator_traits<A>::template rebind_alloc<U>` where `U` is
+an unspecified type whose size and alignment are both
+\_\_STDCPP_DEFAULT_NEW_ALIGNMENT\_\_.
+*Mandates:* `allocator_traits<B>::pointer` is a pointer type.
+*Effects:* Initializes an allocator `b` of type `B` with `A(alloc)`, for
+the overloads with a function parameter `alloc`, and with `A()`
+otherwise. Uses `b` to allocate storage for the smallest array of `U`
+sufficient to provide storage for a coroutine state of size `size`, and
+unspecified additional state necessary to ensure that `operator delete`
+can later deallocate this memory block with an allocator equal to `b`.
+*Returns:* A pointer to the allocated storage.
+``` cpp
+void operator delete(void* pointer, size_t size) noexcept;
+```
+*Preconditions:* `pointer` was returned from an invocation of one of the
+above overloads of `operator new` with a `size` argument equal to
+`size`.
+*Effects:* Deallocates the storage pointed to by `pointer` using an
+allocator equivalent to that used to allocate it.
+### Class `generator::iterator` <a id="coro.generator.iterator">[[coro.generator.iterator]]</a>
+``` cpp
+namespace std {
+  template<class Ref, class V, class Allocator>
+  class generator<Ref, V, Allocator>::iterator {
+  public:
+    using value_type = value;
+    using difference_type = ptrdiff_t;
+    iterator(iterator&& other) noexcept;
+    iterator& operator=(iterator&& other) noexcept;
+    reference operator*() const noexcept(is_nothrow_copy_constructible_v<reference>);
+    iterator& operator++();
+    void operator++(int);
+    friend bool operator==(const iterator& i, default_sentinel_t);
+  private:
+    coroutine_handle<promise_type> coroutine_; // exposition only
+  };
+}
+```
+``` cpp
+iterator(iterator&& other) noexcept;
+```
+*Effects:* Initializes *coroutine\_* with
+`exchange(other.`*`coroutine_`*`, {})`.
+``` cpp
+iterator& operator=(iterator&& other) noexcept;
+```
+*Effects:* Equivalent to
+*`coroutine_`*` = exchange(other.`*`coroutine_`*`, {})`.
+*Returns:* `*this`.
+``` cpp
+reference operator*() const noexcept(is_nothrow_copy_constructible_v<reference>);
+```
+*Preconditions:* For some `generator` object `x`, *coroutine\_* is in
+`*x.`*`active_`* and `x.`*`active_`*`->top()` refers to a suspended
+coroutine with promise object `p`.
+*Effects:* Equivalent to:
+`return static_cast<`*`reference`*`>(*p.`*`value_`*`);`
+``` cpp
+iterator& operator++();
+```
+*Preconditions:* For some `generator` object `x`, *coroutine\_* is in
+`*x.`*`active_`*.
+*Effects:* Equivalent to `x.`*`active_`*`->top().resume()`.
+*Returns:* `*this`.
+``` cpp
+void operator++(int);
+```
+*Effects:* Equivalent to `++*this`.
+``` cpp
+friend bool operator==(const iterator& i, default_sentinel_t);
+```
+*Effects:* Equivalent to: `return i.`*`coroutine_`*`.done();`
+<!-- Link reference definitions -->
+[basic.lookup.argdep]: basic.md#basic.lookup.argdep
+[concepts.equality]: concepts.md#concepts.equality
+[containers]: containers.md#containers
+[conv.rval]: expr.md#conv.rval
+[coro.generator]: #coro.generator
+[coro.generator.class]: #coro.generator.class
+[coro.generator.iterator]: #coro.generator.iterator
+[coro.generator.members]: #coro.generator.members
+[coro.generator.promise]: #coro.generator.promise
+[coroutine.generator.overview]: #coroutine.generator.overview
+[customization.point.object]: library.md#customization.point.object
+[dcl.fct.def.coroutine]: dcl.md#dcl.fct.def.coroutine
+[dcl.init.general]: dcl.md#dcl.init.general
+[expr.await]: expr.md#expr.await
+[expr.const]: expr.md#expr.const
+[expr.yield]: expr.md#expr.yield
+[generator.syn]: #generator.syn
+[iterator.concept.bidir]: iterators.md#iterator.concept.bidir
+[iterator.concept.forward]: iterators.md#iterator.concept.forward
+[iterator.concept.iterator]: iterators.md#iterator.concept.iterator
+[iterator.concept.output]: iterators.md#iterator.concept.output
+[iterator.concept.random.access]: iterators.md#iterator.concept.random.access
+[iterator.concept.sizedsentinel]: iterators.md#iterator.concept.sizedsentinel
+[iterator.concept.winc]: iterators.md#iterator.concept.winc
+[iterator.requirements.general]: iterators.md#iterator.requirements.general
+[namespace.std]: library.md#namespace.std
+[range.access]: #range.access
+[range.access.begin]: #range.access.begin
+[range.access.cbegin]: #range.access.cbegin
+[range.access.cend]: #range.access.cend
+[range.access.crbegin]: #range.access.crbegin
+[range.access.crend]: #range.access.crend
+[range.access.end]: #range.access.end
+[range.access.general]: #range.access.general
+[range.access.rbegin]: #range.access.rbegin
+[range.access.rend]: #range.access.rend
+[range.adaptor.helpers]: #range.adaptor.helpers
+[range.adaptor.object]: #range.adaptor.object
+[range.adaptors]: #range.adaptors
+[range.adaptors.general]: #range.adaptors.general
+[range.adjacent]: #range.adjacent
+[range.adjacent.iterator]: #range.adjacent.iterator
+[range.adjacent.overview]: #range.adjacent.overview
+[range.adjacent.sentinel]: #range.adjacent.sentinel
+[range.adjacent.transform]: #range.adjacent.transform
+[range.adjacent.transform.iterator]: #range.adjacent.transform.iterator
+[range.adjacent.transform.overview]: #range.adjacent.transform.overview
+[range.adjacent.transform.sentinel]: #range.adjacent.transform.sentinel
+[range.adjacent.transform.view]: #range.adjacent.transform.view
+[range.adjacent.view]: #range.adjacent.view
+[range.all]: #range.all
+[range.all.general]: #range.all.general
+[range.as.const]: #range.as.const
+[range.as.const.overview]: #range.as.const.overview
+[range.as.const.view]: #range.as.const.view
+[range.as.rvalue]: #range.as.rvalue
+[range.as.rvalue.overview]: #range.as.rvalue.overview
+[range.as.rvalue.view]: #range.as.rvalue.view
+[range.cartesian]: #range.cartesian
+[range.cartesian.iterator]: #range.cartesian.iterator
+[range.cartesian.overview]: #range.cartesian.overview
+[range.cartesian.view]: #range.cartesian.view
+[range.chunk]: #range.chunk
+[range.chunk.by]: #range.chunk.by
+[range.chunk.by.iter]: #range.chunk.by.iter
+[range.chunk.by.overview]: #range.chunk.by.overview
+[range.chunk.by.view]: #range.chunk.by.view
+[range.chunk.fwd.iter]: #range.chunk.fwd.iter
+[range.chunk.inner.iter]: #range.chunk.inner.iter
+[range.chunk.outer.iter]: #range.chunk.outer.iter
+[range.chunk.outer.value]: #range.chunk.outer.value
+[range.chunk.overview]: #range.chunk.overview
+[range.chunk.view.fwd]: #range.chunk.view.fwd
+[range.chunk.view.input]: #range.chunk.view.input
+[range.common]: #range.common
+[range.common.overview]: #range.common.overview
+[range.common.view]: #range.common.view
+[range.counted]: #range.counted
+[range.dangling]: #range.dangling
+[range.drop]: #range.drop
+[range.drop.overview]: #range.drop.overview
+[range.drop.view]: #range.drop.view
+[range.drop.while]: #range.drop.while
+[range.drop.while.overview]: #range.drop.while.overview
+[range.drop.while.view]: #range.drop.while.view
+[range.elements]: #range.elements
+[range.elements.iterator]: #range.elements.iterator
+[range.elements.overview]: #range.elements.overview
+[range.elements.sentinel]: #range.elements.sentinel
+[range.elements.view]: #range.elements.view
+[range.elementsof]: #range.elementsof
+[range.empty]: #range.empty
+[range.empty.overview]: #range.empty.overview
+[range.empty.view]: #range.empty.view
+[range.enumerate]: #range.enumerate
+[range.enumerate.iterator]: #range.enumerate.iterator
+[range.enumerate.overview]: #range.enumerate.overview
+[range.enumerate.sentinel]: #range.enumerate.sentinel
+[range.enumerate.view]: #range.enumerate.view
+[range.factories]: #range.factories
+[range.factories.general]: #range.factories.general
+[range.filter]: #range.filter
+[range.filter.iterator]: #range.filter.iterator
+[range.filter.overview]: #range.filter.overview
+[range.filter.sentinel]: #range.filter.sentinel
+[range.filter.view]: #range.filter.view
+[range.iota]: #range.iota
+[range.iota.iterator]: #range.iota.iterator
+[range.iota.overview]: #range.iota.overview
+[range.iota.sentinel]: #range.iota.sentinel
+[range.iota.view]: #range.iota.view
+[range.istream]: #range.istream
+[range.istream.iterator]: #range.istream.iterator
+[range.istream.overview]: #range.istream.overview
+[range.istream.view]: #range.istream.view
+[range.join]: #range.join
+[range.join.iterator]: #range.join.iterator
+[range.join.overview]: #range.join.overview
+[range.join.sentinel]: #range.join.sentinel
+[range.join.view]: #range.join.view
+[range.join.with]: #range.join.with
+[range.join.with.iterator]: #range.join.with.iterator
+[range.join.with.overview]: #range.join.with.overview
+[range.join.with.sentinel]: #range.join.with.sentinel
+[range.join.with.view]: #range.join.with.view
+[range.lazy.split]: #range.lazy.split
+[range.lazy.split.inner]: #range.lazy.split.inner
+[range.lazy.split.outer]: #range.lazy.split.outer
+[range.lazy.split.outer.value]: #range.lazy.split.outer.value
+[range.lazy.split.overview]: #range.lazy.split.overview
+[range.lazy.split.view]: #range.lazy.split.view
+[range.move.wrap]: #range.move.wrap
+[range.nonprop.cache]: #range.nonprop.cache
+[range.owning.view]: #range.owning.view
+[range.prim.cdata]: #range.prim.cdata
+[range.prim.data]: #range.prim.data
+[range.prim.empty]: #range.prim.empty
+[range.prim.size]: #range.prim.size
+[range.prim.ssize]: #range.prim.ssize
+[range.range]: #range.range
+[range.ref.view]: #range.ref.view
+[range.refinements]: #range.refinements
+[range.repeat]: #range.repeat
+[range.repeat.iterator]: #range.repeat.iterator
+[range.repeat.overview]: #range.repeat.overview
+[range.repeat.view]: #range.repeat.view
+[range.req]: #range.req
+[range.req.general]: #range.req.general
+[range.reverse]: #range.reverse
+[range.reverse.overview]: #range.reverse.overview
+[range.reverse.view]: #range.reverse.view
+[range.single]: #range.single
+[range.single.overview]: #range.single.overview
+[range.single.view]: #range.single.view
+[range.sized]: #range.sized
+[range.slide]: #range.slide
+[range.slide.iterator]: #range.slide.iterator
+[range.slide.overview]: #range.slide.overview
+[range.slide.sentinel]: #range.slide.sentinel
+[range.slide.view]: #range.slide.view
+[range.split]: #range.split
+[range.split.iterator]: #range.split.iterator
+[range.split.overview]: #range.split.overview
+[range.split.sentinel]: #range.split.sentinel
+[range.split.view]: #range.split.view
+[range.stride]: #range.stride
+[range.stride.iterator]: #range.stride.iterator
+[range.stride.overview]: #range.stride.overview
+[range.stride.view]: #range.stride.view
+[range.subrange]: #range.subrange
+[range.subrange.access]: #range.subrange.access
+[range.subrange.ctor]: #range.subrange.ctor
+[range.subrange.general]: #range.subrange.general
+[range.summary]: #range.summary
+[range.take]: #range.take
+[range.take.overview]: #range.take.overview
+[range.take.sentinel]: #range.take.sentinel
+[range.take.view]: #range.take.view
+[range.take.while]: #range.take.while
+[range.take.while.overview]: #range.take.while.overview
+[range.take.while.sentinel]: #range.take.while.sentinel
+[range.take.while.view]: #range.take.while.view
+[range.transform]: #range.transform
+[range.transform.iterator]: #range.transform.iterator
+[range.transform.overview]: #range.transform.overview
+[range.transform.sentinel]: #range.transform.sentinel
+[range.transform.view]: #range.transform.view
+[range.utility]: #range.utility
+[range.utility.conv]: #range.utility.conv
+[range.utility.conv.adaptors]: #range.utility.conv.adaptors
+[range.utility.conv.general]: #range.utility.conv.general
+[range.utility.conv.to]: #range.utility.conv.to
+[range.utility.general]: #range.utility.general
+[range.utility.helpers]: #range.utility.helpers
+[range.view]: #range.view
+[range.zip]: #range.zip
+[range.zip.iterator]: #range.zip.iterator
+[range.zip.overview]: #range.zip.overview
+[range.zip.sentinel]: #range.zip.sentinel
+[range.zip.transform]: #range.zip.transform
+[range.zip.transform.iterator]: #range.zip.transform.iterator
+[range.zip.transform.overview]: #range.zip.transform.overview
+[range.zip.transform.sentinel]: #range.zip.transform.sentinel
+[range.zip.transform.view]: #range.zip.transform.view
+[range.zip.view]: #range.zip.view
+[ranges]: #ranges
+[ranges.general]: #ranges.general
+[ranges.syn]: #ranges.syn
+[string.view]: strings.md#string.view
+[term.array.type]: dcl.md#term.array.type
+[term.perfect.forwarding.call.wrapper]: utilities.md#term.perfect.forwarding.call.wrapper
+[view.interface]: #view.interface
+[view.interface.general]: #view.interface.general
+[view.interface.members]: #view.interface.members
+[views.span]: containers.md#views.span

Diff to HTML by rtfpessoa