<html>

<head>
  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  <title>
    Remove redundant <code>reserve_hint</code> members from view classes
  </title>
  <style type="text/css">
    body {
      font-variant-ligatures: none;
    }

    p {
      text-align: justify
    }

    li {
      text-align: justify
    }

    blockquote.note,
    div.note {
      background-color: #E0E0E0;
      padding-left: 15px;
      padding-right: 15px;
      padding-top: 1px;
      padding-bottom: 1px;
    }

    p code {
      color: navy
    }

    ins p code {
      color: #00A000
    }

    p ins code {
      color: #00A000
    }

    p del code {
      color: #A00000
    }

    ins {
      color: #00A000
    }

    del {
      color: #A00000
    }

    table#boilerplate {
      border: 0
    }

    table#boilerplate td {
      padding-left: 2em
    }

    table.bordered,
    table.bordered th,
    table.bordered td {
      border: 1px solid;
      text-align: center;
    }

    ins.block {
      color: #00A000;
      text-decoration: none
    }

    del.block {
      color: #A00000;
      text-decoration: none
    }

    #hidedel:checked~* del,
    #hidedel:checked~* del * {
      display: none;
      visibility: hidden
    }
  </style>
</head>

<body data-new-gr-c-s-check-loaded="14.1043.0" data-gr-ext-installed="">
  <table id="boilerplate">
    <tbody>
      <tr>
        <td>Document number</td>
        <td>P3763R0</td>
      </tr>
      <tr>
        <td>Date</td>
        <td>2025-06-21</td>
      </tr>
      <tr>
        <td>Audience</td>
        <td>LEWG, SG9 (Ranges)</td>
      </tr>
      <tr>
        <td>Reply-to</td>
        <td>Hewill Kang &lt;hewillk@gmail.com&gt;</td>
      </tr>
    </tbody>
  </table>
  <hr>
  <h1>Remove redundant <code>reserve_hint</code> members from view classes</h1>
  <ul>
    <li>
      <ul>
        <li>Abstract</li>
        <li>Revision history</li>
        <li>Discussion</li>
        <li>Proposed change</li>
        <li>References</li>
      </ul>
    </li>
  </ul>
  <a name="Abstract"></a>
  <h2>Abstract</h2>
  <p>
    This paper removes the <code>reserve_hint</code> members of view classes when their <code>size</code> members
    are already provided.
  </p>
  <a name="Revision history"></a>
  <h2>Revision history</h2>
  <p>
  <h3>R0</h3>
  <p>Initial revision.</p>
  </p>
  </ol>
  </p>
  <a name="Discussion"></a>
  <h2>Discussion</h2>
  <p>
    After <a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2846r6.pdf">P2846</a>,
    <code>sized_range</code> always implies
    <code>approximately_sized_range</code> by its definition (<a
      href="https://eel.is/c++draft/range.sized">[range.sized]</a>):
  <pre>
  template&lt;class T&gt;
    concept sized_range =
      approximately_sized_range&lt;T&gt; && requires(T& t) { ranges::size(t); };
</pre>
  And <code>size</code> and <code>reserve_hint</code> members of the view class are currently with the
  following
  constraint:
  <pre>
  template&lt;range R&gt;
  struct <i>some</i>_view : public view_interface&lt;<i>some</i>_view&lt;R&gt;&gt; {
    [&hellip;]
    constexpr auto size()               requires sized_range&lt;R&gt;
    constexpr auto size() const         requires sized_range&lt;const R&gt;
    constexpr auto reserve_hint()       requires approximately_sized_range&lt;R&gt;
    constexpr auto reserve_hint() const requires approximately_sized_range&lt;const R&gt;
    [&hellip;]
  };
