Sequential composition chains dependent operations the success of one feeds the input of the next In monadic bind achieves this A monadic carrier wraps a value The callable passed to is a Kleisli arrow it accepts a plain value and returns a monadic carrier of the same kind If the input is infallible it may return either an infallible carrier or a fallible kind it bridges to The identity cluster A chained sequence of bind operations forms the graded pipeline introduced in Why compose types as well as values Chaining a single step follows this pattern Because member cannot change carrier families The computation carriers its Kleisli arrow must return the same carrier family binds to Plain binds to retaining error or via singular lift to transitioning to a graded context Graded expected exact error sets Copack graded unions heterogeneous error sets Copack valued inputs join heterogeneous successful branch types into a normalized Branch convergence preserves the exact type without duplicate union states All branches join to mixed void and non void branches are ill formed Callback results returning bare values require rather than The library formalizes this same kind contract via the concept which lets generic templates probe whether two carrier types belong to the same monadic family libfn and_then and_then auto parse_numeric > fn expected<UserId fn copack<NotANumber>> auto load_user UserId > fn expected<User fn copack<Missing>> auto sequential_bind > void auto result parse_numeric | fn and_then load_user static_assert std same_as<decltype result fn expected<User fn copack_for<Missing NotANumber>>> and_then optional optional expected<T E> expected<U E> E expected<U copack<E>> expected copack void void transform and_then fn same_kind static_assert fn same_kind<fn optional<int> fn optional<User>> static_assert fn same_kind<fn expected<int IoError> fn expected<User IoError>> static_assert fn same_kind<fn expected<int IoError> fn expected<User Missing>>