Data.TreeDiff.Class

A ToExpr class.

Documentation

ediff :: ToExpr a => a -> a -> Edit EditExpr

Difference between two ToExpr values.

>>> let x = (1, Just 2) :: (Int, Maybe Int)
>>> let y = (1, Nothing)
>>> prettyEditExpr (ediff x y)
_×_ 1 -(Just 2) +Nothing

>>> data Foo = Foo { fooInt :: Either Char Int, fooBool :: [Maybe Bool], fooString :: String } deriving (Eq, Generic)
>>> instance ToExpr Foo

>>> prettyEditExpr $ ediff (Foo (Right 2) [Just True] "fo") (Foo (Right 3) [Just True] "fo")
Foo {fooInt = Right -2 +3, fooBool = [Just True], fooString = "fo"}

>>> prettyEditExpr $ ediff (Foo (Right 42) [Just True, Just False] "old") (Foo (Right 42) [Nothing, Just False, Just True] "new")
Foo {
  fooInt = Right 42,
  fooBool = [-Just True, +Nothing, Just False, +Just True],
  fooString = -"old" +"new"}

ediff' :: (ToExpr a, ToExpr b) => a -> b -> Edit EditExpr

Compare different types.

Note: Use with care as you can end up comparing apples with oranges.

>>> prettyEditExpr $ ediff' ["foo", "bar"] [Just "foo", Nothing]
[-"foo", +Just "foo", -"bar", +Nothing]

class ToExpr a where

toExpr converts a Haskell value into untyped Haskell-like syntax tree, Expr.

>>> toExpr ((1, Just 2) :: (Int, Maybe Int))
App "_\215_" [App "1" [],App "Just" [App "2" []]]

Minimal complete definition

Nothing

Methods

toExpr :: a -> Expr

default toExpr :: (Generic a, GToExpr (Rep a)) => a -> Expr

listToExpr :: [a] -> Expr

Instances

ToExpr Bool

Defined in Data.TreeDiff.Class

Methods

toExpr :: Bool -> Expr

listToExpr :: [Bool] -> Expr

ToExpr Char

>>> prettyExpr $ toExpr 'a'
'a'

>>> prettyExpr $ toExpr "Hello world"
"Hello world"

>>> prettyExpr $ toExpr "Hello\nworld"
concat ["Hello\n", "world"]

>>> traverse_ (print . prettyExpr . toExpr) ["", "\n", "foo", "foo\n", "foo\nbar", "foo\nbar\n"]
""
"\n"
"foo"
"foo\n"
concat ["foo\n", "bar"]
concat ["foo\n", "bar\n"]

Defined in Data.TreeDiff.Class

Methods

toExpr :: Char -> Expr

listToExpr :: [Char] -> Expr

ToExpr Double

Defined in Data.TreeDiff.Class

Methods

toExpr :: Double -> Expr

listToExpr :: [Double] -> Expr

ToExpr Float

Defined in Data.TreeDiff.Class

Methods

toExpr :: Float -> Expr

listToExpr :: [Float] -> Expr

ToExpr Int

Defined in Data.TreeDiff.Class

Methods

toExpr :: Int -> Expr

listToExpr :: [Int] -> Expr

ToExpr Int8

Defined in Data.TreeDiff.Class

Methods

toExpr :: Int8 -> Expr

listToExpr :: [Int8] -> Expr

ToExpr Int16

Defined in Data.TreeDiff.Class

Methods

toExpr :: Int16 -> Expr

listToExpr :: [Int16] -> Expr

ToExpr Int32

Defined in Data.TreeDiff.Class

Methods

toExpr :: Int32 -> Expr

listToExpr :: [Int32] -> Expr

ToExpr Int64

Defined in Data.TreeDiff.Class

Methods

toExpr :: Int64 -> Expr

listToExpr :: [Int64] -> Expr

ToExpr Integer

Defined in Data.TreeDiff.Class

Methods

toExpr :: Integer -> Expr

listToExpr :: [Integer] -> Expr

ToExpr Natural

Defined in Data.TreeDiff.Class

Methods

toExpr :: Natural -> Expr

listToExpr :: [Natural] -> Expr

ToExpr Ordering

Defined in Data.TreeDiff.Class

Methods

toExpr :: Ordering -> Expr

listToExpr :: [Ordering] -> Expr

ToExpr Word

Defined in Data.TreeDiff.Class

Methods

toExpr :: Word -> Expr

listToExpr :: [Word] -> Expr

ToExpr Word8

Defined in Data.TreeDiff.Class

Methods

toExpr :: Word8 -> Expr

listToExpr :: [Word8] -> Expr

