darcs-2.8.4: a distributed, interactive, smart revision control system

Safe Haskell | None

Darcs.Witnesses.Ordered

Synopsis

- data (a1 :> a2) x y = forall z . (a1 x z) :> (a2 z y)
- data (a1 :< a2) x y = forall z . (a1 z y) :< (a2 x z)
- data (a1 :\/: a2) x y = forall z . (a1 z x) :\/: (a2 z y)
- data (a1 :/\: a2) x y = forall z . (a1 x z) :/\: (a2 y z)
- data (a1 :||: a2) x y = (a1 x y) :||: (a2 x y)
- data FL a x z where
  - :>: :: a x y -> FL a y z -> FL a x z
  - NilFL :: FL a x x
- data RL a x z where
  - :<: :: a y z -> RL a x y -> RL a x z
  - NilRL :: RL a x x
- 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)
- 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)
- eqFL :: MyEq a => FL a x y -> FL a x z -> EqCheck y z
- eqFLRev :: MyEq a => FL a x z -> FL a y z -> EqCheck x y
- eqFLUnsafe :: MyEq a => FL a x y -> FL a z w -> Bool

# 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) => 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

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

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

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 where

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

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)

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

Check that two `FL`s 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 y

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