Safe Haskell	None
Language	Haskell2010

Data.TreeDiff.Class

Contents

SOP

Description

A ToExpr class.

Synopsis

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 {fooBool = [Just True], fooInt = Right -2 +3, fooString = "fo"}

>>> 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"}

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" []]]

Methods

toExpr :: a -> Expr #

toExpr :: (Generic a, All2 ToExpr (GCode a), GFrom a, GDatatypeInfo a) => a -> Expr #

listToExpr :: [a] -> Expr #

Instances

ToExpr Bool #
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"]
Methods toExpr :: Char -> Expr # listToExpr :: [Char] -> Expr #
ToExpr Double #
Methods toExpr :: Double -> Expr # listToExpr :: [Double] -> Expr #
ToExpr Float #
Methods toExpr :: Float -> Expr # listToExpr :: [Float] -> Expr #
ToExpr Int #
Methods toExpr :: Int -> Expr # listToExpr :: [Int] -> Expr #
ToExpr Int8 #
Methods toExpr :: Int8 -> Expr # listToExpr :: [Int8] -> Expr #
ToExpr Int16 #
Methods toExpr :: Int16 -> Expr # listToExpr :: [Int16] -> Expr #
ToExpr Int32 #
Methods toExpr :: Int32 -> Expr # listToExpr :: [Int32] -> Expr #
ToExpr Int64 #
Methods toExpr :: Int64 -> Expr # listToExpr :: [Int64] -> Expr #
ToExpr Integer #
Methods toExpr :: Integer -> Expr # listToExpr :: [Integer] -> Expr #
ToExpr Natural #
Methods toExpr :: Natural -> Expr # listToExpr :: [Natural] -> Expr #
ToExpr Ordering #
Methods toExpr :: Ordering -> Expr # listToExpr :: [Ordering] -> Expr #
ToExpr Word #
Methods toExpr :: Word -> Expr # listToExpr :: [Word] -> Expr #
ToExpr Word8 #
Methods toExpr :: Word8 -> Expr # listToExpr :: [Word8] -> Expr #
ToExpr Word16 #
Methods toExpr :: Word16 -> Expr # listToExpr :: [Word16] -> Expr #
ToExpr Word32 #
Methods toExpr :: Word32 -> Expr # listToExpr :: [Word32] -> Expr #
ToExpr Word64 #
Methods toExpr :: Word64 -> Expr # listToExpr :: [Word64] -> Expr #
ToExpr () #
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"]
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"]
Methods toExpr :: ByteString -> Expr # listToExpr :: [ByteString] -> Expr #
ToExpr Scientific #	`>>>` `prettyExpr $ toExpr (123.456 :: Scientific)`scientific 123456 `-3`
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"]
Methods toExpr :: Text -> Expr # listToExpr :: [Text] -> Expr #
ToExpr UTCTime #
Methods toExpr :: UTCTime -> Expr # listToExpr :: [UTCTime] -> Expr #
ToExpr Value #
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"]
Methods toExpr :: Text -> Expr # listToExpr :: [Text] -> Expr #
ToExpr Void #
Methods toExpr :: Void -> Expr # listToExpr :: [Void] -> Expr #
ToExpr IntSet #
Methods toExpr :: IntSet -> Expr # listToExpr :: [IntSet] -> Expr #
ToExpr Day #	`>>>` `prettyExpr $ toExpr $ ModifiedJulianDay 58014`Day "2017-09-18"
Methods toExpr :: Day -> Expr # listToExpr :: [Day] -> Expr #
ToExpr UUID #	`>>>` `prettyExpr $ toExpr UUID.nil`UUID "00000000-0000-0000-0000-000000000000"
Methods toExpr :: UUID -> Expr # listToExpr :: [UUID] -> Expr #
ToExpr Expr #
Methods toExpr :: Expr -> Expr # listToExpr :: [Expr] -> Expr #
ToExpr a => ToExpr [a] #
Methods toExpr :: [a] -> Expr # listToExpr :: [[a]] -> Expr #
ToExpr a => ToExpr (Maybe a) #
Methods toExpr :: Maybe a -> Expr # listToExpr :: [Maybe a] -> Expr #
(ToExpr a, Integral a) => ToExpr (Ratio a) #	`>>>` `prettyExpr $ toExpr (3 % 12 :: Rational)`_%_ 1 4
Methods toExpr :: Ratio a -> Expr # listToExpr :: [Ratio a] -> Expr #
HasResolution a => ToExpr (Fixed a) #
Methods toExpr :: Fixed a -> Expr # listToExpr :: [Fixed a] -> Expr #
ToExpr a => ToExpr (Min a) #
Methods toExpr :: Min a -> Expr # listToExpr :: [Min a] -> Expr #
ToExpr a => ToExpr (Max a) #
Methods toExpr :: Max a -> Expr # listToExpr :: [Max a] -> Expr #
ToExpr a => ToExpr (First a) #
Methods toExpr :: First a -> Expr # listToExpr :: [First a] -> Expr #
ToExpr a => ToExpr (Last a) #
Methods toExpr :: Last a -> Expr # listToExpr :: [Last a] -> Expr #
ToExpr a => ToExpr (Option a) #
Methods toExpr :: Option a -> Expr # listToExpr :: [Option a] -> Expr #
ToExpr a => ToExpr (NonEmpty a) #
Methods toExpr :: NonEmpty a -> Expr # listToExpr :: [NonEmpty a] -> Expr #
ToExpr a => ToExpr (ZipList a) #
Methods toExpr :: ZipList a -> Expr # listToExpr :: [ZipList a] -> Expr #
ToExpr a => ToExpr (Identity a) #	`>>>` `prettyExpr $ toExpr $ Identity 'a'`Identity 'a'
Methods toExpr :: Identity a -> Expr # listToExpr :: [Identity a] -> Expr #
ToExpr a => ToExpr (Dual a) #
Methods toExpr :: Dual a -> Expr # listToExpr :: [Dual a] -> Expr #
ToExpr a => ToExpr (Sum a) #
Methods toExpr :: Sum a -> Expr # listToExpr :: [Sum a] -> Expr #
ToExpr a => ToExpr (Product a) #
Methods toExpr :: Product a -> Expr # listToExpr :: [Product a] -> Expr #
ToExpr a => ToExpr (First a) #
Methods toExpr :: First a -> Expr # listToExpr :: [First a] -> Expr #
ToExpr a => ToExpr (Last a) #
Methods toExpr :: Last a -> Expr # listToExpr :: [Last a] -> Expr #
ToExpr v => ToExpr (IntMap v) #
Methods toExpr :: IntMap v -> Expr # listToExpr :: [IntMap v] -> Expr #
ToExpr a => ToExpr (Tree a) #
Methods toExpr :: Tree a -> Expr # listToExpr :: [Tree a] -> Expr #
ToExpr v => ToExpr (Seq v) #
Methods toExpr :: Seq v -> Expr # listToExpr :: [Seq v] -> Expr #
ToExpr k => ToExpr (Set k) #
Methods toExpr :: Set k -> Expr # listToExpr :: [Set k] -> Expr #
ToExpr a => ToExpr (Hashed a) #
Methods toExpr :: Hashed a -> Expr # listToExpr :: [Hashed a] -> Expr #
ToExpr k => ToExpr (HashSet k) #
Methods toExpr :: HashSet k -> Expr # listToExpr :: [HashSet k] -> Expr #
(ToExpr a, Unbox a) => ToExpr (Vector a) #
Methods toExpr :: Vector a -> Expr # listToExpr :: [Vector a] -> Expr #
(ToExpr a, Storable a) => ToExpr (Vector a) #
Methods toExpr :: Vector a -> Expr # listToExpr :: [Vector a] -> Expr #
(ToExpr a, Prim a) => ToExpr (Vector a) #
Methods toExpr :: Vector a -> Expr # listToExpr :: [Vector a] -> Expr #
ToExpr a => ToExpr (Vector a) #
Methods toExpr :: Vector a -> Expr # listToExpr :: [Vector a] -> Expr #
(ToExpr a, ToExpr b) => ToExpr (Either a b) #
Methods toExpr :: Either a b -> Expr # listToExpr :: [Either a b] -> Expr #
(ToExpr a, ToExpr b) => ToExpr (a, b) #
Methods toExpr :: (a, b) -> Expr # listToExpr :: [(a, b)] -> Expr #
(ToExpr k, ToExpr v) => ToExpr (HashMap k v) #
Methods toExpr :: HashMap k v -> Expr # listToExpr :: [HashMap k v] -> Expr #
(ToExpr k, ToExpr v) => ToExpr (Map k v) #
Methods toExpr :: Map k v -> Expr # listToExpr :: [Map k v] -> Expr #
ToExpr (Proxy * a) #
Methods toExpr :: Proxy * a -> Expr # listToExpr :: [Proxy * a] -> Expr #
(ToExpr a, ToExpr b, ToExpr c) => ToExpr (a, b, c) #
Methods toExpr :: (a, b, c) -> Expr # listToExpr :: [(a, b, c)] -> Expr #
ToExpr a => ToExpr (Const * a b) #
Methods toExpr :: Const * a b -> Expr # listToExpr :: [Const * a b] -> Expr #
ToExpr a => ToExpr (Tagged * t a) #
Methods toExpr :: Tagged * t a -> Expr # listToExpr :: [Tagged * t a] -> Expr #
(ToExpr a, ToExpr b, ToExpr c, ToExpr d) => ToExpr (a, b, c, d) #
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) #
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.

SOP

sopToExpr :: All2 ToExpr xss => DatatypeInfo xss -> SOP I xss -> Expr #

>>> prettyExpr $ sopToExpr (gdatatypeInfo (Proxy :: Proxy String)) (gfrom "foo")
_:_ 'f' "oo"