Merge pull request #1808 from ericniebler/metaprogramming-naming-consistency

rename `__types` to `__mlist`

Author: ericniebler

include/exec/any_sender_of.hpp

@@ -964,7 +964,7 @@ namespace exec {
       }
     };
 
-    template <class _Sigs, class _SenderQueries = __types<>, class _ReceiverQueries = __types<>>
+    template <class _Sigs, class _SenderQueries = __mlist<>, class _ReceiverQueries = __mlist<>>
     struct __sender {
       using sender_concept = STDEXEC::sender_t;
       using completion_signatures = _Sigs;
@@ -1047,7 +1047,7 @@ namespace exec {
       void* __sender_;
     };
 
-    template <class _ScheduleSender, class _SchedulerQueries = __types<>>
+    template <class _ScheduleSender, class _SchedulerQueries = __mlist<>>
     class __scheduler {
       static constexpr std::size_t __buffer_size = 4 * sizeof(void*);
       template <class _Ty>
@@ -1147,7 +1147,7 @@ namespace exec {
   } // namespace __any
 
   template <auto... _Sigs>
-  using queries = STDEXEC::__types<decltype(_Sigs)...>;
+  using queries = STDEXEC::__mlist<decltype(_Sigs)...>;
 
   template <class _Completions, auto... _ReceiverQueries>
   class any_receiver_ref {

include/exec/repeat_until.hpp

@@ -247,10 +247,10 @@ namespace exec {
         transform_sender(STDEXEC::set_value_t, _CvSender &&__sndr, const _Env &) noexcept {
         using namespace STDEXEC;
         using __child_t = __child_of<_CvSender>;
-        using __values_t = value_types_of_t<__child_t, _Env, __types, __types>;
+        using __values_t = value_types_of_t<__child_t, _Env, __mlist, __mlist>;
         auto &[__tag, __ign, __child] = __sndr;
 
-        if constexpr (__same_as<__values_t, __types<>> || __same_as<__values_t, __types<__types<>>>) {
+        if constexpr (__same_as<__values_t, __mlist<>> || __same_as<__values_t, __mlist<__mlist<>>>) {
           return repeat_until_t()(then(static_cast<__child_t &&>(__child), _never{}));
         } else {
           return __not_a_sender<

include/exec/sequence.hpp

@@ -135,7 +135,7 @@ namespace exec {
         STDEXEC::__mfill_c<
           sizeof...(Senders),
           STDEXEC::__mfalse,
-          STDEXEC::__mbind_back_q<STDEXEC::__types, STDEXEC::__mtrue>
+          STDEXEC::__mbind_back_q<STDEXEC::__mlist, STDEXEC::__mtrue>
         >
       >;
 

include/exec/sequence/any_sequence_of.hpp

@@ -211,7 +211,7 @@ namespace exec {
       void* __sender_;
     };
 
-    template <class _Sigs, class _SenderQueries = __types<>, class _ReceiverQueries = __types<>>
+    template <class _Sigs, class _SenderQueries = __mlist<>, class _ReceiverQueries = __mlist<>>
     struct __sequence_sender {
       using __receiver_ref_t = __next_receiver_ref<_Sigs, _ReceiverQueries>;
       using __vtable_t = __sender_vtable<_Sigs, _SenderQueries, _ReceiverQueries>;

include/exec/sequence/ignore_all_values.hpp

@@ -228,9 +228,9 @@ namespace exec {
     template <class _Sigs>
     using __result_variant_ = __transform_completion_signatures_t<
       _Sigs,
-      __mconst<__types<>>::__f,
-      __mcompose_q<__types, __mbind_front_q<__decayed_tuple, set_error_t>::__f>::__f,
-      __types<__tuple<set_stopped_t>>,
+      __mconst<__mlist<>>::__f,
+      __mcompose_q<__mlist, __mbind_front_q<__decayed_tuple, set_error_t>::__f>::__f,
+      __mlist<__tuple<set_stopped_t>>,
       __mconcat<__qq<__variant_for>>::__f
     >;
 

include/exec/sequence/merge_each.hpp

@@ -131,7 +131,7 @@ namespace exec {
     };
 
     template <class... _Args>
-    using drop = __types<>;
+    using drop = __mlist<>;
 
     enum class __completion_t {
       __started,
@@ -755,7 +755,7 @@ namespace exec {
         template <class... _Senders>
         using __f = __minvoke_if_c<
           __arg_of_base_t<_Env...>::template __valid_args<_Senders...>(),
-          __mconst<STDEXEC::__types<_Senders...>>,
+          __mconst<STDEXEC::__mlist<_Senders...>>,
           __value_completions_error<_Sequence, _Sender, _Env...>,
           _Senders...
         >;
@@ -770,9 +770,9 @@ namespace exec {
           // if set_value
           __arg_of_t<_Sequence, _Sender, _Env...>::template __f,
           // else remove
-          STDEXEC::__mconst<STDEXEC::__types<>>::__f,
-          // concat to __types result
-          STDEXEC::__mconcat<STDEXEC::__qq<STDEXEC::__types>>::__f
+          STDEXEC::__mconst<STDEXEC::__mlist<>>::__f,
+          // concat to __mlist result
+          STDEXEC::__mconcat<STDEXEC::__qq<STDEXEC::__mlist>>::__f
         >;
       };
 
@@ -786,9 +786,9 @@ namespace exec {
       struct __nested_sequences_fn {
         template <class... _Senders>
         using __f = __mapply<
-          STDEXEC::__munique<STDEXEC::__qq<__types>>,
+          STDEXEC::__munique<STDEXEC::__qq<__mlist>>,
           STDEXEC::__minvoke<
-            STDEXEC::__mconcat<STDEXEC::__qq<__types>>,
+            STDEXEC::__mconcat<STDEXEC::__qq<__mlist>>,
             __minvoke_q<__nested_sequences_from_item_type_t, _Sequence, _Senders, _Env...>...
           >
         >;
@@ -806,7 +806,7 @@ namespace exec {
       struct __all_nested_values_fn {
         template <class... _Sequences>
         using __f = STDEXEC::__minvoke<
-          STDEXEC::__mconcat<STDEXEC::__qq<STDEXEC::__types>>,
+          STDEXEC::__mconcat<STDEXEC::__qq<STDEXEC::__mlist>>,
           __item_types_of_t<_Sequences, _Env...>...
         >;
       };
@@ -824,15 +824,15 @@ namespace exec {
         template <class _Sender>
         using __f = STDEXEC::__error_types_t<
           __completion_signatures_of_t<_Sender, _Env...>,
-          STDEXEC::__qq<STDEXEC::__types>
+          STDEXEC::__qq<STDEXEC::__mlist>
         >;
       };
 
       template <class _Senders, class... _Env>
       using __error_types_t = __mapply<
         STDEXEC::__mtransform<
           __error_types_fn<_Env...>,
-          STDEXEC::__mconcat<STDEXEC::__qq<STDEXEC::__types>>
+          STDEXEC::__mconcat<STDEXEC::__qq<STDEXEC::__mlist>>
         >,
         _Senders
       >;
@@ -848,9 +848,9 @@ namespace exec {
 
       template <class _Sequence, class... _Env>
       using __errors_t = STDEXEC::__minvoke<
-        STDEXEC::__mconcat<STDEXEC::__qq<STDEXEC::__types>>,
+        STDEXEC::__mconcat<STDEXEC::__qq<STDEXEC::__mlist>>,
         // always include std::exception_ptr
-        STDEXEC::__types<std::exception_ptr>,
+        STDEXEC::__mlist<std::exception_ptr>,
         // include errors from senders of the nested sequences
         __error_types_t<__item_types_of_t<_Sequence, _Env...>, _Env...>,
         // include errors from the nested sequences

include/exec/sequence_senders.hpp

@@ -201,7 +201,7 @@ namespace exec {
 
   template <class... _Senders>
   struct item_types {
-    template <class _Fn, class _Continuation = STDEXEC::__qq<STDEXEC::__types>>
+    template <class _Fn, class _Continuation = STDEXEC::__qq<STDEXEC::__mlist>>
     static constexpr auto __transform(_Fn __fn, _Continuation __continuation = {}) {
       return __continuation(__fn.template operator()<_Senders>()...);
     }

include/nvexec/stream/when_all.cuh

@@ -67,7 +67,7 @@ namespace nvexec::_strm {
 
     template <class... Env, class... Senders>
       requires(too_many_completions_sender<Senders, Env...> || ...)
-    struct completions<__types<Env...>, Senders...> {
+    struct completions<__mlist<Env...>, Senders...> {
       static constexpr auto position_of() noexcept -> std::size_t {
         constexpr bool which[] = {too_many_completions_sender<Senders, Env...>...};
         return __pos_of(which, which + sizeof...(Senders));
@@ -79,7 +79,7 @@ namespace nvexec::_strm {
 
     template <class... Env, class... Senders>
       requires(valid_child_sender<Senders, Env...> && ...)
-    struct completions<__types<Env...>, Senders...> {
+    struct completions<__mlist<Env...>, Senders...> {
       using non_values_t = __minvoke_q<
         __concat_completion_signatures_t,
         completion_signatures<set_error_t(cudaError_t), set_stopped_t()>,
@@ -94,8 +94,8 @@ namespace nvexec::_strm {
         __mconcat<__qf<set_value_t>>,
         __value_types_t<
           __completion_signatures_of_t<Senders, Env...>,
-          __q<__types>,
-          __msingle_or<__types<>>
+          __q<__mlist>,
+          __msingle_or<__mlist<>>
         >...
       >;
 
@@ -126,7 +126,7 @@ namespace nvexec::_strm {
 
     template <class Cv, class... Env>
     using _completions_t = STDEXEC::__t<
-      _when_all::completions<__types<_when_all::env_t<Env>...>, __copy_cvref_t<Cv, Senders>...>
+      _when_all::completions<__mlist<_when_all::env_t<Env>...>, __copy_cvref_t<Cv, Senders>...>
     >;
 
    public:

include/stdexec/__detail/__completion_signatures.hpp

@@ -129,14 +129,14 @@ namespace STDEXEC {
     // __partitions specialization. If the cache is never accessed, it is never
     // instantiated.
     template <
-      class _ValueTuplesList = __types<>,
-      class _ErrorsList = __types<>,
-      class _StoppedList = __types<>
+      class _ValueTuplesList = __mlist<>,
+      class _ErrorsList = __mlist<>,
+      class _StoppedList = __mlist<>
     >
     struct __partitions;
 
     template <class... _ValueTuples, class... _Errors, class... _Stopped>
-    struct __partitions<__types<_ValueTuples...>, __types<_Errors...>, __types<_Stopped...>> {
+    struct __partitions<__mlist<_ValueTuples...>, __mlist<_Errors...>, __mlist<_Stopped...>> {
       template <class _Tuple, class _Variant>
       using __value_types = _Variant::template __f<__mapply<_Tuple, _ValueTuples>...>;
 
@@ -184,25 +184,25 @@ namespace STDEXEC {
     struct __partitioned_fold_fn<set_value_t> {
       template <class... _ValueTuples, class _Errors, class _Stopped, class _Values>
       constexpr auto operator()(
-        __partitions<__types<_ValueTuples...>, _Errors, _Stopped>&,
+        __partitions<__mlist<_ValueTuples...>, _Errors, _Stopped>&,
         __undefined<_Values>&) const
-        -> __undefined<__partitions<__types<_ValueTuples..., _Values>, _Errors, _Stopped>>&;
+        -> __undefined<__partitions<__mlist<_ValueTuples..., _Values>, _Errors, _Stopped>>&;
     };
 
     template <>
     struct __partitioned_fold_fn<set_error_t> {
       template <class _Values, class... _Errors, class _Stopped, class _Error>
       constexpr auto operator()(
-        __partitions<_Values, __types<_Errors...>, _Stopped>&,
-        __undefined<__types<_Error>>&) const
-        -> __undefined<__partitions<_Values, __types<_Errors..., _Error>, _Stopped>>&;
+        __partitions<_Values, __mlist<_Errors...>, _Stopped>&,
+        __undefined<__mlist<_Error>>&) const
+        -> __undefined<__partitions<_Values, __mlist<_Errors..., _Error>, _Stopped>>&;
     };
 
     template <>
     struct __partitioned_fold_fn<set_stopped_t> {
       template <class _Values, class _Errors, class _Stopped>
       constexpr auto operator()(__partitions<_Values, _Errors, _Stopped>&, __ignore) const
-        -> __undefined<__partitions<_Values, _Errors, __types<set_stopped_t()>>>&;
+        -> __undefined<__partitions<_Values, _Errors, __mlist<set_stopped_t()>>>&;
     };
 
     // The following overload of binary operator* is used to build up the cache of completion
@@ -213,7 +213,7 @@ namespace STDEXEC {
     constexpr auto operator*(__undefined<_Partitioned>&, _Tag (*)(_Args...)) -> __call_result_t<
       __partitioned_fold_fn<_Tag>,
       _Partitioned&,
-      __undefined<__types<_Args...>>&
+      __undefined<__mlist<_Args...>>&
     >;
 
     // This function declaration is used to extract the cache from the `__undefined` type.

include/stdexec/__detail/__concepts.hpp

@@ -52,11 +52,11 @@ namespace STDEXEC {
 
   //////////////////////////////////////////////////////////////////////////////////////////////////
   template <class...>
-  struct __types;
+  struct __mlist;
 
   template <class... _Ts>
   concept __typename = requires {
-    typename __types<_Ts...>; // NOLINT
+    typename __mlist<_Ts...>; // NOLINT
   };
 
   //////////////////////////////////////////////////////////////////////////////////////////////////