Safe Haskell	None
Language	Haskell2010

Data.Diff

Contents

Generic implementations

Synopsis

Documentation

class (Eq a, Patch (Edit a)) => Diff a where Source #

Diffable types

uncurry diff . undiff = id
undiff . uncurry diff = id
patch (diff x y) x = Just y

Associated Types

type Edit a Source #

Methods

diff :: a -> a -> Edit a Source #

Generate a patch between two values, that can be used to transform one value into the other

patch :: Edit a -> a -> Maybe a Source #

Apply a patch to a value

undiff :: Edit a -> (a, a) Source #

Deconstruct a patch to recover the original value used to create it, and the application of the patch to that original value

diff :: DefaultDiff (Edit a) a => a -> a -> Edit a Source #

Generate a patch between two values, that can be used to transform one value into the other

patch :: DefaultDiff (Edit a) a => Edit a -> a -> Maybe a Source #

Apply a patch to a value

undiff :: DefaultDiff (Edit a) a => Edit a -> (a, a) Source #

Deconstruct a patch to recover the original value used to create it, and the application of the patch to that original value

Instances

Diff Bool Source #
Associated Types type Edit Bool :: * Source # Methods diff :: Bool -> Bool -> Edit Bool Source # patch :: Edit Bool -> Bool -> Maybe Bool Source # undiff :: Edit Bool -> (Bool, Bool) Source #
Diff Char Source #
Associated Types type Edit Char :: * Source # Methods diff :: Char -> Char -> Edit Char Source # patch :: Edit Char -> Char -> Maybe Char Source # undiff :: Edit Char -> (Char, Char) Source #
Diff Double Source #
Associated Types type Edit Double :: * Source # Methods diff :: Double -> Double -> Edit Double Source # patch :: Edit Double -> Double -> Maybe Double Source # undiff :: Edit Double -> (Double, Double) Source #
Diff Float Source #
Associated Types type Edit Float :: * Source # Methods diff :: Float -> Float -> Edit Float Source # patch :: Edit Float -> Float -> Maybe Float Source # undiff :: Edit Float -> (Float, Float) Source #
Diff Int Source #
Associated Types type Edit Int :: * Source # Methods diff :: Int -> Int -> Edit Int Source # patch :: Edit Int -> Int -> Maybe Int Source # undiff :: Edit Int -> (Int, Int) Source #
Diff Integer Source #
Associated Types type Edit Integer :: * Source # Methods diff :: Integer -> Integer -> Edit Integer Source # patch :: Edit Integer -> Integer -> Maybe Integer Source # undiff :: Edit Integer -> (Integer, Integer) Source #
Eq a => Diff (EqDiff a) Source #
Associated Types type Edit (EqDiff a) :: * Source # Methods diff :: EqDiff a -> EqDiff a -> Edit (EqDiff a) Source # patch :: Edit (EqDiff a) -> EqDiff a -> Maybe (EqDiff a) Source # undiff :: Edit (EqDiff a) -> (EqDiff a, EqDiff a) Source #
(ConvertibleStrings t Text, ConvertibleStrings Text t, Eq t) => Diff (Lines t) Source #	Line-by-line diffing of strings
Associated Types type Edit (Lines t) :: * Source # Methods diff :: Lines t -> Lines t -> Edit (Lines t) Source # patch :: Edit (Lines t) -> Lines t -> Maybe (Lines t) Source # undiff :: Edit (Lines t) -> (Lines t, Lines t) Source #
(Diff a, Diff b, Typeable * a, Typeable * b) => Diff (Either a b) Source #
Associated Types type Edit (Either a b) :: * Source # Methods diff :: Either a b -> Either a b -> Edit (Either a b) Source # patch :: Edit (Either a b) -> Either a b -> Maybe (Either a b) Source # undiff :: Edit (Either a b) -> (Either a b, Either a b) Source #
(Diff a, Diff b) => Diff (a, b) Source #
Associated Types type Edit (a, b) :: * Source # Methods diff :: (a, b) -> (a, b) -> Edit (a, b) Source # patch :: Edit (a, b) -> (a, b) -> Maybe (a, b) Source # undiff :: Edit (a, b) -> ((a, b), (a, b)) Source #
(Diff a, Diff b, Diff c) => Diff (a, b, c) Source #
Associated Types type Edit (a, b, c) :: * Source # Methods diff :: (a, b, c) -> (a, b, c) -> Edit (a, b, c) Source # patch :: Edit (a, b, c) -> (a, b, c) -> Maybe (a, b, c) Source # undiff :: Edit (a, b, c) -> ((a, b, c), (a, b, c)) Source #
(Diff a, Diff b, Diff c, Diff d) => Diff (a, b, c, d) Source #
Associated Types type Edit (a, b, c, d) :: * Source # Methods diff :: (a, b, c, d) -> (a, b, c, d) -> Edit (a, b, c, d) Source # patch :: Edit (a, b, c, d) -> (a, b, c, d) -> Maybe (a, b, c, d) Source # undiff :: Edit (a, b, c, d) -> ((a, b, c, d), (a, b, c, d)) Source #
(Diff a, Diff b, Diff c, Diff d, Diff e) => Diff (a, b, c, d, e) Source #
Associated Types type Edit (a, b, c, d, e) :: * Source # Methods diff :: (a, b, c, d, e) -> (a, b, c, d, e) -> Edit (a, b, c, d, e) Source # patch :: Edit (a, b, c, d, e) -> (a, b, c, d, e) -> Maybe (a, b, c, d, e) Source # undiff :: Edit (a, b, c, d, e) -> ((a, b, c, d, e), (a, b, c, d, e)) Source #
(Diff a, Diff b, Diff c, Diff d, Diff e, Diff f) => Diff (a, b, c, d, e, f) Source #
Associated Types type Edit (a, b, c, d, e, f) :: * Source # Methods diff :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Edit (a, b, c, d, e, f) Source # patch :: Edit (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Maybe (a, b, c, d, e, f) Source # undiff :: Edit (a, b, c, d, e, f) -> ((a, b, c, d, e, f), (a, b, c, d, e, f)) Source #
(Diff a, Diff b, Diff c, Diff d, Diff e, Diff f, Diff g) => Diff (a, b, c, d, e, f, g) Source #
Associated Types type Edit (a, b, c, d, e, f, g) :: * Source # Methods diff :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Edit (a, b, c, d, e, f, g) Source # patch :: Edit (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Maybe (a, b, c, d, e, f, g) Source # undiff :: Edit (a, b, c, d, e, f, g) -> ((a, b, c, d, e, f, g), (a, b, c, d, e, f, g)) Source #

