- 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
- data RL a x z where
- 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
forall z . (a1 x z) :> (a2 z y) |
forall z . (a1 z y) :< (a2 x z) |
forall z . (a1 z x) :\/: (a2 z y) |
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, IsHunk p, PatchListFormat p, ShowPatch p) => ShowPatch (FL p) | |
(PatchListFormat p, ShowPatchBasic p) => ShowPatchBasic (FL p) | |
Apply p => Apply (FL p) | |
(IsHunk p, PatchListFormat p, Patchy p) => Patchy (FL p) | |
RepairToFL p => Repair (FL p) | |
Check p => Check (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) |
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, IsHunk p, PatchListFormat p, ShowPatch p) => ShowPatch (RL p) | |
(PatchListFormat p, ShowPatchBasic p) => ShowPatchBasic (RL p) | |
Apply p => Apply (RL p) | |
(IsHunk p, PatchListFormat p, Patchy p) => Patchy (RL p) | |
Check p => Check (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) |
isShorterThanRL :: RL a x y -> Int -> BoolSource
filterFLFL :: (forall x y. p x y -> EqCheck x y) -> FL p w z -> FL p w zSource
consRLSealed :: a y z -> FlippedSeal (RL a) y -> FlippedSeal (RL a) zSource
dropWhileFL :: (forall x y. a x y -> Bool) -> FL a r v -> FlippedSeal (FL a) vSource
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