[libc++] Add the __bind_back and __compose helpers

[ldionne]

Summary

Those are going to be used to implement range adaptors,
see D107098 for details.

[• Quuxplusone]

Marking "request changes" so it shows up correctly in queues; but there's nothing big or urgent among my comments. Just consider enabling in C++14 mode, and (almost certainly IMHO) include the new files in <functional>.

libcxx/include/__functional/bind_back.h

28

Could this be > 11?
Could it be > 11 if you used _VSTD::__invoke instead of _VSTD::invoke?
(Besides just feeling nicer, keeping our dependencies minimal might one day help us clean up old code faster. As soon as we drop support for C++11, the whole #if goes away. Whereas if you make it depend on C++20, then we have to keep the #if in place for another 9 years until we drop support for C++17.)

libcxx/include/__functional/compose.h

26

Same here: could this be > 11?

libcxx/test/libcxx/utilities/function.objects/func.bind.partial/bind_back.pass.cpp

9

If you do enable __bind_back back to C++14, then this line will need to change and you'll need to use more ::value and less _v in this test.

20

What's the ruling on whether <foo> should include <__foo/internal_detail.h>? I know when we were originally debating the micro-headers, the idea was floated (but not necessarily agreed upon or even remarked upon) that <foo> should eventually be a simple mechanical listing of all <__foo/*.h>, i.e., if any <__foo/internal_detail.h> were missing from <foo>, we'd call that a bug.
This also applies to D107584: Should <concepts> include <__concepts/boolean_testable.h>? Should it include <__concepts/class_or_enum.h>? Right now I've answered "yes" to both, following what seems like precedent:

• <algorithm> includes <__algorithm/comp_ref_type.h> and <__algorithm/half_positive.h>;
• <memory> includes <__memory/compressed_pair.h>;
• <iterator> includes <__iterator/wrap_iter.h>.

If this is enough precedent for you, I think we should adopt it as official (unwritten) policy and this TODO should just get DONE. :)

326–333

Nit: You could flip these around:

auto ret = std::__bind_back(std::move(value), 1);
using RetT = decltype(ret);
static_assert( std::is_move_constructible<RetT>::value);  // etc.

384

Nit: Lines 386–390 are about whether the unspecified type's operator() is SFINAE-friendly.
Lines 394–406 are about whether the std::__bind_back function itself is SFINAE-friendly.
Tests for both are needed and good, of course; the comment is just a little icky to conflate them.

libcxx/test/libcxx/utilities/function.objects/func.bind.partial/compose.pass.cpp

62–72

Maybe worth testing some ref-qualified member functions too?
I notice we're not testing any of the perfect-forwarding-call-wrapper stuff here; e.g. we're never checking whether std::move(c) is invocable; nor whether it's not invocable when F2 is not move-invocable; etc. etc. That lack may be intentional, given that we have older tests for perfect-forwarding-call-wrapper stuff elsewhere in the test suite.

[ldionne]

Address review comments except bumping the required Standard.

libcxx/include/__functional/bind_back.h

28

I would agree because of the "dropping #ifs faster" story, but I think the benefit of using standard facilities (i.e. invoke instead of __invoke) outweighs that. WDYT?

libcxx/test/libcxx/utilities/function.objects/func.bind.partial/bind_back.pass.cpp

9

There isn't a huge benefit in doing this, since if Barry's paper gets in, bind_back would be enabled in C++20 (or 23) only. I'd basically rename it from __bind_back to bind_back and expose it publicly.

20

Sold, let's mechanically include everything. I will still include __functional/compose.h in the compose.pass.cpp test, since there's no plan to make it part of <functional> in the spec. I'll still include it in <functional> just for consistency, but I think it's better to include the minimal header if we're testing a pure implementation detail.

libcxx/test/libcxx/utilities/function.objects/func.bind.partial/compose.pass.cpp

62–72

Yes, it is intentional. I think I should actually put it in a test that is specific to __perfect_forward, but I'm on the fence because I don't want to have the tests in three places once bind_back makes it to the standard (bind_front, bind_back and __perfect_forward).

[• Quuxplusone]

libcxx/include/__functional/bind_back.h

28

I see cost-but-no-benefit to using _VSTD::invoke over _VSTD::__invoke. We have __invoke precisely so that we can use it in places where invoke wouldn't have been available until C++17. Also invoke is heavier-weight than __invoke; we'd rather use __invoke than invoke throughout the library.

libcxx/test/libcxx/utilities/function.objects/func.bind.partial/bind_back.pass.cpp

9

I doubt bind_back would be "DR'ed" back to C++20 at this point — but that doesn't stop libc++ from supporting it in C++20 anyway. Leaving __bind_back untested in '14 and '17 SGTM.

