Add bind_front function (P0356R5)

[zoecarver]

Summary

Implementes P0356R5. Adds bind_front to functional.

[zoecarver]

Fix return in tests and update www.

[EricWF]

I don't believe this patch implements the perfect forwarding call wrapper requirements laid out in the paper. Take a look at the not_fn implementation as an example of this (perhaps even generalize it's implementation to be used here as well).

include/functional

2980 ↗

(On Diff #194430)

Types don't need to be qualified. Only functions calls that potentially use ADL do.

2992 ↗

(On Diff #194430)

No need to quality tuple.

[zoecarver]

After looking at not_fn, I think I can simplify this a lot.

include/functional

2992 ↗

(On Diff #194430)

Is there a better way to store the bound args?

[EricWF]

include/functional

2992 ↗

(On Diff #194430)

By "qualify tuple" I meant the _VSTD:: isn't needed

[zoecarver]

I updated this patch to use a more generalized perfect forwarding call struct. I modeled it after not_fn and got a lot of help from @EricWF. I also updated not_fn to use this more generalized struct.

I added tests similar to not_fn's tests to ensure perfect forwarding functions properly. I also generalized the structs used in those tests so I would not have to duplicate code. I think these tests cover the perfect forwarding implementation, but I can add more if needed.

[zoecarver]

include/functional

2875 ↗

(On Diff #196282)

The return type of this function is not specified, it might be beneficial to make it a constexpr (though that would require other parts of this to be updated and might not work). Thoughts?

test/std/utilities/function.objects/func.bind_front/bind_front.fail.cpp

30 ↗

(On Diff #196282)

I am unsure of how to format the fail tests.

test/std/utilities/function.objects/func.not_fn/not_fn.pass.cpp

432 ↗

(On Diff #196282)

I am not sure why this was expected to throw. I think this can simply be moved (but I might be wrong).

[zoecarver]

Fix spacing / formatting.

[mclow.lists]

More to come.

include/functional

2852 ↗

(On Diff #196377)

Formatting nit. Note how the other bits of code have three identical chunks of code, all aligned so that you could see that they were identical. Please do that here. See the code that you're replacing (lines 2815->17) for an example.

test/std/utilities/function.objects/func.bind_front/bind_front.fail.cpp

33 ↗

(On Diff #196377)

This line can be removed; if the compilation never succeeds.

36 ↗

(On Diff #196377)

This one too

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

56 ↗

(On Diff #196377)

Formatting nit. When ganging a bunch of static asserts, leave a space after the '(', so that the negations are easily visible. See test/std/utilities/meta/meta.unary/meta.unary.cat/nullptr.pass.cpp as an example.

[zoecarver]

Fix styling issues

[EricWF]

There are a couple of bugs in this patch related to the value-categories we should (A) store, and (B) initialize the storage with.
The specification specifies both cases here: http://eel.is/c++draft/func.bind.front#1

Let me know if I can help interpret that.

include/functional

2875 ↗

(On Diff #196282)

The standard library is not allowed to add constexpr as an extension.

Also the return type has nothing to do with the constexpr-ness of the function.

2809 ↗

(On Diff #196993)

Why is this different than below?

2857 ↗

(On Diff #196993)

Why does at least one argument need to be provided?

Sure, it seems silly to std::bind_front no arguments, but I don't see anything in the standard forbidding it.

2858 ↗

(On Diff #196993)

This doesn't correctly implement the value categories for the functor nor arguments.
See http://eel.is/c++draft/func.bind.front#1

The type we store is different from the types we're passed in.
The functor is decayed (std::decay) and the arguments are decayed as well, unless they're a std::reference_wrapper<T>, in which case they transform
into T&.

test/std/utilities/function.objects/func.not_fn/not_fn.pass.cpp

126 ↗

(On Diff #196993)

This doesn't seem right.

It's probably related to the bug mentioned below.

432 ↗

(On Diff #196282)

It's expected to throw because the functor must be copied or moved into the not_fn wrapper. ThrowsOnCopy doesn't have a move constructor so its copy constructor is always used.

The reason this test isn't failing anymore is because of a bug in your implementation.
You're not decaying the type of the functor before copying it into the tuple, so you're storing a reference to it instead.

test/support/callable_types.h

1 ↗

(On Diff #196993)

Missing the license header.

2 ↗

(On Diff #196993)

Missing header guards.

7 ↗

(On Diff #196993)

This needs inline now that it's in a header.

[zoecarver]

@EricWF, Thanks for the review :) I will try to apply those changes today.

include/functional

2857 ↗

(On Diff #196993)

For some reason, I thought I remembered reading something about that in the paper, but looking back at it I cannot find it. I will remove this.

2858 ↗

(On Diff #196993)

I seem to have skipped over that part, my bad. Will fix.

[zoecarver]

Update based on review:

• fix decay type
• fix move return type
• universal reference parameter args
• tests

[zoecarver]

• updates not_fn constraints
• adds constexpr
• updates perfect forwarding to be perfect
• enables constraints on bind_front and perfect forwarding wrapper
• more tests for bind_front
• fix 3184
• implement P1651

[zoecarver]

@EricWF any more comments on this?

[zoecarver]

@EricWF friendly ping.

[ldionne]

I'm not seeing any issues with the perfect forwarding anymore. This looks pretty good, with a few comments.

libcxx/include/functional

3010

Can you please throw in _LIBCPP_INLINE_VISIBILITY (and below)?

3051

If you used fold a expression like (is_move_constructible<_Bound>::value && ...), I believe you could get rid of __all_true completely.

3084

I think you need to check all the requirements at this point (from the paper):

conjunction_v<is_constructible<FD, F>, is_move_constructible<FD>, is_constructible<BoundArgs, Args>..., is_move_constructible<BoundArgs>...>

As it stands, you seem to be testing for is_constructible<FD, F> && is_move_constructible<FD> here, but you're delaying the checks for is_constructible<BoundArgs, Args> and is_move_constructible<BoundArgs> until the constructor of __perfect_forward_impl. I think you need to check everything eagerly here, or some SFINAE-able errors may become hard errors instead.

Furthermore, I would suggest going the easy way and sticking to the way the spec words it: you could just use conjunction instead of fold expressions or other clever tricks above -- this will also have the correct short-circuit behavior for evaluating the various is_constructible<BoundArgs, Args> and is_move_constructible<BoundArgs, Args> traits.

3220

Can you please drop these unrelated whitespace changes?

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

1 ↗

(On Diff #216761)

You could rename this to .verify.cpp instead since it's using clang-verify.

[zoecarver]

libcxx/include/functional

3051

I think I'm going to update this to use the following which will also allow me to get rid of __all_true:

std::is_move_constructible<std::tuple<_Bound...>>::value

3084

I think you're right. I'll update it.

[ldionne]

libcxx/include/functional

3051

To be clear, I don't think you'll need that at all anymore if you implement my suggestion of using conjunction_v below.

[zoecarver]

• Rebase and address review comments
• Add _LIBCPP_INLINE_VISIBILITY

[zoecarver]

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

198

Any ideas for types that are move constructible and aren't "self constructible" (i.e. !is_constructible_v<decay_t<T>, T>)?

[zoecarver]

• Remove rejected files and files from incorrectly applied diff

[ldionne]

A few more comments, but this is looking pretty good.

libcxx/include/functional

3089

inline is not needed here, it's a template.

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

129

Looks like a typo to me.

235

Could you instead write all the tests in a constexpr function, and call it once from main(), and once inside a static_assert? This way, we would get the full coverage for both non-constexpr and constexpr code. Like I've done in the tests of https://reviews.llvm.org/D68364.

libcxx/test/support/callable_types.h

10

TEST_CALLABLE_TYPES_H

libcxx/www/cxx2a_status.html

111 ↗

(On Diff #292851)

Please mark it complete as of 12.0. Same below.

[ldionne]

libcxx/include/functional

3066

inline not needed.

This should also be constexpr, but I guess we should leave fixing that to whenever we implement the paper that marked it as constexpr.

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

14

This should be marked as constexpr.

198

You mean a type that satisfies: is_constructible_v<decay_t<T>, T&&> && !is_constructible_v<decay_t<T>, T>? No, I can't think of anything.

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

14

constexpr

[zoecarver]

• Make all constructors and members in callable_types constexpr.
• Make invoke use __invoke_constexpr after C++17.
• Update bind_front.pass.cpp to run all tests in a constexpr context as well.
• Remove inline prefix.

[zoecarver]

• constexpr -> _LIBCPP_CONSTEXPR_AFTER_CXX11 in front of invoke

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

198

OK. Do we even need the second check, then? It seems odd the paper would have it if it's redundant. But maybe it was just an oversight.

235

Good idea. Got it working but had to update invoke to be constexpr after C++17.

[zoecarver]

• Add more test cases.

[zoecarver]

@ldionne no rush, but this is ready for re-review whenever you have time.

[zoecarver]

@ldionne ping.

[curdeius]

libcxx/include/functional

2989

I guess you should add tests for constexpr to https://github.com/llvm/llvm-project/blob/master/libcxx/test/std/utilities/function.objects/func.invoke/invoke.pass.cpp.

2994–2995

Spurious #endif?

[curdeius]

It would be great if you rebased this patch to trigger current CI.

[zoecarver]

libcxx/include/functional

2989

Good point. I should probably make this a different patch.

2994–2995

I don't think so. This one corresponds to line 2977. Because of how the diff is rendered, it looks like I added this one instead of the one on 3095.

[zoecarver]

• Use new status format
• Rebase on master

[curdeius]

@zoecarver, for constexpr invoke, the paper of interest is http://wg21.link/P01065. It concerns some other functions as well, notably not_fn.

libcxx/include/functional

2989

Good point. I should probably make this a different patch.

[ldionne]

I think this looks good, but it needs to be rebased on top of main. invoke has been made constexpr by @Quuxplusone since then.

If CI passes, LGTM. Consider fixing my comment about static_assert, but it's non-blocking. You should also update the release target (it's not 12 anymore, but 13).

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

237

It's weird to call this inside static_assert, since we're already calling the whole test() inside static_assert. Is this needed at all now?

[zoecarver]

• Feature test macros
• Update to version 13
• Remove constexpr test
• Rebase off main
• Update tests as needed

[zoecarver]

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

145–146

@ldionne I did have one problem after rebasing. Because this is implemented with std::tuple, the assignment operator isn't constexpr. I see a few options here:

1. Wait to land this until we implement constexpr assignment operators for std::tuple.
2. Add the above check (is_constant_evaluated) to this test and remove it once constexpr assignment operators for std::tuple are implemented.
3. Just remove this part of the test entirely because it's not required by the standard.
4. Update std::tuple to have constexpr assignment operators (without properly implementing the paper).

[zoecarver]

• Add comments and remove unneeded assignment operators.

[• Quuxplusone]

libcxx/include/functional

3067

Remove space between > (

3087

is_move_constructible<decay_t<_Args>>... perhaps? It looks like _Args can contain lvalue-reference types, and also lvalue-reference-to-array types.

If this is really a bug I found, please add a regression test too.

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

38

These basic tests don't include any tests for rvalues, e.g. bind_front(add, m, 1).
Also I'd recommend some tests to see whether the capture is by value or by reference, e.g.

auto a = std::bind_front(add, m, 1);
m = 42;
assert(a() == 2);

109

I think the comment is wrong: nc(x) would call operator() const &, not operator() const &&, because nc would be an lvalue at that point.

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

50

Would be nice to fix all the "No newline at end of file" warnings.

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

145–146

FWIW, I vote for #3 — std::not_fn(x) isn't supposed to be assignable. It might even be user-friendly to delete its assignment operator so that libc++ users don't start relying on it and then break when they move to a different STL vendor.
Alternatively, provide and test the assignment operator but move the test into test/libcxx/utilities/ instead??

[ldionne]

I'll mark this as "requires changes" so it shows up properly in the queue.

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

145–146

Yeah, I agree with Arthur about doing (3).

[zoecarver]

libcxx/include/functional

3087

Mandates: conjunction_v<is_constructible<FD, F>, is_move_constructible<FD>, is_constructible<BoundArgs, Args>..., is_move_constructible<BoundArgs>...> shall be true.

Additionally, the bound args are decayed meaning that all the args must be move or copy constructible.

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

109

I love trying to figure out what past me was thinking when I wrote this test :P

Anyway, I think I got this from section 3.5 of the paper, so you're right, this should be const & not const &&. I'd like to think this was just a typo, but the name no_const_rvalue seems particularly incriminating in the case that I actually thought it was the latter. Anyway, I'll fix it.

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

145–146

OK. Want me to delete the assignment operators? I don't care one way or another, but it might break some people who are (unfortunately) relying on it.

[zoecarver]

• Fix based on review

[• Quuxplusone]

libcxx/include/functional

3087

Ah, I think I get it (or at least I see something I'd missed the first time around).

int a[10];
int f(int *);
auto fa = std::bind_front(f, a);

works by decaying a into an int* for storage in the closure object.

But here's an example that triggers my problem, when tested against the current patch:

struct S  {
    explicit S() { }
    S(S&);
};
S s;
void f(S&);
auto ff = std::bind_front(f, s);  // OK
auto gg = std::move(ff);  // cascading errors deep inside the template stuff

Here s is an S&, so _Args is S&, so it's true that is_move_constructible_v<_Args> even though not is_move_constructible_v<decay_t<_Args>>. I think either std::bind_front(f, s) should be ill-formed (my preference), or else it should produce a closure object with no move-constructor.

[zoecarver]

libcxx/include/functional

3087

I think you're right. This was just an oversight on my part. Because the standard specifically says to check is_move_constructible<decay_t<_Args>>.

[zoecarver]

• Properly decay args before checking is_move_constructible.

[zoecarver]

• Format bind_front test file.

[zoecarver]

• Rebase off main (somehow my last commit got added to this patch).

[zoecarver]

• Call the test function test_invocability from the main test function.

(Sorry for all the updates/emails.)

[• Quuxplusone]

LGTM; just some naming nits.

libcxx/include/functional

3002

Nit: Could you call this tuple<_Bound...> __bounds or tuple<_Bound...> __tup instead?
I was really puzzled by line 3046's

__bound(_VSTD::forward<_BoundArgs>(__bound)...) { }

for a minute.
Also nit, qualifying _VSTD:: shouldn't be necessary on tuple because it's a type, not a function.

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

233

Utter nit: invocable, not invokable ;)
but also less nitty, isn't this just testing more like is_bind_frontable? I mean you're testing that bind_front(LocalArgs...) is makable, but you're not testing that the resulting bind object is actually invocable at all, right?

libcxx/test/support/callable_types.h

187

Nit: no newline at end of file

[ldionne]

LGTM. Apply Arthur's comments and let's ship this!

[zoecarver]

Thanks!

libcxx/include/functional

3002

Thanks. Done and done. I updated __bound -> __bound_.

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

233

Fair enough. I was thinking about it more like, "is bind_front invocable" not "is the result invocable." But I think is_bind_frontable is more clear anyway, so I'll update it.

[zoecarver]

• Fix review comments

libcxx/docs/Cxx2aStatusIssuesStatus.csv

 "`3180 <https://wg21.link/LWG3180>`__","Inconsistently named return type for ``ranges::minmax_element``\ ","Kona","",""
 "`3182 <https://wg21.link/LWG3182>`__","Specification of ``Same``\  could be clearer","Kona","",""
 "","","","",""
 "`2899 <https://wg21.link/LWG2899>`__","``is_(nothrow_)move_constructible``\  and ``tuple``\ , ``optional``\  and ``unique_ptr``\ ","Cologne","",""
 "`3055 <https://wg21.link/LWG3055>`__","``path::operator+=(*single-character*)``\  misspecified","Cologne","|Complete|","7.0"
 "`3158 <https://wg21.link/LWG3158>`__","``tuple(allocator_arg_t, const Alloc&)``\  should be conditionally explicit","Cologne","",""
 "`3169 <https://wg21.link/LWG3169>`__","``ranges``\  permutation generators discard useful information","Cologne","",""
 "`3183 <https://wg21.link/LWG3183>`__","Normative permission to specialize Ranges variable templates","Cologne","",""
-"`3184 <https://wg21.link/LWG3184>`__","Inconsistencies in ``bind_front``\  wording","Cologne","",""
+"`3184 <https://wg21.link/LWG3184>`__","Inconsistencies in ``bind_front``\  wording","Cologne","|Complete|","13.0"
 "`3185 <https://wg21.link/LWG3185>`__","Uses-allocator construction functions missing ``constexpr``\  and ``noexcept``\ ","Cologne","",""
 "`3186 <https://wg21.link/LWG3186>`__","``ranges``\  removal, partition, and ``partial_sort_copy``\  algorithms discard useful information","Cologne","",""
 "`3187 <https://wg21.link/LWG3187>`__","`P0591R4 <https://wg21.link/p0591r4>`__ reverted DR 2586 fixes to ``scoped_allocator_adaptor::construct()``\ ","Cologne","",""
 "`3191 <https://wg21.link/LWG3191>`__","``std::ranges::shuffle``\  synopsis does not match algorithm definition","Cologne","",""
 "`3196 <https://wg21.link/LWG3196>`__","``std::optional<T>``\  is ill-formed is ``T``\  is an array","Cologne","|Complete|",""
 "`3198 <https://wg21.link/LWG3198>`__","Bad constraint on ``std::span::span()``\ ","Cologne","|Complete|",""
 "`3199 <https://wg21.link/LWG3199>`__","``istream >> bitset<0>``\  fails","Cologne","",""
 "`3202 <https://wg21.link/LWG3202>`__","P0318R1 was supposed to be revised","Cologne","|Complete|",""

libcxx/docs/Cxx2aStatusPaperStatus.csv

 "`P0898R3 <https://wg21.link/P0898R3>`__","LWG","Standard Library Concepts","Rapperswil","|In Progress|",""
 "`P0935R0 <https://wg21.link/P0935R0>`__","LWG","Eradicating unnecessarily explicit default constructors from the standard library","Rapperswil","|Complete|","12.0"
 "`P0941R2 <https://wg21.link/P0941R2>`__","CWG","Integrating feature-test macros into the C++ WD","Rapperswil","|In Progress|",""
 "`P1023R0 <https://wg21.link/P1023R0>`__","LWG","constexpr comparison operators for std::array","Rapperswil","|Complete|","8.0"
 "`P1025R1 <https://wg21.link/P1025R1>`__","CWG","Update The Reference To The Unicode Standard","Rapperswil","",""
 "`P1120R0 <https://wg21.link/P1120R0>`__","CWG","Consistency improvements for <=> and other comparison operators","Rapperswil","",""
 "","","","","",""
 "`P0318R1 <https://wg21.link/P0318R1>`__","LWG","unwrap_ref_decay and unwrap_reference","San Diego","|Complete|","8.0"
-"`P0356R5 <https://wg21.link/P0356R5>`__","LWG","Simplified partial function application","San Diego","* *",""
+"`P0356R5 <https://wg21.link/P0356R5>`__","LWG","Simplified partial function application","San Diego","|Complete|","13.0"
 "`P0357R3 <https://wg21.link/P0357R3>`__","LWG","reference_wrapper for incomplete types","San Diego","|Complete|","8.0"
 "`P0482R6 <https://wg21.link/P0482R6>`__","CWG","char8_t: A type for UTF-8 characters and strings","San Diego","|In Progress|",""
 "`P0487R1 <https://wg21.link/P0487R1>`__","LWG","Fixing ``operator>>(basic_istream&, CharT*)``\  (LWG 2499)","San Diego","|Complete|","8.0"
 "`P0591R4 <https://wg21.link/P0591R4>`__","LWG","Utility functions to implement uses-allocator construction","San Diego","* *",""
 "`P0595R2 <https://wg21.link/P0595R2>`__","CWG","P0595R2 std::is_constant_evaluated()","San Diego","|Complete|","9.0"
 "`P0602R4 <https://wg21.link/P0602R4>`__","LWG","variant and optional should propagate copy/move triviality","San Diego","|Complete|","8.0"
 "`P0608R3 <https://wg21.link/P0608R3>`__","LWG","A sane variant converting constructor","San Diego","|Complete|","9.0"
 "`P0655R1 <https://wg21.link/P0655R1>`__","LWG","visit<R>: Explicit Return Type for visit","San Diego","|Complete|","12.0"

 "`P1522 <https://wg21.link/P1522>`__","LWG","Iterator Difference Type and Integer Overflow","Cologne","",""
 "`P1523 <https://wg21.link/P1523>`__","LWG","Views and Size Types","Cologne","",""
 "`P1612 <https://wg21.link/P1612>`__","LWG","Relocate Endian's Specification","Cologne","|Complete|","10.0"
 "`P1614 <https://wg21.link/P1614>`__","LWG","The Mothership has Landed","Cologne","|In Progress|",""
 "`P1638 <https://wg21.link/P1638>`__","LWG","basic_istream_view::iterator should not be copyable","Cologne","",""
 "`P1643 <https://wg21.link/P1643>`__","LWG","Add wait/notify to atomic_ref","Cologne","",""
 "`P1644 <https://wg21.link/P1644>`__","LWG","Add wait/notify to atomic<shared_ptr>","Cologne","",""
 "`P1650 <https://wg21.link/P1650>`__","LWG","Output std::chrono::days with 'd' suffix","Cologne","",""
-"`P1651 <https://wg21.link/P1651>`__","LWG","bind_front should not unwrap reference_wrapper","Cologne","",""
+"`P1651 <https://wg21.link/P1651>`__","LWG","bind_front should not unwrap reference_wrapper","Cologne","|Complete|","13.0"
 "`P1652 <https://wg21.link/P1652>`__","LWG","Printf corner cases in std::format","Cologne","",""
 "`P1661 <https://wg21.link/P1661>`__","LWG","Remove dedicated precalculated hash lookup interface","Cologne","|Nothing To Do|",""
 "`P1754 <https://wg21.link/P1754>`__","LWG","Rename concepts to standard_case for C++20, while we still can","Cologne","|In Progress|",""
 "","","","","",""
 "`P0883 <https://wg21.link/P0883>`__","LWG","Fixing Atomic Initialization","Belfast","* *",""
 "`P1391 <https://wg21.link/P1391>`__","LWG","Range constructor for std::string_view","Belfast","* *",""
 "`P1394 <https://wg21.link/P1394>`__","LWG","Range constructor for std::span","Belfast","* *",""
 "`P1456 <https://wg21.link/P1456>`__","LWG","Move-only views","Belfast","* *",""

libcxx/docs/FeatureTestMacroTable.rst

.. table:: Current Status
     ``__cpp_lib_atomic_shared_ptr``                   *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_atomic_value_initialization``         *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_atomic_wait``                         ``201907L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_barrier``                             ``201907L``
     ------------------------------------------------- -----------------
-    ``__cpp_lib_bind_front``                          *unimplemented*
+    ``__cpp_lib_bind_front``                          ``201907L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_bit_cast``                            *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_bitops``                              *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_bounded_array_traits``                ``201902L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_char8_t``                             ``201811L``

libcxx/include/functional

 }
 
 #endif  // _LIBCPP_CXX03_LANG
 
 #if _LIBCPP_STD_VER > 14
 
 template <class _Fn, class ..._Args>
 _LIBCPP_CONSTEXPR_AFTER_CXX17 invoke_result_t<_Fn, _Args...>
 invoke(_Fn&& __f, _Args&&... __args)
     noexcept(is_nothrow_invocable_v<_Fn, _Args...>)
 {
     return _VSTD::__invoke(_VSTD::forward<_Fn>(__f), _VSTD::forward<_Args>(__args)...);
 }
 
-template <class _DecayFunc>
-class _LIBCPP_TEMPLATE_VIS __not_fn_imp {
-  _DecayFunc __fd;
+template<class _Op, class _Tuple,
+         class _Idxs = typename __make_tuple_indices<tuple_size<_Tuple>::value>::type>
+struct __perfect_forward_impl;
 
-public:
-    __not_fn_imp() = delete;
+template<class _Op, class... _Bound, size_t... _Idxs>
+struct __perfect_forward_impl<_Op, __tuple_types<_Bound...>, __tuple_indices<_Idxs...>>
+{
+    tuple<_Bound...> __bound_;
 
-    template <class ..._Args>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
-    auto operator()(_Args&& ...__args) &
-            noexcept(noexcept(!_VSTD::invoke(__fd, _VSTD::forward<_Args>(__args)...)))
-        -> decltype(          !_VSTD::invoke(__fd, _VSTD::forward<_Args>(__args)...))
-        { return              !_VSTD::invoke(__fd, _VSTD::forward<_Args>(__args)...); }
+    template<class... _Args>
+    _LIBCPP_INLINE_VISIBILITY constexpr auto operator()(_Args&&... __args) &
+    noexcept(noexcept(_Op::__call(_VSTD::get<_Idxs>(__bound_)..., _VSTD::forward<_Args>(__args)...)))
+    -> decltype(      _Op::__call(_VSTD::get<_Idxs>(__bound_)..., _VSTD::forward<_Args>(__args)...))
+    {return           _Op::__call(_VSTD::get<_Idxs>(__bound_)..., _VSTD::forward<_Args>(__args)...);}
 
-    template <class ..._Args>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
-    auto operator()(_Args&& ...__args) &&
-            noexcept(noexcept(!_VSTD::invoke(_VSTD::move(__fd), _VSTD::forward<_Args>(__args)...)))
-        -> decltype(          !_VSTD::invoke(_VSTD::move(__fd), _VSTD::forward<_Args>(__args)...))
-        { return              !_VSTD::invoke(_VSTD::move(__fd), _VSTD::forward<_Args>(__args)...); }
+    template<class... _Args>
+    _LIBCPP_INLINE_VISIBILITY constexpr auto operator()(_Args&&... __args) const&
+    noexcept(noexcept(_Op::__call(_VSTD::get<_Idxs>(__bound_)..., _VSTD::forward<_Args>(__args)...)))
+    -> decltype(      _Op::__call(_VSTD::get<_Idxs>(__bound_)..., _VSTD::forward<_Args>(__args)...))
+    {return           _Op::__call(_VSTD::get<_Idxs>(__bound_)..., _VSTD::forward<_Args>(__args)...);}
 
-    template <class ..._Args>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
-    auto operator()(_Args&& ...__args) const&
-            noexcept(noexcept(!_VSTD::invoke(__fd, _VSTD::forward<_Args>(__args)...)))
-        -> decltype(          !_VSTD::invoke(__fd, _VSTD::forward<_Args>(__args)...))
-        { return              !_VSTD::invoke(__fd, _VSTD::forward<_Args>(__args)...); }
+    template<class... _Args>
+    _LIBCPP_INLINE_VISIBILITY constexpr auto operator()(_Args&&... __args) &&
+    noexcept(noexcept(_Op::__call(_VSTD::get<_Idxs>(_VSTD::move(__bound_))...,
+                                  _VSTD::forward<_Args>(__args)...)))
+    -> decltype(      _Op::__call(_VSTD::get<_Idxs>(_VSTD::move(__bound_))...,
+                                  _VSTD::forward<_Args>(__args)...))
+    {return           _Op::__call(_VSTD::get<_Idxs>(_VSTD::move(__bound_))...,
+                                  _VSTD::forward<_Args>(__args)...);}
 
+    template<class... _Args>
+    _LIBCPP_INLINE_VISIBILITY constexpr auto operator()(_Args&&... __args) const&&
+    noexcept(noexcept(_Op::__call(_VSTD::get<_Idxs>(_VSTD::move(__bound_))...,
+                                  _VSTD::forward<_Args>(__args)...)))
+    -> decltype(      _Op::__call(_VSTD::get<_Idxs>(_VSTD::move(__bound_))...,
+                                  _VSTD::forward<_Args>(__args)...))
+    {return           _Op::__call(_VSTD::get<_Idxs>(_VSTD::move(__bound_))...,
+                                  _VSTD::forward<_Args>(__args)...);}
+
+    template<class _Fn = typename tuple_element<0, tuple<_Bound...>>::type,
+             class = _EnableIf<is_copy_constructible_v<_Fn>>>
+    constexpr __perfect_forward_impl(__perfect_forward_impl const& __other)
+        : __bound_(__other.__bound_) {}
+
+    template<class _Fn = typename tuple_element<0, tuple<_Bound...>>::type,
+             class = _EnableIf<is_move_constructible_v<_Fn>>>
+    constexpr __perfect_forward_impl(__perfect_forward_impl && __other)
+        : __bound_(_VSTD::move(__other.__bound_)) {}
+
+    template<class... _BoundArgs>
+    explicit constexpr __perfect_forward_impl(_BoundArgs&&... __bound) :
+        __bound_(_VSTD::forward<_BoundArgs>(__bound)...) { }
+};
+
+template<class _Op, class... _Args>
+using __perfect_forward =
+    __perfect_forward_impl<_Op, __tuple_types<decay_t<_Args>...>>;
 
-    template <class ..._Args>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
-    auto operator()(_Args&& ...__args) const&&
-            noexcept(noexcept(!_VSTD::invoke(_VSTD::move(__fd), _VSTD::forward<_Args>(__args)...)))
-        -> decltype(          !_VSTD::invoke(_VSTD::move(__fd), _VSTD::forward<_Args>(__args)...))
-        { return              !_VSTD::invoke(_VSTD::move(__fd), _VSTD::forward<_Args>(__args)...); }
+struct __not_fn_op
+{
+    template<class... _Args>
+    static _LIBCPP_CONSTEXPR_AFTER_CXX17 auto __call(_Args&&... __args)
+    noexcept(noexcept(!_VSTD::invoke(_VSTD::forward<_Args>(__args)...)))
+    -> decltype(      !_VSTD::invoke(_VSTD::forward<_Args>(__args)...))
+    { return          !_VSTD::invoke(_VSTD::forward<_Args>(__args)...); }
+};
 
-private:
-    template <class _RawFunc,
-              class = enable_if_t<!is_same<decay_t<_RawFunc>, __not_fn_imp>::value>>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
-    explicit __not_fn_imp(_RawFunc&& __rf)
-        : __fd(_VSTD::forward<_RawFunc>(__rf)) {}
+template<class _Fn,
+         class = _EnableIf<is_constructible_v<decay_t<_Fn>, _Fn> &&
+                           is_move_constructible_v<_Fn>>>
+_LIBCPP_CONSTEXPR_AFTER_CXX17 auto not_fn(_Fn&& __f)
+{
+    return __perfect_forward<__not_fn_op, _Fn>(_VSTD::forward<_Fn>(__f));
+}
+
+#endif // _LIBCPP_STD_VER > 14
+
+#if _LIBCPP_STD_VER > 17
 
-    template <class _RawFunc>
-    friend inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
-    __not_fn_imp<decay_t<_RawFunc>> not_fn(_RawFunc&&);
+struct __bind_front_op
+{
+    template<class... _Args>
+    constexpr static auto __call(_Args&&... __args)
+    noexcept(noexcept(_VSTD::invoke(_VSTD::forward<_Args>(__args)...)))
+    -> decltype(      _VSTD::invoke(_VSTD::forward<_Args>(__args)...))
+    { return          _VSTD::invoke(_VSTD::forward<_Args>(__args)...); }
 };
 
-template <class _RawFunc>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
-__not_fn_imp<decay_t<_RawFunc>> not_fn(_RawFunc&& __fn) {
-    return __not_fn_imp<decay_t<_RawFunc>>(_VSTD::forward<_RawFunc>(__fn));
+template<class _Fn, class... _Args,
+         class = _EnableIf<conjunction<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>>
+constexpr auto bind_front(_Fn&& __f, _Args&&... __args)
+{
+    return __perfect_forward<__bind_front_op, _Fn, _Args...>(_VSTD::forward<_Fn>(__f),
+                                                             _VSTD::forward<_Args>(__args)...);
 }
 
-#endif
+#endif // _LIBCPP_STD_VER > 17
 
 // struct hash<T*> in <memory>
 
 template <class _BinaryPredicate, class _ForwardIterator1, class _ForwardIterator2>
 pair<_ForwardIterator1, _ForwardIterator1> _LIBCPP_CONSTEXPR_AFTER_CXX11
 __search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
          _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred,
          forward_iterator_tag, forward_iterator_tag)

 using unwrap_reference_t = typename unwrap_reference<_Tp>::type;
 
 template <class _Tp>
 using unwrap_ref_decay_t = typename unwrap_ref_decay<_Tp>::type;
 #endif // > C++17
 
 template <class _Container, class _Predicate>
 inline typename _Container::size_type
 __libcpp_erase_if_container(_Container& __c, _Predicate __pred) {
   typename _Container::size_type __old_size = __c.size();
 
   const typename _Container::iterator __last = __c.end();
   for (typename _Container::iterator __iter = __c.begin(); __iter != __last;) {
     if (__pred(*__iter))
       __iter = __c.erase(__iter);
     else
       ++__iter;
   }
 
   return __old_size - __c.size();
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_FUNCTIONAL

libcxx/include/version

 // #   define __cpp_lib_atomic_value_initialization        201911L
 # endif
 # if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_atomic_wait)
 #   define __cpp_lib_atomic_wait                        201907L
 # endif
 # if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_barrier)
 #   define __cpp_lib_barrier                            201907L
 # endif
-// # define __cpp_lib_bind_front                           201907L
+# define __cpp_lib_bind_front                           201907L
 // # define __cpp_lib_bit_cast                             201806L
 // # define __cpp_lib_bitops                               201907L
 # define __cpp_lib_bounded_array_traits                 201902L
 # if !defined(_LIBCPP_NO_HAS_CHAR8_T)
 #   define __cpp_lib_char8_t                            201811L
 # endif
 // # define __cpp_lib_concepts                             202002L
 # define __cpp_lib_constexpr_algorithms                 201806L

libcxx/test/std/language.support/support.limits/support.limits.general/functional.version.pass.cpp

 # endif
 
 # ifdef __cpp_lib_unwrap_ref
 #   error "__cpp_lib_unwrap_ref should not be defined before c++20"
 # endif
 
 #elif TEST_STD_VER == 20
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_bind_front
-#     error "__cpp_lib_bind_front should be defined in c++20"
-#   endif
-#   if __cpp_lib_bind_front != 201907L
-#     error "__cpp_lib_bind_front should have the value 201907L in c++20"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_bind_front
-#     error "__cpp_lib_bind_front should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+# ifndef __cpp_lib_bind_front
+#   error "__cpp_lib_bind_front should be defined in c++20"
+# endif
+# if __cpp_lib_bind_front != 201907L
+#   error "__cpp_lib_bind_front should have the value 201907L in c++20"
+# endif
 
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_boyer_moore_searcher
 #     error "__cpp_lib_boyer_moore_searcher should be defined in c++20"
 #   endif
 #   if __cpp_lib_boyer_moore_searcher != 201603L
 #     error "__cpp_lib_boyer_moore_searcher should have the value 201603L in c++20"
 #   endif

 #   error "__cpp_lib_unwrap_ref should be defined in c++20"
 # endif
 # if __cpp_lib_unwrap_ref != 201811L
 #   error "__cpp_lib_unwrap_ref should have the value 201811L in c++20"
 # endif
 
 #elif TEST_STD_VER > 20
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_bind_front
-#     error "__cpp_lib_bind_front should be defined in c++2b"
-#   endif
-#   if __cpp_lib_bind_front != 201907L
-#     error "__cpp_lib_bind_front should have the value 201907L in c++2b"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_bind_front
-#     error "__cpp_lib_bind_front should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+# ifndef __cpp_lib_bind_front
+#   error "__cpp_lib_bind_front should be defined in c++2b"
+# endif
+# if __cpp_lib_bind_front != 201907L
+#   error "__cpp_lib_bind_front should have the value 201907L in c++2b"
+# endif
 
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_boyer_moore_searcher
 #     error "__cpp_lib_boyer_moore_searcher should be defined in c++2b"
 #   endif
 #   if __cpp_lib_boyer_moore_searcher != 201603L
 #     error "__cpp_lib_boyer_moore_searcher should have the value 201603L in c++2b"
 #   endif

libcxx/test/std/language.support/support.limits/support.limits.general/version.version.pass.cpp

 #     error "__cpp_lib_barrier should have the value 201907L in c++20"
 #   endif
 # else
 #   ifdef __cpp_lib_barrier
 #     error "__cpp_lib_barrier should not be defined when !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_barrier) is not defined!"
 #   endif
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_bind_front
-#     error "__cpp_lib_bind_front should be defined in c++20"
-#   endif
-#   if __cpp_lib_bind_front != 201907L
-#     error "__cpp_lib_bind_front should have the value 201907L in c++20"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_bind_front
-#     error "__cpp_lib_bind_front should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+# ifndef __cpp_lib_bind_front
+#   error "__cpp_lib_bind_front should be defined in c++20"
+# endif
+# if __cpp_lib_bind_front != 201907L
+#   error "__cpp_lib_bind_front should have the value 201907L in c++20"
+# endif
 
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_bit_cast
 #     error "__cpp_lib_bit_cast should be defined in c++20"
 #   endif
 #   if __cpp_lib_bit_cast != 201806L
 #     error "__cpp_lib_bit_cast should have the value 201806L in c++20"
 #   endif

 #     error "__cpp_lib_barrier should have the value 201907L in c++2b"
 #   endif
 # else
 #   ifdef __cpp_lib_barrier
 #     error "__cpp_lib_barrier should not be defined when !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_barrier) is not defined!"
 #   endif
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_bind_front
-#     error "__cpp_lib_bind_front should be defined in c++2b"
-#   endif
-#   if __cpp_lib_bind_front != 201907L
-#     error "__cpp_lib_bind_front should have the value 201907L in c++2b"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_bind_front
-#     error "__cpp_lib_bind_front should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+# ifndef __cpp_lib_bind_front
+#   error "__cpp_lib_bind_front should be defined in c++2b"
+# endif
+# if __cpp_lib_bind_front != 201907L
+#   error "__cpp_lib_bind_front should have the value 201907L in c++2b"
+# endif
 
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_bit_cast
 #     error "__cpp_lib_bit_cast should be defined in c++2b"
 #   endif
 #   if __cpp_lib_bit_cast != 201806L
 #     error "__cpp_lib_bit_cast should have the value 201806L in c++2b"
 #   endif

libcxx/test/std/utilities/function.objects/func.bind_front/bind_front.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++98, c++03, c++11, c++14, c++17
+
+// functional
+
+// template <class F, class... Args> constexpr unspecified bind_front(F&&, Args&&...);
+
+#include <functional>
+
+#include "callable_types.h"
+#include "test_macros.h"
+
+constexpr int add(int a, int b) { return a + b; }
+
+constexpr int long_test(int a, int b, int c, int d, int e, int f) {
+  return a + b + c + d + e + f;
+}
+
+struct Foo {
+  int a;
+  int b;
+};
+
+struct FooCall {
+  constexpr Foo operator()(int a, int b) { return Foo{a, b}; }
+};
+
+struct S {
+  constexpr bool operator()(int a) { return a == 1; }
+};
+
+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) {}
+};
+
+constexpr bool wasCopied(CopyMoveInfo info) {
+  return info.copy_kind == CopyMoveInfo::copy;
+}
+constexpr bool wasMoved(CopyMoveInfo info) {
+  return info.copy_kind == CopyMoveInfo::move;
+}
+
+constexpr void basic_tests() {
+  int n = 2;
+  int m = 1;
+
+  auto a = std::bind_front(add, m, n);
+  assert(a() == 3);
+
+  auto b = std::bind_front(long_test, m, n, m, m, m, m);
+  assert(b() == 7);
+
+  auto c = std::bind_front(long_test, n, m);
+  assert(c(1, 1, 1, 1) == 7);
+
+  auto d = std::bind_front(S{}, m);
+  assert(d());
+
+  auto f = std::bind_front(add, n);
+  assert(f(3) == 5);
+
+  auto g = std::bind_front(add, n, 1);
+  assert(g() == 3);
+
+  auto h = std::bind_front(long_test, 1, 1, 1);
+  assert(h(2, 2, 2) == 9);
+
+  // Make sure the arg is passed by value.
+  auto i = std::bind_front(add, n, 1);
+  n = 100;
+  assert(i() == 3);
+
+  CopyMoveInfo info;
+  auto copied = std::bind_front(wasCopied, info);
+  assert(copied());
+
+  auto moved = std::bind_front(wasMoved, info);
+  assert(std::move(moved)());
+}
+
+struct variadic_fn {
+  template <class... Args>
+  constexpr int operator()(Args&&... args) {
+    return sizeof...(args);
+  }
+};
+
+constexpr void test_variadic() {
+  variadic_fn value;
+  auto fn = std::bind_front(value, 0, 0, 0);
+  assert(fn(0, 0, 0) == 6);
+}
+
+struct mutable_callable {
+  bool should_call_const;
+
+  constexpr bool operator()(int, int) {
+    assert(!should_call_const);
+    return true;
+  }
+  constexpr bool operator()(int, int) const {
+    assert(should_call_const);
+    return true;
+  }
+};
+
+constexpr void test_mutable() {
+  const mutable_callable v1{true};
+  const auto fn1 = std::bind_front(v1, 0);
+  assert(fn1(0));
+
+  mutable_callable v2{false};
+  auto fn2 = std::bind_front(v2, 0);
+  assert(fn2(0));
+};
+
+struct call_member {
+  constexpr bool member(int, int) { return true; }
+};
+
+constexpr void test_call_member() {
+  call_member value;
+  auto fn = std::bind_front(&call_member::member, value, 0);
+  assert(fn(0));
+}
+
+struct no_const_lvalue {
+  constexpr void operator()(int) && {};
+};
+
+constexpr auto make_no_const_lvalue(int x) {
+  // This is to test that bind_front works when something like the following would not:
+  // return [nc = no_const_lvalue{}, x] { return nc(x); };
+  // Above would not work because it would look for a () const & overload.
+  return std::bind_front(no_const_lvalue{}, x);
+}
+
+constexpr void test_no_const_lvalue() { make_no_const_lvalue(1)(); }
+
+constexpr void constructor_tests() {
+  {
+    MoveOnlyCallable value(true);
+    using RetT = decltype(std::bind_front(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_front(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_front(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_front(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);
+    assert(!ret());
+    assert(ret2());
+    assert(ret2(1, 2, 3));
+  }
+  {
+    CopyAssignableWrapper value(true);
+    using RetT = decltype(std::bind_front(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));
+
+    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);
+  }
+}
+
+template <class Res, class F, class... Args>
+constexpr void test_return(F&& value, Args&&... args) {
+  auto ret =
+      std::bind_front(std::forward<F>(value), std::forward<Args>(args)...);
+  static_assert(std::is_same<decltype(ret()), Res>::value);
+}
+
+constexpr void test_return_types() {
+  test_return<Foo>(FooCall{}, 1, 2);
+  test_return<bool>(S{}, 1);
+  test_return<int>(add, 2, 2);
+}
+
+constexpr void test_arg_count() {
+  using T = decltype(std::bind_front(add, 1));
+  static_assert(!std::is_invocable<T>::value);
+  static_assert(std::is_invocable<T, int>::value);
+}
+
+template <class... Args>
+struct is_bind_frontable {
+  template <class... LocalArgs>
+  static auto test(int)
+      -> decltype((void)std::bind_front(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;
+  void operator()() {}
+};
+
+struct NonConstCopyConstructible {
+  explicit NonConstCopyConstructible() {}
+  NonConstCopyConstructible(NonConstCopyConstructible&) {}
+};
+
+struct MoveConstructible {
+  explicit MoveConstructible() {}
+  MoveConstructible(MoveConstructible&&) {}
+};
+
+constexpr void test_invocability() {
+  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(
+      !std::is_constructible_v<MoveConstructible, MoveConstructible&>);
+  static_assert(std::is_move_constructible_v<MoveConstructible>);
+  static_assert(is_bind_frontable<variadic_fn, MoveConstructible>::value);
+  static_assert(
+      !is_bind_frontable<variadic_fn, MoveConstructible&>::value);
+
+  static_assert(std::is_constructible_v<NonConstCopyConstructible,
+                                        NonConstCopyConstructible&>);
+  static_assert(!std::is_move_constructible_v<NonConstCopyConstructible>);
+  static_assert(
+      !is_bind_frontable<variadic_fn, NonConstCopyConstructible&>::value);
+  static_assert(
+      !is_bind_frontable<variadic_fn, NonConstCopyConstructible>::value);
+}
+
+constexpr bool test() {
+  basic_tests();
+  constructor_tests();
+  test_return_types();
+  test_arg_count();
+  test_variadic();
+  test_mutable();
+  test_call_member();
+  test_no_const_lvalue();
+  test_invocability();
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/utilities/function.objects/func.bind_front/bind_front.verify.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++98, c++03, c++11, c++14, c++17
+
+// functional
+
+// template <class F, class... Args> constexpr unspecified bind_front(F&&, Args&&...);
+
+#include <functional>
+
+#include "test_macros.h"
+
+constexpr int pass(const int n) { return n; }
+
+int simple(int n) { return n; }
+
+template<class T>
+T do_nothing(T t) { return t; }
+
+struct NotMoveConst
+{
+    NotMoveConst(NotMoveConst &&) = delete;
+    NotMoveConst(NotMoveConst const&) = delete;
+
+    NotMoveConst(int) { }
+};
+
+void testNotMoveConst(NotMoveConst) { }
+
+int main(int, char**)
+{
+    int n = 1;
+    const int c = 1;
+
+    auto p = std::bind_front(pass, c);
+    static_assert(p() == 1); // expected-error {{static_assert expression is not an integral constant expression}}
+
+    auto d = std::bind_front(do_nothing, n); // expected-error {{no matching function for call to 'bind_front'}}
+
+    auto t = std::bind_front(testNotMoveConst, NotMoveConst(0)); // expected-error {{no matching function for call to 'bind_front'}}
+
+    return 0;
+}

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

 
 #include <functional>
 #include <type_traits>
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "type_id.h"
-
-
-///////////////////////////////////////////////////////////////////////////////
-//                       CALLABLE TEST TYPES
-///////////////////////////////////////////////////////////////////////////////
-
-constexpr bool returns_true() { return true; }
-
-template <class Ret = bool>
-struct MoveOnlyCallable {
-  MoveOnlyCallable(MoveOnlyCallable const&) = delete;
-  constexpr MoveOnlyCallable(MoveOnlyCallable&& other)
-      : value(other.value)
-  { other.value = !other.value; }
-
-  template <class ...Args>
-  constexpr Ret operator()(Args&&...) { return Ret{value}; }
-
-  constexpr explicit MoveOnlyCallable(bool x) : value(x) {}
-  Ret value;
-};
-
-template <class Ret = bool>
-struct CopyCallable {
-  constexpr CopyCallable(CopyCallable const& other)
-      : value(other.value) {}
-
-  constexpr CopyCallable(CopyCallable&& other)
-      : value(other.value) { other.value = !other.value; }
-
-  template <class ...Args>
-  constexpr Ret operator()(Args&&...) { return Ret{value}; }
-
-  constexpr explicit CopyCallable(bool x) : value(x)  {}
-  Ret value;
-};
-
-
-template <class Ret = bool>
-struct ConstCallable {
-  constexpr ConstCallable(ConstCallable const& other)
-      : value(other.value) {}
-
-  constexpr ConstCallable(ConstCallable&& other)
-      : value(other.value) { other.value = !other.value; }
-
-  template <class ...Args>
-  constexpr Ret operator()(Args&&...) const { return Ret{value}; }
-
-  constexpr explicit ConstCallable(bool x) : value(x)  {}
-  Ret value;
-};
-
-
-
-template <class Ret = bool>
-struct NoExceptCallable {
-  constexpr NoExceptCallable(NoExceptCallable const& other)
-      : value(other.value) {}
-
-  template <class ...Args>
-  constexpr Ret operator()(Args&&...) noexcept { return Ret{value}; }
-
-  template <class ...Args>
-  constexpr Ret operator()(Args&&...) const noexcept { return Ret{value}; }
-
-  constexpr explicit NoExceptCallable(bool x) : value(x)  {}
-  Ret value;
-};
-
-struct CopyAssignableWrapper {
-  constexpr CopyAssignableWrapper(CopyAssignableWrapper const&) = default;
-  constexpr CopyAssignableWrapper(CopyAssignableWrapper&&) = default;
-  constexpr CopyAssignableWrapper& operator=(CopyAssignableWrapper const&) = default;
-  constexpr CopyAssignableWrapper& operator=(CopyAssignableWrapper &&) = default;
-
-  template <class ...Args>
-  constexpr bool operator()(Args&&...) { return value; }
-
-  constexpr explicit CopyAssignableWrapper(bool x) : value(x) {}
-  bool value;
-};
-
-
-struct MoveAssignableWrapper {
-  constexpr MoveAssignableWrapper(MoveAssignableWrapper const&) = delete;
-  constexpr MoveAssignableWrapper(MoveAssignableWrapper&&) = default;
-  constexpr MoveAssignableWrapper& operator=(MoveAssignableWrapper const&) = delete;
-  constexpr MoveAssignableWrapper& operator=(MoveAssignableWrapper &&) = default;
-
-  template <class ...Args>
-  constexpr bool operator()(Args&&...) { return value; }
-
-  constexpr explicit MoveAssignableWrapper(bool x) : value(x) {}
-  bool value;
-};
-
-struct MemFunCallable {
-  constexpr explicit MemFunCallable(bool x) : value(x) {}
-
-  constexpr bool return_value() const { return value; }
-  constexpr bool return_value_nc() { return value; }
-  bool value;
-};
-
-enum CallType : unsigned {
-  CT_None,
-  CT_NonConst = 1,
-  CT_Const = 2,
-  CT_LValue = 4,
-  CT_RValue = 8
-};
-
-inline constexpr CallType operator|(CallType LHS, CallType RHS) {
-    return static_cast<CallType>(static_cast<unsigned>(LHS) | static_cast<unsigned>(RHS));
-}
-
-struct ForwardingCallObject {
-  struct State {
-    CallType      last_call_type = CT_None;
-    TypeID const& (*last_call_args)() = nullptr;
-
-    template <class ...Args>
-    constexpr void set_call(CallType type) {
-      assert(last_call_type == CT_None);
-      assert(last_call_args == nullptr);
-      last_call_type = type;
-      last_call_args = &makeArgumentID<Args...>;
-    }
-
-    template <class ...Args>
-    constexpr bool check_call(CallType type) {
-      bool result =
-           last_call_type == type
-        && last_call_args
-        && *last_call_args == &makeArgumentID<Args...>;
-      last_call_type = CT_None;
-      last_call_args = nullptr;
-      return result;
-    }
-  };
-
-  State *st_;
-
-  explicit constexpr ForwardingCallObject(State& st) : st_(&st) {}
-
-  template <class ...Args>
-  constexpr bool operator()(Args&&...) & {
-      st_->set_call<Args&&...>(CT_NonConst | CT_LValue);
-      return true;
-  }
-
-  template <class ...Args>
-  constexpr bool operator()(Args&&...) const & {
-      st_->set_call<Args&&...>(CT_Const | CT_LValue);
-      return true;
-  }
-
-  // Don't allow the call operator to be invoked as an rvalue.
-  template <class ...Args>
-  constexpr bool operator()(Args&&...) && {
-      st_->set_call<Args&&...>(CT_NonConst | CT_RValue);
-      return true;
-  }
-
-  template <class ...Args>
-  constexpr bool operator()(Args&&...) const && {
-      st_->set_call<Args&&...>(CT_Const | CT_RValue);
-      return true;
-  }
-};
-
+#include "callable_types.h"
 
 ///////////////////////////////////////////////////////////////////////////////
 //                        BOOL TEST TYPES
 ///////////////////////////////////////////////////////////////////////////////
 
 struct EvilBool {
   static int bang_called;
 
bool constructor_tests()
         // test 'ret' has the original value
         assert(ret() == true);
         assert(ret(42, 100) == true);
         // move from 'ret' and check that 'ret2' has the original value.
         auto ret2 = std::move(ret);
         assert(ret() == false);
         assert(ret2() == true);
         assert(ret2("abc") == true);
+        // initialize not_fn with rvalue
+        auto ret3 = std::not_fn(std::move(value));
+        assert(ret(0) == false);
+        assert(ret3(0) == true);
     }
     {
         using T = CopyAssignableWrapper;
         T value(true);
         T value2(false);
         using RetT = decltype(std::not_fn(value));
         static_assert(std::is_move_constructible<RetT>::value, "");
         static_assert(std::is_copy_constructible<RetT>::value, "");
-        LIBCPP_STATIC_ASSERT(std::is_move_assignable<RetT>::value, "");
-        LIBCPP_STATIC_ASSERT(std::is_copy_assignable<RetT>::value, "");
         auto ret = std::not_fn(value);
         assert(ret() == false);
         auto ret2 = std::not_fn(value2);
         assert(ret2() == true);
-#if defined(_LIBCPP_VERSION)
-        ret = ret2;
-        assert(ret() == true);
-        assert(ret2() == true);
-#endif // _LIBCPP_VERSION
     }
     {
         using T = MoveAssignableWrapper;
         T value(true);
         T value2(false);
         using RetT = decltype(std::not_fn(std::move(value)));
         static_assert(std::is_move_constructible<RetT>::value, "");
         static_assert(!std::is_copy_constructible<RetT>::value, "");
-        LIBCPP_STATIC_ASSERT(std::is_move_assignable<RetT>::value, "");
         static_assert(!std::is_copy_assignable<RetT>::value, "");
         auto ret = std::not_fn(std::move(value));
         assert(ret() == false);
         auto ret2 = std::not_fn(std::move(value2));
         assert(ret2() == true);
-#if defined(_LIBCPP_VERSION)
-        ret = std::move(ret2);
-        assert(ret() == true);
-#endif // _LIBCPP_VERSION
     }
     return true;
 }
 
 void return_type_tests()
 {
     using std::is_same;
     {

libcxx/test/support/callable_types.h

+//===----------------------------------------------------------------------===//
+//
+// 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 TEST_CALLABLE_TYPES_H
+#define TEST_CALLABLE_TYPES_H
+
+#include "test_macros.h"
+#include "type_id.h"
+
+///////////////////////////////////////////////////////////////////////////////
+//                       CALLABLE TEST TYPES
+///////////////////////////////////////////////////////////////////////////////
+
+constexpr bool returns_true() { return true; }
+
+template <class Ret = bool>
+struct MoveOnlyCallable {
+  MoveOnlyCallable(MoveOnlyCallable const&) = delete;
+  constexpr MoveOnlyCallable(MoveOnlyCallable&& other)
+      : value(other.value)
+  { other.value = !other.value; }
+
+  template <class ...Args>
+  constexpr Ret operator()(Args&&...) { return Ret{value}; }
+
+  constexpr explicit MoveOnlyCallable(bool x) : value(x) {}
+  Ret value;
+};
+
+template <class Ret = bool>
+struct CopyCallable {
+  constexpr CopyCallable(CopyCallable const& other)
+      : value(other.value) {}
+
+  constexpr CopyCallable(CopyCallable&& other)
+      : value(other.value) { other.value = !other.value; }
+
+  template <class ...Args>
+  constexpr Ret operator()(Args&&...) { return Ret{value}; }
+
+  constexpr explicit CopyCallable(bool x) : value(x)  {}
+  Ret value;
+};
+
+
+template <class Ret = bool>
+struct ConstCallable {
+  constexpr ConstCallable(ConstCallable const& other)
+      : value(other.value) {}
+
+  constexpr ConstCallable(ConstCallable&& other)
+      : value(other.value) { other.value = !other.value; }
+
+  template <class ...Args>
+  constexpr Ret operator()(Args&&...) const { return Ret{value}; }
+
+  constexpr explicit ConstCallable(bool x) : value(x)  {}
+  Ret value;
+};
+
+
+
+template <class Ret = bool>
+struct NoExceptCallable {
+  constexpr NoExceptCallable(NoExceptCallable const& other)
+      : value(other.value) {}
+
+  template <class ...Args>
+  constexpr Ret operator()(Args&&...) noexcept { return Ret{value}; }
+
+  template <class ...Args>
+  constexpr Ret operator()(Args&&...) const noexcept { return Ret{value}; }
+
+  constexpr explicit NoExceptCallable(bool x) : value(x)  {}
+  Ret value;
+};
+
+struct CopyAssignableWrapper {
+  constexpr CopyAssignableWrapper(CopyAssignableWrapper const&) = default;
+  constexpr CopyAssignableWrapper(CopyAssignableWrapper&&) = default;
+  constexpr CopyAssignableWrapper& operator=(CopyAssignableWrapper const&) = default;
+  constexpr CopyAssignableWrapper& operator=(CopyAssignableWrapper &&) = default;
+
+  template <class ...Args>
+  constexpr bool operator()(Args&&...) { return value; }
+
+  constexpr explicit CopyAssignableWrapper(bool x) : value(x) {}
+  bool value;
+};
+
+
+struct MoveAssignableWrapper {
+  constexpr MoveAssignableWrapper(MoveAssignableWrapper const&) = delete;
+  constexpr MoveAssignableWrapper(MoveAssignableWrapper&&) = default;
+  constexpr MoveAssignableWrapper& operator=(MoveAssignableWrapper const&) = delete;
+  constexpr MoveAssignableWrapper& operator=(MoveAssignableWrapper &&) = default;
+
+  template <class ...Args>
+  constexpr bool operator()(Args&&...) { return value; }
+
+  constexpr explicit MoveAssignableWrapper(bool x) : value(x) {}
+  bool value;
+};
+
+struct MemFunCallable {
+  constexpr explicit MemFunCallable(bool x) : value(x) {}
+
+  constexpr bool return_value() const { return value; }
+  constexpr bool return_value_nc() { return value; }
+  bool value;
+};
+
+enum CallType : unsigned {
+  CT_None,
+  CT_NonConst = 1,
+  CT_Const = 2,
+  CT_LValue = 4,
+  CT_RValue = 8
+};
+
+inline constexpr CallType operator|(CallType LHS, CallType RHS) {
+    return static_cast<CallType>(static_cast<unsigned>(LHS) | static_cast<unsigned>(RHS));
+}
+
+struct ForwardingCallObject {
+  struct State {
+    CallType      last_call_type = CT_None;
+    TypeID const& (*last_call_args)() = nullptr;
+
+    template <class ...Args>
+    constexpr void set_call(CallType type) {
+      assert(last_call_type == CT_None);
+      assert(last_call_args == nullptr);
+      last_call_type = type;
+      last_call_args = &makeArgumentID<Args...>;
+    }
+
+    template <class ...Args>
+    constexpr bool check_call(CallType type) {
+      bool result =
+           last_call_type == type
+        && last_call_args
+        && *last_call_args == &makeArgumentID<Args...>;
+      last_call_type = CT_None;
+      last_call_args = nullptr;
+      return result;
+    }
+  };
+
+  State *st_;
+
+  explicit constexpr ForwardingCallObject(State& st) : st_(&st) {}
+
+  template <class ...Args>
+  constexpr bool operator()(Args&&...) & {
+      st_->set_call<Args&&...>(CT_NonConst | CT_LValue);
+      return true;
+  }
+
+  template <class ...Args>
+  constexpr bool operator()(Args&&...) const & {
+      st_->set_call<Args&&...>(CT_Const | CT_LValue);
+      return true;
+  }
+
+  // Don't allow the call operator to be invoked as an rvalue.
+  template <class ...Args>
+  constexpr bool operator()(Args&&...) && {
+      st_->set_call<Args&&...>(CT_NonConst | CT_RValue);
+      return true;
+  }
+
+  template <class ...Args>
+  constexpr bool operator()(Args&&...) const && {
+      st_->set_call<Args&&...>(CT_Const | CT_RValue);
+      return true;
+  }
+};
+
+
+#endif // TEST_CALLABLE_TYPES_H

libcxx/utils/generate_feature_test_macro_components.py

feature_test_macros = [ add_version_header(x) for x in [
     "values": { "c++20": 201907 },
     "headers": ["barrier"],
     "depends": "!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_barrier)",
     "internal_depends": "!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_barrier)",
   }, {
     "name": "__cpp_lib_bind_front",
     "values": { "c++20": 201907 },
     "headers": ["functional"],
-    "unimplemented": True,
   }, {
     "name": "__cpp_lib_bit_cast",
     "values": { "c++20": 201806 },
     "headers": ["bit"],
     "unimplemented": True,
   }, {
     "name": "__cpp_lib_bitops",
     "values": { "c++20": 201907 },