From 9b608d68eb792098b3a23fa6521770bacb86f878 Mon Sep 17 00:00:00 2001
From: Bronek Kozicki <brok@incorrekt.com>
Date: Mon, 28 Sep 2026 20:35:16 +0100
Subject: [PATCH 1/2] Allow `void`-returning callbacks in `transform` over a
 copack

Represent void callback results as pack<> in the result copack, including
transform_error over a copack error. Add copack_value() for expected<void, E>.

Convert results before spliced arguments expire and include the selected
overload's explicit conversion in noexcept. Mutable operands can now select
a void overload where they previously fell back to a valued const overload.

Assisted-by: Claude:claude-opus-5-5
Assisted-by: Codex:gpt-6-astra
---
 CHANGELOG.md                 |   8 ++
 docs/reference/expected.md   |  17 +++-
 include/fn/copack.hpp        | 113 +++++++++++++++++------
 include/fn/expected.hpp      |  35 ++++++--
 tests/fn/copack.cpp          | 117 ++++++++++++++++++++++--
 tests/fn/expected.cpp        | 168 ++++++++++++++++++++++++++++++++---
 tests/fn/just_choice.cpp     |  28 ++++--
 tests/fn/optional.cpp        |  25 ++++++
 tests/fn/transform.cpp       |  49 +++++++++-
 tests/fn/transform_error.cpp |  42 ++++++++-
 10 files changed, 537 insertions(+), 65 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 38376c58..71e5c180 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,14 @@
 
 Design history of libfn, newest first. The living documents — [README.md](README.md), [CONTRIBUTING.md](CONTRIBUTING.md), [docs/](docs/) — describe only the present state of the design; when a decision makes an earlier idea obsolete, this file is where the transition is recorded and explained.
 
+## `transform` over a copack maps a `void` result to `pack<>` — 27 September 2026
+
+`transform` over a copack represents `void` callback results as `pack<>`. Mixed `void` and `int` results yield `copack_for<pack<>, int>`; all-`void` results yield `copack<pack<>>`. This applies through `expected`, `optional` and `choice`, and to `transform_error` over a copack error. Plain error types still reject `void` results. Mutable operands can select a `void` overload where they previously fell back to a valued `const` overload.
+
+Results are converted before spliced arguments expire, fixing a dangling reference. The `noexcept` specification includes the selected overload's explicit result conversion.
+
+`expected<void, E>::copack_value()` lifts to `expected<copack<pack<>>, E>`.
+
 ## `and_then` joins `void` and valued branches through `pack<>` — 26 September 2026
 
 `and_then` accepts branches returning both `void`-valued and valued `expected` results. For example, `A -> expected<void, E>` and `B -> expected<int, E>` join as `expected<copack_for<pack<>, int>, E>`; this previously failed to compile. An all-`void` join stays `void`.
diff --git a/docs/reference/expected.md b/docs/reference/expected.md
index 28d790aa..2698b7ed 100644
--- a/docs/reference/expected.md
+++ b/docs/reference/expected.md
@@ -290,6 +290,15 @@ constexpr auto copack_value() const && -> decltype(auto);
 
 :include-doxygen-doc-params: fn::expected::copack_value { args: "", title: "parameters" }
 
+```cpp {title: "fn::expected< void, Err >::copack_value"}
+constexpr auto copack_value() const & -> expected<copack<pack<>>, error_type>;  // (1)
+constexpr auto copack_value() &&      -> expected<copack<pack<>>, error_type>;  // (2)
+```
+
+:include-doxygen-doc: fn::expected< void, Err >::copack_value { args: "" }
+
+:include-doxygen-doc-params: fn::expected< void, Err >::copack_value { args: "", title: "parameters" }
+
 ## and_then {style: "api"}
 
 ```cpp {title: "fn::expected::and_then"}
@@ -517,10 +526,10 @@ constexpr auto copack_error(some_expected auto &&src) -> decltype(auto);  // (1)
 :include-doxygen-doc-params: fn::copack_error { args: "some_expected auto &&", title: "parameters" }
 
 ```cpp {title: "fn::copack_value"}
