Data.Yoko

Documentation

type Equal a b = IsEQ (Compare a b)

data U

Constructors

U

Instances

Applicative (Idiom cnv) => HComposRs cnv U U

data a :*: b

Constructors

a :*: b

Instances

(HComposRs cnv a a', HComposRs cnv b b') => HComposRs cnv (:*: a b) (:*: a' b')

data Void

newtype N a

Constructors

N a

Instances

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)

data a :+: b

Constructors

L a

R b

Instances

(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

newtype Par1 f a

Constructors

Par1 (f a)

newtype Par2 f a b

Constructors

Par2 (f a b)

newtype Dep a

Constructors

Dep a

Instances

Applicative (Idiom cnv) => HComposRs cnv (Dep a) (Dep a)

newtype Rec a

Constructors

Rec a

Instances

HCompos cnv a b => HComposRs cnv (Rec a) (Rec b)

type family Rep a

class Generic a where

Methods

rep :: a -> Rep a

obj :: Rep a -> a

unDep :: Dep t -> t

unRec :: Rec t -> t

mapRec :: (t -> a) -> Rec t -> Rec a

unPar1 :: Par1 t t1 -> t t1

unPar2 :: Par2 t t1 t2 -> t t1 t2

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

Constructors

DCsOf sum

Instances

Each_ cxt sum => Each_ cxt (DCsOf t sum)

HCompos cnv sum t => HCompos cnv (DCsOf a sum) t

Functor (DCsOf t)

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

Instances

(~ * (Locate x sup) (Just path), InjectAt path x sup) => Embed (N x) sup

(Embed l sup, Embed r sup) => Embed (:+: l r) sup

embed :: Embed sub sup => sub -> sup

inject :: Embed (N a) sum => a -> sum

class Partition sup subL subR

Instances

Partition_N (Elem x subL) x subL subR => Partition (N x) subL subR

(Partition a subL subR, Partition b subL subR) => Partition (:+: a b) 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)

type family Tag dc

type family Range dc

class (Generic dc, DT (Range dc)) => DC dc where

Methods

rejoin :: dc -> Range dc

type family DCs t

type Disbanded t = DCsOf t (DCs t)

class Each IsDCOf (DCs t) => DT t where

Methods

disband :: t -> Disbanded t

class (Partition (DCs (Range dc)) (N dc) (DCs (Range dc) :-: N dc), Embed (N dc) (DCs (Range dc))) => IsDCOf dc

Instances

(Partition (DCs (Range dc)) (N dc) (:-: (DCs (Range dc)) (N dc)), Embed (N dc) (DCs (Range dc))) => IsDCOf dc

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

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

Instances

(~ * (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

Methods

repEach :: sum -> EachRep sum

objEach :: EachRep sum -> sum

Instances

Generic a => EachGeneric (N a)

(EachGeneric a, EachGeneric b) => EachGeneric (:+: a b)

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 :: (DT t, EachGeneric (DCs t)) => t -> EachRep (DCs t)