The constraints the library states its own rules with and which client code can state its rules with too They fall into four groups what a type is how two carriers relate what a value converts to and whether an operation applies Each is declared with the feature it constrains rather than gathered in one place so every concept below names the header that declares it carries the general ones What a type is fn some_monadic_type fn some_expected fn some_expected_void fn some_expected_non_void fn some_optional fn some_just fn some_choice fn some_pack fn some_copack fn empty_copack fn some_identity fn some_empty_error fn some_empty_value fn some_in_place_type How two carriers relate fn same_kind fn same_value_kind fn same_monadic_type_as What a value converts to fn convertible_to_expected fn convertible_to_optional fn convertible_to_choice fn convertible_to_unexpected fn convertible_to_bool Whether an operation applies is the constraint itself carries the rest are the per verb constraints it dispatches to and the ones a verb of your own would join fn monadic_invocable fn applicable_and_then fn applicable_and_then_across fn applicable_transform fn applicable_transform_error fn applicable_transform_promote fn applicable_or_else fn applicable_or_else_across fn applicable_recover fn applicable_filter fn applicable_inspect fn applicable_inspect_error fn applicable_fail fn applicable_value_or Whether a callable applies The constraints behind over plain arguments and over a type list alike fn applicable fn regular_applicable fn typelist_applicable fn typelist_applicable_r <fn concepts hpp> Checks if a type is one of the library s carriers what a pipeline flows through The four kinds a verb may be applied to expected optional choice and just A pack or a copack is data a carrier holds not a carrier and answers false Checks if a type is an fn expected with any sides Checks if a type is an fn expected over void Checks if a type is an fn expected with a non void value type Checks if a type is an fn optional with any value type Checks if a type is a just with any payload Checks if a type is a choice with any alternatives Checks if a type is a pack with any elements Checks if a type is a copack with any alternatives including none Checks if a type is the empty copack<> the uninhabited zero A carrier side of this type is statically known never to hold a value which is what renders the operations over that side vacuous Checks if a type is an identity carrier a monad which never short circuits The equivalence class of the family s unit choice no error channel at all just the canonical minimal carrier and an expected whose error is the empty copack a channel that can never engage Binding across the cluster is lossless exactly because the channels a carrier switch drops are uninhabited Checks if a carrier s error side is uninhabited it can never hold an error The identity expected and only it choice and just have no error channel to empty so they answer false here while some_identity below accepts all three Checks if a carrier s value side is uninhabited it can never hold a value An optional<copack<>> which is never engaged or an expected<copack<> E> which always holds its error every value side operation over one is the identity and its callback is neither invoked nor instantiated optional belongs here where it cannot belong to the mirror above its empty state is a state that is not a channel that can never engage Checks if a type is a std in_place_type_t tag Checks if two carriers are of the same monadic family with compatible error sides What and_then and the other success path operations hold a callback s result to the value side may change freely the family may not For expected the error sides must also agree identical plain types any two graded copack sides or a plain side meeting its own singular lift copack<E> either way round Any two optional s any two choice s and any two just s are the same kind The mirror of same_kind the value side is pinned and the error side may vary What the error side operations hold a callback s result to Value sides agree when identical when both are graded copack or on expected when a plain non void side meets its own singular lift copack<T> either way round Any two choice s qualify never two carriers of different families Checks if two carriers agree on family value side and error side alike The conjunction of same_kind and same_value_kind Checks if an expected over the decayed type can be built from the value by a cast Unlike the other convertible_to_* concepts here void is admitted outright by its own arm expected<void E> is a legitimate carrier with no value to convert Checks if an optional over the decayed type can be built from the value by a cast A void answers false optional<void> is ill formed to instantiate and the concept answers instead Checks if a choice over the decayed type can be built from the value by a cast A void answers false choice<void> is ill formed to instantiate and the concept answers instead Checks if fn unexpected over the decayed type can be built from the value by a cast A void answers false unexpected<void> is ill formed to instantiate and the concept answers instead An immovable value answers false as well there is nothing to move or copy into the carrier Checks if the type casts to bool what filter holds its predicate s result to An explicit operator bool suffices the concept casts it does not ask for an implicit conversion monadic_invocable operator| Checks if a verb applies to a carrier the constraint operator| itself carries The question asked of the verb s own apply object so every arm it offers counts This is what a pipeline asks and it differs from the applicable_ concept of an individual verb which asks whether the callback is used to serve the operand an operation over an uninhabited side consults no callback at all and so applies while no callback is applicable to it Checks if the monadic type can be used with the and_then operation Checks if the identity carrier can be used with and_then binding across the cluster s carrier kinds The callback may return any identity carrier and the bind follows the function results of the input s own kind are left to applicable_and_then and the carrier s member Over a copack payload the branches either all return choices joined into the superset or converge on one carrier type Checks if the monadic type can be used with the transform operation Checks if the monadic type can be used with the transform_error operation Checks if transform of a just operand promotes the callable s copack result to the choice over the same alternatives Checks if the monadic type can be used with the or_else operation Checks if the callback can be used with or_else recovering across the expected optional pair The callback witnesses the inhabited dead state optional s empty state nullary or expected s error per alternative and its declared carrier names the result kind self s value joins the target s value side under the grade sticky rules An identity expected is excluded the fold of the callback over zero error alternatives has no inputs so those keep the vacuous identity Checks if the monadic type can be used with the recover operation Checks if the monadic type can be used with the filter operation Checks if the monadic type can be used with the inspect operation Checks if the monadic type can be used with the inspect_error operation Checks if the monadic type can be used with the fail operation Checks if the monadic type can be used with the pipeline value_or operation fn apply Checks if fn apply of Fn over Args is viable the concept form of is_applicable As applicable adding the semantic promise of equality preservation mirroring std regular_invocable against std invocable Checks if Fn can be applied to every alternative of the typelist T The exhaustiveness question copack and choice dispatch asks before selecting an arm each alternative is tried in T s own cv ref qualification with the trailing Args following the alternative s content As typelist_applicable with every branch result converting to Ret