[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

27

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

25

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

61–71

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

27

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

61–71

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

27

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

27

__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/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_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/bind_back.h> // TODO: Remove this if it gets added to <functional>
+
+#include <functional>
+#include <cassert>
+#include <tuple>
+#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_backable {
+  template <class ...LocalArgs>
+  static auto test(int)
+      -> 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 {
+  NotCopyMove() = delete;
+  NotCopyMove(const NotCopyMove&) = delete;
+  NotCopyMove(NotCopyMove&&) = delete;
+  template <class ...Args>
+  void operator()(Args&& ...) const { }
+};
+
+struct NonConstCopyConstructible {
+  explicit NonConstCopyConstructible() {}
+  NonConstCopyConstructible(NonConstCopyConstructible&) {}
+};
+
+struct MoveConstructible {
+  explicit MoveConstructible() {}
+  MoveConstructible(MoveConstructible&&) {}
+};
+
+struct MakeTuple {
+  template <class ...Args>
+  constexpr auto operator()(Args&& ...args) const {
+    return std::make_tuple(std::forward<Args>(args)...);
+  }
+};
+
+template <int X>
+struct Elem {
+  template <int Y>
+  constexpr bool operator==(Elem<Y> const&) const
+  { return X == Y; }
+};
+
+constexpr bool test() {
+  // Bind arguments, call without arguments
+  {
+    {
+      auto f = std::__bind_back(MakeTuple{});
+      assert(f() == std::make_tuple());
+    }
+    {
+      auto f = std::__bind_back(MakeTuple{}, Elem<1>{});
+      assert(f() == std::make_tuple(Elem<1>{}));
+    }
+    {
+      auto f = std::__bind_back(MakeTuple{}, Elem<1>{}, Elem<2>{});
+      assert(f() == std::make_tuple(Elem<1>{}, Elem<2>{}));
+    }
+    {
+      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_back(MakeTuple{});
+      assert(f(Elem<1>{}) == std::make_tuple(Elem<1>{}));
+    }
+    {
+      auto f = std::__bind_back(MakeTuple{});
+      assert(f(Elem<1>{}, Elem<2>{}) == std::make_tuple(Elem<1>{}, Elem<2>{}));
+    }
+    {
+      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_back(MakeTuple{}, Elem<1>{});
+      assert(f(Elem<10>{}) == std::make_tuple(Elem<10>{}, Elem<1>{}));
+    }
+    {
+      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_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_back(MakeTuple{}, Elem<1>{});
+      assert(f(Elem<10>{}, Elem<11>{}) == std::make_tuple(Elem<10>{}, Elem<11>{}, Elem<1>{}));
+    }
+    {
+      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_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_back(add, m, n);
+    assert(a() == 3);
+
+    auto b = std::__bind_back(addN, m, n, m, m, m, m);
+    assert(b() == 7);
+
+    auto c = std::__bind_back(addN, n, m);
+    assert(c(1, 1, 1, 1) == 7);
+
+    auto f = std::__bind_back(add, n);
+    assert(f(3) == 5);
+
+    auto g = std::__bind_back(add, n, 1);
+    assert(g() == 3);
+
+    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 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_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_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_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_back(wasCopied, info);
+      assert(copied());
+    }
+
+    {
+      auto wasMoved = [](CopyMoveInfo info) {
+        return info.copy_kind == CopyMoveInfo::move;
+      };
+      CopyMoveInfo 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_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_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_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_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_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_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_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_back(F{}, T{}));
+      static_assert(!std::is_invocable_v<X>);
+    }
+  }
+
+  // Test properties of the constructor of the unspecified-type returned by __bind_back.
+  {
+    {
+      MoveOnlyCallable value(true);
+      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);
+
+      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));
+    }
+    {
+      CopyCallable value(true);
+      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);
+
+      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_back(std::move(value), 1);
+      assert(!ret());
+      assert(ret2());
+      assert(ret2(1, 2, 3));
+    }
+    {
+      CopyAssignableWrapper value(true);
+      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_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_back 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);
+
+    static_assert(!std::is_constructible_v<NotCopyMove, NotCopyMove&>);
+    static_assert(!std::is_move_constructible_v<NotCopyMove>);
+    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_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_backable<decltype(takeAnything), NonConstCopyConstructible&>::value);
+    static_assert(!is_bind_backable<decltype(takeAnything), NonConstCopyConstructible>::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/compose.h>
+#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;
+}