-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Test monadic programs using state machine based models
--   
--   See README at
--   <a>https://github.com/stevana/quickcheck-state-machine#readme</a>
@package quickcheck-state-machine
@version 0.9.0


-- | A list diff.
module Test.StateMachine.TreeDiff.List

-- | List difference.
--   
--   <pre>
--   &gt;&gt;&gt; diffBy (==) "hello" "world"
--   [Swp 'h' 'w',Swp 'e' 'o',Swp 'l' 'r',Cpy 'l',Swp 'o' 'd']
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; diffBy (==) "kitten" "sitting"
--   [Swp 'k' 's',Cpy 'i',Cpy 't',Cpy 't',Swp 'e' 'i',Cpy 'n',Ins 'g']
--   </pre>
--   
--   <pre>
--   \xs ys -&gt; length (diffBy (==) xs ys) &gt;= max (length xs) (length (ys :: String))
--   </pre>
--   
--   <pre>
--   \xs ys -&gt; length (diffBy (==) xs ys) &lt;= length xs + length (ys :: String)
--   </pre>
--   
--   <i>Note:</i> currently this has O(n*m) memory requirements, for the
--   sake of more obviously correct implementation.
diffBy :: forall a. (a -> a -> Bool) -> [a] -> [a] -> [Edit a]

-- | List edit operations
--   
--   The <a>Swp</a> constructor is redundant, but it let us spot a
--   recursion point when performing tree diffs.
data Edit a

-- | insert
Ins :: a -> Edit a

-- | delete
Del :: a -> Edit a

-- | copy unchanged
Cpy :: a -> Edit a

-- | swap, i.e. delete + insert
Swp :: a -> a -> Edit a
instance GHC.Show.Show a => GHC.Show.Show (Test.StateMachine.TreeDiff.List.Edit a)


-- | This module uses <a>Expr</a> for richer diffs than based on
--   <tt>Tree</tt>.
module Test.StateMachine.TreeDiff.Expr

-- | A untyped Haskell-like expression.
--   
--   Having richer structure than just <tt>Tree</tt> allows to have richer
--   diffs.
data Expr

-- | application
App :: ConstructorName -> [Expr] -> Expr

-- | record constructor
Rec :: ConstructorName -> Map FieldName Expr -> Expr

-- | list constructor
Lst :: [Expr] -> Expr

-- | Constructor name is a string
type ConstructorName = String

-- | Record field name is a string too.
type FieldName = String

-- | Type used in the result of <tt>ediff</tt>.
data EditExpr
EditApp :: ConstructorName -> [Edit EditExpr] -> EditExpr
EditRec :: ConstructorName -> Map FieldName (Edit EditExpr) -> EditExpr
EditLst :: [Edit EditExpr] -> EditExpr

-- | unchanged tree
EditExp :: Expr -> EditExpr

-- | List edit operations
--   
--   The <a>Swp</a> constructor is redundant, but it let us spot a
--   recursion point when performing tree diffs.
data Edit a

-- | insert
Ins :: a -> Edit a

-- | delete
Del :: a -> Edit a

-- | copy unchanged
Cpy :: a -> Edit a

-- | swap, i.e. delete + insert
Swp :: a -> a -> Edit a

-- | Diff two <a>Expr</a>.
--   
--   For examples see <tt>ediff</tt> in <a>Data.TreeDiff.Class</a>.
exprDiff :: Expr -> Expr -> Edit EditExpr
instance GHC.Show.Show Test.StateMachine.TreeDiff.Expr.Expr
instance GHC.Classes.Eq Test.StateMachine.TreeDiff.Expr.Expr
instance GHC.Show.Show Test.StateMachine.TreeDiff.Expr.EditExpr
instance Test.QuickCheck.Arbitrary.Arbitrary Test.StateMachine.TreeDiff.Expr.Expr


-- | A <a>ToExpr</a> class.
module Test.StateMachine.TreeDiff.Class

