-----------------------------------------------------------------------------
-- |
-- Module      :  Data.Algorithm.DiffOutput
-- Copyright   :  (c) Sterling Clover 2008-2011, Kevin Charter 2011
-- License     :  BSD 3 Clause
-- Maintainer  :  s.clover@gmail.com
-- Stability   :  experimental
-- Portability :  portable
-- Author      :  Stephan Wehr (wehr@factisresearch.com) and JP Moresmau (jp@moresmau.fr)
--
-- Generates a string output that is similar to diff normal mode
-----------------------------------------------------------------------------
module Data.Algorithm.DiffOutput where
import Data.Algorithm.Diff
import Text.PrettyPrint
import Data.Char
import Data.List
import Data.Monoid (mappend)

-- | Converts Diffs to DiffOperations
diffToLineRanges :: [Diff [String]] -> [DiffOperation LineRange]
diffToLineRanges :: [Diff [String]] -> [DiffOperation LineRange]
diffToLineRanges = Int -> Int -> [Diff [String]] -> [DiffOperation LineRange]
toLineRange Int
1 Int
1
   where
          toLineRange :: Int -> Int -> [Diff [String]] -> [DiffOperation LineRange]
          toLineRange :: Int -> Int -> [Diff [String]] -> [DiffOperation LineRange]
toLineRange Int
_ Int
_ []=[]
          toLineRange Int
leftLine Int
rightLine (Both [String]
ls [String]
_:[Diff [String]]
rs)=
                let lins :: Int
lins=[String] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [String]
ls
                in  Int -> Int -> [Diff [String]] -> [DiffOperation LineRange]
toLineRange (Int
leftLineInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
lins) (Int
rightLineInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
lins) [Diff [String]]
rs
          toLineRange Int
leftLine Int
rightLine (Second [String]
lsS:First [String]
lsF:[Diff [String]]
rs)=
                Int
-> Int
-> [String]
-> [String]
-> [Diff [String]]
-> [DiffOperation LineRange]
toChange Int
leftLine Int
rightLine [String]
lsF [String]
lsS [Diff [String]]
rs
          toLineRange Int
leftLine Int
rightLine (First [String]
lsF:Second [String]
lsS:[Diff [String]]
rs)=
                Int
-> Int
-> [String]
-> [String]
-> [Diff [String]]
-> [DiffOperation LineRange]
toChange Int
leftLine Int
rightLine [String]
lsF [String]
lsS [Diff [String]]
rs
          toLineRange Int
leftLine Int
rightLine (Second [String]
lsS:[Diff [String]]
rs)=
                let linesS :: Int
linesS=[String] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [String]
lsS
                    diff :: DiffOperation LineRange
diff=LineRange -> Int -> DiffOperation LineRange
forall a. a -> Int -> DiffOperation a
Addition ((Int, Int) -> [String] -> LineRange
LineRange (Int
rightLine,Int
rightLineInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
linesSInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1) [String]
lsS) (Int
leftLineInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1)
                in  DiffOperation LineRange
diff DiffOperation LineRange
-> [DiffOperation LineRange] -> [DiffOperation LineRange]
forall a. a -> [a] -> [a]
: Int -> Int -> [Diff [String]] -> [DiffOperation LineRange]
toLineRange Int
leftLine (Int
rightLineInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
linesS) [Diff [String]]
rs
          toLineRange Int
leftLine Int
rightLine  (First [String]
lsF:[Diff [String]]
rs)=
                let linesF :: Int
linesF=[String] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [String]
lsF
                    diff :: DiffOperation LineRange
diff=LineRange -> Int -> DiffOperation LineRange
forall a. a -> Int -> DiffOperation a
Deletion ((Int, Int) -> [String] -> LineRange
LineRange (Int
leftLine,Int
leftLineInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
linesFInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1) [String]
lsF) (Int
rightLineInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1)
                in  DiffOperation LineRange
diffDiffOperation LineRange
-> [DiffOperation LineRange] -> [DiffOperation LineRange]
forall a. a -> [a] -> [a]
: Int -> Int -> [Diff [String]] -> [DiffOperation LineRange]
toLineRange(Int
leftLineInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
linesF) Int
rightLine [Diff [String]]
rs
          toChange :: Int
-> Int
-> [String]
-> [String]
-> [Diff [String]]
-> [DiffOperation LineRange]
toChange Int
leftLine Int
rightLine [String]
lsF [String]
lsS [Diff [String]]
rs=
                let linesS :: Int
