A useful helper type to use with a covariant functor combinator that allows you to tag along contravariant access to all fs inside the combinator.

Maybe most usefully, it can be used with Ap. Remember that Ap f a is a collection of f xs, with each x existentially wrapped. Now, for a Ap (Pre a f) a, it will be a collection of f x and a -> xs: not only each individual part, but a way to "select" that individual part from the overal a.

So, you can imagine Ap (Pre a f) b as a collection of f x that consumes a and produces b.

When a and b are the same, Ap (Pre a f) a is like the free invariant sequencer. That is, in a sense, Ap (Pre a f) a contains both contravariant and covariant sequences side-by-side, consuming as and also producing as.

You can build up these values with injectPre, and then use whatever typeclasses your t normally supports to build it up, like Applicative (for Ap). You can then interpret it into both its contravariant and covariant contexts:

-- interpret the covariant part
runCovariant :: Applicative g => (f ~> g) -> Ap (Pre a f) a -> g a
runCovariant f = interpret (f . getPre)

-- interpret the contravariant part
runContravariant :: Divisible g => (f ~> g) -> Ap (Pre a f) a -> g a
runContravariant = preDivisible

The PreT type wraps up Ap (Pre a f) a into a type PreT Ap f a, with nice instances/helpers.

An example of a usage of this in the real world is the unjson library's record type constructor, to implement bidrectional serializers for product types.

Interpret a Pre into a contravariant context, applying the pre-routing function.

Drop the pre-routing function and just give the original wrapped value.

Contravariantly retract the f out of a Pre, applying the pre-routing function. Not usually that useful because Pre is meant to be used with covariant Functors.

Like inject, but allowing you to provide a pre-routing function.

Pre-compose on the pre-routing function.

Run a "pre-routed" t into a contravariant Divisible context. To run it in ts normal covariant context, use interpret with getPre.

This will work for types where there are a possibly-empty collection of fs, like:

preDivisible :: Divisible g => (f ~> g) -> Ap    (Pre a f) b -> g a
preDivisible :: Divisible g => (f ~> g) -> ListF (Pre a f) b -> g a

Run a "pre-routed" t into a contravariant Divise context. To run it in ts normal covariant context, use interpret with getPre.

This will work for types where there are is a non-empty collection of fs, like:

preDivise :: Divise g => (f ~> g) -> Ap1       (Pre a f) b -> g a
preDivise :: Divise g => (f ~> g) -> NonEmptyF (Pre a f) b -> g a

Run a "pre-routed" t into a Contravariant. To run it in ts normal covariant context, use interpret with getPre.

This will work for types where there is exactly one f inside:

preContravariant :: Contravariant g => (f ~> g) -> Step     (Pre a f) b -> g a
preContravariant :: Contravariant g => (f ~> g) -> Coyoneda (Pre a f) b -> g a

A useful helper type to use with a contravariant functor combinator that allows you to tag along covariant access to all fs inside the combinator.

Maybe most usefully, it can be used with Dec. Remember that Dec f a is a collection of f xs, with each x existentially wrapped. Now, for a Dec (Post a f) a, it will be a collection of f x and x -> as: not only each individual part, but a way to "re-embed" that individual part into overal a.

So, you can imagine Dec (Post a f) b as a collection of f x that consumes b and produces a.

When a and b are the same, Dec (Post a f) a is like the free invariant sequencer. That is, in a sense, Dec (Post a f) a contains both contravariant and covariant sequences side-by-side, consuming as and also producing as.

You can build up these values with injectPre, and then use whatever typeclasses your t normally supports to build it up, like Conclude (for Div). You can then interpret it into both its contravariant and covariant contexts:

-- interpret the covariant part
runCovariant :: Plus g => (f ~> g) -> Div (Post a f) a -> g a
runCovariant f = interpret (f . getPost)

-- interpret the contravariant part
runContravariant :: Conclude g => (f ~> g) -> Div (Post a f) a -> g a
runContravariant = preDivisible

The PostT type wraps up Dec (Post a f) a into a type PostT Dec f a, with nice instances/helpers.

An example of a usage of this in the real world is a possible implementation of the unjson library's sum type constructor, to implement bidrectional serializers for sum types.

Interpret a Post into a covariant context, applying the post-routing function.

Drop the post-routing function and just give the original wrapped value.

Covariantly retract the f out of a Post, applying the post-routing function. Not usually that useful because Post is meant to be used with contravariant Functors.

Like inject, but allowing you to provide a post-routing function.

