[PATCH] Simplify common case of use_future_t that uses std::allocator

[Jonathan Wakely]

There is no need to store and pass around the allocator object when it's
an instance of std::allocator. Define a partial specialization of
std::use_future_t and the corresponding completion token so that no
allocator is stored. Overload the completion handler constructor to not
expect an allocator to be stored.

        * include/experimental/executor (__use_future_ct, use_future_t):
        Define partial specializations for std::allocator.
        (__use_future_ch): Overload constructor for completion tokens using
        std::allocator.

Tested x86_64-linux, committed to trunk.



commit ff1859de72d39f46118df4f568ee90d78c6be937
Author: Jonathan Wakely <jwak...@redhat.com>
Date:   Thu Oct 24 15:34:17 2019 +0100

    Simplify common case of use_future_t that uses std::allocator
    
    There is no need to store and pass around the allocator object when it's
    an instance of std::allocator. Define a partial specialization of
    std::use_future_t and the corresponding completion token so that no
    allocator is stored. Overload the completion handler constructor to not
    expect an allocator to be stored.
    
            * include/experimental/executor (__use_future_ct, use_future_t):
            Define partial specializations for std::allocator.
            (__use_future_ch): Overload constructor for completion tokens using
            std::allocator.

diff --git a/libstdc++-v3/include/experimental/executor 
b/libstdc++-v3/include/experimental/executor
index ef141e92cd3..ed18730951c 100644
--- a/libstdc++-v3/include/experimental/executor
+++ b/libstdc++-v3/include/experimental/executor
@@ -1501,12 +1501,18 @@ inline namespace v1
       std::tuple<_Func, _Alloc> _M_t;
     };
 
+  template<typename _Func, typename _Tp>
+    struct __use_future_ct<_Func, std::allocator<_Tp>>
+    {
+      _Func _M_f;
+    };
+
   template<typename _ProtoAllocator = allocator<void>>
     class use_future_t
     {
     public:
       // use_future_t types:
-      typedef _ProtoAllocator allocator_type;
+      using allocator_type = _ProtoAllocator;
 
       // use_future_t members:
       constexpr use_future_t() noexcept : _M_alloc() { }
@@ -1514,7 +1520,7 @@ inline namespace v1
       explicit
       use_future_t(const _ProtoAllocator& __a) noexcept : _M_alloc(__a) { }
 
-      template<class _OtherAllocator>
+      template<typename _OtherAllocator>
        use_future_t<_OtherAllocator>
        rebind(const _OtherAllocator& __a) const noexcept
        { return use_future_t<_OtherAllocator>(__a); }
@@ -1533,6 +1539,35 @@ inline namespace v1
       _ProtoAllocator _M_alloc;
     };
 
+  template<typename _Tp>
+    class use_future_t<std::allocator<_Tp>>
+    {
+    public:
+      // use_future_t types:
+      using allocator_type = std::allocator<_Tp>;
+
+      // use_future_t members:
+      constexpr use_future_t() noexcept = default;
+
+      explicit
+      use_future_t(const allocator_type& __a) noexcept { }
+
+      template<class _Up>
+       use_future_t<std::allocator<_Up>>
+       rebind(const std::allocator<_Up>& __a) const noexcept
+       { return use_future_t<std::allocator<_Up>>(__a); }
+
+      allocator_type get_allocator() const noexcept { return {}; }
+
+      template<typename _Func>
+       auto
+       operator()(_Func&& __f) const
+       {
+         using _Token = __use_future_ct<decay_t<_Func>, allocator_type>;
+         return _Token{std::forward<_Func>(__f)};
+       }
+    };
+
   constexpr use_future_t<> use_future = use_future_t<>();
 
   template<typename _Func, typename _Alloc, typename _Res, typename... _Args>
@@ -1552,6 +1587,12 @@ inline namespace v1
          _M_promise{ std::get<1>(__token._M_t) }
        { }
 
+      template<typename _Tp>
+       explicit
+       __use_future_ch(__use_future_ct<_Func, std::allocator<_Tp>>&& __token)
+       : _M_f{ std::move(__token._M_f) }
+       { }
+
       void
       operator()(_Args&&... __args)
       {