Data.Type.Sum.Lifted

FSum is a type combinators for representing disjoint sums of many functors (fs :: [k -> *]) at a single index (a :: k). As opposed to one-functor-many-indices Sum.

Documentation

data FSum :: [k -> *] -> k -> * where

Constructors

FInL :: !(f a) -> FSum (f :< fs) a

FInR :: !(FSum fs a) -> FSum (f :< fs) a

Instances

ListC ((<$>) Constraint (* -> *) Functor fs) => Functor (FSum * fs)

ListC ((<$>) Constraint (* -> *) Foldable fs) => Foldable (FSum * fs)

(ListC ((<$>) Constraint (* -> *) Functor fs), ListC ((<$>) Constraint (* -> *) Foldable fs), ListC ((<$>) Constraint (* -> *) Traversable fs)) => Traversable (FSum * fs)

nilFSum :: FSum Ø a -> Void

There are no possible values of the type FSum Ø a.

fdecomp :: FSum (f :< fs) a -> Either (f a) (FSum fs a)

Decompose a non-empty FSum into either its head or its tail.

finj :: f ∈ fs => f a -> FSum fs a

Inject an element into an FSum.

fprj :: f ∈ fs => FSum fs a -> Maybe (f a)

Project an implicit index out of an FSum.

injectFSum :: Index fs f -> f a -> FSum fs a

Inject an element into an FSum with an explicitly specified Index.

findex :: Index fs f -> FSum fs a -> Maybe (f a)

Project an explicit index out of an FSum.

imapFSum :: (forall f. Index fs f -> f a -> f b) -> FSum fs a -> FSum fs b

Map over the single element in an FSum with a function that can handle any possible element, along with the element's index.

ifoldMapFSum :: (forall f. Index fs f -> f a -> m) -> FSum fs a -> m

Fun fact: Since there is exactly one element in an FSum, we don't need the Monoid instance!

itraverseFSum :: Functor g => (forall f. Index fs f -> f a -> g (f b)) -> FSum fs a -> g (FSum fs b)

Another fun fact: Since there is exactly one element in an FSum, we require only a Functor instance on g, rather than Applicative.