ToExpr Word16

Defined in Data.TreeDiff.Class

Methods

toExpr :: Word16 -> Expr

listToExpr :: [Word16] -> Expr

ToExpr Word32

Defined in Data.TreeDiff.Class

Methods

toExpr :: Word32 -> Expr

listToExpr :: [Word32] -> Expr

ToExpr Word64

Defined in Data.TreeDiff.Class

Methods

toExpr :: Word64 -> Expr

listToExpr :: [Word64] -> Expr

ToExpr ()

Defined in Data.TreeDiff.Class

Methods

toExpr :: () -> Expr

listToExpr :: [()] -> Expr

ToExpr ByteString

>>> traverse_ (print . prettyExpr . toExpr . BS8.pack) ["", "\n", "foo", "foo\n", "foo\nbar", "foo\nbar\n"]
""
"\n"
"foo"
"foo\n"
BS.concat ["foo\n", "bar"]
BS.concat ["foo\n", "bar\n"]

Defined in Data.TreeDiff.Class

Methods

toExpr :: ByteString -> Expr

listToExpr :: [ByteString] -> Expr

ToExpr ByteString

>>> traverse_ (print . prettyExpr . toExpr . LBS8.pack) ["", "\n", "foo", "foo\n", "foo\nbar", "foo\nbar\n"]
""
"\n"
"foo"
"foo\n"
LBS.concat ["foo\n", "bar"]
LBS.concat ["foo\n", "bar\n"]

Defined in Data.TreeDiff.Class

Methods

toExpr :: ByteString -> Expr

listToExpr :: [ByteString] -> Expr

ToExpr Scientific

>>> prettyExpr $ toExpr (123.456 :: Scientific)
scientific 123456 `-3`

Defined in Data.TreeDiff.Class

Methods

toExpr :: Scientific -> Expr

listToExpr :: [Scientific] -> Expr

ToExpr Text

>>> traverse_ (print . prettyExpr . toExpr . T.pack) ["", "\n", "foo", "foo\n", "foo\nbar", "foo\nbar\n"]
""
"\n"
"foo"
"foo\n"
T.concat ["foo\n", "bar"]
T.concat ["foo\n", "bar\n"]

Defined in Data.TreeDiff.Class

Methods

toExpr :: Text -> Expr

listToExpr :: [Text] -> Expr

ToExpr UTCTime

Defined in Data.TreeDiff.Class

Methods

toExpr :: UTCTime -> Expr

listToExpr :: [UTCTime] -> Expr

ToExpr Value

Defined in Data.TreeDiff.Class

Methods

toExpr :: Value -> Expr

listToExpr :: [Value] -> Expr

ToExpr Text

>>> traverse_ (print . prettyExpr . toExpr . LT.pack) ["", "\n", "foo", "foo\n", "foo\nbar", "foo\nbar\n"]
""
"\n"
"foo"
"foo\n"
LT.concat ["foo\n", "bar"]
LT.concat ["foo\n", "bar\n"]

Defined in Data.TreeDiff.Class

Methods

toExpr :: Text -> Expr

listToExpr :: [Text] -> Expr

ToExpr Void

Defined in Data.TreeDiff.Class

Methods

toExpr :: Void -> Expr

listToExpr :: [Void] -> Expr

ToExpr ShortByteString

>>> traverse_ (print . prettyExpr . toExpr . SBS.toShort . BS8.pack) ["", "\n", "foo", "foo\n", "foo\nbar", "foo\nbar\n"]
""
"\n"
"foo"
"foo\n"
mconcat ["foo\n", "bar"]
mconcat ["foo\n", "bar\n"]

Defined in Data.TreeDiff.Class

Methods

toExpr :: ShortByteString -> Expr

listToExpr :: [ShortByteString] -> Expr

ToExpr IntSet

Defined in Data.TreeDiff.Class

Methods

toExpr :: IntSet -> Expr

listToExpr :: [IntSet] -> Expr

ToExpr Day

>>> prettyExpr $ toExpr $ ModifiedJulianDay 58014
Day "2017-09-18"

Defined in Data.TreeDiff.Class

Methods

toExpr :: Day -> Expr

listToExpr :: [Day] -> Expr

ToExpr UUID

>>> prettyExpr $ toExpr UUID.nil
UUID "00000000-0000-0000-0000-000000000000"

Defined in Data.TreeDiff.Class

Methods

toExpr :: UUID -> Expr

listToExpr :: [UUID] -> Expr

ToExpr Expr

Defined in Data.TreeDiff.Class

Methods

toExpr :: Expr -> Expr

listToExpr :: [Expr] -> Expr