Post-compose on the post-routing function.

Run a "post-routed" t into a covariant Plus context. To run it in ts normal contravariant context, use interpret.

This will work for types where there are a possibly-empty collection of fs, like:

postPlus :: Plus g => (f ~> g) -> Dec (Post a f) b -> g a
postPlus :: Plus g => (f ~> g) -> Div (Post a f) b -> g a

Run a "post-routed" t into a covariant Alt context. To run it in ts normal contravariant context, use interpret.

This will work for types where there are is a non-empty collection of fs, like:

postAlt :: Alt g => (f ~> g) -> Dec1 (Post a f) b -> g a
postAlt :: Alt g => (f ~> g) -> Div1 (Post a f) b -> g a

Run a "post-routed" t into a covariant Functor context. To run it in ts normal contravariant context, use interpret.

This will work for types where there is exactly one f inside:

postFunctor :: Functor g => (f ~> g) -> Step         (Post a f) b -> g a
postFunctor :: Functor g => (f ~> g) -> Coyoneda (Post a f) b -> g a

Turn the covariant functor combinator t into an Invariant functor combinator; if t f a "produces" as, then PreT t f a will both consume and produce as.

You can run this normally as if it were a t f a by using interpret; however, you can also interpret into covariant contexts with preDivisibleT, preDiviseT, and preContravariantT.

A useful way to use this type is to use normal methods of the underlying t to assemble a final t, then using the PreT constructor to wrap it all up.

data MyType = MyType
     { mtInt    :: Int
     , mtBool   :: Bool
     , mtString :: String
     }

myThing :: PreT Ap MyFunctor MyType
myThing = PreT $ MyType
    $ injectPre mtInt    (mfInt    :: MyFunctor Int   )
    * injectPre mtBool   (mfBool   :: MyFunctor Bool  )
    * injectPre mtString (mfString :: MyFunctor STring)

See Pre for more information.

Run a PreT t into a contravariant Divisible context. To run it in ts normal covariant context, use interpret.

This will work for types where there are a possibly-empty collection of fs, like:

preDivisibleT :: Divisible g => (f ~> g) -> PreT Ap    f ~> g
preDivisibleT :: Divisible g => (f ~> g) -> PreT ListF f ~> g

Run a PreT t into a contravariant Divise context. To run it in ts normal covariant context, use interpret.

This will work for types where there is a non-empty collection of fs, like:

preDiviseT :: Divise g => (f ~> g) -> PreT Ap1       f ~> g
preDiviseT :: Divise g => (f ~> g) -> PreT NonEmptyF f ~> g

Run a PreT t into a Contravariant. To run it in ts normal covariant context, use interpret.

This will work for types where there is exactly one f inside:

preContravariantT :: Contravariant g => (f ~> g) -> PreT Step     f ~> g
preContravariantT :: Contravariant g => (f ~> g) -> PreT Coyoneda f ~> g

Turn the contravariant functor combinator t into an Invariant functor combinator; if t f a "consumes" as, then PostT t f a will both consume and produce as.

You can run this normally as if it were a t f a by using interpret; however, you can also interpret into covariant contexts with postPlusT, postAltT, and postFunctorT.

A useful way to use this type is to use normal methods of the underlying t to assemble a final t, then using the PreT constructor to wrap it all up.

myThing :: PostT Dec MyFunctor (Either Int Bool)
myThing = PostT $ decided $
    (injectPost Left  (mfInt  :: MyFunctor Int ))
    (injectPost Right (mfBool :: MyFunctor Bool))

See Post for more information.

Run a PostT t into a covariant Plus context. To run it in ts normal contravariant context, use interpret.

This will work for types where there are a possibly-empty collection of fs, like:

postPlusT :: Plus g => (f ~> g) -> PreT Dec f ~> g
postPlusT :: Plus g => (f ~> g) -> PreT Div f ~> g

Run a PostT t into a covariant Alt context. To run it in ts normal contravariant context, use interpret.

This will work for types where there is a non-empty collection of fs, like:

postAltT :: Alt g => (f ~> g) -> PreT Dec1 f ~> g
postAltT :: Alt g => (f ~> g) -> PreT Div1 f ~> g

Run a PostT t into a covariant Functor context. To run it in ts normal contravariant context, use interpret.

This will work for types where there is exactly one f inside:

postFunctorT :: Functor g => (f ~> g) -> PreT Step f ~> g
postFunctorT :: Functor g => (f ~> g) -> PreT Coyoneda f ~> g