linesS=[String] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [String]
lsS
                    linesF :: Int
linesF=[String] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [String]
lsF
                in  LineRange -> LineRange -> DiffOperation LineRange
forall a. a -> a -> DiffOperation a
Change ((Int, Int) -> [String] -> LineRange
LineRange (Int
leftLine,Int
leftLineInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
linesFInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1) [String]
lsF) ((Int, Int) -> [String] -> LineRange
LineRange (Int
rightLine,Int
rightLineInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
linesSInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1) [String]
lsS)
                        DiffOperation LineRange
-> [DiffOperation LineRange] -> [DiffOperation LineRange]
forall a. a -> [a] -> [a]
: Int -> Int -> [Diff [String]] -> [DiffOperation LineRange]
toLineRange (Int
leftLineInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
linesF) (Int
rightLineInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
linesS) [Diff [String]]
rs

-- | pretty print the differences. The output is similar to the output of the diff utility
ppDiff :: [Diff [String]] -> String
ppDiff :: [Diff [String]] -> String
ppDiff [Diff [String]]
gdiff =
   let  diffLineRanges :: [DiffOperation LineRange]
diffLineRanges = [Diff [String]] -> [DiffOperation LineRange]
diffToLineRanges [Diff [String]]
gdiff
   in
        Doc -> String
render ([DiffOperation LineRange] -> Doc
prettyDiffs [DiffOperation LineRange]
diffLineRanges) String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"\n"


-- | pretty print of diff operations
prettyDiffs :: [DiffOperation LineRange] -> Doc
prettyDiffs :: [DiffOperation LineRange] -> Doc
prettyDiffs [] = Doc
empty
prettyDiffs (DiffOperation LineRange
d : [DiffOperation LineRange]
rest) = DiffOperation LineRange -> Doc
prettyDiff DiffOperation LineRange
d Doc -> Doc -> Doc
$$ [DiffOperation LineRange] -> Doc
prettyDiffs [DiffOperation LineRange]
rest
    where
      prettyDiff :: DiffOperation LineRange -> Doc
prettyDiff (Deletion LineRange
inLeft Int
lineNoRight) =
          (Int, Int) -> Doc
prettyRange (LineRange -> (Int, Int)
lrNumbers LineRange
inLeft) Doc -> Doc -> Doc
forall a. Monoid a => a -> a -> a
`mappend` Char -> Doc
char Char
'd' Doc -> Doc -> Doc
forall a. Monoid a => a -> a -> a
`mappend` Int -> Doc
int Int
lineNoRight Doc -> Doc -> Doc
$$
          Char -> [String] -> Doc
prettyLines Char
'<' (LineRange -> [String]
lrContents LineRange
inLeft)
      prettyDiff (Addition LineRange
inRight Int
lineNoLeft) =
          Int -> Doc
int Int
lineNoLeft Doc -> Doc -> Doc
forall a. Monoid a => a -> a -> a
`mappend` Char -> Doc
char Char
'a' Doc -> Doc -> Doc
forall a. Monoid a => a -> a -> a
`mappend` (Int, Int) -> Doc
prettyRange (LineRange -> (Int, Int)
lrNumbers LineRange
inRight) Doc -> Doc -> Doc
$$
          Char -> [String] -> Doc
prettyLines Char
'>' (LineRange -> [String]
lrContents LineRange
inRight)
      prettyDiff (Change LineRange
inLeft LineRange
inRight) =
          (Int, Int) -> Doc
prettyRange (LineRange -> (Int, Int)
lrNumbers LineRange
inLeft) Doc -> Doc -> Doc
forall a. Monoid a => a -> a -> a
`mappend` Char -> Doc
char Char
'c' Doc -> Doc -> Doc
forall a. Monoid a => a -> a -> a
`mappend` (Int, Int) -> Doc
prettyRange (LineRange -> (Int, Int)
lrNumbers LineRange
inRight) Doc -> Doc -> Doc
$$
          Char -> [String] -> Doc
prettyLines Char
'<' (LineRange -> [String]
lrContents LineRange
inLeft) Doc -> Doc -> Doc
$$
          String -> Doc
text String
"---" Doc -> Doc -> Doc
$$
          Char -> [String] -> Doc
prettyLines Char
'>' (LineRange -> [String]
lrContents LineRange
inRight)
      prettyRange :: (Int, Int) -> Doc
