P2387R3 Pipe for user defined range adaptors

stl/debugger/STL.natvis

@@ -616,6 +616,14 @@ SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
       </Expand>
   </Type>
 
+  <Type Name="std::_Back_binder&lt;*&gt;">
+    <DisplayString>bind_back({_Mypair}, {_Mypair._Myval2,view(noparens)})</DisplayString>
+    <Expand>
+      <Item Name="[f]">_Mypair</Item>
+      <Item Name="[bound_args]">_Mypair._Myval2</Item>
+    </Expand>
+  </Type>
+
 
   <!-- VC 2013 -->
   <Type Name="std::_Mem_fn_wrap&lt;*&gt;">

stl/inc/functional

@@ -2117,6 +2117,82 @@ _NODISCARD constexpr auto bind_front(_Fx&& _Func, _Types&&... _Args) {
 }
 #endif // _HAS_CXX20
 
+#if _HAS_CXX23
+template <size_t... _Ix, class _Cv_FD, class _Cv_tuple_TiD, class... _Unbound>
+constexpr auto _Call_back_binder(index_sequence<_Ix...>, _Cv_FD&& _Obj, _Cv_tuple_TiD&& _Tpl,
+    _Unbound&&... _Unbargs) noexcept(noexcept(_STD invoke(_STD forward<_Cv_FD>(_Obj),
+    _STD forward<_Unbound>(_Unbargs)..., _STD get<_Ix>(_STD forward<_Cv_tuple_TiD>(_Tpl))...)))
+    -> decltype(_STD invoke(_STD forward<_Cv_FD>(_Obj), _STD forward<_Unbound>(_Unbargs)...,
+        _STD get<_Ix>(_STD forward<_Cv_tuple_TiD>(_Tpl))...)) {
+    return _STD invoke(_STD forward<_Cv_FD>(_Obj), _STD forward<_Unbound>(_Unbargs)...,
+        _STD get<_Ix>(_STD forward<_Cv_tuple_TiD>(_Tpl))...);
+}
+
+template <class _Fx, class... _Types>
+class _Back_binder { // wrap bound callable object and arguments
+private:
+    using _Seq = index_sequence_for<_Types...>;
+
+    _Compressed_pair<_Fx, tuple<_Types...>> _Mypair;
+
+    _STL_INTERNAL_STATIC_ASSERT(is_same_v<_Fx, decay_t<_Fx>>);
+    _STL_INTERNAL_STATIC_ASSERT((is_same_v<_Types, decay_t<_Types>> && ...));
+
+public:
+    template <class _FxInit, class... _TypesInit,
+        enable_if_t<sizeof...(_TypesInit) != 0 || !is_same_v<remove_cvref_t<_FxInit>, _Back_binder>, int> = 0>
+    constexpr explicit _Back_binder(_FxInit&& _Func, _TypesInit&&... _Args)
+        : _Mypair(_One_then_variadic_args_t{}, _STD forward<_FxInit>(_Func), _STD forward<_TypesInit>(_Args)...) {}
+
+    template <class... _Unbound>
+    constexpr auto operator()(_Unbound&&... _Unbargs) & noexcept(
+        noexcept(_Call_back_binder(_Seq{}, _Mypair._Get_first(), _Mypair._Myval2, _STD forward<_Unbound>(_Unbargs)...)))
+        -> decltype(_Call_back_binder(
+            _Seq{}, _Mypair._Get_first(), _Mypair._Myval2, _STD forward<_Unbound>(_Unbargs)...)) {
+        return _Call_back_binder(_Seq{}, _Mypair._Get_first(), _Mypair._Myval2, _STD forward<_Unbound>(_Unbargs)...);
+    }
+
+    template <class... _Unbound>
+    constexpr auto operator()(_Unbound&&... _Unbargs) const& noexcept(
+        noexcept(_Call_back_binder(_Seq{}, _Mypair._Get_first(), _Mypair._Myval2, _STD forward<_Unbound>(_Unbargs)...)))
+        -> decltype(_Call_back_binder(
+            _Seq{}, _Mypair._Get_first(), _Mypair._Myval2, _STD forward<_Unbound>(_Unbargs)...)) {
+        return _Call_back_binder(_Seq{}, _Mypair._Get_first(), _Mypair._Myval2, _STD forward<_Unbound>(_Unbargs)...);
+    }
+
+    template <class... _Unbound>
+    constexpr auto operator()(_Unbound&&... _Unbargs) && noexcept(noexcept(_Call_back_binder(
+        _Seq{}, _STD move(_Mypair._Get_first()), _STD move(_Mypair._Myval2), _STD forward<_Unbound>(_Unbargs)...)))
+        -> decltype(_Call_back_binder(
+            _Seq{}, _STD move(_Mypair._Get_first()), _STD move(_Mypair._Myval2), _STD forward<_Unbound>(_Unbargs)...)) {
+        return _Call_back_binder(
+            _Seq{}, _STD move(_Mypair._Get_first()), _STD move(_Mypair._Myval2), _STD forward<_Unbound>(_Unbargs)...);
+    }
+
+    template <class... _Unbound>
+    constexpr auto operator()(_Unbound&&... _Unbargs) const&& noexcept(noexcept(_Call_back_binder(
+        _Seq{}, _STD move(_Mypair._Get_first()), _STD move(_Mypair._Myval2), _STD forward<_Unbound>(_Unbargs)...)))
+        -> decltype(_Call_back_binder(
+            _Seq{}, _STD move(_Mypair._Get_first()), _STD move(_Mypair._Myval2), _STD forward<_Unbound>(_Unbargs)...)) {
+        return _Call_back_binder(
+            _Seq{}, _STD move(_Mypair._Get_first()), _STD move(_Mypair._Myval2), _STD forward<_Unbound>(_Unbargs)...);
+    }
+};
+template <class _Fx, class... _Types>
+_NODISCARD constexpr auto bind_back(_Fx&& _Func, _Types&&... _Args) {
+    static_assert(is_constructible_v<decay_t<_Fx>, _Fx>,
+        "std::bind_back requires the decayed callable to be constructible from an undecayed callable");
+    static_assert(
+        is_move_constructible_v<decay_t<_Fx>>, "std::bind_back requires the decayed callable to be move constructible");
+    static_assert(conjunction_v<is_constructible<decay_t<_Types>, _Types>...>,
+        "std::bind_back requires the decayed bound arguments to be constructible from undecayed bound arguments");
+    static_assert(conjunction_v<is_move_constructible<decay_t<_Types>>...>,
+        "std::bind_back requires the decayed bound arguments to be move constructible");
+
+    return _Back_binder<decay_t<_Fx>, decay_t<_Types>...>(_STD forward<_Fx>(_Func), _STD forward<_Types>(_Args)...);
+}
+#endif // _HAS_CXX23
+
 #if _HAS_FUNCTION_ALLOCATOR_SUPPORT
 template <class _Fty, class _Alloc>
 struct uses_allocator<function<_Fty>, _Alloc> : true_type {}; // true_type if container allocator enabled

