Haskell - The Legend of DSLs

![Haskell - The Legend of DSLs](img/session1.png)

---

# In previous years...

```
             Your knowledge of C#
      + Your knowledge of Haskell
---------------------------------
Ready for mainstream programming!
```

---

# In previous years...

```
             Your knowledge of C#
      + Your knowledge of Haskell
---------------------------------
Ready for mainstream programming!
```

Last decade has been a good one for programing languages

- Java or C# were stuck in 2000s
- Now we have Scala, Kotlin, Swift, Elixir!
- And Java and C# are catching up

---

# Higher order functions are just there

### .grey[You understand this!]

From the Java documentation

.code70[
```java
int sum = 
  widgets.stream()
         .filter(w -> w.getColor() == RED)
         .mapToInt(w -> w.getWeight())
         .sum();
```
]

.font60[
Reference: <br /> `https://docs.oracle.com/javase/8/docs/api/java/util/stream/Stream.html`
]

---

# In previous years...

```
             Your knowledge of C#
      + Your knowledge of Haskell
---------------------------------
Ready for mainstream programming!
```

> Most of these ideas come from FP

INFOFP has become really relevant

## **Let's do something else instead!**

---

# <img src="img/pikachu.png" width="32px" /> Pokémon Trading Card Game

Players take turns drawing and playing cards

<table>
  <tr>
    <td style="vertical-align: top"><img src="img/pikachucard.png" width="100%" /></td>
    <td width="68%" style="padding-left: 20px; line-height: 1.3;">
      <div style="margin-bottom: -20px">Goal: knock out 6 of your opponent's Pokémon</div>
        <ul>
          <li>For this your use <b>attacks</b></li>
          <li>Those attacks cost <b>energy</b></li>
          <li>Each attack does <b>damage</b></li>
          <li><b>HP</b> define the maximum damage before knock-out</li>
        </ul>
    </td>
  </tr>
</table>

---

# 🏗️ Our approach

### .grey[Explanations interleaved with tasks]

1. Representing cards
2. Representing actions
3. Testing actions

## .grey[Domain-specific Language (DSL)]

Implementation of the _Ubiquitous Language_ idea from DDD, the code speaks the domain

---

# <img src="img/pikachu.png" width="32px" /> Representing cards

<table>
  <tr>
    <td style="vertical-align: top"><img src="img/pikachucard.png" width="100%" /></td>
    <td width="68%" style="padding-left: 20px; line-height: 1.3;">
      <div style="margin-bottom: -20px">Each card comes with...</div>
        <ul style="margin-bottom: 20px">
          <li>Name: <span class="remark-code-zoom">Pikachu</span></li>
          <li>Type: <img src="img/energy/lightning.webp" height="32px" /></li>
          <li>HP: 70</li>
          <li>Attack(s)</li>
        </ul>
        (forget about the rest for now)
    </td>
  </tr>
</table>

---

# ⚙️ Algebraic Data Types (ADTs)

<table style="font-size: 70%">
  <tr>
    <td style="vertical-align: top; text-align: right;"><img src="img/pikachucard.png" width="60%" /></td>
    <td width="68%" style="padding-left: 20px; line-height: 1.3;">
      <div style="margin-bottom: -20px">Each card comes with...</div>
        <ul style="margin-bottom: 20px">
          <li>Name: <span class="remark-code-zoom">Pikachu</span></li>
          <li>Type: <img src="img/energy/lightning.webp" height="20px" /></li>
          <li>HP: 70</li>
          <li>Attack(s)</li>
        </ul>
    </td>
  </tr>
</table>

Straightforward translation of the description

.code70[
```haskell
data Card = Card { name    :: Text
                 , typ     :: Energy
                 , hp      :: Natural
                 , attacks :: [Attack] }
```
]

---

# ⚙️ Algebraic Data Types (ADTs)

.code70[
```haskell
data Card = Card { name    :: Text
                 , typ     :: Energy
                 , hp      :: HP
                 , attacks :: [Attack] }

newtype HP = HP Natural 
           deriving (Eq, Show, Num)
```
]

---

# ☯️ Energies

There are 10 types of energy in the game,