</pre>
  This turns outs that all view classes with a valid <code>size</code> member
  also have a
  <code>reserve_hint</code> member.
  </p>
  <p>
    However, those <code>reserve_hint</code> in such cases is actually redundant because
    <code>ranges::reserve_hint</code> always
    prefers the <code>size</code> member when available (<a
      href="https://eel.is/c++draft/range.prim.size.hint">[range.prim.size.hint]</a>):
  </p>
  <blockquote>
    <p>
      -2- Given a subexpression <code>E</code> with type <code>T</code>, let t be an lvalue that denotes the reified
      object for <code>E</code>. Then:
    <ol style="list-style-type: none">
      <li>
        <p>(2.1) &mdash;
          If <code>ranges::size(E)</code> is a valid expression, <code>ranges::reserve_hint(E)</code> is
          expression-equivalent to <code>ranges::size(E)</code>.
        </p>
      </li>
      <li>
        <p>(2.2) &mdash;
          Otherwise, if <code>auto(t.reserve_hint())</code> is a valid expression of integer-like type
          ([iterator.concept.winc]),
          <code>ranges::reserve_hint(E)</code> is expression-equivalent to <code>auto(t.reserve_hint())</code>.
        </p></q>
      </li>
      <li>
        <p>[&hellip;] </p>
      </li>
    </ol></blockquote>
    <p>
      When an exact size is available, providing an additional, less precise <code>reserve_hint</code> serves no
      practical
      purpose.
      There is no use case in the standard that requires these redundant
      <code>reserve_hint</code> members. Both <code>ranges::to</code> and standard containers reserve capacity by
      calling <code>ranges::reserve_hint</code>, which already retrieves the best available size estimate.
    </p>
    <p>
      Additionally, the motivating case in <a
        href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2846r6.pdf">P2846</a>
      (<code>uppercase_view</code>) provides only a <code>reserve_hint</code> member, as it cannot offer an exact size:
    </p>
    <pre>
    template&lt;input_range V&gt;
      class uppercase_view {
      constexpr const V & base() const;
      constexpr auto begin() const;
      constexpr auto end() const;
      constexpr auto reserve_hint() requires approximately_sized_range&lt;V&gt; {
        return ranges::reserve_hint(base());
      }
      constexpr auto reserve_hint() const requires approximately_sized_range&lt;const V&gt; {
        return ranges::reserve_hint(base());
      }
    };</pre>
    <p>This indicates that <code>reserve_hint</code> should only be used to resolve situations where
      <code>size</code>
      cannot be provided, as
      it is only reasonable to provide <code>reserve_hint</code> if <code>approximate_sized_range</code> is modeled
      and <code>sized_range</code> is not; otherwise these <code>reserve_hint</code> would lead to  unnecessary instantiation
      overhead. We should not pay for what we do not need.
    </p>
    <a name="Proposed-change"></a>
    <h2>Proposed change</h2>
    <p>This wording is relative to the <a href="https://eel.is/c++draft">latest working draft</a>.
      It replaces <code>approximately_sized_range</code> with the newly introduced exposition-only concept
      <code><i>only-approximately-sized</i></code> in all relevant view classes,
      to remove <code>reserve_hint</code> members from views that already provide a <code>size</code> member.
    </p>
    </div>
    <div>
      <ol>
        <li>
          <p>Modify 25.7.5 <a href="https://eel.is/c++draft/range.adaptor.helpers">[range.adaptor.helpers]</a>, as
            indicated:</p>

          <blockquote>
            <pre>
namespace std::ranges {
  [&hellip;]
  template&lt;bool Const, class... Views&gt;
    concept <i>all-forward</i> =                           // <i>exposition only</i>
      (forward_range&lt;<i>maybe-const</i>&lt;Const, Views&gt;&gt; && ...);

  <ins>template&lt;class R&gt;
    concept <i>only-approximately-sized</i> =              // <i>exposition only</i>
      !sized_range&lt;R&gt; && approximately_sized_range&lt;R&gt;; </ins>
}
        </pre>
          </blockquote>
        </li>
        <li>
          <p>Modify 25.7.6.2 <a href="https://eel.is/c++draft/range.ref.view">[range.ref.view]</a>, as indicated:</p>

          <blockquote>
            <pre>
