From cb4a64e710541481ceeb3c27a3011cf9d47413e4 Mon Sep 17 00:00:00 2001
From: Bronek Kozicki <brok@incorrekt.com>
Date: Mon, 28 Sep 2026 20:35:29 +0100
Subject: [PATCH] Move `pack` and `copack` operations to `<fn/algebra.hpp>`

Separate the data types from operator&, conjoin, disjoin and the carrier
join helpers. Keep the data operator& overload set together in algebra.hpp.

Make copack.hpp include pack.hpp so void transforms need no extra include.
Carrier headers include algebra.hpp; direct users of the moved operations
must include it. Move the corresponding tests to algebra.cpp.

Assisted-by: Claude:claude-opus-5-5
Assisted-by: Codex:gpt-6-astra
---
 CHANGELOG.md                         |   6 +
 docs/reference/conjoin.md            |  40 ++--
 docs/reference/disjoin.md            |   2 +-
 docs/reference/pack.md               |   2 +
 examples/calculator/calculator.hpp   |   1 +
 examples/type_algebra/main.cpp       |   1 +
 include/CMakeLists.txt               |   1 +
 include/fn/algebra.hpp               | 240 +++++++++++++++++++
 include/fn/copack.hpp                |   6 +-
 include/fn/detail/traits.hpp         |   6 +
 include/fn/detail/variadic_union.hpp |   7 +-
 include/fn/expected.hpp              |   1 +
 include/fn/just.hpp                  |   1 +
 include/fn/optional.hpp              |   1 +
 include/fn/pack.hpp                  | 242 +------------------
 tests/CMakeLists.txt                 |   1 +
 tests/fn/algebra.cpp                 | 344 +++++++++++++++++++++++++++
 tests/fn/copack.cpp                  |   1 -
 tests/fn/detail/functional.cpp       |   1 +
 tests/fn/optional.cpp                |  39 ---
 tests/fn/pack.cpp                    | 306 +-----------------------
 tests/util/helper_types.hpp          |   7 +
 22 files changed, 646 insertions(+), 610 deletions(-)
 create mode 100644 include/fn/algebra.hpp
 create mode 100644 tests/fn/algebra.cpp

diff --git a/CHANGELOG.md b/CHANGELOG.md
index f64d5cc1..bf88c009 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,12 @@
 
 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.
 
+## `pack` and `copack` operations move to `<fn/algebra.hpp>` — 27 September 2026
+
+`operator&` over `pack` and `copack`, `conjoin`, and `disjoin` move to `<fn/algebra.hpp>`. Include this header when using these operations without a carrier header. The `expected`, `optional`, and `just` headers include it.
+
+`<fn/copack.hpp>` includes `<fn/pack.hpp>`; the reverse dependency is removed. A copack transform returning `void` therefore needs only `<fn/copack.hpp>`. Code using `copack` through `<fn/pack.hpp>` must include `<fn/copack.hpp>` explicitly.
+
 ## `&` takes a `void` side as the unit factor `pack<>` — 27 September 2026
 
 `&` treats a `void` value as the unit factor `pack<>`. For example, `expected<int, E> & just<void>` yields `expected<pack<int>, E>`; previously it yielded `expected<int, E>`. This breaking change applies across carrier pairings in either order. Copack values distribute into packs, and `optional<T&> & just<void>` yields an owning `optional<pack<T>>`. Two `void` values still yield `void`.
diff --git a/docs/reference/conjoin.md b/docs/reference/conjoin.md
index 665a855e..a7013f78 100644
--- a/docs/reference/conjoin.md
+++ b/docs/reference/conjoin.md
@@ -2,7 +2,7 @@
 title: "fold fn::conjoin"
 ---
 
-##### Defined in {style: "api", badge: "#include <fn/pack.hpp>"}
+##### Defined in {style: "api", badge: "#include <fn/algebra.hpp>"}
 
 ---
 
@@ -29,54 +29,54 @@ conjoin_t conjoin;  // (1)
 
 ## The operator {style: "api"}
 
-The binary conjunction each carrier declares; `conjoin` is its n-ary fold.
+Binary conjunction of data or carriers; `conjoin` is its n-ary fold.
 
 ```cpp {title: "fn::operator&"}
+constexpr auto operator&(auto &&lh, auto &&rh);  // (1)
+
 template <typename Lh, typename Rh>
-constexpr auto operator&(Lh &&lh, Rh &&rh);  // (1)
+constexpr auto operator&(Lh &&lh, Rh &&rh);  // (2)
 
 template <typename Lh, some_expected Rh>
-constexpr auto operator&(Lh &&lh, Rh &&rh);  // (2)
+constexpr auto operator&(Lh &&lh, Rh &&rh);  // (3)
 
 template <some_expected Lh, typename Rh>
-constexpr auto operator&(Lh &&lh, Rh &&rh);  // (3)
+constexpr auto operator&(Lh &&lh, Rh &&rh);  // (4)
 
 template <typename Lh, some_expected_void Rh>
-constexpr auto operator&(Lh &&, Rh &&rh);  // (4)
+constexpr auto operator&(Lh &&, Rh &&rh);  // (5)
 
 template <some_expected_void Lh, typename Rh>
-constexpr auto operator&(Lh &&lh, Rh &&);  // (5)
+constexpr auto operator&(Lh &&lh, Rh &&);  // (6)
 
 template <typename Lh, typename Rh>
-constexpr auto operator&(Lh &&lh, Rh &&rh);                // (6)
-constexpr auto operator&(Lh &&, Rh &&)     -> just<void>;  // (7)
+constexpr auto operator&(Lh &&lh, Rh &&rh);                // (7)
+constexpr auto operator&(Lh &&, Rh &&)     -> just<void>;  // (8)
 
 template <some_optional Lh, some_optional Rh>
-constexpr auto operator&(Lh &&lh, Rh &&rh);  // (8)
-
-template <typename Lh, some_optional Rh>
 constexpr auto operator&(Lh &&lh, Rh &&rh);  // (9)
 
-template <some_optional Lh, typename Rh>
+template <typename Lh, some_optional Rh>
 constexpr auto operator&(Lh &&lh, Rh &&rh);  // (10)
 
-template <typename Lh, some_optional Rh>
+template <some_optional Lh, typename Rh>
 constexpr auto operator&(Lh &&lh, Rh &&rh);  // (11)
 
-template <some_optional Lh, typename Rh>
+template <typename Lh, some_optional Rh>
 constexpr auto operator&(Lh &&lh, Rh &&rh);  // (12)
 
-constexpr auto operator&(auto &&lh, auto &&rh);  // (13)
+template <some_optional Lh, typename Rh>
+constexpr auto operator&(Lh &&lh, Rh &&rh);  // (13)
 ```
 
-:include-doxygen-doc: fn::operator& { args: "Lh &&, Rh &&" }
-
-:include-doxygen-doc-params: fn::operator& { args: "Lh &&, Rh &&", title: "parameters" }
-
 :include-doxygen-doc: fn::operator& { args: "auto &&, auto &&" }
 
 :include-doxygen-doc-params: fn::operator& { args: "auto &&, auto &&", title: "parameters" }
 
+:include-doxygen-doc: fn::operator& { args: "Lh &&, Rh &&" }
+
+:include-doxygen-doc-params: fn::operator& { args: "Lh &&, Rh &&", title: "parameters" }
+
 ---
 
 ## Call signatures {style: "api"}
diff --git a/docs/reference/disjoin.md b/docs/reference/disjoin.md
index 2dcba1c1..f57b868d 100644
--- a/docs/reference/disjoin.md
+++ b/docs/reference/disjoin.md
@@ -2,7 +2,7 @@
 title: "fold fn::disjoin"
 ---
 
-##### Defined in {style: "api", badge: "#include <fn/pack.hpp>"}
+##### Defined in {style: "api", badge: "#include <fn/algebra.hpp>"}
 
 ---
 