- 9 regular energies <img src="img/energy/grass.webp" width="32px" /> <img src="img/energy/fire.png" width="32px" /> <img src="img/energy/water.webp" width="32px" /> <img src="img/energy/lightning.webp" width="32px" /> <img src="img/energy/fighting.webp" width="32px" /> <img src="img/energy/psychic.webp" width="32px" /> <img src="img/energy/darkness.webp" width="32px" /> <img src="img/energy/metal.webp" width="32px" /> <img src="img/energy/dragon.webp" width="32px" />
- Colorless energy <img src="img/energy/colorless.webp" width="32px" />
    - Any card providing a regular energy may also provide colorless energy

<img src="img/attack.png" height="48px" style="margin-top: 10px; margin-bottom: -10px;" /> = 2 <img src="img/energy/lightning.webp" width="32px" /> + 1 of any other

---

# ☯️ Energies

There are 10 types of energy in the game,

data Card = PokemonCard { ... }
          | EnergyCard  { typ :: Energy }
```
]

---

# ⚔️ Attacks

We consider only "simple" attacks for now

.code70[
```haskell
data Attack = Attack { attackName :: Text
                     , cost       :: [Energy] 
                     , damage     :: Natural }
```
]

---

# 🧑‍💻 Time for practice!

Define values for the following cards

---

# ⚔️ Attacks, redux

## .grey[This is a ~~lie~~ simplification]

---

# ⚔️ Attacks, redux

---

# ⚔️ Attacks, redux

## .grey[This is a ~~lie~~ simplification]

.top-margin[
- More actions than mere damage
    - Draw and discard cards
- Actions may depend on the state
    - Attached cards
    - Coin flips
- Actions may involve conditionals and loops
]

---

# ⚔️ Attacks, redux

## How do we model .grey[actions]?

.top-margin[
- More actions than mere damage
    - Draw and discard cards
- Actions may depend on the state
    - Attached cards
    - Coin flips
- Actions may involve conditionals and loops
]

---

# 🪙 Coin flips

data Action
  = FlipCoin (FlipOutcome -> Action)
  | Damage Natural

surpriseAttackAction
  = FlipCoin $ \case Heads -> Damage 30
                     Tails -> Damage 0
```
]

---

# 🪙 Coin flips

## .grey[🧑‍💻 Time for practice!] .font70[`serranofp.com/infofp.zip`]

---

# 🪙 Coin flips

```haskell
ironTailAction = go 0
  where
    go acc = FlipCoin $ \case
      Tails -> Damage acc
      Heads -> go (acc + 30)
```

---

# 🧞 Syntax/algebra and interpretation

`Action` defines the **syntax** of our DSL <br /> (also known as **algebra** in some circles)

> "The language itself", "what we can say"

---

# 🧞 Syntax/algebra and interpretation

`Action` defines the **syntax** of our DSL <br /> (also known as **algebra** in some circles)

An **interpretation** defines how each value behaves in a certain context

> "What a sentence means"

1 syntax / algebra ⟷ ∞ interpretations

---

# 🎰 Randomness interpretation

During the actual game, we expect to generate random coin flips to obtain the actual damage

```haskell
interpretRandom :: Action -> IO Natural
```

## .grey[🧑‍💻 Time for practice!] .font70[`serranofp.com/infofp.zip`]

---

# 🎰 Randomness interpretation

During the actual game, we expect to generate random coin flips to obtain the actual damage

```haskell
interpretRandom :: Action -> IO Natural
interpretRandom (Damage d)   = pure d
interpretRandom (FlipCoin f) = do
  outcome <- flipCoin
  interpretRandom (f outcome)
  -- one-liner
  -- flipCoin >>= interpretRandom . f
```

---

# 🎴 Actions about cards

---

# 🎴 Actions about cards

.code70[
```haskell
data Action
  = FlipCoin (FlipOutcome -> Action)
  | DrawCard (Maybe Card -> Action)
    -- ^ there may not be more cards
  | QueryAttached ([Card] -> Action)
    -- ^ get info. about the current Pokémon
  | Damage Natural
```
]

### .grey[Can you spot the pattern? 🔍]

---

# 🎴 Actions about cards

- `Damage` is a **final** action
- The rest "generate" a value, <br /> which is consumed to keep going

---

# 🎴 Actions about cards

## .grey[🧑‍💻 Time for practice!] .font70[`serranofp.com/infofp.zip`]

.margin-top[
1. Write a function to **draw *n* ** cards
2. Add an additional operation to **discard** cards
  - Must include a predicate to select cards
  - Outcome: whether a card was discarded
]

---

# 🎴 Actions about cards

## .grey[🧑‍💻 Time for practice!] .font70[`serranofp.com/infofp.zip`]