-- | Difference between two <a>ToExpr</a> values.
--   
--   <pre>
--   &gt;&gt;&gt; let x = (1, Just 2) :: (Int, Maybe Int)
--   
--   &gt;&gt;&gt; let y = (1, Nothing)
--   
--   &gt;&gt;&gt; prettyEditExpr (ediff x y)
--   _×_ 1 -(Just 2) +Nothing
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; data Foo = Foo { fooInt :: Either Char Int, fooBool :: [Maybe Bool], fooString :: String } deriving (Eq, Generic)
--   
--   &gt;&gt;&gt; instance ToExpr Foo
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; prettyEditExpr $ ediff (Foo (Right 2) [Just True] "fo") (Foo (Right 3) [Just True] "fo")
--   Foo {fooBool = [Just True], fooInt = Right -2 +3, fooString = "fo"}
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; prettyEditExpr $ ediff (Foo (Right 42) [Just True, Just False] "old") (Foo (Right 42) [Nothing, Just False, Just True] "new")
--   Foo
--     {fooBool = [-Just True, +Nothing, Just False, +Just True],
--      fooInt = Right 42,
--      fooString = -"old" +"new"}
--   </pre>
ediff :: ToExpr a => a -> a -> Edit EditExpr

-- | Compare different types.
--   
--   <i>Note:</i> Use with care as you can end up comparing apples with
--   oranges.
--   
--   <pre>
--   &gt;&gt;&gt; prettyEditExpr $ ediff' ["foo", "bar"] [Just "foo", Nothing]
--   [-"foo", +Just "foo", -"bar", +Nothing]
--   </pre>
ediff' :: (ToExpr a, ToExpr b) => a -> b -> Edit EditExpr

-- | <a>toExpr</a> converts a Haskell value into untyped Haskell-like
--   syntax tree, <a>Expr</a>.
--   
--   <pre>
--   &gt;&gt;&gt; toExpr ((1, Just 2) :: (Int, Maybe Int))
--   App "_\215_" [App "1" [],App "Just" [App "2" []]]
--   </pre>
class ToExpr a
toExpr :: ToExpr a => a -> Expr
toExpr :: (ToExpr a, Generic a, All2 ToExpr (GCode a), GFrom a, GDatatypeInfo a) => a -> Expr
listToExpr :: ToExpr a => [a] -> Expr

-- | An alternative implementation for literal types. We use <a>show</a>
--   representation of them.
defaultExprViaShow :: Show a => a -> Expr

