Replace C-style cast with move() in let* algos

include/unifex/let_done.hpp

@@ -227,7 +227,7 @@ class _op<Source, Done, Receiver>::type {
   , receiver_((Receiver2&&)dest)
   {
     unifex::activate_union_member_with(sourceOp_, [&] {
-        return unifex::connect((Source&&)source, source_receiver{this});
+        return unifex::connect(std::move(source), source_receiver{this});
       });
     startedOp_ = 0 + 1;
   }

include/unifex/let_error.hpp

@@ -264,7 +264,7 @@ class _op<Source, Func, Receiver>::type final {
     : func_((Func2 &&) func)
     , receiver_((Receiver2 &&) dest) {
     unifex::activate_union_member_with(sourceOp_, [&] {
-      return unifex::connect((Source &&) source, source_receiver{this});
+      return unifex::connect(std::move(source), source_receiver{this});
     });
   }
 

include/unifex/let_value.hpp

@@ -31,6 +31,7 @@
 #include <functional>
 #include <tuple>
 #include <type_traits>
+#include <utility>
 
 #include <unifex/detail/prologue.hpp>
 
@@ -85,7 +86,7 @@ struct _successor_receiver<Operation, Values...>::type {
   void set_error(Error error) && noexcept {
     auto& op = op_;
     cleanup();
-    unifex::set_error(std::move(op.receiver_), (Error &&) error);
+    unifex::set_error(std::move(op.receiver_), std::move(error));
   }
 
 private:
@@ -178,7 +179,7 @@ struct _predecessor_receiver<Operation>::type {
   void set_error(Error error) && noexcept {
     auto& op = op_;
     unifex::deactivate_union_member(op.predOp_);
-    unifex::set_error(std::move(op.receiver_), (Error &&) error);
+    unifex::set_error(std::move(op.receiver_), std::move(error));
   }
 
   template(typename CPO)
@@ -236,7 +237,7 @@ struct _op<Predecessor, SuccessorFactory, Receiver>::type {
         receiver_((Receiver2 &&) receiver) {
     unifex::activate_union_member_with(predOp_, [&] {
       return unifex::connect(
-          (Predecessor &&) pred, predecessor_receiver<operation>{*this});
+          std::move(pred), predecessor_receiver<operation>{*this});
     });
   }
 

include/unifex/let_value_with.hpp

@@ -23,6 +23,8 @@
 #include <unifex/execution_policy.hpp>
 #include <unifex/type_list.hpp>
 
+#include <utility>
+
 #include <unifex/detail/prologue.hpp>
 
 namespace unifex {
@@ -100,12 +102,12 @@ template<typename StateFactory, typename SuccessorFactory, typename Receiver>
 struct _operation<StateFactory, SuccessorFactory, Receiver>::type {
   template <typename StateFactory2, typename SuccessorFactory2, typename Receiver2>
   type(StateFactory2&& stateFactory, SuccessorFactory2&& func, Receiver2&& r) :
-    stateFactory_(static_cast<StateFactory2&&>(stateFactory)),
+    stateFactory_(std::forward<StateFactory2>(stateFactory)),
     func_(static_cast<SuccessorFactory2&&>(func)),
-    state_(static_cast<StateFactory&&>(stateFactory_)()),
+    state_(std::move(stateFactory_)()),
     innerOp_(
         unifex::connect(
-        static_cast<SuccessorFactory&&>(func_)(state_),
+        std::move(func_)(state_),
         static_cast<Receiver2&&>(r))) {
   }
 

include/unifex/let_value_with_stop_source.hpp

@@ -25,6 +25,8 @@
 #include <unifex/execution_policy.hpp>
 #include <unifex/type_list.hpp>
 
+#include <utility>
+
 #include <unifex/detail/prologue.hpp>
 
 namespace unifex {
@@ -165,7 +167,7 @@ struct _stop_source_operation<SuccessorFactory, Receiver>::type {
           nothrow_connectable) {
     return unifex::connect(
         static_cast<SuccessorFactory&&>(func)(stopSource_),
-        receiver_t{*this, static_cast<Receiver&&>(r)});
+        receiver_t{*this, std::move(r)});
   }
 
 public:

include/unifex/let_value_with_stop_token.hpp

@@ -25,6 +25,8 @@
 #include <unifex/sender_concepts.hpp>
 #include <unifex/type_list.hpp>
 
+#include <utility>
+
 #include <unifex/detail/prologue.hpp>
 
 namespace unifex {

test/let_value_with_test.cpp

@@ -0,0 +1,51 @@
+#include <unifex/let_value_with.hpp>
+
+#include <unifex/just.hpp>
+#include <unifex/let_value_with.hpp>
+#include <unifex/sync_wait.hpp>
+#include <unifex/then.hpp>
+#include <unifex/timed_single_thread_context.hpp>
+#include <chrono>
+#include <iostream>
+#include <optional>
+#include <variant>
+
+#include <gtest/gtest.h>
+
+using namespace unifex;
+
+namespace {
+constexpr auto async = [](auto& context, auto&& func) {
+    return then(
+        schedule_after(context.get_scheduler(), std::chrono::milliseconds(10)),
+        (decltype(func))func);
+};
+}
+
+TEST(LetValueWith, StatefulFactory) {
+  // Verifies the let_value_with operation state holds onto the
+  // Factory object until the operation is complete.
+  timed_single_thread_context context;
+  std::optional<int> result = sync_wait(
+      let_value(just(), [&] {
+        return let_value_with([x = std::make_unique<int>(10)]() -> int* { return x.get(); }, [&](int*& v) {
+            return async(context, [&v]() { return *v; });
+          });
+      })
+    );
+  ASSERT_TRUE(!!result);
+  EXPECT_EQ(*result, 10);
+}
+
+TEST(LetValueWith, CallOperatorRvalueRefOverload) {
+  struct Factory {
+    int operator()() && {
+      return 10;
+    }
+  };
+  std::optional<int> result = sync_wait(let_value_with(Factory{}, [&](int& v) {
+      return just(v);
+    }));
+  ASSERT_TRUE(!!result);
+  EXPECT_EQ(*result, 10);
+}