Copyright	Copyright (C) 2015 Kyle Carter
License	BSD3
Maintainer	Kyle Carter <kylcarte@indiana.edu>
Stability	experimental
Portability	RankNTypes
Safe Haskell	None
Language	Haskell2010

Data.Type.Sum.Lifted

Description

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.

Synopsis

Documentation

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

Constructors

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

Instances

ListC ((<$>) Constraint (* -> ) Functor fs) => Functor (FSum fs) Source #
Methods fmap :: (a -> b) -> FSum * fs a -> FSum * fs b # (<$) :: a -> FSum * fs b -> FSum * fs a #
ListC ((<$>) Constraint (* -> ) Foldable fs) => Foldable (FSum fs) Source #
Methods fold :: Monoid m => FSum * fs m -> m # foldMap :: Monoid m => (a -> m) -> FSum * fs a -> m # foldr :: (a -> b -> b) -> b -> FSum * fs a -> b # foldr' :: (a -> b -> b) -> b -> FSum * fs a -> b # foldl :: (b -> a -> b) -> b -> FSum * fs a -> b # foldl' :: (b -> a -> b) -> b -> FSum * fs a -> b # foldr1 :: (a -> a -> a) -> FSum * fs a -> a # foldl1 :: (a -> a -> a) -> FSum * fs a -> a # toList :: FSum * fs a -> [a] # null :: FSum * fs a -> Bool # length :: FSum * fs a -> Int # elem :: Eq a => a -> FSum * fs a -> Bool # maximum :: Ord a => FSum * fs a -> a # minimum :: Ord a => FSum * fs a -> a # sum :: Num a => FSum * fs a -> a # product :: Num a => FSum * fs a -> a #
(ListC ((<$>) Constraint (* -> ) Functor fs), ListC ((<$>) Constraint ( -> ) Foldable fs), ListC ((<$>) Constraint ( -> ) Traversable fs)) => Traversable (FSum fs) Source #
Methods traverse :: Applicative f => (a -> f b) -> FSum * fs a -> f (FSum * fs b) # sequenceA :: Applicative f => FSum * fs (f a) -> f (FSum * fs a) # mapM :: Monad m => (a -> m b) -> FSum * fs a -> m (FSum * fs b) # sequence :: Monad m => FSum * fs (m a) -> m (FSum * fs a) #

nilFSum :: FSum Ø a -> Void Source #

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

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

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

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

Inject an element into an FSum.

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

Project an implicit index out of an FSum.

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

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

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

Project an explicit index out of an FSum.

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

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 Source #

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) Source #

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