ToExpr a => ToExpr [a]

Defined in Data.TreeDiff.Class

Methods

toExpr :: [a] -> Expr

listToExpr :: [[a]] -> Expr

ToExpr a => ToExpr (Maybe a)

Defined in Data.TreeDiff.Class

Methods

toExpr :: Maybe a -> Expr

listToExpr :: [Maybe a] -> Expr

(ToExpr a, Integral a) => ToExpr (Ratio a)

>>> prettyExpr $ toExpr (3 % 12 :: Rational)
_%_ 1 4

Defined in Data.TreeDiff.Class

Methods

toExpr :: Ratio a -> Expr

listToExpr :: [Ratio a] -> Expr

ToExpr a => ToExpr (Min a)

Defined in Data.TreeDiff.Class

Methods

toExpr :: Min a -> Expr

listToExpr :: [Min a] -> Expr

ToExpr a => ToExpr (Max a)

Defined in Data.TreeDiff.Class

Methods

toExpr :: Max a -> Expr

listToExpr :: [Max a] -> Expr

ToExpr a => ToExpr (First a)

Defined in Data.TreeDiff.Class

Methods

toExpr :: First a -> Expr

listToExpr :: [First a] -> Expr

ToExpr a => ToExpr (Last a)

Defined in Data.TreeDiff.Class

Methods

toExpr :: Last a -> Expr

listToExpr :: [Last a] -> Expr

ToExpr a => ToExpr (Option a)

Defined in Data.TreeDiff.Class

Methods

toExpr :: Option a -> Expr

listToExpr :: [Option a] -> Expr

ToExpr a => ToExpr (ZipList a)

Defined in Data.TreeDiff.Class

Methods

toExpr :: ZipList a -> Expr

listToExpr :: [ZipList a] -> Expr

ToExpr a => ToExpr (Identity a)

>>> prettyExpr $ toExpr $ Identity 'a'
Identity 'a'

Defined in Data.TreeDiff.Class

Methods

toExpr :: Identity a -> Expr

listToExpr :: [Identity a] -> Expr

ToExpr a => ToExpr (First a)

Defined in Data.TreeDiff.Class

Methods

toExpr :: First a -> Expr

listToExpr :: [First a] -> Expr

ToExpr a => ToExpr (Last a)

Defined in Data.TreeDiff.Class

Methods

toExpr :: Last a -> Expr

listToExpr :: [Last a] -> Expr

ToExpr a => ToExpr (Dual a)

Defined in Data.TreeDiff.Class

Methods

toExpr :: Dual a -> Expr

listToExpr :: [Dual a] -> Expr

ToExpr a => ToExpr (Sum a)

Defined in Data.TreeDiff.Class

Methods

toExpr :: Sum a -> Expr

listToExpr :: [Sum a] -> Expr

ToExpr a => ToExpr (Product a)

Defined in Data.TreeDiff.Class

Methods

toExpr :: Product a -> Expr

listToExpr :: [Product a] -> Expr

ToExpr a => ToExpr (NonEmpty a)

Defined in Data.TreeDiff.Class

Methods

toExpr :: NonEmpty a -> Expr

listToExpr :: [NonEmpty a] -> Expr

ToExpr v => ToExpr (IntMap v)

Defined in Data.TreeDiff.Class

Methods

toExpr :: IntMap v -> Expr

listToExpr :: [IntMap v] -> Expr

ToExpr a => ToExpr (Tree a)

Defined in Data.TreeDiff.Class

Methods

toExpr :: Tree a -> Expr

listToExpr :: [Tree a] -> Expr

ToExpr v => ToExpr (Seq v)

Defined in Data.TreeDiff.Class

Methods

toExpr :: Seq v -> Expr

listToExpr :: [Seq v] -> Expr

ToExpr k => ToExpr (Set k)

Defined in Data.TreeDiff.Class

Methods

toExpr :: Set k -> Expr

listToExpr :: [Set k] -> Expr

ToExpr a => ToExpr (Hashed a)

Defined in Data.TreeDiff.Class

Methods

toExpr :: Hashed a -> Expr

listToExpr :: [Hashed a] -> Expr

ToExpr k => ToExpr (HashSet k)

Defined in Data.TreeDiff.Class

Methods

toExpr :: HashSet k -> Expr

listToExpr :: [HashSet k] -> Expr

ToExpr a => ToExpr (Maybe a)

Defined in Data.TreeDiff.Class

Methods

toExpr :: Maybe a -> Expr

listToExpr :: [Maybe a] -> Expr

(ToExpr a, Unbox a) => ToExpr (Vector a)

Defined in Data.TreeDiff.Class