namespace std::ranges {
  template&lt;range R&gt;
    requires is_object_v&lt;R&gt;
  class ref_view : public view_interface&lt;ref_view&lt;R&gt;&gt; {
    [&hellip;]
  public:
    [&hellip;]
    constexpr auto reserve_hint() const requires <del>approximately_sized_range</del><ins><i>only-approximately-sized</i></ins>&lt;R&gt;
    { return ranges::reserve_hint(*<i>r_</i>); }
    [&hellip;]
  };
  [&hellip;]
}
        </pre>
          </blockquote>
        </li>
        <li>
          <p>Modify 25.7.6.3 <a href="https://eel.is/c++draft/range.owning.view">[range.owning.view]</a>, as indicated:
          </p>

          <blockquote>
            <pre>
namespace std::ranges {
  template&lt;range R&gt;
    requires movable&lt;R&gt; && (!<i>is-initializer-list</i>&lt;R&gt;) // <i>see [range.refinements]</i>
  class owning_view : public view_interface&lt;owning_view&lt;R&gt;&gt; {
    [&hellip;]
  public: 
    [&hellip;]
    constexpr auto reserve_hint() requires <del>approximately_sized_range</del><ins><i>only-approximately-sized</i></ins>&lt;R&gt;
    { return ranges::reserve_hint(<i>r_</i>); }
    constexpr auto reserve_hint() const requires <del>approximately_sized_range</del><ins><i>only-approximately-sized</i></ins>&lt;const R&gt;
    { return ranges::reserve_hint(<i>r_</i>); }
    [&hellip;]
  };
}
        </pre>
          </blockquote>
        </li>
        <li>
          <p>Modify 25.7.7.2 <a href="https://eel.is/c++draft/range.as.rvalue.view">[range.as.rvalue.view]</a>, as
            indicated:</p>

          <blockquote>
            <pre>
namespace std::ranges {
  templatelt;view Vgt;
    requires input_rangelt;Vgt;
  class as_rvalue_view : public view_interfacelt;as_rvalue_viewlt;Vgt;gt; {
    [&hellip;]
  public:
    [&hellip;]
    constexpr auto reserve_hint() requires <del>approximately_sized_range</del><ins><i>only-approximately-sized</i></ins>&lt;V&gt;
    { return ranges::reserve_hint(<i>base_</i>); }
    constexpr auto reserve_hint() const requires <del>approximately_sized_range</del><ins><i>only-approximately-sized</i></ins>&lt;const V&gt;
    { return ranges::reserve_hint(<i>base_</i>); }
  };
  [&hellip;]
}
        </pre>
          </blockquote>
        </li>
        <li>
          <p>Modify 25.7.9.2 <a href="https://eel.is/c++draft/range.transform.view">[range.transform.view]</a>, as
            indicated:</p>

          <blockquote>
            <pre>
namespace std::ranges {
  templatelt;input_range V, move_constructible F&gt;
    requires viewlt;V&gt; && is_object_vlt;F&gt; &&
             regular_invocablelt;F&, range_reference_tlt;V&gt;&gt; &&
             <i>can-reference</i>lt;invoke_result_tlt;F&, range_reference_tlt;V&gt;&gt;&gt;
  class transform_view : public view_interfacelt;transform_viewlt;V, F&gt;&gt; {
    [&hellip;]
  public:
    [&hellip;]
    constexpr auto reserve_hint() requires <del>approximately_sized_range</del><ins><i>only-approximately-sized</i></ins>&lt;V&gt;
    { return ranges::reserve_hint(<i>base_</i>); }
    constexpr auto reserve_hint() const requires <del>approximately_sized_range</del><ins><i>only-approximately-sized</i></ins>&lt;const V&gt;
    { return ranges::reserve_hint(<i>base_</i>); }
  };
  [&hellip;]
}
        </pre>
          </blockquote>
        </li>
        <li>
          <p>Modify 25.7.10.2 <a href="https://eel.is/c++draft/range.take.view">[range.take.view]</a>, as indicated:</p>

          <blockquote>
            <pre>
namespace std::ranges {
  template&lt;view V&gt;
  class take_view : public view_interface&lt;take_view&lt;V&gt;&gt; {
    [&hellip;]
  public:
    [&hellip;]
    constexpr auto reserve_hint() <ins>noexcept</ins> {
      <del>if constexpr (approximately_sized_range&lt;V&gt;) {
        auto n = static_cast&lt;range_difference_t&lt;V&gt;&gt;(ranges::reserve_hint(<i>base_</i>));
        return <i>to-unsigned-like</i>(ranges::min(n, <i>count_</i>));
      }</del>
      return <i>to-unsigned-like</i>(<i>count_</i>);
    }