stl/inc/ranges

@@ -60,6 +60,23 @@ namespace ranges {
     template <bool _IsWrapped, class _Ty>
     using _Maybe_wrapped = conditional_t<_IsWrapped, _Ty, _Unwrapped_t<_Ty>>;
 
+#if _HAS_CXX23
+    template <class _Derived>
+        requires is_class_v<_Derived> && same_as<_Derived, remove_cv_t<_Derived>>
+    class range_adaptor_closure;
+
+    template <class _Ty>
+    using _Range_Adaptor_Base = range_adaptor_closure<_Ty>;
+#else // ^^^ _HAS_CXX23 / _HAS_CXX20 vvv
+    namespace _Pipe {
+        template <class _Derived>
+        struct _Base;
+    } // namespace _Pipe
+
+    template <class _Ty>
+    using _Range_Adaptor_Base = _Pipe::_Base<_Ty>;
+#endif
+
     namespace _Pipe {
         // clang-format off
         template <class _Left, class _Right>
@@ -72,9 +89,49 @@ namespace ranges {
             && constructible_from<remove_cvref_t<_Right>, _Right>;
         // clang-format on
 
-        template <class, class>
-        struct _Pipeline;
+        template <class _ClosureLeft, class _ClosureRight>
+        struct _Pipeline : _Range_Adaptor_Base<_Pipeline<_ClosureLeft, _ClosureRight>> {
+            /* [[no_unique_address]] */ _ClosureLeft _Left;
+            /* [[no_unique_address]] */ _ClosureRight _Right;
+
+            template <class _Ty1, class _Ty2>
+            constexpr explicit _Pipeline(_Ty1&& _Val1, _Ty2&& _Val2) noexcept(
+                is_nothrow_constructible_v<_Ty1, _ClosureLeft>&& is_nothrow_constructible_v<_Ty2, _ClosureRight>)
+                : _Left(_STD forward<_Ty1>(_Val1)), _Right(_STD forward<_Ty2>(_Val2)) {}
+
+            template <class _Ty>
+            _NODISCARD constexpr auto operator()(_Ty&& _Val) & noexcept(
+                noexcept(_Right(_Left(_STD forward<_Ty>(_Val))))) requires requires {
+                _Right(_Left(_STD forward<_Ty>(_Val)));
+            }
+            { return _Right(_Left(_STD forward<_Ty>(_Val))); }
+
+            template <class _Ty>
+            _NODISCARD constexpr auto operator()(_Ty&& _Val) && noexcept(
+                noexcept(_STD move(_Right)(_STD move(_Left)(_STD forward<_Ty>(_Val))))) requires requires {
+                _STD move(_Right)(_STD move(_Left)(_STD forward<_Ty>(_Val)));
+            }
+            { return _STD move(_Right)(_STD move(_Left)(_STD forward<_Ty>(_Val))); }
+
+            template <class _Ty>
+            _NODISCARD constexpr auto operator()(_Ty&& _Val) const& noexcept(
+                noexcept(_Right(_Left(_STD forward<_Ty>(_Val))))) requires requires {
+                _Right(_Left(_STD forward<_Ty>(_Val)));
+            }
+            { return _Right(_Left(_STD forward<_Ty>(_Val))); }
+
+            template <class _Ty>
+            _NODISCARD constexpr auto operator()(_Ty&& _Val) const&& noexcept(
+                noexcept(_STD move(_Right)(_STD move(_Left)(_STD forward<_Ty>(_Val))))) requires requires {
+                _STD move(_Right)(_STD move(_Left)(_STD forward<_Ty>(_Val)));
+            }
+            { return _STD move(_Right)(_STD move(_Left)(_STD forward<_Ty>(_Val))); }
+        };
+
+        template <class _Ty1, class _Ty2>
+        _Pipeline(_Ty1, _Ty2) -> _Pipeline<_Ty1, _Ty2>;
 
+#if !_HAS_CXX23
         template <class _Derived>
         struct _Base {
             template <class _Other>
@@ -135,34 +192,7 @@ namespace ranges {
                 return static_cast<_Derived&&>(__r)(_STD forward<_Left>(__l));
             }
         };
-
-        template <class _Left, class _Right>
-        struct _Pipeline : _Base<_Pipeline<_Left, _Right>> {
-            /* [[no_unique_address]] */ _Left __l;
-            /* [[no_unique_address]] */ _Right __r;
-
-            template <class _Ty1, class _Ty2>
-            constexpr explicit _Pipeline(_Ty1&& _Val1, _Ty2&& _Val2) noexcept(
-                is_nothrow_convertible_v<_Ty1, _Left>&& is_nothrow_convertible_v<_Ty2, _Right>)
-                : __l(_STD forward<_Ty1>(_Val1)), __r(_STD forward<_Ty2>(_Val2)) {}
-
-            template <class _Ty>
-            _NODISCARD constexpr auto operator()(_Ty&& _Val) noexcept(
-                noexcept(__r(__l(_STD forward<_Ty>(_Val))))) requires requires {
-                __r(__l(static_cast<_Ty&&>(_Val)));
-            }
-            { return __r(__l(_STD forward<_Ty>(_Val))); }
-
-            template <class _Ty>
-            _NODISCARD constexpr auto operator()(_Ty&& _Val) const
-                noexcept(noexcept(__r(__l(_STD forward<_Ty>(_Val))))) requires requires {
-                __r(__l(static_cast<_Ty&&>(_Val)));
-            }
-            { return __r(__l(_STD forward<_Ty>(_Val))); }
-        };
-
-        template <class _Ty1, class _Ty2>
-        _Pipeline(_Ty1, _Ty2) -> _Pipeline<_Ty1, _Ty2>;
+#endif //!_HAS_CXX23
     } // namespace _Pipe
 
     template <range _Rng, class _Derived>
@@ -806,7 +836,7 @@ namespace ranges {
     };
 
     template <class _Fn, class... _Types>
-    class _Range_closure : public _Pipe::_Base<_Range_closure<_Fn, _Types...>> {
+    class _Range_closure : public _Range_Adaptor_Base<_Range_closure<_Fn, _Types...>> {
     public:
         // We assume that _Fn is the type of a customization point object. That means
         // 1. The behavior of operator() is independent of cvref qualifiers, so we can use `invocable<_Fn, ` without
@@ -1433,6 +1463,93 @@ namespace ranges {
         inline constexpr _Istream_fn<_Ty> istream;
     } // namespace views
 
+#if _HAS_CXX23
+    namespace _Pipe {
+        template <class _Ty>
+        void _Derived_from_range_adaptor_closure_impl(const volatile range_adaptor_closure<_Ty>&);
+
+        template <class _Ty>
+        concept _Derived_from_range_adaptor_closure = requires(const volatile _Ty& __obj) {
+            _Derived_from_range_adaptor_closure_impl(__obj);
+        };
+
+        template <class _Ty>
+        concept _Is_range_adaptor_common = derived_from<remove_cvref_t<_Ty>,
+            range_adaptor_closure<remove_cvref_t<_Ty>>> && _Derived_from_range_adaptor_closure<_Ty> && !range<_Ty>;
+
+        template <class _Rng, class _Ty>
+        concept _Is_invocable_range_adaptor_closure =
+            range<_Rng> && _Can_pipe<_Rng, _Ty> && _Is_range_adaptor_common<_Ty>;
+
+        template <class _Left, class _Right>
+        concept _Are_composable_range_adaptor_closures =
+            _Is_range_adaptor_common<_Left> && _Is_range_adaptor_common<_Right> && _Can_compose<_Left, _Right>;
+    } // namespace _Pipe
+
+    template <class _Derived>
+        requires is_class_v<_Derived> && same_as<_Derived, remove_cv_t<_Derived>>
+    class range_adaptor_closure {
+    public:
+        template <class _Other>
+            requires _Pipe::_Are_composable_range_adaptor_closures<_Derived, _Other>
+        constexpr auto operator|(_Other&& _Right) && noexcept(
+            noexcept(_Pipe::_Pipeline{static_cast<_Derived&&>(*this), _STD forward<_Other>(_Right)})) {
+            return _Pipe::_Pipeline{static_cast<_Derived&&>(*this), _STD forward<_Other>(_Right)};
+        }
+
+        template <class _Other>
+            requires _Pipe::_Are_composable_range_adaptor_closures<const _Derived&, _Other>
+        constexpr auto operator|(_Other&& _Right) const& noexcept(
+            noexcept(_Pipe::_Pipeline{static_cast<const _Derived&>(*this), _STD forward<_Other>(_Right)})) {
+            return _Pipe::_Pipeline{static_cast<const _Derived&>(*this), _STD forward<_Other>(_Right)};
+        }
+
+        template <_Pipe::_Is_invocable_range_adaptor_closure<_Derived&> _Rng>
+        friend constexpr auto operator|(_Rng&& _Left, _Derived& _Right)
+#ifdef __EDG__ // TRANSITION, VSO-1222776
+            noexcept(noexcept(_STD declval<_Derived&>()(_STD forward<_Rng>(_Left))))
+#else // ^^^ workaround / no workaround vvv
+            noexcept(noexcept(static_cast<_Derived&>(_Right)(_STD forward<_Rng>(_Left))))
+#endif // TRANSITION, VSO-1222776
+        {
+            return static_cast<_Derived&>(_Right)(_STD forward<_Rng>(_Left));
+        }
+
+        template <_Pipe::_Is_invocable_range_adaptor_closure<_Derived&&> _Rng>
+        friend constexpr auto operator|(_Rng&& _Left, _Derived&& _Right)
+#ifdef __EDG__ // TRANSITION, VSO-1222776
+            noexcept(noexcept(_STD declval<_Derived>()(_STD forward<_Rng>(_Left))))
+#else // ^^^ workaround / no workaround vvv
+            noexcept(noexcept(static_cast<_Derived&&>(_Right)(_STD forward<_Rng>(_Left))))
+#endif // TRANSITION, VSO-1222776
+        {
+            return static_cast<_Derived&&>(_Right)(_STD forward<_Rng>(_Left));
+        }
+
+        template <_Pipe::_Is_invocable_range_adaptor_closure<const _Derived&> _Rng>
+        friend constexpr auto operator|(_Rng&& _Left, const _Derived& _Right)
+#ifdef __EDG__ // TRANSITION, VSO-1222776
+            noexcept(noexcept(_STD declval<const _Derived&>()(_STD forward<_Rng>(_Left))))
+#else // ^^^ workaround / no workaround vvv
+            noexcept(noexcept(static_cast<const _Derived&>(_Right)(_STD forward<_Rng>(_Left))))
+#endif // TRANSITION, VSO-1222776
+        {
+            return static_cast<const _Derived&>(_Right)(_STD forward<_Rng>(_Left));
+        }
+
+        template <_Pipe::_Is_invocable_range_adaptor_closure<const _Derived&&> _Rng>
+        friend constexpr auto operator|(_Rng&& _Left, const _Derived&& _Right)
+#ifdef __EDG__ // TRANSITION, VSO-1222776
+            noexcept(noexcept(_STD declval<const _Derived>()(_STD forward<_Rng>(_Left))))
+#else // ^^^ workaround / no workaround vvv
+            noexcept(noexcept(static_cast<const _Derived&&>(_Right)(_STD forward<_Rng>(_Left))))
+#endif // TRANSITION, VSO-1222776
+        {
+            return static_cast<const _Derived&&>(_Right)(_STD forward<_Rng>(_Left));
+        }
+    };
+#endif //_HAS_CXX23
+
     template <range _Rng>
         requires is_object_v<_Rng>
     class ref_view : public view_interface<ref_view<_Rng>> {
@@ -1579,7 +1696,7 @@ namespace ranges {
             owning_view{static_cast<_Rng&&>(__r)};
         };
 
-        class _All_fn : public _Pipe::_Base<_All_fn> {
+        class _All_fn : public _Range_Adaptor_Base<_All_fn> {
         private:
             enum class _St { _None, _View, _Ref, _Own };
 
@@ -3398,7 +3515,7 @@ namespace ranges {
     explicit join_view(_Rng&&) -> join_view<views::all_t<_Rng>>;
 
     namespace views {
-        class _Join_fn : public _Pipe::_Base<_Join_fn> {
+        class _Join_fn : public _Range_Adaptor_Base<_Join_fn> {
         public:
             // clang-format off
             template <viewable_range _Rng>
@@ -3893,7 +4010,7 @@ namespace ranges {
 #else // ^^^ no workaround / workaround vvv
                 auto _Match = _RANGES search(subrange{_Current, _Last}, _Parent->_Pattern);
                 auto _Begin = _Match.begin();
-                auto _End = _Match.end();
+                auto _End   = _Match.end();
 #endif // TRANSITION, DevCom-1559808
                 if (_Begin != _Last && _RANGES empty(_Parent->_Pattern)) {
                     ++_Begin;
@@ -3945,7 +4062,7 @@ namespace ranges {
 #else // ^^^ no workaround / workaround vvv
             auto _Match = _RANGES search(subrange{_It, _Last}, _Pattern);
             auto _Begin = _Match.begin();
-            auto _End = _Match.end();
+            auto _End   = _Match.end();
 #endif // TRANSITION, DevCom-1559808
             if (_Begin != _Last && _RANGES empty(_Pattern)) {
                 ++_Begin;
@@ -4155,7 +4272,7 @@ namespace ranges {
     inline constexpr bool enable_borrowed_range<common_view<_Rng>> = enable_borrowed_range<_Rng>;
 
     namespace views {
-        class _Common_fn : public _Pipe::_Base<_Common_fn> {
+        class _Common_fn : public _Range_Adaptor_Base<_Common_fn> {
         private:
             enum class _St { _None, _All, _Common };
 
@@ -4279,7 +4396,7 @@ namespace ranges {
             reverse_view{static_cast<_Rng&&>(__r)};
         };
 
-        class _Reverse_fn : public _Pipe::_Base<_Reverse_fn> {
+        class _Reverse_fn : public _Range_Adaptor_Base<_Reverse_fn> {
         private:
             enum class _St { _None, _Base, _Subrange_unsized, _Subrange_sized, _Reverse };
 
@@ -4731,7 +4848,7 @@ namespace ranges {
 
     namespace views {
         template <size_t _Index>
-        class _Elements_fn : public _Pipe::_Base<_Elements_fn<_Index>> {
+        class _Elements_fn : public _Range_Adaptor_Base<_Elements_fn<_Index>> {
         public:
             template <viewable_range _Rng>
             _NODISCARD constexpr auto operator()(_Rng&& _Range) const noexcept(