Key expected's SMF constraints/noexcept on E, not the exposition-only unexpected<E> (#69)

## Summary

`expected<T,E>` stores its error as the exposition-only `unexpected<E>`
(D4280) so the reference specializations can share one member type
(`unexpected<E&>` holds a pointer). This PR makes sure that's genuinely
observable-only, ABI-preserving scaffolding:

- Re-keys every special-member
*Constraints*/*Mandates*/`noexcept`/triviality condition in
`expected.hpp` (all three specializations) from `unexpected<E>` to `E`,
and does the same in the just-landed wording (`expected-new.tex`). An
implementation that stores `E` directly stays trivially conforming — no
ABI, layout, or mangling change is forced on anyone.
- Fixes two divergences from `std::expected` a beman-vs-`std`
trait-equivalence harness (added here) turned up:
- the hidden-friend `swap` was unconstrained, so
`is_swappable_v<expected<T,E>>` was a hard compile error (not a
well-formed `false`) for a move-restricted `E`
- the non-trivial copy constructor/assignment were missing their
conditional `noexcept`
- Declares the trivial-path copy/move constructor unconditionally (no
`requires`-clause), matching libstdc++'s own `<expected>` idiom, after
the equivalence harness caught GCC and Clang disagreeing on
`is_trivially_copyable_v<expected<int, Immovable>>` for a
fully-immovable error type. The same trick was tried for assignment and
reverted — it silently broke the "move assignment must be deleted when
neither side is nothrow-movable" safety guarantee — so assignment
operators keep their original two-candidate form; this is documented in
the paper rather than forced.
- Documents both decisions in `D4280R0.tex` (D12: exposition-only
member, ABI stability as a design goal, resolution toward the T/E
rendering if any divergence is ever found; D13: `expected<T,E>` is
trivially copyable when `T`,`E` are, called out as a drive-by fix over
`std::expected`'s non-trivial-by-specification-accident assignment).

## Test plan

- [x] Full suite (1081 tests, including the `std::expected` parity gate
and the new equivalence gate) passes on GCC/libstdc++
- [x] Full suite passes on Clang/libstdc++
- [x] `pre-commit` (clang-format, gersemi, codespell, beman-tidy) clean
on all changed files

Author: steve-downey

include/beman/expected/expected.hpp

@@ -614,6 +614,72 @@ \section{Feature test macro (D11)}
 A feature test macro \tcode{__cpp_lib_expected_ref} is proposed, so code can
 detect the reference specializations.
 
+\section{The held \tcode{unexpected<E>} is exposition-only; the observable
+  behavior is keyed on \tcode{E} (D12)}
+
+Storing the error as \tcode{unexpected<E>} (D4) is a specification device, not a
+representation mandate. It buys the reference case --- \tcode{unexpected<E\&>}
+holds a pointer --- without a new specialization. It must buy nothing else. In
+particular it must not reach an existing implementation and tell it to change
+what \tcode{expected<T, E>} stores.
+
+So the exposition-only member is \tcode{unexpected<E>}, but every observable
+property is stated in terms of \tcode{E}: the \emph{Constraints}, the
+\emph{Mandates}, the exception specifications, and the triviality of each special
+member function read exactly as they do in the current \tcode{T}-and-\tcode{E}
+wording. An implementation that stores \tcode{E} directly, as every shipping one
+does, is conforming unchanged. Its layout, its name mangling, and its trait
+answers do not move. ABI stability for existing implementations was a goal of
+this design, not an accident of it.
+
+This is safe because \tcode{unexpected<E>} is a transparent wrapper over
+\tcode{E}: for an object \tcode{E} its copy, move, assignment, destruction,
+exception specifications, and triviality all track \tcode{E}'s own. The one place
+the language lets such a wrapper diverge --- a defaulted move that is defined as
+deleted is ignored by overload resolution, where a user-deleted move is not ---
+is reconciled by \tcode{expected}'s own fall-back from a constrained-out move to
+its copy, and lands on the same answer. The equivalence was checked trait by
+trait against \tcode{std::expected} across a battery of awkward error types.
+
+The design commits to the conclusion, not to the coincidence. If an observable
+difference between the \tcode{unexpected<E>} rendering and a rendering with
+separate \tcode{T} and \tcode{E} members is ever found, that is a defect in this
+proposal, and its resolution is already decided: the behavior is whatever the
+\tcode{T}-and-\tcode{E} rendering gives. The wrapper is how the error is
+described, never what the program is allowed to observe.
+
+One implementation note, since it is not obvious and cost real debugging time.
+Declaring a copy or move constructor as two candidates, each guarded by its own
+\tcode{requires}-clause covering only the trivial and only the non-trivial case,
+leaves a gap when \tcode{E} is not copy or move constructible at all: neither
+candidate's constraint holds, and whether the compiler still falls back to an
+implicitly-declared (and correctly deleted) constructor is exactly the kind of
+question compilers have disagreed about. \tcode{libstdc++}'s own
+\tcode{<expected>} avoids the question by declaring the trivial-path constructor
+with no constraint at all --- an unconditional \tcode{= default} --- and letting
+constraint subsumption prefer the non-trivial candidate whenever it applies. The
+reference implementation adopts the same idiom. It is a statement about how to
+spell the declaration, not about what either candidate computes, and it changes
+nothing this section already promised.
+
+\section{\tcode{expected<T, E>} is trivially copyable when \tcode{T} and
+  \tcode{E} are (D13)}
+
+A drive-by. \tcode{expected<int, int>} is not trivially copyable today, because
+\tcode{expected}'s copy and move assignment are specified as non-trivial
+operations even when every component is trivial. There is no semantic reason for
+this. The assignment of a sum of trivially copyable, trivially assignable,
+trivially destructible types can be defaulted, and then the whole
+\tcode{expected} is trivially copyable --- it can be passed in registers and
+relocated with \tcode{memcpy}.
+
+``Non-trivial by specification'' is not a reason; it is the absence of one. This
+proposal specifies the special member functions of \tcode{expected} to be trivial
+when \tcode{T} and \tcode{E} make them trivial, matching the intuition that a sum
+of trivial types is trivial. The change is a widening: types that were trivially
+copyable stay so, and \tcode{expected<int, int>} joins them. Nothing that was
+trivially copyable becomes less so.
+
 \chapter{Anticipated objections}
 
 \section{``Use \tcode{reference\_wrapper} instead''}

papers/D4280R0.tex

@@ -1393,7 +1393,7 @@
 The exception specification is equivalent to:
 \begin{codeblock}
 is_nothrow_move_constructible_v<T> && is_nothrow_swappable_v<T> &&
-is_nothrow_move_constructible_v<unexpected<E>> && is_nothrow_swappable_v<unexpected<E>>
+is_nothrow_move_constructible_v<E> && (is_reference_v<E> || is_nothrow_swappable_v<E>)
 \end{codeblock}
 \end{itemdescr}
 
@@ -2479,7 +2479,7 @@
 \pnum
 \remarks
 The exception specification is equivalent to
-\tcode{is_nothrow_move_constructible_v<unexpected<E>> \&\& is_nothrow_swappable_v<unexpected<E>>}.
+\tcode{is_nothrow_move_constructible_v<E> \&\& (is_reference_v<E> || is_nothrow_swappable_v<E>)}.
 \end{itemdescr}
 
 \indexlibrarymember{swap}{expected<void>}%
@@ -3062,10 +3062,10 @@
 \pnum
 \remarks
 The exception specification of the move constructor is equivalent to
-\tcode{is_nothrow_move_constructible_v<unexpected<E>>}. Each of these
+\tcode{is_nothrow_move_constructible_v<E>}. Each of these
 constructors is trivial if the corresponding constructor of
-\tcode{unexpected<E>} is trivial, and is defined as deleted unless that
-constructor of \tcode{unexpected<E>} is available.
+\tcode{E} is trivial, and is defined as deleted unless that
+constructor of \tcode{E} is available.
 \end{itemdescr}
 
 \indexlibraryctor{expected}%
@@ -3205,7 +3205,7 @@
 
 \pnum
 \remarks
-This destructor is trivial if \tcode{unexpected<E>} is trivially
+This destructor is trivial if \tcode{E} is trivially
 destructible. \tcode{T} is not destroyed; \tcode{*this} never owns the object
 it refers to.
 \end{itemdescr}
@@ -3340,7 +3340,7 @@
 \pnum
 \remarks
 The exception specification is equivalent to
-\tcode{is_nothrow_move_constructible_v<unexpected<E>> \&\&}
+\tcode{is_nothrow_move_constructible_v<E> \&\&}
 \tcode{(is_reference_v<E> || is_nothrow_swappable_v<E>)}.
 \end{itemdescr}
 

papers/expected-new.tex

@@ -39,6 +39,7 @@ set(beman_expected_beman_only_tests
     expected_ref_both.test.cpp
     expected_void_ref_e.test.cpp
     expected_review_corrections.test.cpp
+    expected_smf_regressions.test.cpp
     header_idempotence.test.cpp
 )
 
@@ -97,6 +98,31 @@ if(NOT BEMAN_EXPECTED_USING_LIBCXX)
     )
 endif()
 
