Copyright	Original (c) 2010-2011 Patrick Bahr Tom Hvitved; modifications (c) 2020 James Koppel
License	BSD3
Safe Haskell	None
Language	Haskell2010

Data.Comp.Ops

Description

This module provides sum and product operators on functors.

The main item of interest is the Sum datatype, a constant-memory implementation of type-level sums.

Synopsis

data Sum (fs :: [Type -> Type]) e where
- Sum :: forall (f :: Type -> Type) (fs :: [Type -> Type]) e. Elem f fs -> f e -> Sum fs e
data ((f :: Type -> Type) :+: (g :: Type -> Type)) a
- = Inl (f a)
- | Inr (g a)
data ((f :: k -> Type) :*: (g :: k -> Type)) (a :: k) = (f a) :*: (g a)
class (f :: Type -> Type) :<: (g :: Type -> Type) where
- inj :: f a -> g a
- prj :: g a -> Maybe (f a)
type (:=:) (f :: Type -> Type) (g :: Type -> Type) = (f :<: g, g :<: f)
spl :: forall f (fs :: [Type -> Type]) a b. f :=: Sum fs => Alts fs a b -> f a -> b
ffst :: forall {k} f (g :: k -> Type) (a :: k). (f :*: g) a -> f a
fsnd :: forall {k} (f :: k -> Type) g (a :: k). (f :*: g) a -> g a
caseCxt :: forall cxt (fs :: [Type -> Type]) a b. All cxt fs => (forall (f :: Type -> Type). cxt f => f a -> b) -> Sum fs a -> b
caseSumF :: forall cxt f (fs :: [Type -> Type]) a b. (All cxt fs, Functor f) => (forall (g :: Type -> Type). cxt g => g a -> f (g b)) -> Sum fs a -> f (Sum fs b)
caseSum :: forall cxt (fs :: [Type -> Type]) a b. All cxt fs => (forall (g :: Type -> Type). cxt g => g a -> g b) -> Sum fs a -> Sum fs b
at :: forall f (fs :: [Type -> Type]) a. Elem f fs -> Sum fs a -> Maybe (f a)
caseF :: forall (fs :: [Type -> Type]) a b. Alts fs a b -> Sum fs a -> b
data Alts (fs :: [Type -> Type]) e b
data Alt (f :: Type -> Type) e b
alt :: (f e -> b) -> Alt f e b
(<|) :: forall (f :: Type -> Type) e b (fs :: [Type -> Type]). Alt f e b -> Alts fs e b -> Alts (f ': fs) e b
cons :: forall (f :: Type -> Type) e b (fs :: [Type -> Type]). Alt f e b -> Alts fs e b -> Alts (f ': fs) e b
nil :: Alts ('[] :: [Type -> Type]) e b

Documentation

data Sum (fs :: [Type -> Type]) e where Source #

See documentation for the mult-sorted version, Sum

Constructors

Sum :: forall (f :: Type -> Type) (fs :: [Type -> Type]) e. Elem f fs -> f e -> Sum fs e

Instances

Instances details

(Functor f, Mem f fs) => f :<: (Sum fs) Source #
Instance details Defined in Data.Comp.Ops Methods inj :: f a -> Sum fs a Source # prj :: Sum fs a -> Maybe (f a) Source #
All Foldable fs => Foldable (Sum fs) Source #
Instance details Defined in Data.Comp.Ops Methods fold :: Monoid m => Sum fs m -> m # foldMap :: Monoid m => (a -> m) -> Sum fs a -> m # foldMap' :: Monoid m => (a -> m) -> Sum fs a -> m # foldr :: (a -> b -> b) -> b -> Sum fs a -> b # foldr' :: (a -> b -> b) -> b -> Sum fs a -> b # foldl :: (b -> a -> b) -> b -> Sum fs a -> b # foldl' :: (b -> a -> b) -> b -> Sum fs a -> b # foldr1 :: (a -> a -> a) -> Sum fs a -> a # foldl1 :: (a -> a -> a) -> Sum fs a -> a # toList :: Sum fs a -> [a] # null :: Sum fs a -> Bool # length :: Sum fs a -> Int # elem :: Eq a => a -> Sum fs a -> Bool # maximum :: Ord a => Sum fs a -> a # minimum :: Ord a => Sum fs a -> a # sum :: Num a => Sum fs a -> a # product :: Num a => Sum fs a -> a #
(All Traversable fs, All Functor fs, All Foldable fs) => Traversable (Sum fs) Source #
Instance details Defined in Data.Comp.Ops Methods traverse :: Applicative f => (a -> f b) -> Sum fs a -> f (Sum fs b) # sequenceA :: Applicative f => Sum fs (f a) -> f (Sum fs a) # mapM :: Monad m => (a -> m b) -> Sum fs a -> m (Sum fs b) # sequence :: Monad m => Sum fs (m a) -> m (Sum fs a) #
All Functor fs => Functor (Sum fs) Source #
Instance details Defined in Data.Comp.Ops Methods fmap :: (a -> b) -> Sum fs a -> Sum fs b # (<$) :: a -> Sum fs b -> Sum fs a #

data ((f :: Type -> Type) :+: (g :: Type -> Type)) a infixr 6 Source #

Data type defining coproducts.

Constructors

Inl (f a)
Inr (g a)

data ((f :: k -> Type) :*: (g :: k -> Type)) (a :: k) infixr 8 Source #

Formal product of signatures (functors).

Constructors

(f a) :*: (g a) infixr 8

Instances

Instances details

(Foldable f, Foldable g) => Foldable (f :*: g) Source #
Instance details Defined in Data.Comp.Ops Methods fold :: Monoid m => (f :: g) m -> m # foldMap :: Monoid m => (a -> m) -> (f :: g) a -> m # foldMap' :: Monoid m => (a -> m) -> (f :: g) a -> m # foldr :: (a -> b -> b) -> b -> (f :: g) a -> b # foldr' :: (a -> b -> b) -> b -> (f :: g) a -> b # foldl :: (b -> a -> b) -> b -> (f :: g) a -> b # foldl' :: (b -> a -> b) -> b -> (f :: g) a -> b # foldr1 :: (a -> a -> a) -> (f :: g) a -> a # foldl1 :: (a -> a -> a) -> (f :: g) a -> a # toList :: (f :: g) a -> [a] # null :: (f :: g) a -> Bool # length :: (f :: g) a -> Int # elem :: Eq a => a -> (f :: g) a -> Bool # maximum :: Ord a => (f :: g) a -> a # minimum :: Ord a => (f :: g) a -> a # sum :: Num a => (f :: g) a -> a # product :: Num a => (f :*: g) a -> a #
(Traversable f, Traversable g) => Traversable (f :*: g) Source #
Instance details Defined in Data.Comp.Ops Methods traverse :: Applicative f0 => (a -> f0 b) -> (f :: g) a -> f0 ((f :: g) b) # sequenceA :: Applicative f0 => (f :: g) (f0 a) -> f0 ((f :: g) a) # mapM :: Monad m => (a -> m b) -> (f :: g) a -> m ((f :: g) b) # sequence :: Monad m => (f :: g) (m a) -> m ((f :: g) a) #
(Functor f, Functor g) => Functor (f :*: g) Source #
Instance details Defined in Data.Comp.Ops Methods fmap :: (a -> b) -> (f :: g) a -> (f :: g) b # (<$) :: a -> (f :: g) b -> (f :: g) a #

class (f :: Type -> Type) :<: (g :: Type -> Type) where infixl 5 Source #

Methods

inj :: f a -> g a Source #

prj :: g a -> Maybe (f a) Source #

Instances

Instances details

a :<: a Source #
Instance details Defined in Data.Comp.Ops Methods inj :: a a0 -> a a0 Source # prj :: a a0 -> Maybe (a a0) Source #
(Functor f, Mem f fs) => f :<: (Sum fs) Source #
Instance details Defined in Data.Comp.Ops Methods inj :: f a -> Sum fs a Source # prj :: Sum fs a -> Maybe (f a) Source #

type (:=:) (f :: Type -> Type) (g :: Type -> Type) = (f :<: g, g :<: f) Source #

A constraint f :<: g expresses that the signature f is subsumed by g, i.e. f can be used to construct elements in g.

spl :: forall f (fs :: [Type -> Type]) a b. f :=: Sum fs => Alts fs a b -> f a -> b Source #

ffst :: forall {k} f (g :: k -> Type) (a :: k). (f :*: g) a -> f a Source #

fsnd :: forall {k} (f :: k -> Type) g (a :: k). (f :*: g) a -> g a Source #

caseCxt :: forall cxt (fs :: [Type -> Type]) a b. All cxt fs => (forall (f :: Type -> Type). cxt f => f a -> b) -> Sum fs a -> b Source #

caseSumF :: forall cxt f (fs :: [Type -> Type]) a b. (All cxt fs, Functor f) => (forall (g :: Type -> Type). cxt g => g a -> f (g b)) -> Sum fs a -> f (Sum fs b) Source #

caseSum :: forall cxt (fs :: [Type -> Type]) a b. All cxt fs => (forall (g :: Type -> Type). cxt g => g a -> g b) -> Sum fs a -> Sum fs b Source #

at :: forall f (fs :: [Type -> Type]) a. Elem f fs -> Sum fs a -> Maybe (f a) Source #

caseF :: forall (fs :: [Type -> Type]) a b. Alts fs a b -> Sum fs a -> b Source #

Utility function to case on a functor sum, without exposing the internal representation of sums.

data Alts (fs :: [Type -> Type]) e b #

data Alt (f :: Type -> Type) e b #

alt :: (f e -> b) -> Alt f e b #

(<|) :: forall (f :: Type -> Type) e b (fs :: [Type -> Type]). Alt f e b -> Alts fs e b -> Alts (f ': fs) e b #

cons :: forall (f :: Type -> Type) e b (fs :: [Type -> Type]). Alt f e b -> Alts fs e b -> Alts (f ': fs) e b #

nil :: Alts ('[] :: [Type -> Type]) e b #