prettyRange (Int
start, Int
end) =
          if Int
start Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
end then Int -> Doc
int Int
start else Int -> Doc
int Int
start Doc -> Doc -> Doc
forall a. Monoid a => a -> a -> a
`mappend` Doc
comma Doc -> Doc -> Doc
forall a. Monoid a => a -> a -> a
`mappend` Int -> Doc
int Int
end
      prettyLines :: Char -> [String] -> Doc
prettyLines Char
start [String]
lins =
          [Doc] -> Doc
vcat ((String -> Doc) -> [String] -> [Doc]
forall a b. (a -> b) -> [a] -> [b]
map (\String
l -> Char -> Doc
char Char
start Doc -> Doc -> Doc
<+> String -> Doc
text String
l) [String]
lins)

-- | Parse pretty printed Diffs as DiffOperations
parsePrettyDiffs :: String -> [DiffOperation LineRange]
parsePrettyDiffs :: String -> [DiffOperation LineRange]
parsePrettyDiffs = [DiffOperation LineRange] -> [DiffOperation LineRange]
forall a. [a] -> [a]
reverse ([DiffOperation LineRange] -> [DiffOperation LineRange])
-> (String -> [DiffOperation LineRange])
-> String
-> [DiffOperation LineRange]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [DiffOperation LineRange] -> [String] -> [DiffOperation LineRange]
doParse [] ([String] -> [DiffOperation LineRange])
-> (String -> [String]) -> String -> [DiffOperation LineRange]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> [String]
lines
  where
    doParse :: [DiffOperation LineRange] -> [String] -> [DiffOperation LineRange]
doParse [DiffOperation LineRange]
diffs [] = [DiffOperation LineRange]
diffs
    doParse [DiffOperation LineRange]
diffs [String]
s =
        let (Maybe (DiffOperation LineRange)
mnd,[String]
r) = [String] -> (Maybe (DiffOperation LineRange), [String])
parseDiff [String]
s
        in case Maybe (DiffOperation LineRange)
mnd of
            Just DiffOperation LineRange
nd -> [DiffOperation LineRange] -> [String] -> [DiffOperation LineRange]
doParse (DiffOperation LineRange
ndDiffOperation LineRange
-> [DiffOperation LineRange] -> [DiffOperation LineRange]
forall a. a -> [a] -> [a]
:[DiffOperation LineRange]
diffs) [String]
r
            Maybe (DiffOperation LineRange)
_          -> [DiffOperation LineRange] -> [String] -> [DiffOperation LineRange]
doParse [DiffOperation LineRange]
diffs [String]
r
    parseDiff :: [String] -> (Maybe (DiffOperation LineRange), [String])
parseDiff [] = (Maybe (DiffOperation LineRange)
forall a. Maybe a
Nothing,[])
    parseDiff (String
h:[String]
rs) = let
        ((Int, Int)
r1,String
hrs1) = String -> ((Int, Int), String)
parseRange String
h
        in case String
hrs1 of
                (Char
'd':String
hrs2) -> (Int, Int)
-> String
-> [String]
-> (Maybe (DiffOperation LineRange), [String])
parseDel (Int, Int)
r1 String
hrs2 [String]
rs
                (Char
'a':String
hrs2) -> (Int, Int)
-> String
-> [String]
-> (Maybe (DiffOperation LineRange), [String])
forall b.
(Int, b)
-> String
-> [String]
-> (Maybe (DiffOperation LineRange), [String])
parseAdd (Int, Int)
r1 String
hrs2 [String]
rs
                (Char
'c':String
hrs2) -> (Int, Int)
-> String
-> [String]
-> (Maybe (DiffOperation LineRange), [String])
parseChange (Int, Int)
r1 String
hrs2 [String]
rs
                String
_ -> (Maybe (DiffOperation LineRange)
forall a. Maybe a
Nothing,[String]
rs)
    parseDel :: (Int, Int)