-- | <pre>
--   &gt;&gt;&gt; prettyExpr $ sopToExpr (gdatatypeInfo (Proxy :: Proxy String)) (gfrom "foo")
--   _:_ 'f' "oo"
--   </pre>
sopToExpr :: All2 ToExpr xss => DatatypeInfo xss -> SOP I xss -> Expr
instance Test.StateMachine.TreeDiff.Class.ToExpr Test.StateMachine.TreeDiff.Expr.Expr
instance Test.StateMachine.TreeDiff.Class.ToExpr ()
instance Test.StateMachine.TreeDiff.Class.ToExpr GHC.Types.Bool
instance Test.StateMachine.TreeDiff.Class.ToExpr GHC.Types.Ordering
instance Test.StateMachine.TreeDiff.Class.ToExpr GHC.Num.Integer.Integer
instance Test.StateMachine.TreeDiff.Class.ToExpr GHC.Num.Natural.Natural
instance Test.StateMachine.TreeDiff.Class.ToExpr GHC.Types.Float
instance Test.StateMachine.TreeDiff.Class.ToExpr GHC.Types.Double
instance Test.StateMachine.TreeDiff.Class.ToExpr GHC.Types.Int
instance Test.StateMachine.TreeDiff.Class.ToExpr GHC.Int.Int8
instance Test.StateMachine.TreeDiff.Class.ToExpr GHC.Int.Int16
instance Test.StateMachine.TreeDiff.Class.ToExpr GHC.Int.Int32
instance Test.StateMachine.TreeDiff.Class.ToExpr GHC.Int.Int64
instance Test.StateMachine.TreeDiff.Class.ToExpr GHC.Types.Word
instance Test.StateMachine.TreeDiff.Class.ToExpr GHC.Word.Word8
instance Test.StateMachine.TreeDiff.Class.ToExpr GHC.Word.Word16
instance Test.StateMachine.TreeDiff.Class.ToExpr GHC.Word.Word32
instance Test.StateMachine.TreeDiff.Class.ToExpr GHC.Word.Word64
instance Test.StateMachine.TreeDiff.Class.ToExpr (Data.Proxy.Proxy a)
instance Test.StateMachine.TreeDiff.Class.ToExpr GHC.Types.Char
instance Test.StateMachine.TreeDiff.Class.ToExpr a => Test.StateMachine.TreeDiff.Class.ToExpr (GHC.Maybe.Maybe a)
instance (Test.StateMachine.TreeDiff.Class.ToExpr a, Test.StateMachine.TreeDiff.Class.ToExpr b) => Test.StateMachine.TreeDiff.Class.ToExpr (Data.Either.Either a b)
instance Test.StateMachine.TreeDiff.Class.ToExpr a => Test.StateMachine.TreeDiff.Class.ToExpr [a]
instance (Test.StateMachine.TreeDiff.Class.ToExpr a, Test.StateMachine.TreeDiff.Class.ToExpr b) => Test.StateMachine.TreeDiff.Class.ToExpr (a, b)
instance (Test.StateMachine.TreeDiff.Class.ToExpr a, Test.StateMachine.TreeDiff.Class.ToExpr b, Test.StateMachine.TreeDiff.Class.ToExpr c) => Test.StateMachine.TreeDiff.Class.ToExpr (a, b, c)
instance (Test.StateMachine.TreeDiff.Class.ToExpr a, Test.StateMachine.TreeDiff.Class.ToExpr b, Test.StateMachine.TreeDiff.Class.ToExpr c, Test.StateMachine.TreeDiff.Class.ToExpr d) => Test.StateMachine.TreeDiff.Class.ToExpr (a, b, c, d)
instance (Test.StateMachine.TreeDiff.Class.ToExpr a, Test.StateMachine.TreeDiff.Class.ToExpr b, Test.StateMachine.TreeDiff.Class.ToExpr c, Test.StateMachine.TreeDiff.Class.ToExpr d, Test.StateMachine.TreeDiff.Class.ToExpr e) => Test.StateMachine.TreeDiff.Class.ToExpr (a, b, c, d, e)
instance (Test.StateMachine.TreeDiff.Class.ToExpr a, GHC.Real.Integral a) => Test.StateMachine.TreeDiff.Class.ToExpr (GHC.Real.Ratio a)
instance Data.Fixed.HasResolution a => Test.StateMachine.TreeDiff.Class.ToExpr (Data.Fixed.Fixed a)
instance Test.StateMachine.TreeDiff.Class.ToExpr a => Test.StateMachine.TreeDiff.Class.ToExpr (Data.Functor.Identity.Identity a)
instance Test.StateMachine.TreeDiff.Class.ToExpr a => Test.StateMachine.TreeDiff.Class.ToExpr (Data.Functor.Const.Const a b)
instance Test.StateMachine.TreeDiff.Class.ToExpr a => Test.StateMachine.TreeDiff.Class.ToExpr (Control.Applicative.ZipList a)
instance Test.StateMachine.TreeDiff.Class.ToExpr a => Test.StateMachine.TreeDiff.Class.ToExpr (GHC.Base.NonEmpty a)
instance Test.StateMachine.TreeDiff.Class.ToExpr GHC.Base.Void
instance Test.StateMachine.TreeDiff.Class.ToExpr a => Test.StateMachine.TreeDiff.Class.ToExpr (Data.Semigroup.Internal.Dual a)
instance Test.StateMachine.TreeDiff.Class.ToExpr a => Test.StateMachine.TreeDiff.Class.ToExpr (Data.Semigroup.Internal.Sum a)
instance Test.StateMachine.TreeDiff.Class.ToExpr a => Test.StateMachine.TreeDiff.Class.ToExpr (Data.Semigroup.Internal.Product a)
instance Test.StateMachine.TreeDiff.Class.ToExpr a => Test.StateMachine.TreeDiff.Class.ToExpr (Data.Monoid.First a)
instance Test.StateMachine.TreeDiff.Class.ToExpr a => Test.StateMachine.TreeDiff.Class.ToExpr (Data.Monoid.Last a)
instance Test.StateMachine.TreeDiff.Class.ToExpr a => Test.StateMachine.TreeDiff.Class.ToExpr (Data.Semigroup.Min a)
instance Test.StateMachine.TreeDiff.Class.ToExpr a => Test.StateMachine.TreeDiff.Class.ToExpr (Data.Semigroup.Max a)
instance Test.StateMachine.TreeDiff.Class.ToExpr a => Test.StateMachine.TreeDiff.Class.ToExpr (Data.Semigroup.First a)
instance Test.StateMachine.TreeDiff.Class.ToExpr a => Test.StateMachine.TreeDiff.Class.ToExpr (Data.Semigroup.Last a)
instance Test.StateMachine.TreeDiff.Class.ToExpr a => Test.StateMachine.TreeDiff.Class.ToExpr (Data.Tree.Tree a)
instance (Test.StateMachine.TreeDiff.Class.ToExpr k, Test.StateMachine.TreeDiff.Class.ToExpr v) => Test.StateMachine.TreeDiff.Class.ToExpr (Data.Map.Internal.Map k v)
instance Test.StateMachine.TreeDiff.Class.ToExpr k => Test.StateMachine.TreeDiff.Class.ToExpr (Data.Set.Internal.Set k)
instance Test.StateMachine.TreeDiff.Class.ToExpr v => Test.StateMachine.TreeDiff.Class.ToExpr (Data.IntMap.Internal.IntMap v)
instance Test.StateMachine.TreeDiff.Class.ToExpr Data.IntSet.Internal.IntSet
instance Test.StateMachine.TreeDiff.Class.ToExpr v => Test.StateMachine.TreeDiff.Class.ToExpr (Data.Sequence.Internal.Seq v)
instance Test.StateMachine.TreeDiff.Class.ToExpr Data.Text.Internal.Lazy.Text
instance Test.StateMachine.TreeDiff.Class.ToExpr Data.Text.Internal.Text
instance Test.StateMachine.TreeDiff.Class.ToExpr Data.Time.Calendar.Days.Day
instance Test.StateMachine.TreeDiff.Class.ToExpr Data.Time.Clock.Internal.UTCTime.UTCTime
instance Test.StateMachine.TreeDiff.Class.ToExpr Data.ByteString.Lazy.Internal.ByteString
instance Test.StateMachine.TreeDiff.Class.ToExpr Data.ByteString.Internal.Type.ByteString
instance Test.StateMachine.TreeDiff.Class.ToExpr a => Test.StateMachine.TreeDiff.Class.ToExpr (Data.Vector.Vector a)
instance (Test.StateMachine.TreeDiff.Class.ToExpr a, Data.Vector.Unboxed.Base.Unbox a) => Test.StateMachine.TreeDiff.Class.ToExpr (Data.Vector.Unboxed.Base.Vector a)
instance (Test.StateMachine.TreeDiff.Class.ToExpr a, Foreign.Storable.Storable a) => Test.StateMachine.TreeDiff.Class.ToExpr (Data.Vector.Storable.Vector a)
instance (Test.StateMachine.TreeDiff.Class.ToExpr a, Data.Primitive.Types.Prim a) => Test.StateMachine.TreeDiff.Class.ToExpr (Data.Vector.Primitive.Vector a)


