Remove unnecessary typename before dependent names

examples/benchmark/fibonacci.cpp

@@ -29,7 +29,7 @@ auto serial_fib(long n) -> long {
 
 template <class... Ts>
 using any_sender_of =
-  typename exec::any_receiver_ref<stdexec::completion_signatures<Ts...>>::template any_sender<>;
+  exec::any_receiver_ref<stdexec::completion_signatures<Ts...>>::template any_sender<>;
 
 using fib_sender = any_sender_of<stdexec::set_value_t(long)>;
 

examples/nvexec/maxwell/snr.cuh

@@ -61,14 +61,14 @@ namespace ex = stdexec;
 namespace nvexec::_strm::repeat_n {
   template <class OpT>
   class receiver_2_t : public stream_receiver_base {
-    using Sender = typename OpT::PredSender;
-    using Receiver = typename OpT::Receiver;
+    using Sender = OpT::PredSender;
+    using Receiver = OpT::Receiver;
 
     OpT& op_state_;
 
    public:
     void set_value() noexcept {
-      using inner_op_state_t = typename OpT::inner_op_state_t;
+      using inner_op_state_t = OpT::inner_op_state_t;
 
       op_state_.i_++;
 
@@ -95,7 +95,7 @@ namespace nvexec::_strm::repeat_n {
       op_state_.propagate_completion_signal(set_stopped_t());
     }
 
-    auto get_env() const noexcept -> typename OpT::env_t {
+    auto get_env() const noexcept -> OpT::env_t {
       return op_state_.make_env();
     }
 
@@ -106,13 +106,13 @@ namespace nvexec::_strm::repeat_n {
 
   template <class OpT>
   class receiver_1_t : public stream_receiver_base {
-    using Receiver = typename OpT::Receiver;
+    using Receiver = OpT::Receiver;
 
     OpT& op_state_;
 
    public:
     void set_value() noexcept {
-      using inner_op_state_t = typename OpT::inner_op_state_t;
+      using inner_op_state_t = OpT::inner_op_state_t;
 
       if (op_state_.n_) {
         auto sch = ex::get_scheduler(ex::get_env(op_state_.rcvr_));
@@ -137,7 +137,7 @@ namespace nvexec::_strm::repeat_n {
       op_state_.propagate_completion_signal(set_stopped_t());
     }
 
-    auto get_env() const noexcept -> typename OpT::env_t {
+    auto get_env() const noexcept -> OpT::env_t {
       return op_state_.make_env();
     }
 
@@ -196,16 +196,16 @@ namespace repeat_n_detail {
 
   template <class OpT>
   class receiver_2_t {
-    using Sender = typename OpT::PredSender;
-    using Receiver = typename OpT::Receiver;
+    using Sender = OpT::PredSender;
+    using Receiver = OpT::Receiver;
 
     OpT& op_state_;
 
    public:
     using receiver_concept = ex::receiver_t;
 
     void set_value() noexcept {
-      using inner_op_state_t = typename OpT::inner_op_state_t;
+      using inner_op_state_t = OpT::inner_op_state_t;
 
       op_state_.i_++;
 
@@ -244,15 +244,15 @@ namespace repeat_n_detail {
 
   template <class OpT>
   class receiver_1_t {
-    using Receiver = typename OpT::Receiver;
+    using Receiver = OpT::Receiver;
 
     OpT& op_state_;
 
    public:
     using receiver_concept = ex::receiver_t;
 
     void set_value() noexcept {
-      using inner_op_state_t = typename OpT::inner_op_state_t;
+      using inner_op_state_t = OpT::inner_op_state_t;
 
       if (op_state_.n_) {
         auto sch = ex::get_scheduler(ex::get_env(op_state_.rcvr_));

include/asioexec/as_default_on.hpp

@@ -27,9 +27,10 @@ namespace asioexec {
 
   template <typename CompletionToken, typename IoObject>
   using as_default_on_t =
-    typename std::remove_cvref_t<IoObject>::template rebind_executor<executor_with_default<
+    std::remove_cvref_t<IoObject>::template rebind_executor<executor_with_default<
       std::remove_cvref_t<decltype(std::declval<IoObject&>().get_executor())>,
-      CompletionToken>>::other;
+      CompletionToken
+    >>::other;
 
   namespace detail::as_default_on {
 

include/asioexec/use_sender.hpp

@@ -139,7 +139,7 @@ namespace asioexec {
     };
 
     template <typename... Args>
-    using transform_set_value_t = typename transform_set_value<Args...>::type;
+    using transform_set_value_t = transform_set_value<Args...>::type;
 
     template <typename Signatures>
     using completion_signatures = ::stdexec::transform_completion_signatures<

include/exec/__detail/__basic_sequence.hpp

@@ -37,7 +37,7 @@ namespace exec {
     using __t = __seqexpr;
     using __id = __seqexpr;
     using __desc_t = decltype(_DescriptorFn());
-    using __tag_t = typename __desc_t::__tag;
+    using __tag_t = __desc_t::__tag;
     using __captures_t =
       stdexec::__minvoke<__desc_t, stdexec::__q<stdexec::__detail::__captures_t>>;
 

include/exec/__detail/__bwos_lifo_queue.hpp

@@ -84,7 +84,7 @@ namespace exec::bwos {
 
    private:
     template <class Sp>
-    using allocator_of_t = typename std::allocator_traits<Allocator>::template rebind_alloc<Sp>;
+    using allocator_of_t = std::allocator_traits<Allocator>::template rebind_alloc<Sp>;
 
     struct block_type {
       explicit block_type(std::size_t block_size, Allocator allocator = Allocator());
@@ -319,8 +319,8 @@ namespace exec::bwos {
   }
 
   template <class Tp, class Allocator>
-  auto lifo_queue<Tp, Allocator>::block_type::operator=(const block_type &other) ->
-    typename lifo_queue<Tp, Allocator>::block_type & {
+  auto lifo_queue<Tp, Allocator>::block_type::operator=(const block_type &other)
+    -> lifo_queue<Tp, Allocator>::block_type & {
     head_.store(other.head_.load(std::memory_order_relaxed), std::memory_order_relaxed);
     tail_.store(other.tail_.load(std::memory_order_relaxed), std::memory_order_relaxed);
     steal_tail_.store(other.steal_tail_.load(std::memory_order_relaxed), std::memory_order_relaxed);
@@ -339,8 +339,8 @@ namespace exec::bwos {
   }
 
   template <class Tp, class Allocator>
-  auto lifo_queue<Tp, Allocator>::block_type::operator=(block_type &&other) noexcept ->
-    typename lifo_queue<Tp, Allocator>::block_type & {
+  auto lifo_queue<Tp, Allocator>::block_type::operator=(block_type &&other) noexcept
+    -> lifo_queue<Tp, Allocator>::block_type & {
     head_.store(other.head_.load(std::memory_order_relaxed), std::memory_order_relaxed);
     tail_.store(other.tail_.load(std::memory_order_relaxed), std::memory_order_relaxed);
     steal_tail_.store(other.steal_tail_.load(std::memory_order_relaxed), std::memory_order_relaxed);

include/exec/any_sender_of.hpp

@@ -333,7 +333,7 @@ namespace exec {
         void __construct_small(_As&&... __args) {
           static_assert(sizeof(_Tp) <= __buffer_size && alignof(_Tp) <= __alignment);
           _Tp* __pointer = reinterpret_cast<_Tp*>(&__buffer_[0]);
-          using _Alloc = typename std::allocator_traits<_Allocator>::template rebind_alloc<_Tp>;
+          using _Alloc = std::allocator_traits<_Allocator>::template rebind_alloc<_Tp>;
           _Alloc __alloc{__allocator_};
           std::allocator_traits<_Alloc>::construct(
             __alloc, __pointer, static_cast<_As&&>(__args)...);
@@ -342,7 +342,7 @@ namespace exec {
 
         template <class _Tp, class... _As>
         void __construct_large(_As&&... __args) {
-          using _Alloc = typename std::allocator_traits<_Allocator>::template rebind_alloc<_Tp>;
+          using _Alloc = std::allocator_traits<_Allocator>::template rebind_alloc<_Tp>;
           _Alloc __alloc{__allocator_};
           _Tp* __pointer = std::allocator_traits<_Alloc>::allocate(__alloc, 1);
           STDEXEC_TRY {
@@ -361,7 +361,7 @@ namespace exec {
           if (!__self.__object_pointer_) {
             return;
           }
-          using _Alloc = typename std::allocator_traits<_Allocator>::template rebind_alloc<_Tp>;
+          using _Alloc = std::allocator_traits<_Allocator>::template rebind_alloc<_Tp>;
           _Alloc __alloc{__self.__allocator_};
           _Tp* __pointer = static_cast<_Tp*>(std::exchange(__self.__object_pointer_, nullptr));
           std::allocator_traits<_Alloc>::destroy(__alloc, __pointer);
@@ -500,15 +500,15 @@ namespace exec {
       void __construct_small(_As&&... __args) {
         static_assert(sizeof(_Tp) <= __buffer_size && alignof(_Tp) <= __alignment);
         _Tp* __pointer = reinterpret_cast<_Tp*>(&__buffer_[0]);
-        using _Alloc = typename std::allocator_traits<_Allocator>::template rebind_alloc<_Tp>;
+        using _Alloc = std::allocator_traits<_Allocator>::template rebind_alloc<_Tp>;
         _Alloc __alloc{__allocator_};
         std::allocator_traits<_Alloc>::construct(__alloc, __pointer, static_cast<_As&&>(__args)...);
         __object_pointer_ = __pointer;
       }
 
       template <class _Tp, class... _As>
       void __construct_large(_As&&... __args) {
-        using _Alloc = typename std::allocator_traits<_Allocator>::template rebind_alloc<_Tp>;
+        using _Alloc = std::allocator_traits<_Allocator>::template rebind_alloc<_Tp>;
         _Alloc __alloc{__allocator_};
         _Tp* __pointer = std::allocator_traits<_Alloc>::allocate(__alloc, 1);
         STDEXEC_TRY {
@@ -527,7 +527,7 @@ namespace exec {
         if (!__self.__object_pointer_) {
           return;
         }
-        using _Alloc = typename std::allocator_traits<_Allocator>::template rebind_alloc<_Tp>;
+        using _Alloc = std::allocator_traits<_Allocator>::template rebind_alloc<_Tp>;
         _Alloc __alloc{__self.__allocator_};
         _Tp* __pointer = static_cast<_Tp*>(std::exchange(__self.__object_pointer_, nullptr));
         std::allocator_traits<_Alloc>::destroy(__alloc, __pointer);
@@ -546,7 +546,7 @@ namespace exec {
         if constexpr (__is_small<_Tp>) {
           _Tp& __other_object = *__pointer;
           __self.template __construct_small<_Tp>(static_cast<_Tp&&>(__other_object));
-          using _Alloc = typename std::allocator_traits<_Allocator>::template rebind_alloc<_Tp>;
+          using _Alloc = std::allocator_traits<_Allocator>::template rebind_alloc<_Tp>;
           _Alloc __alloc{__self.__allocator_};
           std::allocator_traits<_Alloc>::destroy(__alloc, __pointer);
         } else {
@@ -873,9 +873,8 @@ namespace exec {
     struct __operation_base {
       STDEXEC_ATTRIBUTE(no_unique_address) _Receiver __rcvr_;
       stdexec::inplace_stop_source __stop_source_{};
-      using __stop_callback = typename stdexec::stop_token_of_t<
-        stdexec::env_of_t<_Receiver>
-      >::template callback_type<__on_stop_t>;
+      using __stop_callback =
+        stdexec::stop_token_of_t<stdexec::env_of_t<_Receiver>>::template callback_type<__on_stop_t>;
       std::optional<__stop_callback> __on_stop_{};
     };
 
@@ -1250,9 +1249,9 @@ namespace exec {
       }
 
       template <stdexec::__decays_to<any_sender> _Self, class... _Env>
-      requires(__any::__satisfies_receiver_query<decltype(_ReceiverQueries), _Env ...> && ...)
-      static auto get_completion_signatures(_Self&&, _Env&&...) noexcept ->
-        typename __sender_base::completion_signatures {
+        requires(__any::__satisfies_receiver_query<decltype(_ReceiverQueries), _Env...> && ...)
+      static auto get_completion_signatures(_Self&&, _Env&&...) noexcept
+        -> __sender_base::completion_signatures {
         return {};
       }
 
@@ -1298,10 +1297,10 @@ namespace exec {
           stdexec::get_completion_scheduler<stdexec::set_value_t>.signature<any_scheduler() noexcept>;
         template <class... _Queries>
         using __schedule_sender_fn =
-          typename __schedule_receiver::template any_sender<__any_scheduler_noexcept_signature>;
+          __schedule_receiver::template any_sender<__any_scheduler_noexcept_signature>;
 #else
         template <class... _Queries>
-        using __schedule_sender_fn = typename __schedule_receiver::template any_sender<
+        using __schedule_sender_fn = __schedule_receiver::template any_sender<
           stdexec::get_completion_scheduler<stdexec::set_value_t>.template signature<any_scheduler() noexcept>
         >;
 #endif

include/exec/async_scope.hpp

@@ -311,7 +311,7 @@ namespace exec {
 
       class __t : __subscription {
         using __forward_consumer =
-          typename stop_token_of_t<env_of_t<_Receiver>>::template callback_type<__forward_stopped>;
+          stop_token_of_t<env_of_t<_Receiver>>::template callback_type<__forward_stopped>;
 
         void __complete_() noexcept {
           STDEXEC_TRY {

include/exec/fork_join.hpp

@@ -59,7 +59,7 @@ namespace exec {
     >;
 
     template <class Completions>
-    using _variant_t = typename stdexec::__mset_insert<
+    using _variant_t = stdexec::__mset_insert<
       stdexec::__for_each_completion_signature<
         Completions,
         stdexec::__decayed_tuple,

include/exec/just_from.hpp

@@ -153,7 +153,7 @@ namespace exec {
     };
 
     template <class Fn, class Tag = JustTag>
-    using _sndr = typename Tag::template _sndr<Fn>;
+    using _sndr = Tag::template _sndr<Fn>;
 
    public:
     template <class Fn>

include/exec/libdispatch_queue.hpp

@@ -420,7 +420,7 @@ namespace exec {
     libdispatch_queue &queue_;
 
     void enqueue() noexcept {
-      using bulk_task = typename shared_state::bulk_task;
+      using bulk_task = shared_state::bulk_task;
       shared_state_.tasks_.reserve(static_cast<std::size_t>(shared_state_.shape_));
       for (Shape i{}; i != shared_state_.shape_; ++i) {
         shared_state_.tasks_.push_back(bulk_task(&shared_state_, i));

include/exec/sequence/any_sequence_of.hpp

@@ -27,18 +27,18 @@ namespace exec {
       template <__valid_completion_signatures _Sigs>
       struct __rcvr_next_vfun {
         using __return_sigs = completion_signatures<set_value_t(), set_stopped_t()>;
-        using __void_sender = typename any_receiver_ref<__return_sigs>::template any_sender<>;
-        using __item_sender = typename any_receiver_ref<_Sigs>::template any_sender<>;
+        using __void_sender = any_receiver_ref<__return_sigs>::template any_sender<>;
+        using __item_sender = any_receiver_ref<_Sigs>::template any_sender<>;
         __void_sender (*__fn_)(void*, __item_sender&&) noexcept;
       };
 
       template <class _Rcvr>
       struct __rcvr_next_vfun_fn {
         using __return_sigs = completion_signatures<set_value_t(), set_stopped_t()>;
-        using __void_sender = typename any_receiver_ref<__return_sigs>::template any_sender<>;
+        using __void_sender = any_receiver_ref<__return_sigs>::template any_sender<>;
 
         template <class _Sigs>
-        using __item_sender = typename any_receiver_ref<_Sigs>::template any_sender<>;
+        using __item_sender = any_receiver_ref<_Sigs>::template any_sender<>;
 
         template <__valid_completion_signatures _Sigs>
         constexpr auto
@@ -55,7 +55,7 @@ namespace exec {
 
       template <class _NextSigs, class... _Sigs, class... _Queries>
       struct __next_vtable<_NextSigs, completion_signatures<_Sigs...>, _Queries...> {
-        using __item_sender = typename any_receiver_ref<_NextSigs>::template any_sender<>;
+        using __item_sender = any_receiver_ref<_NextSigs>::template any_sender<>;
         using __item_types = item_types<__item_sender>;
 
         struct __t
@@ -108,10 +108,10 @@ namespace exec {
       struct __receiver_ref<completion_signatures<_Sigs...>, _Queries...> {
         struct __t {
           using __return_sigs = completion_signatures<set_value_t(), set_stopped_t()>;
-          using __void_sender = typename any_receiver_ref<__return_sigs>::template any_sender<>;
+          using __void_sender = any_receiver_ref<__return_sigs>::template any_sender<>;
           using __next_sigs = completion_signatures<_Sigs...>;
           using __sigs = __to_sequence_completions_t<__next_sigs>;
-          using __item_sender = typename any_receiver_ref<__next_sigs>::template any_sender<>;
+          using __item_sender = any_receiver_ref<__next_sigs>::template any_sender<>;
           using __item_types = item_types<__item_sender>;
 
           using __vtable_t = stdexec::__t<__next_vtable<__next_sigs, __sigs, _Queries...>>;
@@ -233,7 +233,7 @@ namespace exec {
       using __vtable_t = stdexec::__t<__sender_vtable<_Sigs, _SenderQueries, _ReceiverQueries>>;
 
       using __sigs = __to_sequence_completions_t<_Sigs>;
-      using __item_sender = typename any_receiver_ref<_Sigs>::template any_sender<>;
+      using __item_sender = any_receiver_ref<_Sigs>::template any_sender<>;
 
       class __t {
        public:
@@ -343,8 +343,8 @@ namespace exec {
     using __id = any_sender;
     using __t = any_sender;
     using sender_concept = sequence_sender_t;
-    using completion_signatures = typename __sender_base::completion_signatures;
-    using item_types = typename __sender_base::item_types;
+    using completion_signatures = __sender_base::completion_signatures;
+    using item_types = __sender_base::item_types;
 
     template <stdexec::__not_decays_to<any_sender> _Sender>
       requires stdexec::sender_in<_Sender, __env_t> && sequence_sender_to<_Sender, __receiver_base>

include/exec/sequence_senders.hpp

@@ -154,7 +154,7 @@ namespace exec {
     concept __with_tag_invoke = tag_invocable<get_item_types_t, __tfx_sender<_Sender, _Env>, _Env>;
 
     template <class _Sender, class _Env>
-    using __member_alias_t = typename __decay_t<__tfx_sender<_Sender, _Env>>::item_types;
+    using __member_alias_t = __decay_t<__tfx_sender<_Sender, _Env>>::item_types;
 
     template <class _Sender, class _Env>
     concept __with_member_alias = __mvalid<__member_alias_t, _Sender, _Env>;

include/exec/static_thread_pool.hpp

@@ -1577,7 +1577,7 @@ namespace exec {
           using NextReceiver = stdexec::__t<next_receiver<Range, ReceiverId>>;
           using ItemOperation = connect_result_t<NextSender, NextReceiver>;
 
-          using ItemAllocator = typename std::allocator_traits<Allocator>::template rebind_alloc<
+          using ItemAllocator = std::allocator_traits<Allocator>::template rebind_alloc<
             stdexec::__manual_lifetime<ItemOperation>
           >;
 

include/exec/system_context.hpp

@@ -324,7 +324,7 @@ namespace exec {
     template <class _Previous, class _BulkState, class... _As>
     struct __typed_forward_args_receiver : __forward_args_receiver<_Previous> {
       using __base_t = __forward_args_receiver<_Previous>;
-      using __rcvr_t = typename _BulkState::__rcvr_t;
+      using __rcvr_t = _BulkState::__rcvr_t;
 
       /// Stores `__as` in the base class storage, with the right types.
       explicit __typed_forward_args_receiver(_As&&... __as) {
@@ -617,7 +617,7 @@ namespace exec {
       -> __detail::__system_bulk_op<_IsUnchunked, _Previous, _Size, _Fn, _Rcvr, _Parallelize> {
       using __res_t =
         __detail::__system_bulk_op<_IsUnchunked, _Previous, _Size, _Fn, _Rcvr, _Parallelize>;
-      using __receiver_t = typename __res_t::__intermediate_receiver_t;
+      using __receiver_t = __res_t::__intermediate_receiver_t;
       return {std::move(*this), std::move(__rcvr), [this](auto& __op) {
                 // Connect bulk input receiver with the previous operation and store in the operating state.
                 return stdexec::connect(