# 1. Introduction¶

## 1.1. Motivating example¶

Suppose we want to encode lambda-calculus using an ADT. We could use the following one:

```
data Expr n -- "n" represents a variable name
= Lambda n (Expr n)
| Var n
| App (Expr n) (Expr n)
```

We can define a pretty-print operation:

```
prettyPrint :: Show n => Expr n -> String
prettyPrint = \case
Var n -> show n
Lambda n e -> mconcat ["\\",show n,".",prettyPrint e]
App e1 e2 -> mconcat ["(",prettyPrint e1,") (",prettyPrint e2,")"]
```

And we can test on an example:

```
sampleDouble :: Expr String
sampleDouble = Lambda "x" (Var "+" `App` Var "x" `App` Var "x")
> putStrLn (prettyPrint sampleDouble)
\"x".(("+") ("x")) ("x")
```

Now suppose that we want to add support for annotations. We can define a new expression ADT with an additional constructor:

```
data AExpr a n -- "n" represents a variable name, "a" represents an annotation
= ALambda n (AExpr a n)
| AVar n
| AApp (AExpr a n) (AExpr a n)
| Ann a (AExpr a n)
```

But now we need to rewrite our operations and expressions (such as “prettyPrint” and “sampleDouble”) to handle and to use the constructors of the new expression ADT:

```
prettyPrintA :: (Show n, Show a) => AExpr a n -> String
prettyPrintA = \case
AVar n -> show n
ALambda n e -> mconcat ["\\",show n,".",prettyPrintA e]
AApp e1 e2 -> mconcat ["(",prettyPrintA e1,") (",prettyPrintA e2,")"]
Ann a e -> mconcat ["{",show a,"} ", prettyPrintA e]
sampleDoubleA :: AExpr a String
sampleDoubleA = ALambda "x" (AVar "+" `AApp` AVar "x" `AApp` AVar "x")
sampleAnnA :: AExpr String String
sampleAnnA = Ann "Double its input" sampleDouble
```

Now the problem is that we have two totally independent expression types
(`Expr`

and `AExpr`

) with different operations (`prettyPrint`

vs
`prettyPrintA`

) which can’t be easily mixed. Moreover to define
`prettyPrintA`

we had to copy-paste `prettyPrint`

just to add a single case
alternative. Now suppose that we want to add a new function (e.g. to compute
free variables of an expression): should we implement it for `Expr`

, for
`AExpr`

, for both?

Finally suppose that we want to add some other constructors: we either get a combinatorial explosion of ADTs and functions, or we give up on static checking and use the “largest” ADT (which contains a superset of the constructors of the others) with some conventions, e.g. comments and runtime assertions such as “at this point this expression shouldn’t contain any annotation” that are not enforced by the compiler.

## 1.2. Motivating example with EADTs¶

The same example with EADTs would be written as follows. First we define the EADTs:

```
import Haskus.Utils.EADT
import Haskus.Utils.EADT.TH
data LambdaF n e = LambdaF n e deriving Functor
data VarF n e = VarF n deriving Functor
data AppF e = AppF e e deriving Functor
data AnnF a e = AnnF a e deriving Functor
eadtPattern 'LambdaF "Lambda"
eadtPattern 'VarF "Var"
eadtPattern 'AppF "App"
eadtPattern 'AnnF "Ann"
type Expr n = EADT '[LambdaF n, VarF n, AppF]
type AExpr a n = EADT '[LambdaF n, VarF n, AppF, AnnF a]
```

Then we define the `prettyPrint`

operation by using type classes:

```
class PrettyPrint f where
prettyPrint' :: f String -> String
instance Show n => PrettyPrint (VarF n) where
prettyPrint' (VarF n) = show n
instance Show n => PrettyPrint (LambdaF n) where
prettyPrint' (LambdaF n e) = mconcat ["\\",show n,".",e]
instance PrettyPrint AppF where
prettyPrint' (AppF e1 e2) = mconcat ["(",e1,") (",e2,")"]
instance Show a => PrettyPrint (AnnF a) where
prettyPrint' (AnnF a e) = mconcat ["{",show a,"} ",e]
prettyPrint :: (BottomUp PrettyPrint xs, Functor (VariantF xs)) => EADT xs -> String
prettyPrint = bottomUp (toBottomUp @PrettyPrint prettyPrint')
```

We can test it with:

```
sampleDouble :: Expr String
sampleDouble = Lambda "x" (Var "+" `App` Var "x" `App` Var "x")
sampleAnn :: AExpr String String
sampleAnn = Ann "Double its input" (liftEADT sampleDouble)
> putStrLn (prettyPrint sampleDouble)
\"x".(("+") ("x")) ("x")
> putStrLn (prettyPrint sampleAnn)
{"Double its input"} \"x".(("+") ("x")) ("x")
```