AnyOf: make it a functor

Being a functor is more fashionable than being a function.

Author: DanglingPointer

src/include/crhandle/taskutils.hpp

@@ -58,48 +58,54 @@ struct NonVoid<C<Ts...>>
 template <typename T>
 using NonVoid = typename internal::NonVoid<T>::Type;
 
-template <Executor E, TaskResult... Rs>
-TaskHandle<NonVoid<std::variant<Rs...>>, E> AnyOf(TaskHandle<Rs, E>... ts)
+struct AnyOfFn
 {
-   using ThisTaskHandle = TaskHandle<NonVoid<std::variant<Rs...>>, E>;
-
-   std::optional<NonVoid<std::variant<Rs...>>> ret;
-   stdcr::coroutine_handle<> continuation = nullptr;
-
-   auto TaskWrapper = [&]<size_t I, typename R>(std::in_place_index_t<I> i,
-                                                TaskHandle<R, E> task) -> TaskHandle<void, E> {
-      if (ret.has_value())
-         co_return;
-
-      if constexpr (std::is_same_v<R, void>) {
-         co_await std::move(task);
-         ret.emplace(i, internal::TypeConverter<void>::Type{});
-      } else {
-         R tmp = co_await std::move(task);
-         ret.emplace(i, std::move(tmp));
-      }
-      if (continuation)
-         continuation.resume();
-   };
-
-   auto handles = internal::CreateArray(std::make_index_sequence<sizeof...(Rs)>{},
-                                        std::forward_as_tuple(std::move(ts)...),
-                                        TaskWrapper);
+   template <Executor E, TaskResult... Rs>
+   using HandleType = TaskHandle<NonVoid<std::variant<Rs...>>, E>;
 
-   auto thisHandle =
-      co_await internal::CurrentHandleRetriever<typename ThisTaskHandle::promise_type>{};
-   const auto & thisPromise = thisHandle.promise();
-
-   for (auto & h : handles)
-      h.Run(thisPromise.Executor(), &thisPromise.CancelationFlag());
+   template <Executor E, TaskResult... Rs>
+   HandleType<E, Rs...> operator()(TaskHandle<Rs, E>... ts) const
+   {
+      std::optional<NonVoid<std::variant<Rs...>>> ret;
+      stdcr::coroutine_handle<> continuation = nullptr;
+
+      auto TaskWrapper = [&]<size_t I, typename R>(std::in_place_index_t<I> i,
+                                                   TaskHandle<R, E> task) -> TaskHandle<void, E> {
+         if (ret.has_value())
+            co_return;
+
+         if constexpr (std::is_same_v<R, void>) {
+            co_await std::move(task);
+            ret.emplace(i, internal::TypeConverter<void>::Type{});
+         } else {
+            R tmp = co_await std::move(task);
+            ret.emplace(i, std::move(tmp));
+         }
+         if (continuation)
+            continuation.resume();
+      };
+
+      auto tasks = internal::CreateArray(std::make_index_sequence<sizeof...(Rs)>{},
+                                         std::forward_as_tuple(std::move(ts)...),
+                                         TaskWrapper);
+
+      auto thisHandle =
+         co_await internal::CurrentHandleRetriever<typename HandleType<E, Rs...>::promise_type>{};
+      const auto & thisPromise = thisHandle.promise();
+
+      for (auto & h : tasks)
+         h.Run(thisPromise.Executor(), &thisPromise.CancelationFlag());
+
+      if (!ret.has_value()) {
+         continuation = thisHandle;
+         co_await stdcr::suspend_always{};
+      }
 
-   if (!ret.has_value()) {
-      continuation = thisHandle;
-      co_await stdcr::suspend_always{};
+      co_return *ret;
    }
+};
 
-   co_return *ret;
-}
+inline constexpr AnyOfFn AnyOf;
 
 } // namespace cr