Add assignment to sum, with the strong exception guarantee

[Bronek]

Without it fn::expected<T, fn::sum<E1, E2>> - the graded monad the sum exists to serve - was not assignable at all.

_reinit mirrors reinit-expected ([expected.object.assign]): a sum always holds one of its alternatives, and there is no valueless state to fall back on, so the one it holds is destroyed only once its replacement is certain. Which arm applies is decided per ALTERNATIVE, not for the sum as a whole - a nothrow-copyable one is built straight over the old, and one whose copy can throw is copied into a temporary first, where only its (nothrow) move goes near the storage. A sum whose alternatives need different arms is therefore still assignable, and the spec is the conjunction of what each arm promises.

The standard's third arm - snapshot the old alternative, roll back on throw - has nothing to offer a sum. It would exist for an alternative that can neither be built nor moved without throwing; but every alternative is also a possible OLD alternative, since one is assigned over itself whenever the sum already holds it, and snapshotting that same type would throw in turn. There is no safe path, so such an alternative is constrained away rather than half-served.

The alternative being replaced is CONSTRUCTED over, never assigned to - even when it does not change. Assignment therefore asks nothing of Ts beyond what construction already asks, and a type with no assignment operator at all is still assignable through the sum.

choice adds no state of its own, so it only has to declare the two operators to inherit all of this: its move constructor would otherwise have deleted the implicit copy assignment and suppressed the implicit move assignment - the same reason sum cannot rely on implicit ones either.

Closes #183

---

Stack: P10 of 13 — the release-0.1 bugfix queue, merging bottom-up into main. Based on #303 and to be retargeted to main once it merges; the diff shows only this PR's commits. Every stack boundary was validated with a gcc build and the full test suite on top of main, and the aggregate branch ran the full CI matrix green (#289).

[augmentcode]

🤖 Augment PR Summary

Summary: This PR makes fn::sum (and therefore fn::choice and fn::expected<T, fn::sum<...>>) assignable while targeting the strong exception guarantee.

Changes:

• Adds <memory> and implements sum::_reinit<T> to rebuild the active alternative via either a direct nothrow construction path or a temporary-then-move path.
• Adds a constrained sum::operator=(sum const&) that only requires construction (not alternative assignment operators) and computes noexcept from copy construction.
• Adds a constrained sum::operator=(sum&&) that is only provided when all alternatives are nothrow move-constructible.
• Declares defaulted copy/move assignment operators on choice so it inherits sum’s constraints/guarantees.
• Extends tests for sum, choice, and graded expected to cover assignment behavior, noexcept traits, constexpr usage, self-assignment, destruction of replaced alternatives, exception safety, and constraints.

Technical Notes: Assignment reconstructs the alternative (never assigns into it), and rvalue assignment can fall back to copy assignment when move assignment is constrained away.

_{🤖 Was this summary useful? React with 👍 or 👎}

[augmentcode]

Review completed. 1 suggestion posted.

Comment augment review to trigger a new review at any time.

[Bronek]

augment review

[augmentcode]

Review completed. No suggestions at this time.

Comment augment review to trigger a new review at any time.

[codecov]

Codecov Report

❌ Patch coverage is 85.00000% with 3 lines in your changes missing coverage. Please review.

Files with missing lines	Patch %	Lines
include/fn/sum.hpp	83.3%	3 Missing ⚠️

📢 Thoughts on this report? Let us know!

[sonarqubecloud]

Quality Gate passed

Issues
0 New issues
0 Accepted issues

Measures
0 Security Hotspots
86.2% Coverage on New Code
0.0% Duplication on New Code

See analysis details on SonarQube Cloud