diff --git a/docs/reference/pack.md b/docs/reference/pack.md
index f898672d..b06ada56 100644
--- a/docs/reference/pack.md
+++ b/docs/reference/pack.md
@@ -133,6 +133,8 @@ template <std::size_t I, some_pack P>
 constexpr auto get(P &&p) -> decltype(auto);  // (3)
 ```
 
+Overloads (1) and (2) take a `copack` and are defined in `<fn/copack.hpp>`.
+
 :include-doxygen-doc: fn::get { args: "Cp &&" }
 
 :include-doxygen-doc-params: fn::get { args: "Cp &&", title: "parameters" }
diff --git a/examples/calculator/calculator.hpp b/examples/calculator/calculator.hpp
index 3ad129ea..a2b56da2 100644
--- a/examples/calculator/calculator.hpp
+++ b/examples/calculator/calculator.hpp
@@ -6,6 +6,7 @@
 #ifndef EXAMPLES_CALCULATOR_CALCULATOR
 #define EXAMPLES_CALCULATOR_CALCULATOR
 
+#include <fn/algebra.hpp>
 #include <fn/and_then.hpp>
 #include <fn/expected.hpp>
 #include <fn/pack.hpp>
diff --git a/examples/type_algebra/main.cpp b/examples/type_algebra/main.cpp
index bc533620..f3a60229 100644
--- a/examples/type_algebra/main.cpp
+++ b/examples/type_algebra/main.cpp
@@ -1,3 +1,4 @@
+#include <fn/algebra.hpp>
 #include <fn/and_then.hpp>
 #include <fn/concepts.hpp>
 #include <fn/copack.hpp>
diff --git a/include/CMakeLists.txt b/include/CMakeLists.txt
index cfd60e5f..13278643 100644
--- a/include/CMakeLists.txt
+++ b/include/CMakeLists.txt
@@ -112,6 +112,7 @@ set(INCLUDE_FN_HEADERS
     fn/detail/pack_impl.hpp
     fn/detail/traits.hpp
     fn/detail/variadic_union.hpp
+    fn/algebra.hpp
     fn/and_then.hpp
     fn/concepts.hpp
     fn/copack.hpp
diff --git a/include/fn/algebra.hpp b/include/fn/algebra.hpp
new file mode 100644
index 00000000..4002db75
--- /dev/null
+++ b/include/fn/algebra.hpp
@@ -0,0 +1,240 @@
+// Copyright (c) 2026 Bronek Kozicki
+//
+// Distributed under the ISC License. See accompanying file LICENSE.md
+// or copy at https://opensource.org/licenses/ISC
+
+#ifndef INCLUDE_FN_ALGEBRA
+#define INCLUDE_FN_ALGEBRA
+
+#include <fn/copack.hpp>
+#include <fn/detail/functional.hpp>
+#include <fn/detail/traits.hpp>
+#include <fn/monadic.hpp>
+#include <fn/pack.hpp>
+#include <libfn_version.hpp>
+
+#include <type_traits>
+#include <utility>
+
+#include <fn/detail/macro_begin.hpp>
+
+namespace fn {
+inline namespace LIBFN_VERSION {
+
+namespace detail {
+
+// The join checks has_value() before value(); exclude the accessor
+// from noexcept calculations for folding and result construction.
+template <typename Monad> using _value_of_t = decltype(::std::declval<Monad>().value());
+
+template <typename Monad>
+using _factor_t = ::std::conditional_t<::std::is_void_v<typename ::std::remove_cvref_t<Monad>::value_type>,
+                                       ::fn::pack<>, typename ::std::remove_cvref_t<Monad>::value_type>;
+template <typename Monad>
+using _factor_of_t = ::std::conditional_t<::std::is_void_v<typename ::std::remove_cvref_t<Monad>::value_type>,
+                                          ::fn::pack<>, _value_of_t<Monad>>;
+
+template <typename Monad> [[nodiscard]] constexpr auto _factor(Monad &&m) -> _factor_of_t<Monad>
+{
+  if constexpr (::std::is_void_v<typename ::std::remove_cvref_t<Monad>::value_type>)
+    return {};
+  else
+    return FWD(m).value();
+}
+
+// An uninhabited factor has no value fold. Avoid instantiating it in types,
+// noexcept specifications and bodies.
+template <typename Lh, typename Rh>
+constexpr inline bool _uninhabited_join = empty_copack<typename ::std::remove_cvref_t<Lh>::value_type>
+                                          || empty_copack<typename ::std::remove_cvref_t<Rh>::value_type>;
+
+template <bool Uninhabited, typename Lh, typename Rh> struct _joined {
+  using type = copack<>;
+};
+template <typename Lh, typename Rh> struct _joined<false, Lh, Rh> {
+  using type = decltype(::fn::detail::_fold_detail::fold<_factor_t<Lh>, _factor_t<Rh>>(
+      ::std::declval<_factor_of_t<Lh>>(), ::std::declval<_factor_of_t<Rh>>()));
+};
+template <typename Lh, typename Rh> using _joined_t = typename _joined<_uninhabited_join<Lh, Rh>, Lh, Rh>::type;
+
+// Match the named efn parameter, which _join invokes as an lvalue.
+template <bool Uninhabited, template <typename> typename Tpl, typename Lh, typename Rh, typename Efn>
+struct _nothrow_join_arm {
+  static constexpr bool value = ::std::is_nothrow_invocable_v<Efn &, Lh> && ::std::is_nothrow_invocable_v<Efn &, Rh>
+                                && _nothrow_initializable<Tpl<copack<>>, ::std::invoke_result_t<Efn &, Lh>>
+                                && _nothrow_initializable<Tpl<copack<>>, ::std::invoke_result_t<Efn &, Rh>>;
+};
+template <template <typename> typename Tpl, typename Lh, typename Rh, typename Efn>
+struct _nothrow_join_arm<false, Tpl, Lh, Rh, Efn> {
+  static constexpr bool value = noexcept(::fn::detail::_fold_detail::fold<_factor_t<Lh>, _factor_t<Rh>>(
+                                    ::std::declval<_factor_of_t<Lh>>(), ::std::declval<_factor_of_t<Rh>>()))
+                                && _nothrow_initializable<Tpl<_joined_t<Lh, Rh>>, ::std::in_place_t, _joined_t<Lh, Rh>>
+                                && ::std::is_nothrow_invocable_v<Efn &, Lh> && ::std::is_nothrow_invocable_v<Efn &, Rh>
+                                && _nothrow_initializable<Tpl<_joined_t<Lh, Rh>>, ::std::invoke_result_t<Efn &, Lh>>
+                                && _nothrow_initializable<Tpl<_joined_t<Lh, Rh>>, ::std::invoke_result_t<Efn &, Rh>>;
+};
+template <template <typename> typename Tpl, typename Lh, typename Rh, typename Efn>
+constexpr inline bool _nothrow_join = _nothrow_join_arm<_uninhabited_join<Lh, Rh>, Tpl, Lh, Rh, Efn>::value;
+
+template <typename Lh, typename Rh>
+using _disjoined_t = copack_for<_sum_element_t<typename ::std::remove_cvref_t<Lh>::value_type>,
+                                _sum_element_t<typename ::std::remove_cvref_t<Rh>::value_type>>;
+
+template <typename T> constexpr inline bool _dead_value = empty_copack<typename ::std::remove_cvref_t<T>::value_type>;
+
+// Uninhabited values cannot reach the injection arm.
+template <bool Dead, typename Type, typename Side> struct _nothrow_disj_inject {
+  static constexpr bool value = true;
+};
+template <typename Type, typename Side> struct _nothrow_disj_inject<false, Type, Side> {
+  static constexpr bool value
+      = _nothrow_initializable<Type, ::std::in_place_t, decltype(::std::declval<Side>().value())>;
+};
+
+template <template <typename> typename Tpl>
+[[nodiscard]] constexpr auto _join(auto &&lh, auto &&rh, auto &&efn) //
+    noexcept(_nothrow_join<Tpl, decltype(lh), decltype(rh), decltype(efn)>)
+        -> Tpl<_joined_t<decltype(lh), decltype(rh)>>
+{
+  using type = Tpl<_joined_t<decltype(lh), decltype(rh)>>;
+  if constexpr (_uninhabited_join<decltype(lh), decltype(rh)>) {
+    if (not lh.has_value())
+      return type{efn(FWD(lh))};
+    else
+      return type{efn(FWD(rh))};
+  } else {
+    using Lh = _factor_t<decltype(lh)>;
+    using Rh = _factor_t<decltype(rh)>;
+    if (lh.has_value() && rh.has_value())
+      return type{::std::in_place, ::fn::detail::_fold_detail::fold<Lh, Rh>(_factor(FWD(lh)), _factor(FWD(rh)))};
+    else if (not lh.has_value())
+      return type{efn(FWD(lh))};
+    else
+      return type{efn(FWD(rh))};
+  }
+}
+
+} // namespace detail
+
+/**
+ * @brief The data conjunction: concatenates into a `pack`, distributing over `copack` alternatives
+ *
+ * With plain data on both sides the fields concatenate into one flat `pack`. When either operand
+ * is a `copack`, the product distributes over its alternatives - two copacks yield the full
+ * cartesian product - producing a normalized `copack` of `pack`s. Dispatches on its left operand:
+ * a bare `scalar & scalar` is not part of the algebra, so lift one side first, as in
+ * `fn::as_pack(a) & b`.
+ *
+ * @param lh A `pack` or a `copack`
+ * @param rh The data to conjoin: a scalar, a `pack` or a `copack`
+ * @return A `pack`, or a `copack` of `pack`s where alternatives distribute
+ */
+[[nodiscard]] constexpr auto operator&(auto &&lh, auto &&rh) //
+    noexcept(noexcept(::fn::detail::_fold_detail::fold<::std::remove_cvref_t<decltype(lh)>,
+                                                       ::std::remove_cvref_t<decltype(rh)>>(FWD(lh), FWD(rh))))
+  requires(some_copack<decltype(lh)> || some_pack<decltype(lh)>)
+{
+  using Lh = ::std::remove_cvref_t<decltype(lh)>;
+  using Rh = ::std::remove_cvref_t<decltype(rh)>;
+  return ::fn::detail::_fold_detail::fold<Lh, Rh>(FWD(lh), FWD(rh));
+}
+
+namespace detail {
+// Reject carriers here to avoid silently storing them as pack elements.
+template <typename... Ts>
+concept _no_carrier = (... && (not some_monadic_type<Ts>));
+
+template <typename... Ts>
+concept _all_carriers = (... && some_monadic_type<Ts>);
+} // namespace detail
+
+/**
+ * @brief The n-ary fold of `operator &` above; a single argument is forwarded unchanged
+ *
+ * Arguments must be all carriers or all data. Data forms a product, with a leading scalar
+ * lifted into a `pack`; carriers compose through their `operator &`.
+ */
+constexpr inline struct conjoin_t {
+  /**
+   * @brief Forwards a single argument unchanged
+   * @param arg The argument
+   * @return The argument, forwarded
+   */
+  template <typename Arg> [[nodiscard]] constexpr auto operator()(Arg &&arg) const -> decltype(arg) { return FWD(arg); }
+
+  /**
+   * @brief Folds data into a product, or carriers into their conjunction
+   *
+   * @param arg The leading argument
+   * @param args Further arguments - all data, or all carriers, never the two mixed
+   * @return The folded product, or the folded conjunction
+   */
+  template <typename Arg, typename... Args>
+    requires(not some_copack<Arg>) && (not some_pack<Arg>) && detail::_no_carrier<Arg, Args...>
+  [[nodiscard]] constexpr auto operator()(Arg &&arg, Args &&...args) const
+  {
+    return (::fn::pack{FWD(arg)} & ... & FWD(args));
+  }
+
+  template <typename Arg, typename... Args>
+    requires(some_copack<Arg> || some_pack<Arg>) && detail::_no_carrier<Args...>
+  [[nodiscard]] constexpr auto operator()(Arg &&arg, Args &&...args) const
+  {
+    return (FWD(arg) & ... & FWD(args));
+  }
+
+  template <typename Arg, typename... Args>
+    requires(sizeof...(Args) > 0)
+            && detail::_all_carriers<Arg, Args...> && requires(Arg &&a, Args &&...as) { (FWD(a) & ... & FWD(as)); }
+  [[nodiscard]] constexpr auto operator()(Arg &&arg, Args &&...args) const //
+      noexcept(noexcept((FWD(arg) & ... & FWD(args))))
+  {
+    return (FWD(arg) & ... & FWD(args));
+  }
+} conjoin; ///< The n-ary conjunction: `conjoin(a, b, c)`
+
+/**
+ * @brief The n-ary fold of the disjunction `operator |` over the monadic carriers; a single
+ *        argument is forwarded unchanged
+ *
+ * Carriers only, in every arity - disjunction has no data-level form. An identity-cluster operand
+ * makes the whole disjunction total, folding the result into `just` or `choice`.
+ */
+constexpr inline struct disjoin_t {
+  /**
+   * @brief Forwards a single carrier unchanged
+   * @param arg The carrier
+   * @return The carrier, forwarded
+   */
+  template <some_monadic_type Arg> [[nodiscard]] constexpr auto operator()(Arg &&arg) const -> decltype(arg)
+  {
+    return FWD(arg);
+  }
+
+  /**
+   * @brief Folds the carriers into their disjunction
+   *
+   * The n-ary form of `operator |`: the result holds the first operand that worked, its values
+   * summing into a `copack`, and the errors multiply into a `pack` reached only where every
+   * operand failed. An identity-cluster operand makes the whole disjunction total.
+   *
+   * @param arg The leading carrier
+   * @param args Further carriers to disjoin
+   * @return The folded disjunction
+   */
+  template <typename Arg, typename... Args>
+    requires(sizeof...(Args) > 0)
+            && detail::_all_carriers<Arg, Args...> && requires(Arg &&a, Args &&...as) { (FWD(a) | ... | FWD(as)); }
+  [[nodiscard]] constexpr auto operator()(Arg &&arg, Args &&...args) const //
+      noexcept(noexcept((FWD(arg) | ... | FWD(args))))
+  {
+    return (FWD(arg) | ... | FWD(args));
+  }
+} disjoin; ///< The n-ary disjunction: `disjoin(a, b, c)`
+
+} // namespace LIBFN_VERSION
+} // namespace fn
+
+#include <fn/detail/macro_end.hpp>
+
+#endif // INCLUDE_FN_ALGEBRA
diff --git a/include/fn/copack.hpp b/include/fn/copack.hpp
index 7749292c..2bf88e05 100644
--- a/include/fn/copack.hpp
+++ b/include/fn/copack.hpp
@@ -11,6 +11,7 @@
 #include <fn/detail/traits.hpp>
 #include <fn/detail/variadic_union.hpp>
 #include <fn/functional.hpp>
+#include <fn/pack.hpp>
 #include <libfn_version.hpp>
 #include <pfn/utility.hpp>
 
@@ -162,7 +163,7 @@ template <typename To, typename Fn> struct _copack_injector final {
     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
+      return To{::fn::pack<>{}};
     } else
       return static_cast<To>(::std::invoke(FWD(fn), FWD(args)...));
   }
@@ -1136,8 +1137,7 @@ struct copack<Ts...> {
    *
    * The self-flattening map: the callable is dispatched exhaustively, and the branch results -
    * 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`.
