darcs

Safe HaskellSafe-Infered

Darcs.Witnesses.Ordered

Synopsis

Documentation

data a1 :> a2

Constructors

a1 :> a2 

Instances

(MyEq a, MyEq b) => Eq (:> a b) 
(Show2 a, Show2 b) => Show (:> a b) 
(Show2 a, Show2 b) => Show2 (:> a b) 
(Show2 a, Show2 b) => Show1 (:> a b) 
(MyEq a, MyEq b) => MyEq (:> a b) 

data a1 :< a2

Constructors

a1 :< a2 

Instances

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

data a1 :\/: a2

Constructors

a1 :\/: a2 

Instances

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

data a1 :/\: a2

Constructors

a1 :/\: a2 

data a1 :||: a2

Constructors

a1 :||: a2 

data FL a where

Constructors

:>: :: a -> FL a -> FL a 
NilFL :: FL a 

Instances

WL FL 
Show2 a => Show (FL a) 
Show2 a => Show2 (FL a) 
Show2 a => Show1 (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) 
(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) 

data RL a where

Constructors

:<: :: a -> RL a -> RL a 
NilRL :: RL a 

Instances

WL RL 
Show2 a => Show (RL a) 
Show2 a => Show2 (RL a) 
Show2 a => Show1 (RL a) 
(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) 
(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) 

lengthFL :: FL a -> Int

mapFL :: (a -> b) -> FL a -> [b]

mapFL_FL :: (a -> b) -> FL a -> FL b

spanFL :: (a -> Bool) -> FL a -> FL a :> FL a

foldlFL :: (a -> b -> a) -> a -> FL b -> a

allFL :: (a -> Bool) -> FL a -> Bool

anyFL :: (a -> Bool) -> FL a -> Bool

filterFL :: (a -> Bool) -> FL a -> [Sealed2 a]

splitAtFL :: Int -> FL a -> FL a :> FL a

splitAtRL :: Int -> RL a -> RL a :< RL a

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

foldlRL :: (a -> b -> a) -> a -> RL b -> a

lengthRL :: RL a -> Int

mapRL :: (a -> b) -> RL a -> [b]

mapRL_RL :: (a -> b) -> RL a -> RL b

zipWithFL :: (a -> p -> q) -> [a] -> FL p -> FL q

filterFLFL :: (p -> EqCheck) -> FL p -> FL p

filterRL :: (p -> Bool) -> RL p -> [Sealed2 p]

reverseFL :: FL a -> RL a

reverseRL :: RL a -> FL a

(+>+) :: FL a -> FL a -> FL a

(+<+) :: RL a -> RL a -> RL a

nullFL :: FL a -> Bool

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

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

nullRL :: RL a -> Bool

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

dropWhileFL :: (a -> Bool) -> FL a -> FlippedSeal (FL a)

dropWhileRL :: (a -> Bool) -> RL a -> Sealed (RL a)

spanFL_M :: forall a m. Monad m => (a -> m Bool) -> FL a -> m (FL a :> FL a)

eqFL :: MyEq a => FL a -> FL a -> EqCheck

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 -> FL a -> EqCheck

eqFLUnsafe :: MyEq a => FL a -> FL a -> Bool