-- | Utilities to pretty print <a>Expr</a> and <a>EditExpr</a>
module Test.StateMachine.TreeDiff.Pretty

-- | Because we don't want to commit to single pretty printing library, we
--   use explicit dictionary.
data Pretty doc
Pretty :: (ConstructorName -> doc) -> ([(FieldName, doc)] -> doc) -> ([doc] -> doc) -> (doc -> doc) -> (doc -> doc) -> (doc -> doc) -> ([doc] -> doc) -> (doc -> doc) -> (doc -> doc -> doc) -> Pretty doc
[ppCon] :: Pretty doc -> ConstructorName -> doc
[ppRec] :: Pretty doc -> [(FieldName, doc)] -> doc
[ppLst] :: Pretty doc -> [doc] -> doc
[ppCpy] :: Pretty doc -> doc -> doc
[ppIns] :: Pretty doc -> doc -> doc
[ppDel] :: Pretty doc -> doc -> doc
[ppSep] :: Pretty doc -> [doc] -> doc
[ppParens] :: Pretty doc -> doc -> doc
[ppHang] :: Pretty doc -> doc -> doc -> doc

-- | Pretty print an <a>Expr</a> using explicit pretty-printing dictionary.
ppExpr :: Pretty doc -> Expr -> doc

-- | Pretty print an <tt><a>Edit</a> <a>EditExpr</a></tt> using explicit
--   pretty-printing dictionary.
ppEditExpr :: Pretty doc -> Edit EditExpr -> doc

-- | Like <a>ppEditExpr</a> but print unchanged parts only shallowly
ppEditExprCompact :: Pretty doc -> Edit EditExpr -> doc

-- | <a>Pretty</a> via <tt>pretty</tt> library.
prettyPretty :: Pretty Doc

-- | Pretty print <a>Expr</a> using <tt>pretty</tt>.
--   
--   <pre>
--   &gt;&gt;&gt; prettyExpr $ Rec "ex" (Map.fromList [("[]", App "bar" [])])
--   ex {`[]` = bar}
--   </pre>
prettyExpr :: Expr -> Doc

-- | Pretty print <tt><a>Edit</a> <a>EditExpr</a></tt> using
--   <tt>pretty</tt>.
prettyEditExpr :: Edit EditExpr -> Doc