+   * `pack<>` - flatten, deduplicate and sort into the `copack_for` of them all.
    *
    * @param fn Callable applied on the active alternative; `fn::overload` fuses arms into one
    * @param args Additional arguments, appended after the alternative's content
diff --git a/include/fn/detail/traits.hpp b/include/fn/detail/traits.hpp
index 7b801f35..d8147228 100644
--- a/include/fn/detail/traits.hpp
+++ b/include/fn/detail/traits.hpp
@@ -13,6 +13,12 @@
 
 namespace fn::inline LIBFN_VERSION::detail {
 
+template <typename T> constexpr bool _is_in_place_type = false;
+template <typename T> constexpr bool _is_in_place_type<::std::in_place_type_t<T> &> = true;
+template <typename T> constexpr bool _is_in_place_type<::std::in_place_type_t<T> const &> = true;
+template <typename T>
+concept _some_in_place_type = _is_in_place_type<T &>;
+
 // The storage initializes an element as `T{args...}`, so a constraint on it must ask the same
 // question: `is_constructible_v` spells parenthesized initialization, which for an aggregate
 // performs no brace elision (`std::array<int, 3>` is not "constructible" from 3 ints) and permits
diff --git a/include/fn/detail/variadic_union.hpp b/include/fn/detail/variadic_union.hpp
index b805c21f..cbee56ec 100644
--- a/include/fn/detail/variadic_union.hpp
+++ b/include/fn/detail/variadic_union.hpp
@@ -7,6 +7,7 @@
 #define INCLUDE_FN_DETAIL_VARIADIC_UNION
 
 #include <fn/detail/functional.hpp>
+#include <fn/detail/traits.hpp>
 #include <libfn_version.hpp>
 #include <pfn/utility.hpp>
 
@@ -17,12 +18,6 @@
 
 namespace fn::inline LIBFN_VERSION::detail {
 
-template <typename T> constexpr bool _is_in_place_type = false;
-template <typename T> constexpr bool _is_in_place_type<::std::in_place_type_t<T> &> = true;
-template <typename T> constexpr bool _is_in_place_type<::std::in_place_type_t<T> const &> = true;
-template <typename T>
-concept _some_in_place_type = _is_in_place_type<T &>;
-
 // Constrained so a non-viable visitor fails overload resolution here: a deduced return would
 // otherwise instantiate the body and turn the answer into a hard error.
 template <typename T, typename Fn, typename... Args>
diff --git a/include/fn/expected.hpp b/include/fn/expected.hpp
index 2cd69724..f7f62d2e 100644
--- a/include/fn/expected.hpp
+++ b/include/fn/expected.hpp
@@ -10,6 +10,7 @@
 #include <pfn/expected.hpp>
 #include <pfn/utility.hpp>
 
+#include <fn/algebra.hpp>
 #include <fn/copack.hpp>
 #include <fn/detail/traits.hpp>
 #include <fn/fwd.hpp>
diff --git a/include/fn/just.hpp b/include/fn/just.hpp
index 1e640e32..e979ccd5 100644
--- a/include/fn/just.hpp
+++ b/include/fn/just.hpp
@@ -9,6 +9,7 @@
 #include <libfn_version.hpp>
 #include <pfn/utility.hpp>
 
+#include <fn/algebra.hpp>
 #include <fn/copack.hpp>
 #include <fn/detail/functional.hpp>
 #include <fn/detail/fwd.hpp>
diff --git a/include/fn/optional.hpp b/include/fn/optional.hpp
index 98bbc429..29c42b8c 100644
--- a/include/fn/optional.hpp
+++ b/include/fn/optional.hpp
@@ -10,6 +10,7 @@
 #include <pfn/optional.hpp>
 #include <pfn/utility.hpp>
 
+#include <fn/algebra.hpp>
 #include <fn/copack.hpp>
 #include <fn/detail/functional.hpp>
 #include <fn/fwd.hpp>
diff --git a/include/fn/pack.hpp b/include/fn/pack.hpp
index a08161d6..0b900470 100644
--- a/include/fn/pack.hpp
+++ b/include/fn/pack.hpp
@@ -6,10 +6,8 @@
 #ifndef INCLUDE_FN_PACK
 #define INCLUDE_FN_PACK
 
-#include <fn/copack.hpp>
 #include <fn/detail/meta.hpp>
 #include <fn/detail/pack_impl.hpp>
-#include <fn/monadic.hpp>
 #include <libfn_version.hpp>
 
 #include <type_traits>
@@ -136,7 +134,7 @@ template <typename... Ts> struct pack : detail::pack_impl<::std::index_sequence_
   [[nodiscard]] constexpr auto append(Arg &&arg) & //
       noexcept(noexcept(_impl::template _append<Arg, append_type<Arg>>(::std::declval<pack &>(), FWD(arg))))
           -> append_type<Arg>
-    requires(not some_in_place_type<Arg>)
+    requires(not detail::_some_in_place_type<Arg>)
             && requires { _impl::template _append<Arg, append_type<Arg>>(*this, FWD(arg)); }
   {
     return _impl::template _append<Arg, append_type<Arg>>(*this, FWD(arg));
@@ -146,7 +144,7 @@ template <typename... Ts> struct pack : detail::pack_impl<::std::index_sequence_
   [[nodiscard]] constexpr auto append(Arg &&arg) const & //
       noexcept(noexcept(_impl::template _append<Arg, append_type<Arg>>(::std::declval<pack const &>(), FWD(arg))))
           -> append_type<Arg>
-    requires(not some_in_place_type<Arg>)
+    requires(not detail::_some_in_place_type<Arg>)
             && requires { _impl::template _append<Arg, append_type<Arg>>(*this, FWD(arg)); }
   {
     return _impl::template _append<Arg, append_type<Arg>>(*this, FWD(arg));
@@ -156,7 +154,7 @@ template <typename... Ts> struct pack : detail::pack_impl<::std::index_sequence_
   [[nodiscard]] constexpr auto append(Arg &&arg) && //
       noexcept(noexcept(_impl::template _append<Arg, append_type<Arg>>(::std::declval<pack &&>(), FWD(arg))))
           -> append_type<Arg>
-    requires(not some_in_place_type<Arg>)
+    requires(not detail::_some_in_place_type<Arg>)
             && requires { _impl::template _append<Arg, append_type<Arg>>(::std::move(*this), FWD(arg)); }
   {
     return _impl::template _append<Arg, append_type<Arg>>(::std::move(*this), FWD(arg));
@@ -166,7 +164,7 @@ template <typename... Ts> struct pack : detail::pack_impl<::std::index_sequence_
   [[nodiscard]] constexpr auto append(Arg &&arg) const && //
       noexcept(noexcept(_impl::template _append<Arg, append_type<Arg>>(::std::declval<pack const &&>(), FWD(arg))))
           -> append_type<Arg>
-    requires(not some_in_place_type<Arg>)
+    requires(not detail::_some_in_place_type<Arg>)
             && requires { _impl::template _append<Arg, append_type<Arg>>(::std::move(*this), FWD(arg)); }
   {
     return _impl::template _append<Arg, append_type<Arg>>(::std::move(*this), FWD(arg));
@@ -300,7 +298,7 @@ template <::std::size_t I, some_pack P>
 // The unused leading pack absorbs explicit template arguments and the constraint rejects them:
 // this overload is deduction-only (value-category preserving), the overload below serves spelled types
 template <typename... Explicit, typename T, typename... Args>
-  requires(sizeof...(Explicit) == 0) && (not some_in_place_type<T>)
+  requires(sizeof...(Explicit) == 0) && (not detail::_some_in_place_type<T>)
           && detail::_initializable<pack<T, Args...>, T, Args...>
 [[nodiscard]] constexpr auto as_pack(T &&src, Args &&...args) //
     noexcept(detail::_nothrow_initializable<pack<T, Args...>, T, Args...>) -> pack<T, Args...>
@@ -325,241 +323,13 @@ template <typename... Explicit, typename T, typename... Args>
 // (a partial spelling fails on arity); by-value parameters admit conversion at the call boundary
 // (narrowing included) while still relocating rvalue arguments
 template <typename T, typename... Args>
-  requires(not some_in_place_type<T>) && detail::_initializable<pack<T, Args...>, T, Args...>
+  requires(not detail::_some_in_place_type<T>) && detail::_initializable<pack<T, Args...>, T, Args...>
 [[nodiscard]] constexpr auto as_pack(::std::type_identity_t<T> src, ::std::type_identity_t<Args>... args) //
     noexcept(detail::_nothrow_initializable<pack<T, Args...>, T, Args...>) -> pack<T, Args...>
 {
   return pack<T, Args...>{FWD(src), FWD(args)...};
 }
 
-namespace detail {
-
-// `value()` throws when the monad holds no value, but the join only reaches it once `has_value()`
-// has answered - so the specification below asks what folding and lifting the value promise, with
-// the accessor spelled as a type rather than as a call which would drag its own throw in.
-template <typename Monad> using _value_of_t = decltype(::std::declval<Monad>().value());
-
-template <typename Monad>
-using _factor_t = ::std::conditional_t<::std::is_void_v<typename ::std::remove_cvref_t<Monad>::value_type>,
-                                       ::fn::pack<>, typename ::std::remove_cvref_t<Monad>::value_type>;
-template <typename Monad>
-using _factor_of_t = ::std::conditional_t<::std::is_void_v<typename ::std::remove_cvref_t<Monad>::value_type>,
-                                          ::fn::pack<>, _value_of_t<Monad>>;
-
-template <typename Monad> [[nodiscard]] constexpr auto _factor(Monad &&m) -> _factor_of_t<Monad>
-{
-  if constexpr (::std::is_void_v<typename ::std::remove_cvref_t<Monad>::value_type>)
-    return {};
-  else
-    return FWD(m).value();
-}
-
-// A product with an uninhabited factor is itself uninhabited, and copack<> has no value fold - the
-// join over such a side must not name the fold, in the declared type, the noexcept specification
-// or the body, and always resolves through `efn`.
-template <typename Lh, typename Rh>
-constexpr inline bool _uninhabited_join = empty_copack<typename ::std::remove_cvref_t<Lh>::value_type>
-                                          || empty_copack<typename ::std::remove_cvref_t<Rh>::value_type>;
-
-template <bool Uninhabited, typename Lh, typename Rh> struct _joined {
-  using type = copack<>;
-};
-template <typename Lh, typename Rh> struct _joined<false, Lh, Rh> {
-  using type = decltype(::fn::detail::_fold_detail::fold<_factor_t<Lh>, _factor_t<Rh>>(
-      ::std::declval<_factor_of_t<Lh>>(), ::std::declval<_factor_of_t<Rh>>()));
-};
-template <typename Lh, typename Rh> using _joined_t = typename _joined<_uninhabited_join<Lh, Rh>, Lh, Rh>::type;
-
-// `_join` invokes `efn` as an lvalue - a named parameter - so the `Efn &` questions ask about the
-// call the body performs; the reference collapses to it whatever category the callable arrived in.
-template <bool Uninhabited, template <typename> typename Tpl, typename Lh, typename Rh, typename Efn>
-struct _nothrow_join_arm {
-  static constexpr bool value = ::std::is_nothrow_invocable_v<Efn &, Lh> && ::std::is_nothrow_invocable_v<Efn &, Rh>
-                                && _nothrow_initializable<Tpl<copack<>>, ::std::invoke_result_t<Efn &, Lh>>
-                                && _nothrow_initializable<Tpl<copack<>>, ::std::invoke_result_t<Efn &, Rh>>;
-};
-template <template <typename> typename Tpl, typename Lh, typename Rh, typename Efn>
-struct _nothrow_join_arm<false, Tpl, Lh, Rh, Efn> {
-  static constexpr bool value = noexcept(::fn::detail::_fold_detail::fold<_factor_t<Lh>, _factor_t<Rh>>(
-                                    ::std::declval<_factor_of_t<Lh>>(), ::std::declval<_factor_of_t<Rh>>()))
-                                && _nothrow_initializable<Tpl<_joined_t<Lh, Rh>>, ::std::in_place_t, _joined_t<Lh, Rh>>
-                                && ::std::is_nothrow_invocable_v<Efn &, Lh> && ::std::is_nothrow_invocable_v<Efn &, Rh>
-                                && _nothrow_initializable<Tpl<_joined_t<Lh, Rh>>, ::std::invoke_result_t<Efn &, Lh>>
-                                && _nothrow_initializable<Tpl<_joined_t<Lh, Rh>>, ::std::invoke_result_t<Efn &, Rh>>;
-};
-template <template <typename> typename Tpl, typename Lh, typename Rh, typename Efn>
-constexpr inline bool _nothrow_join = _nothrow_join_arm<_uninhabited_join<Lh, Rh>, Tpl, Lh, Rh, Efn>::value;
-
-template <typename Lh, typename Rh>
-using _disjoined_t = copack_for<_sum_element_t<typename ::std::remove_cvref_t<Lh>::value_type>,
-                                _sum_element_t<typename ::std::remove_cvref_t<Rh>::value_type>>;
-
-template <typename T> constexpr inline bool _dead_value = empty_copack<typename ::std::remove_cvref_t<T>::value_type>;
-
-// A dead side (uninhabited value) never relocates into the result - its inject arm is if
-// constexpr'd out of the body, and weighs nothing here.
-template <bool Dead, typename Type, typename Side> struct _nothrow_disj_inject {
-  static constexpr bool value = true;
-};
-template <typename Type, typename Side> struct _nothrow_disj_inject<false, Type, Side> {
-  static constexpr bool value
-      = _nothrow_initializable<Type, ::std::in_place_t, decltype(::std::declval<Side>().value())>;
-};
-
-template <template <typename> typename Tpl>
-[[nodiscard]] constexpr auto _join(auto &&lh, auto &&rh, auto &&efn) //
-    noexcept(_nothrow_join<Tpl, decltype(lh), decltype(rh), decltype(efn)>)
-        -> Tpl<_joined_t<decltype(lh), decltype(rh)>>
-{
-  using type = Tpl<_joined_t<decltype(lh), decltype(rh)>>;
-  if constexpr (_uninhabited_join<decltype(lh), decltype(rh)>) {
-    if (not lh.has_value())
-      return type{efn(FWD(lh))};
-    else
-      return type{efn(FWD(rh))};
-  } else {
-    using Lh = _factor_t<decltype(lh)>;
-    using Rh = _factor_t<decltype(rh)>;
-    if (lh.has_value() && rh.has_value())
-      return type{::std::in_place, ::fn::detail::_fold_detail::fold<Lh, Rh>(_factor(FWD(lh)), _factor(FWD(rh)))};
-    else if (not lh.has_value())
-      return type{efn(FWD(lh))};
-    else
-      return type{efn(FWD(rh))};
-  }
-}
-
-} // namespace detail
-
-/**
- * @brief The data conjunction: concatenates into a `pack`, distributing over `copack` alternatives
- *
- * With plain data on both sides the fields concatenate into one flat `pack`. When either operand
- * is a `copack`, the product distributes over its alternatives - two copacks yield the full
- * cartesian product - producing a normalized `copack` of `pack`s. Dispatches on its left operand:
- * a bare `scalar & scalar` is not part of the algebra, so lift one side first, as in
- * `fn::as_pack(a) & b`.
- *
- * @param lh A `pack` or a `copack`
- * @param rh The data to conjoin: a scalar, a `pack` or a `copack`
- * @return A `pack`, or a `copack` of `pack`s where alternatives distribute
- */
-[[nodiscard]] constexpr auto operator&(auto &&lh, auto &&rh) //
-    noexcept(noexcept(::fn::detail::_fold_detail::fold<::std::remove_cvref_t<decltype(lh)>,
-                                                       ::std::remove_cvref_t<decltype(rh)>>(FWD(lh), FWD(rh))))
-  requires(some_copack<decltype(lh)> || some_pack<decltype(lh)>)
-{
-  using Lh = ::std::remove_cvref_t<decltype(lh)>;
-  using Rh = ::std::remove_cvref_t<decltype(rh)>;
-  return ::fn::detail::_fold_detail::fold<Lh, Rh>(FWD(lh), FWD(rh));
-}
-
-namespace detail {
-// The data fold takes data. A monadic carrier among the arguments would become a pack element,
-// silently answering a question the caller did not ask: `&` over carriers conjoins the carriers
-// themselves, and their values cannot be reached without `value()`, which throws.
-template <typename... Ts>
-concept _no_carrier = (... && (not some_monadic_type<Ts>));
-
-// ... and the carrier folds take carriers, all of them: a mixed argument list belongs to neither
-// world and is refused, rather than resolved by the leading argument.
-template <typename... Ts>
-concept _all_carriers = (... && some_monadic_type<Ts>);
-} // namespace detail
-
-/**
- * @brief The n-ary fold of `operator &` above; a single argument is forwarded unchanged
- *
- * Two modes, never mixed in one call: with every argument a computation carrier the fold is the
- * monadic conjunction, exactly what cascading `operator &` produces, and with none of them a
- * carrier it is the data-level product, a leading scalar lifted into a `pack` first. A mixed
- * argument list is refused rather than resolved by the leading argument.
- */
-constexpr inline struct conjoin_t {
-  /**
-   * @brief Forwards a single argument unchanged
-   * @param arg The argument
-   * @return The argument, forwarded
-   */
-  template <typename Arg> [[nodiscard]] constexpr auto operator()(Arg &&arg) const -> decltype(arg) { return FWD(arg); }
-
-  /**
-   * @brief Folds data into a product, or carriers into their conjunction
-   *
-   * With no carrier among the arguments the fold is the data-level product: a leading scalar is
-   * lifted into a `pack` first, and a leading `pack` or `copack` dispatches `operator &` itself.
-   * With every argument a carrier the same fold is their monadic conjunction.
-   *
-   * @param arg The leading argument
-   * @param args Further arguments - all data, or all carriers, never the two mixed
-   * @return The folded product, or the folded conjunction
-   */
-  template <typename Arg, typename... Args>
-    requires(not some_copack<Arg>) && (not some_pack<Arg>) && detail::_no_carrier<Arg, Args...>
-  [[nodiscard]] constexpr auto operator()(Arg &&arg, Args &&...args) const
-  {
-    return (::fn::pack{FWD(arg)} & ... & FWD(args));
-  }
-
-  template <typename Arg, typename... Args>
-    requires(some_copack<Arg> || some_pack<Arg>) && detail::_no_carrier<Args...>
-  [[nodiscard]] constexpr auto operator()(Arg &&arg, Args &&...args) const
-  {
-    return (FWD(arg) & ... & FWD(args));
-  }
-
-  template <typename Arg, typename... Args>
-    requires(sizeof...(Args) > 0)
-            && detail::_all_carriers<Arg, Args...> && requires(Arg &&a, Args &&...as) { (FWD(a) & ... & FWD(as)); }
-  [[nodiscard]] constexpr auto operator()(Arg &&arg, Args &&...args) const //
-      noexcept(noexcept((FWD(arg) & ... & FWD(args))))
-  {
-    return (FWD(arg) & ... & FWD(args));
-  }
-} conjoin; ///< The n-ary conjunction: `conjoin(a, b, c)`
-
-/**
- * @brief The n-ary fold of the disjunction `operator |` over the monadic carriers; a single
- *        argument is forwarded unchanged
- *
- * Carriers only, in every arity - disjunction has no data-level form. An identity-cluster operand
- * makes the whole disjunction total, folding the result into `just` or `choice`.
- */
-constexpr inline struct disjoin_t {
-  // Carriers only, in every arity: `|` over anything else is the built-in operator, and folding
-  // integers into 3 is not what this asks for
-
-  /**
-   * @brief Forwards a single carrier unchanged
-   * @param arg The carrier
-   * @return The carrier, forwarded
-   */
-  template <some_monadic_type Arg> [[nodiscard]] constexpr auto operator()(Arg &&arg) const -> decltype(arg)
-  {
-    return FWD(arg);
-  }
-
-  /**
-   * @brief Folds the carriers into their disjunction
-   *
-   * The n-ary form of `operator |`: the result holds the first operand that worked, its values
-   * summing into a `copack`, and the errors multiply into a `pack` reached only where every
-   * operand failed. An identity-cluster operand makes the whole disjunction total.
-   *
-   * @param arg The leading carrier
-   * @param args Further carriers to disjoin
-   * @return The folded disjunction
-   */
-  template <typename Arg, typename... Args>
-    requires(sizeof...(Args) > 0)
-            && detail::_all_carriers<Arg, Args...> && requires(Arg &&a, Args &&...as) { (FWD(a) | ... | FWD(as)); }
-  [[nodiscard]] constexpr auto operator()(Arg &&arg, Args &&...args) const //
-      noexcept(noexcept((FWD(arg) | ... | FWD(args))))
-  {
-    return (FWD(arg) | ... | FWD(args));
-  }
-} disjoin; ///< The n-ary disjunction: `disjoin(a, b, c)`
-
 } // namespace LIBFN_VERSION
 } // namespace fn
 
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index ce5e8a3e..c1be3e55 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -111,6 +111,7 @@ set(TESTS_FN_SOURCES
     fn/detail/pack_impl.cpp
     fn/detail/traits.cpp
     fn/detail/variadic_union.cpp
+    fn/algebra.cpp
     fn/and_then.cpp
     fn/concepts.cpp
     fn/copack.cpp
diff --git a/tests/fn/algebra.cpp b/tests/fn/algebra.cpp
new file mode 100644
index 00000000..1e8d705e
--- /dev/null
+++ b/tests/fn/algebra.cpp
@@ -0,0 +1,344 @@
+// Copyright (c) 2026 Bronek Kozicki
+//
+// Distributed under the ISC License. See accompanying file LICENSE.md
+// or copy at https://opensource.org/licenses/ISC
+
+#include "util/helper_types.hpp"
+
+#include <fn/algebra.hpp>
+#include <fn/copack.hpp>
+#include <fn/expected.hpp>
+#include <fn/just.hpp>
+#include <fn/optional.hpp>
+#include <fn/pack.hpp>
+
+#include <catch2/catch_all.hpp>
+
+#include <concepts>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+#include <fn/detail/macro_begin.hpp>
+
+namespace {
+struct Alef final {
+  int value;
+};
+struct Bet final {
+  int value;
+};
+struct Gimel final {
+  int value;
+};
+struct Heh final {
+  int value;
+};
+struct Vav final {
+  int value;
+};
+struct Zayn final {
+  int value;
+};
+
+// Namespace scope: local classes cannot have member templates.
+struct EfnLvalueNothrow {
+  constexpr auto operator()(auto const &) & noexcept -> std::nullopt_t { return std::nullopt; }
+  auto operator()(auto const &) && noexcept(false) -> std::nullopt_t { throw 0; }
+};
+struct EfnRvalueNothrow {
+  auto operator()(auto const &) & noexcept(false) -> std::nullopt_t { throw 0; }
+  constexpr auto operator()(auto const &) && noexcept -> std::nullopt_t { return std::nullopt; }
+};
+struct EfnLvalueOnly {
+  constexpr auto operator()(auto const &) & noexcept -> std::nullopt_t { return std::nullopt; }
+  auto operator()(auto const &) && -> std::nullopt_t = delete;
+};
+} // namespace
+
+namespace {
+constexpr auto join_witness = [](auto &&...v) -> int { return (0 + ... + v.value); };
+
+struct join_via_optional final {
+  template <typename R, typename LH, typename RH> static constexpr auto join(LH const &lh, RH const &rh)
+  {
+    constexpr auto efn = [](auto &&...) { return std::nullopt; };
+    auto const r = fn::detail::_join<fn::optional>(fn::optional<LH>{lh}, fn::optional<RH>{rh}, efn);
+    static_assert(std::is_same_v<decltype(r), fn::optional<R> const>);
+    return r.value();
+  }
+};
+
+struct join_via_operator final {
+  template <typename R, typename LH, typename RH> static constexpr auto join(LH const &lh, RH const &rh)
+  {
+    auto const r = lh & rh;
+    static_assert(std::is_same_v<decltype(r), R const>);
+    return r;
+  }
+};
+
+template <typename S> constexpr bool join_battery()
+{
+  using fn::copack;
+  using fn::copack_for;
+  using fn::pack;
+
+  bool ok = true;
+  {
+    using R = copack_for<pack<Alef, Gimel, Heh>, pack<Alef, Gimel, Vav>, pack<Alef, Gimel, Zayn>, //
+                         pack<Bet, Gimel, Heh>, pack<Bet, Gimel, Vav>, pack<Bet, Gimel, Zayn>>;
+    auto const r = S::template join<R>(copack_for<pack<Alef, Gimel>, pack<Bet, Gimel>>{pack{Alef{3}, Gimel{14}}},
+                                       copack<Heh, Vav, Zayn>{Vav{15}});
+    ok = ok && r.template has_value<pack<Alef, Gimel, Vav>>() && r.apply(join_witness) == 3 + 14 + 15;
+  }
+  {
+    using R = copack_for<pack<Alef, Gimel, Heh, Zayn>, pack<Alef, Gimel, Vav>, //
+                         pack<Bet, Gimel, Heh, Zayn>, pack<Bet, Gimel, Vav>>;
+    auto const r = S::template join<R>(copack_for<pack<Alef, Gimel>, pack<Bet, Gimel>>{pack{Alef{3}, Gimel{14}}},
+                                       copack<pack<Heh, Zayn>, pack<Vav>>{pack{Vav{15}}});
+    ok = ok && r.template has_value<pack<Alef, Gimel, Vav>>() && r.apply(join_witness) == 3 + 14 + 15;
+  }
+  {
+    using R = copack_for<pack<Alef, Heh>, pack<Alef, Vav>, pack<Alef, Zayn>, pack<Bet, Heh>, pack<Bet, Vav>,
+                         pack<Bet, Zayn>, pack<Gimel, Heh>, pack<Gimel, Vav>, pack<Gimel, Zayn>>;
+    auto const r = S::template join<R>(copack_for<Alef, Bet, Gimel>{Gimel{3}}, copack<Heh, Vav, Zayn>{Vav{14}});
+    ok = ok && r.template has_value<pack<Gimel, Vav>>() && r.apply(join_witness) == 3 + 14;
+  }
+  {
+    using R = copack_for<pack<Alef, Heh, Zayn>, pack<Alef, Vav>, pack<Bet, Heh, Zayn>, //
+                         pack<Bet, Vav>, pack<Gimel, Heh, Zayn>, pack<Gimel, Vav>>;
+    auto const r = S::template join<R>(copack_for<Alef, Bet, Gimel>{Gimel{3}},
+                                       copack<pack<Heh, Zayn>, pack<Vav>>{pack{Vav{14}}});
+    ok = ok && r.template has_value<pack<Gimel, Vav>>() && r.apply(join_witness) == 3 + 14;
+  }
+  {
+    using R = copack_for<pack<Alef, Gimel, Vav>, pack<Bet, Gimel, Vav>>;
+    auto const r
+        = S::template join<R>(copack_for<pack<Alef, Gimel>, pack<Bet, Gimel>>{pack{Alef{3}, Gimel{14}}}, Vav{15});
+    ok = ok && r.template has_value<pack<Alef, Gimel, Vav>>() && r.apply(join_witness) == 3 + 14 + 15;
+  }
+  {
+    using R = copack_for<pack<Alef, Gimel, Vav>, pack<Bet, Gimel, Vav>>;
+    auto const r = S::template join<R>(copack_for<pack<Alef, Gimel>, pack<Bet, Gimel>>{pack{Alef{3}, Gimel{14}}},
+                                       pack<Vav>{pack{Vav{15}}});
+    ok = ok && r.template has_value<pack<Alef, Gimel, Vav>>() && r.apply(join_witness) == 3 + 14 + 15;
+  }
+  {
+    using R = copack_for<pack<Alef, Vav>, pack<Bet, Vav>, pack<Gimel, Vav>>;
+    auto const r = S::template join<R>(copack_for<Alef, Bet, Gimel>{Gimel{3}}, Vav{14});
+    ok = ok && r.template has_value<pack<Gimel, Vav>>() && r.apply(join_witness) == 3 + 14;
+  }
+  {
+    using R = copack_for<pack<Alef, Vav>, pack<Bet, Vav>, pack<Gimel, Vav>>;
+    auto const r = S::template join<R>(copack_for<Alef, Bet, Gimel>{Gimel{3}}, pack<Vav>{pack{Vav{14}}});
+    ok = ok && r.template has_value<pack<Gimel, Vav>>() && r.apply(join_witness) == 3 + 14;
+  }
+  {
+    using R = copack<pack<Alef, Gimel, Heh>, pack<Alef, Gimel, Vav>, pack<Alef, Gimel, Zayn>>;
+    auto const r = S::template join<R>(pack<Alef, Gimel>{pack{Alef{3}, Gimel{14}}}, copack<Heh, Vav, Zayn>{Vav{15}});
+    ok = ok && r.template has_value<pack<Alef, Gimel, Vav>>() && r.apply(join_witness) == 3 + 14 + 15;
+  }
+  {
+    using R = copack<pack<Alef, Gimel, Heh, Zayn>, pack<Alef, Gimel, Vav>>;
+    auto const r = S::template join<R>(pack<Alef, Gimel>{pack{Alef{3}, Gimel{14}}},
+                                       copack<pack<Heh, Zayn>, pack<Vav>>{pack{Vav{15}}});
+    ok = ok && r.template has_value<pack<Alef, Gimel, Vav>>() && r.apply(join_witness) == 3 + 14 + 15;
+  }
+  {
+    auto const r = S::template join<pack<Alef, Gimel, Vav>>(pack<Alef, Gimel>{pack{Alef{3}, Gimel{14}}}, Vav{15});
+    ok = ok && r.apply(join_witness) == 3 + 14 + 15;
+  }
+  {
+    auto const r = S::template join<pack<Alef, Gimel, Vav>>(pack<Alef, Gimel>{pack{Alef{3}, Gimel{14}}},
+                                                            pack<Vav>{pack{Vav{15}}});
+    ok = ok && r.apply(join_witness) == 3 + 14 + 15;
+  }
+  return ok;
+}
+
+// Scalar left operands are supported only by the carrier join.
+constexpr bool join_value_lhs_battery()
+{
+  using fn::copack;
+  using fn::pack;
+  using S = join_via_optional;
+
+  bool ok = true;
+  {
+    using R = copack<pack<Alef, Heh>, pack<Alef, Vav>, pack<Alef, Zayn>>;
+    auto const r = S::join<R>(Alef{3}, copack<Heh, Vav, Zayn>{Vav{14}});
+    ok = ok && r.template has_value<pack<Alef, Vav>>() && r.apply(join_witness) == 3 + 14;
+  }
+  {
+    using R = copack<pack<Alef, Heh, Zayn>, pack<Alef, Vav>>;
+    auto const r = S::join<R>(Alef{3}, copack<pack<Heh, Zayn>, pack<Vav>>{pack{Vav{14}}});
+    ok = ok && r.template has_value<pack<Alef, Vav>>() && r.apply(join_witness) == 3 + 14;
+  }
+  {
+    auto const r = S::join<pack<Alef, Vav>>(Alef{3}, Vav{14});
+    ok = ok && r.apply(join_witness) == 3 + 14;
+  }
+  {
+    auto const r = S::join<pack<Alef, Vav>>(Alef{3}, pack<Vav>{pack{Vav{14}}});
+    ok = ok && r.apply(join_witness) == 3 + 14;
+  }
+  return ok;
+}
+} // namespace
+
+TEMPLATE_TEST_CASE("join of copacks, packs and values", "[pack][copack][detail][optional][operator_and]",
+                   join_via_optional, join_via_operator)
+{
+  static_assert(join_battery<TestType>());
+  REQUIRE(join_battery<TestType>());
+}
+
+TEST_CASE("detail::_join with value operands", "[detail][pack][copack][optional]")
+{
+  static_assert(join_value_lhs_battery());
+  REQUIRE(join_value_lhs_battery());
+}
+
+TEST_CASE("detail::_join with an error continuation", "[detail][optional][noexcept]")
+{
+  using Rh = fn::optional<int>;
+
+  using fn::detail::_join;
+  static_assert(noexcept(_join<fn::optional>(std::declval<Rh &>(), std::declval<Rh &>(), EfnLvalueNothrow{})));
+  static_assert(not noexcept(_join<fn::optional>(std::declval<Rh &>(), std::declval<Rh &>(), EfnRvalueNothrow{})));
+  static_assert(noexcept(_join<fn::optional>(std::declval<Rh &>(), std::declval<Rh &>(), EfnLvalueOnly{})));
+  static_assert(
+      noexcept(_join<fn::optional>(std::declval<Rh &>(), std::declval<Rh &>(), std::declval<EfnLvalueNothrow &>())));
+  static_assert(not noexcept(
+      _join<fn::optional>(std::declval<Rh &>(), std::declval<Rh &>(), std::declval<EfnRvalueNothrow &>())));
+
+  CHECK(not _join<fn::optional>(Rh{std::nullopt}, Rh{12}, EfnLvalueNothrow{}).has_value());
+  CHECK(not _join<fn::optional>(Rh{12}, Rh{std::nullopt}, EfnLvalueOnly{}).has_value());
+  CHECK(_join<fn::optional>(Rh{3}, Rh{4}, EfnLvalueOnly{}).has_value());
+  static_assert(not _join<fn::optional>(Rh{std::nullopt}, Rh{12}, EfnLvalueNothrow{}).has_value());
+  static_assert(not _join<fn::optional>(Rh{12}, Rh{std::nullopt}, EfnLvalueOnly{}).has_value());
+  static_assert(_join<fn::optional>(Rh{3}, Rh{4}, EfnLvalueOnly{}).has_value());
+}
+
+TEST_CASE("operator &", "[pack][copack][operator_and]")
+{
+  constexpr auto r1 = fn::as_copack(12) & 3 & 2.5 & fn::pack{0.5, true}
+                      & fn::copack_for<bool, int, fn::pack<double, int>>(fn::pack{1.5, 12});
+  static_assert(std::is_same_v<                                     //
+                decltype(r1),                                       //
+                fn::copack_for<                                     //
+                    fn::pack<int, int, double, double, bool, bool>, //
+                    fn::pack<int, int, double, double, bool, int>,  //
+                    fn::pack<int, int, double, double, bool, double, int>> const>);
+  static_assert(r1.apply([](auto &&...args) -> double { return (1 * ... * static_cast<double>(args)); })
+                == 12. * 3 * 2.5 * 0.5 * 1 * 1.5 * 12);
+
+  constexpr auto r2 = fn::conjoin(12, 3, 2.5, fn::pack{0.5, true},
+                                  fn::copack_for<bool, int, fn::pack<double, int>>(fn::pack{1.5, 12}));
+  static_assert(std::is_same_v<                                     //
+                decltype(r2),                                       //
+                fn::copack_for<                                     //
+                    fn::pack<int, int, double, double, bool, bool>, //
+                    fn::pack<int, int, double, double, bool, int>,  //
+                    fn::pack<int, int, double, double, bool, double, int>> const>);
+  static_assert(r2.apply([](auto &&...args) -> double { return (1 * ... * static_cast<double>(args)); })
+                == 12. * 3 * 2.5 * 0.5 * 1 * 1.5 * 12);
+
+  constexpr auto r3 = fn::as_copack(12) & fn::pack<std::tuple<int, int>>{std::tuple{1, 2}};
+  static_assert(std::is_same_v<decltype(r3), fn::copack<fn::pack<int, std::tuple<int, int>>> const>);
+  static_assert(r3.apply([](int i, std::tuple<int, int> const &t) { return i == 12 && std::get<0>(t) == 1; }));
+
+  SECTION("noexcept")
+  {
+    static_assert(noexcept(std::declval<fn::pack<int> &>() & 2));
+    static_assert(noexcept(std::declval<fn::copack<int> &>() & 2));
+    SUCCEED();
+  }
+
+  SECTION("an element is held as itself")
+  {
+    constexpr auto held = [] {
+      fn::pack<Atom> const src{{{Atom{7}}}};
+      return fn::get<0>(src & fn::pack{9}).n;
+    };
+    static_assert(held() == 7);
+    CHECK(held() == 7);
+  }
+
+  SECTION("the data fold takes data, never a carrier")
+  {
+    constexpr auto can = [](auto &&...args) { return requires { fn::conjoin(FWD(args)...); }; };
+    static_assert(can(12, 2.5));
+    static_assert(can(fn::pack{1, 2}, 3));
+    static_assert(can(fn::as_copack(12), 3));
+    static_assert(not can(fn::expected<int, bool>{1}, 3));
+    static_assert(not can(12, fn::expected<int, bool>{1}));
+    static_assert(not can(fn::pack{1, 2}, fn::expected<int, bool>{1}));
+    static_assert(not can(fn::as_copack(12), fn::optional<int>{1}));
+    static_assert(not can(fn::choice<int>{1}, 2));
+    static_assert(can(fn::expected<int, bool>{1}));
+    static_assert(fn::conjoin(fn::expected<int, bool>{1}) == fn::expected<int, bool>{1});
+    SUCCEED();
+  }
+
+  SECTION("all carriers instead, and the fold is the carrier conjunction")
+  {
+    using EA = fn::expected<int, bool>;
+    using EB = fn::expected<double, bool>;
+    static_assert(std::same_as<decltype(fn::conjoin(std::declval<EA>(), std::declval<EB>())),
+                               decltype(std::declval<EA>() & std::declval<EB>())>);
+    constexpr auto is_1_2_5 = [](int i, double d) { return i == 1 && d == 2.5; };
+    static_assert(fn::conjoin(EA{1}, EB{2.5}).value().apply(is_1_2_5));
+    static_assert(fn::conjoin(EA{fn::unexpect, true}, EB{2.5}).error() == true);
+
+    using EC = fn::expected<double, int>;
+    static_assert(std::same_as<decltype(fn::conjoin(std::declval<EA>(), std::declval<EC>())),
+                               fn::expected<fn::pack<int, double>, fn::copack_for<bool, int>>>);
+    static_assert(fn::conjoin(EA{1}, EC{2.5}).value().apply(is_1_2_5));
+    static_assert(fn::conjoin(EA{fn::unexpect, true}, EC{2.5}).error() == fn::copack_for<bool, int>{true});
+    static_assert(fn::conjoin(EA{1}, EC{fn::unexpect, 7}).error() == fn::copack_for<bool, int>{7});
+    CHECK(fn::conjoin(EA{1}, EC{2.5}).value().apply(is_1_2_5));
+    CHECK(bool(fn::conjoin(EA{1}, EC{fn::unexpect, 7}).error() == fn::copack_for<bool, int>{7}));
+
+    constexpr auto is_1_true_2 = [](int a, bool b, int c) { return a == 1 && b && c == 2; };
+    static_assert(fn::conjoin(fn::just<int>{1}, fn::just<bool>{true}, fn::just<int>{2}).value().apply(is_1_true_2));
+    constexpr auto is_1_true = [](int i, bool b) { return i == 1 && b; };
+    static_assert(fn::conjoin(fn::optional<int>{1}, fn::optional<bool>{true}).value().apply(is_1_true));
+    CHECK(fn::conjoin(fn::optional<int>{1}, fn::optional<bool>{true}).value().apply(is_1_true));
+    static_assert(not fn::conjoin(fn::optional<int>{}, fn::optional<bool>{true}).has_value());
+
+    constexpr auto can = [](auto &&...args) { return requires { fn::conjoin(FWD(args)...); }; };
+    static_assert(can(fn::optional<int>{1}, fn::optional<bool>{true}));
+    static_assert(not can(fn::optional<int>{1}, true));
+    static_assert(not can(fn::optional<int>{1}, fn::expected<int, bool>{1}));
+    SUCCEED();
+  }
+}
+
+TEST_CASE("disjoin", "[disjoin][pack][expected][just]")
+{
+  enum Error : int { FileNotFound };
+  using EA = fn::expected<int, Error>;
+  using EB = fn::expected<bool, int>;
+
+  static_assert(std::same_as<decltype(fn::disjoin(std::declval<EA>(), std::declval<EB>())),
+                             decltype(std::declval<EA>() | std::declval<EB>())>);
+  static_assert(fn::disjoin(EA{1}) == EA{1});
+  static_assert(fn::disjoin(EA{::fn::unexpect, FileNotFound}, EB{true}) == fn::copack{true});
+  static_assert(
+      fn::disjoin(fn::just<void>{}, fn::just<void>{}, fn::just<int>{7}).apply([]([[maybe_unused]] auto &&...args) {
+        return sizeof...(args);
+      })
+      == 0);
+  CHECK(bool(fn::disjoin(EA{::fn::unexpect, FileNotFound}, EB{true})
+             == fn::copack{true})); // bool(): Catch2 decomposition re-enters the == constraint
+
+  constexpr auto can = [](auto &&...args) { return requires { fn::disjoin(FWD(args)...); }; };
+  static_assert(can(EA{1}, EB{true}));
+  static_assert(not can(EA{1}, 42));
+
+  static_assert(not can(1, 2));
+  static_assert(not can(42));
+  static_assert(can(EA{1}));
+}
diff --git a/tests/fn/copack.cpp b/tests/fn/copack.cpp
index f37cdc5b..9e19523c 100644
--- a/tests/fn/copack.cpp
+++ b/tests/fn/copack.cpp
@@ -4,7 +4,6 @@
 // or copy at https://opensource.org/licenses/ISC
 
 #include <fn/copack.hpp>
-#include <fn/pack.hpp>
 #include <fn/utility.hpp>
 
 #include <catch2/catch_all.hpp>
diff --git a/tests/fn/detail/functional.cpp b/tests/fn/detail/functional.cpp
index 9ce964f2..96fcb503 100644
--- a/tests/fn/detail/functional.cpp
+++ b/tests/fn/detail/functional.cpp
@@ -3,6 +3,7 @@
 // Distributed under the ISC License. See accompanying file LICENSE.md
 // or copy at https://opensource.org/licenses/ISC
 
+#include <fn/copack.hpp>
 #include <fn/detail/functional.hpp>
 #include <fn/pack.hpp>
 #include <fn/utility.hpp>
diff --git a/tests/fn/optional.cpp b/tests/fn/optional.cpp
index 2e24131f..7fd981b7 100644
--- a/tests/fn/optional.cpp
+++ b/tests/fn/optional.cpp
@@ -33,23 +33,6 @@ struct MoveNothrow {
   MoveNothrow(MoveNothrow &&) noexcept = default;
 };
 
-// The join invokes its error-continuation as an lvalue - a named parameter - whatever the value
-// category it was passed in, and its specification must ask about that call. These answer the
-// lvalue and the rvalue question differently, in both directions - and the third offers only the
-// call the body performs. Namespace scope: a local class cannot have member templates.
-struct EfnLvalueNothrow {
-  constexpr auto operator()(auto const &) & noexcept -> std::nullopt_t { return std::nullopt; }
-  auto operator()(auto const &) && noexcept(false) -> std::nullopt_t { throw 0; }
-};
-struct EfnRvalueNothrow {
-  auto operator()(auto const &) & noexcept(false) -> std::nullopt_t { throw 0; }
-  constexpr auto operator()(auto const &) && noexcept -> std::nullopt_t { return std::nullopt; }
-};
-struct EfnLvalueOnly {
-  constexpr auto operator()(auto const &) & noexcept -> std::nullopt_t { return std::nullopt; }
-  auto operator()(auto const &) && -> std::nullopt_t = delete;
-};
-
 // Copacks whose alternatives include a non-builtin (Xint/std::string_view/fn::pack — any
 // class/struct/enum) have platform-specific order (see copack.cpp); pure-builtin copacks keep copack<...>.
 } // namespace
@@ -742,28 +725,6 @@ TEST_CASE("optional pack support", "[optional][pack][and_then][transform][operat
       static_assert(not noexcept(std::declval<Sh &>() & std::declval<Rh &>()));
       static_assert(noexcept(std::declval<Sh &&>() & std::declval<Rh &&>()));
 
-      SECTION("_join")
-      {
-        // the join invokes its error-continuation as an lvalue, and its specification asks about
-        // that call - whether the callable arrives as a temporary or an lvalue
-        using fn::detail::_join;
-        static_assert(noexcept(_join<fn::optional>(std::declval<Rh &>(), std::declval<Rh &>(), EfnLvalueNothrow{})));
-        static_assert(
-            not noexcept(_join<fn::optional>(std::declval<Rh &>(), std::declval<Rh &>(), EfnRvalueNothrow{})));
-        static_assert(noexcept(_join<fn::optional>(std::declval<Rh &>(), std::declval<Rh &>(), EfnLvalueOnly{})));
-        static_assert(noexcept(
-            _join<fn::optional>(std::declval<Rh &>(), std::declval<Rh &>(), std::declval<EfnLvalueNothrow &>())));
-        static_assert(not noexcept(
-            _join<fn::optional>(std::declval<Rh &>(), std::declval<Rh &>(), std::declval<EfnRvalueNothrow &>())));
-
-        // the body performs the lvalue call: the rvalue overload throws, or does not exist
-        CHECK(not _join<fn::optional>(Rh{std::nullopt}, Rh{12}, EfnLvalueNothrow{}).has_value());
-        CHECK(not _join<fn::optional>(Rh{12}, Rh{std::nullopt}, EfnLvalueOnly{}).has_value());
-        CHECK(_join<fn::optional>(Rh{3}, Rh{4}, EfnLvalueOnly{}).has_value());
-        static_assert(not _join<fn::optional>(Rh{std::nullopt}, Rh{12}, EfnLvalueNothrow{}).has_value());
-        static_assert(not _join<fn::optional>(Rh{12}, Rh{std::nullopt}, EfnLvalueOnly{}).has_value());
-        static_assert(_join<fn::optional>(Rh{3}, Rh{4}, EfnLvalueOnly{}).has_value());
-      }
       SUCCEED();
     }
 
diff --git a/tests/fn/pack.cpp b/tests/fn/pack.cpp
index 5160232f..21fcebee 100644
--- a/tests/fn/pack.cpp
+++ b/tests/fn/pack.cpp
@@ -49,13 +49,6 @@ concept can_append = requires(V v, Arg arg) { FWD(v).append(FWD(arg)); };
 // must say so. Its non-const-lvalue copy is noexcept, which is what makes the promise category-wise.
 using Throwing = helper_t<prop::throw_copy | prop::throw_move>;
 
-struct Atom final {
-  int n = 0;
-  constexpr Atom() noexcept = default;
-  constexpr explicit Atom(int x) noexcept : n(x) {}
-  template <typename R> constexpr operator R() const noexcept { return R{}; }
-};
-
 template <typename... Args>
 concept can_as_pack = requires(Args &&...args) { fn::as_pack(FWD(args)...); };
 
@@ -714,11 +707,10 @@ TEST_CASE("append value categories", "[pack][append]")
           fn::get<0>(pack<>{}.append(src)).n,
           fn::get<0>(pack<>{}.append(std::in_place_type<pack<Atom>>, src)).n,
           fn::get<0>(src.append(std::in_place_type<pack<int>>, 9)).n,
-          fn::get<0>(src & pack{9}).n,
       };
     };
-    static_assert(held() == std::array{7, 7, 7, 7, 7, 7, 7});
-    CHECK(held() == std::array{7, 7, 7, 7, 7, 7, 7});
+    static_assert(held() == std::array{7, 7, 7, 7, 7, 7});
+    CHECK(held() == std::array{7, 7, 7, 7, 7, 7});
   }
 }
 
