diff --git a/examples/co_file_copy.cpp b/examples/co_file_copy.cpp
new file mode 100644
index 000000000..b836d90ac
--- /dev/null
+++ b/examples/co_file_copy.cpp
@@ -0,0 +1,359 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License Version 2.0 with LLVM Exceptions
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *   https://llvm.org/LICENSE.txt
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <unifex/config.hpp>
+
+#undef UNIFEX_NO_COROUTINES
+#define UNIFEX_NO_COROUTINES false
+#undef UNIFEX_NO_COROUTINES_HEADER
+#define UNIFEX_COROUTINES_HEADER <coroutine>
+#undef UNIFEX_NO_COROUTINES_NAMESPACE
+#define UNIFEX_COROUTINES_NAMESPACE std
+
+//#if !UNIFEX_NO_COROUTINES
+
+#if !UNIFEX_NO_LIBURING
+
+#include <unifex/scheduler_concepts.hpp>
+#include <unifex/scope_guard.hpp>
+#include <unifex/inplace_stop_token.hpp>
+#include <unifex/async_manual_reset_event.hpp>
+#include <unifex/linux/io_uring_context.hpp>
+#include <unifex/scope_guard.hpp>
+#include <unifex/async_scope.hpp>
+#include <unifex/defer.hpp>
+#include <unifex/let_value_with.hpp>
+#include <unifex/let_error.hpp>
+#include <unifex/let_done.hpp>
+#include <unifex/sequence.hpp>
+#include <unifex/sync_wait.hpp>
+#include <unifex/finally.hpp>
+#include <unifex/stop_when.hpp>
+#include <unifex/then.hpp>
+#include <unifex/task.hpp>
+#include <unifex/just.hpp>
+#include <unifex/just_from.hpp>
+#include <unifex/just_done.hpp>
+#include <unifex/just_error.hpp>
+#include <unifex/repeat_effect_until.hpp>
+
+#include <cstdio>
+
+#include <chrono>
+#include <iostream>
+#include <charconv>
+#include <string>
+#include <string_view>
+#include <vector>
+#include <thread>
+#include <filesystem>
+
+using namespace unifex;
+using namespace unifex::linuxos;
+using namespace std::chrono;
+using namespace std::chrono_literals;
+using namespace std::string_view_literals;
+namespace fs = std::filesystem;
+
+inline constexpr size_t bufferSize = 64000;
+inline constexpr int highInFlightMarker = 500;
+inline constexpr int lowInFlightMarker = 400;
+
+inline constexpr auto error_as_exception_ptr = let_error([](auto e){
+    using error_t = decltype(e);
+    std::exception_ptr ep;
+    if constexpr (same_as<error_t, std::exception_ptr>) {
+      try {std::rethrow_exception(e);} catch(const std::exception& ex) {
+        printf("EXCEPTIONPTR: '%s'\n", ex.what()); fflush(stdout);
+      }
+      ep = e;
+    } else if constexpr (same_as<error_t, std::error_code>) {
+      printf("ERROR: '%s'\n", e.message().c_str()); fflush(stdout);
+      ep = std::make_exception_ptr(std::system_error(e));
+    } else {
+      printf("UNKNOWN:\n"); fflush(stdout);
+      ep = std::make_exception_ptr((error_t&&)e);
+    }
+    return just_error(ep);
+  });
+
+// This could be made generic across any scheduler that supports the
+// async_write_only_file() CPO.
+
+using writable_file_t = callable_result_t<tag_t<open_file_write_only>, io_uring_context::scheduler, std::string>;
+task<int> write(writable_file_t& to, int index, span<char> pending) {
+  int result = 0;
+  while(pending.size() != 0) {
+    auto bytesWritten = co_await (async_write_some_at(to, index, as_bytes(pending)) 
+    | error_as_exception_ptr);
+
+    index += bytesWritten;
+    result += bytesWritten;
+    pending = span{pending.begin() + bytesWritten, pending.size() - bytesWritten};
+  }
+  co_return result;
+}
+
+using readable_file_t = callable_result_t<tag_t<open_file_read_only>, io_uring_context::scheduler, std::string>;
+using writable_bytes_t = decltype(as_writable_bytes(span<char>{}));
+task<int> read_some_at(readable_file_t& from, int index, writable_bytes_t bytes) {
+  co_return co_await (async_read_some_at(from, index, bytes)
+    | error_as_exception_ptr);
+}
+
+task<void> copy_file(io_uring_context::scheduler s, std::string from, std::string to) {
+  auto file_from = open_file_read_only(s, from);
+  auto file_to = open_file_write_only(s, to); 
+
+  int index = 0; 
+  std::vector<char> buffer;
+
+  buffer.resize(bufferSize);
+  buffer.resize(buffer.capacity());
+  const auto writableBytes = as_writable_bytes(span{buffer.data(), buffer.size()});
+
+  while(!buffer.empty()){
+    auto bytesRead = co_await read_some_at(file_from, index, writableBytes);
+    if(bytesRead == 0) {
+      break;
+    }
+    auto bytesWritten = co_await write(file_to, index, span{buffer.data(), size_t(bytesRead)});
+    index += bytesWritten;
+  }
+}
+
+#if 0
+int main(int argc, char* argv[]) {
+  if (argc < 3)
+    std::cout << "usage: vcopy what where\n";
+
+  io_uring_context ctx;
+  inplace_stop_source stopSource;
+  std::thread t{[&] { ctx.run(stopSource.get_token()); }};
+  scope_guard stopOnExit = [&]() noexcept {
+    stopSource.request_stop();
+    t.join();
+  };
+
+  auto scheduler = ctx.get_scheduler();
+
+  sync_wait(copy_file(scheduler, argv[1], argv[2]));
+}
+#endif
+
+task<void> copy_files(
+  io_uring_context::scheduler s, 
+  const fs::path& from, 
+  const fs::path& to) 
+{
+  unifex::async_scope scope;
+  std::atomic<int> pending{0}; 
+  unifex::async_manual_reset_event drain;
+
+  drain.set();
+
+  std::exception_ptr ep;
+  try {
+    for(auto& entry : fs::recursive_directory_iterator(from)) {
+      if (entry.is_directory()) {
+        // skip this item 
+        continue;
+      }
+
+      if(++pending >= highInFlightMarker && drain.ready()) {
+        // wait for some files to complete
+        drain.reset();
+      }
+
+      co_await (drain.async_wait() | with_query_value(get_scheduler, s));
+
+      const auto& p = entry.path();
+      // Create path in target, if not existing.
+      const auto relativeSrc = fs::relative(p, from);
+      const auto targetParentPath = to / relativeSrc.parent_path();
+      const auto targetParentFile = targetParentPath / p.filename();
+
+      scope.spawn([](
+        // use parameters instead of captures because async_scope
+        // will run this after this scope has unwound 
+        io_uring_context::scheduler s, 
+        std::atomic<int>& pending, 
+        unifex::async_manual_reset_event& drain,
+        std::string p,
+        std::string targetParentPath,
+        std::string targetParentFile
+      )->task<void>{
+
+        try {
+          fs::create_directories(targetParentPath);
+
+          // Copy to the targetParentPath which we just created.
+          co_await copy_file(s, p, targetParentFile);
+
+          printf("%d: %s -> %s\n", pending.load(), p.c_str(), targetParentFile.c_str());
+        } catch (const std::exception& ex) {
+          printf("EXCEPTION: '%s' %d: %s -> %s\n", ex.what(), pending.load(), p.c_str(), targetParentFile.c_str());
+          throw;
+        } catch(...) {
+          printf("UNKNOWN EXCEPTION: %d: %s -> %s\n", pending.load(), p.c_str(), targetParentFile.c_str());
+          throw;
+        }
+        fflush(stdout);
+
+        if (--pending <= lowInFlightMarker && !drain.ready()) { 
+          // resume file iteration
+          drain.set();
+        }
+      }(s, pending, drain, p.string(), targetParentPath.string(), targetParentFile.string()));
+    }
+  } catch(...) { ep = std::current_exception(); }
+  // can't co_await in  catch block or destructor. so save any exception
+  co_await (scope.complete() | with_query_value(get_scheduler, s));
+  // rethrow if an exception was caught
+  if (!!ep) {std::rethrow_exception(ep);}
+}
+
+
+auto copy_files(const fs::path& from, const fs::path& to) noexcept
+{
+    for (const auto& dirEntry : fs::recursive_directory_iterator(from))
+    {
+        if (dirEntry.is_directory()) { continue; }
+
+        const auto& p = dirEntry.path();
+        // Create path in target, if not existing.
+        const auto relativeSrc = fs::relative(p, from);
+        const auto targetParentPath = to / relativeSrc.parent_path();
+        const auto targetParentFile = targetParentPath / p.filename();
+ 
+        fs::create_directories(targetParentPath);
+
+        // Copy to the targetParentPath which we just created.
+        try {
+          copy_file(p, targetParentFile, fs::copy_options::overwrite_existing);
+          printf("%s -> %s\n", p.c_str(), targetParentFile.c_str());
+        } catch(const std::exception& ex) {
+          printf("EXCEPTION: '%s' %s -> %s\n", ex.what(), p.c_str(), targetParentFile.c_str());
+        }
+    }
+}
+
+struct stop_running {
+  inplace_stop_source& stopSource_;
+  friend void tag_invoke(unifex::tag_t<unifex::set_value>, stop_running&& self, auto&&...) {
+    self.stopSource_.request_stop();
+  }
+  template<typename Error>
+  friend void tag_invoke(unifex::tag_t<unifex::set_error>, stop_running&& self, Error&&) noexcept {
+    self.stopSource_.request_stop();
+  }
+  friend void tag_invoke(unifex::tag_t<unifex::set_done>, stop_running&& self) noexcept {
+    self.stopSource_.request_stop();
+  }
+};
+
+int main(int argc, char* argv[]) {
+  fs::path from;
+  fs::path to;
+  bool use_std_copy = false;
+
+  int position = 0;
+  std::vector<std::string_view> args(argv+1, argv+argc);
+  for (auto arg : args) {
+    if (arg.find("usestd"sv) == 0) {
+      use_std_copy = true;
+    } else {
+      if (position == 0) {
+        printf("from: -> %s\n", arg.data());
+        from = arg;
+      } else if (position == 1){
+        printf("to: -> %s\n", arg.data());
+        to = arg;
+      } else {
+        printf("error: too many positional arguments!");
+        return -1;
+      }
+      ++position;
+    }
+  }
+
+  io_uring_context ctx;
+  inplace_stop_source stopSource;
+
+  auto scheduler = ctx.get_scheduler();
+
+  try {
+    using double_sec = duration<double>;
+    auto start = steady_clock::now();
+    auto finish = steady_clock::now();
+    if (use_std_copy) {
+      start = steady_clock::now();
+      copy_files(from, to);
+      finish = steady_clock::now();
+      printf("std filesystem: Copied all the files in %6.6f seconds\n",
+              duration_cast<double_sec>(finish-start).count());
+      fflush(stdout); 
+    } else {
+      auto op = unifex::connect(
+        sequence(
+          scheduler.schedule(),
+          just_from([&] { 
+            std::printf("copy file\n"); 
+            fflush(stdout); 
+            start = steady_clock::now();
+          }),
+          copy_files(scheduler, from, to),
+          just_from([&] { 
+            finish = steady_clock::now();
+            std::printf("copy completed\n");
+            fflush(stdout); 
+          })), stop_running{stopSource});
+      unifex::start(op);
+
+      printf("running...\n");
+      ctx.run(stopSource.get_token());
+
+      printf("uring: Copied all the files in %6.6f seconds\n",
+              duration_cast<double_sec>(finish-start).count());
+      fflush(stdout); 
+    }
+  } catch (const std::exception& ex) {
+    std::printf("error: %s\n", ex.what());
+    fflush(stdout); 
+  }
+
+  return 0;
+}
+
+#else // UNIFEX_NO_LIBURING
+
+#include <cstdio>
+int main() {
+  printf("liburing support not found\n");
+  return 0;
+}
+
+#endif // UNIFEX_NO_LIBURING
+
+// #else // UNIFEX_NO_COROUTINES
+
+// #include <cstdio>
+// int main() {
+//   printf("coroutine support not found\n");
+//   return 0;
+// }
+
+// #endif // UNIFEX_NO_COROUTINES
diff --git a/include/unifex/let_error.hpp b/include/unifex/let_error.hpp
index e284623f4..9daff4e6d 100644
--- a/include/unifex/let_error.hpp
+++ b/include/unifex/let_error.hpp
@@ -22,6 +22,7 @@
 #include <unifex/type_traits.hpp>
 #include <unifex/type_list.hpp>
 #include <unifex/manual_lifetime.hpp>