class Patch a where Source #

Methods

patchLevel :: a -> DiffLevel Source #

Level of patch

mergePatch :: a -> a -> MergeResult a Source #

Left-biased parallel merge of two patches

Returns Nothing if patches come from incompatible sources

Returns True if conflict occurred (and was resolved)

patchLevel :: (Generic a, Every (Every Patch) (Code a)) => a -> DiffLevel Source #

Level of patch

mergePatch :: (IsProductType a as, Every Patch as) => a -> a -> MergeResult a Source #

Left-biased parallel merge of two patches

Returns Nothing if patches come from incompatible sources

Returns True if conflict occurred (and was resolved)

Instances

Eq a => Patch (Swap a) Source #
Methods patchLevel :: Swap a -> DiffLevel Source # mergePatch :: Swap a -> Swap a -> MergeResult (Swap a) Source #
(IsProductType a as, Every * Diff as) => Patch (GPatchProd a) Source #
Methods patchLevel :: GPatchProd a -> DiffLevel Source # mergePatch :: GPatchProd a -> GPatchProd a -> MergeResult (GPatchProd a) Source #
(Generic a, Every [] (Every Diff) (Code a)) => Patch (GPatch a) Source #
Methods patchLevel :: GPatch a -> DiffLevel Source # mergePatch :: GPatch a -> GPatch a -> MergeResult (GPatch a) Source #
Patch (Edit a) => Patch (Edit' a) Source #
Methods patchLevel :: Edit' a -> DiffLevel Source # mergePatch :: Edit' a -> Edit' a -> MergeResult (Edit' a) Source #
Patch (LinesPatch t) Source #
Methods patchLevel :: LinesPatch t -> DiffLevel Source # mergePatch :: LinesPatch t -> LinesPatch t -> MergeResult (LinesPatch t) Source #
Eq a => Patch (EqSeqPatch a) Source #
Methods patchLevel :: EqSeqPatch a -> DiffLevel Source # mergePatch :: EqSeqPatch a -> EqSeqPatch a -> MergeResult (EqSeqPatch a) Source #
(KnownNat p, Diff a) => Patch (SeqPatchAt p a) Source #
Methods patchLevel :: SeqPatchAt p a -> DiffLevel Source # mergePatch :: SeqPatchAt p a -> SeqPatchAt p a -> MergeResult (SeqPatchAt p a) Source #
Diff a => Patch (MapDiff IntMap a) Source #
Methods patchLevel :: MapDiff IntMap a -> DiffLevel Source # mergePatch :: MapDiff IntMap a -> MapDiff IntMap a -> MergeResult (MapDiff IntMap a) Source #
(Diff a, Ord k) => Patch (MapDiff (Map k) a) Source #
Methods patchLevel :: MapDiff (Map k) a -> DiffLevel Source # mergePatch :: MapDiff (Map k) a -> MapDiff (Map k) a -> MergeResult (MapDiff (Map k) a) Source #
(Hashable k, Eq k, Diff a) => Patch (MapDiff (HashMap k) a) Source #
Methods patchLevel :: MapDiff (HashMap k) a -> DiffLevel Source # mergePatch :: MapDiff (HashMap k) a -> MapDiff (HashMap k) a -> MergeResult (MapDiff (HashMap k) a) Source #

data DiffLevel Source #

Data type representing a "percentage difference"

Constructors

DL
Fields dlAmt :: Double dlTot :: Double

Bundled Patterns

pattern NoDiff :: Double -> DiffLevel
pattern TotalDiff :: Double -> DiffLevel

Instances

Show DiffLevel Source #
Methods showsPrec :: Int -> DiffLevel -> ShowS # show :: DiffLevel -> String # showList :: [DiffLevel] -> ShowS #
Semigroup DiffLevel Source #
Methods (<>) :: DiffLevel -> DiffLevel -> DiffLevel # sconcat :: NonEmpty DiffLevel -> DiffLevel # stimes :: Integral b => b -> DiffLevel -> DiffLevel #
Monoid DiffLevel Source #
Methods mempty :: DiffLevel # mappend :: DiffLevel -> DiffLevel -> DiffLevel # mconcat :: [DiffLevel] -> DiffLevel #

data MergeResult a Source #

Result of a merge

Constructors

Incompatible	Incompatible sources
Conflict a	Conflicts, throwing away info
NoConflict a	All conflicts resolved

Instances

