Certain operations behave like an identity functor across carriers Because some states correspond structurally licenses specific cross carrier behavior to avoid boilerplate The identity cluster consists of three structurally equivalent infallible states Carrier Algebraic State Shape code just<T> type InlinedCode type StrongEmphasis content text T type SimpleText text A single value type SimpleText code choice<Ts > type InlinedCode type StrongEmphasis content text Ts type SimpleText text A coproduct of values type SimpleText code expected<T copack<>> type InlinedCode type StrongEmphasis content text T 0 type SimpleText text type SimpleText type StrongEmphasis content text T type SimpleText text A value and an uninhabited error type SimpleText Each carrier is canonically isomorphic to its payload none adds failure or empty states so a value is always present Because no member can hide failure pipeline bind operations can transition across these boundaries The bind operation adopts the carrier family of the provided callback a crossing only the pipeline scoped functors are licensed to make The computation carriers Success Path Bridging Fallible carriers excluding and cannot transition to infallible carriers because doing so would risk silently discarding an active error or empty state In contrast identity carriers can bridge to any fallible carrier via pipeline Because identity carriers are statically infallible transitioning to or a standard merely introduces potential downstream failure No pre existing failure is discarded as none can exist upstream All three cluster members and can bridge to fallible carriers Monadic operations on the identity cluster Success Mapping Preserves the carrier family for member calls Pipeline adds a licensed crossing a returned from a callable mapped over a is promoted to a over the same alternatives choice identity over a coproduct Sequential Binding Allows cross carrier transitions within the identity cluster such as to when using pipeline Recovery & Error Mapping Because and lack an error side these are ill formed On they are vacuously well formed but statically unreachable to allow generic compilation Short Circuiting Ill formed for identity carriers as no failure error or empty state can be constructed from an infallible context Elimination Fallbacks Ill formed on and On it remains well formed to support generic code but the fallback must still initialize even though its branch is statically unreachable If the value side is no fallback is accepted Neutral Observation Supported and behave normally NOTE Note the vacuous or_else asks nothing For instance the following function compiles successfully even though the recovery handler is a plain not a callable at all In contrast if the error grade is inhabited or on where the empty state is a genuine inhabited state is loudly rejected The operation evaluates the callback over the error alternatives Over the uninhabited there are zero alternatives so the underlying fold has zero inputs The operation trivially collapses to the identity mapping the callback contributes nothing and no questions about the callback not even invocability are formable Demanding a constraint on the callback would be an arbitrary invention rather than a logical derivation This serves a load bearing design principle generic code remains closed under all error grades If were rejected on a recovery step would become ill formed simply because an upstream stage statically proved that failure is impossible breaking generic composition Instead the recovery step stays writable everywhereand does nothing where failure is impossible TIP Mathematical note isomorphic yet nominally distinct The three shapes in the table are isomorphic in so they carry the same information C is nominal and keeps it that way rather than exposing those isomorphisms as implicit conversions doing so would drop three mutually convertible types into every overload set that mentions any one of them and the conversions would compose into cycles Each isomorphism is instead reachable as a licensed crossing a pipeline functor you invoke so the equivalence is available exactly where it is asked for That boundary is not only a restriction in choice identity over a coproduct it is what makes a monad rather than a bare coproduct libfn auto test_identity_cross > void fn just<UserId> j UserId Cross carrier pipeline bind to another identity carrier auto result j | fn and_then UserId u return fn expected<UserId fn copack<>> u static_assert std same_as<decltype result fn expected<UserId fn copack<>>> expected<T copack<>> optional fn and_then optional expected auto test_success_bridge fn just<int> j > void An identity carrier can bridge to fallible carriers on the success path auto to_opt j | fn and_then int i return fn optional<int> i static_assert std same_as<decltype to_opt fn optional<int>> auto to_exp j | fn and_then int i return fn expected<int IoError> i static_assert std same_as<decltype to_exp fn expected<int IoError>> Bridging a multi alternative choice to fallible optional with heterogeneous success join auto choice_to_opt fn choice_for<int bool> true | fn and_then fn overload int > fn optional<char> return a bool > fn optional<long> return 2L static_assert std same_as<decltype choice_to_opt fn optional<fn copack_for<char long>>> just choice expected<T copack<>> transform fn transform copack just choice and_then just expected<U copack<>> fn and_then transform_error or_else recover inspect_error just choice expected<T copack<>> fail filter value_or just choice expected<T copack<>> T void inspect discard int auto test_vacuous_or_else > void using type decltype fn expected<void fn copack<>> | fn or_else std declval<int> static_assert std same_as<type fn expected<void fn copack<>>> optional or_else 42 or_else copack<> or_else expected<T copack<>> libfn choice