Data.Type.Sum.Dual

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)

nilSumF :: FSum Ø a -> Void

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

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

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

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

Inject an element into an FSum.

prjF :: 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.

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

Project an explicit index out of an FSum.

imapF :: (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.

ifoldMapF :: (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!

itraverseF :: 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.