A representation of a bidirectional arrow (embedding-projection pair of arrows transformer): an arrow and its inverse. Most uses will prefer the specialized <-> type for function arrows.

To constitute a valid bijection, biTo and biFrom should be inverses:

• biTo . biFrom = id

• biFrom . biTo = id

It may be argued that the arguments should be in the opposite order due to the arrow syntax, but it makes more sense to me to have the forward function come first.

Construct an expression representing a function bijection based on a set of newline- or semicolon-separated cases. Each case should be two pattern-expressions separated by -. Each pattern-expression is a haskell pattern that can also be interpreted as an expression. You can think of these as symmetric or bidirectional case expressions. The result will be a bijection that is the combination of two lambdas, one with the cases intepreted forward, and one reverse. For example:

newtype T a = C a
biC :: T a <-> a
biC = [biCase| C a <-> a |]

isJust :: Maybe () <-> Bool
isJust = [biCase|
    Just () <-> True
    Nothing <-> False
  |]

Another synonym for fmap to match other operators in this module.

Given a value an an invariant for that value, always provide that value and ignore the produced value. fmap . flip consts ()

flip (>$)

Invariant monoidal functor. This roughly corresponds to Applicative, which, for covariant functors, is equivalent to a monoidal functor. Invariant functors, however, may admit a monoidal instance but not applicative.

Default unit implementation for non-invertible Applicatives.

Default '>*< implementation for non-invertible Applicatives.

Sequence actions, discarding/inhabiting the unit value of the second argument.

Sequence actions, discarding/inhabiting the unit value of the first argument.

Lift an (uncurried) bijection into a monoidal functor.

A constant monoidal (like pure), which always produces the same value and ignores everything.

Supply a constant value to a monoidal and ignore whatever is produced.

Sequence (like sequenceA_) a list of monoidals, ignoring (const ()) all the results.

Map each element to a monoidal and sequenceI_ the results.

flip mapI_

Sequence (like sequenceA) and filter (like catMaybes) a list of monoidals, producing the list of non-Nothing values. Shorter input lists pad with Nothings and longer ones are ignored.

Map each element to a Maybe monoidal and sequence the results (like traverse and mapMaybe).

Monoidal functors that allow choice.

Default >|< implementation for non-invertible Alternatives.

Assymetric (and therefore probably not bijective) version of >|< that returns whichever action succeeds but always uses the left one on inputs.

Assymetric (and therefore probably not bijective) version of >|< that returns whichever action succeeds but always uses the right one on inputs.

Analogous to optional: always succeeds.

Return a default value if a monoidal functor fails, and only apply it to non-default values.

Repeatedly apply a monoidal functor until it fails. Analogous to many.

Try a list of monoidal actions in sequence, producing the index of the first successful action, and evaluating the action with the given index.

Fold a structure with >| (|<), thus always applying the input to the first (last) item for generation.

Fold a structure with >| (|<), thus always applying the input to the first (last) item for generation.

Take a list of items and apply them to the action in sequence until one succeeds and return the cooresponding item; match the input with the list and apply the corresponding action (or produce an error if the input is not an element of the list).