Darcs.Witnesses.Ordered

Documentation

data EqCheck where

Constructors

IsEq :: EqCheck

NotEq :: EqCheck

Instances

Eq EqCheck

Show EqCheck

isEq :: EqCheck -> Bool

data a1 :> a2

Constructors

a1 :> a2

Instances

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

(Show2 a, Show2 b) => Show2 (:> a b)

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

data a1 :< a2

Constructors

a1 :< a2

Instances

(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

Show2 a => Show (FL a)

Show2 a => Show2 (FL a)

(MyEq p, Commute p) => MyEq (FL p)

(Invert p, Commute p) => Invert (FL p)

ReadPatch p => ReadPatch (FL p)

(Conflict p, Apply p, Effect p, ShowPatch p) => ShowPatch (FL p)

Commute p => Commute (FL p)

Apply p => Apply (FL p)

(Conflict p, Patchy p) => Patchy (FL p)

Effect p => Effect (FL p)

Conflict p => Conflict (FL p)

FromPrim p => FromPrims (FL p)

RepoPatchBase p => RepoPatch (FL p)

data RL a where

Constructors

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

NilRL :: RL a

Instances

(MyEq p, Commute p) => MyEq (RL p)

(Commute p, Invert p) => Invert (RL p)

ReadPatch p => ReadPatch (RL p)

(Conflict p, Apply p, ShowPatch p) => ShowPatch (RL p)

Commute p => Commute (RL p)

Apply p => Apply (RL p)

(Conflict p, Patchy p) => Patchy (RL p)

Effect p => Effect (RL p)

Conflict p => Conflict (RL p)

FromPrim p => FromPrims (RL p)

data Proof a where

Constructors

Proof :: a -> Proof a

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

isShorterThanRL :: RL a -> Int -> Bool

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

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

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

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

filterE :: (a -> EqCheck) -> [a] -> [Proof a]

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

concatReverseFL :: FL (RL a) -> RL a

headRL :: RL a -> FlippedSeal a

class MyEq p where

Methods

unsafeCompare :: p -> p -> Bool

(=\/=) :: p -> p -> EqCheck

(=/\=) :: p -> p -> EqCheck

Instances

MyEq DirPatchType

MyEq FilePatchType

MyEq Prim

MyEq Patch

MyEq RealPatch

MyEq WPatchInfo

(MyEq p, Commute p) => MyEq (RL p)

(MyEq p, Commute p) => MyEq (FL p)

MyEq p => MyEq (Named p)

MyEq p => MyEq (PatchInfoAnd p)

MyEq p => MyEq (PatchChoice p)

MyEq p => MyEq (TaggedPatch p)

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

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

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

nullRL :: RL a -> Bool

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

data a1 :>> a2

Constructors

a1 :>> a2

unsafeCoercePStart :: a -> a

unsafeCoercePEnd :: a -> a

unsafeCoerceP :: a -> a

unsafeCoerceP2 :: t -> t

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