    <ins>constexpr auto reserve_hint() requires <i>only-approximately-sized</i>&lt;V&gt; {
      auto n = static_cast&lt;range_difference_t&lt;V&gt;&gt;(ranges::reserve_hint(<i>base_</i>));
      return <i>to-unsigned-like</i>(ranges::min(n, <i>count_</i>));
    }</ins>

    constexpr auto reserve_hint() const <ins>noexcept</ins> {
      <del>if constexpr (approximately_sized_range&lt;const V&gt;) {
        auto n = static_cast&lt;range_difference_t&lt;const V&gt;&gt;(ranges::reserve_hint(<i>base_</i>));
        return <i>to-unsigned-like</i>(ranges::min(n, <i>count_</i>));
      }</del>
      return <i>to-unsigned-like</i>(<i>count_</i>);
    }

    <ins>constexpr auto reserve_hint() const requires <i>only-approximately-sized</i>&lt;const V&gt; {
      auto n = static_cast&lt;range_difference_t&lt;const V&gt;&gt;(ranges::reserve_hint(<i>base_</i>));
      return <i>to-unsigned-like</i>(ranges::min(n, <i>count_</i>));
    }</ins>
  };
  [&hellip;]
}
        </pre>
          </blockquote>
        </li>
        <li>
          <p>Modify 25.7.12.2 <a href="https://eel.is/c++draft/range.drop.view">[range.drop.view]</a>, as indicated:</p>

          <blockquote>
            <pre>
namespace std::ranges {
  template&lt;view V&gt;
  class drop_view : public view_interface&lt;drop_view&lt;V&gt;&gt; {
  public:
    [&hellip;]
    constexpr auto reserve_hint() requires <del>approximately_sized_range</del><ins><i>only-approximately-sized</i></ins>&lt;V&gt; {
      const auto s = static_cast&lt;range_difference_t&lt;V&gt;&gt;(ranges::reserve_hint(<i>base_</i>));
      return <i>to-unsigned-like</i>(s &lt; <i>count_</i> ? 0 : s - <i>count_</i>);
    }

    constexpr auto reserve_hint() const requires <del>approximately_sized_range</del><ins><i>only-approximately-sized</i></ins>&lt;const V&gt; {
      const auto s = static_cast&lt;range_difference_t&lt;const V&gt;&gt;(ranges::reserve_hint(<i>base_</i>));
      return <i>to-unsigned-like</i>(s &lt; <i>count_</i> ? 0 : s - <i>count_</i>);
    }
    [&hellip;]
  };
  [&hellip;]
}
        </pre>
          </blockquote>
        </li>
        <li>
          <p>Modify 25.7.20.2 <a href="https://eel.is/c++draft/range.common.view">[range.common.view]</a>, as indicated:
          </p>

          <blockquote>
            <pre>
namespace std::ranges {
  template&lt;view V&gt;
    requires (!common_range&lt;V&gt; && copyable&lt;iterator_t&lt;V&gt;&gt;)
  class common_view : public view_interface&lt;common_view&lt;V&gt;&gt; {
    [&hellip;]
  public:
    [&hellip;]
    constexpr auto reserve_hint() requires <del>approximately_sized_range</del><ins><i>only-approximately-sized</i></ins>&lt;V&gt; {
      return ranges::reserve_hint(<i>base_</i>);
    }
    constexpr auto reserve_hint() const requires <del>approximately_sized_range</del><ins><i>only-approximately-sized</i></ins>&lt;const V&gt; {
      return ranges::reserve_hint(<i>base_</i>);
    }
  };
  [&hellip;]
}
        </pre>
          </blockquote>
        </li>
        <li>
          <p>Modify 25.7.21.2 <a href="https://eel.is/c++draft/range.reverse.view">[range.reverse.view]</a>, as
            indicated:
          </p>
          <blockquote>
            <pre>