-- | Compact <a>prettyEditExpr</a>.
prettyEditExprCompact :: Edit EditExpr -> Doc

-- | <a>Pretty</a> via <tt>ansi-wl-pprint</tt> library (with colors).
ansiWlPretty :: Pretty Doc

-- | Pretty print <a>Expr</a> using <tt>ansi-wl-pprint</tt>.
ansiWlExpr :: Expr -> Doc

-- | Pretty print <tt><a>Edit</a> <a>EditExpr</a></tt> using
--   <tt>ansi-wl-pprint</tt>.
ansiWlEditExpr :: Edit EditExpr -> Doc

-- | Compact <a>ansiWlEditExpr</a>
ansiWlEditExprCompact :: Edit EditExpr -> Doc

-- | Like <a>ansiWlPretty</a> but color the background.
ansiWlBgPretty :: Pretty Doc

-- | Pretty print <a>Expr</a> using <tt>ansi-wl-pprint</tt>.
ansiWlBgExpr :: Expr -> Doc

-- | Pretty print <tt><a>Edit</a> <a>EditExpr</a></tt> using
--   <tt>ansi-wl-pprint</tt>.
ansiWlBgEditExpr :: Edit EditExpr -> Doc

-- | Compact <a>ansiWlBgEditExpr</a>.
ansiWlBgEditExprCompact :: Edit EditExpr -> Doc

-- | Escape field or constructor name
--   
--   <pre>
--   &gt;&gt;&gt; putStrLn $ escapeName "Foo"
--   Foo
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; putStrLn $ escapeName "_×_"
--   _×_
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; putStrLn $ escapeName "-3"
--   `-3`
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; putStrLn $ escapeName "kebab-case"
--   kebab-case
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; putStrLn $ escapeName "inner space"
--   `inner space`
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; putStrLn $ escapeName $ show "looks like a string"
--   "looks like a string"
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; putStrLn $ escapeName $ show "tricky" ++ "   "
--   `"tricky"   `
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; putStrLn $ escapeName "[]"
--   `[]`
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; putStrLn $ escapeName "_,_"
--   `_,_`
--   </pre>
escapeName :: String -> String


-- | Implements <tt>CanDiff</tt> with our vendored version of
--   <tt>tree-diff</tt>.
module Test.StateMachine.TreeDiff.Diffing
instance Test.StateMachine.TreeDiff.Class.ToExpr Test.StateMachine.Types.References.Var
instance (Test.StateMachine.TreeDiff.Class.ToExpr a, Test.StateMachine.TreeDiff.Class.ToExpr (Test.StateMachine.Lockstep.NAry.MockHandleN t a)) => Test.StateMachine.TreeDiff.Class.ToExpr (Test.StateMachine.Lockstep.NAry.Refs t Test.StateMachine.Types.References.Concrete a)
instance Test.StateMachine.TreeDiff.Class.ToExpr x => Test.StateMachine.Diffing.CanDiff x
instance Test.StateMachine.TreeDiff.Class.ToExpr a => Test.StateMachine.TreeDiff.Class.ToExpr (Test.StateMachine.Types.References.Symbolic a)
instance Test.StateMachine.TreeDiff.Class.ToExpr a => Test.StateMachine.TreeDiff.Class.ToExpr (Test.StateMachine.Types.References.Concrete a)
instance Test.StateMachine.TreeDiff.Class.ToExpr (r a) => Test.StateMachine.TreeDiff.Class.ToExpr (Test.StateMachine.Types.References.Reference a r)
instance Test.StateMachine.TreeDiff.Class.ToExpr (Test.StateMachine.Types.References.Opaque a)
instance Test.StateMachine.TreeDiff.Class.ToExpr (Test.StateMachine.Lockstep.Simple.MockHandle t) => Test.StateMachine.TreeDiff.Class.ToExpr (Test.StateMachine.Lockstep.NAry.MockHandleN (Test.StateMachine.Lockstep.Simple.Simple t) (Test.StateMachine.Lockstep.Simple.RealHandle t))
instance Data.SOP.Constraint.All (Data.SOP.Constraint.And Test.StateMachine.TreeDiff.Class.ToExpr (Data.SOP.Constraint.Compose Test.StateMachine.TreeDiff.Class.ToExpr (Test.StateMachine.Lockstep.NAry.MockHandleN t))) (Test.StateMachine.Lockstep.NAry.RealHandles t) => Test.StateMachine.TreeDiff.Class.ToExpr (Test.StateMachine.Lockstep.NAry.Refss t Test.StateMachine.Types.References.Concrete)
instance (Test.StateMachine.TreeDiff.Class.ToExpr (Test.StateMachine.Lockstep.NAry.MockState t), Data.SOP.Constraint.All (Data.SOP.Constraint.And Test.StateMachine.TreeDiff.Class.ToExpr (Data.SOP.Constraint.Compose Test.StateMachine.TreeDiff.Class.ToExpr (Test.StateMachine.Lockstep.NAry.MockHandleN t))) (Test.StateMachine.Lockstep.NAry.RealHandles t)) => Test.StateMachine.TreeDiff.Class.ToExpr (Test.StateMachine.Lockstep.NAry.Model t Test.StateMachine.Types.References.Concrete)


