[PATCH] P0356R5 Simplified partial function application

[PATCH] P0356R5 Simplified partial function application

[Jonathan Wakely]

[-- Attachment #1: Type: text/plain, Size: 255 bytes --]

	* include/std/functional [C++20] (_Bind_front, _Bind_front_t): Define
	helpers for bind_front.
	(bind_front, __cpp_lib_bind_front): Define.
	* testsuite/20_util/function_objects/bind_front/1.cc: New test.

Tested powerpc64le-linux, committed to trunk.



[-- Attachment #2: patch.txt --]
[-- Type: text/plain, Size: 10128 bytes --]

commit 1944c1ed745ed945860d9e28ff48e3d7436e6ba3
Author: Jonathan Wakely <jwakely@redhat.com>
Date:   Thu Mar 7 13:06:52 2019 +0000

    P0356R5 Simplified partial function application
    
            * include/std/functional [C++20] (_Bind_front, _Bind_front_t): Define
            helpers for bind_front.
            (bind_front, __cpp_lib_bind_front): Define.
            * testsuite/20_util/function_objects/bind_front/1.cc: New test.

diff --git a/libstdc++-v3/include/std/functional b/libstdc++-v3/include/std/functional
index 911a041cba5..8cf2c670648 100644
--- a/libstdc++-v3/include/std/functional
+++ b/libstdc++-v3/include/std/functional
@@ -836,6 +836,106 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 					  std::forward<_BoundArgs>(__args)...);
     }
 