+# --- beman::expected vs std::expected trait-equivalence gate ----------------
+# The exposition-only held member is unexpected<E>, but every observable
+# special-member property is keyed on E. This target asserts (both headers in
+# one TU) that the resulting traits match std::expected across a battery of
+# adversarial error types -- i.e. the unexpected<E> member is behaviourally
+# inert against a T/E rendering. Requires C++23; skipped on libc++ for the same
+# reason as the std parity gate above (see docs/std-parity.md).
+if(NOT BEMAN_EXPECTED_USING_LIBCXX)
+    add_executable(beman.expected.tests.equivalence)
+    target_sources(
+        beman.expected.tests.equivalence
+        PRIVATE expected_std_equivalence.test.cpp
+    )
+    target_compile_features(beman.expected.tests.equivalence PRIVATE cxx_std_23)
+    target_include_directories(
+        beman.expected.tests.equivalence
+        PRIVATE ${PROJECT_SOURCE_DIR}/tests
+    )
+    target_link_libraries(
+        beman.expected.tests.equivalence
+        PRIVATE beman::expected Catch2::Catch2WithMain
+    )
+    catch_discover_tests(beman.expected.tests.equivalence)
+endif()
+
 # =============================================================================
 # Negative compile tests (WILL_FAIL = compile failure is the expected outcome)
 # =============================================================================

