fpkata-relex/ep0001/Solution.md

# FPKATA #01: In the library…

(Soundtrack: Arch Enemy — War Eternal)

(Inspired from this exercice: http://www.codewars.com/kata/54dc6f5a224c26032800005c/train/haskell)

## REPL compatible copy/paste (TL;DR)

```
import Dict

type Stock = Stock { name : String, count : Int }
library1 =  [ Stock { name = "ABART", count = 20 } , Stock { name = "CDXEF", count = 50 } , Stock { name = "BKWRK", count = 25 } , Stock { name = "BTSQZ", count = 89 } , Stock { name = "DRTYM", count = 60 } ]
categories1 = [ 'A', 'B', 'C', 'W' ]

toUplet : List Repl.Stock -> List ( String, Int )
toUplet = List.map (\x -> case x of Stock v -> (v.name,v.count))

onlyInitials : List (String, Int) -> List (Char, Int)
onlyInitials = List.map (\x -> case x of (s, i) -> ((Maybe.withDefault '\0' << List.head << String.toList) s,i) )

howMany : Char -> List Char Int -> Int
howMany c = (List.foldl (\t acc -> acc + Tuple.second t) 0) << List.filter (\t -> (Tuple.first t) == c)

stockList : List Stock -> List Char -> List ( Char, Int )
stockList sl = List.map (\c -> (c, sl |> toUplet >> onlyInitials >> howMany c))
```

## Prologue

You are stuck in a library with a very talkative and experimental science-minded IA. It keeps repeating the following:

> — Pleeease, can you help me?

> — …

> — Pleaaase, can you help?

> — …

> — Hellooooo?

> — …

Since you would really like to have peace, you dare ask:

> — What's the matter?

> — My code is incomplete, I've lost my code, please help!

> — What code? What are you talking about?

> — I really need to sort the library index and count how many books have the
> same first-letter reference, but only in from a list…

> — Wait!

> — … of characters that my master will provide.

> This makes no sense, can't you write it down?

A few seconds pass in total silence. Then, there's a sound coming from
your right, something like an inkjet printer work at a fast pace. It's
actually a printer. It throws the printed sheet of paper at you in a furious
“TWEEEEEEEEEEEP”. You pick up the paper and read:

    INPUT................:
      LIBRARY COUNT......: [("ABOOK", 12), ("BPDEXU", 45), ("BJLDRSA", 15), ("CLDAVB", 98), ("DAJLDI", 32)]
      INDICES............: ['A','B','C','W']
    OUTPUT...............:
      INDEX COUNT........: [('A',12),('B',60),('C',98),('W',0)]
    TIME TO GOOD ANSWER..: 203 years

You frown:

> — It took you so long to find this?

> — Can you help me? I've lost my code, my dedicated code for this task.

> — Well, you managed to get this one right, didn't you?

> — Nooooo! Master is going to unplug me if I use bruteforce again! Master was
    very unhappy with my performance! I want to live! Please help me!

> — Ok, all right, calmn down, there, there… What are programmed with?

> — Elm.

Of course it's Elm…

## Outline

```
module Main exposing (..)

import Html exposing (text)


type Stock
    = Stock String Int


library1 : List Stock
library1 =
    [ Stock "ABART" 20
    , Stock "CDXEF" 50
    , Stock "BKWRK" 25
    , Stock "BTSQZ" 89
    , Stock "DRTYM" 60
    ]


categories1 : List Char
categories1 =
    [ 'A'
    , 'B'
    , 'C'
    , 'W'
    ]


stockList : List Stock -> List Char -> List ( Char, Int )
stockList st cs =
    <THIS IS BLANK, FILL ME>


main =
    text (toString (stockList library1 categories1))
```

## Walkthrough

All is needed is to fill the gaps from `library1`, `categories1` to `stockList`.
So, what is needed for successfully building a stockList? Let's look at the types:
We have a `List Stock` but we don't have any function to work on it. We could
make some functions for this, but we'll just be lazy and turn a List Stock into
a much lower level `List (String, Int)`:

    toUplet : List Stock -> List ( String, Int )
    toUplet = List.map (\x -> case x of Stock v -> (v.name,v.count))

We'll need to count stock by initials, so we write a function for that:

    onlyInitials : List (String, Int) -> List (Char, Int)
    onlyInitials = List.map (\x -> case x of (s, i) -> ((Maybe.withDefault '\0' << List.head << String.toList) s,i) )

So, for every tuple, we operate of the left part. There is some strange
machinery for turning a `String -> Char` involving a Maybe value, because
`List.head` may fail. Of course in our case, no book should ever have an empty
title, but Elm doesn't know that. We mitigate this by setting a default `null`
char if the title is empty.

Good! We can already chain the two preceding functions since the output type
of `toUplet` matches the input type of `onlyInitials`. Ain't that a coincidence?

    > library1 |> toUplet >> onlyInitials
    [('A',20),('C',50),('B',25),('B',89),('D',60)] : List ( Char, Int )

Oh, but oh. There are two Bs in there! Those should go together and their counts
added together, and for that, nothing is better than a fold. Let's write a function
that answers the question: “How many X is there?” where X is a Char.

    howMany : Char -> List Char Int -> Int
    howMany c = List.filter (\t -> (Tuple.first t) == c)
              >> (List.foldl (\t acc -> acc + Tuple.second t) 0)

`howMany` is made of two functions: the first is one that only keeps tuples
of interest (they match our Char c) and then we blindly sum the count of the
resulting list. We always start the count from 0, so that if we don't find
anything, it's still correct.

Let's try to find how may books that have a title starting with B in the library:

    > library1 |> toUplet >> onlyInitials >> howMany 'B'
    114 : Int

Nice! Well, we're almost done actually. We just need to do that for every letter
we were requested in `categories1`. Let's use a map for that:

    stockList sl = List.map (\c -> (c, sl |> toUplet >> onlyInitials >> howMany c) )

And voilà! Let's run this:

    > stockList library1 categories1
    [('A',20),('B',114),('C',50),('W',0)] : List ( Char, Int )

Mission accomplished.

## Epilogue