+#if __cplusplus > 201703L
+#define __cpp_lib_bind_front 201902L
+
+  template<typename _Fd, typename... _BoundArgs>
+    struct _Bind_front
+    {
+      static_assert(is_move_constructible_v<_Fd>);
+      static_assert((is_move_constructible_v<_BoundArgs> && ...));
+
+      // First parameter is to ensure this constructor is never used
+      // instead of the copy/move constructor.
+      template<typename _Fn, typename... _Args>
+	explicit constexpr
+	_Bind_front(int, _Fn&& __fn, _Args&&... __args)
+	noexcept(__and_<is_nothrow_constructible<_Fd, _Fn>,
+			is_nothrow_constructible<_BoundArgs, _Args>...>::value)
+	: _M_fd(std::forward<_Fn>(__fn)),
+	  _M_bound_args(std::forward<_Args>(__args)...)
+	{ static_assert(sizeof...(_Args) == sizeof...(_BoundArgs)); }
+
+      _Bind_front(const _Bind_front&) = default;
+      _Bind_front(_Bind_front&&) = default;
+      _Bind_front& operator=(const _Bind_front&) = default;
+      _Bind_front& operator=(_Bind_front&&) = default;
+      ~_Bind_front() = default;
+
+      template<typename... _CallArgs>
+	constexpr
+	invoke_result_t<_Fd&, _BoundArgs&..., _CallArgs...>
+	operator()(_CallArgs&&... __call_args) &
+	noexcept(is_nothrow_invocable_v<_Fd&, _BoundArgs&..., _CallArgs...>)
+	{
+	  return _S_call(*this, _BoundIndices(),
+	      std::forward<_CallArgs>(__call_args)...);
+	}
+
+      template<typename... _CallArgs>
+	constexpr
+	invoke_result_t<const _Fd&, const _BoundArgs&..., _CallArgs...>
+	operator()(_CallArgs&&... __call_args) const &
+	noexcept(is_nothrow_invocable_v<const _Fd&, const _BoundArgs&...,
+					_CallArgs...>)
+	{
+	  return _S_call(*this, _BoundIndices(),
+	      std::forward<_CallArgs>(__call_args)...);
+	}
+
+      template<typename... _CallArgs>
+	constexpr
+	invoke_result_t<_Fd, _BoundArgs..., _CallArgs...>
+	operator()(_CallArgs&&... __call_args) &&
+	noexcept(is_nothrow_invocable_v<_Fd, _BoundArgs..., _CallArgs...>)
+	{
+	  return _S_call(std::move(*this), _BoundIndices(),
+	      std::forward<_CallArgs>(__call_args)...);
+	}
+
+      template<typename... _CallArgs>
+	constexpr
+	invoke_result_t<const _Fd, const _BoundArgs..., _CallArgs...>
+	operator()(_CallArgs&&... __call_args) const &&
+	noexcept(is_nothrow_invocable_v<const _Fd, const _BoundArgs...,
+					_CallArgs...>)
+	{
+	  return _S_call(std::move(*this), _BoundIndices(),
+	      std::forward<_CallArgs>(__call_args)...);
+	}
+
+    private:
+      using _BoundIndices = index_sequence_for<_BoundArgs...>;
+
+      template<typename _Tp, size_t... _Ind, typename... _CallArgs>
+	static constexpr
+	decltype(auto)
+	_S_call(_Tp&& __g, index_sequence<_Ind...>, _CallArgs&&... __call_args)
+	{
+	  return std::invoke(std::forward<_Tp>(__g)._M_fd,
+	      std::get<_Ind>(std::forward<_Tp>(__g)._M_bound_args)...,
+	      std::forward<_CallArgs>(__call_args)...);
+	}
+
+      _Fd _M_fd;
+      std::tuple<_BoundArgs...> _M_bound_args;
+    };
+
+  template<typename _Fn, typename... _Args>
+    using _Bind_front_t
+      = _Bind_front<decay_t<_Fn>, unwrap_ref_decay_t<_Args>...>;
+
+  template<typename _Fn, typename... _Args>
+    _Bind_front_t<_Fn, _Args...>
+    bind_front(_Fn&& __fn, _Args&&... __args)
+    noexcept(is_nothrow_constructible_v<int, _Bind_front_t<_Fn, _Args...>,
+					_Fn, _Args...>)
+    {
+      return _Bind_front_t<_Fn, _Args...>(0, std::forward<_Fn>(__fn),
+					  std::forward<_Args>(__args)...);
+    }
+#endif
+
 #if __cplusplus >= 201402L
   /// Generalized negator.
   template<typename _Fn>
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
new file mode 100644
index 00000000000..eea31e9e8a5
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/function_objects/bind_front/1.cc
@@ -0,0 +1,176 @@
+// Copyright (C) 2014-2019 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+// { dg-options "-std=gnu++2a" }
+// { dg-do compile { target c++2a } }
+
+#include <functional>
+#include <testsuite_hooks.h>
+
+#ifndef __cpp_lib_bind_front
+# error "Feature test macro for bind_front is missing"
+#elif __cpp_lib_bind_front < 201811L
+# error "Feature test macro for bind_front has wrong value"
+#endif
+
+using std::bind_front;
+using std::is_same_v;
+using std::is_invocable_v;
+using std::is_invocable_r_v;
+
+void
+test01()
+{
+  struct F { void operator()() {} };
+
+  // Arguments should be decayed:
+  static_assert(std::is_same_v<
+      decltype(bind_front(std::declval<F>(), std::declval<int>())),
+      decltype(bind_front(std::declval<F&>(), std::declval<int&>()))
+      >);
+  static_assert(std::is_same_v<
+      decltype(bind_front(std::declval<F>(), std::declval<int>())),
+      decltype(bind_front(std::declval<const F&>(), std::declval<const int&>()))
+      >);
+
+  // Reference wrappers should be handled:
+  static_assert(!std::is_same_v<
+      decltype(bind_front(std::declval<F>(), std::declval<int&>())),
+      decltype(bind_front(std::declval<F>(), std::ref(std::declval<int&>())))
+      >);
+  static_assert(!std::is_same_v<
+      decltype(bind_front(std::declval<F>(), std::declval<const int&>())),
+      decltype(bind_front(std::declval<F>(), std::cref(std::declval<int&>())))
+      >);
+  static_assert(!std::is_same_v<
+      decltype(bind_front(std::declval<F>(), std::ref(std::declval<int&>()))),
+      decltype(bind_front(std::declval<F>(), std::cref(std::declval<int&>())))
+      >);
+}
+
+void
+test02()
+{
+  struct quals
+  {
+    bool as_const;
+    bool as_lvalue;
+  };
+
+  struct F
+  {
+    quals operator()() & { return { false, true }; }
+    quals operator()() const & { return { true, true }; }
+    quals operator()() && { return { false, false }; }
+    quals operator()() const && { return { true, false }; }
+  };
+
+  F f;
+  auto g = bind_front(f);
+  const auto& cg = g;
+  quals q;
+
+  // constness and value category should be forwarded to the target object:
+  q = g();
+  VERIFY( ! q.as_const && q.as_lvalue );
+  std::move(g)();
+  VERIFY( ! q.as_const && ! q.as_lvalue );
+  q = cg();
+  VERIFY( q.as_const && q.as_lvalue );
+  q = std::move(cg)();
+  VERIFY( q.as_const && ! q.as_lvalue );
+}
+
+void
+test03()
+{
+  struct F
+  {
+    int& operator()(int& i, void*) { return i; }
+    void* operator()(int, void* p) const { return p; }
+  };
+
+  int i = 5;
+  void* vp = &vp; // arbitrary void* value
+
+  auto g1 = bind_front(F{}, i); // call wrapper has bound arg of type int
+  using G1 = decltype(g1);
+  // Invoking G1& will pass g1's bound arg as int&, so calls first overload:
+  static_assert(is_invocable_r_v<int&, G1&, void*>);
+  // Invoking const G1& or G&& calls second overload:
+  static_assert(is_invocable_r_v<void*, const G1&, void*>);
+  static_assert(is_invocable_r_v<void*, G1&&, void*>);
+  void* p1 = static_cast<G1&&>(g1)(vp);
+  VERIFY( p1 == vp );
+
+  auto g2 = bind_front(F{}, std::ref(i)); // bound arg of type int&
+  using G2 = decltype(g2);
+  // Bound arg always forwarded as int& even from G2&& or const G2&
+  static_assert(is_invocable_r_v<int&, G2&, void*>);
+  static_assert(is_invocable_r_v<int&, G2&&, void*>);
+  // But cannot call first overload on const G2:
+  static_assert(is_invocable_r_v<void*, const G2&, void*>);
+  static_assert(is_invocable_r_v<void*, const G2&&, void*>);
+  int& i2 = g2(vp);
+  VERIFY( &i2 == &i );
+  int& i2r = static_cast<G2&&>(g2)(vp);
+  VERIFY( &i2r == &i );
+  void* p2 = const_cast<const G2&>(g2)(vp);
+  VERIFY( p2 == vp );
+
+  auto g3 = bind_front(F{}, std::cref(i)); // bound arg of type const int&
+  using G3 = decltype(g3);
+  // Bound arg always forwarded as const int& so can only call second overload:
+  static_assert(is_invocable_r_v<void*, G3&, void*>);
+  static_assert(is_invocable_r_v<void*, G3&&, void*>);
+  static_assert(is_invocable_r_v<void*, const G3&, void*>);
+  static_assert(is_invocable_r_v<void*, const G3&&, void*>);
+
+  auto g4 = bind_front(g2, nullptr);
+  using G4 = decltype(g4);
+  static_assert(is_invocable_r_v<int&, G4&>);
+  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&&>);
+}
+
+int f(int i, int j, int k) { return i + j + k; }
+
+void
+test04()
+{
+  auto g = bind_front(f);
+  VERIFY( g(1, 2, 3) == 6 );
+  auto g1 = bind_front(f, 1);
+  VERIFY( g1(2, 3) == 6 );
+  VERIFY( bind_front(g, 1)(2, 3) == 6 );
+  auto g2 = bind_front(f, 1, 2);
+  VERIFY( g2(3) == 6 );
+  VERIFY( bind_front(g1, 2)(3) == 6 );
+  auto g3 = bind_front(f, 1, 2, 3);
+  VERIFY( g3() == 6 );
+  VERIFY( bind_front(g2, 3)() == 6 );
+}
+
+int
+main()
+{
+  test01();
+  test02();
+  test03();
+  test04();
+}