-> String
-> [String]
-> (Maybe (DiffOperation LineRange), [String])
parseDel (Int, Int)
r1 String
hrs2 [String]
rs = let
        ((Int, Int)
r2,String
_) = String -> ((Int, Int), String)
parseRange String
hrs2
        ([String]
ls,[String]
rs2) = (String -> Bool) -> [String] -> ([String], [String])
forall a. (a -> Bool) -> [a] -> ([a], [a])
span (String -> String -> Bool
forall a. Eq a => [a] -> [a] -> Bool
isPrefixOf String
"<") [String]
rs
        in (DiffOperation LineRange -> Maybe (DiffOperation LineRange)
forall a. a -> Maybe a
Just (DiffOperation LineRange -> Maybe (DiffOperation LineRange))
-> DiffOperation LineRange -> Maybe (DiffOperation LineRange)
forall a b. (a -> b) -> a -> b
$ LineRange -> Int -> DiffOperation LineRange
forall a. a -> Int -> DiffOperation a
Deletion ((Int, Int) -> [String] -> LineRange
LineRange (Int, Int)
r1 ((String -> String) -> [String] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map (Int -> String -> String
forall a. Int -> [a] -> [a]
drop Int
2) [String]
ls)) ((Int, Int) -> Int
forall a b. (a, b) -> a
fst (Int, Int)
r2), [String]
rs2)
    parseAdd :: (Int, b)
-> String
-> [String]
-> (Maybe (DiffOperation LineRange), [String])
parseAdd (Int, b)
r1 String
hrs2 [String]
rs = let
        ((Int, Int)
r2,String
_) = String -> ((Int, Int), String)
parseRange String
hrs2
        ([String]
ls,[String]
rs2) = (String -> Bool) -> [String] -> ([String], [String])
forall a. (a -> Bool) -> [a] -> ([a], [a])
span (String -> String -> Bool
forall a. Eq a => [a] -> [a] -> Bool
isPrefixOf String
">") [String]
rs
        in (DiffOperation LineRange -> Maybe (DiffOperation LineRange)
forall a. a -> Maybe a
Just (DiffOperation LineRange -> Maybe (DiffOperation LineRange))
-> DiffOperation LineRange -> Maybe (DiffOperation LineRange)
forall a b. (a -> b) -> a -> b
$ LineRange -> Int -> DiffOperation LineRange
forall a. a -> Int -> DiffOperation a
Addition ((Int, Int) -> [String] -> LineRange
LineRange (Int, Int)
r2 ((String -> String) -> [String] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map (Int -> String -> String
forall a. Int -> [a] -> [a]
drop Int
2) [String]
ls)) ((Int, b) -> Int
forall a b. (a, b) -> a
fst (Int, b)
r1), [String]
rs2)
    parseChange :: (Int, Int)
-> String
-> [String]
-> (Maybe (DiffOperation LineRange), [String])
parseChange (Int, Int)
r1 String
hrs2 [String]
rs = let
        ((Int, Int)
r2,String
_) = String -> ((Int, Int), String)
parseRange String
hrs2
        ([String]
ls1,[String]
rs2) = (String -> Bool) -> [String] -> ([String], [String])
forall a. (a -> Bool) -> [a] -> ([a], [a])
span (String -> String -> Bool
forall a. Eq a => [a] -> [a] -> Bool
isPrefixOf String
"<") [String]
rs
        in case [String]
rs2 of
            (String
"---":[String]
rs3) -> let
                ([String]
ls2,[String]
rs4) = (String -> Bool) -> [String] -> ([String], [String])
forall a. (a -> Bool) -> [a] -> ([a], [a])
span (String -> String -> Bool
forall a. Eq a => [a] -> [a] -> Bool
isPrefixOf String
">") [String]
rs3
                in (DiffOperation LineRange -> Maybe (DiffOperation LineRange)
forall a. a -> Maybe a
Just (DiffOperation LineRange -> Maybe (DiffOperation LineRange))
-> DiffOperation LineRange -> Maybe (DiffOperation LineRange)
forall a b. (a -> b) -> a -> b
$ LineRange -> LineRange -> DiffOperation LineRange
forall a. a -> a -> DiffOperation a
Change ((Int, Int) -> [String] -> LineRange
LineRange (Int, Int)
r1 ((String -> String) -> [String] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map (Int -> String -> String
forall a. Int -> [a] -> [a]
drop Int
2) [String]
ls1)) ((Int, Int) -> [String] -> LineRange
LineRange (Int, Int)
r2 ((String -> String) -> [String] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map (Int -> String -> String
forall a. Int -> [a] -> [a]
drop Int
2) [String]
ls2)), [String]
rs4)
            [String]
_ -> (Maybe (DiffOperation LineRange)
forall a. Maybe a
Nothing,[String]
rs2)
    parseRange :: String -> ((LineNo, LineNo),String)
    parseRange :: String -> ((Int, Int), String)