Methods

toExpr :: Vector a -> Expr

listToExpr :: [Vector a] -> Expr

(ToExpr a, Storable a) => ToExpr (Vector a)

Defined in Data.TreeDiff.Class

Methods

toExpr :: Vector a -> Expr

listToExpr :: [Vector a] -> Expr

(ToExpr a, Prim a) => ToExpr (Vector a)

Defined in Data.TreeDiff.Class

Methods

toExpr :: Vector a -> Expr

listToExpr :: [Vector a] -> Expr

ToExpr a => ToExpr (Vector a)

Defined in Data.TreeDiff.Class

Methods

toExpr :: Vector a -> Expr

listToExpr :: [Vector a] -> Expr

(ToExpr a, ToExpr b) => ToExpr (Either a b)

Defined in Data.TreeDiff.Class

Methods

toExpr :: Either a b -> Expr

listToExpr :: [Either a b] -> Expr

(ToExpr a, ToExpr b) => ToExpr (a, b)

Defined in Data.TreeDiff.Class

Methods

toExpr :: (a, b) -> Expr

listToExpr :: [(a, b)] -> Expr

(ToExpr k, ToExpr v) => ToExpr (HashMap k v)

Defined in Data.TreeDiff.Class

Methods

toExpr :: HashMap k v -> Expr

listToExpr :: [HashMap k v] -> Expr

(ToExpr k, ToExpr v) => ToExpr (Map k v)

Defined in Data.TreeDiff.Class

Methods

toExpr :: Map k v -> Expr

listToExpr :: [Map k v] -> Expr

HasResolution a => ToExpr (Fixed a)

Defined in Data.TreeDiff.Class

Methods

toExpr :: Fixed a -> Expr

listToExpr :: [Fixed a] -> Expr

ToExpr (Proxy a)

Defined in Data.TreeDiff.Class

Methods

toExpr :: Proxy a -> Expr

listToExpr :: [Proxy a] -> Expr

(ToExpr a, ToExpr b) => ToExpr (These a b)

Defined in Data.TreeDiff.Class

Methods

toExpr :: These a b -> Expr

listToExpr :: [These a b] -> Expr

(ToExpr a, ToExpr b) => ToExpr (Pair a b)

Defined in Data.TreeDiff.Class

Methods

toExpr :: Pair a b -> Expr

listToExpr :: [Pair a b] -> Expr

(ToExpr a, ToExpr b) => ToExpr (These a b)

Defined in Data.TreeDiff.Class

Methods

toExpr :: These a b -> Expr

listToExpr :: [These a b] -> Expr

(ToExpr a, ToExpr b) => ToExpr (Either a b)

Defined in Data.TreeDiff.Class

Methods

toExpr :: Either a b -> Expr

listToExpr :: [Either a b] -> Expr

(ToExpr a, ToExpr b, ToExpr c) => ToExpr (a, b, c)

Defined in Data.TreeDiff.Class

Methods

toExpr :: (a, b, c) -> Expr

listToExpr :: [(a, b, c)] -> Expr

ToExpr a => ToExpr (Const a b)

Defined in Data.TreeDiff.Class

Methods

toExpr :: Const a b -> Expr

listToExpr :: [Const a b] -> Expr

ToExpr a => ToExpr (Tagged t a)

Defined in Data.TreeDiff.Class

Methods

toExpr :: Tagged t a -> Expr

listToExpr :: [Tagged t a] -> Expr

(ToExpr a, ToExpr b, ToExpr c, ToExpr d) => ToExpr (a, b, c, d)

Defined in Data.TreeDiff.Class

Methods

toExpr :: (a, b, c, d) -> Expr

listToExpr :: [(a, b, c, d)] -> Expr

(ToExpr a, ToExpr b, ToExpr c, ToExpr d, ToExpr e) => ToExpr (a, b, c, d, e)

Defined in Data.TreeDiff.Class

Methods

toExpr :: (a, b, c, d, e) -> Expr

listToExpr :: [(a, b, c, d, e)] -> Expr

defaultExprViaShow :: Show a => a -> Expr

An alternative implementation for literal types. We use show representation of them.

Generics

genericToExpr :: (Generic a, GToExpr (Rep a)) => a -> Expr

Generic toExpr.

>>> data Foo = Foo Int Char deriving Generic
>>> genericToExpr (Foo 42 'x')
App "Foo" [App "42" [],App "'x'" []]

class GToExpr f

Minimal complete definition

gtoExpr

Instances

GSumToExpr f => GToExpr (M1 i c f)

Defined in Data.TreeDiff.Class

Methods

gtoExpr :: M1 i c f x -> Expr