A pairing of invariant functors to create a new invariant functor that represents the "choice" between the two.

A Night f g a is a invariant "consumer" and "producer" of a, and it does this by either feeding the a to f, or feeding the a to g, and then collecting the result from whichever one it was fed to. Which decision of which path to takes happens at runtime depending what a is actually given.

For example, if we have x :: f a and y :: g b, then night x y :: Night f g (Either a b). This is a consumer/producer of Either a bs, and it consumes Left branches by feeding it to x, and Right branches by feeding it to y. It then passes back the single result from the one of the two that was chosen.

Mathematically, this is a invariant day convolution, except with a different choice of bifunctor (Either) than the typical one we talk about in Haskell (which uses (,)). Therefore, it is an alternative to the typical Day convolution --- hence, the name Night.

A value of type Not a is "proof" that a is uninhabited.

Pair two invariant actions together into a Night; assigns the first one to Left inputs and outputs and the second one to Right inputs and outputs.

Interpret the covariant part of a Night into a target context h, as long as the context is an instance of Alt. The Alt is used to combine results back together, chosen by <!>.

Interpret the contravariant part of a Night into a target context h, as long as the context is an instance of Decide. The Decide is used to pick which part to feed the input to.

Convert an invariant Night into the covariant version, dropping the contravariant part.

Note that there is no covariant version of Night defined in any common library, so we use an equivalent type (if f and g are Functors) f :*: g.

Convert an invariant Night into the contravariant version, dropping the covariant part.

Night is associative.

Night is associative.

The left identity of Night is Not; this is one side of that isomorphism.

The right identity of Night is Not; this is one side of that isomorphism.

The left identity of Night is Not; this is one side of that isomorphism.

The right identity of Night is Not; this is one side of that isomorphism.

The two sides of a Night can be swapped.

Hoist a function over the left side of a Night.

Hoist a function over the right side of a Night.

Instead of defining yet another separate free monoid like Ap, Div, or Dec, we re-use Chain.

You can assemble values using the combinators in Data.HFunctor.Chain, and then tear them down/interpret them using runCoNightChain and runContraNightChain. There is no general invariant interpreter (and so no MonoidIn instance for Night) because the typeclasses used to express the target contexts are probably not worth defining given how little the Haskell ecosystem uses invariant functors as an abstraction.

Match on a non-empty NightChain; contains no fs, but only the terminal value. Analogous to the Choose constructor.

Match on an "empty" NightChain; contains no fs, but only the terminal value. Analogous to the Lose constructor.

In the covariant direction, we can interpret out of a Chain of Night into any Plus.

In the contravariant direction, we can interpret out of a Chain of Night into any Conclude.

Convenient wrapper to build up a NightChain on by providing each component 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) $
  assembleNightChain $ intPrim
                    :* boolPrim
                    :* stringPrim
                    :* Nil

This is much more convenient than doing it using manual applications of decide or choose or Night, which would require manually peeling off eithers one-by-one.

A version of assembleNightChain where each component is itself a NightChain.

assembleNightChain (x :* y :* z :* Nil)
  = concatNightChain (injectChain x :* injectChain y :* injectChain z :* Nil)

Instead of defining yet another separate free semigroup like Ap1, Div1, or Dec1, we re-use Chain1.

You can assemble values using the combinators in Data.HFunctor.Chain, and then tear them down/interpret them using runCoNightChain1 and runContraNightChain1. There is no general invariant interpreter (and so no SemigroupIn instance for Night) because the typeclasses used to express the target contexts are probably not worth defining given how little the Haskell ecosystem uses invariant functors as an abstraction.

Match on a NightChain1 to get the head and the rest of the items. Analogous to the Dec1 constructor.

In the covariant direction, we can interpret out of a Chain1 of Night into any Alt.

In the contravariant direction, we can interpret out of a Chain1 of Night into any Decide.

A version of assembleNightChain but for NightChain1 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.

A version of concatNightChain but for NightChain1 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.