Add double-transcode optimization section to the paper

Author: ednolan

paper/P2728.md

@@ -1378,6 +1378,181 @@ std::basic_string<ToCharT> transcode_to(std::basic_string<FromCharT> const& inpu
 }
 ```
 
+## Optimizing for Double-Transcoding
+
+In generic code, it's possible to introduce transcoding views that wrap other transcoding
+views:
+
+```c++
+void foo(std::ranges::view auto v) {
+#ifdef _MSC_VER
+  windows_function(v | std::views::to_utf16);
+#endif
+  // ...
+}
+
+int main(int, char const* argv[]) {
+  foo(std::null_term(argv[1]) | std::views::as_char8_t | std::views::to_utf32);
+}
+```
+
+In the above example, if the user is building on Windows, `foo` will create a
+`to_utf16_view` wrapping a `to_utf32_view`.
+
+### Eliding the Inner Transcoding View in the CPO
+
+You might want to add logic in the CPO such that it notices that `foo` is creating a
+`to_utf16_view` wrapping a `to_utf32_view`, elides the `to_utf16_view`, and creates the
+`to_utf32_view` directly wrapping the view produced by `as_char8_t`.
+
+However, this runs into issues where the result of `base()` isn't what the user
+expects. Consider this transcode function that works similarly to `std::ranges::copy`, in
+that it returns both the output iterator and the final position of the input iterator:
+
+```c++
+template <typename I, typename O>
+using transcode_result = std::ranges::in_out_result<I, O>;
+
+template <std::input_iterator I, std::sentinel_for<I> S, std::output_iterator<char8_t> O>
+transcode_result<I, O> transcode_to_utf32(I first, S last, O out) {
+  auto r = std::ranges::subrange(first, last) | to_utf32;
+
+  auto copy_result = std::ranges::copy(r, out);
+
+  return transcode_result<I, O>{copy_result.in.base(), copy_result.out};
+}
+```
+
+if `copy_result.in.base()` is a different type than `first`, this will break.
+
+### "Innermost" Optimization
+
+Instead, the iterator of the transcoding view can "look through" the iterator of the inner
+transcoding view that it's wrapping. Since the iterator is just a backpointer to the
+parent and an iterator to the current position, optimizing like this instead points the
+backpointer to its parent's parent, and uses the inner iterator of the iterator it's
+wrapping for the current position. We use exposition-only concepts named
+`@*innermost-parent*@` and `@*innermost-base*@` to explicate how this works in the
+wording.
+
+The wording change that would enable this optimization is as follows:
+
+#### Additional helper templates
+
+```diff
++  template<class T>
++  concept @*to-utf-view-iterator-optimizable*@ = @*unspecified*@ // @*exposition only*@
++  template<class T>
++  concept @*to-utf-view-sentinel-optimizable*@ = @*unspecified*@ // @*exposition only*@
+```
+
+These concepts are true when the type in question is the iterator/sentinel of a transcoding view.
+
+#### Exposition-only class template `@*to-utf-view-impl*@`
+
+```diff
+-    using @*Parent*@ = @*maybe-const*@<Const, @*to-utf-view-impl*@>; // @*exposition only*@
+-    using @*Base*@ = @*maybe-const*@<Const, V>; // @*exposition only*@
++    using @*innermost-parent*@ = @*unspecified*@ // @*exposition only*@
++    using @*innermost-base*@ = @*unspecified*@ // @*exposition only*@
++    static constexpr bool @*optimizing*@{@*to-utf-view-iterator-optimizable*@<iterator_t<@*Base*@>>
+```
+
+#### Class `@*to-utf-view-impl*@::@*iterator*@`
+
+```diff
+-    iterator_t<@*Base*@> current_ = iterator_t<@*Base*@>(); // @*exposition only*@
+-    @*Parent*@* parent_ = nullptr; // @*exposition only*@
++
++    iterator_t<@*innermost-base*@> current_ = iterator_t<@*innermost-base*@>(); // @*exposition only*@
++    @*innermost-parent*@* parent_ = nullptr; // @*exposition only*@
+```
+
+```diff
+-  constexpr @*iterator*@(@*Parent*@& parent, iterator_t<@*Base*@> begin) 
+-    : current_(std::move(begin)), 
+-      parent_(addressof(parent)) {
+-    if (base() != @*end*@())
+-      @*read*@();
+-    else if constexpr (!forward_range<@*Base*@>) {
+-      buf_index_ = -1;
+-    }
+-  }
++
++  constexpr @*iterator*@(@*innermost-parent*@& parent, iterator_t<@*innermost-base*@> begin)
++    : current_(std::move(begin)),
++      parent_(std::addressof(parent))
++  {
++    if (current_ != @*end*@())
++      @*read*@();
++    else if constexpr (!forward_range<@*Base*@>) {
++      buf_index_ = -1;
++    }
++  }
++
++    constexpr @*iterator*@(@*Parent*@& parent, iterator_t<@*Base*@> begin) requires @*optimizing*@
++        : current_(std::move(begin.current_)), parent_(begin.parent_) {
++      if (current_ != @*end*@())
++        @*read*@();
++      else if constexpr (!forward_range<@*Base*@>) {
++        buf_index_ = -1;
++      }
++    }
+```
+
+```diff
+-    constexpr const iterator_t<@*Base*@>& base() const& noexcept { return current_; }
++    constexpr iterator_t<@*Base*@> base() const& noexcept requires forward_range<@*Base*@>
++    {
++      if constexpr (@*optimizing*@) {
++        return iterator_t<@*Base*@>{*parent_, current_};
++      } else {
++        return current_;
++      }
++    }
+
+-    constexpr iterator_t<@*Base*@> base() && { return std::move(current_); }
++    constexpr iterator_t<@*Base*@> base() && {
++      if constexpr (@*optimizing*@) {
++        return iterator_t<@*Base*@>{*parent_, std::move(current_)};
++      } else {
++        return std::move(current_);
++      }
++    }
+```
+
+```diff
+-    constexpr sentinel_t<@*Base*@> @*end*@() const { // @*exposition only*/
++    constexpr sentinel_t<@*innermost-base*@> @*end*@() const { // @*exposition only*/
+       return end(parent_->base_);
+     }
+```
+
+#### Class `@*to-utf-view-impl*@::@*sentinel*@`
+
+```diff
+-    using @*Parent*@ = @*maybe-const*@<Const, @*to-utf-view-impl*@>; // @*exposition only*@
+-    using @*Base*@ = @*maybe-const*@<Const, V>; // @*exposition only*@
+-    sentinel_t<@*Base*@> end_ = sentinel_t<@*Base*@>();
++
++    using @*innermost-parent*@ = @*unspecified*@ // @*exposition only*@
++    using @*innermost-base*@ = @*unspecified*@ // @*exposition only*@
++    sentinel_t<@*innermost-base*@> end_ = sentinel_t<@*innermost-base*@>();
++    static constexpr bool @*optimizing*@{@*to-utf-view-sentinel-optimizable*@<sentinel_t<@*Base*@>>};
+```
+
+```diff
++    constexpr explicit @*sentinel*@(sentinel_t<@*Base*@> end) requires @*optimizing*@
++        : end_{end.end_} {}
+```
+
+```diff
++    constexpr sentinel_t<@*Base*@> base() const requires @*optimizing*@
++    {
++      return sentinel_t<@*Base*@>{end_};
++    }
+```
+
 # Changelog
 
 ## Changes since R8