mgeneric-0.0.0.2: Generics with multiple parameters

Safe HaskellNone
LanguageHaskell2010

Data.MTraversable

Synopsis

Documentation

type family AppMap fs t Source

AppMap ((a1 -> b1) : ...) t ~ (a1 -> t b1) : ...

Equations

AppMap [] t = [] 
AppMap ((a -> b) : fs) t = (a -> t b) : AppMap fs t 

type family Domains fs Source

Domain (a -> b) ~ a
Domains fs ~ Map Domain fs

Equations

Domains [] = [] 
Domains ((a -> b) : as) = a : Domains as 

type family Codomains fs Source

Codomain (a -> b) ~ b
Codomains fs ~ Map Codomain fs

Equations

Codomains [] = [] 
Codomains ((a -> b) : as) = b : Codomains as 

class MTraversable f fs t | fs -> k where Source

Traversable type class, generalisation of Traversable, Bitraversable, etc.

Minimal complete definition

Nothing

Methods

mtraverseP :: Applicative t => Proxy f -> Proxy fs -> Proxy t -> HList (AppMap fs t) -> (f :$: Domains fs) -> t (f :$: Codomains fs) Source

see mtraverse

Instances

MTraversable * Bool ([] *) t 
MTraversable * Ordering ([] *) t 
MTraversable * () ([] *) t 
MTraversable (* -> * -> * -> * -> * -> * -> * -> * -> * -> *) (,,,,,,,,) ((:) * (a -> a') ((:) * (b -> b') ((:) * (c -> c') ((:) * (d -> d') ((:) * (e -> e') ((:) * (f -> f') ((:) * (g -> g') ((:) * (h -> h') ((:) * (i -> i') ([] *)))))))))) t 
MTraversable (* -> * -> * -> * -> * -> * -> * -> * -> *) (,,,,,,,) ((:) * (a -> a') ((:) * (b -> b') ((:) * (c -> c') ((:) * (d -> d') ((:) * (e -> e') ((:) * (f -> f') ((:) * (g -> g') ((:) * (h -> h') ([] *))))))))) t 
MTraversable (* -> * -> * -> * -> * -> * -> * -> *) (,,,,,,) ((:) * (a -> a') ((:) * (b -> b') ((:) * (c -> c') ((:) * (d -> d') ((:) * (e -> e') ((:) * (f -> f') ((:) * (g -> g') ([] *)))))))) t 
MTraversable (* -> * -> * -> * -> * -> * -> *) (,,,,,) ((:) * (a -> a') ((:) * (b -> b') ((:) * (c -> c') ((:) * (d -> d') ((:) * (e -> e') ((:) * (f -> f') ([] *))))))) t 
MTraversable (* -> * -> * -> * -> * -> *) (,,,,) ((:) * (a -> a') ((:) * (b -> b') ((:) * (c -> c') ((:) * (d -> d') ((:) * (e -> e') ([] *)))))) t 
MTraversable (* -> * -> * -> * -> *) (,,,) ((:) * (a -> a') ((:) * (b -> b') ((:) * (c -> c') ((:) * (d -> d') ([] *))))) t 
MTraversable (* -> * -> * -> *) (,,) ((:) * (a -> a') ((:) * (b -> b') ((:) * (c -> c') ([] *)))) t 
MTraversable (* -> * -> *) Either ((:) * (a -> a') ((:) * (b -> b') ([] *))) t 
MTraversable (* -> * -> *) (,) ((:) * (a -> a') ((:) * (b -> b') ([] *))) t 
MTraversable (* -> *) [] ((:) * (a -> a') ([] *)) t 
MTraversable (* -> *) Sum ((:) * (a -> b) ([] *)) t 
MTraversable (* -> *) Product ((:) * (a -> b) ([] *)) t 
MTraversable (* -> *) First ((:) * (a -> b) ([] *)) t 
MTraversable (* -> *) Last ((:) * (a -> b) ([] *)) t 
MTraversable (* -> *) Maybe ((:) * (a -> a') ([] *)) t 

mtraverse :: forall t f fs a b fs'. (Applicative t, Unapply a f (Domains fs), Unapply b f (Codomains fs), UnAppMap fs t fs', MTraversable f fs t) => HList fs' -> a -> t b Source

Map elements of all type parameters of a structure to an action, evaluate these actions from left to right, and collect the results.

Proxy-less version of mtraverseP

Generalisation of traverse, bitraverse, etc.

mtraverse :: HList '[a1 -> f b1, ..., an -> f bn] -> f a1 ... an -> t (f b1 ... bn)

msequence :: forall t f as a b. (Applicative t, Unapply a f (Map t as), Unapply b f as, Map t as ~ Domains (SequenceMap as t), as ~ Codomains (SequenceMap as t), MTraversable f (SequenceMap as t) t, SequenceMapId as t) => a -> t b Source

msequence :: f (t a1) ... (t an) -> t (f a1 ... an)