@@ -855,300 +847,6 @@ TEST_CASE("pack with immovable data", "[pack][immovable]")
   CHECK(v.apply([](auto &&...args) noexcept -> int { return (0 + ... + args.value); }) == 3 + 14 + 15 + 92);
 }
 
-namespace {
-struct Alef final {
-  int value;
-};
-struct Bet final {
-  int value;
-};
-struct Gimel final {
-  int value;
-};
-struct Heh final {
-  int value;
-};
-struct Vav final {
-  int value;
-};
-struct Zayn final {
-  int value;
-};
-} // namespace
-
-namespace {
-constexpr auto join_witness = [](auto &&...v) -> int { return (0 + ... + v.value); };
-
-// One join algebra, two layers walking the same shape grid: the TEMPLATE_TEST_CASE below runs the
-// battery through each subject, in both constant and runtime evaluation.
-struct join_via_optional final { // fn::detail::_join over engaged optionals - the monads' layer
-  template <typename R, typename LH, typename RH> static constexpr auto join(LH const &lh, RH const &rh)
-  {
-    constexpr auto efn = [](auto &&...) { return std::nullopt; };
-    auto const r = fn::detail::_join<fn::optional>(fn::optional<LH>{lh}, fn::optional<RH>{rh}, efn);
-    static_assert(std::is_same_v<decltype(r), fn::optional<R> const>);
-    return r.value();
-  }
-};
-
-struct join_via_operator final { // the public operator& over bare copacks, packs and values
-  template <typename R, typename LH, typename RH> static constexpr auto join(LH const &lh, RH const &rh)
-  {
-    auto const r = lh & rh;
-    static_assert(std::is_same_v<decltype(r), R const>);
-    return r;
-  }
-};
-
-template <typename S> constexpr bool join_battery()
-{
-  using fn::copack;
-  using fn::copack_for;
-  using fn::pack;
-
-  bool ok = true;
-  { // copack of packs join copack of scalars
-    using R = copack_for<pack<Alef, Gimel, Heh>, pack<Alef, Gimel, Vav>, pack<Alef, Gimel, Zayn>, //
-                         pack<Bet, Gimel, Heh>, pack<Bet, Gimel, Vav>, pack<Bet, Gimel, Zayn>>;
-    auto const r = S::template join<R>(copack_for<pack<Alef, Gimel>, pack<Bet, Gimel>>{pack{Alef{3}, Gimel{14}}},
-                                       copack<Heh, Vav, Zayn>{Vav{15}});
-    ok = ok && r.template has_value<pack<Alef, Gimel, Vav>>() && r.apply(join_witness) == 3 + 14 + 15;
-  }
-  {                                                                            // copack of packs join copack of packs
-    using R = copack_for<pack<Alef, Gimel, Heh, Zayn>, pack<Alef, Gimel, Vav>, //
-                         pack<Bet, Gimel, Heh, Zayn>, pack<Bet, Gimel, Vav>>;
-    auto const r = S::template join<R>(copack_for<pack<Alef, Gimel>, pack<Bet, Gimel>>{pack{Alef{3}, Gimel{14}}},
-                                       copack<pack<Heh, Zayn>, pack<Vav>>{pack{Vav{15}}});
-    ok = ok && r.template has_value<pack<Alef, Gimel, Vav>>() && r.apply(join_witness) == 3 + 14 + 15;
-  }
-  { // copack of scalars join copack of scalars
-    using R = copack_for<pack<Alef, Heh>, pack<Alef, Vav>, pack<Alef, Zayn>, pack<Bet, Heh>, pack<Bet, Vav>,
-                         pack<Bet, Zayn>, pack<Gimel, Heh>, pack<Gimel, Vav>, pack<Gimel, Zayn>>;
-    auto const r = S::template join<R>(copack_for<Alef, Bet, Gimel>{Gimel{3}}, copack<Heh, Vav, Zayn>{Vav{14}});
-    ok = ok && r.template has_value<pack<Gimel, Vav>>() && r.apply(join_witness) == 3 + 14;
-  }
-  { // copack of scalars join copack of packs
-    using R = copack_for<pack<Alef, Heh, Zayn>, pack<Alef, Vav>, pack<Bet, Heh, Zayn>, //
-                         pack<Bet, Vav>, pack<Gimel, Heh, Zayn>, pack<Gimel, Vav>>;
-    auto const r = S::template join<R>(copack_for<Alef, Bet, Gimel>{Gimel{3}},
-                                       copack<pack<Heh, Zayn>, pack<Vav>>{pack{Vav{14}}});
-    ok = ok && r.template has_value<pack<Gimel, Vav>>() && r.apply(join_witness) == 3 + 14;
-  }
-  { // copack of packs join scalar
-    using R = copack_for<pack<Alef, Gimel, Vav>, pack<Bet, Gimel, Vav>>;
-    auto const r
-        = S::template join<R>(copack_for<pack<Alef, Gimel>, pack<Bet, Gimel>>{pack{Alef{3}, Gimel{14}}}, Vav{15});
-    ok = ok && r.template has_value<pack<Alef, Gimel, Vav>>() && r.apply(join_witness) == 3 + 14 + 15;
-  }
-  { // copack of packs join pack
-    using R = copack_for<pack<Alef, Gimel, Vav>, pack<Bet, Gimel, Vav>>;
-    auto const r = S::template join<R>(copack_for<pack<Alef, Gimel>, pack<Bet, Gimel>>{pack{Alef{3}, Gimel{14}}},
-                                       pack<Vav>{pack{Vav{15}}});
-    ok = ok && r.template has_value<pack<Alef, Gimel, Vav>>() && r.apply(join_witness) == 3 + 14 + 15;
-  }
-  { // copack of scalars join scalar
-    using R = copack_for<pack<Alef, Vav>, pack<Bet, Vav>, pack<Gimel, Vav>>;
-    auto const r = S::template join<R>(copack_for<Alef, Bet, Gimel>{Gimel{3}}, Vav{14});
-    ok = ok && r.template has_value<pack<Gimel, Vav>>() && r.apply(join_witness) == 3 + 14;
-  }
-  { // copack of scalars join pack
-    using R = copack_for<pack<Alef, Vav>, pack<Bet, Vav>, pack<Gimel, Vav>>;
-    auto const r = S::template join<R>(copack_for<Alef, Bet, Gimel>{Gimel{3}}, pack<Vav>{pack{Vav{14}}});
-    ok = ok && r.template has_value<pack<Gimel, Vav>>() && r.apply(join_witness) == 3 + 14;
-  }
-  { // pack join copack of scalars
-    using R = copack<pack<Alef, Gimel, Heh>, pack<Alef, Gimel, Vav>, pack<Alef, Gimel, Zayn>>;
-    auto const r = S::template join<R>(pack<Alef, Gimel>{pack{Alef{3}, Gimel{14}}}, copack<Heh, Vav, Zayn>{Vav{15}});
-    ok = ok && r.template has_value<pack<Alef, Gimel, Vav>>() && r.apply(join_witness) == 3 + 14 + 15;
-  }
-  { // pack join copack of packs
-    using R = copack<pack<Alef, Gimel, Heh, Zayn>, pack<Alef, Gimel, Vav>>;
-    auto const r = S::template join<R>(pack<Alef, Gimel>{pack{Alef{3}, Gimel{14}}},
-                                       copack<pack<Heh, Zayn>, pack<Vav>>{pack{Vav{15}}});
-    ok = ok && r.template has_value<pack<Alef, Gimel, Vav>>() && r.apply(join_witness) == 3 + 14 + 15;
-  }
-  { // pack join scalar
-    auto const r = S::template join<pack<Alef, Gimel, Vav>>(pack<Alef, Gimel>{pack{Alef{3}, Gimel{14}}}, Vav{15});
-    ok = ok && r.apply(join_witness) == 3 + 14 + 15;
-  }
-  { // pack join pack
-    auto const r = S::template join<pack<Alef, Gimel, Vav>>(pack<Alef, Gimel>{pack{Alef{3}, Gimel{14}}},
-                                                            pack<Vav>{pack{Vav{15}}});
-    ok = ok && r.apply(join_witness) == 3 + 14 + 15;
-  }
-  return ok;
-}
-
-// A bare value can sit on the LEFT of the monad-level join only - operator& has no overload for it,
-// so these four shapes belong to join_via_optional alone.
-constexpr bool join_value_lhs_battery()
-{
-  using fn::copack;
-  using fn::pack;
-  using S = join_via_optional;
-
-  bool ok = true;
-  { // scalar join copack of scalars
-    using R = copack<pack<Alef, Heh>, pack<Alef, Vav>, pack<Alef, Zayn>>;
-    auto const r = S::join<R>(Alef{3}, copack<Heh, Vav, Zayn>{Vav{14}});
-    ok = ok && r.template has_value<pack<Alef, Vav>>() && r.apply(join_witness) == 3 + 14;
-  }
-  { // scalar join copack of packs
-    using R = copack<pack<Alef, Heh, Zayn>, pack<Alef, Vav>>;
-    auto const r = S::join<R>(Alef{3}, copack<pack<Heh, Zayn>, pack<Vav>>{pack{Vav{14}}});
-    ok = ok && r.template has_value<pack<Alef, Vav>>() && r.apply(join_witness) == 3 + 14;
-  }
-  { // scalar join scalar
-    auto const r = S::join<pack<Alef, Vav>>(Alef{3}, Vav{14});
-    ok = ok && r.apply(join_witness) == 3 + 14;
-  }
-  { // scalar join pack
-    auto const r = S::join<pack<Alef, Vav>>(Alef{3}, pack<Vav>{pack{Vav{14}}});
-    ok = ok && r.apply(join_witness) == 3 + 14;
-  }
-  return ok;
-}
-} // namespace
-
-TEMPLATE_TEST_CASE("join of copacks, packs and values", "[pack][copack][detail][optional][operator_and]",
-                   join_via_optional, join_via_operator)
-{
-  static_assert(join_battery<TestType>());
-  REQUIRE(join_battery<TestType>());
-}
-
-TEST_CASE("detail::_join with value operands", "[detail][pack][copack][optional]")
-{
-  static_assert(join_value_lhs_battery());
-  REQUIRE(join_value_lhs_battery());
-}
-
-TEST_CASE("operator &", "[pack][copack][operator_and]")
-{
-  constexpr auto r1 = fn::as_copack(12) & 3 & 2.5 & fn::pack{0.5, true}
-                      & fn::copack_for<bool, int, fn::pack<double, int>>(fn::pack{1.5, 12});
-  static_assert(std::is_same_v<                                     //
-                decltype(r1),                                       //
-                fn::copack_for<                                     //
-                    fn::pack<int, int, double, double, bool, bool>, //
-                    fn::pack<int, int, double, double, bool, int>,  //
-                    fn::pack<int, int, double, double, bool, double, int>> const>);
-  static_assert(r1.apply([](auto &&...args) -> double { return (1 * ... * static_cast<double>(args)); })
-                == 12. * 3 * 2.5 * 0.5 * 1 * 1.5 * 12);
-
-  constexpr auto r2 = fn::conjoin(12, 3, 2.5, fn::pack{0.5, true},
-                                  fn::copack_for<bool, int, fn::pack<double, int>>(fn::pack{1.5, 12}));
-  static_assert(std::is_same_v<                                     //
-                decltype(r2),                                       //
-                fn::copack_for<                                     //
-                    fn::pack<int, int, double, double, bool, bool>, //
-                    fn::pack<int, int, double, double, bool, int>,  //
-                    fn::pack<int, int, double, double, bool, double, int>> const>);
-  static_assert(r2.apply([](auto &&...args) -> double { return (1 * ... * static_cast<double>(args)); })
-                == 12. * 3 * 2.5 * 0.5 * 1 * 1.5 * 12);
-
-  // a pack whose only element is tuple-like splices whole through the join
-  constexpr auto r3 = fn::as_copack(12) & fn::pack<std::tuple<int, int>>{std::tuple{1, 2}};
-  static_assert(std::is_same_v<decltype(r3), fn::copack<fn::pack<int, std::tuple<int, int>>> const>);
-  static_assert(r3.apply([](int i, std::tuple<int, int> const &t) { return i == 12 && std::get<0>(t) == 1; }));
-
-  SECTION("noexcept")
-  {
-    // This operator& builds a pack from operands it relocates, and weighs that: nothing here can
-    // throw, so it promises noexcept - as optional's and expected's joins now do.
-    static_assert(noexcept(std::declval<fn::pack<int> &>() & 2));
-    static_assert(noexcept(std::declval<fn::copack<int> &>() & 2));
-    SUCCEED();
-  }
-
-  SECTION("the data fold takes data, never a carrier")
-  {
-    // A carrier passed here would have become a pack element - the pack of the carriers, not the
-    // conjunction of what they carry - so the fold refuses it, in any position.
-    constexpr auto can = [](auto &&...args) { return requires { fn::conjoin(FWD(args)...); }; };
-    static_assert(can(12, 2.5));
-    static_assert(can(fn::pack{1, 2}, 3));
-    static_assert(can(fn::as_copack(12), 3));
-    static_assert(not can(fn::expected<int, bool>{1}, 3));
-    static_assert(not can(12, fn::expected<int, bool>{1}));
-    static_assert(not can(fn::pack{1, 2}, fn::expected<int, bool>{1}));
-    static_assert(not can(fn::as_copack(12), fn::optional<int>{1}));
-    static_assert(not can(fn::choice<int>{1}, 2));
-    // ... while a single argument is forwarded unchanged, carrier or not: nothing is packed
-    static_assert(can(fn::expected<int, bool>{1}));
-    static_assert(fn::conjoin(fn::expected<int, bool>{1}) == fn::expected<int, bool>{1});
-    SUCCEED();
-  }
-
-  SECTION("all carriers instead, and the fold is the carrier conjunction")
-  {
-    // The same spelling over carriers folds `operator &` over the carriers themselves - the
-    // conjunction, whose value side is the product - and it is the fold of that operator, exactly
-    using EA = fn::expected<int, bool>;
-    using EB = fn::expected<double, bool>;
-    static_assert(std::same_as<decltype(fn::conjoin(std::declval<EA>(), std::declval<EB>())),
-                               decltype(std::declval<EA>() & std::declval<EB>())>);
-    constexpr auto is_1_2_5 = [](int i, double d) { return i == 1 && d == 2.5; };
-    static_assert(fn::conjoin(EA{1}, EB{2.5}).value().apply(is_1_2_5));
-    static_assert(fn::conjoin(EA{fn::unexpect, true}, EB{2.5}).error() == true);
-
-    // ... and the operands' errors need not agree: the conjunction sums them, ungraded or not
-    using EC = fn::expected<double, int>;
-    static_assert(std::same_as<decltype(fn::conjoin(std::declval<EA>(), std::declval<EC>())),
-                               fn::expected<fn::pack<int, double>, fn::copack_for<bool, int>>>);
-    static_assert(fn::conjoin(EA{1}, EC{2.5}).value().apply(is_1_2_5));
-    static_assert(fn::conjoin(EA{fn::unexpect, true}, EC{2.5}).error() == fn::copack_for<bool, int>{true});
-    static_assert(fn::conjoin(EA{1}, EC{fn::unexpect, 7}).error() == fn::copack_for<bool, int>{7});
-    CHECK(fn::conjoin(EA{1}, EC{2.5}).value().apply(is_1_2_5));
-    CHECK(bool(fn::conjoin(EA{1}, EC{fn::unexpect, 7}).error() == fn::copack_for<bool, int>{7}));
-
-    // n-ary, and the product splices rather than nesting
-    constexpr auto is_1_true_2 = [](int a, bool b, int c) { return a == 1 && b && c == 2; };
-    static_assert(fn::conjoin(fn::just<int>{1}, fn::just<bool>{true}, fn::just<int>{2}).value().apply(is_1_true_2));
-    constexpr auto is_1_true = [](int i, bool b) { return i == 1 && b; };
-    static_assert(fn::conjoin(fn::optional<int>{1}, fn::optional<bool>{true}).value().apply(is_1_true));
-    CHECK(fn::conjoin(fn::optional<int>{1}, fn::optional<bool>{true}).value().apply(is_1_true));
-    static_assert(not fn::conjoin(fn::optional<int>{}, fn::optional<bool>{true}).has_value());
-
-    // the two worlds never mix: the refusals above hold in both directions
-    constexpr auto can = [](auto &&...args) { return requires { fn::conjoin(FWD(args)...); }; };
-    static_assert(can(fn::optional<int>{1}, fn::optional<bool>{true}));
-    static_assert(not can(fn::optional<int>{1}, true));
-    static_assert(not can(fn::optional<int>{1}, fn::expected<int, bool>{1})); // no mixed-kind `&`
-    SUCCEED();
-  }
-}
-
-TEST_CASE("disjoin", "[disjoin][pack][expected][just]")
-{
-  enum Error : int { FileNotFound };
-  using EA = fn::expected<int, Error>;
-  using EB = fn::expected<bool, int>;
-
-  static_assert(std::same_as<decltype(fn::disjoin(std::declval<EA>(), std::declval<EB>())),
-                             decltype(std::declval<EA>() | std::declval<EB>())>);
-  static_assert(fn::disjoin(EA{1}) == EA{1}); // unary forwards unchanged
-  static_assert(fn::disjoin(EA{::fn::unexpect, FileNotFound}, EB{true}) == fn::copack{true});
-  static_assert(
-      fn::disjoin(fn::just<void>{}, fn::just<void>{}, fn::just<int>{7}).apply([]([[maybe_unused]] auto &&...args) {
-        return sizeof...(args);
-      })
-      == 0); // left catch through the whole chain
-  CHECK(bool(fn::disjoin(EA{::fn::unexpect, FileNotFound}, EB{true})
-             == fn::copack{true})); // bool(): Catch2 decomposition re-enters the == constraint
-
-  // a non-viable fold answers instead of erroring
-  constexpr auto can = [](auto &&...args) { return requires { fn::disjoin(FWD(args)...); }; };
-  static_assert(can(EA{1}, EB{true}));
-  static_assert(not can(EA{1}, 42));
-
-  // carriers only, in every arity: `|` over anything else is the built-in operator, and the fold of
-  // two integers is 3, an answer this verb has no business giving
-  static_assert(not can(1, 2));
-  static_assert(not can(42));
-  static_assert(can(EA{1}));
-}
-
 namespace {
 template <typename P, std::size_t I>
 concept can_get = requires(P p) { fn::get<I>(static_cast<P &&>(p)); };
diff --git a/tests/util/helper_types.hpp b/tests/util/helper_types.hpp
index 45276226..03cf0fd9 100644
--- a/tests/util/helper_types.hpp
+++ b/tests/util/helper_types.hpp
@@ -296,4 +296,11 @@ static_assert(not std::is_move_constructible_v<helper_immovable>);
 static_assert(not std::is_copy_assignable_v<helper_immovable>);
 static_assert(not std::is_move_assignable_v<helper_immovable>);
 
+struct Atom final {
+  int n = 0;
+  constexpr Atom() noexcept = default;
+  constexpr explicit Atom(int x) noexcept : n(x) {}
+  template <typename R> constexpr operator R() const noexcept { return R{}; }
+};
+
 #endif // INCLUDE_TESTS_UTIL_HELPER_TYPES