+#include <unifex/manual_lifetime_union.hpp>
 #include <unifex/async_trace.hpp>
 #include <unifex/bind_back.hpp>
 
@@ -68,7 +69,7 @@ template <typename Source, typename Error, typename Receiver>
 class _rcvr<Source, Error, Receiver>::type final {
   using operation = operation_type<Source, Error, Receiver>;
   using final_receiver = final_receiver_type<Source, Error, Receiver>;
-  using final_sender_t = callable_result_t<Error&>;
+
 
 public:
   explicit type(operation* op) noexcept
@@ -91,28 +92,39 @@ class _rcvr<Source, Error, Receiver>::type final {
     unifex::set_done(std::move(op_->receiver_));
   }
 
-  void set_error(_ignore) noexcept {
+  template<typename ErrorValue>
+  void set_error(ErrorValue e) noexcept {
     UNIFEX_ASSERT(op_ != nullptr);
     auto op = op_; // preserve pointer value.
+
+    using final_sender_t = callable_result_t<Error&, ErrorValue>;
+    using final_op_t = unifex::connect_result_t<final_sender_t, final_receiver>;
+
     if constexpr (
-      is_nothrow_callable_v<Error> &&
-      is_nothrow_connectable_v<final_sender_t, final_receiver>) {
+      is_nothrow_callable_v<Error, ErrorValue> &&
+      is_nothrow_connectable_v<callable_result_t<Error, ErrorValue>, final_receiver>) {
       op->startedOp_ = state::neither;
       unifex::deactivate_union_member(op->sourceOp_);
-      unifex::activate_union_member_with(op->finalOp_, [&] {
-        return unifex::connect(std::move(op->error_)(), final_receiver{op});
+      auto& finalOp = unifex::activate_union_member_with<final_op_t>(op->finalOp_, [&] {
+        return unifex::connect(std::move(op->error_)(e), final_receiver{op});
       });
+      op->deactivate_ = [](auto& op) noexcept {
+        unifex::deactivate_union_member<final_op_t>(op);
+      };
       op->startedOp_ = state::final;
-      unifex::start(op->finalOp_.get());
+      unifex::start(finalOp);
     } else {
       UNIFEX_TRY {
         op->startedOp_ = state::neither;
         unifex::deactivate_union_member(op->sourceOp_);
-        unifex::activate_union_member_with(op->finalOp_, [&] {
-          return unifex::connect(std::move(op->error_)(), final_receiver{op});
+        auto& finalOp = unifex::activate_union_member_with<final_op_t>(op->finalOp_, [&] {
+          return unifex::connect(std::move(op->error_)(e), final_receiver{op});
         });
+        op->deactivate_ = [](auto& op) noexcept {
+          unifex::deactivate_union_member<final_op_t>(op);
+        };
         op->startedOp_ = state::final;
-        unifex::start(op->finalOp_.get());
+        unifex::start(finalOp);
       } UNIFEX_CATCH (...) {
         unifex::set_error(std::move(op->receiver_), std::current_exception());
       }
@@ -208,19 +220,20 @@ class _frcvr<Source, Error, Receiver>::type {
   operation* op_;
 };
 
-template <typename Source, typename Error, typename Receiver>
-class _op<Source, Error, Receiver>::type {
-  using source_receiver = receiver_type<Source, Error, Receiver>;
-  using final_receiver = final_receiver_type<Source, Error, Receiver>;
+template <typename Source, typename Func, typename Receiver>
+class _op<Source, Func, Receiver>::type {
+  using source_receiver = receiver_type<Source, Func, Receiver>;
+  using final_receiver = final_receiver_type<Source, Func, Receiver>;
 
 public:
-  template <typename Error2, typename Receiver2>
-  explicit type(Source&& source, Error2&& error, Receiver2&& dest)
+  template <typename Func2, typename Receiver2>
+  explicit type(Source&& source, Func2&& error, Receiver2&& dest)
       noexcept(std::is_nothrow_move_constructible_v<Receiver> &&
-               std::is_nothrow_move_constructible_v<Error> &&
+               std::is_nothrow_move_constructible_v<Func> &&
                is_nothrow_connectable_v<Source, source_receiver>)
-  : error_((Error2&&)error)
+  : error_((Func2&&)error)
   , receiver_((Receiver2&&)dest)
+  , deactivate_(nullptr)
   {
     unifex::activate_union_member_with(sourceOp_, [&] {
         return unifex::connect((Source&&)source, source_receiver{this});
@@ -236,7 +249,7 @@ class _op<Source, Error, Receiver>::type {
       unifex::deactivate_union_member(sourceOp_);
       break;
     case state::final:
-      unifex::deactivate_union_member(finalOp_);
+      deactivate_(finalOp_);
       break;
     }
     startedOp_ = state::neither;
@@ -252,22 +265,61 @@ class _op<Source, Error, Receiver>::type {
 
   using source_op_t = connect_result_t<Source, source_receiver>;
 
-  using final_sender_t = callable_result_t<Error>;
+  template <typename Error>
+  using final_sender_t = callable_result_t<Func&, remove_cvref_t<Error>>;
+
+  using final_receiver_t = final_receiver_type<Source, Func, Receiver>;
+
+  template <typename Error>
+  using final_op_t = connect_result_t<
+      final_sender_t<Error>,
+      final_receiver_t>;
+
+  template <typename... Errors>
+  using final_op_union = manual_lifetime_union<final_op_t<Errors>...>;
 
-  using final_op_t = connect_result_t<final_sender_t, final_receiver>;
+  using final_op_union_t = typename remove_cvref_t<Source>::template error_types<final_op_union>;
 
-  UNIFEX_NO_UNIQUE_ADDRESS Error error_;
+  UNIFEX_NO_UNIQUE_ADDRESS Func error_;
   UNIFEX_NO_UNIQUE_ADDRESS Receiver receiver_;
   state startedOp_ = state::neither;
   union {
     manual_lifetime<source_op_t> sourceOp_;
-    manual_lifetime<final_op_t> finalOp_;
+    final_op_union_t finalOp_;
   };
+  using deactivate_t = void(*)(final_op_union_t&) noexcept;
+  deactivate_t deactivate_;
 };
 
-template <typename Source, typename Error>
-class _sndr<Source, Error>::type {
-  using final_sender_t = callable_result_t<Error>;
+template<typename Sender>
+struct sends_done_impl : std::bool_constant<sender_traits<Sender>::sends_done> {};
+
+template<typename... Senders>
+using any_sends_done = std::disjunction<sends_done_impl<Senders>...>;
+
+template <typename Source, typename Func>
+class _sndr<Source, Func>::type {
+
+  template <typename Error>
+  using final_sender = callable_result_t<Func&, remove_cvref_t<Error>>;
+
+  template <template <typename...> class Tuple>
+  struct make_value_type_list {
+    template<typename... Errors>
+    using make = typename concat_type_lists_unique<
+      sender_value_types_t<final_sender<Errors>, type_list, Tuple>...>::type;
+    using type = sender_error_types_t<Source, make>;
+  };
+  template <template <typename...> class Tuple>
+  using make_value_type_list_t = typename make_value_type_list<Tuple>::type;
+
+  template <typename... Errors>
+  using make_error_type_list =
+      typename concat_type_lists_unique<
+          sender_error_types_t<final_sender<Errors>, type_list>...>::type;
+
+  template <typename... Errors>
+  using sends_done_impl = any_sends_done<Source, final_sender<Errors>...>;
 
 public:
   template <template <typename...> class Variant,
@@ -275,45 +327,46 @@ class _sndr<Source, Error>::type {
   using value_types =
       typename concat_type_lists_unique_t<
           sender_value_types_t<Source, type_list, Tuple>,
-          sender_value_types_t<final_sender_t, type_list, Tuple>>::template
+          make_value_type_list_t<Tuple>>::template
               apply<Variant>;
 
   template <template <typename...> class Variant>
   using error_types =
       typename concat_type_lists_unique_t<
-          sender_error_types_t<Source, type_list>,
-          sender_error_types_t<final_sender_t, type_list>,
+          sender_error_types_t<Source, make_error_type_list>,
           type_list<std::exception_ptr>>::template apply<Variant>;
 
-  static constexpr bool sends_done = sender_traits<final_sender_t>::sends_done;
+  static constexpr bool sends_done = 
+    sender_traits<Source>::sends_done |
+    sender_error_types_t<Source, sends_done_impl>::value;
 
-  template <typename Source2, typename Error2>
-  explicit type(Source2&& source, Error2&& error)
+  template <typename Source2, typename Func2>
+  explicit type(Source2&& source, Func2&& error)
     noexcept(
       std::is_nothrow_constructible_v<Source, Source2> &&
-      std::is_nothrow_constructible_v<Error, Error2>)
+      std::is_nothrow_constructible_v<Func, Func2>)
     : source_((Source2&&)source)
-    , error_((Error2&&)error)
+    , error_((Func2&&)error)
   {}
 
   template(
     typename Sender,
     typename Receiver,
     typename...,
-    typename SourceReceiver = receiver_type<member_t<Sender, Source>, Error, Receiver>,
-    typename FinalReceiver = final_receiver_type<member_t<Sender, Source>, Error, Receiver>)
+    typename SourceReceiver = receiver_type<member_t<Sender, Source>, Func, Receiver>,
+    typename FinalReceiver = final_receiver_type<member_t<Sender, Source>, Func, Receiver>)
       (requires same_as<remove_cvref_t<Sender>, type> AND
-          constructible_from<Error, member_t<Sender, Error>> AND
+          constructible_from<Func, member_t<Sender, Func>> AND
           constructible_from<remove_cvref_t<Receiver>, Receiver> AND
-          sender_to<member_t<Sender, Source>, SourceReceiver> AND
-          sender_to<final_sender_t, FinalReceiver>)
+          sender_to<member_t<Sender, Source>, SourceReceiver>)// AND
+          // sender_to<final_sender_t, FinalReceiver>)
   friend auto tag_invoke(tag_t<unifex::connect>, Sender&& s, Receiver&& r)
        noexcept(
         is_nothrow_connectable_v<member_t<Sender, Source>, SourceReceiver> &&
-        std::is_nothrow_constructible_v<Error, member_t<Sender, Error>> &&
+        std::is_nothrow_constructible_v<Func, member_t<Sender, Func>> &&
         std::is_nothrow_constructible_v<remove_cvref_t<Receiver>, Receiver>)
-      -> operation_type<member_t<Sender, Source>, Error, Receiver> {
-    return operation_type<member_t<Sender, Source>, Error, Receiver>{
+      -> operation_type<member_t<Sender, Source>, Func, Receiver> {
+    return operation_type<member_t<Sender, Source>, Func, Receiver>{
       static_cast<Sender&&>(s).source_,
       static_cast<Sender&&>(s).error_,
       static_cast<Receiver&&>(r)
@@ -322,7 +375,7 @@ class _sndr<Source, Error>::type {
 
 private:
   Source source_;
-  Error error_;
+  Func error_;
 };
 
 namespace _cpo
@@ -330,9 +383,9 @@ namespace _cpo
 struct _fn {
   template(typename Source, typename Error)
     (requires tag_invocable<_fn, Source, Error> AND
-        sender<Source> AND
-        callable<remove_cvref_t<Error>> AND
-        sender<callable_result_t<remove_cvref_t<Error>>>)
+        sender<Source>)
+        // callable<remove_cvref_t<Error>> AND
+        // sender<callable_result_t<remove_cvref_t<Error>>>)
   auto operator()(Source&& source, Error&& error) const
       noexcept(is_nothrow_tag_invocable_v<_fn, Source, Error>)
       -> tag_invoke_result_t<_fn, Source, Error> {
@@ -342,9 +395,9 @@ struct _fn {
   template(typename Source, typename Error)
     (requires (!tag_invocable<_fn, Source, Error>) AND
         constructible_from<remove_cvref_t<Source>, Source> AND
-        constructible_from<remove_cvref_t<Error>, Error> AND
-        callable<remove_cvref_t<Error>> AND
-        sender<callable_result_t<remove_cvref_t<Error>>>)
+        constructible_from<remove_cvref_t<Error>, Error>)
+        // callable<remove_cvref_t<Error>> AND
+        // sender<callable_result_t<remove_cvref_t<Error>>>)
   auto operator()(Source&& source, Error&& error) const
       noexcept(std::is_nothrow_constructible_v<
                    _sender<remove_cvref_t<Source>, remove_cvref_t<Error>>,
@@ -354,9 +407,9 @@ struct _fn {
     return _sender<remove_cvref_t<Source>, remove_cvref_t<Error>>{
         (Source&&)source, (Error&&)error};
   }
-  template(typename Error)
-      (requires callable<remove_cvref_t<Error>> AND
-        sender<callable_result_t<remove_cvref_t<Error>>>)
+  template<typename Error>
+      // (requires callable<remove_cvref_t<Error>> AND
+      //   sender<callable_result_t<remove_cvref_t<Error>>>)
   constexpr auto operator()(Error&& error) const
       noexcept(is_nothrow_callable_v<
         tag_t<bind_back>, _fn, Error>)
diff --git a/test/finally_test.cpp b/test/finally_test.cpp
index 07c2546c7..fd40a5f1c 100644
--- a/test/finally_test.cpp
+++ b/test/finally_test.cpp
@@ -62,7 +62,7 @@ TEST(Finally, Error) {
 
   auto res = just_error(-1)
     | finally(schedule(context.get_scheduler()))
-    | let_error([]{ return just(std::this_thread::get_id()); })
+    | let_error([](auto&&){ return just(std::this_thread::get_id()); })
     | sync_wait();
 
   ASSERT_TRUE(res.has_value());
diff --git a/test/let_error_test.cpp b/test/let_error_test.cpp
index ce53a9c2c..a4d74d5f7 100644
--- a/test/let_error_test.cpp
+++ b/test/let_error_test.cpp
@@ -49,7 +49,7 @@ TEST(TransformError, Smoke) {
           let_done(
             schedule_after(scheduler, 200ms), 
             []{ return just_error(-1); }),
-          []{ return just(); }),
+          [](auto&&){ return just(); }),
         just_from([&]{ ++count; })),
       schedule_after(scheduler, 100ms)));
 
@@ -64,7 +64,7 @@ TEST(TransformError, StayError) {
   int count = 0;
 
   auto op = sequence(
-    on(scheduler, just_error(42) | let_error([]{ return just(); })),
+    on(scheduler, just_error(42) | let_error([](auto&&){ return just(); })),
     just_from([&]{ ++count; }));
   sync_wait(std::move(op));
 
@@ -81,7 +81,7 @@ TEST(TransformError, Pipeable) {
   sequence(
     schedule_after(scheduler, 200ms)
       | let_done([]{ return just_error(-1); })
-      | let_error([]{ return just(); }), 
+      | let_error([](auto&&){ return just(); }), 
     just_from([&]{ ++count; }))
     | stop_when(schedule_after(scheduler, 100ms))
     | sync_wait();
@@ -92,7 +92,7 @@ TEST(TransformError, Pipeable) {
 TEST(TransformError, WithValue) {
   auto one = 
     just_error(-1)
-    | let_error([]{ return just(42); })
+    | let_error([](auto&&){ return just(42); })
     | sync_wait();
 
   EXPECT_TRUE(one.has_value());
@@ -100,7 +100,7 @@ TEST(TransformError, WithValue) {
 
   auto multiple = 
     just_error(-1)
-    | let_error([]{ return just(42, 1, 2); })
+    | let_error([](auto&&){ return just(42, 1, 2); })
     | sync_wait();
 
   EXPECT_TRUE(multiple.has_value());