[ldionne]

Try to fix the modules build

libcxx/include/__functional/bind_back.h

28

__perfect_forward uses is_invocable, the wording for bind_front uses std::invoke, and so does the wording for bind_back in the paper. It just feels better to use something that everybody knows the semantics of at first glance (std::invoke) over something that might or might not be exactly what you'd expect (you can't know without looking). I think that's the primary reason why I find it easier to understand what's going on when std::invoke is used over __invoke. IMO, we should strive to use standard APIs when we can and when it makes sense to do that, instead of using internal variants of those.

[zoecarver]

LGTM. Thanks!

libcxx/include/CMakeLists.txt

set(files
   __debug
   __errc
   __format/format_error.h
   __format/format_parse_context.h
   __function_like.h
   __functional_base
   __functional/binary_function.h
   __functional/binary_negate.h
+  __functional/bind_back.h
   __functional/bind_front.h
   __functional/bind.h
   __functional/binder1st.h
   __functional/binder2nd.h
+  __functional/compose.h
   __functional/default_searcher.h
   __functional/function.h
   __functional/hash.h
   __functional/identity.h
   __functional/invoke.h
   __functional/is_transparent.h
   __functional/mem_fn.h
   __functional/mem_fun_ref.h

libcxx/include/__functional/bind_back.h

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___FUNCTIONAL_BIND_BACK_H
+#define _LIBCPP___FUNCTIONAL_BIND_BACK_H
+
+#include <__config>
+#include <__functional/invoke.h>
+#include <__functional/perfect_forward.h>
+#include <__utility/forward.h>
+#include <__utility/integer_sequence.h>
+#include <tuple>
+#include <type_traits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER > 17
+
+template <size_t _NBound, class = make_index_sequence<_NBound>>
+struct __bind_back_op;
+
+template <size_t _NBound, size_t ..._Ip>
+struct __bind_back_op<_NBound, index_sequence<_Ip...>> {
+    template <class _Fn, class _Bound, class ..._Args>
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr auto operator()(_Fn&& __f, _Bound&& __bound, _Args&& ...__args) const
+        noexcept(noexcept(_VSTD::invoke(_VSTD::forward<_Fn>(__f), _VSTD::forward<_Args>(__args)..., _VSTD::get<_Ip>(_VSTD::forward<_Bound>(__bound))...)))
+        -> decltype(      _VSTD::invoke(_VSTD::forward<_Fn>(__f), _VSTD::forward<_Args>(__args)..., _VSTD::get<_Ip>(_VSTD::forward<_Bound>(__bound))...))
+        { return          _VSTD::invoke(_VSTD::forward<_Fn>(__f), _VSTD::forward<_Args>(__args)..., _VSTD::get<_Ip>(_VSTD::forward<_Bound>(__bound))...); }
+};
+
+template <class _Fn, class _BoundArgs>
+struct __bind_back_t : __perfect_forward<__bind_back_op<tuple_size_v<_BoundArgs>>, _Fn, _BoundArgs> {
+    using __perfect_forward<__bind_back_op<tuple_size_v<_BoundArgs>>, _Fn, _BoundArgs>::__perfect_forward;
+};
+
+template <class _Fn, class ..._Args, class = _EnableIf<
+    _And<
+        is_constructible<decay_t<_Fn>, _Fn>,
+        is_move_constructible<decay_t<_Fn>>,
+        is_constructible<decay_t<_Args>, _Args>...,
+        is_move_constructible<decay_t<_Args>>...
+    >::value
+>>
+_LIBCPP_HIDE_FROM_ABI
+constexpr auto __bind_back(_Fn&& __f, _Args&&... __args)
+    noexcept(noexcept(__bind_back_t<decay_t<_Fn>, tuple<decay_t<_Args>...>>(_VSTD::forward<_Fn>(__f), _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...))))
+    -> decltype(      __bind_back_t<decay_t<_Fn>, tuple<decay_t<_Args>...>>(_VSTD::forward<_Fn>(__f), _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...)))
+    { return          __bind_back_t<decay_t<_Fn>, tuple<decay_t<_Args>...>>(_VSTD::forward<_Fn>(__f), _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...)); }
+
+#endif // _LIBCPP_STD_VER > 17
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___FUNCTIONAL_BIND_BACK_H