parseRange String
l = let
        (String
fstLine,String
rs) = (Char -> Bool) -> String -> (String, String)
forall a. (a -> Bool) -> [a] -> ([a], [a])
span Char -> Bool
isDigit String
l
        (String
sndLine,String
rs3) = case String
rs of
                                    (Char
',':String
rs2) -> (Char -> Bool) -> String -> (String, String)
forall a. (a -> Bool) -> [a] -> ([a], [a])
span Char -> Bool
isDigit String
rs2
                                    String
_ -> (String
fstLine,String
rs)
        in ((String -> Int
forall a. Read a => String -> a
read String
fstLine,String -> Int
forall a. Read a => String -> a
read String
sndLine),String
rs3)

-- | Line number alias
type LineNo = Int

-- | Line Range: start, end and contents
data LineRange = LineRange { LineRange -> (Int, Int)
lrNumbers :: (LineNo, LineNo)
                           , LineRange -> [String]
lrContents :: [String]
                           }
            deriving (Int -> LineRange -> String -> String
[LineRange] -> String -> String
LineRange -> String
(Int -> LineRange -> String -> String)
-> (LineRange -> String)
-> ([LineRange] -> String -> String)
-> Show LineRange
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [LineRange] -> String -> String
$cshowList :: [LineRange] -> String -> String
show :: LineRange -> String
$cshow :: LineRange -> String
showsPrec :: Int -> LineRange -> String -> String
$cshowsPrec :: Int -> LineRange -> String -> String
Show,ReadPrec [LineRange]
ReadPrec LineRange
Int -> ReadS LineRange
ReadS [LineRange]
(Int -> ReadS LineRange)
-> ReadS [LineRange]
-> ReadPrec LineRange
-> ReadPrec [LineRange]
-> Read LineRange
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [LineRange]
$creadListPrec :: ReadPrec [LineRange]
readPrec :: ReadPrec LineRange
$creadPrec :: ReadPrec LineRange
readList :: ReadS [LineRange]
$creadList :: ReadS [LineRange]
readsPrec :: Int -> ReadS LineRange
$creadsPrec :: Int -> ReadS LineRange
Read,LineRange -> LineRange -> Bool
(LineRange -> LineRange -> Bool)
-> (LineRange -> LineRange -> Bool) -> Eq LineRange
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LineRange -> LineRange -> Bool
$c/= :: LineRange -> LineRange -> Bool
== :: LineRange -> LineRange -> Bool
$c== :: LineRange -> LineRange -> Bool
Eq,Eq LineRange
Eq LineRange
-> (LineRange -> LineRange -> Ordering)
-> (LineRange -> LineRange -> Bool)
-> (LineRange -> LineRange -> Bool)
-> (LineRange -> LineRange -> Bool)
-> (LineRange -> LineRange -> Bool)
-> (LineRange -> LineRange -> LineRange)
-> (LineRange -> LineRange -> LineRange)
-> Ord LineRange
LineRange -> LineRange -> Bool
LineRange -> LineRange -> Ordering
LineRange -> LineRange -> LineRange
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: LineRange -> LineRange -> LineRange
$cmin :: LineRange -> LineRange -> LineRange
max :: LineRange -> LineRange -> LineRange
$cmax :: LineRange -> LineRange -> LineRange
>= :: LineRange -> LineRange -> Bool
$c>= :: LineRange -> LineRange -> Bool
> :: LineRange -> LineRange -> Bool
$c> :: LineRange -> LineRange -> Bool
<= :: LineRange -> LineRange -> Bool
$c<= :: LineRange -> LineRange -> Bool
< :: LineRange -> LineRange -> Bool
$c< :: LineRange -> LineRange -> Bool
compare :: LineRange -> LineRange -> Ordering
$ccompare :: LineRange -> LineRange -> Ordering
$cp1Ord :: Eq LineRange
Ord)