tests/beman/expected/CMakeLists.txt

@@ -0,0 +1,84 @@
+// tests/beman/expected/expected_smf_regressions.test.cpp             -*-C++-*-
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// Beman-only regressions for special-member-function observable behavior.
+//
+// These guard three fixes made when the special-member constraints/noexcept
+// were re-keyed from the exposition-only held type unexpected<E> onto E
+// (so that an implementation storing E directly is trivially conforming, and
+// ABI stability for existing implementations is preserved):
+//
+//   1. The hidden-friend swap was unconstrained, so is_swappable_v<expected>
+//      was a hard error (ill-formed) for a move-restricted E instead of a
+//      well-formed bool. It must be a constant.
+//   2. The non-trivial copy constructor and copy assignment dropped their
+//      noexcept, so a non-trivial-but-noexcept-copyable E (or one with a
+//      non-trivial destructor) reported a throwing copy where std::expected
+//      does not.
+//
+// Value parity with std::expected is checked separately in
+// expected_std_equivalence.test.cpp (skipped on libc++).
+
+#include <beman/expected/expected.hpp>
+
+#include <catch2/catch_test_macros.hpp>
+
+#include <type_traits>
+#include <utility>
+
+using namespace beman::expected;
+
+namespace {
+
+// Copy is usable, move is user-deleted: E is not swappable, so expected's own
+// swap is constrained out and only the generic std::swap fallback remains.
+struct DelMoveOkCopy {
+    DelMoveOkCopy()                                = default;
+    DelMoveOkCopy(const DelMoveOkCopy&) noexcept   = default;
+    DelMoveOkCopy(DelMoveOkCopy&&)                 = delete;
+    DelMoveOkCopy& operator=(const DelMoveOkCopy&) = default;
+    DelMoveOkCopy& operator=(DelMoveOkCopy&&)      = delete;
+};
+
+// Trivial copy constructor, but a non-trivial destructor.
+struct NonTrivialDtor {
+    int x = 0;
+    ~NonTrivialDtor() {}
+};
+
+// User-provided (non-trivial) but noexcept copy and move.
+struct NoexceptNonTrivial {
+    NoexceptNonTrivial() = default;
+    NoexceptNonTrivial(const NoexceptNonTrivial&) noexcept {}
+    NoexceptNonTrivial(NoexceptNonTrivial&&) noexcept {}
+    NoexceptNonTrivial& operator=(const NoexceptNonTrivial&) noexcept { return *this; }
+    NoexceptNonTrivial& operator=(NoexceptNonTrivial&&) noexcept { return *this; }
+};
+
+// Bug 1: querying is_swappable must be well-formed (a hard error here would
+// fail to compile). Forcing the trait into a constant proves it.
+template <class Ex>
+inline constexpr bool swap_query_is_wellformed = (static_cast<void>(std::is_swappable_v<Ex>), true);
+
+static_assert(swap_query_is_wellformed<expected<int, DelMoveOkCopy>>);
+static_assert(swap_query_is_wellformed<expected<void, DelMoveOkCopy>>);
+
+// Bug 2: non-trivial-but-noexcept copy => nothrow copy construct/assign.
+static_assert(std::is_nothrow_copy_constructible_v<expected<int, NonTrivialDtor>>);
+static_assert(std::is_nothrow_copy_constructible_v<expected<int, NoexceptNonTrivial>>);
+static_assert(std::is_nothrow_copy_constructible_v<expected<void, NonTrivialDtor>>);
+static_assert(std::is_nothrow_copy_assignable_v<expected<int, NonTrivialDtor>>);
+static_assert(std::is_nothrow_copy_assignable_v<expected<int, NoexceptNonTrivial>>);
+static_assert(std::is_nothrow_copy_assignable_v<expected<void, NonTrivialDtor>>);
+
+} // namespace
+
+TEST_CASE("swap is well-formed and works for a move-restricted error type") {
+    // Previously a hard error via the unconstrained hidden-friend swap.
+    expected<int, DelMoveOkCopy> a(1);
+    expected<int, DelMoveOkCopy> b(2);
+    using std::swap;
+    swap(a, b); // resolves to the generic std::swap fallback
+    CHECK(*a == 2);
+    CHECK(*b == 1);
+}