Monad MergeResult Source #
Methods (>>=) :: MergeResult a -> (a -> MergeResult b) -> MergeResult b # (>>) :: MergeResult a -> MergeResult b -> MergeResult b # return :: a -> MergeResult a # fail :: String -> MergeResult a #
Functor MergeResult Source #
Methods fmap :: (a -> b) -> MergeResult a -> MergeResult b # (<$) :: a -> MergeResult b -> MergeResult a #
Applicative MergeResult Source #
Methods pure :: a -> MergeResult a # (<>) :: MergeResult (a -> b) -> MergeResult a -> MergeResult b # liftA2 :: (a -> b -> c) -> MergeResult a -> MergeResult b -> MergeResult c # (>) :: MergeResult a -> MergeResult b -> MergeResult b # (<*) :: MergeResult a -> MergeResult b -> MergeResult a #
Foldable MergeResult Source #
Methods fold :: Monoid m => MergeResult m -> m # foldMap :: Monoid m => (a -> m) -> MergeResult a -> m # foldr :: (a -> b -> b) -> b -> MergeResult a -> b # foldr' :: (a -> b -> b) -> b -> MergeResult a -> b # foldl :: (b -> a -> b) -> b -> MergeResult a -> b # foldl' :: (b -> a -> b) -> b -> MergeResult a -> b # foldr1 :: (a -> a -> a) -> MergeResult a -> a # foldl1 :: (a -> a -> a) -> MergeResult a -> a # toList :: MergeResult a -> [a] # null :: MergeResult a -> Bool # length :: MergeResult a -> Int # elem :: Eq a => a -> MergeResult a -> Bool # maximum :: Ord a => MergeResult a -> a # minimum :: Ord a => MergeResult a -> a # sum :: Num a => MergeResult a -> a # product :: Num a => MergeResult a -> a #
Traversable MergeResult Source #
Methods traverse :: Applicative f => (a -> f b) -> MergeResult a -> f (MergeResult b) # sequenceA :: Applicative f => MergeResult (f a) -> f (MergeResult a) # mapM :: Monad m => (a -> m b) -> MergeResult a -> m (MergeResult b) # sequence :: Monad m => MergeResult (m a) -> m (MergeResult a) #
Eq a => Eq (MergeResult a) Source #
Methods (==) :: MergeResult a -> MergeResult a -> Bool # (/=) :: MergeResult a -> MergeResult a -> Bool #
Ord a => Ord (MergeResult a) Source #
Methods compare :: MergeResult a -> MergeResult a -> Ordering # (<) :: MergeResult a -> MergeResult a -> Bool # (<=) :: MergeResult a -> MergeResult a -> Bool # (>) :: MergeResult a -> MergeResult a -> Bool # (>=) :: MergeResult a -> MergeResult a -> Bool # max :: MergeResult a -> MergeResult a -> MergeResult a # min :: MergeResult a -> MergeResult a -> MergeResult a #
Show a => Show (MergeResult a) Source #
Methods showsPrec :: Int -> MergeResult a -> ShowS # show :: MergeResult a -> String # showList :: [MergeResult a] -> ShowS #

merge :: Diff a => a -> a -> a -> MergeResult a Source #

Left-biased merge of two diffable values.

catLevels :: Foldable f => f DiffLevel -> DiffLevel Source #

Merge all DiffLevel in a Foldable container, treating them all as equally weighted.

normDL :: Double -> DiffLevel -> Maybe DiffLevel Source #

Rescale DiffLevel to be out of a given total.

dlPercent :: DiffLevel -> Double Source #

Calculate percent difference.

TODO: What about 0?

percentDiff :: Diff a => a -> a -> Double Source #

How different two items are, as a percentage

prodPatchLevel :: forall as. Every Diff as => Prod Edit' as -> DiffLevel Source #

DiffLevel of a Prod of Edits

compareDiff :: Diff a => a -> a -> DiffLevel Source #

Get DiffLevel between two items

class Patch a => ShowPatch a where Source #

Minimal complete definition

showPatch

Methods

showPatch :: a -> Doc Source #

Instances

