Data.MTraversable

Documentation

type family AppMap fs t

Equations

AppMap [] t = []

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

type family Domains fs

Equations

Domains [] = []

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

type family Codomains fs

Equations

Codomains [] = []

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

class MTraversable f fs t | fs -> k where

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)

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

class (AppMap fs t ~ fs') => UnAppMap fs t fs' | fs' -> fs

Instances

UnAppMap ([] *) t ([] *)

UnAppMap fs t fs' => UnAppMap ((:) * (a -> b) fs) t ((:) * (a -> t b) fs')

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

type family Map as t

Equations

Map [] t = []

Map (a : as) t = t a : Map as t

type family SequenceMap as t

Equations

SequenceMap [] t = []

SequenceMap (a : as) t = (t a -> a) : SequenceMap as t

class SequenceMapId as t where

Methods

sequenceMapId :: Proxy as -> Proxy t -> HList (AppMap (SequenceMap as t) t)

Instances

SequenceMapId ([] *) t

SequenceMapId as t => SequenceMapId ((:) * a as) t

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

class GMTraversable f fs t where

Methods

mtraverseG :: Applicative t => Proxy fs -> HList (AppMap fs t) -> In f (Domains fs) -> t (In f (Codomains fs))

Instances

GMTraversable (UT *) fs t

GMTraversable (UV *) fs t

GFMTraversable f fs t => GMTraversable (UF * f) fs t

(GMTraversable u fs t, GMTraversable v fs t) => GMTraversable ((:++:) * u v) fs t

(GMTraversable u fs t, GMTraversable v fs t) => GMTraversable ((:**:) * u v) fs t

class GFMTraversable f fs t where

Methods

mtraverseGF :: Applicative t => Proxy fs -> HList (AppMap fs t) -> InField f (Domains fs) -> t (InField f (Codomains fs))

Instances

GFPMTraversable n fs t => GFMTraversable (FP * n) fs t

GFMTraversable (FK * a) fs t

(MTraversable k f (ExpandFieldFunction as fs) t, (~) * ((:$:) k f (ExpandField as (Codomains fs))) ((:$:) k f (Codomains (ExpandFieldFunction as fs))), (~) * ((:$:) k f (ExpandField as (Domains fs))) ((:$:) k f (Domains (ExpandFieldFunction as fs))), AdaptFieldFunction as fs t) => GFMTraversable ((:@:) * k f as) fs t

class GFPMTraversable n fs t where

Methods

mtraverseGFP :: Applicative t => Proxy n -> Proxy fs -> HList (AppMap fs t) -> (Domains fs :!: n) -> t (Codomains fs :!: n)

Instances

GFPMTraversable NZ ((:) * (a -> b) as) t

GFPMTraversable n as t => GFPMTraversable (NS n) ((:) * (a -> b) as) t

type family ExpandFieldFunction f ps :: [*]

Equations

ExpandFieldFunction [] ps = []

ExpandFieldFunction (FK a : fs) ps = (a -> a) : ExpandFieldFunction fs ps

ExpandFieldFunction (FP n : fs) ps = (ps :!: n) : ExpandFieldFunction fs ps

ExpandFieldFunction ((f :@: as) : fs) ps = ((f :$: ExpandField as (Domains ps)) -> f :$: ExpandField as (Codomains ps)) : ExpandFieldFunction fs ps

class AdaptFieldFunction f fs t where

Methods

adaptFieldFunction :: Applicative t => Proxy f -> Proxy fs -> Proxy t -> HList (AppMap fs t) -> HList (AppMap (ExpandFieldFunction f fs) t)

Instances

AdaptFieldFunction ([] (Field *)) fs t

(MTraversable k f (ExpandFieldFunction bs fs) t, (~) * ((:$:) k f (ExpandField bs (Codomains fs))) ((:$:) k f (Codomains (ExpandFieldFunction bs fs))), (~) * ((:$:) k f (ExpandField bs (Domains fs))) ((:$:) k f (Domains (ExpandFieldFunction bs fs))), AdaptFieldFunction bs fs t, AdaptFieldFunction as fs t) => AdaptFieldFunction ((:) (Field *) ((:@:) * k f bs) as) fs t

(GFPMTraversable n fs t, AdaptFieldFunction as fs t, (~) [*] (AppMap ((:) * ((:!:) fs n) (ExpandFieldFunction as fs)) t) ((:) * ((:!:) (Domains fs) n -> t ((:!:) (Codomains fs) n)) (AppMap (ExpandFieldFunction as fs) t))) => AdaptFieldFunction ((:) (Field *) (FP * n) as) fs t

AdaptFieldFunction as fs t => AdaptFieldFunction ((:) (Field *) (FK * a) as) fs t