darcs-beta-2.7.99.2: a distributed, interactive, smart revision control system

Safe HaskellSafe-Infered

Darcs.Witnesses.Ordered

Synopsis

Documentation

data (a1 :> a2) x y Source

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) => Show1 (:> a b x) 
(MyEq a, MyEq b) => Eq (:> a b x y) 
(Show2 a, Show2 b) => Show (:> a b x y) 

data (a1 :< a2) x y Source

Constructors

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

Instances

(MyEq a, MyEq b) => MyEq (:< a b) 
(MyEq a, MyEq b) => Eq (:< a b x y) 

data (a1 :\/: a2) x y Source

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 Source

Constructors

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

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

Constructors

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

data FL a x z whereSource

Constructors

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

Instances

WL FL 
Show2 a => Show2 (FL a) 
(MyEq p, Commute p) => MyEq (FL p) 
Commute p => Commute (FL p) 
(Invert p, Commute p) => Invert (FL p) 
Merge p => Merge (FL p) 
PatchInspect p => PatchInspect (FL p) 
(ReadPatch p, PatchListFormat p) => ReadPatch (FL p) 
Apply p => Apply (FL p) 
RepairToFL p => Repair (FL p) 
Check p => Check (FL p) 
(Apply p, IsHunk p, PatchListFormat p, ShowPatch p) => ShowPatch (FL p) 
(PatchListFormat p, ShowPatchBasic p) => ShowPatchBasic (FL p) 
(IsHunk p, PatchListFormat p, Patchy p) => Patchy (FL p) 
FromPrim p => FromPrims (FL p) 
FromPrim p => FromPrim (FL p) 
PrimPatchBase p => PrimPatchBase (FL p) 
Effect p => Effect (FL p) 
CommuteNoConflicts p => CommuteNoConflicts (FL p) 
(CommuteNoConflicts p, Conflict p) => Conflict (FL p) 
Show2 a => Show1 (FL a x) 
Show2 a => Show (FL a x z) 

data RL a x z whereSource

Constructors

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

Instances

WL RL 
Show2 a => Show2 (RL a) 
(MyEq p, Commute p) => MyEq (RL p) 
Commute p => Commute (RL p) 
(Commute p, Invert p) => Invert (RL p) 
Merge p => Merge (RL p) 
PatchInspect p => PatchInspect (RL p) 
(ReadPatch p, PatchListFormat p) => ReadPatch (RL p) 
Apply p => Apply (RL p) 
Check p => Check (RL p) 
(Apply p, IsHunk p, PatchListFormat p, ShowPatch p) => ShowPatch (RL p) 
(PatchListFormat p, ShowPatchBasic p) => ShowPatchBasic (RL p) 
(IsHunk p, PatchListFormat p, Patchy p) => Patchy (RL p) 
FromPrim p => FromPrims (RL p) 
PrimPatchBase p => PrimPatchBase (RL p) 
Effect p => Effect (RL p) 
CommuteNoConflicts p => CommuteNoConflicts (RL p) 
(CommuteNoConflicts p, Conflict p) => Conflict (RL p) 
Show2 a => Show1 (RL a x) 
Show2 a => Show (RL a x z) 

lengthFL :: FL a x z -> IntSource

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

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

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

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

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

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

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

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

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

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

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

lengthRL :: RL a x z -> IntSource

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

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

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

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

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

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

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

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

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

nullFL :: FL a x z -> BoolSource

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

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

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

nullRL :: RL a x z -> BoolSource

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

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

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

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)Source

eqFL :: MyEq a => FL a x y -> FL a x z -> EqCheck y zSource

Check that two FLs are equal element by element. This differs from the MyEq instance for FL which uses commutation.

eqFLRev :: MyEq a => FL a x z -> FL a y z -> EqCheck x ySource

eqFLUnsafe :: MyEq a => FL a x y -> FL a z w -> BoolSource