Re: [PATCH] P0356R5 Simplified partial function application

[Jonathan Wakely]

[-- Attachment #1: Type: text/plain, Size: 397 bytes --]

On 07/03/19 14:15 +0000, Jonathan Wakely wrote:
>	* include/std/functional [C++20] (_Bind_front, _Bind_front_t): Define
>	helpers for bind_front.
>	(bind_front, __cpp_lib_bind_front): Define.
>	* testsuite/20_util/function_objects/bind_front/1.cc: New test.

The new test had a typo, which wasn't noticed because the test was
only being compiled, not executed. Fixed like so, committed to trunk.


[-- Attachment #2: patch.txt --]
[-- Type: text/x-patch, Size: 1139 bytes --]

commit 2d3fddd4358a7ab0f92aa3295c7ac04c8dc6390f
Author: Jonathan Wakely <jwakely@redhat.com>
Date:   Thu Mar 7 14:34:21 2019 +0000

    Fix new test to run as well as compile
    
            * testsuite/20_util/function_objects/bind_front/1.cc: Change from
            compile test to run. Fix typo.

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 eea31e9e8a5..8ebc2bab41a 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
@@ -16,7 +16,7 @@
 // <http://www.gnu.org/licenses/>.
 
 // { dg-options "-std=gnu++2a" }
-// { dg-do compile { target c++2a } }
+// { dg-do run { target c++2a } }
 
 #include <functional>
 #include <testsuite_hooks.h>
@@ -87,7 +87,7 @@ test02()
   // constness and value category should be forwarded to the target object:
   q = g();
   VERIFY( ! q.as_const && q.as_lvalue );
-  std::move(g)();
+  q = std::move(g)();
   VERIFY( ! q.as_const && ! q.as_lvalue );
   q = cg();
   VERIFY( q.as_const && q.as_lvalue );

Re: [PATCH] P0356R5 Simplified partial function application

[Jonathan Wakely]

[-- Attachment #1: Type: text/plain, Size: 741 bytes --]

On 07/03/19 14:15 +0000, Jonathan Wakely wrote:
>	* include/std/functional [C++20] (_Bind_front, _Bind_front_t): Define
>	helpers for bind_front.
>	(bind_front, __cpp_lib_bind_front): Define.
>	* testsuite/20_util/function_objects/bind_front/1.cc: New test.

I'm considering something like the attached patch (but with better
names for __tag1 and __tag2 obviously). With this change bind_front
would unwrap nested binders, so that bind_front(bind_front(f, 1), 2)
would create a _Bind_front<F, int, int> instead of
_Bind_front<_Bind_front<F, int>, int>.

That would make the call go straight to the target object, instead of
through an extra layer of wrapper (which should improve compile times,
and also unoptimized runtime performance).




[-- Attachment #2: patch.txt --]
[-- Type: text/x-patch, Size: 3399 bytes --]

diff --git a/libstdc++-v3/include/std/functional b/libstdc++-v3/include/std/functional
index 8cf2c670648..da61b00bd15 100644
--- a/libstdc++-v3/include/std/functional
+++ b/libstdc++-v3/include/std/functional
@@ -839,6 +839,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 #if __cplusplus > 201703L
 #define __cpp_lib_bind_front 201902L
 
+  struct __tag1;
+  struct __tag2;
+
   template<typename _Fd, typename... _BoundArgs>
     struct _Bind_front
     {
@@ -849,13 +852,31 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       // instead of the copy/move constructor.
       template<typename _Fn, typename... _Args>
 	explicit constexpr
-	_Bind_front(int, _Fn&& __fn, _Args&&... __args)
+	_Bind_front(__tag1*, _Fn&& __fn, _Args&&... __args)
 	noexcept(__and_<is_nothrow_constructible<_Fd, _Fn>,
 			is_nothrow_constructible<_BoundArgs, _Args>...>::value)
 	: _M_fd(std::forward<_Fn>(__fn)),
 	  _M_bound_args(std::forward<_Args>(__args)...)
 	{ static_assert(sizeof...(_Args) == sizeof...(_BoundArgs)); }
 
+      template<typename... _BArgs, typename... _Args>
+	explicit constexpr
+	_Bind_front(__tag2*, const _Bind_front<_Fd, _BArgs...>& __fn,
+		    _Args&&... __args)
+	: _M_fd(__fn._M_fd),
+	  _M_bound_args(std::tuple_cat(__fn._M_bound_args,
+		std::make_tuple(std::forward<_Args>(__args)...)))
+	{ }
+
+      template<typename... _BArgs, typename... _Args>
+	explicit constexpr
+	_Bind_front(__tag2*, _Bind_front<_Fd, _BArgs...>&& __fn,
+		    _Args&&... __args)
+	: _M_fd(std::move(__fn._M_fd)),
+	  _M_bound_args(std::tuple_cat(std::move(__fn._M_bound_args),
+		std::make_tuple(std::forward<_Args>(__args)...)))
+	{ }
+
       _Bind_front(const _Bind_front&) = default;
       _Bind_front(_Bind_front&&) = default;
       _Bind_front& operator=(const _Bind_front&) = default;
@@ -919,19 +940,42 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
       _Fd _M_fd;
       std::tuple<_BoundArgs...> _M_bound_args;
+
+      template<typename _Fd2, typename... _BArgs>
+	friend class _Bind_front;
     };
 
   template<typename _Fn, typename... _Args>
-    using _Bind_front_t
-      = _Bind_front<decay_t<_Fn>, unwrap_ref_decay_t<_Args>...>;
+    struct _Bind_front_helper
+    {
+      using type = _Bind_front<_Fn, _Args...>;
+      using __tag = __tag1*;
+    };
+
+  template<typename _Fn, typename... _BoundArgs, typename... _Args>
+    struct _Bind_front_helper<_Bind_front<_Fn, _BoundArgs...>, _Args...>
+    {
+      using type = _Bind_front<_Fn, _BoundArgs..., _Args...>;
+      using __tag = __tag2*;
+    };
+
+  template<typename _Fn, typename... _Args>
+    using _Bind_front_t = typename
+      _Bind_front_helper<decay_t<_Fn>, unwrap_ref_decay_t<_Args>...>::type;
+
+  template<typename _Fn, typename... _Args>
+    using _Bind_front_tag = typename
+      _Bind_front_helper<decay_t<_Fn>, unwrap_ref_decay_t<_Args>...>::__tag;
 
   template<typename _Fn, typename... _Args>
     _Bind_front_t<_Fn, _Args...>
     bind_front(_Fn&& __fn, _Args&&... __args)
-    noexcept(is_nothrow_constructible_v<int, _Bind_front_t<_Fn, _Args...>,
+    noexcept(is_nothrow_constructible_v<_Bind_front_tag<_Fn, _Args...>,
+					_Bind_front_t<_Fn, _Args...>,
 					_Fn, _Args...>)
     {
-      return _Bind_front_t<_Fn, _Args...>(0, std::forward<_Fn>(__fn),
+      return _Bind_front_t<_Fn, _Args...>(_Bind_front_tag<_Fn, _Args...>(),
+					  std::forward<_Fn>(__fn),
 					  std::forward<_Args>(__args)...);
     }
 #endif