Safe Haskell | Safe-Infered |
---|
- derive :: Name -> Q [Dec]
- type Equal a b = IsEQ (Compare a b)
- data U = U
- newtype F a = F a
- data a :*: b = a :*: b
- data Void
- newtype N a = N a
- data a :+: b
- newtype Par1 f a = Par1 (f a)
- newtype Dep a = Dep a
- newtype Rec a = Rec a
- type family Rep a
- class Generic a where
- unDep :: Dep t -> t
- unRec :: Rec t -> t
- mapRec :: (t -> a) -> Rec t -> Rec a
- unPar1 :: Par1 t t1 -> t t1
- unN :: N t -> t
- foldN :: (b -> c) -> N b -> c
- mapN :: (b1 -> b) -> N b1 -> N b
- foldPlus :: (t1 -> t) -> (t2 -> t) -> :+: t1 t2 -> t
- mapPlus :: (t -> b) -> (t1 -> b1) -> :+: t t1 -> :+: b b1
- mapTimes :: (t -> a) -> (t1 -> b) -> :*: t t1 -> :*: a b
- foldTimes :: (t3 -> t4 -> t) -> (t1 -> t3) -> (t2 -> t4) -> :*: t1 t2 -> t
- type family DistMaybePlus a b
- data Z
- data S n
- type family Add n m
- type family CountRs rep
- newtype DCsOf t sum = DCsOf sum
- unDCsOf :: DCsOf t t1 -> t1
- (|||) :: (DCsOf t sumL -> a) -> (DCsOf t sumR -> a) -> DCsOf t (sumL :+: sumR) -> a
- type family sum :-: sum2
- class Embed sub sup
- embed :: Embed sub sup => sub -> sup
- inject :: Embed (N a) sum => a -> sum
- class Partition sup subL subR
- project :: Partition sum (N a) (sum :-: N a) => sum -> Either a (sum :-: N a)
- partition :: Partition sup sub (sup :-: sub) => sup -> Either sub (sup :-: sub)
- one :: (dc -> a) -> DCsOf (Range dc) (N dc) -> a
- (.|.) :: ~ * (Range dc) (Range dc1) => (dc -> a) -> (dc1 -> a) -> DCsOf (Range dc1) (:+: (N dc) (N dc1)) -> a
- (.||) :: (dc -> a) -> (DCsOf (Range dc) sumR -> a) -> DCsOf (Range dc) (:+: (N dc) sumR) -> a
- (||.) :: (DCsOf (Range dc) sumL -> a) -> (dc -> a) -> DCsOf (Range dc) (:+: sumL (N dc)) -> a
- type family Tag dc
- type family Range dc
- class (Generic dc, DT (Range dc)) => DC dc where
- type family DCs t
- type Disbanded t = DCsOf t (DCs t)
- class Each IsDCOf (DCs t) => DT t where
- class (Partition (DCs (Range dc)) (N dc) (DCs (Range dc) :-: N dc), Embed (N dc) (DCs (Range dc))) => IsDCOf dc
- disbanded :: Embed (N dc) (DCs (Range dc)) => dc -> Disbanded (Range dc)
- band :: forall t. Each (ConDCOf t) (DCs t) => Disbanded t -> t
- class (Range dc ~ t, DC dc) => ConDCOf t dc
- inject :: Embed (N dc) sum => dc -> sum
- partition :: Partition sum sub (sum :-: sub) => DCsOf t sum -> Either (DCsOf t sub) (DCsOf t (sum :-: sub))
- project :: Partition sum (N dc) (sum :-: N dc) => DCsOf (Range dc) sum -> Either dc (DCsOf (Range dc) (sum :-: N dc))
- reps :: EachGeneric sum => DCsOf t sum -> EachRep sum
- type family EachRep sum
- class EachGeneric sum where
- exact_case :: (DT t, Partition (DCs t) dcs (DCs t :-: dcs)) => (DCsOf t (DCs t :-: dcs) -> a) -> t -> (DCsOf t dcs -> a) -> a
- ig_from :: (EachGeneric (DCs t), DT t) => t -> EachRep (DCs t)
- encode :: Serialize a => a -> Type
Documentation
a :*: b |
N a |
cxt a => Each_ cxt (N a) | |
(Generic dc, ~ * (Just (N dc')) (FindDCs (Tag dc) (DCs t)), HComposRs cnv (Rep dc) (Rep dc'), DC dc', ~ * (Range dc') t, DT t) => HCompos cnv (N dc) t | |
Generic a => EachGeneric (N a) | |
(~ * (Locate x sup) (Just path), InjectAt path x sup) => Embed (N x) sup | |
Partition_N (Elem x subL) x subL subR => Partition (N x) subL subR | |
InjectAt (Here a) a (N a) |
(Each_ cxt a, Each_ cxt b) => Each_ cxt (:+: a b) | |
(HCompos cnv a t, HCompos cnv b t) => HCompos cnv (:+: a b) t | |
InjectAt path a r => InjectAt (TurnRight path) a (:+: l r) | |
InjectAt path a l => InjectAt (TurnLeft path) a (:+: l r) | |
(Eq a, Eq b) => Eq (:+: a b) | |
(Ord a, Ord b) => Ord (:+: a b) | |
(Read a, Read b) => Read (:+: a b) | |
(Show a, Show b) => Show (:+: a b) | |
(EachGeneric a, EachGeneric b) => EachGeneric (:+: a b) | |
(Embed l sup, Embed r sup) => Embed (:+: l r) sup | |
(Partition a subL subR, Partition b subL subR) => Partition (:+: a b) subL subR |
type family DistMaybePlus a b Source
DCsOf sum |
(.|.) :: ~ * (Range dc) (Range dc1) => (dc -> a) -> (dc1 -> a) -> DCsOf (Range dc1) (:+: (N dc) (N dc1)) -> aSource
class (Partition (DCs (Range dc)) (N dc) (DCs (Range dc) :-: N dc), Embed (N dc) (DCs (Range dc))) => IsDCOf dc Source
partition :: Partition sum sub (sum :-: sub) => DCsOf t sum -> Either (DCsOf t sub) (DCsOf t (sum :-: sub))Source
project :: Partition sum (N dc) (sum :-: N dc) => DCsOf (Range dc) sum -> Either dc (DCsOf (Range dc) (sum :-: N dc))Source
reps :: EachGeneric sum => DCsOf t sum -> EachRep sumSource
class EachGeneric sum whereSource
Generic a => EachGeneric (N a) | |
(EachGeneric a, EachGeneric b) => EachGeneric (:+: a b) |