namespace std::ranges {
  template&lt;view V&gt;
    requires bidirectional_range&lt;V&gt;
  class reverse_view : public view_interface&lt;reverse_view&lt;V&gt;&gt; {
    [&hellip;]
  public:
    [&hellip;]
    constexpr auto reserve_hint() requires <del>approximately_sized_range</del><ins><i>only-approximately-sized</i></ins>&lt;V&gt; {
      return ranges::reserve_hint(<i>base_</i>);
    }
    constexpr auto reserve_hint() const requires <del>approximately_sized_range</del><ins><i>only-approximately-sized</i></ins>&lt;const V&gt; {
      return ranges::reserve_hint(<i>base_</i>);
    }
  };
  [&hellip;]
}
        </pre>
          </blockquote>
        </li>
        <li>
          <p>Modify 25.7.22.2 <a href="https://eel.is/c++draft/range.as.const.view">[range.as.const.view]</a>, as
            indicated:</p>
          <blockquote>
            <pre>
namespace std::ranges {
  template&lt;view V&gt;
    requires input_range&lt;V&gt;
  class as_const_view : public view_interface&lt;as_const_view&lt;V&gt;&gt; {
    [&hellip;]
  public:
    [&hellip;]
    constexpr auto reserve_hint() requires <del>approximately_sized_range</del><ins><i>only-approximately-sized</i></ins>&lt;V&gt; {
      return ranges::reserve_hint(<i>base_</i>);
    }
    constexpr auto reserve_hint() const requires <del>approximately_sized_range</del><ins><i>only-approximately-sized</i></ins>&lt;const V&gt; {
      return ranges::reserve_hint(<i>base_</i>);
    }
  };
  [&hellip;]
}
        </pre>
          </blockquote>
        </li>
        <li>
          <p>Modify 25.7.23.2 <a href="https://eel.is/c++draft/range.elements.view">[range.elements.view]</a>, as
            indicated:</p>
          <blockquote>
            <pre>
namespace std::ranges {
  [&hellip;]
  template&lt;input_range V, size_t N&gt;
    requires view&lt;V&gt; && <i>has-tuple-element</i>&lt;range_value_t&lt;V&gt;, N&gt; &&
             <i>has-tuple-element</i>&lt;remove_reference_t&lt;range_reference_t&lt;V&gt;&gt;, N&gt; &&
             <i>returnable-element</i>&lt;range_reference_t&lt;V&gt;, N&gt;
  class elements_view : public view_interface&lt;elements_view&lt;V, N&gt;&gt; {
  public:
    [&hellip;]
    constexpr auto reserve_hint() requires <del>approximately_sized_range</del><ins><i>only-approximately-sized</i></ins>&lt;V&gt;
    { return ranges::reserve_hint(<i>base_</i>); }

    constexpr auto reserve_hint() const requires <del>approximately_sized_range</del><ins><i>only-approximately-sized</i></ins>&lt;const V&gt;
    { return ranges::reserve_hint(<i>base_</i>); }
    [&hellip;]
  };
}
        </pre>
          </blockquote>
        </li>
        <li>
          <p>Modify 25.7.24.2 <a href="https://eel.is/c++draft/range.enumerate.view">[range.enumerate.view]</a>, as
            indicated:</p>
          <blockquote>
            <pre>
namespace std::ranges {
  template&lt;view V&gt;
    requires <i>range-with-movable-references</i>&lt;V&gt;
  class enumerate_view : public view_interface&lt;enumerate_view&lt;V&gt;&gt; {
    [&hellip;]
  public:
    [&hellip;]
    constexpr auto reserve_hint() requires <del>approximately_sized_range</del><ins><i>only-approximately-sized</i></ins>&lt;V&gt;
    { return ranges::reserve_hint(<i>base_</i>); }
    constexpr auto reserve_hint() const requires <del>approximately_sized_range</del><ins><i>only-approximately-sized</i></ins>&lt;const V&gt;
    { return ranges::reserve_hint(<i>base_</i>); }
    [&hellip;]
  };
  [&hellip;]
}
        </pre>
          </blockquote>
        </li>
        <li>
          <p>Modify 25.7.27.2 <a href="https://eel.is/c++draft/range.adjacent.view">[range.adjacent.view]</a>, as
            indicated:</p>
          <blockquote>
            <pre>
