This is a snapshot of work on P2714 "Bind front and back to NTTP
callables", posted for reference.
Questions:
1. Jonathan asks if __type_forward_like_t does the same job as __like_t
in bits/move.h.
2. Could the "if constexpr" statements be better expressed as requires
clauses via the A=>B == !A||B identity?
libstdc++-v3/ChangeLog:
PR libstdc++/119744
* include/bits/version.def: Redefine __cpp_lib_bind_front etc.
* include/bits/version.h: Ditto.
* include/std/functional: Add new bind_front etc. overloads
---
libstdc++-v3/include/bits/version.def | 12 +++
libstdc++-v3/include/bits/version.h | 21 ++++-
libstdc++-v3/include/std/functional | 124 +++++++++++++++++++++++++-
3 files changed, 153 insertions(+), 4 deletions(-)
diff --git a/libstdc++-v3/include/bits/version.def
b/libstdc++-v3/include/bits/version.def
index 5d5758bf203..8ab9a7207e7 100644
--- a/libstdc++-v3/include/bits/version.def
+++ b/libstdc++-v3/include/bits/version.def
@@ -463,6 +463,10 @@ ftms = {
ftms = {
name = not_fn;
+ values = {
+ v = 202306;
+ cxxmin = 26;
+ };
values = {
v = 201603;
cxxmin = 17;
@@ -776,6 +780,10 @@ ftms = {
ftms = {
name = bind_front;
+ values = {
+ v = 202306;
+ cxxmin = 26;
+ };
values = {
v = 201907;
cxxmin = 20;
@@ -784,6 +792,10 @@ ftms = {
ftms = {
name = bind_back;
+ values = {
+ v = 202306;
+ cxxmin = 26;
+ };
values = {
v = 202202;
cxxmin = 23;
diff --git a/libstdc++-v3/include/bits/version.h
b/libstdc++-v3/include/bits/version.h
index 2b00e8419b3..c204ae3c48c 100644
--- a/libstdc++-v3/include/bits/version.h
+++ b/libstdc++-v3/include/bits/version.h
@@ -511,7 +511,12 @@
#undef __glibcxx_want_make_from_tuple
#if !defined(__cpp_lib_not_fn)
-# if (__cplusplus >= 201703L)
+# if (__cplusplus > 202302L)
+# define __glibcxx_not_fn 202306L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_not_fn)
+# define __cpp_lib_not_fn 202306L
+# endif
+# elif (__cplusplus >= 201703L)
# define __glibcxx_not_fn 201603L
# if defined(__glibcxx_want_all) || defined(__glibcxx_want_not_fn)
# define __cpp_lib_not_fn 201603L
@@ -866,7 +871,12 @@
#undef __glibcxx_want_atomic_value_initialization
#if !defined(__cpp_lib_bind_front)
-# if (__cplusplus >= 202002L)
+# if (__cplusplus > 202302L)
+# define __glibcxx_bind_front 202306L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_bind_front)
+# define __cpp_lib_bind_front 202306L
+# endif
+# elif (__cplusplus >= 202002L)
# define __glibcxx_bind_front 201907L
# if defined(__glibcxx_want_all) || defined(__glibcxx_want_bind_front)
# define __cpp_lib_bind_front 201907L
@@ -876,7 +886,12 @@
#undef __glibcxx_want_bind_front
#if !defined(__cpp_lib_bind_back)
-# if (__cplusplus >= 202100L) && (__cpp_explicit_this_parameter)
+# if (__cplusplus > 202302L)
+# define __glibcxx_bind_back 202306L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_bind_back)
+# define __cpp_lib_bind_back 202306L
+# endif
+# elif (__cplusplus >= 202100L) && (__cpp_explicit_this_parameter)
# define __glibcxx_bind_back 202202L
# if defined(__glibcxx_want_all) || defined(__glibcxx_want_bind_back)
# define __cpp_lib_bind_back 202202L
diff --git a/libstdc++-v3/include/std/functional
b/libstdc++-v3/include/std/functional
index 307bcb95bcc..21f0b1cb2d5 100644
--- a/libstdc++-v3/include/std/functional
+++ b/libstdc++-v3/include/std/functional
@@ -940,7 +940,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_M_bound_args(std::forward<_Args>(__args)...)
{ static_assert(sizeof...(_Args) == sizeof...(_BoundArgs)); }
-#if __cpp_explicit_this_parameter
+#ifdef __cpp_explicit_this_parameter
template<typename _Self, typename... _CallArgs>
constexpr
invoke_result_t<__like_t<_Self, _Fd>, __like_t<_Self, _BoundArgs>...,
_CallArgs...>
@@ -1218,8 +1218,130 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
{
return _Not_fn<std::decay_t<_Fn>>{std::forward<_Fn>(__fn), 0};
}
+#if __cpp_lib_not_fn >= 202306
+ /** Wrap a function type to create a function object that negates its result.
+ *
+ * The function template `std::not_fn` creates a "forwarding call wrapper",
+ * which is a function object that when called forwards its arguments to
+ * its invocable template argument.
+ *
+ * The result of invoking the wrapper is the negation (using `!`) of
+ * the wrapped function object.
+ *
+ * @ingroup functors
+ * @since C++26
+ */
+ template<auto __fn>
+ constexpr auto
+ not_fn() noexcept
+ {
+ using _Fn = decltype(__fn);
+ if constexpr (is_pointer_v<_Fn> or is_member_pointer_v<_Fn>) {
+ static_assert(__fn != nullptr);
+ }
+ return []<typename... _Tp> (_Tp&&... __call_args)
+ noexcept(is_nothrow_invocable_v<_Fn, _Tp...>)
+ -> invoke_result_t<_Fn, _Tp...>
+ {
+ return !invoke(__fn, forward<_Tp>(__call_args)...);
+ };
+ }
+#endif // __cpp_lib_not_fn >= 202306
+#endif // __cpp_lib_not_fn
+
+#if __cpp_lib_bind_front >= 202306 || __cpp_lib_bind_back >= 202306
+
+ template<typename _Tp, typename _Up>
+ using __copy_const = conditional<is_const_v<_Tp>, const _Up, _Up>;
+
+ template<typename _Tp, typename _Up,
+ typename _Xp = __copy_const<remove_reference_t<_Tp>, _Up>::type>
+ using __copy_value_category =
+ conditional<is_lvalue_reference_v<_Tp&&>, _Xp&, _Xp&&>;
+
+ template<typename _Tp, typename _Up>
+ using __type_forward_like =
+ __copy_value_category<_Tp, remove_reference_t<_Up>>;
+
+ template<typename _Tp, typename _Up>
+ using __type_forward_like_t = __type_forward_like<_Tp, _Up>::type;
+
#endif
+#if __cpp_lib_bind_front >= 202306
+ /** Create call wrapper by partial application of arguments to function.
+ *
+ * The result of `std::bind_front<f>(args...)` is a function object that
+ * stores the bound arguments, `args...`. When that function object is
+ * invoked with `call_args...` it returns the result of calling
+ * `f(args..., call_args...)`.
+ *
+ * @since C++26
+ */
+
+ template<auto __fn, typename... _Args>
+ constexpr auto
+ bind_front(_Args&&... __args)
+ requires (
+ (is_constructible_v<decay_t<_Args>, _Args> and ...) and
+ (is_move_constructible_v<decay_t<_Args>> and ...))
+ {
+ using _Fn = decltype(__fn);
+ if constexpr (is_pointer_v<_Fn> or is_member_pointer_v<_Fn>) {
+ static_assert(__fn != nullptr);
+ }
+ return [... __bound_args(std::forward<_Args>(__args))]<
+ typename _Self, typename... _Tp>
+ (this _Self&&, _Tp&&... __call_args)
+ noexcept(is_nothrow_invocable_v<
+ _Fn, __type_forward_like_t<_Self, decay_t<_Args>>..., _Tp...>)
+ -> invoke_result_t<
+ _Fn, __type_forward_like_t<_Self, decay_t<_Args>>..., _Tp...>
+ {
+ return invoke(__fn,
+ forward_like<_Self>(__bound_args)...,
+ forward<_Tp>(__call_args)...);
+ };
+ }
+#endif // __cpp_lib_bind_front
+
+#if __cpp_lib_bind_back >= 202306
+ /** Create call wrapper by partial application of arguments to function.
+ *
+ * The result of `std::bind_back<f>(args...)` is a function object that
+ * stores the bound arguments, `args...`. When that function object is
+ * invoked with `call_args...` it returns the result of calling
+ * `f(call_args..., args...)`.
+ *
+ * @since C++26
+ */
+
+ template<auto __fn, typename... _Args>
+ constexpr auto
+ bind_back(_Args&&... __args)
+ requires (
+ (is_constructible_v<decay_t<_Args>, _Args> and ...) and
+ (is_move_constructible_v<decay_t<_Args>> and ...))
+ {
+ using _Fn = decltype(__fn);
+ if constexpr (is_pointer_v<_Fn> or is_member_pointer_v<_Fn>) {
+ static_assert(__fn != nullptr);
+ }
+ return [... __bound_args(std::forward<_Args>(__args))]<
+ typename _Self, typename... _Tp>
+ (this _Self&&, _Tp&&... __call_args)
+ noexcept(is_nothrow_invocable_v<
+ _Fn, _Tp..., __type_forward_like_t<_Self, decay_t<_Args>>...>)
+ -> invoke_result_t<
+ _Fn, _Tp..., __type_forward_like_t<_Self, decay_t<_Args>>...>
+ {
+ return invoke(__fn,
+ forward<_Tp>(__call_args)...,
+ forward_like<_Self>(__bound_args)...);
+ };
+ }
+#endif // __cpp_lib_bind_back
+
#if __cplusplus >= 201703L
// Searchers
--
2.50.0