Write a function to **draw *n* ** cards

_What should be the function signature?_

```haskell
drawN :: Natural             -- amount
      -> ([Card] -> Action)  -- "next"
      -> Action
drawN n next = _
```

---

# 🎴 Actions about cards

Write a function to **draw *n* ** cards

.code70[
```haskell
drawN n next = go n []
  where
    go n acc
      | n <= 0
      = next (reverse acc)
      | otherwise
      = DrawCard $ \case
          Nothing -> next (reverse acc)
          Just c  -> go (n - 1) (c : acc)
```
]

---

# 🩻 Property-based testing

Generate many _random_ tests for the same function (or set of them)

Focus on **properties** rather than examples

- PBT frameworks are good at generating corner cases (extreme values, empty lists, ...)

---

# ✅ Testing actions

### .grey[How can we test `ironTailAction`?]

---

# ✅ Testing actions

### .grey[How can we test `ironTailAction`?]

- If we get a tail as first result, we get 0
- If our outcomes start with `n` heads, <br /> then the result is `30 * n`

---

# ✅ Testing actions

### .grey[How can we test `ironTailAction`?]

❌ Using `interpretRandom` would not work

- The outcome is random
- Testing `IO` is cumbersome

---

# 🧮 Pure interpretation of flipping

We pass the future outcomes as a parameter

```haskell
interpretPure :: [FlipOutcome]
              -> Action -> Natural
```

---

# 🧮 Pure interpretation of flipping

We pass the future outcomes as a parameter

```haskell
interpretPure :: [FlipOutcome]
              -> Action -> Natural
```

Now we control the future 🔮

```haskell
> interpretPure [Heads, Heads, Tails] 
                ironTailAction
60
```

---

# 🧮 Pure interpretation of flipping

.code70[
```haskell
interpretPure :: [FlipOutcome]
              -> Action -> Natural
interpretPure (result : future) (FlipCoin next) =
  interpretPure future (next result)
interpretPure _future (Damage n) = n
```
]

---

# 🏃 QuickCheck + Tasty 🥧

**QuickCheck** is a well-known library for property-based testing

- Define properties of functions
- Support for custom generators

**Tasty** is a test runner

- Runs and reports over a set of tests

---

# 🏃 QuickCheck + Tasty 🥧

🥧 `testGroup` + 🏃 `testProperty`
- `outcomes` is randomly selected

.code70[
```haskell
tests :: TestTree
tests = testGroup "Iron Tail"
  [ testProperty "non-negative" $ \outcomes -> 
      interpretPure (outcomes ++ [Tails]) 
                    ironTailAction >= 0
  , ... ]
```
]

---

# ✋ A wrong property

```haskell
interpretPure ... ironTailAction > 0
```

A counter-example is found by QuickCheck

.code70[
```
Iron Tail
  non-negative:        FAIL
    *** Failed! Falsified (after 1 test):
    []
    Use --quickcheck-replay=139730 to reproduce.
    Use -p '/non-negative/' to rerun this test only.
```
]

---

# <img src="img/pikachu.png" width="32px" /> The "times 30" property

To create good properties you must...

- Be creative with the inputs
- Ensure that inputs are correct

.code70[
```haskell
testProperty "30 * # heads" $ \(hs :: Int) ->
  hs > 0 ==>
    let outcomes = replicate hs Heads ++ [Tails]
    in interpretPure outcomes ironTailAction
          == fromIntegral (hs * 30)
```]

---

# 👻 Spooky slides ahead

---

# 👎 This is terrible

```haskell
ironTailAction = go 0
  where
    go acc = FlipCoin $ \case
      Tails -> Damage acc
      Heads -> go (acc + 30)
```

---

# 👍 This reads better

```haskell
ironTailAction = do
  heads <- while (/= Tails) flipCoin
  return (30 * length heads)
```

## We are building our own .grey[language]

---

# 🧙 Monads!

```haskell
data Action
  = FlipCoin (FlipOutcome -> Action)
  | Damage Natural
```

Why is it **not** possible to write `Monad` for this?

`Monad` applies to .grey[**type constructors**]

- We need to turn this into `Action a`

---

# 🧙 Monads!

```haskell
data Action a
  = FlipCoin (FlipOutcome -> Action a)
  | Return a  -- "ends" the computation
```

## .grey[🧑‍💻 Time for practice!] .font70[`serranofp.com/infofp.zip`]

Write the `Monad Action` instance

---

# 🧙 Monads!