-- | Diff Operation  representing changes to apply
data DiffOperation a = Deletion a LineNo
            | Addition a LineNo
            | Change a a
            deriving (Int -> DiffOperation a -> String -> String
[DiffOperation a] -> String -> String
DiffOperation a -> String
(Int -> DiffOperation a -> String -> String)
-> (DiffOperation a -> String)
-> ([DiffOperation a] -> String -> String)
-> Show (DiffOperation a)
forall a. Show a => Int -> DiffOperation a -> String -> String
forall a. Show a => [DiffOperation a] -> String -> String
forall a. Show a => DiffOperation a -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [DiffOperation a] -> String -> String
$cshowList :: forall a. Show a => [DiffOperation a] -> String -> String
show :: DiffOperation a -> String
$cshow :: forall a. Show a => DiffOperation a -> String
showsPrec :: Int -> DiffOperation a -> String -> String
$cshowsPrec :: forall a. Show a => Int -> DiffOperation a -> String -> String
Show,ReadPrec [DiffOperation a]
ReadPrec (DiffOperation a)
Int -> ReadS (DiffOperation a)
ReadS [DiffOperation a]
(Int -> ReadS (DiffOperation a))
-> ReadS [DiffOperation a]
-> ReadPrec (DiffOperation a)
-> ReadPrec [DiffOperation a]
-> Read (DiffOperation a)
forall a. Read a => ReadPrec [DiffOperation a]
forall a. Read a => ReadPrec (DiffOperation a)
forall a. Read a => Int -> ReadS (DiffOperation a)
forall a. Read a => ReadS [DiffOperation a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DiffOperation a]
$creadListPrec :: forall a. Read a => ReadPrec [DiffOperation a]
readPrec :: ReadPrec (DiffOperation a)
$creadPrec :: forall a. Read a => ReadPrec (DiffOperation a)
readList :: ReadS [DiffOperation a]
$creadList :: forall a. Read a => ReadS [DiffOperation a]
readsPrec :: Int -> ReadS (DiffOperation a)
$creadsPrec :: forall a. Read a => Int -> ReadS (DiffOperation a)
Read,DiffOperation a -> DiffOperation a -> Bool
(DiffOperation a -> DiffOperation a -> Bool)
-> (DiffOperation a -> DiffOperation a -> Bool)
-> Eq (DiffOperation a)
forall a. Eq a => DiffOperation a -> DiffOperation a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DiffOperation a -> DiffOperation a -> Bool
$c/= :: forall a. Eq a => DiffOperation a -> DiffOperation a -> Bool
== :: DiffOperation a -> DiffOperation a -> Bool
$c== :: forall a. Eq a => DiffOperation a -> DiffOperation a -> Bool
Eq,Eq (DiffOperation a)
Eq (DiffOperation a)
-> (DiffOperation a -> DiffOperation a -> Ordering)
-> (DiffOperation a -> DiffOperation a -> Bool)
-> (DiffOperation a -> DiffOperation a -> Bool)
-> (DiffOperation a -> DiffOperation a -> Bool)
-> (DiffOperation a -> DiffOperation a -> Bool)
-> (DiffOperation a -> DiffOperation a -> DiffOperation a)
-> (DiffOperation a -> DiffOperation a -> DiffOperation a)
-> Ord (DiffOperation a)
DiffOperation a -> DiffOperation a -> Bool
DiffOperation a -> DiffOperation a -> Ordering
DiffOperation a -> DiffOperation a -> DiffOperation a
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (DiffOperation a)
forall a. Ord a => DiffOperation a -> DiffOperation a -> Bool
forall a. Ord a => DiffOperation a -> DiffOperation a -> Ordering
forall a.
Ord a =>
DiffOperation a -> DiffOperation a -> DiffOperation a
min :: DiffOperation a -> DiffOperation a -> DiffOperation a
$cmin :: forall a.
Ord a =>
DiffOperation a -> DiffOperation a -> DiffOperation a
max :: DiffOperation a -> DiffOperation a -> DiffOperation a
$cmax :: forall a.
Ord a =>
DiffOperation a -> DiffOperation a -> DiffOperation a
>= :: DiffOperation a -> DiffOperation a -> Bool
$c>= :: forall a. Ord a => DiffOperation a -> DiffOperation a -> Bool
> :: DiffOperation a -> DiffOperation a -> Bool
$c> :: forall a. Ord a => DiffOperation a -> DiffOperation a -> Bool
<= :: DiffOperation a -> DiffOperation a -> Bool
$c<= :: forall a. Ord a => DiffOperation a -> DiffOperation a -> Bool
< :: DiffOperation a -> DiffOperation a -> Bool
$c< :: forall a. Ord a => DiffOperation a -> DiffOperation a -> Bool
compare :: DiffOperation a -> DiffOperation a -> Ordering
$ccompare :: forall a. Ord a => DiffOperation a -> DiffOperation a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (DiffOperation a)
Ord)