On Tue, Jul 8, 2025 at 5:41 AM Nathan Myers <n...@cantrip.org> wrote:

> This is a snapshot of work in progress, for reference.
> bind_front<f>(...) is uglified directly from the sample
> implementation in P2714, at include/std/functional:1284 .
>
> Test failures:
>
> bind_front/1.cc:53: error: static assertion failed
> bind_front/1.cc:57: error: static assertion failed
> bind_front/1.cc:214: error: static assertion failed
> bind_front/1.cc:215: error: static assertion failed
> bind_front/1.cc:216: required from here
> functional:1301: error: invalid conversion from
> 'std::invoke_result_t<const test03()::F&, std::reference_wrapper<int>&,
> void*&>' {aka 'void*'} to 'int' [-fpermissive]
> [... etc. ]
> Also complains about 218, 220, 231, 233-6, 264, 267
>
The issue is raised on the line:
 int& i6 = g6(vp);
 VERIFY( &i6 == &i );
Where G6 is defined as follows:
 auto g6 = bind_front<f>(std::ref(i)); // bound arg of type int&
  using G6 = decltype(g6);
And f:
  struct F
  {
    int& operator()(int& i, void*) { return i; }
    void* operator()(int, void* p) const { return p; }
  };
 constexpr static F f{};

As the template parameter object, i.e. what id-expression f refers to  in
bind_front<f> is always constant,
g6(vp) i.e. bind_front<f>(ref(i), vp) calls f(ref(i), vp), and because f is
const qualified, the only viable candiate is:
    void* operator()(int, void* p) const { return p; }
So you get void* returned, that int& obviously cannot bind to.