(Show a, Eq a) => ShowPatch (Swap a) Source #
Methods showPatch :: Swap a -> Doc Source #
(IsProductType a as, Every * Diff as, Every * Show as, HasDatatypeInfo a, Every * (Comp * * ShowPatch Edit') as) => ShowPatch (GPatchProd a) Source #
Methods showPatch :: GPatchProd a -> Doc Source #
(Generic a, HasDatatypeInfo a, Every [] (Every Diff) (Code a), Every [] (Every Show) (Code a), Every [] (Every (Comp * * ShowPatch Edit')) (Code a)) => ShowPatch (GPatch a) Source #
Methods showPatch :: GPatch a -> Doc Source #
ShowPatch (Edit a) => ShowPatch (Edit' a) Source #
Methods showPatch :: Edit' a -> Doc Source #
(KnownNat p, Diff a, Show a, ShowPatch (Edit a)) => ShowPatch (SeqPatchAt p a) Source #
Methods showPatch :: SeqPatchAt p a -> Doc Source #
(Diff a, Show a, ShowPatch (Edit a)) => ShowPatch (MapDiff IntMap a) Source #
Methods showPatch :: MapDiff IntMap a -> Doc Source #
(Diff a, Ord k, Show k, Show a, ShowPatch (Edit a)) => ShowPatch (MapDiff (Map k) a) Source #
Methods showPatch :: MapDiff (Map k) a -> Doc Source #
(Diff a, Hashable k, Eq k, Show k, Show a, ShowPatch (Edit a)) => ShowPatch (MapDiff (HashMap k) a) Source #
Methods showPatch :: MapDiff (HashMap k) a -> Doc Source #

putPatch :: ShowPatch a => a -> IO () Source #

class DefaultDiff p a where Source #

Minimal complete definition

defaultDiff, defaultPatch, defaultUndiff

Methods

defaultDiff :: a -> a -> p Source #

defaultPatch :: p -> a -> Maybe a Source #

defaultUndiff :: p -> (a, a) Source #

Instances

Eq a => DefaultDiff (Swap a) a Source #
Methods defaultDiff :: a -> a -> Swap a Source # defaultPatch :: Swap a -> a -> Maybe a Source # defaultUndiff :: Swap a -> (a, a) Source #
(IsProductType a as, Every * Diff as) => DefaultDiff (GPatchProd a) a Source #
Methods defaultDiff :: a -> a -> GPatchProd a Source # defaultPatch :: GPatchProd a -> a -> Maybe a Source # defaultUndiff :: GPatchProd a -> (a, a) Source #
(Generic a, Every [] (Every Diff) (Code a), Every [] (Typeable []) (Code a)) => DefaultDiff (GPatch a) a Source #
Methods defaultDiff :: a -> a -> GPatch a Source # defaultPatch :: GPatch a -> a -> Maybe a Source # defaultUndiff :: GPatch a -> (a, a) Source #
(ConvertibleStrings t Text, ConvertibleStrings Text t) => DefaultDiff (LinesPatch t) t Source #
Methods defaultDiff :: t -> t -> LinesPatch t Source # defaultPatch :: LinesPatch t -> t -> Maybe t Source # defaultUndiff :: LinesPatch t -> (t, t) Source #
(IsList l, (~) * e (Item l), Eq e) => DefaultDiff (EqSeqPatch e) l Source #
Methods defaultDiff :: l -> l -> EqSeqPatch e Source # defaultPatch :: EqSeqPatch e -> l -> Maybe l Source # defaultUndiff :: EqSeqPatch e -> (l, l) Source #
(IsList l, (~) * e (Item l), Diff e, KnownNat p) => DefaultDiff (SeqPatchAt p e) l Source #
Methods defaultDiff :: l -> l -> SeqPatchAt p e Source # defaultPatch :: SeqPatchAt p e -> l -> Maybe l Source # defaultUndiff :: SeqPatchAt p e -> (l, l) Source #

newtype Edit' a Source #

Newtype used to get around partial application of type families

Constructors

Edit'
Fields getEdit' :: Edit a

Instances

Generic (Edit' a) Source #
Associated Types type Rep (Edit' a) :: * -> * # Methods from :: Edit' a -> Rep (Edit' a) x # to :: Rep (Edit' a) x -> Edit' a #
Generic (Edit' a) Source #
Associated Types type Code (Edit' a) :: [[*]] # Methods from :: Edit' a -> Rep (Edit' a) # to :: Rep (Edit' a) -> Edit' a #
ShowPatch (Edit a) => ShowPatch (Edit' a) Source #
Methods showPatch :: Edit' a -> Doc Source #
Patch (Edit a) => Patch (Edit' a) Source #
Methods patchLevel :: Edit' a -> DiffLevel Source # mergePatch :: Edit' a -> Edit' a -> MergeResult (Edit' a) Source #
type Rep (Edit' a) Source #
type Rep (Edit' a) = D1 * (MetaData "Edit'" "Data.Diff.Internal" "data-diff-0.1.0.0-7AASwadXUeC9iuW5cOIQhE" True) (C1 * (MetaCons "Edit'" PrefixI True) (S1 * (MetaSel (Just Symbol "getEdit'") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Edit a))))
type Code (Edit' a) Source #
type Code (Edit' a) = GCode (Edit' a)

diff' :: Diff a => a -> a -> Edit' a Source #

diff' lifted to Edit'

patch' :: Diff a => Edit' a -> a -> Maybe a Source #

patch' lifted to Edit'

undiff' :: Diff a => Edit' a -> (a, a) Source #

undiff' lifted to Edit'

data Swap a Source #

Patch type that treats all changes as total differences

Constructors

NoChange a
Replace a a

Instances

Eq a => Eq (Swap a) Source #
Methods (==) :: Swap a -> Swap a -> Bool # (/=) :: Swap a -> Swap a -> Bool #
Ord a => Ord (Swap a) Source #
Methods compare :: Swap a -> Swap a -> Ordering # (<) :: Swap a -> Swap a -> Bool # (<=) :: Swap a -> Swap a -> Bool # (>) :: Swap a -> Swap a -> Bool # (>=) :: Swap a -> Swap a -> Bool # max :: Swap a -> Swap a -> Swap a # min :: Swap a -> Swap a -> Swap a #
Read a => Read (Swap a) Source #
Methods readsPrec :: Int -> ReadS (Swap a) # readList :: ReadS [Swap a] # readPrec :: ReadPrec (Swap a) # readListPrec :: ReadPrec [Swap a] #
Show a => Show (Swap a) Source #
Methods showsPrec :: Int -> Swap a -> ShowS # show :: Swap a -> String # showList :: [Swap a] -> ShowS #
Generic (Swap a) Source #
Associated Types type Rep (Swap a) :: * -> * # Methods from :: Swap a -> Rep (Swap a) x # to :: Rep (Swap a) x -> Swap a #
(Show a, Eq a) => ShowPatch (Swap a) Source #
Methods showPatch :: Swap a -> Doc Source #
Eq a => Patch (Swap a) Source #
Methods patchLevel :: Swap a -> DiffLevel Source # mergePatch :: Swap a -> Swap a -> MergeResult (Swap a) Source #
Eq a => DefaultDiff (Swap a) a Source #
Methods defaultDiff :: a -> a -> Swap a Source # defaultPatch :: Swap a -> a -> Maybe a Source # defaultUndiff :: Swap a -> (a, a) Source #
type Rep (Swap a) Source #
type Rep (Swap a) = D1 * (MetaData "Swap" "Data.Diff.Internal" "data-diff-0.1.0.0-7AASwadXUeC9iuW5cOIQhE" False) ((:+:) * (C1 * (MetaCons "NoChange" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a))) (C1 * (MetaCons "Replace" PrefixI False) ((::) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)))))

eqDiff :: Eq a => a -> a -> Swap a Source #

diff for all instances of Eq

eqPatch :: Swap a -> a -> Maybe a Source #

patch for Swap

newtype EqDiff a Source #

Newtype wrapper that gives an automatic Diff instance that treats all changes as total differences.

Constructors

EqDiff
Fields getEqDiff :: a

Instances

Eq a => Eq (EqDiff a) Source #
Methods (==) :: EqDiff a -> EqDiff a -> Bool # (/=) :: EqDiff a -> EqDiff a -> Bool #
Ord a => Ord (EqDiff a) Source #
Methods compare :: EqDiff a -> EqDiff a -> Ordering # (<) :: EqDiff a -> EqDiff a -> Bool # (<=) :: EqDiff a -> EqDiff a -> Bool # (>) :: EqDiff a -> EqDiff a -> Bool # (>=) :: EqDiff a -> EqDiff a -> Bool # max :: EqDiff a -> EqDiff a -> EqDiff a # min :: EqDiff a -> EqDiff a -> EqDiff a #
Read a => Read (EqDiff a) Source #
Methods readsPrec :: Int -> ReadS (EqDiff a) # readList :: ReadS [EqDiff a] # readPrec :: ReadPrec (EqDiff a) # readListPrec :: ReadPrec [EqDiff a] #
Show a => Show (EqDiff a) Source #
Methods showsPrec :: Int -> EqDiff a -> ShowS # show :: EqDiff a -> String # showList :: [EqDiff a] -> ShowS #
Generic (EqDiff a) Source #
Associated Types type Rep (EqDiff a) :: * -> * # Methods from :: EqDiff a -> Rep (EqDiff a) x # to :: Rep (EqDiff a) x -> EqDiff a #
Eq a => Diff (EqDiff a) Source #
Associated Types type Edit (EqDiff a) :: * Source # Methods diff :: EqDiff a -> EqDiff a -> Edit (EqDiff a) Source # patch :: Edit (EqDiff a) -> EqDiff a -> Maybe (EqDiff a) Source # undiff :: Edit (EqDiff a) -> (EqDiff a, EqDiff a) Source #
type Rep (EqDiff a) Source #
type Rep (EqDiff a) = D1 * (MetaData "EqDiff" "Data.Diff.Internal" "data-diff-0.1.0.0-7AASwadXUeC9iuW5cOIQhE" True) (C1 * (MetaCons "EqDiff" PrefixI True) (S1 * (MetaSel (Just Symbol "getEqDiff") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)))
type Edit (EqDiff a) Source #
type Edit (EqDiff a) = Swap a

Generic implementations

Patch

gpatchLevel :: forall a ass. (Generic a, Code a ~ ass, Every (Every Patch) ass) => a -> DiffLevel Source #

patchLevel written to work for any types deriving Generic.

gmergePatch :: forall a as. (IsProductType a as, Every Patch as) => a -> a -> MergeResult a Source #

mergePatch written to work for any product types deriving Generic.

Diff

Sequences

Diff

newtype SeqPatchAt (p :: Nat) a Source #

Constructors

SPA
Fields getSPA :: [Diff a]

Instances

Eq a => Eq (SeqPatchAt p a) Source #
Methods (==) :: SeqPatchAt p a -> SeqPatchAt p a -> Bool # (/=) :: SeqPatchAt p a -> SeqPatchAt p a -> Bool #
Show a => Show (SeqPatchAt p a) Source #
Methods showsPrec :: Int -> SeqPatchAt p a -> ShowS # show :: SeqPatchAt p a -> String # showList :: [SeqPatchAt p a] -> ShowS #
Generic (SeqPatchAt p a) Source #
Associated Types type Rep (SeqPatchAt p a) :: * -> * # Methods from :: SeqPatchAt p a -> Rep (SeqPatchAt p a) x # to :: Rep (SeqPatchAt p a) x -> SeqPatchAt p a #
(KnownNat p, Diff a, Show a, ShowPatch (Edit a)) => ShowPatch (SeqPatchAt p a) Source #
Methods showPatch :: SeqPatchAt p a -> Doc Source #
(KnownNat p, Diff a) => Patch (SeqPatchAt p a) Source #
Methods patchLevel :: SeqPatchAt p a -> DiffLevel Source # mergePatch :: SeqPatchAt p a -> SeqPatchAt p a -> MergeResult (SeqPatchAt p a) Source #
(IsList l, (~) * e (Item l), Diff e, KnownNat p) => DefaultDiff (SeqPatchAt p e) l Source #
Methods defaultDiff :: l -> l -> SeqPatchAt p e Source # defaultPatch :: SeqPatchAt p e -> l -> Maybe l Source # defaultUndiff :: SeqPatchAt p e -> (l, l) Source #
type Rep (SeqPatchAt p a) Source #
type Rep (SeqPatchAt p a) = D1 * (MetaData "SeqPatchAt" "Data.Diff.Internal.Sequence" "data-diff-0.1.0.0-7AASwadXUeC9iuW5cOIQhE" True) (C1 * (MetaCons "SPA" PrefixI True) (S1 * (MetaSel (Just Symbol "getSPA") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Diff a])))

type SeqPatch = SeqPatchAt 20 Source #

listDiff :: forall p a. (KnownNat p, Diff a) => [a] -> [a] -> SeqPatchAt p a Source #

listPatch :: Eq a => SeqPatchAt p a -> [a] -> Maybe [a] Source #

listUndiff :: SeqPatchAt p a -> ([a], [a]) Source #

seqDiff :: (KnownNat p, Diff a) => (t -> [a]) -> t -> t -> SeqPatchAt p a Source #

seqPatch :: Eq a => (t -> [a]) -> ([a] -> t) -> SeqPatchAt p a -> t -> Maybe t Source #

seqUndiff :: ([a] -> t) -> SeqPatchAt p a -> (t, t) Source #

Eq

newtype EqSeqPatch a Source #

Constructors

ESP
Fields getESP :: SeqPatchAt 0 (EqDiff a)

Instances

Eq a => Eq (EqSeqPatch a) Source #
Methods (==) :: EqSeqPatch a -> EqSeqPatch a -> Bool # (/=) :: EqSeqPatch a -> EqSeqPatch a -> Bool #
Show a => Show (EqSeqPatch a) Source #
Methods showsPrec :: Int -> EqSeqPatch a -> ShowS # show :: EqSeqPatch a -> String # showList :: [EqSeqPatch a] -> ShowS #
Generic (EqSeqPatch a) Source #
Associated Types type Rep (EqSeqPatch a) :: * -> * # Methods from :: EqSeqPatch a -> Rep (EqSeqPatch a) x # to :: Rep (EqSeqPatch a) x -> EqSeqPatch a #
Eq a => Patch (EqSeqPatch a) Source #
Methods patchLevel :: EqSeqPatch a -> DiffLevel Source # mergePatch :: EqSeqPatch a -> EqSeqPatch a -> MergeResult (EqSeqPatch a) Source #
(IsList l, (~) * e (Item l), Eq e) => DefaultDiff (EqSeqPatch e) l Source #
Methods defaultDiff :: l -> l -> EqSeqPatch e Source # defaultPatch :: EqSeqPatch e -> l -> Maybe l Source # defaultUndiff :: EqSeqPatch e -> (l, l) Source #
type Rep (EqSeqPatch a) Source #
type Rep (EqSeqPatch a) = D1 * (MetaData "EqSeqPatch" "Data.Diff.Internal.Sequence" "data-diff-0.1.0.0-7AASwadXUeC9iuW5cOIQhE" True) (C1 * (MetaCons "ESP" PrefixI True) (S1 * (MetaSel (Just Symbol "getESP") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (SeqPatchAt 0 (EqDiff a)))))

eqListDiff :: Eq a => [a] -> [a] -> EqSeqPatch a Source #

eqListPatch :: Eq a => EqSeqPatch a -> [a] -> Maybe [a] Source #

eqListUndiff :: EqSeqPatch a -> ([a], [a]) Source #

eqSeqDiff :: Eq a => (t -> [a]) -> t -> t -> EqSeqPatch a Source #

eqSeqPatch :: Eq a => (t -> [a]) -> ([a] -> t) -> EqSeqPatch a -> t -> Maybe t Source #

eqSeqUndiff :: Eq a => ([a] -> t) -> EqSeqPatch a -> (t, t) Source #

Line-by-line

newtype LinesPatch t Source #

Constructors

LP
Fields getLP :: EqSeqPatch Text

Instances

Eq (LinesPatch t) Source #
Methods (==) :: LinesPatch t -> LinesPatch t -> Bool # (/=) :: LinesPatch t -> LinesPatch t -> Bool #
Show (LinesPatch t) Source #
Methods showsPrec :: Int -> LinesPatch t -> ShowS # show :: LinesPatch t -> String # showList :: [LinesPatch t] -> ShowS #
Generic (LinesPatch t) Source #
Associated Types type Rep (LinesPatch t) :: * -> * # Methods from :: LinesPatch t -> Rep (LinesPatch t) x # to :: Rep (LinesPatch t) x -> LinesPatch t #
Patch (LinesPatch t) Source #
Methods patchLevel :: LinesPatch t -> DiffLevel Source # mergePatch :: LinesPatch t -> LinesPatch t -> MergeResult (LinesPatch t) Source #
(ConvertibleStrings t Text, ConvertibleStrings Text t) => DefaultDiff (LinesPatch t) t Source #
Methods defaultDiff :: t -> t -> LinesPatch t Source # defaultPatch :: LinesPatch t -> t -> Maybe t Source # defaultUndiff :: LinesPatch t -> (t, t) Source #
type Rep (LinesPatch t) Source #
type Rep (LinesPatch t) = D1 * (MetaData "LinesPatch" "Data.Diff.Internal.Sequence" "data-diff-0.1.0.0-7AASwadXUeC9iuW5cOIQhE" True) (C1 * (MetaCons "LP" PrefixI True) (S1 * (MetaSel (Just Symbol "getLP") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (EqSeqPatch Text))))

newtype Lines t Source #

Newtype wrapper for line-by-line diffing

Constructors

Lines
Fields getLines :: t

Instances

ConvertibleStrings s t => ConvertibleStrings s (Lines t) Source #
Methods convertString :: s -> Lines t #
Eq t => Eq (Lines t) Source #
Methods (==) :: Lines t -> Lines t -> Bool # (/=) :: Lines t -> Lines t -> Bool #
Read t => Read (Lines t) Source #
Methods readsPrec :: Int -> ReadS (Lines t) # readList :: ReadS [Lines t] # readPrec :: ReadPrec (Lines t) # readListPrec :: ReadPrec [Lines t] #
Show t => Show (Lines t) Source #
Methods showsPrec :: Int -> Lines t -> ShowS # show :: Lines t -> String # showList :: [Lines t] -> ShowS #
Generic (Lines t) Source #
Associated Types type Rep (Lines t) :: * -> * # Methods from :: Lines t -> Rep (Lines t) x # to :: Rep (Lines t) x -> Lines t #
(ConvertibleStrings t Text, ConvertibleStrings Text t, Eq t) => Diff (Lines t) Source #	Line-by-line diffing of strings
Associated Types type Edit (Lines t) :: * Source # Methods diff :: Lines t -> Lines t -> Edit (Lines t) Source # patch :: Edit (Lines t) -> Lines t -> Maybe (Lines t) Source # undiff :: Edit (Lines t) -> (Lines t, Lines t) Source #
ConvertibleStrings t s => ConvertibleStrings (Lines t) s Source #
Methods convertString :: Lines t -> s #
type Rep (Lines t) Source #
type Rep (Lines t) = D1 * (MetaData "Lines" "Data.Diff.Internal.Sequence" "data-diff-0.1.0.0-7AASwadXUeC9iuW5cOIQhE" True) (C1 * (MetaCons "Lines" PrefixI True) (S1 * (MetaSel (Just Symbol "getLines") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * t)))
type Edit (Lines t) Source #
type Edit (Lines t) = LinesPatch (Lines t)

Generic ADTs

newtype GPatch a Source #

Generic patch type for any types deriving Generic.

Constructors

GP
Fields getGP :: SumDiff Tuple (Prod Edit') (Code a)

Instances

Generic (GPatch a) Source #
Associated Types type Rep (GPatch a) :: * -> * # Methods from :: GPatch a -> Rep (GPatch a) x # to :: Rep (GPatch a) x -> GPatch a #
Generic (GPatch a) Source #
Associated Types type Code (GPatch a) :: [[*]] # Methods from :: GPatch a -> Rep (GPatch a) # to :: Rep (GPatch a) -> GPatch a #
(Generic a, HasDatatypeInfo a, Every [] (Every Diff) (Code a), Every [] (Every Show) (Code a), Every [] (Every (Comp * * ShowPatch Edit')) (Code a)) => ShowPatch (GPatch a) Source #
Methods showPatch :: GPatch a -> Doc Source #
(Generic a, Every [] (Every Diff) (Code a)) => Patch (GPatch a) Source #
Methods patchLevel :: GPatch a -> DiffLevel Source # mergePatch :: GPatch a -> GPatch a -> MergeResult (GPatch a) Source #
(Generic a, Every [] (Every Diff) (Code a), Every [] (Typeable []) (Code a)) => DefaultDiff (GPatch a) a Source #
Methods defaultDiff :: a -> a -> GPatch a Source # defaultPatch :: GPatch a -> a -> Maybe a Source # defaultUndiff :: GPatch a -> (a, a) Source #
type Rep (GPatch a) Source #
type Rep (GPatch a) = D1 * (MetaData "GPatch" "Data.Diff.Internal" "data-diff-0.1.0.0-7AASwadXUeC9iuW5cOIQhE" True) (C1 * (MetaCons "GP" PrefixI True) (S1 * (MetaSel (Just Symbol "getGP") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (SumDiff [] Tuple (Prod Edit') (Code a)))))
type Code (GPatch a) Source #
type Code (GPatch a) = GCode (GPatch a)

gdiff :: forall a. (Generic a, Every (Every Diff) (Code a), Every Typeable (Code a)) => a -> a -> GPatch a Source #

diff intented to work for all instances of Generic. Will treat constructor changes as partial differences if they both contain the same type of values.

gdiff' :: forall a. (Generic a, Every (Every Diff) (Code a)) => a -> a -> GPatch a Source #

diff intented to work for all instances of Generic. Differs from gdiff in that it treats constructor changes as total differences, even if they both contain the same type of values.

gpatch :: forall a. (Generic a, Every (Every Diff) (Code a)) => GPatch a -> a -> Maybe a Source #

patch intented to work for all instances of Generic.

gundiff :: forall a. (Generic a, Every (Every Diff) (Code a)) => GPatch a -> (a, a) Source #

undiff intended to work for all instances of Generic.

data GPatchProd a Source #

Generic patch type for all product types that are instances of Generic.

Constructors

Code a ~ '[as] => GPP
Fields getGPP :: Prod Edit' as

Instances

(IsProductType a as, Every * Diff as, Every * Show as, HasDatatypeInfo a, Every * (Comp * * ShowPatch Edit') as) => ShowPatch (GPatchProd a) Source #
Methods showPatch :: GPatchProd a -> Doc Source #
(IsProductType a as, Every * Diff as) => Patch (GPatchProd a) Source #
Methods patchLevel :: GPatchProd a -> DiffLevel Source # mergePatch :: GPatchProd a -> GPatchProd a -> MergeResult (GPatchProd a) Source #
(IsProductType a as, Every * Diff as) => DefaultDiff (GPatchProd a) a Source #
Methods defaultDiff :: a -> a -> GPatchProd a Source # defaultPatch :: GPatchProd a -> a -> Maybe a Source # defaultUndiff :: GPatchProd a -> (a, a) Source #

gdiffProd :: forall a as. (IsProductType a as, Every Diff as) => a -> a -> GPatchProd a Source #

diff intended to work for all product types that are instances of Generic.

gpatchProd :: forall a as. (IsProductType a as, Every Diff as) => GPatchProd a -> a -> Maybe a Source #

patch intended to work for all product types that are instances of Generic.

gundiffProd :: forall a as. (IsProductType a as, Every Diff as) => GPatchProd a -> (a, a) Source #

undiff intended to work for all product types that are instances of Generic.

data SumDiff :: (k -> Type) -> (k -> Type) -> [k] -> Type where Source #

Constructors

SD :: (Index as :&: CtrDiff f g as) a -> SumDiff f g as

data CtrDiff :: (k -> Type) -> (k -> Type) -> [k] -> k -> Type where Source #

Constructors

CDEdit :: g a -> CtrDiff f g as a
CDName :: (Index as :&: g) a -> CtrDiff f g as a
CDDiff :: f a -> (Index as :&: f) b -> CtrDiff f g as a

Maps

data ValDiff a Source #

Constructors

VDDel a
VDIns a
VDMod (Edit a)

Instances

(Show a, Show (Edit a)) => Show (ValDiff a) Source #
Methods showsPrec :: Int -> ValDiff a -> ShowS # show :: ValDiff a -> String # showList :: [ValDiff a] -> ShowS #
Generic (ValDiff a) Source #
Associated Types type Rep (ValDiff a) :: * -> * # Methods from :: ValDiff a -> Rep (ValDiff a) x # to :: Rep (ValDiff a) x -> ValDiff a #
type Rep (ValDiff a) Source #
type Rep (ValDiff a) = D1 * (MetaData "ValDiff" "Data.Diff.Internal.Map" "data-diff-0.1.0.0-7AASwadXUeC9iuW5cOIQhE" False) ((:+:) * (C1 * (MetaCons "VDDel" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a))) ((:+:) * (C1 * (MetaCons "VDIns" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a))) (C1 * (MetaCons "VDMod" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Edit a))))))

newtype MapDiff m a Source #

Constructors

MD
Fields getMD :: m (ValDiff a)

Instances

Eq (m (ValDiff a)) => Eq (MapDiff m a) Source #
Methods (==) :: MapDiff m a -> MapDiff m a -> Bool # (/=) :: MapDiff m a -> MapDiff m a -> Bool #
Ord (m (ValDiff a)) => Ord (MapDiff m a) Source #
Methods compare :: MapDiff m a -> MapDiff m a -> Ordering # (<) :: MapDiff m a -> MapDiff m a -> Bool # (<=) :: MapDiff m a -> MapDiff m a -> Bool # (>) :: MapDiff m a -> MapDiff m a -> Bool # (>=) :: MapDiff m a -> MapDiff m a -> Bool # max :: MapDiff m a -> MapDiff m a -> MapDiff m a # min :: MapDiff m a -> MapDiff m a -> MapDiff m a #
Read (m (ValDiff a)) => Read (MapDiff m a) Source #
Methods readsPrec :: Int -> ReadS (MapDiff m a) # readList :: ReadS [MapDiff m a] # readPrec :: ReadPrec (MapDiff m a) # readListPrec :: ReadPrec [MapDiff m a] #
Show (m (ValDiff a)) => Show (MapDiff m a) Source #
Methods showsPrec :: Int -> MapDiff m a -> ShowS # show :: MapDiff m a -> String # showList :: [MapDiff m a] -> ShowS #
Generic (MapDiff m a) Source #
Associated Types type Rep (MapDiff m a) :: * -> * # Methods from :: MapDiff m a -> Rep (MapDiff m a) x # to :: Rep (MapDiff m a) x -> MapDiff m a #
(Diff a, Show a, ShowPatch (Edit a)) => ShowPatch (MapDiff IntMap a) Source #
Methods showPatch :: MapDiff IntMap a -> Doc Source #
(Diff a, Ord k, Show k, Show a, ShowPatch (Edit a)) => ShowPatch (MapDiff (Map k) a) Source #
Methods showPatch :: MapDiff (Map k) a -> Doc Source #
(Diff a, Hashable k, Eq k, Show k, Show a, ShowPatch (Edit a)) => ShowPatch (MapDiff (HashMap k) a) Source #
Methods showPatch :: MapDiff (HashMap k) a -> Doc Source #
Diff a => Patch (MapDiff IntMap a) Source #
Methods patchLevel :: MapDiff IntMap a -> DiffLevel Source # mergePatch :: MapDiff IntMap a -> MapDiff IntMap a -> MergeResult (MapDiff IntMap a) Source #
(Diff a, Ord k) => Patch (MapDiff (Map k) a) Source #
Methods patchLevel :: MapDiff (Map k) a -> DiffLevel Source # mergePatch :: MapDiff (Map k) a -> MapDiff (Map k) a -> MergeResult (MapDiff (Map k) a) Source #
(Hashable k, Eq k, Diff a) => Patch (MapDiff (HashMap k) a) Source #
Methods patchLevel :: MapDiff (HashMap k) a -> DiffLevel Source # mergePatch :: MapDiff (HashMap k) a -> MapDiff (HashMap k) a -> MergeResult (MapDiff (HashMap k) a) Source #
type Rep (MapDiff m a) Source #
type Rep (MapDiff m a) = D1 * (MetaData "MapDiff" "Data.Diff.Internal.Map" "data-diff-0.1.0.0-7AASwadXUeC9iuW5cOIQhE" True) (C1 * (MetaCons "MD" PrefixI True) (S1 * (MetaSel (Just Symbol "getMD") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (m (ValDiff a)))))