namespace std::ranges {
  template&lt;forward_range V, size_t N&gt;
    requires view&lt;V&gt; && (N &gt; 0)
  class adjacent_view : public view_interface&lt;adjacent_view&lt;V, N&gt;&gt; {
    [&hellip;]
  public:
    [&hellip;]
    constexpr auto reserve_hint() requires <del>approximately_sized_range</del><ins><i>only-approximately-sized</i></ins>&lt;V&gt;;
    constexpr auto reserve_hint() const requires <del>approximately_sized_range</del><ins><i>only-approximately-sized</i></ins>&lt;const V&gt;;
  };
}</pre>
            [&hellip;]
            <pre>
constexpr auto reserve_hint() requires <del>approximately_sized_range</del><ins><i>only-approximately-sized</i></ins>&lt;V&gt;;
constexpr auto reserve_hint() const requires <del>approximately_sized_range</del><ins><i>only-approximately-sized</i></ins>&lt;const V&gt;;</pre>
            <blockquote>
              <p>-3- <i>Effects</i>: Equivalent to:
              </p>
              [&hellip;]
            </blockquote>
        </li>
        <li>
          <p>Modify 25.7.28.2 <a
              href="https://eel.is/c++draft/range.adjacent.transform.view">[range.adjacent.transform.view]</a>, as
            indicated:</p>
          <blockquote>
            <pre>
namespace std::ranges {
  template&lt;forward_range V, move_constructible F, size_t N&gt;
    requires view&lt;V&gt; && (N &gt; 0) && is_object_v&lt;F&gt; &&
             regular_invocable&lt;F&, <i>REPEAT</i>(range_reference_t&lt;V&gt;, N)...&gt; &&
             <i>can-reference</i>&lt;invoke_result_t&lt;F&, <i>REPEAT</i>(range_reference_t&lt;V&gt;, N)...&gt;&gt;
  class adjacent_transform_view : public view_interface&lt;adjacent_transform_view&lt;V, F, N&gt;&gt; {
    [&hellip;]
  public:
    [&hellip;]
    constexpr auto reserve_hint() requires <del>approximately_sized_range</del><ins><i>only-approximately-sized</i></ins>&lt;<i>InnerView</i>&gt; {
      return <i>inner_</i>.reserve_hint();
    }

    constexpr auto reserve_hint() const requires <del>approximately_sized_range</del><ins><i>only-approximately-sized</i></ins>&lt;const <i>InnerView</i>&gt; {
      return <i>inner_</i>.reserve_hint();
    }
  };
}
</pre>
        </li>
        <li>
          <p>Modify 25.7.29.2 <a href="https://eel.is/c++draft/range.chunk.view.input">[range.chunk.view.input]</a>, as
            indicated:</p>
          <blockquote>
            <pre>
namespace std::ranges {
  [&hellip;]
  template&lt;view V&gt;
    requires input_range&lt;V&gt;
  class chunk_view : public view_interface&lt;chunk_view&lt;V, N&gt;&gt; {
    [&hellip;]
  public:
    [&hellip;]
    constexpr auto reserve_hint() requires <del>approximately_sized_range</del><ins><i>only-approximately-sized</i></ins>&lt;V&gt;;
    constexpr auto reserve_hint() const requires <del>approximately_sized_range</del><ins><i>only-approximately-sized</i></ins>&lt;const V&gt;;
  };
  [&hellip;]
}</pre>
            [&hellip;]
            <pre>
constexpr auto reserve_hint() requires <del>approximately_sized_range</del><ins><i>only-approximately-sized</i></ins>&lt;V&gt;;
constexpr auto reserve_hint() const requires <del>approximately_sized_range</del><ins><i>only-approximately-sized</i></ins>&lt;const V&gt;;</pre>
            <blockquote>
              <p>-6- <i>Effects</i>: Equivalent to:
              </p>
              [&hellip;]
            </blockquote>
        </li>
        <li>
          <p>Modify 25.7.29.2 <a href="https://eel.is/c++draft/range.chunk.outer.value">[range.chunk.outer.value]</a>,
            as
            indicated:</p>
          <blockquote>
            <pre>