libcxx/include/__functional/compose.h

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___FUNCTIONAL_COMPOSE_H
+#define _LIBCPP___FUNCTIONAL_COMPOSE_H
+
+#include <__config>
+#include <__functional/invoke.h>
+#include <__functional/perfect_forward.h>
+#include <__utility/forward.h>
+#include <type_traits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER > 17
+
+struct __compose_op {
+    template<class _Fn1, class _Fn2, class ..._Args>
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr auto operator()(_Fn1&& __f1, _Fn2&& __f2, _Args&&... __args) const
+        noexcept(noexcept(_VSTD::invoke(_VSTD::forward<_Fn1>(__f1), _VSTD::invoke(_VSTD::forward<_Fn2>(__f2), _VSTD::forward<_Args>(__args)...))))
+        -> decltype(      _VSTD::invoke(_VSTD::forward<_Fn1>(__f1), _VSTD::invoke(_VSTD::forward<_Fn2>(__f2), _VSTD::forward<_Args>(__args)...)))
+        { return          _VSTD::invoke(_VSTD::forward<_Fn1>(__f1), _VSTD::invoke(_VSTD::forward<_Fn2>(__f2), _VSTD::forward<_Args>(__args)...)); }
+};
+
+template <class _Fn1, class _Fn2>
+struct __compose_t : __perfect_forward<__compose_op, _Fn1, _Fn2> {
+    using __perfect_forward<__compose_op, _Fn1, _Fn2>::__perfect_forward;
+};
+
+template <class _Fn1, class _Fn2>
+_LIBCPP_HIDE_FROM_ABI
+constexpr auto __compose(_Fn1&& __f1, _Fn2&& __f2)
+    noexcept(noexcept(__compose_t<decay_t<_Fn1>, decay_t<_Fn2>>(_VSTD::forward<_Fn1>(__f1), _VSTD::forward<_Fn2>(__f2))))
+    -> decltype(      __compose_t<decay_t<_Fn1>, decay_t<_Fn2>>(_VSTD::forward<_Fn1>(__f1), _VSTD::forward<_Fn2>(__f2)))
+    { return          __compose_t<decay_t<_Fn1>, decay_t<_Fn2>>(_VSTD::forward<_Fn1>(__f1), _VSTD::forward<_Fn2>(__f2)); }
+
+#endif // _LIBCPP_STD_VER > 17
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___FUNCTIONAL_COMPOSE_H

libcxx/include/functional

 
 */
 
 #include <__algorithm/search.h>
 #include <__config>
 #include <__debug>
 #include <__functional/binary_function.h> // TODO: deprecate
 #include <__functional/binary_negate.h>
+#include <__functional/bind_back.h>
 #include <__functional/bind_front.h>
 #include <__functional/bind.h>
 #include <__functional/binder1st.h>
 #include <__functional/binder2nd.h>
+#include <__functional/compose.h>
 #include <__functional/default_searcher.h>
 #include <__functional/function.h>
 #include <__functional/hash.h>
 #include <__functional/identity.h>
 #include <__functional/invoke.h>
 #include <__functional/mem_fn.h> // TODO: deprecate
 #include <__functional/mem_fun_ref.h>
 #include <__functional/not_fn.h>

libcxx/include/module.modulemap

module std [system] {
   module functional {
     header "functional"
     export *
 
     module __functional {
       module binary_function            { private header "__functional/binary_function.h" }
       module binary_negate              { private header "__functional/binary_negate.h" }
       module bind                       { private header "__functional/bind.h" }
+      module bind_back                  { private header "__functional/bind_back.h" }
       module bind_front                 { private header "__functional/bind_front.h" }
       module binder1st                  { private header "__functional/binder1st.h" }
       module binder2nd                  { private header "__functional/binder2nd.h" }
+      module compose                    { private header "__functional/compose.h" }
       module default_searcher           { private header "__functional/default_searcher.h" }
       module function                   { private header "__functional/function.h" }
       module hash                       { private header "__functional/hash.h" }
       module identity                   { private header "__functional/identity.h" }
-      module is_transparent             { private header "__functional/is_transparent.h" }
       module invoke                     { private header "__functional/invoke.h" }
+      module is_transparent             { private header "__functional/is_transparent.h" }
       module mem_fn                     { private header "__functional/mem_fn.h"  }
       module mem_fun_ref                { private header "__functional/mem_fun_ref.h"  }
       module not_fn                     { private header "__functional/not_fn.h" }
       module operations                 { private header "__functional/operations.h" }
       module perfect_forward            { private header "__functional/perfect_forward.h" }
       module pointer_to_binary_function { private header "__functional/pointer_to_binary_function.h" }
       module pointer_to_unary_function  { private header "__functional/pointer_to_unary_function.h" }
       module ranges_operations          { private header "__functional/ranges_operations.h" }

libcxx/test/libcxx/diagnostics/detail.headers/functional/bind_back.module.verify.cpp

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__functional/bind_back.h'}}
+#include <__functional/bind_back.h>

libcxx/test/libcxx/diagnostics/detail.headers/functional/compose.module.verify.cpp

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__functional/compose.h'}}
+#include <__functional/compose.h>

libcxx/test/libcxx/utilities/function.objects/func.bind.partial/bind_back.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 // functional
 
