Darcs.Witnesses.Ordered

Documentation

data (a1 :> a2) x y

Constructors

forall z . (a1 x z) :> (a2 z y)

Instances

(Show2 a, Show2 b) => Show2 (:> a b)
(MyEq a, MyEq b) => MyEq (:> a b)
(Show2 a, Show2 b) => Show (:> a b x y)

data (a1 :< a2) x y

Constructors

forall z . (a1 z y) :< (a2 x z)

Instances

(MyEq a, MyEq b) => MyEq (:< a b)

data (a1 :\/: a2) x y

Constructors

forall z . (a1 z x) :\/: (a2 z y)

Instances

(Show2 a, Show2 b) => Show2 (:\/: a b)
(Show2 a, Show2 b) => Show (:\/: a b x y)

data (a1 :/\: a2) x y

Constructors

forall z . (a1 x z) :/\: (a2 y z)

data (a1 :||: a2) x y

Constructors

(a1 x y) :||: (a2 x y)

data FL a x z where

Constructors

:>: :: a x y -> FL a y z -> FL a x z
NilFL :: FL a x x

Instances

Show2 a => Show2 (FL a)
(MyEq p, Commute p) => MyEq (FL p)
Commute p => Commute (FL p)
Merge p => Merge (FL p)
(Invert p, Commute p) => Invert (FL p)
PatchInspect p => PatchInspect (FL p)
Effect p => Effect (FL p)
Conflict p => Conflict (FL p)
FromPrim p => FromPrims (FL p)
ReadPatch p => ReadPatch (FL p)
(Apply p, Effect p, ShowPatch p) => ShowPatch (FL p)
Apply p => Apply (FL p)
(Effect p, Patchy p) => Patchy (FL p)
RepoPatchBase p => RepoPatch (FL p)
Show2 a => Show (FL a x z)

data RL a x z where

Constructors

:<: :: a y z -> RL a x y -> RL a x z
NilRL :: RL a x x

Instances

(MyEq p, Commute p) => MyEq (RL p)
Commute p => Commute (RL p)
Merge p => Merge (RL p)
(Commute p, Invert p) => Invert (RL p)
PatchInspect p => PatchInspect (RL p)
Effect p => Effect (RL p)
Conflict p => Conflict (RL p)
FromPrim p => FromPrims (RL p)
ReadPatch p => ReadPatch (RL p)
(Apply p, Effect p, ShowPatch p) => ShowPatch (RL p)
Apply p => Apply (RL p)
(Effect p, Patchy p) => Patchy (RL p)

lengthFL :: FL a x z -> Int

mapFL :: (forall w z. a w z -> b) -> FL a x y -> [b]

mapFL_FL :: (forall w y. a w y -> b w y) -> FL a x z -> FL b x z

spanFL :: (forall w y. a w y -> Bool) -> FL a x z -> (FL a :> FL a) x z

foldlFL :: (forall w y. a -> b w y -> a) -> a -> FL b x z -> a

allFL :: (forall x y. a x y -> Bool) -> FL a w z -> Bool

anyFL :: (forall x y. a x y -> Bool) -> FL a w z -> Bool

filterFL :: (forall x y. a x y -> Bool) -> FL a w z -> [Sealed2 a]

splitAtFL :: Int -> FL a x z -> (FL a :> FL a) x z

splitAtRL :: Int -> RL a x z -> (RL a :< RL a) x z

bunchFL :: Int -> FL a x y -> FL (FL a) x y

foldlRL :: (forall w y. a -> b w y -> a) -> a -> RL b x z -> a

lengthRL :: RL a x z -> Int

isShorterThanRL :: RL a x y -> Int -> Bool

mapRL :: (forall w z. a w z -> b) -> RL a x y -> [b]

mapRL_RL :: (forall w y. a w y -> b w y) -> RL a x z -> RL b x z

zipWithFL :: (forall x y. a -> p x y -> q x y) -> [a] -> FL p w z -> FL q w z

filterFLFL :: (forall x y. p x y -> EqCheck x y) -> FL p w z -> FL p w z

filterRL :: (forall x y. p x y -> Bool) -> RL p a b -> [Sealed2 p]

reverseFL :: FL a x z -> RL a x z

reverseRL :: RL a x z -> FL a x z

(+>+) :: FL a x y -> FL a y z -> FL a x z

(+<+) :: RL a y z -> RL a x y -> RL a x z

nullFL :: FL a x z -> Bool

concatFL :: FL (FL a) x z -> FL a x z

concatRL :: RL (RL a) x z -> RL a x z

consRLSealed :: a y z -> FlippedSeal (RL a) y -> FlippedSeal (RL a) z

nullRL :: RL a x z -> Bool

toFL :: [FreeLeft a] -> Sealed (FL a x)

data (a1 :>> a2) y

Constructors

forall z . (a1 z) :>> (a2 z y)

dropWhileFL :: (forall x y. a x y -> Bool) -> FL a r v -> FlippedSeal (FL a) v

dropWhileRL :: (forall x y. a x y -> Bool) -> RL a r v -> Sealed (RL a r)

spanFL_M :: forall a m x z. Monad m => (forall w y. a w y -> m Bool) -> FL a x z -> m ((FL a :> FL a) x z)