-- | Diffing of (expression) trees.
--   
--   Diffing arbitrary Haskell data. First we convert values to untyped
--   haskell-like expression <a>Expr</a> using generically derivable
--   <a>ToExpr</a> class. Then we can diff two <a>Expr</a> values. The
--   conversion and diffing is done by <a>ediff</a> function. See type and
--   function haddocks for an examples.
--   
--   Interesting modules:
--   
--   <ul>
--   <li><a>Data.TreeDiff.Class</a> for a <a>ToExpr</a> class and
--   <a>ediff</a> utility.</li>
--   </ul>
module Test.StateMachine.TreeDiff


-- | Tree diffing working on <tt>containers</tt> <a>Tree</a>.
module Test.StateMachine.TreeDiff.Tree

-- | A breadth-traversal diff.
--   
--   It's different from <tt>gdiff</tt>, as it doesn't produce a flat edit
--   script, but edit script iself is a tree. This makes visualising the
--   diff much simpler.
--   
--   <h4>Examples</h4>
--   
--   Let's start from simple tree. We pretty print them as s-expressions.
--   
--   <pre>
--   &gt;&gt;&gt; let x = Node 'a' [Node 'b' [], Node 'c' [return 'd', return 'e'], Node 'f' []]
--   
--   &gt;&gt;&gt; ppTree PP.char x
--   (a b (c d e) f)
--   </pre>
--   
--   If we modify an argument in a tree, we'll notice it's changed:
--   
--   <pre>
--   &gt;&gt;&gt; let y = Node 'a' [Node 'b' [], Node 'c' [return 'x', return 'e'], Node 'f' []]
--   
--   &gt;&gt;&gt; ppTree PP.char y
--   (a b (c x e) f)
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; ppEditTree PP.char (treeDiff x y)
--   (a b (c -d +x e) f)
--   </pre>
--   
--   If we modify a constructor, the whole sub-trees is replaced, though
--   there might be common subtrees.
--   
--   <pre>
--   &gt;&gt;&gt; let z = Node 'a' [Node 'b' [], Node 'd' [], Node 'f' []]
--   
--   &gt;&gt;&gt; ppTree PP.char z
--   (a b d f)
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; ppEditTree PP.char (treeDiff x z)
--   (a b -(c d e) +d f)
--   </pre>
--   
--   If we add arguments, they are spotted too:
--   
--   <pre>
--   &gt;&gt;&gt; let w = Node 'a' [Node 'b' [], Node 'c' [return 'd', return 'x', return 'e'], Node 'f' []]
--   
--   &gt;&gt;&gt; ppTree PP.char w
--   (a b (c d x e) f)
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; ppEditTree PP.char (treeDiff x w)
--   (a b (c d +x e) f)
--   </pre>
treeDiff :: Eq a => Tree a -> Tree a -> Edit (EditTree a)

-- | Type used in the result of <a>treeDiff</a>.
--   
--   It's essentially a <a>Tree</a>, but the forest list is changed from
--   <tt>[tree a]</tt> to <tt>[<a>Edit</a> (tree a)]</tt>. This highlights
--   that <a>treeDiff</a> performs a list diff on each tree level.
data EditTree a
EditNode :: a -> [Edit (EditTree a)] -> EditTree a

-- | List edit operations
--   
--   The <a>Swp</a> constructor is redundant, but it let us spot a
--   recursion point when performing tree diffs.
data Edit a

-- | insert
Ins :: a -> Edit a

-- | delete
Del :: a -> Edit a

-- | copy unchanged
Cpy :: a -> Edit a

-- | swap, i.e. delete + insert
Swp :: a -> a -> Edit a
instance GHC.Show.Show a => GHC.Show.Show (Test.StateMachine.TreeDiff.Tree.EditTree a)