namespace std::ranges {
  [&hellip;]
  template&lt;view V&gt;
    requires input_range&lt;V&gt;
  struct chunk_view&lt;V&gt;::<i>outer-iterator</i>::value_type : view_interface&lt;value_type&gt; {
    [&hellip;]
  public:
    [&hellip;]
    constexpr auto size() const
      requires sized_sentinel_for&lt;sentinel_t&lt;V&gt;, iterator_t&lt;V&gt;&gt;;
    constexpr auto reserve_hint() const noexcept
      <ins>requires !sized_sentinel_for&lt;sentinel_t&lt;V&gt;, iterator_t&lt;V&gt;&gt;</ins>;
  };
}</pre>
            [&hellip;]
            <pre>
    constexpr auto reserve_hint() const noexcept
      <ins>requires !sized_sentinel_for&lt;sentinel_t&lt;V&gt;, iterator_t&lt;V&gt;&gt;</ins>;</pre>
            <blockquote>
              <p>-5- <i>Effects</i>: Equivalent to:
              </p>
              [&hellip;]
            </blockquote>
        </li>
        <li>
          <p>Modify 25.7.29.6 <a href="https://eel.is/c++draft/range.chunk.view.fwd">[range.chunk.view.fwd]</a>, as
            indicated:</p>
          <blockquote>
            <pre>
namespace std::ranges {
  template&lt;view V&gt;
    requires forward_range&lt;V&gt;
  class chunk_view : public view_interface&lt;chunk_view&lt;V, N&gt;&gt; {
    [&hellip;]
  public:
    [&hellip;]
    constexpr auto reserve_hint() requires <del>approximately_sized_range</del><ins><i>only-approximately-sized</i></ins>&lt;V&gt;;
    constexpr auto reserve_hint() const requires <del>approximately_sized_range</del><ins><i>only-approximately-sized</i></ins>&lt;const V&gt;;
  };
}</pre>
            [&hellip;]
            <pre>
constexpr auto reserve_hint() requires <del>approximately_sized_range</del><ins><i>only-approximately-sized</i></ins>&lt;V&gt;;
constexpr auto reserve_hint() const requires <del>approximately_sized_range</del><ins><i>only-approximately-sized</i></ins>&lt;const V&gt;;</pre>
            <blockquote>
              <p>-4- <i>Effects</i>: Equivalent to:
              </p>
              [&hellip;]
            </blockquote>
        </li>
        <li>
          <p>Modify 25.7.30.2 <a href="https://eel.is/c++draft/range.slide.view">[range.slide.view]</a>, as indicated:
          </p>
          <blockquote>
            <pre>
namespace std::ranges {
  [&hellip;]
  template&lt;forward_range V&gt;
    requires view&lt;V&gt;
  class slide_view : public view_interface&lt;slide_view&lt;V, N&gt;&gt; {
    [&hellip;]
  public:
    [&hellip;]
    constexpr auto reserve_hint() requires <del>approximately_sized_range</del><ins><i>only-approximately-sized</i></ins>&lt;V&gt;;
    constexpr auto reserve_hint() const requires <del>approximately_sized_range</del><ins><i>only-approximately-sized</i></ins>&lt;const V&gt;;
  };
  [&hellip;]
}</pre>
            [&hellip;]
            <pre>
constexpr auto reserve_hint() requires <del>approximately_sized_range</del><ins><i>only-approximately-sized</i></ins>&lt;V&gt;;
constexpr auto reserve_hint() const requires <del>approximately_sized_range</del><ins><i>only-approximately-sized</i></ins>&lt;const V&gt;;</pre>
            <blockquote>
              <p>-10- <i>Effects</i>: Equivalent to:
              </p>
              [&hellip;]
            </blockquote>
        </li>
        <li>
          <p>Modify 25.7.32.2 <a href="https://eel.is/c++draft/range.stride.view">[range.stride.view]</a>, as indicated:
          </p>
          <blockquote>
            <pre>