 // template <class F, class... Args>
-// constexpr unspecified bind_front(F&&, Args&&...);
+// constexpr unspecified __bind_back(F&&, Args&&...);
+
+// This isn't part of the standard, however we use it internally and there is a
+// chance that it will be added to the standard, so we implement those tests
+// as-if it were part of the spec.
 
 #include <functional>
 #include <cassert>
 #include <tuple>
-#include <type_traits>
 #include <utility>
 
 #include "callable_types.h"
 #include "test_macros.h"
 
 struct CopyMoveInfo {
   enum { none, copy, move } copy_kind;
 
   constexpr CopyMoveInfo() : copy_kind(none) {}
   constexpr CopyMoveInfo(CopyMoveInfo const&) : copy_kind(copy) {}
   constexpr CopyMoveInfo(CopyMoveInfo&&) : copy_kind(move) {}
 };
 
 template <class ...Args>
-struct is_bind_frontable {
+struct is_bind_backable {
   template <class ...LocalArgs>
   static auto test(int)
-      -> decltype((void)std::bind_front(std::declval<LocalArgs>()...), std::true_type());
+      -> decltype((void)std::__bind_back(std::declval<LocalArgs>()...), std::true_type());
 
   template <class...>
   static std::false_type test(...);
 
   static constexpr bool value = decltype(test<Args...>(0))::value;
 };
 
 struct NotCopyMove {
struct Elem {
   constexpr bool operator==(Elem<Y> const&) const
   { return X == Y; }
 };
 
 constexpr bool test() {
   // Bind arguments, call without arguments
   {
     {
-      auto f = std::bind_front(MakeTuple{});
+      auto f = std::__bind_back(MakeTuple{});
       assert(f() == std::make_tuple());
     }
     {
-      auto f = std::bind_front(MakeTuple{}, Elem<1>{});
+      auto f = std::__bind_back(MakeTuple{}, Elem<1>{});
       assert(f() == std::make_tuple(Elem<1>{}));
     }
     {
-      auto f = std::bind_front(MakeTuple{}, Elem<1>{}, Elem<2>{});
+      auto f = std::__bind_back(MakeTuple{}, Elem<1>{}, Elem<2>{});
       assert(f() == std::make_tuple(Elem<1>{}, Elem<2>{}));
     }
     {
-      auto f = std::bind_front(MakeTuple{}, Elem<1>{}, Elem<2>{}, Elem<3>{});
+      auto f = std::__bind_back(MakeTuple{}, Elem<1>{}, Elem<2>{}, Elem<3>{});
       assert(f() == std::make_tuple(Elem<1>{}, Elem<2>{}, Elem<3>{}));
     }
   }
 
   // Bind no arguments, call with arguments
   {
     {
-      auto f = std::bind_front(MakeTuple{});
+      auto f = std::__bind_back(MakeTuple{});
       assert(f(Elem<1>{}) == std::make_tuple(Elem<1>{}));
     }
     {
-      auto f = std::bind_front(MakeTuple{});
+      auto f = std::__bind_back(MakeTuple{});
       assert(f(Elem<1>{}, Elem<2>{}) == std::make_tuple(Elem<1>{}, Elem<2>{}));
     }
     {
-      auto f = std::bind_front(MakeTuple{});
+      auto f = std::__bind_back(MakeTuple{});
       assert(f(Elem<1>{}, Elem<2>{}, Elem<3>{}) == std::make_tuple(Elem<1>{}, Elem<2>{}, Elem<3>{}));
     }
   }
 
   // Bind arguments, call with arguments
   {
     {
-      auto f = std::bind_front(MakeTuple{}, Elem<1>{});
-      assert(f(Elem<10>{}) == std::make_tuple(Elem<1>{}, Elem<10>{}));
+      auto f = std::__bind_back(MakeTuple{}, Elem<1>{});
+      assert(f(Elem<10>{}) == std::make_tuple(Elem<10>{}, Elem<1>{}));
     }
     {
-      auto f = std::bind_front(MakeTuple{}, Elem<1>{}, Elem<2>{});
-      assert(f(Elem<10>{}) == std::make_tuple(Elem<1>{}, Elem<2>{}, Elem<10>{}));
+      auto f = std::__bind_back(MakeTuple{}, Elem<1>{}, Elem<2>{});
+      assert(f(Elem<10>{}) == std::make_tuple(Elem<10>{}, Elem<1>{}, Elem<2>{}));
     }
     {
-      auto f = std::bind_front(MakeTuple{}, Elem<1>{}, Elem<2>{}, Elem<3>{});
-      assert(f(Elem<10>{}) == std::make_tuple(Elem<1>{}, Elem<2>{}, Elem<3>{}, Elem<10>{}));
+      auto f = std::__bind_back(MakeTuple{}, Elem<1>{}, Elem<2>{}, Elem<3>{});
+      assert(f(Elem<10>{}) == std::make_tuple(Elem<10>{}, Elem<1>{}, Elem<2>{}, Elem<3>{}));
     }
 
     {
-      auto f = std::bind_front(MakeTuple{}, Elem<1>{});
-      assert(f(Elem<10>{}, Elem<11>{}) == std::make_tuple(Elem<1>{}, Elem<10>{}, Elem<11>{}));
+      auto f = std::__bind_back(MakeTuple{}, Elem<1>{});
+      assert(f(Elem<10>{}, Elem<11>{}) == std::make_tuple(Elem<10>{}, Elem<11>{}, Elem<1>{}));
     }
     {
-      auto f = std::bind_front(MakeTuple{}, Elem<1>{}, Elem<2>{});
-      assert(f(Elem<10>{}, Elem<11>{}) == std::make_tuple(Elem<1>{}, Elem<2>{}, Elem<10>{}, Elem<11>{}));
+      auto f = std::__bind_back(MakeTuple{}, Elem<1>{}, Elem<2>{});
+      assert(f(Elem<10>{}, Elem<11>{}) == std::make_tuple(Elem<10>{}, Elem<11>{}, Elem<1>{}, Elem<2>{}));
     }
     {
-      auto f = std::bind_front(MakeTuple{}, Elem<1>{}, Elem<2>{}, Elem<3>{});
-      assert(f(Elem<10>{}, Elem<11>{}) == std::make_tuple(Elem<1>{}, Elem<2>{}, Elem<3>{}, Elem<10>{}, Elem<11>{}));
+      auto f = std::__bind_back(MakeTuple{}, Elem<1>{}, Elem<2>{}, Elem<3>{});
+      assert(f(Elem<10>{}, Elem<11>{}) == std::make_tuple(Elem<10>{}, Elem<11>{}, Elem<1>{}, Elem<2>{}, Elem<3>{}));
     }
   }
 
   // Basic tests with fundamental types
   {
     int n = 2;
     int m = 1;
     auto add = [](int x, int y) { return x + y; };
     auto addN = [](int a, int b, int c, int d, int e, int f) {
       return a + b + c + d + e + f;
     };
 
-    auto a = std::bind_front(add, m, n);
+    auto a = std::__bind_back(add, m, n);
     assert(a() == 3);
 
-    auto b = std::bind_front(addN, m, n, m, m, m, m);
+    auto b = std::__bind_back(addN, m, n, m, m, m, m);
     assert(b() == 7);
 
-    auto c = std::bind_front(addN, n, m);
+    auto c = std::__bind_back(addN, n, m);
     assert(c(1, 1, 1, 1) == 7);
 
-    auto f = std::bind_front(add, n);
+    auto f = std::__bind_back(add, n);
     assert(f(3) == 5);
 
-    auto g = std::bind_front(add, n, 1);
+    auto g = std::__bind_back(add, n, 1);
     assert(g() == 3);
 
-    auto h = std::bind_front(addN, 1, 1, 1);
+    auto h = std::__bind_back(addN, 1, 1, 1);
     assert(h(2, 2, 2) == 9);
   }
 
   // Make sure we don't treat std::reference_wrapper specially.
   {
-    auto add = [](std::reference_wrapper<int> a, std::reference_wrapper<int> b) {
-      return a.get() + b.get();
+    auto sub = [](std::reference_wrapper<int> a, std::reference_wrapper<int> b) {
+      return a.get() - b.get();
     };
     int i = 1, j = 2;
-    auto f = std::bind_front(add, std::ref(i));
-    assert(f(std::ref(j)) == 3);
+    auto f = std::__bind_back(sub, std::ref(i));
+    assert(f(std::ref(j)) == 2 - 1);
   }
 
   // Make sure we can call a function that's a pointer to a member function.
   {
     struct MemberFunction {
       constexpr bool foo(int, int) { return true; }
     };
     MemberFunction value;
-    auto fn = std::bind_front(&MemberFunction::foo, value, 0);
-    assert(fn(0));
+    auto fn = std::__bind_back(&MemberFunction::foo, 0, 0);
+    assert(fn(value));
   }
 
   // Make sure that we copy the bound arguments into the unspecified-type.
   {
     auto add = [](int x, int y) { return x + y; };
     int n = 2;
-    auto i = std::bind_front(add, n, 1);
+    auto i = std::__bind_back(add, n, 1);
     n = 100;
     assert(i() == 3);
   }
 
   // Make sure we pass the bound arguments to the function object
   // with the right value category.
   {
     {
       auto wasCopied = [](CopyMoveInfo info) {
         return info.copy_kind == CopyMoveInfo::copy;
       };
       CopyMoveInfo info;
-      auto copied = std::bind_front(wasCopied, info);
+      auto copied = std::__bind_back(wasCopied, info);
       assert(copied());
     }
 
     {
       auto wasMoved = [](CopyMoveInfo info) {
         return info.copy_kind == CopyMoveInfo::move;
       };
       CopyMoveInfo info;
-      auto moved = std::bind_front(wasMoved, info);
+      auto moved = std::__bind_back(wasMoved, info);
       assert(std::move(moved)());
     }
   }
 
   // Make sure we call the correctly cv-ref qualified operator() based on the
-  // value category of the bind_front unspecified-type.
+  // value category of the __bind_back unspecified-type.
   {
     struct F {
       constexpr int operator()() & { return 1; }
       constexpr int operator()() const& { return 2; }
       constexpr int operator()() && { return 3; }
       constexpr int operator()() const&& { return 4; }
     };
-    auto x = std::bind_front(F{});
+    auto x = std::__bind_back(F{});
     using X = decltype(x);
     assert(static_cast<X&>(x)() == 1);
     assert(static_cast<X const&>(x)() == 2);
     assert(static_cast<X&&>(x)() == 3);
     assert(static_cast<X const&&>(x)() == 4);
   }
 
-  // Make sure the bind_front unspecified-type is NOT invocable when the call would select a
+  // Make sure the __bind_back unspecified-type is NOT invocable when the call would select a
   // differently-qualified operator().
   //
   // For example, if the call to `operator()() &` is ill-formed, the call to the unspecified-type
   // should be ill-formed and not fall back to the `operator()() const&` overload.
   {
     // Make sure we delete the & overload when the underlying call isn't valid
     {
       struct F {
         void operator()() & = delete;
         void operator()() const&;
         void operator()() &&;
         void operator()() const&&;
       };
-      using X = decltype(std::bind_front(F{}));
+      using X = decltype(std::__bind_back(F{}));
       static_assert(!std::is_invocable_v<X&>);
       static_assert( std::is_invocable_v<X const&>);
       static_assert( std::is_invocable_v<X>);
       static_assert( std::is_invocable_v<X const>);
     }
 
     // There's no way to make sure we delete the const& overload when the underlying call isn't valid,
     // so we can't check this one.
 
     // Make sure we delete the && overload when the underlying call isn't valid
     {
       struct F {
         void operator()() &;
         void operator()() const&;
         void operator()() && = delete;
         void operator()() const&&;
       };
-      using X = decltype(std::bind_front(F{}));
+      using X = decltype(std::__bind_back(F{}));
       static_assert( std::is_invocable_v<X&>);
       static_assert( std::is_invocable_v<X const&>);
       static_assert(!std::is_invocable_v<X>);
       static_assert( std::is_invocable_v<X const>);
     }
 
     // Make sure we delete the const&& overload when the underlying call isn't valid
     {
       struct F {
         void operator()() &;
         void operator()() const&;
         void operator()() &&;
         void operator()() const&& = delete;
       };
-      using X = decltype(std::bind_front(F{}));
+      using X = decltype(std::__bind_back(F{}));
       static_assert( std::is_invocable_v<X&>);
       static_assert( std::is_invocable_v<X const&>);
       static_assert( std::is_invocable_v<X>);
       static_assert(!std::is_invocable_v<X const>);
     }
   }
 
   // Some examples by Tim Song
   {
     {
       struct T { };
       struct F {
         void operator()(T&&) const &;
         void operator()(T&&) && = delete;
       };
-      using X = decltype(std::bind_front(F{}));
+      using X = decltype(std::__bind_back(F{}));
       static_assert(!std::is_invocable_v<X, T>);
     }
 
     {
       struct T { };
       struct F {
         void operator()(T const&) const;
         void operator()(T&&) const = delete;
       };
-      using X = decltype(std::bind_front(F{}, T{}));
+      using X = decltype(std::__bind_back(F{}, T{}));
       static_assert(!std::is_invocable_v<X>);
     }
   }
 
-  // Test properties of the constructor of the unspecified-type returned by bind_front.
+  // Test properties of the constructor of the unspecified-type returned by __bind_back.
   {
     {
       MoveOnlyCallable value(true);
-      auto ret = std::bind_front(std::move(value), 1);
+      auto ret = std::__bind_back(std::move(value), 1);
       assert(ret());
       assert(ret(1, 2, 3));
 
       auto ret1 = std::move(ret);
       assert(!ret());
       assert(ret1());
       assert(ret1(1, 2, 3));
 
       using RetT = decltype(ret);
       static_assert( std::is_move_constructible<RetT>::value);
       static_assert(!std::is_copy_constructible<RetT>::value);
       static_assert(!std::is_move_assignable<RetT>::value);
       static_assert(!std::is_copy_assignable<RetT>::value);
     }
     {
       CopyCallable value(true);
-      auto ret = std::bind_front(value, 1);
+      auto ret = std::__bind_back(value, 1);
       assert(ret());
       assert(ret(1, 2, 3));
 
       auto ret1 = std::move(ret);
       assert(ret1());
       assert(ret1(1, 2, 3));
 
-      auto ret2 = std::bind_front(std::move(value), 1);
+      auto ret2 = std::__bind_back(std::move(value), 1);
       assert(!ret());
       assert(ret2());
       assert(ret2(1, 2, 3));
 
       using RetT = decltype(ret);
       static_assert( std::is_move_constructible<RetT>::value);
       static_assert( std::is_copy_constructible<RetT>::value);
       static_assert(!std::is_move_assignable<RetT>::value);
       static_assert(!std::is_copy_assignable<RetT>::value);
     }
     {
       CopyAssignableWrapper value(true);
-      using RetT = decltype(std::bind_front(value, 1));
+      using RetT = decltype(std::__bind_back(value, 1));
 
       static_assert(std::is_move_constructible<RetT>::value);
       static_assert(std::is_copy_constructible<RetT>::value);
       static_assert(std::is_move_assignable<RetT>::value);
       static_assert(std::is_copy_assignable<RetT>::value);
     }
     {
       MoveAssignableWrapper value(true);
-      using RetT = decltype(std::bind_front(std::move(value), 1));
+      using RetT = decltype(std::__bind_back(std::move(value), 1));
 
       static_assert( std::is_move_constructible<RetT>::value);
       static_assert(!std::is_copy_constructible<RetT>::value);
       static_assert( std::is_move_assignable<RetT>::value);
       static_assert(!std::is_copy_assignable<RetT>::value);
     }
   }
 
-  // Make sure bind_front is SFINAE friendly
+  // Make sure __bind_back is SFINAE friendly
   {
-    using T = decltype(std::bind_front(std::declval<int(*)(int, int)>(), 1));
-    static_assert(!std::is_invocable<T>::value);
-    static_assert( std::is_invocable<T, int>::value);
-    static_assert(!std::is_invocable<T, void*>::value);
-    static_assert(!std::is_invocable<T, int, int>::value);
-
     static_assert(!std::is_constructible_v<NotCopyMove, NotCopyMove&>);
     static_assert(!std::is_move_constructible_v<NotCopyMove>);
-    static_assert(!is_bind_frontable<NotCopyMove>::value);
-    static_assert(!is_bind_frontable<NotCopyMove&>::value);
+    static_assert(!is_bind_backable<NotCopyMove>::value);
+    static_assert(!is_bind_backable<NotCopyMove&>::value);
 
     auto takeAnything = [](auto&& ...) { };
     static_assert(!std::is_constructible_v<MoveConstructible, MoveConstructible&>);
     static_assert( std::is_move_constructible_v<MoveConstructible>);
-    static_assert( is_bind_frontable<decltype(takeAnything), MoveConstructible>::value);
-    static_assert(!is_bind_frontable<decltype(takeAnything), MoveConstructible&>::value);
+    static_assert( is_bind_backable<decltype(takeAnything), MoveConstructible>::value);
+    static_assert(!is_bind_backable<decltype(takeAnything), MoveConstructible&>::value);
 
     static_assert( std::is_constructible_v<NonConstCopyConstructible, NonConstCopyConstructible&>);
     static_assert(!std::is_move_constructible_v<NonConstCopyConstructible>);
-    static_assert(!is_bind_frontable<decltype(takeAnything), NonConstCopyConstructible&>::value);
-    static_assert(!is_bind_frontable<decltype(takeAnything), NonConstCopyConstructible>::value);
+    static_assert(!is_bind_backable<decltype(takeAnything), NonConstCopyConstructible&>::value);
+    static_assert(!is_bind_backable<decltype(takeAnything), NonConstCopyConstructible>::value);
+  }
+
+  // Make sure bind_back's unspecified type's operator() is SFINAE-friendly
+  {
+    using T = decltype(std::__bind_back(std::declval<int(*)(int, int)>(), 1));
+    static_assert(!std::is_invocable<T>::value);
+    static_assert( std::is_invocable<T, int>::value);
+    static_assert(!std::is_invocable<T, void*>::value);
+    static_assert(!std::is_invocable<T, int, int>::value);
   }
 
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/libcxx/utilities/function.objects/func.bind.partial/compose.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// template <class F1, class F2>
+// constexpr unspecified __compose(F1&&, F2&&);
+
+#include <functional>
+#include <cassert>
+#include <tuple>
+#include <utility>
+
+template <int X>
+struct Elem {
+  template <int Y>
+  constexpr bool operator==(Elem<Y> const&) const
+  { return X == Y; }
+};
+
+struct F {
+  template <class ...Args>
+  constexpr auto operator()(Args&& ...args) const {
+    return std::make_tuple(Elem<888>{}, std::forward<Args>(args)...);
+  }
+};
+
+struct G {
+  template <class ...Args>
+  constexpr auto operator()(Args&& ...args) const {
+    return std::make_tuple(Elem<999>{}, std::forward<Args>(args)...);
+  }
+};
+
+constexpr bool test() {
+  F const f;
+  G const g;
+
+  {
+    auto c = std::__compose(f, g);
+    assert(c() == f(g()));
+  }
+  {
+    auto c = std::__compose(f, g);
+    assert(c(Elem<0>{}) == f(g(Elem<0>{})));
+  }
+  {
+    auto c = std::__compose(f, g);
+    assert(c(Elem<0>{}, Elem<1>{}) == f(g(Elem<0>{}, Elem<1>{})));
+  }
+  {
+    auto c = std::__compose(f, g);
+    assert(c(Elem<0>{}, Elem<1>{}, Elem<2>{}) == f(g(Elem<0>{}, Elem<1>{}, Elem<2>{})));
+  }
+
+  // Make sure we can call a function that's a pointer to a member function.
+  {
+    struct MemberFunction1 {
+      constexpr Elem<0> foo() { return {}; }
+    };
+    struct MemberFunction2 {
+      constexpr MemberFunction1 bar() { return {}; }
+    };
+    auto c = std::__compose(&MemberFunction1::foo, &MemberFunction2::bar);
+    assert(c(MemberFunction2{}) == Elem<0>{});
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/utilities/function.objects/func.bind_front/bind_front.pass.cpp

// Test properties of the constructor of the unspecified-type returned by bind_front.
       static_assert(!std::is_copy_constructible<RetT>::value);
       static_assert( std::is_move_assignable<RetT>::value);
       static_assert(!std::is_copy_assignable<RetT>::value);
     }
   }
 
   // Make sure bind_front is SFINAE friendly
   {
-    using T = decltype(std::bind_front(std::declval<int(*)(int, int)>(), 1));
-    static_assert(!std::is_invocable<T>::value);
-    static_assert( std::is_invocable<T, int>::value);
-    static_assert(!std::is_invocable<T, void*>::value);
-    static_assert(!std::is_invocable<T, int, int>::value);
-
     static_assert(!std::is_constructible_v<NotCopyMove, NotCopyMove&>);
     static_assert(!std::is_move_constructible_v<NotCopyMove>);
     static_assert(!is_bind_frontable<NotCopyMove>::value);
     static_assert(!is_bind_frontable<NotCopyMove&>::value);
 
     auto takeAnything = [](auto&& ...) { };
     static_assert(!std::is_constructible_v<MoveConstructible, MoveConstructible&>);
     static_assert( std::is_move_constructible_v<MoveConstructible>);
     static_assert( is_bind_frontable<decltype(takeAnything), MoveConstructible>::value);
     static_assert(!is_bind_frontable<decltype(takeAnything), MoveConstructible&>::value);
 
     static_assert( std::is_constructible_v<NonConstCopyConstructible, NonConstCopyConstructible&>);
     static_assert(!std::is_move_constructible_v<NonConstCopyConstructible>);
     static_assert(!is_bind_frontable<decltype(takeAnything), NonConstCopyConstructible&>::value);
     static_assert(!is_bind_frontable<decltype(takeAnything), NonConstCopyConstructible>::value);
   }
 
+  // Make sure bind_front's unspecified type's operator() is SFINAE-friendly
+  {
+    using T = decltype(std::bind_front(std::declval<int(*)(int, int)>(), 1));
+    static_assert(!std::is_invocable<T>::value);
+    static_assert( std::is_invocable<T, int>::value);
+    static_assert(!std::is_invocable<T, void*>::value);
+    static_assert(!std::is_invocable<T, int, int>::value);
+  }
+
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }