Example.hs

{-# LANGUAGE AllowAmbiguousTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeApplications    #-}

module Example where

import Data.Text (Text)
import GHC.Generics (Generic)
import Dhall (ToDhall)
import Dhall.Diff (Diff)
import OldType (OldType)
import NewType (NewType)

import qualified Dhall
import qualified Dhall.Core as Core
import qualified Dhall.Diff as Diff

diffType :: forall a b . (ToDhall a, ToDhall b) => Diff
diffType = do
    Diff.diff
        (Core.denote (Dhall.declared (Dhall.inject @a)))
        (Core.denote (Dhall.declared (Dhall.inject @b)))

main :: IO ()
main = do
    print (Diff.doc (diffType @OldType @NewType))

NewType.hs

{-# LANGUAGE DeriveAnyClass #-}
{-# LANGUAGE DeriveGeneric  #-}

module NewType where

import Data.Text (Text)
import Dhall (ToDhall)
import GHC.Generics (Generic)

data NewType
    = Foo{ bar :: Text, baz :: Bool, new :: [Double] }
    | Qux{ qyzzy :: Integer }
    deriving (Generic, ToDhall)

OldType.hs

{-# LANGUAGE DeriveAnyClass        #-}
{-# LANGUAGE DeriveGeneric         #-}

module OldType where

import Data.Text (Text)
import Dhall (ToDhall)
import GHC.Generics (Generic)
import Numeric.Natural (Natural)

data OldType
    = Foo{ bar :: Text, baz :: Bool }
    | Qux{ qyzzy :: Natural }
    deriving (Generic, ToDhall)

output.txt

< Foo : : { + new : …
          , …
          }
| Qux : : { qyzzy : - Natural
                    + Integer
          }
>