-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Generics with multiple parameters
--   
@package mgeneric
@version 0.0.0.0

module Data.Nat
data Nat
NZ :: Nat
NS :: Nat -> Nat

module Data.HList
data HList as
HNil :: HList []
HCons :: a -> HList as -> HList (a : as)
class HNth as n
hnth :: HNth as n => HList as -> Proxy n -> as :!: n
instance HNth (a : as) 'NZ
instance HNth as n => HNth (b : as) ('NS n)

module Data.HList.TH
hlist :: ExpQ -> ExpQ

module Data.MGeneric
data Un s
UV :: Un s
UT :: Un s
UF :: (Field s) -> Un s
(:**:) :: Un s -> Un s -> Un s
(:++:) :: Un s -> Un s -> Un s
data Field s
FK :: s -> Field s
FP :: Nat -> Field s
(:@:) :: k -> [Field s] -> Field s
data In (u :: Un *) (ps :: [*]) :: *
InT :: In UT ps
InF :: InField f ps -> In (UF f) ps
InL :: In u ps -> In (u :++: v) ps
InR :: In v ps -> In (u :++: v) ps
(:*:) :: In u ps -> In v ps -> In (u :**: v) ps
data InField (f :: Field *) (ps :: [*]) :: *
InK :: a -> InField (FK a) ps
InP :: ps :!: n -> InField (FP n) ps
InA :: f :$: ExpandField as ps -> InField (f :@: as) ps
class MGeneric (a :: *) where type family Rep a :: Un * type family Pars a :: [*]
from :: MGeneric a => a -> In (Rep a) (Pars a)
to :: MGeneric a => In (Rep a) (Pars a) -> a

module Data.MGeneric.TH
viewData :: Dec -> Maybe (Cxt, Name, [TyVarBndr], [Con], [Name])
viewCon :: Con -> (Name, [Type])
index :: Eq a => [a] -> a -> Maybe Int
nthNat :: Int -> TypeQ
viewAppType :: Type -> (Type, [Type])
typeEncoding :: [Name] -> Type -> Name
encodeField :: [Name] -> Type -> TypeQ
foldBinary :: (a -> a -> a) -> a -> [a] -> a
deriveMGeneric :: Name -> Q [Dec]

module Data.Unapply
class f ~ (f' :$: as) => Unapply (f :: *) (f' :: k') (as :: [*]) | f' as -> f, f -> f' as
instance Unapply (a -> b) (->) '[a, b]
instance Unapply (Sum a) Sum '[a]
instance Unapply (Product a) Product '[a]
instance Unapply (First a) First '[a]
instance Unapply (Last a) Last '[a]
instance Unapply (a, b, c, d, e, f, g, h, i) (,,,,,,,,) '[a, b, c, d, e, f, g, h, i]
instance Unapply (a, b, c, d, e, f, g, h) (,,,,,,,) '[a, b, c, d, e, f, g, h]
instance Unapply (a, b, c, d, e, f, g) (,,,,,,) '[a, b, c, d, e, f, g]
instance Unapply (a, b, c, d, e, f) (,,,,,) '[a, b, c, d, e, f]
instance Unapply (a, b, c, d, e) (,,,,) '[a, b, c, d, e]
instance Unapply (a, b, c, d) (,,,) '[a, b, c, d]
instance Unapply (a, b, c) (,,) '[a, b, c]
instance Unapply (a, b) (,) '[a, b]
instance Unapply () () '[]
instance Unapply Ordering Ordering '[]
instance Unapply Bool Bool '[]
instance Unapply (Either a b) Either '[a, b]
instance Unapply (Maybe a) Maybe '[a]
instance Unapply [a] [] '[a]

module Data.MFunctor
data Variance
CoV :: Variance
ContraV :: Variance
class MFunctor (f :: k) (fs :: [*]) (vs :: [Variance]) | f -> vs, fs -> k, vs -> k where mmapP _ pv fs = to . mmapG pv fs . from
mmapP :: MFunctor f fs vs => Proxy f -> Proxy vs -> HList fs -> f :$: Domains fs vs -> f :$: Codomains fs vs
mmap :: (Unapply a f (Domains fs vs), Unapply b f (Codomains fs vs), MFunctor f fs vs) => HList fs -> a -> b
class GMFunctor (f :: Un *) (fs :: [*]) (vs :: [Variance])
mmapG :: GMFunctor f fs vs => Proxy vs -> HList fs -> In f (Domains fs vs) -> In f (Codomains fs vs)
class GFMFunctor (f :: Field *) (fs :: [*]) (vs :: [Variance])
mmapGF :: GFMFunctor f fs vs => Proxy vs -> HList fs -> InField f (Domains fs vs) -> InField f (Codomains fs vs)
class GFPMFunctor n fs vs
mmapGFP :: GFPMFunctor n fs vs => Proxy n -> Proxy vs -> HList fs -> fs :!: n
class AdaptFieldFunction (f :: [Field *]) (vfs :: [Variance]) (ps :: [*]) (vs :: [Variance])
adaptFieldFunction :: AdaptFieldFunction f vfs ps vs => Proxy f -> Proxy vfs -> Proxy vs -> HList ps -> HList (ExpandFieldFunction f vfs ps vs)
instance (MFunctor f (ExpandFieldFunction as vs' ps vs) vs', ExpandField as (Codomains ps vs) ~ Codomains (ExpandFieldFunction as vs' ps vs) vs', ExpandField as (Domains ps vs) ~ Domains (ExpandFieldFunction as vs' ps vs) vs', AdaptFieldFunction as vs' ps vs) => GFMFunctor (f ':@: as) ps vs
instance (MFunctor f (ExpandFieldFunction bs (FlipVariance vs') ps vs) vs', ExpandField bs (Domains ps vs) ~ Codomains (ExpandFieldFunction bs (FlipVariance vs') ps vs) vs', ExpandField bs (Codomains ps vs) ~ Domains (ExpandFieldFunction bs (FlipVariance vs') ps vs) vs', AdaptFieldFunction bs (FlipVariance vs') ps vs, AdaptFieldFunction as vfs ps vs) => AdaptFieldFunction ((f ':@: bs) : as) ('ContraV : vfs) ps vs
instance (MFunctor f (ExpandFieldFunction bs vs' ps vs) vs', ExpandField bs (Codomains ps vs) ~ Codomains (ExpandFieldFunction bs vs' ps vs) vs', ExpandField bs (Domains ps vs) ~ Domains (ExpandFieldFunction bs vs' ps vs) vs', AdaptFieldFunction bs vs' ps vs, AdaptFieldFunction as vfs ps vs) => AdaptFieldFunction ((f ':@: bs) : as) ('CoV : vfs) ps vs
instance (GFPMFunctor n ps vs, AdaptFieldFunction as vfs ps vs, Flip (ps :!: n) ~ ((Domains ps vs :!: n) -> Codomains ps vs :!: n)) => AdaptFieldFunction ('FP n : as) ('ContraV : vfs) ps vs
instance (GFPMFunctor n ps vs, AdaptFieldFunction as vfs ps vs, (ps :!: n) ~ ((Domains ps vs :!: n) -> Codomains ps vs :!: n)) => AdaptFieldFunction ('FP n : as) ('CoV : vfs) ps vs
instance AdaptFieldFunction as vfs ps vs => AdaptFieldFunction ('FK a : as) (v : vfs) ps vs
instance AdaptFieldFunction '[] '[] ps vs
instance GFPMFunctor n as vs => GFPMFunctor ('NS n) ((a -> b) : as) ('ContraV : vs)
instance GFPMFunctor n as vs => GFPMFunctor ('NS n) ((a -> b) : as) ('CoV : vs)
instance GFPMFunctor 'NZ ((a -> b) : as) (v : vs)
instance (GFPMFunctor n fs vs, (fs :!: n) ~ ((Domains fs vs :!: n) -> Codomains fs vs :!: n)) => GFMFunctor ('FP n) fs vs
instance GFMFunctor ('FK a) fs vs
instance GFMFunctor f fs vs => GMFunctor ('UF f) fs vs
instance (GMFunctor u fs vs, GMFunctor v fs vs) => GMFunctor (u ':**: v) fs vs
instance (GMFunctor u fs vs, GMFunctor v fs vs) => GMFunctor (u ':++: v) fs vs
instance GMFunctor 'UT fs vs
instance GMFunctor 'UV fs vs

module Data.MFoldable
class MFoldable (f :: k) (as :: [*]) | as -> k where mfoldMapP _ _ fs = mfoldMapG fs . from
mfoldMapP :: (MFoldable f as, Monoid m) => Proxy f -> Proxy as -> HList (MonoidMap as m) -> f :$: as -> m
mfoldMap :: (Monoid m, Unapply a f as, MFoldable f as) => HList (MonoidMap as m) -> a -> m
class Repeat m as
repeatId :: Repeat m as => Proxy m -> Proxy as -> HList (MonoidMap as m)
mfold :: (Monoid m, Repeat m as, MFoldable f as, Unapply a f as) => a -> m
class GMFoldable (f :: Un *) (as :: [*])
mfoldMapG :: (GMFoldable f as, Monoid m) => HList (MonoidMap as m) -> In f as -> m
class GFMFoldable (f :: Field *) (as :: [*])
mfoldMapGF :: (GFMFoldable f as, Monoid m) => HList (MonoidMap as m) -> InField f as -> m
class GFPMFoldable n as
mfoldMapGFP :: (GFPMFoldable n as, Monoid m) => Proxy n -> Proxy as -> HList (MonoidMap as m) -> as :!: n -> m
class AdaptFieldMonoid (f :: [Field *]) (as :: [*])
adaptFieldMonoid :: (AdaptFieldMonoid f as, Monoid m) => Proxy f -> Proxy as -> Proxy m -> HList (MonoidMap as m) -> HList (MonoidMap (ExpandField f as) m)
instance (MFoldable f (ExpandField as bs), AdaptFieldMonoid as bs) => GFMFoldable (f ':@: as) bs
instance (MFoldable f (ExpandField bs fs), AdaptFieldMonoid bs fs, AdaptFieldMonoid as fs) => AdaptFieldMonoid ((f ':@: bs) : as) fs
instance (GFPMFoldable n fs, AdaptFieldMonoid as fs) => AdaptFieldMonoid ('FP n : as) fs
instance AdaptFieldMonoid as fs => AdaptFieldMonoid ('FK a : as) fs
instance AdaptFieldMonoid '[] fs
instance GFPMFoldable n as => GFPMFoldable ('NS n) (a : as)
instance GFPMFoldable 'NZ (a : as)
instance GFPMFoldable n as => GFMFoldable ('FP n) as
instance GFMFoldable ('FK a) as
instance GFMFoldable f as => GMFoldable ('UF f) as
instance (GMFoldable u as, GMFoldable v as) => GMFoldable (u ':**: v) as
instance (GMFoldable u as, GMFoldable v as) => GMFoldable (u ':++: v) as
instance GMFoldable 'UT fs
instance GMFoldable 'UV fs
instance Repeat m as => Repeat m (m : as)
instance Repeat m '[]

module Data.MTraversable
class MTraversable (f :: k) (fs :: [*]) t | fs -> k where mtraverseP _ pf _ fs = fmap to . mtraverseG pf fs . from
mtraverseP :: (MTraversable f fs t, Applicative t) => Proxy f -> Proxy fs -> Proxy t -> HList (AppMap fs t) -> f :$: Domains fs -> t (f :$: Codomains fs)
class AppMap fs t ~ fs' => UnAppMap fs t fs' | fs' -> fs
mtraverse :: (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
class SequenceMapId as t
sequenceMapId :: SequenceMapId as t => Proxy as -> Proxy t -> HList (AppMap (SequenceMap as t) t)
msequence :: (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 :: Un *) (fs :: [*]) t
mtraverseG :: (GMTraversable f fs t, Applicative t) => Proxy fs -> HList (AppMap fs t) -> In f (Domains fs) -> t (In f (Codomains fs))
class GFMTraversable (f :: Field *) (fs :: [*]) t
mtraverseGF :: (GFMTraversable f fs t, Applicative t) => Proxy fs -> HList (AppMap fs t) -> InField f (Domains fs) -> t (InField f (Codomains fs))
class GFPMTraversable n fs t
mtraverseGFP :: (GFPMTraversable n fs t, Applicative t) => Proxy n -> Proxy fs -> HList (AppMap fs t) -> Domains fs :!: n -> t (Codomains fs :!: n)
class AdaptFieldFunction (f :: [Field *]) (fs :: [*]) t
adaptFieldFunction :: (AdaptFieldFunction f fs t, Applicative t) => Proxy f -> Proxy fs -> Proxy t -> HList (AppMap fs t) -> HList (AppMap (ExpandFieldFunction f fs) t)
instance (MTraversable f (ExpandFieldFunction as fs) t, (f :$: ExpandField as (Codomains fs)) ~ (f :$: Codomains (ExpandFieldFunction as fs)), (f :$: ExpandField as (Domains fs)) ~ (f :$: Domains (ExpandFieldFunction as fs)), AdaptFieldFunction as fs t) => GFMTraversable (f ':@: as) fs t
instance (MTraversable f (ExpandFieldFunction bs fs) t, (f :$: ExpandField bs (Codomains fs)) ~ (f :$: Codomains (ExpandFieldFunction bs fs)), (f :$: ExpandField bs (Domains fs)) ~ (f :$: Domains (ExpandFieldFunction bs fs)), AdaptFieldFunction bs fs t, AdaptFieldFunction as fs t) => AdaptFieldFunction ((f ':@: bs) : as) fs t
instance (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 ('FP n : as) fs t
instance AdaptFieldFunction as fs t => AdaptFieldFunction ('FK a : as) fs t
instance AdaptFieldFunction '[] fs t
instance GFPMTraversable n as t => GFPMTraversable ('NS n) ((a -> b) : as) t
instance GFPMTraversable 'NZ ((a -> b) : as) t
instance GFPMTraversable n fs t => GFMTraversable ('FP n) fs t
instance GFMTraversable ('FK a) fs t
instance GFMTraversable f fs t => GMTraversable ('UF f) fs t
instance (GMTraversable u fs t, GMTraversable v fs t) => GMTraversable (u ':**: v) fs t
instance (GMTraversable u fs t, GMTraversable v fs t) => GMTraversable (u ':++: v) fs t
instance GMTraversable 'UT fs t
instance GMTraversable 'UV fs t
instance SequenceMapId as t => SequenceMapId (a : as) t
instance SequenceMapId '[] t
instance UnAppMap fs t fs' => UnAppMap ((a -> b) : fs) t ((a -> t b) : fs')
instance UnAppMap '[] t '[]

module Data.MZipWith
class MZipWithG n f rf fs
mzipWithPG :: MZipWithG n f rf fs => Proxy n -> Proxy f -> Proxy rf -> Proxy fs -> ZipWithTypeUn n rf fs -> ZipWithType n f fs
class MZipWith (n :: Nat) (f :: k) (fs :: [*]) where mzipWithP pn pf pfs fs = mzipWithPG pn pf prf (Proxy :: Proxy fs) (mzipWithG pn prf pfs fs) where prf = Proxy :: Proxy (Rep (f :$: LCodoms n fs))
mzipWithP :: MZipWith n f fs => Proxy n -> Proxy f -> Proxy fs -> HList (ZipInputs n fs) -> ZipWithType n f fs
class GMZipWith (n :: Nat) (f :: Un *) (fs :: [*])
mzipWithG :: GMZipWith n f fs => Proxy n -> Proxy f -> Proxy fs -> HList (ZipInputs n fs) -> ZipWithTypeUn n f fs
class GMTZipWith n fs
mzipWithGT :: GMTZipWith n fs => Proxy n -> Proxy fs -> ZipWithTypeUn n UT fs
class GMZipWithFail n u fs
mzipWithFail :: GMZipWithFail n u fs => Proxy n -> Proxy u -> Proxy fs -> ZipWithTypeUn n u fs
class GMLZipWith n u v fs
mzipWithGL :: GMLZipWith n u v fs => Proxy n -> Proxy u -> Proxy v -> Proxy fs -> ZipWithTypeUn n u fs -> ZipWithTypeUn n (u :++: v) fs
class GMRZipWith n u v fs
mzipWithGR :: GMRZipWith n u v fs => Proxy n -> Proxy u -> Proxy v -> Proxy fs -> ZipWithTypeUn n v fs -> ZipWithTypeUn n (u :++: v) fs
class GPiMZipWith n u v fs
mzipWithGPi :: GPiMZipWith n u v fs => Proxy n -> Proxy u -> Proxy v -> Proxy fs -> ZipWithTypeUn n u fs -> ZipWithTypeUn n v fs -> ZipWithTypeUn n (u :**: v) fs
class GMZipWithF n f fs
mzipWithGFF :: GMZipWithF n f fs => Proxy n -> Proxy f -> Proxy fs -> ZipWithTypeField n f fs -> ZipWithTypeUn n (UF f) fs
class GFMZipWith (n :: Nat) (f :: Field *) (fs :: [*])
mzipWithGF :: GFMZipWith n f fs => Proxy n -> Proxy f -> Proxy fs -> HList (ZipInputs n fs) -> ZipWithTypeField n f fs
class GFPMZipWith n m fs
mzipWithGFP :: GFPMZipWith n m fs => Proxy n -> Proxy m -> Proxy fs -> (ZipInputs n fs :!: m) -> ZipWithTypeField n (FP m) fs
class HLookup n m fs
hlookup :: HLookup n m fs => Proxy n -> Proxy m -> Proxy fs -> HList (ZipInputs m fs) -> ZipInputs m fs :!: n
class AdaptFieldFunction (n :: Nat) (f :: [Field *]) (ps :: [*])
adaptFieldFunction :: AdaptFieldFunction n f ps => Proxy n -> Proxy f -> Proxy ps -> HList (ZipInputs n ps) -> HList (ZipInputs n (ExpandFieldFunction n f ps))
class GFAMZipWith n f as fs
mzipWithGFA :: GFAMZipWith n f as fs => Proxy n -> Proxy f -> Proxy as -> Proxy fs -> ZipWithType n f (ExpandFieldFunction n as fs) -> ZipWithTypeField n (f :@: as) fs
instance (GFAMZipWith n f as fs, MZipWith n f (ExpandFieldFunction n as fs), AdaptFieldFunction n as fs) => GFMZipWith n (f ':@: as) fs
instance (ExpandFieldFunction n as (Codoms fs) ~ Codoms (ExpandFieldFunction ('NS n) as fs), Doms (ExpandFieldFunction ('NS n) as fs) ~ ExpandField as (Doms fs), GFAMZipWith n f as (Codoms fs)) => GFAMZipWith ('NS n) f as fs
instance ExpandField as fs ~ ExpandFieldFunction 'NZ as fs => GFAMZipWith 'NZ f as fs
instance (MZipWith n f (ExpandFieldFunction n bs ps), ZipInput n (ZipWithType' n f (ExpandFieldFunction n bs ps)) ~ ZipWithType n f (ExpandFieldFunction n bs ps), AdaptFieldFunction n bs ps, AdaptFieldFunction n as ps) => AdaptFieldFunction n ((f ':@: bs) : as) ps
instance (HLookup m n ps, ZipInput n (ps :!: m) ~ (ZipInputs n ps :!: m), AdaptFieldFunction n as ps) => AdaptFieldFunction n ('FP m : as) ps
instance AdaptFieldFunction n '[] ps
instance HLookup n m as => HLookup ('NS n) m (a : as)
instance HLookup 'NZ m (a : as)
instance (GFPMZipWith n m fs, HLookup m n fs) => GFMZipWith n ('FP m) fs
instance ((ZipInputs ('NS n) fs :!: m) ~ ((Doms fs :!: m) -> ZipInputs n (Codoms fs) :!: m), GFPMZipWith n m (Codoms fs)) => GFPMZipWith ('NS n) m fs
instance Maybe (fs :!: m) ~ (ZipInputs 'NZ fs :!: m) => GFPMZipWith 'NZ m fs
instance (GFMZipWith n f fs, GMZipWithF n f fs) => GMZipWith n ('UF f) fs
instance GMZipWithF n f (Codoms fs) => GMZipWithF ('NS n) f fs
instance GMZipWithF 'NZ f fs
instance (GMZipWith n u fs, GMZipWith n v fs, GPiMZipWith n u v fs) => GMZipWith n (u ':**: v) fs
instance GPiMZipWith n u v (Codoms fs) => GPiMZipWith ('NS n) u v fs
instance GPiMZipWith 'NZ u v fs
instance (GMZipWith ('NS n) u fs, GMZipWith ('NS n) v fs, GMLZipWith n u v (Codoms fs), GMRZipWith n u v (Codoms fs)) => GMZipWith ('NS n) (u ':++: v) fs
instance (GMRZipWith n u v (Codoms fs), GMZipWithFail n (u ':++: v) (Codoms fs)) => GMRZipWith ('NS n) u v fs
instance GMRZipWith 'NZ u v fs
instance (GMLZipWith n u v (Codoms fs), GMZipWithFail n (u ':++: v) (Codoms fs)) => GMLZipWith ('NS n) u v fs
instance GMLZipWith 'NZ u v fs
instance GMZipWithFail 'NZ u fs
instance GMTZipWith n fs => GMZipWith n 'UT fs
instance GMTZipWith n (Codoms fs) => GMTZipWith ('NS n) fs
instance GMTZipWith 'NZ fs
instance GMZipWith n 'UV fs
instance (MZipWithG n f rf (Codoms fs), rf ~ Rep (f :$: Doms fs), Doms fs ~ Pars (f :$: Doms fs), MGeneric (f :$: Doms fs)) => MZipWithG ('NS n) f rf fs
instance (fs ~ Pars (f :$: fs), rf ~ Rep (f :$: fs), MGeneric (f :$: fs)) => MZipWithG 'NZ f rf fs

module Data.MGeneric.Instances
data Test a b c
Test :: ([(a, [b])], c) -> Test a b c
instance (MZipWithG n Test (Rep (Test :$: LCodoms n '[f, g, h])) '[f, g, h], GMZipWith n (Rep (Test :$: LCodoms n '[f, g, h])) '[f, g, h]) => MZipWith n Test '[f, g, h]
instance Unapply (Test a b c) Test '[a, b, c]
instance MGeneric (Test a0 b0 c0)
instance (Show a, Show b, Show c) => Show (Test a b c)
instance (MZipWithG n First (Rep (First :$: LCodoms n '[f])) '[f], GMZipWith n (Rep (First :$: LCodoms n '[f])) '[f]) => MZipWith n First '[f]
instance (MZipWithG n Last (Rep (Last :$: LCodoms n '[f])) '[f], GMZipWith n (Rep (Last :$: LCodoms n '[f])) '[f]) => MZipWith n Last '[f]
instance (MZipWithG n Sum (Rep (Sum :$: LCodoms n '[f])) '[f], GMZipWith n (Rep (Sum :$: LCodoms n '[f])) '[f]) => MZipWith n Sum '[f]
instance (MZipWithG n Product (Rep (Product :$: LCodoms n '[f])) '[f], GMZipWith n (Rep (Product :$: LCodoms n '[f])) '[f]) => MZipWith n Product '[f]
instance (MZipWithG n (,,,,,,,,) (Rep ((,,,,,,,,) :$: LCodoms n '[f, g, h, i, j, k, l, m, o])) '[f, g, h, i, j, k, l, m, o], GMZipWith n (Rep ((,,,,,,,,) :$: LCodoms n '[f, g, h, i, j, k, l, m, o])) '[f, g, h, i, j, k, l, m, o]) => MZipWith n (,,,,,,,,) '[f, g, h, i, j, k, l, m, o]
instance (MZipWithG n (,,,,,,,) (Rep ((,,,,,,,) :$: LCodoms n '[f, g, h, i, j, k, l, m])) '[f, g, h, i, j, k, l, m], GMZipWith n (Rep ((,,,,,,,) :$: LCodoms n '[f, g, h, i, j, k, l, m])) '[f, g, h, i, j, k, l, m]) => MZipWith n (,,,,,,,) '[f, g, h, i, j, k, l, m]
instance (MZipWithG n (,,,,,,) (Rep ((,,,,,,) :$: LCodoms n '[f, g, h, i, j, k, l])) '[f, g, h, i, j, k, l], GMZipWith n (Rep ((,,,,,,) :$: LCodoms n '[f, g, h, i, j, k, l])) '[f, g, h, i, j, k, l]) => MZipWith n (,,,,,,) '[f, g, h, i, j, k, l]
instance (MZipWithG n (,,,,,) (Rep ((,,,,,) :$: LCodoms n '[f, g, h, i, j, k])) '[f, g, h, i, j, k], GMZipWith n (Rep ((,,,,,) :$: LCodoms n '[f, g, h, i, j, k])) '[f, g, h, i, j, k]) => MZipWith n (,,,,,) '[f, g, h, i, j, k]
instance (MZipWithG n (,,,,) (Rep ((,,,,) :$: LCodoms n '[f, g, h, i, j])) '[f, g, h, i, j], GMZipWith n (Rep ((,,,,) :$: LCodoms n '[f, g, h, i, j])) '[f, g, h, i, j]) => MZipWith n (,,,,) '[f, g, h, i, j]
instance (MZipWithG n (,,,) (Rep ((,,,) :$: LCodoms n '[f, g, h, i])) '[f, g, h, i], GMZipWith n (Rep ((,,,) :$: LCodoms n '[f, g, h, i])) '[f, g, h, i]) => MZipWith n (,,,) '[f, g, h, i]
instance (MZipWithG n (,,) (Rep ((,,) :$: LCodoms n '[f, g, h])) '[f, g, h], GMZipWith n (Rep ((,,) :$: LCodoms n '[f, g, h])) '[f, g, h]) => MZipWith n (,,) '[f, g, h]
instance (MZipWithG n (,) (Rep ((,) :$: LCodoms n '[f, g])) '[f, g], GMZipWith n (Rep ((,) :$: LCodoms n '[f, g])) '[f, g]) => MZipWith n (,) '[f, g]
instance (MZipWithG n () (Rep (() :$: LCodoms n '[])) '[], GMZipWith n (Rep (() :$: LCodoms n '[])) '[]) => MZipWith n () '[]
instance (MZipWithG n Ordering (Rep (Ordering :$: LCodoms n '[])) '[], GMZipWith n (Rep (Ordering :$: LCodoms n '[])) '[]) => MZipWith n Ordering '[]
instance (MZipWithG n Bool (Rep (Bool :$: LCodoms n '[])) '[], GMZipWith n (Rep (Bool :$: LCodoms n '[])) '[]) => MZipWith n Bool '[]
instance (MZipWithG n Either (Rep (Either :$: LCodoms n '[f, g])) '[f, g], GMZipWith n (Rep (Either :$: LCodoms n '[f, g])) '[f, g]) => MZipWith n Either '[f, g]
instance (MZipWithG n Maybe (Rep (Maybe :$: LCodoms n '[f])) '[f], GMZipWith n (Rep (Maybe :$: LCodoms n '[f])) '[f]) => MZipWith n Maybe '[f]
instance (MZipWithG n [] (Rep ([] :$: LCodoms n '[f])) '[f], GMZipWith n (Rep ([] :$: LCodoms n '[f])) '[f]) => MZipWith n [] '[f]
instance MTraversable Sum '[a -> b] t
instance MTraversable Product '[a -> b] t
instance MTraversable First '[a -> b] t
instance MTraversable Last '[a -> b] t
instance MTraversable (,,,,,,,,) '[a -> a', b -> b', c -> c', d -> d', e -> e', f -> f', g -> g', h -> h', i -> i'] t
instance MTraversable (,,,,,,,) '[a -> a', b -> b', c -> c', d -> d', e -> e', f -> f', g -> g', h -> h'] t
instance MTraversable (,,,,,,) '[a -> a', b -> b', c -> c', d -> d', e -> e', f -> f', g -> g'] t
instance MTraversable (,,,,,) '[a -> a', b -> b', c -> c', d -> d', e -> e', f -> f'] t
instance MTraversable (,,,,) '[a -> a', b -> b', c -> c', d -> d', e -> e'] t
instance MTraversable (,,,) '[a -> a', b -> b', c -> c', d -> d'] t
instance MTraversable (,,) '[a -> a', b -> b', c -> c'] t
instance MTraversable (,) '[a -> a', b -> b'] t
instance MTraversable () '[] t
instance MTraversable Ordering '[] t
instance MTraversable Bool '[] t
instance MTraversable Either '[a -> a', b -> b'] t
instance MTraversable Maybe '[a -> a'] t
instance MTraversable [] '[a -> a'] t
instance MFoldable Identity '[a]
instance MFoldable Sum '[a]
instance MFoldable Product '[a]
instance MFoldable First '[a]
instance MFoldable Last '[a]
instance MFoldable (,,,,,,,,) '[a, b, c, d, e, f, g, h, i]
instance MFoldable (,,,,,,,) '[a, b, c, d, e, f, g, h]
instance MFoldable (,,,,,,) '[a, b, c, d, e, f, g]
instance MFoldable (,,,,,) '[a, b, c, d, e, f]
instance MFoldable (,,,,) '[a, b, c, d, e]
instance MFoldable (,,,) '[a, b, c, d]
instance MFoldable (,,) '[a, b, c]
instance MFoldable (,) '[a, b]
instance MFoldable () '[]
instance MFoldable Ordering '[]
instance MFoldable Bool '[]
instance MFoldable Either '[a, b]
instance MFoldable Maybe '[a]
instance MFoldable [] '[a]
instance MFunctor (->) '[a' -> a, b -> b'] '['ContraV, 'CoV]
instance MFunctor Sum '[a -> b] '['CoV]
instance MFunctor Product '[a -> b] '['CoV]
instance MFunctor First '[a -> b] '['CoV]
instance MFunctor Last '[a -> b] '['CoV]
instance MFunctor (,,,,,,,,) '[a -> a', b -> b', c -> c', d -> d', e -> e', f -> f', g -> g', h -> h', i -> i'] '['CoV, 'CoV, 'CoV, 'CoV, 'CoV, 'CoV, 'CoV, 'CoV, 'CoV]
instance MFunctor (,,,,,,,) '[a -> a', b -> b', c -> c', d -> d', e -> e', f -> f', g -> g', h -> h'] '['CoV, 'CoV, 'CoV, 'CoV, 'CoV, 'CoV, 'CoV, 'CoV]
instance MFunctor (,,,,,,) '[a -> a', b -> b', c -> c', d -> d', e -> e', f -> f', g -> g'] '['CoV, 'CoV, 'CoV, 'CoV, 'CoV, 'CoV, 'CoV]
instance MFunctor (,,,,,) '[a -> a', b -> b', c -> c', d -> d', e -> e', f -> f'] '['CoV, 'CoV, 'CoV, 'CoV, 'CoV, 'CoV]
instance MFunctor (,,,,) '[a -> a', b -> b', c -> c', d -> d', e -> e'] '['CoV, 'CoV, 'CoV, 'CoV, 'CoV]
instance MFunctor (,,,) '[a -> a', b -> b', c -> c', d -> d'] '['CoV, 'CoV, 'CoV, 'CoV]
instance MFunctor (,,) '[a -> a', b -> b', c -> c'] '['CoV, 'CoV, 'CoV]
instance MFunctor (,) '[a -> a', b -> b'] '['CoV, 'CoV]
instance MFunctor () '[] '[]
instance MFunctor Ordering '[] '[]
instance MFunctor Bool '[] '[]
instance MFunctor Either '[a -> a', b -> b'] '['CoV, 'CoV]
instance MFunctor Maybe '[a -> a'] '['CoV]
instance MFunctor [] '[a -> a'] '['CoV]
instance MGeneric (Identity a0)
instance MGeneric (Const a0 b0)
instance MGeneric (Endo a0)
instance MGeneric (Sum a0)
instance MGeneric (Product a0)
instance MGeneric (First a0)
instance MGeneric (Last a0)
instance MGeneric (a0, b0, c0, d0, e0, f0, g0, h0, i0)
instance MGeneric (a0, b0, c0, d0, e0, f0, g0, h0)
instance MGeneric (a0, b0, c0, d0, e0, f0, g0)
instance MGeneric (a0, b0, c0, d0, e0, f0)
instance MGeneric (a0, b0, c0, d0, e0)
instance MGeneric (a0, b0, c0, d0)
instance MGeneric (a0, b0, c0)
instance MGeneric (a0, b0)
instance MGeneric ()
instance MGeneric Ordering
instance MGeneric Bool
instance MGeneric (Either a0 b0)
instance MGeneric (Maybe a0)
instance MGeneric [a0]