-constexpr auto copack_value(some_expected_non_void auto &&src) -> decltype(auto);  // (1)
-constexpr auto copack_value(some_optional auto &&src)          -> decltype(auto);  // (2)
+constexpr auto copack_value(some_expected auto &&src) -> decltype(auto);  // (1)
+constexpr auto copack_value(some_optional auto &&src) -> decltype(auto);  // (2)
 ```
 
-:include-doxygen-doc: fn::copack_value { args: "some_expected_non_void auto &&" }
+:include-doxygen-doc: fn::copack_value { args: "some_expected auto &&" }
 
-:include-doxygen-doc-params: fn::copack_value { args: "some_expected_non_void auto &&", title: "parameters" }
+:include-doxygen-doc-params: fn::copack_value { args: "some_expected auto &&", title: "parameters" }
diff --git a/include/fn/copack.hpp b/include/fn/copack.hpp
index 71a1d5da..7749292c 100644
--- a/include/fn/copack.hpp
+++ b/include/fn/copack.hpp
@@ -104,11 +104,7 @@ template <template <typename...> typename Tpl, typename... Ts> struct normalized
 };
 } // namespace _collapsing_copack
 
-// A result no copack can hold - void above all - must drop the caller's candidate, not explode:
-// everything behind the gate (flattening, normalization, the copack they name) hard-errors OUTSIDE
-// any immediate context. The false gate has no `type`, and the collapsing traits pass that absence
-// through by inheritance, so it surfaces where a return type names `::type` - in the immediate
-// context, as a clean substitution failure.
+// Reject invalid alternatives before normalization, whose errors would escape SFINAE.
 template <bool, template <typename...> typename Tpl, typename... Rs> struct _collapsing_copack_gate {};
 template <template <typename...> typename Tpl, typename... Rs> struct _collapsing_copack_gate<true, Tpl, Rs...> {
   using type = _collapsing_copack::normalized<Tpl, _collapsing_copack::flattened<Rs...>>::type;
@@ -116,16 +112,19 @@ template <template <typename...> typename Tpl, typename... Rs> struct _collapsin
 
 template <typename R> constexpr inline bool _collapsible_result = some_copack<R> || _is_valid_copack_subtype<R>;
 
+// A copack represents void success with pack<>.
+template <typename V> using _sum_element_t = ::std::conditional_t<::std::is_void_v<V>, ::fn::pack<>, V>;
+
 template <typename Fn, typename Self, typename T, typename... Args> struct _typelist_collapsing_copack;
 template <typename Fn, typename Self, template <typename...> typename Tpl, typename... Ts, typename... Args>
 struct _typelist_collapsing_copack<Fn, Self, Tpl<Ts...>, Args...>
     : _collapsing_copack_gate<
           (...
-           && _collapsible_result<::std::remove_cvref_t<
-               typename ::fn::detail::_apply_result<Fn, apply_const_lvalue_t<Self, Ts>, Args...>::type>>),
+           && _collapsible_result<_sum_element_t<::std::remove_cvref_t<
+               typename ::fn::detail::_apply_result<Fn, apply_const_lvalue_t<Self, Ts>, Args...>::type>>>),
           Tpl,
-          ::std::remove_cvref_t<
-              typename ::fn::detail::_apply_result<Fn, apply_const_lvalue_t<Self, Ts>, Args...>::type>...> {};
+          _sum_element_t<::std::remove_cvref_t<
+              typename ::fn::detail::_apply_result<Fn, apply_const_lvalue_t<Self, Ts>, Args...>::type>>...> {};
 
 template <typename T, typename Fn, typename Self, typename... Args> struct _copack_apply_result final {
   using type = T;
@@ -138,6 +137,56 @@ template <typename Fn, typename Self, typename... Args>
 struct _copack_apply_result<_collapsing_copack_tag, Fn, Self, Args...> final
     : _typelist_collapsing_copack<Fn, Self, ::std::remove_cvref_t<Self>, Args...> {};
 
+// Convert results before spliced arguments expire. Keep callback invocability
+// unchanged so the injector preserves overload selection.
+template <typename To, typename Fn, typename... Args> struct _nothrow_copack_inject : ::std::false_type {};
+template <typename To, typename Fn, typename... Args>
+  requires ::std::is_void_v<::std::invoke_result_t<Fn, Args...>>
+struct _nothrow_copack_inject<To, Fn, Args...>
+    : ::std::bool_constant<
+          ::std::is_nothrow_invocable_v<Fn, Args...> && ::std::is_nothrow_constructible_v<To, ::fn::pack<>>> {};
+template <typename To, typename Fn, typename... Args>
+  requires(not ::std::is_void_v<::std::invoke_result_t<Fn, Args...>>)
+          && requires { static_cast<To>(::std::invoke(::std::declval<Fn>(), ::std::declval<Args>()...)); }
+struct _nothrow_copack_inject<To, Fn, Args...>
+    : ::std::bool_constant<noexcept(static_cast<To>(::std::invoke(::std::declval<Fn>(), ::std::declval<Args>()...)))> {
+};
+
+template <typename To, typename Fn> struct _copack_injector final {
+  Fn fn;
+
+  template <typename... Args>
+  constexpr auto operator()(Args &&...args) const noexcept(_nothrow_copack_inject<To, Fn, Args...>::value) -> To
+    requires ::std::is_invocable_v<Fn, Args...>
+  {
+    using result = ::std::invoke_result_t<Fn, Args...>;
+    if constexpr (::std::is_void_v<result>) {
+      ::std::invoke(FWD(fn), FWD(args)...);
+      return To{_sum_element_t<result>{}}; // pack<>, spelled dependently: pack.hpp includes this header
+    } else
+      return static_cast<To>(::std::invoke(FWD(fn), FWD(args)...));
+  }
+};
+
+template <typename To, typename Fn> struct _copack_admission final {
+  template <typename... Args>
+  auto operator()(Args &&...) const -> To
+    requires(::std::is_void_v<::std::invoke_result_t<Fn, Args...>> && ::std::is_constructible_v<To, ::fn::pack<>>)
+            || ((not ::std::is_void_v<::std::invoke_result_t<Fn, Args...>>) && ::std::is_invocable_r_v<To, Fn, Args...>)
+  {
+    ::pfn::unreachable(); // LCOV_EXCL_LINE
+  }
+};
+
+template <typename To, typename Data, typename Fn, typename... Args>
+  requires _typelist_applicable_r<To, _copack_admission<To, Fn &&>, Data &&, Args &&...>
+[[nodiscard]] constexpr auto _collapsing_apply(Data &&data, ::std::size_t index, Fn &&fn, Args &&...args) //
+    noexcept(_is_nothrow_rts_applicable<To, _copack_injector<To, Fn &&>, Data &&, Args &&...>) -> To
+{
+  return apply_variadic_union<To, ::std::remove_cvref_t<Data>>(FWD(data), index, _copack_injector<To, Fn &&>{FWD(fn)},
+                                                               FWD(args)...);
+}
+
 struct _joining_superset_tag final {};
 
 // Bind joins the payloads of just results. A choice contributes its alternatives, an ordinary
@@ -1086,8 +1135,9 @@ struct copack<Ts...> {
    * @brief Maps the alternatives, the branch results forming a new normalized copack
    *
    * The self-flattening map: the callable is dispatched exhaustively, and the branch results -
-   * heterogeneous types allowed, a copack result dissolving into the set - flatten, deduplicate
-   * and sort into the `copack_for` of them all.
+   * heterogeneous types allowed, a copack result dissolving into the set, a `void` one entering as
+   * `pack<>` - flatten, deduplicate and sort into the `copack_for` of them all. A `void` result
+   * needs `<fn/pack.hpp>`, which defines `pack`.
    *
    * @param fn Callable applied on the active alternative; `fn::overload` fuses arms into one
    * @param args Additional arguments, appended after the alternative's content
@@ -1097,48 +1147,62 @@ struct copack<Ts...> {
   [[nodiscard]] constexpr auto transform(Fn &&fn, Args &&...args) & noexcept(
       detail::_is_nothrow_rts_applicable<
           typename detail::_copack_apply_result<detail::_collapsing_copack_tag, Fn &&, copack &, Args &&...>::type,
-          Fn &&, copack &, Args &&...>) ->
+          detail::_copack_injector<
+              typename detail::_copack_apply_result<detail::_collapsing_copack_tag, Fn &&, copack &, Args &&...>::type,
+              Fn &&>,
+          copack &, Args &&...>) ->
       typename detail::_copack_apply_result<detail::_collapsing_copack_tag, Fn &&, copack &, Args &&...>::type
     requires typelist_applicable<Fn, copack &, Args &&...>
   {
     using type = detail::_copack_apply_result<detail::_collapsing_copack_tag, Fn &&, copack &, Args &&...>::type;
-    return detail::apply_variadic_union<type, data_t>(this->data, index, FWD(fn), FWD(args)...);
+    return detail::_collapsing_apply<type>(this->data, index, FWD(fn), FWD(args)...);
   }
 
   template <typename Fn, typename... Args>
   [[nodiscard]] constexpr auto transform(Fn &&fn, Args &&...args) const & noexcept(
-      detail::_is_nothrow_rts_applicable<typename detail::_copack_apply_result<detail::_collapsing_copack_tag, Fn &&,
-                                                                               copack const &, Args &&...>::type,
-                                         Fn &&, copack const &, Args &&...>) ->
+      detail::_is_nothrow_rts_applicable<
+          typename detail::_copack_apply_result<detail::_collapsing_copack_tag, Fn &&, copack const &,
+                                                Args &&...>::type,
+          detail::_copack_injector<typename detail::_copack_apply_result<detail::_collapsing_copack_tag, Fn &&,
+                                                                         copack const &, Args &&...>::type,
+                                   Fn &&>,
+          copack const &, Args &&...>) ->
       typename detail::_copack_apply_result<detail::_collapsing_copack_tag, Fn &&, copack const &, Args &&...>::type
     requires typelist_applicable<Fn, copack const &, Args &&...>
   {
     using type = detail::_copack_apply_result<detail::_collapsing_copack_tag, Fn &&, copack const &, Args &&...>::type;
-    return detail::apply_variadic_union<type, data_t>(this->data, index, FWD(fn), FWD(args)...);
+    return detail::_collapsing_apply<type>(this->data, index, FWD(fn), FWD(args)...);
   }
 
   template <typename Fn, typename... Args>
   [[nodiscard]] constexpr auto transform(Fn &&fn, Args &&...args) && noexcept(
       detail::_is_nothrow_rts_applicable<
           typename detail::_copack_apply_result<detail::_collapsing_copack_tag, Fn &&, copack &&, Args &&...>::type,
-          Fn &&, copack &&, Args &&...>) ->
+          detail::_copack_injector<
+              typename detail::_copack_apply_result<detail::_collapsing_copack_tag, Fn &&, copack &&, Args &&...>::type,
+              Fn &&>,
+          copack &&, Args &&...>) ->
       typename detail::_copack_apply_result<detail::_collapsing_copack_tag, Fn &&, copack &&, Args &&...>::type
     requires typelist_applicable<Fn, copack &&, Args &&...>
   {
     using type = detail::_copack_apply_result<detail::_collapsing_copack_tag, Fn &&, copack &&, Args &&...>::type;
-    return detail::apply_variadic_union<type, data_t>(::std::move(*this).data, index, FWD(fn), FWD(args)...);
+    return detail::_collapsing_apply<type>(::std::move(*this).data, index, FWD(fn), FWD(args)...);
   }
 
   template <typename Fn, typename... Args>
   [[nodiscard]] constexpr auto transform(Fn &&fn, Args &&...args) const && noexcept(
-      detail::_is_nothrow_rts_applicable<typename detail::_copack_apply_result<detail::_collapsing_copack_tag, Fn &&,
-                                                                               copack const &&, Args &&...>::type,
-                                         Fn &&, copack const &&, Args &&...>) ->
+      detail::_is_nothrow_rts_applicable<
+          typename detail::_copack_apply_result<detail::_collapsing_copack_tag, Fn &&, copack const &&,
+                                                Args &&...>::type,
+          detail::_copack_injector<typename detail::_copack_apply_result<detail::_collapsing_copack_tag, Fn &&,
+                                                                         copack const &&, Args &&...>::type,
+                                   Fn &&>,
+          copack const &&, Args &&...>) ->
       typename detail::_copack_apply_result<detail::_collapsing_copack_tag, Fn &&, copack const &&, Args &&...>::type
     requires typelist_applicable<Fn, copack const &&, Args &&...>
   {
     using type = detail::_copack_apply_result<detail::_collapsing_copack_tag, Fn &&, copack const &&, Args &&...>::type;
-    return detail::apply_variadic_union<type, data_t>(::std::move(*this).data, index, FWD(fn), FWD(args)...);
+    return detail::_collapsing_apply<type>(::std::move(*this).data, index, FWD(fn), FWD(args)...);
   }
 };
 
@@ -1284,9 +1348,6 @@ template <::std::size_t I, some_copack C>
 }
 
 namespace detail {
-// A copack represents void success with pack<>.
-template <typename V> using _sum_element_t = ::std::conditional_t<::std::is_void_v<V>, ::fn::pack<>, V>;
-
 // Compare exact branch result types: stripping cv/ref could select a convergent path
 // whose type assertion fails. Tpl avoids a dependency on the expected header.
 template <template <typename...> typename Tpl, typename E> struct _joining_expected_tag final {};
diff --git a/include/fn/expected.hpp b/include/fn/expected.hpp
index 5be2032d..65f7ee48 100644
--- a/include/fn/expected.hpp
+++ b/include/fn/expected.hpp
@@ -146,8 +146,6 @@ template <typename T, typename Fn, typename ErrArg>
   requires _some_copack<::std::remove_cvref_t<ErrArg>>
 struct _or_else_dispatch<T, Fn, ErrArg> : _copack_apply_result<_joining_recovery_tag<::fn::expected, T>, Fn, ErrArg> {};
 
-// Constraining the injector by result conversion would change overload selection.
-// Keep its invocability identical to the callback; check conversion separately.
 template <typename To, typename From>
 concept _void_success_into = _is_some_expected<From &> && ::std::is_void_v<typename From::value_type>
                              && (not ::std::is_void_v<typename To::value_type>);
@@ -168,6 +166,7 @@ struct _nothrow_expected_inject<To, Fn, Args...>
     : ::std::bool_constant<noexcept(static_cast<To>(::std::invoke(::std::declval<Fn>(), ::std::declval<Args>()...)))> {
 };
 
+// Constraining result conversion here would change callback overload selection.
 template <typename To, typename Fn> struct _expected_injector final {
   Fn fn;
 
@@ -620,8 +619,7 @@ template <typename T, typename E> struct _expected_base : ::pfn::detail::_expect
       });
   }
 
-  // transform_error, error type is a copack (delegates to copack::transform). The callback is constrained
-  // here, in the immediate context, for the reason given on optional's copack-case _transform.
+  // Constrain the call here so invalid transforms fail in the immediate context.
   template <typename Self, typename Fn>
   static constexpr auto _transform_error(Self &&self, Fn &&fn) //
       noexcept(noexcept(_pfn_base::_error(FWD(self)).transform(FWD(fn)))
@@ -630,6 +628,7 @@ template <typename T, typename E> struct _expected_base : ::pfn::detail::_expect
                        T, ::fn::apply_const_lvalue_t<Self, typename _pfn_base::_value_t &&>>)) // extension
     requires some_copack<E> && (not empty_copack<E>)
              && ::fn::detail::_typelist_applicable<Fn, decltype(_pfn_base::_error(FWD(self)))>
+             && requires { _pfn_base::_error(FWD(self)).transform(FWD(fn)); }
              && (::std::is_void_v<T> || ::std::is_constructible_v<T, decltype(_pfn_base::_value(FWD(self)))>)
   {
     using new_error_type = decltype(_pfn_base::_error(FWD(self)).transform(FWD(fn)));
@@ -2253,6 +2252,32 @@ template <typename Err> class expected<void, Err> : private detail::_expected_ba
     return _base::_transform_error(::std::move(*this), FWD(f));
   }
 
+  /**
+   * @brief Lifts the value side into its singular copack: `expected<void, E>` becomes
+   *        `expected<copack<pack<>>, E>`
+   *
+   * @return The graded `expected`, relocating the error
+   */
+  constexpr auto
+  copack_value() const & noexcept(::std::is_nothrow_constructible_v<error_type, error_type const &>) // extension
+      -> expected<copack<pack<>>, error_type>
+  {
+    using type = expected<copack<pack<>>, error_type>;
+    if (this->has_value())
+      return type{::std::in_place, pack<>{}};
+    else
+      return type{::fn::unexpect, this->error()};
+  }
+  constexpr auto copack_value() && noexcept(::std::is_nothrow_constructible_v<error_type, error_type>) // extension
+      -> expected<copack<pack<>>, error_type>
+  {
+    using type = expected<copack<pack<>>, error_type>;
+    if (this->has_value())
+      return type{::std::in_place, pack<>{}};
+    else
+      return type{::fn::unexpect, ::std::move(*this).error()};
+  }
+
   /**
    * @brief Lifts the error side into its singular copack: `expected<void, E>` becomes
    *        `expected<void, copack<E>>`
@@ -2350,7 +2375,7 @@ constexpr bool operator==(expected<T, Err> const &x, T2 const &v) //
  * @param src The `expected` to lift
  * @return `src.copack_value()`
  */
-[[nodiscard]] constexpr auto copack_value(some_expected_non_void auto &&src) noexcept(noexcept(FWD(src).copack_value()))
+[[nodiscard]] constexpr auto copack_value(some_expected auto &&src) noexcept(noexcept(FWD(src).copack_value()))
     -> decltype(auto)
 {
   return FWD(src).copack_value();
diff --git a/tests/fn/copack.cpp b/tests/fn/copack.cpp
index 749b44f3..52845d12 100644
--- a/tests/fn/copack.cpp
+++ b/tests/fn/copack.cpp
@@ -1749,14 +1749,16 @@ TEST_CASE("copack type collapsing", "[copack][transform][normalized]")
 
   SECTION("a result no copack can hold")
   {
-    // a void-returning callback must drop the caller's candidate in the immediate context: the
-    // collapsing machinery would hard-error where no requires-expression can absorb it
-    constexpr auto fnVoid = [](auto &&...) {};
-    static_assert(not can_transform<copack<double, int> &, decltype(fnVoid)>);
-    static_assert(not can_transform<copack<double, int> const &, decltype(fnVoid)>);
-    static_assert(not can_transform<copack<double, int> &&, decltype(fnVoid)>);
-    static_assert(not can_transform<copack<double, int> const &&, decltype(fnVoid)>);
+    constexpr auto fnTag = [](auto &&...) { return std::in_place_type<int>; };
+    static_assert(not can_transform<copack<double, int> &, decltype(fnTag)>);
+    static_assert(not can_transform<copack<double, int> const &, decltype(fnTag)>);
+    static_assert(not can_transform<copack<double, int> &&, decltype(fnTag)>);
+    static_assert(not can_transform<copack<double, int> const &&, decltype(fnTag)>);
     static_assert(can_transform<copack<double, int> &, PassThrough>); // the same copack, a holdable result
+    constexpr auto fnVoid = [](auto &&...) {};
+    static_assert(std::same_as<
+                  typename _copack_apply_result<_collapsing_copack_tag, decltype(fnVoid), copack<double, int> &>::type,
+                  copack<::fn::pack<>>>);
     SUCCEED();
   }
 }
@@ -1809,11 +1811,19 @@ TEST_CASE("copack transform", "[copack][transform]")
     CHECK(std::move(std::as_const(a)).transform(add, 3) == copack{3.5});
     CHECK(std::move(a).transform(add, 3) == copack{3.5});
 
+    // a returned reference into a spliced argument is read while that argument lives
+    struct Arg final {
+      int v;
+    };
+    constexpr auto field = [](double, Arg &&arg) noexcept -> int const & { return arg.v; };
+    CHECK(a.transform(field, fn::pack<Arg>{Arg{7}}) == copack{7});
+
     SECTION("constexpr")
     {
       constexpr type b{std::in_place_type<double>, 0.5};
       static_assert(b.transform(add, 3) == copack{3.5});
       static_assert(std::move(b).transform(add, 3) == copack{3.5});
+      static_assert(b.transform(field, fn::pack<Arg>{Arg{7}}) == copack{7});
       SUCCEED();
     }
   }
@@ -1840,7 +1850,98 @@ TEST_CASE("copack transform", "[copack][transform]")
     static_assert(noexcept(a.transform(nothrow)));
     static_assert(noexcept(std::move(a).transform(nothrow)));
 
-    SUCCEED();
+    struct X final {
+      int n;
+      constexpr explicit X(int v) : n(v) {}
+      constexpr explicit X(X const &v) noexcept(false) : n(v.n) {}
+    };
+    struct Elements final {
+      X const *x;
+      constexpr auto operator()(int) const noexcept -> X const & { return *x; }
+      constexpr auto operator()(std::tuple<int>) const noexcept -> copack<X>
+      {
+        return copack<X>{std::in_place_type<X>, 0};
+      }
+    };
+    static_assert(not noexcept(std::declval<copack<std::tuple<int>> &>().transform(std::declval<Elements>())));
+    constexpr X seven{7};
+    copack<std::tuple<int>> t{std::tuple<int>{2}};
+    CHECK(t.transform(Elements{&seven}).apply([](X const &x) { return x.n; }) == 7);
+    static_assert([] {
+      X const x{7};
+      copack<std::tuple<int>> tup{std::tuple<int>{2}};
+      return tup.transform(Elements{&x}).apply([](X const &v) { return v.n; }) == 7;
+    }());
+  }
+
+  SECTION("a void result enters as pack<>")
+  {
+    struct A final {};
+    struct B final {};
+    using AB = fn::copack_for<A, B>;
+    constexpr auto which = fn::overload{[](int i) { return i; }, [] { return -1; }, [](fn::pack<>) { return -2; }};
+    constexpr auto fnMixed = fn::overload{[](A) {}, [](B) { return 5; }};
+    constexpr auto fnVoid = [](auto) {};
+    AB ca{A{}};
+    AB cb{B{}};
+    static_assert(std::same_as<decltype(ca.transform(fnMixed)), fn::copack_for<fn::pack<>, int>>);
+    static_assert(std::same_as<decltype(ca.transform(fnVoid)), copack<fn::pack<>>>);
+    CHECK(ca.transform(fnMixed).apply(which) == -1);
+    CHECK(std::as_const(ca).transform(fnMixed).apply(which) == -1);
+    CHECK(std::move(std::as_const(ca)).transform(fnMixed).apply(which) == -1);
+    CHECK(cb.transform(fnMixed).apply(which) == 5);
+    CHECK(cb.transform(fnVoid).apply(which) == -1);
+    CHECK(std::move(ca).transform(fnMixed).apply(which) == -1);
+
+    constexpr auto fnUnit = fn::overload{[](A) {}, [](B) { return fn::pack<>{}; }};
+    static_assert(std::same_as<decltype(cb.transform(fnUnit)), copack<fn::pack<>>>);
+    CHECK(cb.transform(fnUnit).apply(which) == -1);
+
+    int seen = 0;
+    CHECK(ca.transform(fn::overload{[](A, int &s) { s = 7; }, [](B, int &) { return 1; }}, seen).apply(which) == -1);
+    CHECK(seen == 7);
+
+    int elements = 0;
+    auto const fnT = fn::overload{[&](int) { ++elements; }, [](std::tuple<int>) { return 91; }, [](B) { return 5; }};
+    fn::copack_for<std::tuple<int>, B> t{std::tuple<int>{3}};
+    static_assert(std::same_as<decltype(t.transform(fnT)), fn::copack_for<fn::pack<>, int>>);
+    CHECK(t.transform(fnT).apply(which) == -1);
+    CHECK(elements == 1);
+
+    struct Handler final {
+      constexpr void operator()(int &) const noexcept {}
+      constexpr int operator()(int const &n) const noexcept { return n + 1; }
+    };
+    copack<int> ci{42};
+    static_assert(std::same_as<decltype(ci.transform(Handler{})), copack<fn::pack<>>>);
+    CHECK(ci.transform(Handler{}).apply(which) == -1);
+    CHECK(std::as_const(ci).transform(Handler{}) == copack{43});
+
+    static_assert([] {
+      constexpr auto unit = fn::overload{[] { return true; }, [](int) { return false; }};
+      int written = 0;
+      AB x{A{}};
+      int calls = 0;
+      fn::copack_for<std::tuple<int>, B> tup{std::tuple<int>{3}};
+      copack<int> c42{42};
+      return x.transform(fn::overload{[](A, int &s) { s = 7; }, [](B, int &) { return 1; }}, written).apply(unit)
+             && written == 7
+             && tup.transform(
+                       fn::overload{[&](int) { ++calls; }, [](std::tuple<int>) { return 91; }, [](B) { return 5; }})
+                    .apply(unit)
+             && calls == 1 && c42.transform(Handler{}).apply(unit)
+             && std::as_const(c42).transform(Handler{}) == copack{43};
+    }());
+
+    constexpr auto fnNothrow = fn::overload{[](A) noexcept {}, [](B) noexcept { return 5; }};
+    static_assert(noexcept(ca.transform(fnNothrow)));
+    static_assert(not noexcept(ca.transform(fnMixed)));
+    CHECK_THROWS_AS(ca.transform(fn::overload{[](A) { throw 0; }, [](B) { return 5; }}), int);
+
+    constexpr AB cca{A{}};
+    static_assert(cca.transform(fnMixed).apply(which) == -1);
+    static_assert(cca.transform(fnVoid).apply(which) == -1);
+    static_assert(std::move(cca).transform(fnMixed).apply(which) == -1);
   }
 }
 
diff --git a/tests/fn/expected.cpp b/tests/fn/expected.cpp
index 7a97de67..cea94d2f 100644
--- a/tests/fn/expected.cpp
+++ b/tests/fn/expected.cpp
@@ -370,18 +370,65 @@ TEST_CASE("graded monad", "[expected][copack][graded][and_then][or_else][copack_
     static_assert(noexcept(fn::copack_value(s))); // the free function propagates what the member says
   }
 
-  SECTION("copack_value absent for void value")
+  SECTION("copack_value from void value")
   {
-    // by design: a void value cannot be copack-wrapped -- the void specialization has no
-    // copack_value member and the free fn::copack_value is constrained some_expected_non_void
-    // (include/fn/expected.hpp:1020); copack_error, by contrast, serves void (asserted above)
-    constexpr auto can_member_copack_value = [](auto &&e) { return requires { e.copack_value(); }; };
-    constexpr auto can_free_copack_value = [](auto &&e) { return requires { fn::copack_value(e); }; };
-    static_assert(not can_member_copack_value(fn::expected<void, Error>{}));
-    static_assert(not can_free_copack_value(fn::expected<void, Error>{}));
-    static_assert(can_member_copack_value(fn::expected<int, Error>{1}));
-    static_assert(can_free_copack_value(fn::expected<int, Error>{1}));
-    SUCCEED();
+    using T = fn::expected<void, Error>;
+    using Out = fn::expected<fn::copack<fn::pack<>>, Error>;
+    T s{};
+    static_assert(std::is_same_v<decltype(s.copack_value()), Out>);
+    static_assert(std::is_same_v<decltype(std::as_const(s).copack_value()), Out>);
+    static_assert(std::is_same_v<decltype(std::move(std::as_const(s)).copack_value()), Out>);
+    static_assert(std::is_same_v<decltype(std::move(s).copack_value()), Out>);
+    static_assert(noexcept(s.copack_value()));
+    static_assert(noexcept(std::move(s).copack_value()));
+    constexpr auto which = fn::overload{[] { return 1; }, [](fn::pack<>) { return 2; }};
+    SECTION("value")
+    {
+      CHECK(s.copack_value().value().apply(which) == 1);
+      CHECK(std::as_const(s).copack_value().value().apply(which) == 1);
+      CHECK(std::move(std::as_const(s)).copack_value().value().apply(which) == 1);
+      CHECK(std::move(s).copack_value().value().apply(which) == 1);
+    }
+    SECTION("error")
+    {
+      T s{::fn::unexpect, Unknown};
+      CHECK(s.copack_value().error() == Unknown);
+      CHECK(std::as_const(s).copack_value().error() == Unknown);
+      CHECK(std::move(std::as_const(s)).copack_value().error() == Unknown);
+      CHECK(std::move(s).copack_value().error() == Unknown);
+    }
+    SECTION("the error's relocation weighs, and its exception propagates")
+    {
+      struct Throwing final {
+        int v;
+        Throwing(int i) : v(i) {}
+        Throwing(Throwing const &) { throw 1; }
+        Throwing(Throwing &&) { throw 2; }
+      };
+      static_assert(not noexcept(std::declval<fn::expected<void, Throwing> &>().copack_value()));
+      static_assert(not noexcept(std::declval<fn::expected<void, Throwing> &&>().copack_value()));
+      fn::expected<void, Throwing> t{::fn::unexpect, 5};
+      CHECK_THROWS_AS(t.copack_value(), int);
+      CHECK((not t.has_value() && t.error().v == 5));
+      CHECK_THROWS_AS(std::move(t).copack_value(), int);
+      CHECK((not t.has_value() && t.error().v == 5));
+    }
+
+    static_assert(std::is_same_v<decltype(fn::copack_value(s)), Out>);
+    static_assert(noexcept(fn::copack_value(s)));
+    static_assert([] {
+      constexpr auto w = fn::overload{[] { return 1; }, [](fn::pack<>) { return 2; }};
+      fn::expected<void, Error> ok{};
+      fn::expected<void, Error> const cok{};
+      fn::expected<void, Error> err{::fn::unexpect, FileNotFound};
+      fn::expected<void, Error> const cerr{::fn::unexpect, FileNotFound};
+      return ok.copack_value().value().apply(w) == 1 && cok.copack_value().value().apply(w) == 1
+             && std::move(cok).copack_value().value().apply(w) == 1
+             && std::move(ok).copack_value().value().apply(w) == 1 && fn::copack_value(cok).value().apply(w) == 1
+             && err.copack_value().error() == FileNotFound && cerr.copack_value().error() == FileNotFound
+             && std::move(cerr).copack_value().error() == FileNotFound
+             && std::move(err).copack_value().error() == FileNotFound;
+    }());
   }
 
   SECTION("and_then")
@@ -3340,6 +3387,41 @@ TEST_CASE("expected copack support transform", "[expected][copack][transform]")
               .has_value<std::monostate>());
   }
 
+  SECTION("a void result enters as pack<>")
+  {
+    using S2 = fn::expected<fn::copack_for<int, std::string_view>, Error>;
+    constexpr auto which
+        = fn::overload{[](bool b) { return b ? 1 : 0; }, [] { return -1; }, [](fn::pack<>) { return -2; }};
+    constexpr auto fnMixed = fn::overload{[](int) {}, [](std::string_view) { return true; }};
+    constexpr auto fnVoid = [](auto &&) {};
+    using OutM = fn::expected<fn::copack_for<bool, fn::pack<>>, Error>;
+    S2 s{fn::copack{12}};
+    static_assert(std::is_same_v<decltype(s.transform(fnMixed)), OutM>);
+    static_assert(std::is_same_v<decltype(s.transform(fnVoid)), fn::expected<fn::copack<fn::pack<>>, Error>>);
+    CHECK(s.transform(fnMixed).value().apply(which) == -1);
+    CHECK(std::as_const(s).transform(fnMixed).value().apply(which) == -1);
+    CHECK(std::move(std::as_const(s)).transform(fnMixed).value().apply(which) == -1);
+    CHECK(std::move(s).transform(fnMixed).value().apply(which) == -1);
+    S2 sv{fn::copack{std::string_view{"x"}}};
+    CHECK(sv.transform(fnMixed).value().apply(which) == 1);
+    CHECK(sv.transform(fnVoid).value().apply(which) == -1);
+    S2 e{::fn::unexpect, FileNotFound};
+    CHECK(e.transform(fnMixed).error() == FileNotFound);
+    CHECK(e.transform(fnVoid).error() == FileNotFound);
+
+    constexpr auto fnNothrow = fn::overload{[](int) noexcept {}, [](std::string_view) noexcept { return true; }};
+    static_assert(noexcept(s.transform(fnNothrow)));
+    static_assert(not noexcept(s.transform(fnMixed)));
+    static_assert([] {
+      constexpr auto w
+          = fn::overload{[](bool b) { return b ? 1 : 0; }, [] { return -1; }, [](fn::pack<>) { return -2; }};
+      constexpr auto f = fn::overload{[](int) {}, [](std::string_view) { return true; }};
+      fn::expected<fn::copack_for<int, std::string_view>, Error> const c{fn::copack{12}};
+      fn::expected<fn::copack_for<int, std::string_view>, Error> const ce{::fn::unexpect, FileNotFound};
+      return c.transform(f).value().apply(w) == -1 && ce.transform(f).error() == FileNotFound;
+    }());
+  }
+
   SECTION("error")
   {
     fn::expected<fn::copack_for<int, std::string_view>, Error> s{::fn::unexpect, FileNotFound};
@@ -3428,6 +3510,70 @@ TEST_CASE("expected copack support transform_error", "[expected][copack][transfo
   constexpr auto can_transform_error = [](auto &&f) { return requires { std::declval<S &>().transform_error(f); }; };
   static_assert(can_transform_error(nothrow_visitor));
 
+  SECTION("a void result enters the error as pack<>")
+  {
+    constexpr auto fnVoid = fn::overload{[](int const &) {}, [](std::string_view const &) { return true; }};
+    static_assert(std::is_same_v<decltype(std::declval<S &>().transform_error(fnVoid)),
+                                 fn::expected<double, fn::copack_for<fn::pack<>, bool>>>);
+    static_assert(std::is_same_v<decltype(std::declval<S &>().transform_error([](auto &&) {})),
+                                 fn::expected<double, fn::copack<fn::pack<>>>>);
+    S s{::fn::unexpect, fn::copack{12}};
+    CHECK(s.transform_error(fnVoid).error().has_value(std::in_place_type<fn::pack<>>));
+    CHECK(S{12.5}.transform_error(fnVoid).value() == 12.5);
+    S t{::fn::unexpect, fn::copack{std::string_view{"x"}}};
+    CHECK(t.transform_error(fnVoid).error() == fn::copack{true});
+    static_assert([] {
+      using C = fn::expected<int, fn::copack_for<bool, int>>;
+      constexpr auto f = fn::overload{[](bool) {}, [](int i) { return i + 1; }};
+      return C{::fn::unexpect, fn::copack{true}}.transform_error(f).error().has_value(std::in_place_type<fn::pack<>>)
+             && C{::fn::unexpect, fn::copack{1}}.transform_error(f).error() == fn::copack{2}
+             && C{3}.transform_error(f).value() == 3;
+    }());
+  }
+
+  SECTION("a void result for the error follows overload resolution")
+  {
+    struct Handler final {
+      constexpr void operator()(int &) const noexcept {}
+      constexpr void operator()(int &&) const noexcept {}
+      constexpr int operator()(int const &n) const noexcept { return n + 1; }
+    };
+    struct Value final {
+      int n;
+      constexpr Value(int v) : n(v) {}
+      constexpr Value(Value &o) noexcept : n(o.n + 10) {}
+      constexpr Value(Value const &o) noexcept : n(o.n + 100) {}
+      constexpr Value(Value &&o) noexcept : n(o.n + 1000) {}
+      constexpr Value(Value const &&o) noexcept : n(o.n + 10000) {}
+    };
+    using E = fn::expected<Value, fn::copack<int>>;
+    using P = fn::expected<Value, fn::copack<fn::pack<>>>;
+    static_assert(std::is_same_v<decltype(std::declval<E &>().transform_error(Handler{})), P>);
+    static_assert(std::is_same_v<decltype(std::declval<E const &>().transform_error(Handler{})), E>);
+    static_assert(std::is_same_v<decltype(std::declval<E &&>().transform_error(Handler{})), P>);
+    static_assert(std::is_same_v<decltype(std::declval<E const &&>().transform_error(Handler{})), E>);
+    E v{std::in_place, 1};
+    CHECK(v.transform_error(Handler{}).value().n == 11);
+    CHECK(std::as_const(v).transform_error(Handler{}).value().n == 101);
+    CHECK(std::move(std::as_const(v)).transform_error(Handler{}).value().n == 10001);
+    CHECK(std::move(v).transform_error(Handler{}).value().n == 1001);
+    E e{::fn::unexpect, fn::copack{42}};
+    CHECK(e.transform_error(Handler{}).error().has_value(std::in_place_type<fn::pack<>>));
+    CHECK(std::as_const(e).transform_error(Handler{}).error() == fn::copack{43});
+    CHECK(std::move(std::as_const(e)).transform_error(Handler{}).error() == fn::copack{43});
+    CHECK(std::move(e).transform_error(Handler{}).error().has_value(std::in_place_type<fn::pack<>>));
+    static_assert([] {
+      E ok{std::in_place, 1};
+      E bad{::fn::unexpect, fn::copack{42}};
+      return ok.transform_error(Handler{}).value().n == 11
+             && std::move(std::as_const(ok)).transform_error(Handler{}).value().n == 10001
+             && std::move(ok).transform_error(Handler{}).value().n == 1001
+             && bad.transform_error(Handler{}).error().has_value(std::in_place_type<fn::pack<>>)
+             && std::move(std::as_const(bad)).transform_error(Handler{}).error() == fn::copack{43}
+             && std::move(bad).transform_error(Handler{}).error().has_value(std::in_place_type<fn::pack<>>);
+    }());
+  }
+
   SECTION("value")
   {
     fn::expected<double, fn::copack_for<int, std::string_view>> s{::fn::unexpect, fn::copack{12}};
diff --git a/tests/fn/just_choice.cpp b/tests/fn/just_choice.cpp
index 91497e3d..8929972e 100644
--- a/tests/fn/just_choice.cpp
+++ b/tests/fn/just_choice.cpp
@@ -1460,14 +1460,28 @@ TEST_CASE("choice transform", "[choice][transform]")
 
   SECTION("a result no choice can hold")
   {
-    // a void-returning callback must drop the caller's candidate in the immediate context: the
-    // collapsing machinery would hard-error where no requires-expression can absorb it
+    constexpr auto fnTag = [](auto &&...) { return std::in_place_type<int>; };
+    static_assert(not can_transform<fn::choice<bool, int> &, decltype(fnTag)>);
+    static_assert(not can_transform<fn::choice<bool, int> const &, decltype(fnTag)>);
+    static_assert(not can_transform<fn::choice<bool, int> &&, decltype(fnTag)>);
+    static_assert(not can_transform<fn::choice<bool, int> const &&, decltype(fnTag)>);
     constexpr auto fnVoid = [](auto &&...) {};
-    static_assert(not can_transform<fn::choice<bool, int> &, decltype(fnVoid)>);
-    static_assert(not can_transform<fn::choice<bool, int> const &, decltype(fnVoid)>);
-    static_assert(not can_transform<fn::choice<bool, int> &&, decltype(fnVoid)>);
-    static_assert(not can_transform<fn::choice<bool, int> const &&, decltype(fnVoid)>);
-    SUCCEED();
+    static_assert(can_transform<fn::choice<bool, int> &, decltype(fnVoid)>);
+    static_assert(can_transform<fn::choice<bool, int> const &&, decltype(fnVoid)>);
+    constexpr auto which = fn::overload{[](int i) { return i; }, [] { return -1; }, [](fn::pack<>) { return -2; }};
+    constexpr auto fnMixed = fn::overload{[](bool) {}, [](int i) { return i + 1; }};
+    fn::choice<bool, int> b{true};
+    static_assert(std::is_same_v<decltype(b.transform(fnMixed)), fn::just<fn::copack_for<fn::pack<>, int>>>);
+    static_assert(std::is_same_v<decltype(b.transform(fnVoid)), fn::just<fn::copack<fn::pack<>>>>);
+    CHECK(b.transform(fnMixed).value().apply(which) == -1);
+    CHECK(std::as_const(b).transform(fnMixed).value().apply(which) == -1);
+    CHECK(std::move(std::as_const(b)).transform(fnMixed).value().apply(which) == -1);
+    CHECK(std::move(b).transform(fnMixed).value().apply(which) == -1);
+    CHECK(fn::choice<bool, int>{41}.transform(fnMixed).value().apply(which) == 42);
+    // named source: VS 2022 misreads a mid-expression prvalue's empty-class union member
+    constexpr fn::choice<bool, int> cb{true};
+    static_assert(cb.transform(fnMixed).value().apply(which) == -1);
+    static_assert(cb.transform(fnVoid).value().apply(which) == -1);
   }
 }
 
diff --git a/tests/fn/optional.cpp b/tests/fn/optional.cpp
index 4b9a5270..70de93f5 100644
--- a/tests/fn/optional.cpp
+++ b/tests/fn/optional.cpp
@@ -1025,6 +1025,31 @@ TEST_CASE("optional transform copack", "[optional][copack][transform]")
           == fn::copack{true});
   }
 
+  SECTION("a void result enters as pack<>")
+  {
+    constexpr auto which
+        = fn::overload{[](bool b) { return b ? 1 : 0; }, [] { return -1; }, [](fn::pack<>) { return -2; }};
+    constexpr auto fnMixed = fn::overload{[](int) {}, [](Xint) { return true; }};
+    constexpr auto fnVoid = [](auto &&) {};
+    S s{12};
+    static_assert(std::is_same_v<decltype(s.transform(fnMixed)), fn::optional<fn::copack_for<bool, fn::pack<>>>>);
+    static_assert(std::is_same_v<decltype(s.transform(fnVoid)), fn::optional<fn::copack<fn::pack<>>>>);
+    CHECK(s.transform(fnMixed).value().apply(which) == -1);
+    CHECK(std::as_const(s).transform(fnMixed).value().apply(which) == -1);
+    CHECK(std::move(std::as_const(s)).transform(fnMixed).value().apply(which) == -1);
+    CHECK(std::move(s).transform(fnMixed).value().apply(which) == -1);
+    CHECK(S{12}.transform(fnVoid).value().apply(which) == -1);
+    CHECK(not S{}.transform(fnMixed).has_value());
+    constexpr auto fnNothrow = fn::overload{[](int) noexcept {}, [](Xint) noexcept { return true; }};
+    static_assert(noexcept(s.transform(fnNothrow)));
+    static_assert(not noexcept(s.transform(fnMixed)));
+    // named sources: VS 2022 misreads a mid-expression prvalue's empty-class union member
+    constexpr S cs{12};
+    constexpr S ce{};
+    static_assert(cs.transform(fnMixed).value().apply(which) == -1);
+    static_assert(not ce.transform(fnMixed).has_value());
+  }
+
   SECTION("error")
   {
     fn::optional<fn::copack_for<Xint, int>> s{};
diff --git a/tests/fn/transform.cpp b/tests/fn/transform.cpp
index 758b2a5f..6df3f071 100644
--- a/tests/fn/transform.cpp
+++ b/tests/fn/transform.cpp
@@ -781,6 +781,47 @@ TEST_CASE("transform tuple-like payload", "[transform][expected][optional][tuple
   }
 }
 
+TEST_CASE("transform maps a void result into pack<>", "[transform][expected][optional][choice][copack]")
+{
+  struct A final {};
+  struct B final {};
+  struct E final {
+    bool operator==(E const &) const = default;
+  };
+  constexpr auto which = fn::overload{[](int i) { return i; }, [] { return -1; }, [](fn::pack<>) { return -2; }};
+  constexpr auto fnMixed = fn::overload{[](A) {}, [](B) { return 5; }};
+  using Unit = fn::copack_for<fn::pack<>, int>;
+
+  using InE = fn::expected<fn::copack_for<A, B>, E>;
+  InE e{fn::copack_for<A, B>{A{}}};
+  static_assert(std::is_same_v<decltype(e | fn::transform(fnMixed)), fn::expected<Unit, E>>);
+  CHECK((e | fn::transform(fnMixed)).value().apply(which) == -1);
+  CHECK((InE{fn::copack_for<A, B>{B{}}} | fn::transform(fnMixed)).value().apply(which) == 5);
+  CHECK((InE{fn::unexpect, E{}} | fn::transform(fnMixed)).error() == E{});
+
+  using InO = fn::optional<fn::copack_for<A, B>>;
+  InO o{fn::copack_for<A, B>{A{}}};
+  static_assert(std::is_same_v<decltype(o | fn::transform(fnMixed)), fn::optional<Unit>>);
+  CHECK((o | fn::transform(fnMixed)).value().apply(which) == -1);
+  CHECK(not(InO{} | fn::transform(fnMixed)).has_value());
+
+  using InC = fn::choice_for<A, B>;
+  InC c{A{}};
+  static_assert(std::is_same_v<decltype(c | fn::transform(fnMixed)), fn::just<Unit>>);
+  CHECK((c | fn::transform(fnMixed)).value().apply(which) == -1);
+
+  // named sources: VS 2022 misreads a mid-expression prvalue's empty-class union member
+  constexpr InE ce{fn::copack_for<A, B>{A{}}};
+  constexpr InO co{fn::copack_for<A, B>{A{}}};
+  constexpr InC cc{A{}};
+  static_assert((ce | fn::transform(fnMixed)).value().apply(which) == -1);
+  static_assert((co | fn::transform(fnMixed)).value().apply(which) == -1);
+  static_assert((cc | fn::transform(fnMixed)).value().apply(which) == -1);
+
+  static_assert(not fn::applicable_transform<decltype([](int) {}), fn::optional<int>>);
+  static_assert(std::is_same_v<decltype(fn::expected<int, E>{1} | fn::transform([](int) {})), fn::expected<void, E>>);
+}
+
 TEST_CASE("transform over an uninhabited value side", "[transform][expected][optional][copack]")
 {
   // A copack<> value can never be constructed, so the callback can never be presented one: the
@@ -861,7 +902,7 @@ static_assert(applicable_transform<decltype(fn_generic<int>), optional<Value>>);
 static_assert(not applicable_transform<decltype(fn_int<void>), optional<int>>);                 // void return: no optional<void>
 static_assert(applicable_transform<decltype(fn_generic<int>), choice<int>>);
 static_assert(not applicable_transform<decltype(fn_int<int>), choice<Value>>);            // must serve every alternative
-static_assert(not applicable_transform<decltype(fn_int<void>), choice<int>>);             // a void result has no place in a choice
+static_assert(applicable_transform<decltype(fn_int<void>), choice<int>>);
 static_assert(not applicable_transform<decltype(fn_int_lvalue), expected<int, Error>>);   // cannot bind temporary to lvalue
 static_assert(applicable_transform<decltype(fn_int_lvalue), expected<int, Error> &>);
 static_assert(applicable_transform<decltype(fn_int_rvalue), expected<int, Error>>);
@@ -872,8 +913,10 @@ static_assert(applicable_transform<decltype(fn_generic<int>), expected<copack_fo
 static_assert(not applicable_transform<decltype(fn_int<int>), expected<copack_for<Value, int>, Error>>); // int alone is not exhaustive
 static_assert(applicable_transform<decltype(fn_generic<int>), optional<copack_for<Value, int>>>);
 static_assert(not applicable_transform<decltype(fn_int<int>), optional<copack_for<Value, int>>>);
-static_assert(not applicable_transform<decltype(fn_generic<void>), expected<copack_for<Value, int>, Error>>); // a void result has no place in a copack
-static_assert(not applicable_transform<decltype(fn_generic<void>), optional<copack_for<Value, int>>>);
+static_assert(applicable_transform<decltype(fn_generic<void>), expected<copack_for<Value, int>, Error>>);
+static_assert(applicable_transform<decltype(fn_generic<void>), optional<copack_for<Value, int>>>);
+static_assert(not applicable_transform<decltype(fn_generic<std::in_place_type_t<int>>), expected<copack_for<Value, int>, Error>>);
+static_assert(not applicable_transform<decltype(fn_generic<std::in_place_type_t<int>>), optional<copack_for<Value, int>>>);
 
 // An uninhabited value side has no alternative to dispatch, so the concept answers false where the rows
 // above answer true: applicability is a property of the callback, and a vacuous mapping consults none.
diff --git a/tests/fn/transform_error.cpp b/tests/fn/transform_error.cpp
index 18ca90f7..d8186048 100644
--- a/tests/fn/transform_error.cpp
+++ b/tests/fn/transform_error.cpp
@@ -207,6 +207,46 @@ TEST_CASE("transform_error", "[transform_error][expected]")
 
         SUCCEED();
       }
+
+      SECTION("a void result enters the error as pack<>")
+      {
+        constexpr auto fnVoid = fn::overload{[](bool) {}, [](Error) { return 1; }};
+        static_assert(fn::applicable_transform_error<decltype(fnVoid), T>);
+        constexpr auto r1 = T{::fn::unexpect, fn::copack{true}} | fn::transform_error(fnVoid);
+        static_assert(std::is_same_v<decltype(r1), fn::expected<int, fn::copack_for<fn::pack<>, int>> const>);
+        static_assert(r1.error().has_value(std::in_place_type<fn::pack<>>));
+        constexpr auto r2 = T{::fn::unexpect, fn::copack{Error::SomethingElse}} | fn::transform_error(fnVoid);
+        static_assert(r2.error() == fn::copack{1});
+        constexpr auto r3 = T{42} | fn::transform_error(fnVoid);
+        static_assert(r3.value() == 42);
+        CHECK((T{::fn::unexpect, fn::copack{true}} | fn::transform_error(fnVoid))
+                  .error()
+                  .has_value(std::in_place_type<fn::pack<>>));
+        CHECK((T{::fn::unexpect, fn::copack{Error::SomethingElse}} | fn::transform_error(fnVoid)).error()
+              == fn::copack{1});
+
+        static_assert(not fn::applicable_transform_error<decltype([](Error) {}), fn::expected<int, Error>>);
+
+        struct Handler final {
+          constexpr void operator()(int &) const noexcept {}
+          constexpr void operator()(int &&) const noexcept {}
+          constexpr int operator()(int const &n) const noexcept { return n + 1; }
+        };
+        using U = fn::expected<int, fn::copack<int>>;
+        static_assert(fn::applicable_transform_error<Handler, U &>);
+        static_assert(fn::applicable_transform_error<Handler, U &&>);
+        static_assert(fn::applicable_transform_error<Handler, U const &&>);
+        U u{::fn::unexpect, fn::copack{42}};
+        CHECK((u | fn::transform_error(Handler{})).error().has_value(std::in_place_type<fn::pack<>>));
+        CHECK((std::move(std::as_const(u)) | fn::transform_error(Handler{})).error() == fn::copack{43});
+        CHECK((std::move(u) | fn::transform_error(Handler{})).error().has_value(std::in_place_type<fn::pack<>>));
+        static_assert([] {
+          U bad{::fn::unexpect, fn::copack{42}};
+          return (bad | fn::transform_error(Handler{})).error().has_value(std::in_place_type<fn::pack<>>)
+                 && (std::move(std::as_const(bad)) | fn::transform_error(Handler{})).error() == fn::copack{43}
+                 && (std::move(bad) | fn::transform_error(Handler{})).error().has_value(std::in_place_type<fn::pack<>>);
+        }());
+      }
     }
   }
 }
@@ -301,7 +341,7 @@ static_assert(not applicable_transform_error<decltype(fn_Error_rvalue), expected
 // A copack error dispatches through copack::transform - the callback must cover ALL alternatives.
 static_assert(applicable_transform_error<decltype(fn_generic<Xerror>), expected<int, copack_for<Error, Value>>>);
 static_assert(not applicable_transform_error<decltype(fn_Error<Xerror>), expected<int, copack_for<Error, Value>>>); // not exhaustive
-static_assert(not applicable_transform_error<decltype(fn_generic<void>), expected<int, copack_for<Error, Value>>>); // a void result has no place in a copack
+static_assert(applicable_transform_error<decltype(fn_generic<void>), expected<int, copack_for<Error, Value>>>);
 
 // at an uninhabited error side the concept stays false - the dedicated arm, not the concept, admits the operand
 static_assert(not applicable_transform_error<decltype(fn_generic<Xerror>), expected<int, copack<>>>);

From 1ffad0040524529b5ec60256d458e164812aff24 Mon Sep 17 00:00:00 2001
From: Bronek Kozicki <brok@incorrekt.com>
Date: Mon, 28 Sep 2026 22:04:17 +0100
Subject: [PATCH 2/2] Splice an rvalue into a following pack by value

Store rvalue operands by value when the apply fold constructs a pack,
matching as_pack. This avoids forming the forbidden pack<T&&>, which
prevented transforming an rvalue copack with a following pack argument.
It also fixes MSVC's failure when checking the const&& transform overload
for an lvalue call.

Assisted-by: Claude:claude-opus-5-5
Assisted-by: Codex:gpt-6-astra
---
 CHANGELOG.md                     |  2 +-
 include/fn/detail/functional.hpp | 21 +++++++++++++--------
 tests/fn/copack.cpp              |  2 ++
 tests/fn/detail/functional.cpp   | 15 ++++++++++++++-
 4 files changed, 30 insertions(+), 10 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 71e5c180..f66f0a73 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,7 +6,7 @@ Design history of libfn, newest first. The living documents — [README.md](READ
 
 `transform` over a copack represents `void` callback results as `pack<>`. Mixed `void` and `int` results yield `copack_for<pack<>, int>`; all-`void` results yield `copack<pack<>>`. This applies through `expected`, `optional` and `choice`, and to `transform_error` over a copack error. Plain error types still reject `void` results. Mutable operands can select a `void` overload where they previously fell back to a valued `const` overload.
 
-Results are converted before spliced arguments expire, fixing a dangling reference. The `noexcept` specification includes the selected overload's explicit result conversion.
+Results are converted before spliced arguments expire, fixing a dangling reference. The `noexcept` specification includes the selected overload's explicit result conversion. Rvalues spliced before a `pack` argument are stored by value, fixing a compilation failure.
 
 `expected<void, E>::copack_value()` lifts to `expected<copack<pack<>>, E>`.
 
diff --git a/include/fn/detail/functional.hpp b/include/fn/detail/functional.hpp
index 91762e08..fe57d70b 100644
--- a/include/fn/detail/functional.hpp
+++ b/include/fn/detail/functional.hpp
@@ -21,18 +21,24 @@
 namespace fn::inline LIBFN_VERSION::detail {
 
 namespace _fold_detail {
+// pack forbids rvalue references.
+template <typename T>
+using _element_t = ::std::conditional_t<::std::is_rvalue_reference_v<T>, ::std::remove_reference_t<T>, T>;
+
 // The branch the fold takes is chosen by `if constexpr`, so a single expression cannot state its
 // specification: the two untaken spellings would be ill-formed. Hence one specialization per branch.
 template <typename L, typename R, typename Lv, typename Rv>
-struct _nothrow_fold : ::std::bool_constant<noexcept(::fn::pack<L, R>{::std::declval<Lv>(), ::std::declval<Rv>()})> {};
+struct _nothrow_fold : ::std::bool_constant<noexcept(
+                           ::fn::pack<_element_t<L>, _element_t<R>>{::std::declval<Lv>(), ::std::declval<Rv>()})> {};
 template <typename L, typename R, typename Lv, typename Rv>
   requires _some_pack<L>
 struct _nothrow_fold<L, R, Lv, Rv>
     : ::std::bool_constant<noexcept(::std::declval<Lv>().append(::std::in_place_type_t<R>{}, ::std::declval<Rv>()))> {};
 template <typename L, typename R, typename Lv, typename Rv>
   requires(not _some_pack<L>) && _some_pack<R>
-struct _nothrow_fold<L, R, Lv, Rv> : ::std::bool_constant<noexcept(::fn::pack<L>{::std::declval<Lv>()}.append(
-                                         ::std::in_place_type_t<R>{}, ::std::declval<Rv>()))> {};
+struct _nothrow_fold<L, R, Lv, Rv>
+    : ::std::bool_constant<noexcept(::fn::pack<_element_t<L>>{::std::declval<Lv>()}.append(::std::in_place_type_t<R>{},
+                                                                                           ::std::declval<Rv>()))> {};
 
 template <typename L, typename R>
 [[nodiscard]] constexpr auto _fold(auto &&l, auto &&r) //
@@ -42,9 +48,9 @@ template <typename L, typename R>
     return FWD(l).append(::std::in_place_type_t<R>{}, FWD(r));
   } else {
     if constexpr (_some_pack<R>) {
-      return ::fn::pack<L>{FWD(l)}.append(::std::in_place_type_t<R>{}, FWD(r));
+      return ::fn::pack<_element_t<L>>{FWD(l)}.append(::std::in_place_type_t<R>{}, FWD(r));
     } else {
-      return ::fn::pack<L, R>{FWD(l), FWD(r)};
+      return ::fn::pack<_element_t<L>, _element_t<R>>{FWD(l), FWD(r)};
     }
   }
 }
@@ -162,9 +168,8 @@ template <typename Fn, typename Arg, typename Arg0, typename... Args>
                apply<Fn, decltype(::fn::detail::_fold_detail::fold<Arg, Arg0>(FWD(arg), FWD(arg0))), Args...>(
                    FWD(fn), ::fn::detail::_fold_detail::fold<Arg, Arg0>(FWD(arg), FWD(arg0)), FWD(args)...);
              }
-// Deduced return: a trailing return type is substituted before constraints are checked, so an
-// explicit one would instantiate `fold` for non-viable candidates and static_assert (a `pack` of
-// rvalue refs). The body's `using type` alias is inlined only to dodge MSVC's body-local-alias leak.
+// Deduced return delays fold instantiation until constraints are checked.
+// Inline the return expression to avoid MSVC's body-local alias leak.
 [[nodiscard]] constexpr auto apply(Fn &&fn, Arg &&arg, Arg0 &&arg0, Args &&...args) //
     noexcept(noexcept(apply<Fn, decltype(::fn::detail::_fold_detail::fold<Arg, Arg0>(FWD(arg), FWD(arg0))), Args...>(
         FWD(fn), ::fn::detail::_fold_detail::fold<Arg, Arg0>(FWD(arg), FWD(arg0)), FWD(args)...))) -> decltype(auto)
diff --git a/tests/fn/copack.cpp b/tests/fn/copack.cpp
index 52845d12..f37cdc5b 100644
--- a/tests/fn/copack.cpp
+++ b/tests/fn/copack.cpp
@@ -1817,6 +1817,7 @@ TEST_CASE("copack transform", "[copack][transform]")
     };
     constexpr auto field = [](double, Arg &&arg) noexcept -> int const & { return arg.v; };
     CHECK(a.transform(field, fn::pack<Arg>{Arg{7}}) == copack{7});
+    CHECK(std::move(a).transform(field, fn::pack<Arg>{Arg{7}}) == copack{7});
 
     SECTION("constexpr")
     {
@@ -1824,6 +1825,7 @@ TEST_CASE("copack transform", "[copack][transform]")
       static_assert(b.transform(add, 3) == copack{3.5});
       static_assert(std::move(b).transform(add, 3) == copack{3.5});
       static_assert(b.transform(field, fn::pack<Arg>{Arg{7}}) == copack{7});
+      static_assert(std::move(b).transform(field, fn::pack<Arg>{Arg{7}}) == copack{7});
       SUCCEED();
     }
   }
diff --git a/tests/fn/detail/functional.cpp b/tests/fn/detail/functional.cpp
index 319bea12..9ce964f2 100644
--- a/tests/fn/detail/functional.cpp
+++ b/tests/fn/detail/functional.cpp
@@ -11,11 +11,13 @@
 
 #include <concepts>
 #include <type_traits>
+#include <utility>
 
 namespace {
 template <typename...> struct types;
 
 constexpr auto sum_two = [](int i, double d) { return i + d; };
+constexpr auto sum_three = [](int i, double d, char c) { return i + d + c; };
 } // namespace
 
 TEST_CASE("_apply_result", "[functional][apply_result]")
@@ -40,6 +42,9 @@ TEST_CASE("_is_applicable", "[functional][is_applicable]")
   static_assert(not _is_applicable<decltype(sum_two), int, int *>::value);
   // negative: wrong arity
   static_assert(not _is_applicable<decltype(sum_two), int>::value);
+  static_assert(_is_applicable<decltype(sum_two), int &&, fn::pack<double> &&>::value);
+  static_assert(_is_applicable<decltype(sum_two), int const &&, fn::pack<double> &&>::value);
+  static_assert(_is_applicable<decltype(sum_three), int &&, double &&, fn::pack<char> &&>::value);
   SUCCEED();
 }
 
@@ -103,7 +108,15 @@ TEST_CASE("_apply", "[functional][apply]")
   // pack arg: dispatches through pack::apply
   constexpr fn::pack<int, double> p{2, 0.25};
   static_assert(_apply(sum_two, p) == 2.25);
-  SUCCEED();
+  constexpr auto spliced = [] {
+    int i = 2;
+    int j = 2;
+    double d = 0.25;
+    return _apply(sum_two, std::move(i), fn::pack<double>{0.25})
+           + _apply(sum_three, std::move(j), std::move(d), fn::pack<char>{'a'});
+  };
+  static_assert(spliced() == 2.25 + 99.25);
+  CHECK(spliced() == 2.25 + 99.25);
 }
 
 TEST_CASE("_apply_r", "[functional][apply_r]")