>
> 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
>         * testsuite/20_util/function_objects/bind_front/1.cc
> ---
>  libstdc++-v3/include/bits/version.def         |  12 ++
>  libstdc++-v3/include/bits/version.h           |  21 ++-
>  libstdc++-v3/include/std/functional           | 124 +++++++++++++++++-
>  .../20_util/function_objects/bind_front/1.cc  | 103 ++++++++++++++-
>  4 files changed, 278 insertions(+), 5 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
>
> diff --git
> a/libstdc++-v3/testsuite/20_util/function_objects/bind_front/1.cc
> b/libstdc++-v3/testsuite/20_util/function_objects/bind_front/1.cc
> index 57482c52263..d21432f9629 100644
> --- a/libstdc++-v3/testsuite/20_util/function_objects/bind_front/1.cc
> +++ b/libstdc++-v3/testsuite/20_util/function_objects/bind_front/1.cc
> @@ -47,6 +47,18 @@ test01()
>        decltype(bind_front(std::declval<F>(), std::declval<int>())),
>        decltype(bind_front(std::declval<const F&>(), std::declval<const
> int&>()))
>        >);
> +#if __cpp_lib_bind_front >= 202306
> +  const F f{};
> +
> +  static_assert(std::is_same_v<
> +      decltype(bind_front<f>(std::declval<int>())),
> +      decltype(bind_front<f>(std::declval<int&>()))
> +      >);
> +  static_assert(std::is_same_v<
> +      decltype(bind_front<f>(std::declval<int>())),
> +      decltype(bind_front<f>(std::declval<const int&>()))
> +      >);
> +#endif
>
>    // Reference wrappers should be handled:
>    static_assert(!std::is_same_v<
> @@ -61,6 +73,20 @@ test01()
>        decltype(bind_front(std::declval<F>(),
> std::ref(std::declval<int&>()))),
>        decltype(bind_front(std::declval<F>(),
> std::cref(std::declval<int&>())))
>        >);
> +#if __cpp_lib_bind_front >= 202306
> +  static_assert(!std::is_same_v<
> +      decltype(bind_front<f>(std::declval<int&>())),
> +      decltype(bind_front<f>(std::ref(std::declval<int&>())))
> +      >);
> +  static_assert(!std::is_same_v<
> +      decltype(bind_front<f>(std::declval<const int&>())),
> +      decltype(bind_front<f>(std::cref(std::declval<int&>())))
> +      >);
> +  static_assert(!std::is_same_v<
> +      decltype(bind_front<f>(std::ref(std::declval<int&>()))),
> +      decltype(bind_front<f>(std::cref(std::declval<int&>())))
> +      >);
> +#endif
>  }
>
>  void
> @@ -81,6 +107,7 @@ test02()
>    };
>
>    F f;
> +
>    auto g = bind_front(f);
>    const auto& cg = g;
>    quals q;
> @@ -94,6 +121,23 @@ test02()
>    VERIFY( q.as_const && q.as_lvalue );
>    q = std::move(cg)();
>    VERIFY( q.as_const && ! q.as_lvalue );
> +
> +#if __cpp_lib_bind_front >= 202306
> +  const F f2;
> +  auto g2 = bind_front<f2>();
> +  const auto& cg2 = g2;
> +  quals q2;
> +
> +  // constness and value category should be forwarded to the target
> object:
> +  q2 = g2();
> +  VERIFY( ! q2.as_const && q2.as_lvalue );
> +  q2 = std::move(g)();
> +  VERIFY( ! q2.as_const && ! q2.as_lvalue );
> +  q2 = cg2();
> +  VERIFY( q2.as_const && q2.as_lvalue );
> +  q2 = std::move(cg2)();
> +  VERIFY( q2.as_const && ! q2.as_lvalue );
> +#endif
>  }
>
>  void
> @@ -147,9 +191,53 @@ test03()
>    static_assert(is_invocable_r_v<int&, G4&&>);
>    static_assert(is_invocable_r_v<void*, const G4&>);
>    static_assert(is_invocable_r_v<void*, const G4&&>);
> +
> +#if __cpp_lib_bind_front >= 202306
> +  constexpr static F f{};
> +
> +  auto g5 = bind_front<f>(i); // call wrapper has bound arg of type int
> +  using G5 = decltype(g5);
> +  // Invoking G5& will pass g5's bound arg as int&, so calls first
> overload:
> +  static_assert(is_invocable_r_v<int&, G5&, void*>);
> +  // Invoking const G5& or G&& calls second overload:
> +  static_assert(is_invocable_r_v<void*, const G5&, void*>);
> +  static_assert(is_invocable_r_v<void*, G5&&, void*>);
> +  void* p5 = static_cast<G5&&>(g5)(vp);
> +  VERIFY( p5 == vp );
> +
> +  auto g6 = bind_front<f>(std::ref(i)); // bound arg of type int&
> +  using G6 = decltype(g6);
> +  // Bound arg always forwarded as int& even from G6&& or const G6&
> +  static_assert(is_invocable_r_v<int&, G6&, void*>);
> +  static_assert(is_invocable_r_v<int&, G6&&, void*>);
> +  // But cannot call first overload on const G6:
> +  static_assert(is_invocable_r_v<void*, const G6&, void*>);
> +  static_assert(is_invocable_r_v<void*, const G6&&, void*>);
> +  int& i6 = g6(vp);
> +  VERIFY( &i6 == &i );
> +  int& i6r = static_cast<G6&&>(g6)(vp);
> +  VERIFY( &i6r == &i );
> +  void* p6 = const_cast<const G6&>(g6)(vp);
> +  VERIFY( p6 == vp );
> +
> +  auto g7 = bind_front<f>(std::cref(i)); // bound arg of type const int&
> +  using G7 = decltype(g7);
> +  // Bound arg always forwarded as const int& so can only call second
> overload:
> +  static_assert(is_invocable_r_v<void*, G7&, void*>);
> +  static_assert(is_invocable_r_v<void*, G7&&, void*>);
> +  static_assert(is_invocable_r_v<void*, const G7&, void*>);
> +  static_assert(is_invocable_r_v<void*, const G7&&, void*>);
> +
> +  auto g8 = bind_front<g7>(nullptr);
> +  using G8 = decltype(g8);
> +  static_assert(is_invocable_r_v<int&, G8&>);
> +  static_assert(is_invocable_r_v<int&, G8&&>);
> +  static_assert(is_invocable_r_v<void*, const G8&>);
> +  static_assert(is_invocable_r_v<void*, const G8&&>);
> +#endif
>  }
>
> -int f(int i, int j, int k) { return i + j + k; }
> +constexpr int f(int i, int j, int k) { return i + j + k; }
>
>  void
>  test04()
> @@ -165,6 +253,19 @@ test04()
>    auto g3 = bind_front(f, 1, 2, 3);
>    VERIFY( g3() == 6 );
>    VERIFY( bind_front(g2, 3)() == 6 );
> +#if __cpp_lib_bind_front >= 202306
> +  const auto g4 = bind_front<f>();
> +  VERIFY( g4(1, 2, 3) == 6 );
> +  const auto g5 = bind_front<f>(1);
> +  VERIFY( g5(2, 3) == 6 );
> +  VERIFY( bind_front<g4>(1)(2, 3) == 6 );
> +  const auto g6 = bind_front<f>(1, 2);
> +  VERIFY( g6(3) == 6 );
> +  VERIFY( bind_front<g5>(2)(3) == 6 );
> +  const auto g7 = bind_front<f>(1, 2, 3);
> +  VERIFY( g7() == 6 );
> +  VERIFY( bind_front<g6>(3)() == 6 );
> +#endif
>  }
>
>  int
> --
> 2.50.0
>
>

Reply via email to