namespace std::ranges {
  [&hellip;]
  template&lt;input_range V&gt;
    requires view&lt;V&gt;
  class stride_view : public view_interface&lt;stride_view&lt;V, N&gt;&gt; {
    [&hellip;]
  public:
    [&hellip;]
    constexpr auto reserve_hint() requires <del>approximately_sized_range</del><ins><i>only-approximately-sized</i></ins>&lt;V&gt;;
    constexpr auto reserve_hint() const requires <del>approximately_sized_range</del><ins><i>only-approximately-sized</i></ins>&lt;const V&gt;;
  };
  [&hellip;]
}</pre>
            [&hellip;]
            <pre>
constexpr auto reserve_hint() requires <del>approximately_sized_range</del><ins><i>only-approximately-sized</i></ins>&lt;V&gt;;
constexpr auto reserve_hint() const requires <del>approximately_sized_range</del><ins><i>only-approximately-sized</i></ins>&lt;const V&gt;;</pre>
            <blockquote>
              <p>-5- <i>Effects</i>: Equivalent to:
              </p>
              [&hellip;]
            </blockquote>
        </li>
        <li>
          <p>Modify 25.7.34.2 <a href="https://eel.is/c++draft/range.cache.latest.view">[range.cache.latest.view]</a>,
            as
            indicated:
          </p>
          <blockquote>
            <pre>
namespace std::ranges {
  template&lt;input_range V&gt;
    requires view&lt;V&gt;
  class cache_latest_view : public view_interface&lt;cache_latest_view&lt;V, N&gt;&gt; {
    [&hellip;]
  public:
    [&hellip;]
    constexpr auto reserve_hint() requires <del>approximately_sized_range</del><ins><i>only-approximately-sized</i></ins>&lt;V&gt;;
    constexpr auto reserve_hint() const requires <del>approximately_sized_range</del><ins><i>only-approximately-sized</i></ins>&lt;const V&gt;;
  };
  [&hellip;]
}</pre>
            [&hellip;]
            <pre>
constexpr auto reserve_hint() requires <del>approximately_sized_range</del><ins><i>only-approximately-sized</i></ins>&lt;V&gt;;
constexpr auto reserve_hint() const requires <del>approximately_sized_range</del><ins><i>only-approximately-sized</i></ins>&lt;const V&gt;;</pre>
            <blockquote>
              <p>-5- <i>Effects</i>: Equivalent to: <code>return ranges::reserve_hint(<i>base_</i>);</code>
              </p>
              [&hellip;]
            </blockquote>
        </li>
        <li>
          <p>Modify 25.7.35.2 <a href="https://eel.is/c++draft/range.to.input.view">[range.to.input.view]</a>, as
            indicated:
          </p>
          <blockquote>
            <pre>
namespace std::ranges {
  template&lt;input_range V&gt;
    requires view&lt;V&gt;
  class to_input_view : public view_interface&lt;to_input_view&lt;V, N&gt;&gt; {
    [&hellip;]
  public:
    [&hellip;]
    constexpr auto reserve_hint() requires <del>approximately_sized_range</del><ins><i>only-approximately-sized</i></ins>&lt;V&gt;;
    constexpr auto reserve_hint() const requires <del>approximately_sized_range</del><ins><i>only-approximately-sized</i></ins>&lt;const V&gt;;
  };
  [&hellip;]
}</pre>
            [&hellip;]
            <pre>
constexpr auto reserve_hint() requires <del>approximately_sized_range</del><ins><i>only-approximately-sized</i></ins>&lt;V&gt;;
constexpr auto reserve_hint() const requires <del>approximately_sized_range</del><ins><i>only-approximately-sized</i></ins>&lt;const V&gt;;</pre>
            <blockquote>
              <p>-6- <i>Effects</i>: Equivalent to: <code>return ranges::reserve_hint(<i>base_</i>);</code>
              </p>
            </blockquote>
        </li>
      </ol>
    </div>
    <a name="References"></a>
    <h2>References</h2>
    <dd>
    <dt id="biblio-p2846">[P2846R6]
    <dd>Corentin Jabot. <code>reserve_hint</code>: Eagerly reserving memory for
      not-quite-sized lazy ranges. URL: <a
        href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2846r6.pdf">https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2846r6.pdf</a>
</body>

</html>