Dino.AST.Diff

Documentation

dropEnd :: Int -> [a] -> [a]

Drop elements at the end of a list

Types

data Replace a

Constructors

Replace

Fields

• original :: a
• new :: a

Instances

Functor Replace

Defined in Dino.AST.Diff

Methods

fmap :: (a -> b) -> Replace a -> Replace b

(<$) :: a -> Replace b -> Replace a

Eq a => Eq (Replace a)

Defined in Dino.AST.Diff

Methods

(==) :: Replace a -> Replace a -> Bool

(/=) :: Replace a -> Replace a -> Bool

Show a => Show (Replace a)

Defined in Dino.AST.Diff

Methods

showsPrec :: Int -> Replace a -> ShowS

show :: Replace a -> String

showList :: [Replace a] -> ShowS

Pretty a => Pretty (Replace a)

Defined in Dino.AST.Diff

Methods

pretty :: Replace a -> Doc

prettyList :: [Replace a] -> Doc

data ElemOp a

Edit operations on an optional element

Constructors

AddElem a

RemoveElem a

EditElem (Diff a)

Instances

(Eq a, Eq (Diff a)) => Eq (ElemOp a)

Defined in Dino.AST.Diff

Methods

(==) :: ElemOp a -> ElemOp a -> Bool

(/=) :: ElemOp a -> ElemOp a -> Bool

(Show a, Show (Diff a)) => Show (ElemOp a)

Defined in Dino.AST.Diff

Methods

showsPrec :: Int -> ElemOp a -> ShowS

show :: ElemOp a -> String

showList :: [ElemOp a] -> ShowS

(Pretty a, Pretty (Diff a), Show k, Ord k) => Pretty (Mapping k (ElemOp a))

If k is a String-like type, it will be shown with quotes. Use Field to prevent this.

Defined in Dino.AST.Diff

Methods

pretty :: Mapping k (ElemOp a) -> Doc

prettyList :: [Mapping k (ElemOp a)] -> Doc

data EndOp a

Edit operations at the end of a list

Constructors

Append [a]

DropEnd [a]

Instances

Functor EndOp

Defined in Dino.AST.Diff

Methods

fmap :: (a -> b) -> EndOp a -> EndOp b

(<$) :: a -> EndOp b -> EndOp a

Eq a => Eq (EndOp a)

Defined in Dino.AST.Diff

Methods

(==) :: EndOp a -> EndOp a -> Bool

(/=) :: EndOp a -> EndOp a -> Bool

Show a => Show (EndOp a)

Defined in Dino.AST.Diff

Methods

showsPrec :: Int -> EndOp a -> ShowS

show :: EndOp a -> String

showList :: [EndOp a] -> ShowS

data ListOp a

Edit operations on lists

Constructors

ListOp [Maybe (Diff a)] (Maybe (EndOp a))

Instances

(Eq a, Eq (Diff a)) => Eq (ListOp a)

Defined in Dino.AST.Diff

Methods

(==) :: ListOp a -> ListOp a -> Bool

(/=) :: ListOp a -> ListOp a -> Bool

(Show a, Show (Diff a)) => Show (ListOp a)

Defined in Dino.AST.Diff

Methods

showsPrec :: Int -> ListOp a -> ShowS

show :: ListOp a -> String

showList :: [ListOp a] -> ShowS

(Pretty a, Pretty (Diff a)) => Pretty (ListOp a)

Defined in Dino.AST.Diff

Methods

pretty :: ListOp a -> Doc

prettyList :: [ListOp a] -> Doc

data Edit a

Edit operation on a AST

Constructors

Replacement (Replace (AST a))

EditApp Constr [Maybe (Edit a)]

EditList (Diff [AST a])

EditLet (Diff (Text, AST a, AST a))

EditRecord (Diff (Mapping Field (AST a)))

Instances

Eq a => Eq (Edit a)

Defined in Dino.AST.Diff

Methods

(==) :: Edit a -> Edit a -> Bool

(/=) :: Edit a -> Edit a -> Bool

Show a => Show (Edit a)

Defined in Dino.AST.Diff

Methods

showsPrec :: Int -> Edit a -> ShowS

show :: Edit a -> String

showList :: [Edit a] -> ShowS

Show a => Pretty (Edit a)

Defined in Dino.AST.Diff

Methods

pretty :: Edit a -> Doc

prettyList :: [Edit a] -> Doc

newtype Monolithic a

Wrapper for values that should be regarded as monolithic when diffing

Constructors

Monolithic

Fields

• unMonolithic :: a

Instances

Eq a => Diffable (Monolithic a)

Defined in Dino.AST.Diff

Associated Types

type Diff (Monolithic a) :: Type

Methods

diff :: Monolithic a -> Monolithic a -> Maybe (Diff (Monolithic a))

applyDiff :: Diff (Monolithic a) -> Monolithic a -> Maybe (Monolithic a)

type Diff (Monolithic a)

Defined in Dino.AST.Diff

type Diff (Monolithic a) = Replace a

Diffing

class Diffable a where

Minimal complete definition

Nothing

Associated Types

type Diff a

Representation of the difference between two values

Methods

diff

Arguments

:: a

Original

-> a

New

-> Maybe (Diff a)

Calculate the difference between two values

The result is Nothing iff. the two values are equal.

The following property holds:

If   Just d = diff a b
Then Just b = applyDiff d a

diff

Arguments

:: (Eq a, Diff a ~ Replace a)

=> a

Original

-> a

New

