The invariant version of ListF and Dec: combines the capabilities of both ListF and Dec together.

Conceptually you can think of DecAlt f a as a way of consuming and producing as that contains a collection of f xs of different xs. When interpreting this, a specific f is chosen to handle the interpreting; the a is sent to that f, and the single result is returned back out.

To do this, the main tools to combine DecAlts are its Inalt instance, using swerve to combine two DecAlts in a choice-like manner (with the choosing and re-injecting function), and its Inplus instance, using reject to create an "empty" choice that is never taken.

This does have an Interpret function, but the target typeclass (Inplus) doesn't have too many useful instances. Instead, you are probably going to run it into either Plus instance (to "produce" an a from a DecAlt f a) with runCoDecAlt, or a Choose instance (to "consume" an a from a DecAlt f a) with runContraDecAlt.

If you think of this type as a combination of ListF and Dec, then you can also extract the ListF part out using decAltListF, and extract the Dec part out using decAltDec.

Note that this type's utility is similar to that of PostT Dec, except PostT Dec lets you use Conclude typeclass methods to assemble it.

Since: 0.3.5.0

In the covariant direction, we can interpret into any Plus.

In theory, this shouldn't never be necessary, because you should just be able to use interpret, since any instance of Plus is also an instance of Inplus. However, this can be handy if you are using an instance of Plus that has no Inplus instance. Consider also unsafeInplusCo if you are using a specific, concrete type for g.

In the contravariant direction, we can interpret into any Decide.

In theory, this shouldn't never be necessary, because you should just be able to use interpret, since any instance of Conclude is also an instance of Inplus. However, this can be handy if you are using an instance of Conclude that has no Inplus instance. Consider also unsafeInplusContra if you are using a specific, concrete type for g.

Extract the ListF part out of a DecAlt, shedding the contravariant bits.

Since: 0.3.2.0

Extract the ListF part out of a DecAlt, shedding the contravariant bits.

This version does not require a Functor constraint because it converts to the coyoneda-wrapped product, which is more accurately the true conversion to a covariant chain.

Since: 0.3.2.0

Extract the Dec part out of a DecAlt, shedding the covariant bits.

General-purpose folder of DecAlt. Provide a way to handle the identity (emptyconcludeReject) and a way to handle a cons (<!>decideswerve).

Since: 0.3.5.0

Convenient wrapper to build up a DecAlt on by providing each branch of it. This makes it much easier to build up longer chains because you would only need to write the splitting/joining functions in one place.

For example, if you had a data type

data MyType = MTI Int | MTB Bool | MTS String

and an invariant functor Prim (representing, say, a bidirectional parser, where Prim Int is a bidirectional parser for an Int), then you could assemble a bidirectional parser for a MyType@ using:

invmap (case MTI x -> Z (I x); MTB y -> S (Z (I y)); MTS z -> S (S (Z (I z))))
       (case Z (I x) -> MTI x; S (Z (I y)) -> MTB y; S (S (Z (I z))) -> MTS z) $
  assembleDecAlt $ intPrim
                    :* boolPrim
                    :* stringPrim
                    :* Nil

Some notes on usefulness depending on how many components you have:

• If you have 0 components, use Reject directly.
• If you have 1 component, use inject or injectChain directly.
• If you have 2 components, use toListBy or toChain.
• If you have 3 or more components, these combinators may be useful; otherwise you'd need to manually peel off eithers one-by-one.

If each component is itself a DecAlt f (instead of f), you can use concatInplus.

The invariant version of NonEmptyF and Dec1: combines the capabilities of both NonEmptyF and Dec1 together.

Conceptually you can think of DecAlt1 f a as a way of consuming and producing as that contains a (non-empty) collection of f xs of different xs. When interpreting this, a specific f is chosen to handle the interpreting; the a is sent to that f, and the single result is returned back out.

To do this, the main tools to combine DecAlt1s are its Inalt instance, using swerve to combine two DecAlt1s in a choice-like manner (with the choosing and re-injecting function).

This does have an Interpret function, but the target typeclass (Inalt) doesn't have too many useful instances. Instead, you are probably going to run it into either an Alt instance (to "produce" an a from a DecAlt1 f a) with runCoDecAlt1, or a Decide instance (to "consume" an a from a DecAlt1 f a) with runContraDecAlt1.

If you think of this type as a combination of NonEmptyF and Dec1, then you can also extract the NonEmptyF part out using decAltNonEmptyF, and extract the Dec1 part out using decAltDec1.

Note that this type's utility is similar to that of PostT Dec1, except PostT Dec1 lets you use Decide typeclass methods to assemble it.

Since: 0.3.5.0

In the covariant direction, we can interpret into any Alt.

In theory, this shouldn't never be necessary, because you should just be able to use interpret, since any instance of Alt is also an instance of Inalt. However, this can be handy if you are using an instance of Alt that has no Inalt instance. Consider also unsafeInaltCo if you are using a specific, concrete type for g.

In the contravariant direction, we can interpret into any Decide.

In theory, this shouldn't never be necessary, because you should just be able to use interpret, since any instance of Decide is also an instance of Inalt. However, this can be handy if you are using an instance of Decide that has no Inalt instance. Consider also unsafeInaltContra if you are using a specific, concrete type for g.

Extract the NonEmptyF part out of a DecAlt1, shedding the contravariant bits.

Since: 0.3.2.0

Extract the NonEmptyF part out of a DecAlt1, shedding the contravariant bits.

This version does not require a Functor constraint because it converts to the coyoneda-wrapped product, which is more accurately the true conversion to a covariant chain.

Since: 0.3.2.0

Extract the Dec1 part out of a DecAlt1, shedding the covariant bits.

General-purpose folder of DecAlt1. Provide a way to handle the individual leaves and a way to handle a cons (<!>decideswerve).

Since: 0.3.5.0

A version of assembleDecAlt but for DecAlt1 instead. Can be useful if you intend on interpreting it into something with only a Decide or Alt instance, but no Decidable or Plus or Alternative.

If each component is itself a DecAlt1 f (instead of f), you can use concatInalt.