cubix-compdata-1.0.1: Compositional Data Types for Cubix
CopyrightOriginal (c) 2010-2011 Patrick Bahr Tom Hvitved; modifications (c) 2020 James Koppel
LicenseBSD3
Safe HaskellNone
LanguageHaskell98

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

Documentation

data (f :*: g) a infixr 8 Source #

Formal product of signatures (functors).

Constructors

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

Instances

Instances details
(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 #

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

type (:=:) f g = (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.

class (f :: * -> *) :<: (g :: * -> *) 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 #

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

See documentation for the mult-sorted version, Sum

Constructors

Sum :: 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 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 #

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

data (f :+: g) (a :: *) infixr 6 Source #

Data type defining coproducts.

Constructors

Inl (f a) 
Inr (g a) 

at :: Elem f fs -> Sum fs a -> Maybe (f a) Source #

caseF :: Alts fs a b -> Sum fs a -> b Source #

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

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

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

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

spl :: f :=: Sum fs => Alts fs a b -> f a -> b Source #

ffst :: (f :*: g) a -> f a Source #

fsnd :: (f :*: g) a -> g a Source #

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

A value of type Alts [f1, f2, ...] e b is a vector of functions, of type f1 e -> b, f2 e -> b, etc.

data Alt f e b Source #

Element of an Alts value

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

(<|) :: Alt f e b -> Alts fs e b -> Alts (f ': fs) e b infixr 6 Source #

cons :: Alt f e b -> Alts fs e b -> Alts (f ': fs) e b Source #

nil :: Alts '[] e b Source #