-> Maybe (Diff a)

Calculate the difference between two values

The result is Nothing iff. the two values are equal.

The following property holds:

If   Just d = diff a b
Then Just b = applyDiff d a

applyDiff :: Diff a -> a -> Maybe a

Apply an Edit to a Value

This function is mostly intended for testing. It succeeds iff. the edit makes sense.

applyDiff :: (Eq a, Diff a ~ Replace a) => Diff a -> a -> Maybe a

Apply an Edit to a Value

This function is mostly intended for testing. It succeeds iff. the edit makes sense.

Instances

Diffable Bool

Defined in Dino.AST.Diff

Associated Types

type Diff Bool :: Type

Methods

diff :: Bool -> Bool -> Maybe (Diff Bool)

applyDiff :: Diff Bool -> Bool -> Maybe Bool

Diffable Double

Defined in Dino.AST.Diff

Associated Types

type Diff Double :: Type

Methods

diff :: Double -> Double -> Maybe (Diff Double)

applyDiff :: Diff Double -> Double -> Maybe Double

Diffable Float

Defined in Dino.AST.Diff

Associated Types

type Diff Float :: Type

Methods

diff :: Float -> Float -> Maybe (Diff Float)

applyDiff :: Diff Float -> Float -> Maybe Float

Diffable Int

Defined in Dino.AST.Diff

Associated Types

type Diff Int :: Type

Methods

diff :: Int -> Int -> Maybe (Diff Int)

applyDiff :: Diff Int -> Int -> Maybe Int

Diffable Integer

Defined in Dino.AST.Diff

Associated Types

type Diff Integer :: Type

Methods

diff :: Integer -> Integer -> Maybe (Diff Integer)

applyDiff :: Diff Integer -> Integer -> Maybe Integer

Diffable Rational

Defined in Dino.AST.Diff

Associated Types

type Diff Rational :: Type

Methods

diff :: Rational -> Rational -> Maybe (Diff Rational)

applyDiff :: Diff Rational -> Rational -> Maybe Rational

Diffable ()

Defined in Dino.AST.Diff

Associated Types

type Diff () :: Type

Methods

diff :: () -> () -> Maybe (Diff ())

applyDiff :: Diff () -> () -> Maybe ()

Diffable Text

Defined in Dino.AST.Diff

Associated Types

type Diff Text :: Type

Methods

diff :: Text -> Text -> Maybe (Diff Text)

applyDiff :: Diff Text -> Text -> Maybe Text

Diffable a => Diffable [a]

Matches element-wise from the start of the lists, and detects additions/removals at the end.

Defined in Dino.AST.Diff

Associated Types

type Diff [a] :: Type

Methods

diff :: [a] -> [a] -> Maybe (Diff [a])

applyDiff :: Diff [a] -> [a] -> Maybe [a]

Diffable a => Diffable (Maybe a)

Defined in Dino.AST.Diff

Associated Types

type Diff (Maybe a) :: Type

Methods

diff :: Maybe a -> Maybe a -> Maybe (Diff (Maybe a))

applyDiff :: Diff (Maybe a) -> Maybe a -> Maybe (Maybe a)

Eq a => Diffable (AST a)

Defined in Dino.AST.Diff

Associated Types

type Diff (AST a) :: Type

Methods

diff :: AST a -> AST a -> Maybe (Diff (AST a))

applyDiff :: Diff (AST a) -> AST a -> Maybe (AST a)

Eq a => Diffable (Monolithic a)

Defined in Dino.AST.Diff

Associated Types

type Diff (Monolithic a) :: Type

Methods

diff :: Monolithic a -> Monolithic a -> Maybe (Diff (Monolithic a))

applyDiff :: Diff (Monolithic a) -> Monolithic a -> Maybe (Monolithic a)

(Diffable a, Diffable b) => Diffable (a, b)

Defined in Dino.AST.Diff

Associated Types

type Diff (a, b) :: Type

Methods

diff :: (a, b) -> (a, b) -> Maybe (Diff (a, b))

applyDiff :: Diff (a, b) -> (a, b) -> Maybe (a, b)

(Eq k, Hashable k, Diffable a) => Diffable (Mapping k a)

Defined in Dino.AST.Diff

Associated Types

type Diff (Mapping k a) :: Type

Methods

diff :: Mapping k a -> Mapping k a -> Maybe (Diff (Mapping k a))

applyDiff :: Diff (Mapping k a) -> Mapping k a -> Maybe (Mapping k a)

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

Defined in Dino.AST.Diff

Associated Types

type Diff (a, b, c) :: Type

Methods

diff :: (a, b, c) -> (a, b, c) -> Maybe (Diff (a, b, c))

applyDiff :: Diff (a, b, c) -> (a, b, c) -> Maybe (a, b, c)

applyDiffWhen :: Diffable a => Maybe (Diff a) -> a -> Maybe a

Rendering

prettyEditTuple :: Pretty a => Doc -> Doc -> Doc -> [Maybe a] -> Doc

Pretty print for edits on tuple-like collections (where elements are identified by position)

prettyEditApp :: Pretty a => NameType -> Text -> [Maybe a] -> Doc

Pretty print EditApp for "named" constructors

printEdit :: Show a => Edit a -> IO ()

Print an Edit value to the terminal using ANSI colors

diffAsTestResult :: Show a => Maybe (Edit a) -> Doc

Print a diff as a test result

Nothing is shown as a green "OK".

Just d is shown as a red "Fail", followed by a rendering of the diff.