関数型言語Elmでテスト駆動開発(15~16章)

[前回の記事](https://qiita.com/ababup1192/items/efc8355281a656479f3a)の続きになります。前回レート計算の実装が課題でしたが辞書型のお陰で思いの外、簡単に実装がおこなえました。今回でさらなる抽象化を進め、複雑なテストを増やすことで最終回となります。ここまで見てくださった方(いれば)、本当にありがとうございました！

# 15章

遂に、本来やりたかった他貨幣間での足し算の実装をおこないます。それにともない、各関数を```Money```型から```Expression```に抽象度を引き上げていきます。

- [ ] **\$5 + 10 CHF = \$10 (レートが2:1の場合)**
- [x] ~~\$5 + \$5 = \$10~~
- [ ] \$5 + \$5 がMoneyを返す
- [x] ~~Bank.reduce(Money)~~
- [x] ~~Moneyを変換して換算を行う~~
- [x] ~~Reduce(Bank, Currency)~~

追加される他貨幣間の足し算のテストは以下のものになります。

[tests/Tests.elm](https://github.com/ababup1192/elm-tdd/blob/s15_step1_money2expression/tests/Tests.elm)

```diff
+ describe "Mixed Addition"
+            [ "CHF ~> USD 2"
+                => let
+                    fiveBucks =
+                        dollar 5
+
+                    tenFrancs =
+                        franc 10
+
+                    bank =
+                        Bank.bank |> Bank.addRate (CHF ~> USD) 2
+
+                    result =
+                        Bank.reduce (fiveBucks $+ tenFrancs) USD bank
+                   in
+                    dollar 10 === result
+            ]
```

Moneyの定義では、```dollar```と```franc```関数が```Money```型を返したいたものを```Single```に噛ませて```Expression```型に引き上げます。そして、今までMoney型で書いていた関数を全てExpression型に引き上げます(結構大工事です)。その場合すべての関数でパターンマッチをする必要があり面倒ですが、あとから解消するための手立てが出てくるのでお待ち下さい。ただ```currency```関数は、
Sum(足し算)の場合には、後ろの項の貨幣が取得されるという実装詳細が生じてしまいます。

[src/Money/Money.elm](https://github.com/ababup1192/elm-tdd/blob/s15_step1_money2expression/src/Money/Money.elm)

```diff
- dollar : Amount -> Money
+ dollar : Amount -> Expression
  dollar amount =
-     Money amount USD
+     Single <| Money amount USD

- franc : Amount -> Money
+ franc : Amount -> Expression
  franc amount =
-     Money amount CHF
+     Single <| Money amount CHF

- times : Int -> Money -> Money
- times multiplier (Money amount currency) =
-     Money (multiplier * amount) currency
+ times : Expression -> Int -> Expression
+ times exp multiplier =
+     case exp of
+         Single (Money amnt crncy) ->
+             Single <| Money (amnt * multiplier) crncy
+
+         Sum exp1 exp2 ->
+             let
+                 mlp_ e =
+                     times e multiplier
+             in
+                 Sum (mlp_ exp1) (mlp_ exp2)

- ($+) : Money -> Money -> Expression
+ ($+) : Expression -> Expression -> Expression
- ($+) money1 money2 =
-     Expression.sum money1 money2
+ ($+) exp1 exp2 =
+     Sum exp1 exp2
  
- amount : Money -> Amount
- amount (Money amount _) =
-     amount

- currency : Money -> Currency
+ currency : Expression -> Currency
- currency (Money _ currency) =
-     currency
+ currency expression =
+     case expression of
+         Single (Money _ currency) ->
+             currency
+         Sum _ exp2 ->
+             currency exp2
```

Bankの```reduce```関数も```Money```型を返却していたものを```Expression```型のまま返すようにしています。```amount```関数は、Bankのみ(レート計算が行われた前提)で使われるためMoneyから移行をしました。

[src/Bank.elm](https://github.com/ababup1192/elm-tdd/blob/7c0d09d9cf719624e4f9e182523e8c05b3e9ded3/src/Bank.elm)

```diff
- reduce : Expression -> Currency -> Bank -> Money
+ reduce : Expression -> Currency -> Bank -> Expression
  reduce source to bank =
       case source of
-        Single (Money amount currency) ->
+        Single (Money amnt currency) ->
              let
                  r =
                      rate (currency ~> to) bank
              in
-                 Money (amount // r) to
+                 Single <| Money (amnt // r) to
  
          Sum exp1 exp2 ->
-             Money (sum_ exp1 exp2 to bank) to
+             Single <| Money (sum_ exp1 exp2 to bank) to
+ 
+
+ amount : Expression -> Int
+ amount expression =
+      case expression of
+         Single (Money amnt _) ->
+             amnt
+
+         Sum exp1 exp2 ->
+             (amount exp1) + (amount exp2)
```

[この時点でのコード全体](https://github.com/ababup1192/elm-tdd/tree/s15_step1_money2expression)

書籍の方ではここまで完全な抽象化は行っていないのですが、Elmでは完全な形で移行しないと上手く行かない部分が生じてしまったのでこのような形になりました。また、この抽象化で、16章の内容も終わっています。しかし、コードが冗長な部分をリファクタリングをしたかったため、もう少し15章の内容を進めたいと思います。

これまでの内容で```Money```から```Expression```に引き上げたので、Expression.elmに内容を移したほうがモジュールとしてスッキリする気がしてきました。また、```$+```に合わせて、timesも```$*```という特殊な演算子に変えてしまいましょう。

[src/Expression.elm](https://github.com/ababup1192/elm-tdd/blob/755f8a0743c1f488b6ccb7a1c11256448809ecae/src/Expression.elm)

```diff
+ ($+) : Expression -> Expression -> Expression
+ ($+) exp1 exp2 =
+     Sum exp1 exp2
+
+
+ ($*) : Expression -> Int -> Expression
+ ($*) exp multiplier =
+     case exp of
+         Single (Money amnt crncy) ->
+             Single <| Money (amnt * multiplier) crncy
+
+         Sum exp1 exp2 ->
+             let
+                 mlp_ e =
+                     e $* multiplier
+             in
+                 Sum (mlp_ exp1) (mlp_ exp2)
+
+
+ currency : Expression -> Currency
+ currency expression =
+     case expression of
+         Single (Money _ currency) ->
+             currency
+
+         Sum _ exp2 ->
+             currency exp2
+
+
+ amount : Expression -> Int
+ amount expression =
+     case expression of
+         Single (Money amnt _) ->
+             amnt
+
+         Sum exp1 exp2 ->
+             (amount exp1) + (amount exp2)
```

テストも演算子で書き換えてみましょう。自然な計算のように見えます！

```diff
- => (dollar 5 |> times 2)
+ => (dollar 5 $* 2)
- => (dollar 5 |> times 3)
+ => (dollar 5 $* 3)
```

ここでExpressionの関数に注目してみましょう。2つのタイプの関数があることがわかります。```($*)```のように、Expressionが新たなExpressionを返す関数と、```currency```や```amount```のように別な型に収束するタイプの関数です。

```haskell
($*) : Expression -> Int -> Expression

currency : Expression -> Currency
amount : Expression -> Int
```

更に内部構造に注目すると以下の2つの関数のように括り出すことができます。この2つの関数は関数型由来のものですが、本来の性質と若干違う部分があるので詳細の説明は省きます。

```haskell
map : (Money -> Money) -> Expression -> Expression
map f exp =
    case exp of
        Single money ->
            Single <| f money

        Sum exp1 exp2 ->
            Sum (map f exp1) (map f exp2)


fold : (Money -> a -> a) -> a -> Expression -> a
fold f init exp =
    case exp of
        Single money ->
            f money init

        Sum exp1 exp2 ->
            (amount exp1) + (amount exp2)
            fold f (fold f init exp1) exp2
```

この2つの関数を利用すると、なんとなんと1行で実装が終わってしまいます！2つの関数に当てはめながらどんな風に展開されるか試していただけると楽しめると思います。
 
```haskell
($*) : Expression -> Int -> Expression
($*) exp multiplier =
map (\(Money amnt c) -> Money (amnt * multiplier) c) exp
 ```
 
fold関数は初期値が必要とされるのですが、貨幣(Currency)の初期値というものは存在しないので、USDと仮でさせていただきました。
 
 
```haskell
currency : Expression -> Currency
currency exp =
     fold (\(Money _ c) _ -> c) USD exp
```
 
```haskell
amount exp =
     fold (\(Money amnt _) sum -> sum + amnt) 0 exp
```

amount関数のみ、どのように展開されるかやってみましょう。非常にシンプルなパターンですが、以下のように展開されます。

```haskell
amount Single(Money 10 USD)
    = fold (\(Money amnt _) sum -> sum + amnt) 0 Single (Money 10 USD)
    = (\(Money amnt _) sum -> sum + amnt) (Money 10 USD) 0 
    = (\(Money 10 _) 0 -> 0 + 10)
    = 0 + 10
    = 10
```

これでリファクタリングは終わりとなります。この先、このプロジェクトを拡張するときも、同じパターンに適用できる場合は、関数を渡すだけで処理を記述することができます。

# 16章

15章の説明で述べた通りです。実装はすでに終えているので、テストを追加するのみです。演算子のお陰で貨幣の計算が自然に記述できるのが嬉しいですね。

```diff
+         , describe "Sum Plus Money"
+            [ "($5 + 10 CHF) + $5"
+                => let
+                    fiveBucks =
+                        dollar 5
+
+                    tenFrancs =
+                        franc 10
+
+                    bank =
+                        Bank.bank |> Bank.addRate (CHF ~> USD) 2
+
+                    sum =
+                        Bank.reduce ((fiveBucks $+ tenFrancs) $+ fiveBucks) USD bank
+
+                    result =
+                        Bank.reduce sum USD bank
+                   in
+                    dollar 15 === result
+            ]
+        , describe "Sum Times"
+            [ "($5 + 10 CHF) * 2"
+                => let
+                    fiveBucks =
+                        dollar 5
+
+                    tenFrancs =
+                        franc 10
+
+                    bank =
+                        Bank.bank |> Bank.addRate (CHF ~> USD) 2
+
+                    sum =
+                        Bank.reduce ((fiveBucks $+ tenFrancs) $* 2) USD bank
+
+                    result =
+                        Bank.reduce sum USD bank
+                   in
+                    dollar 20 === result
+            ]
```

お疲れ様です。[最終実装](https://github.com/ababup1192/elm-tdd/tree/session15)になります。

# まとめ

MoneyからExpression型に引き上げ、最後の実装にまで一気に解決しました。また処理の性質に注目し、mapとfoldという関数を定義しExpressionの関数を短くすることができました。また今回のTdd Elm連載を通した、全体的な総括とオブジェクト指向のコードをElmコードに落とすテクニックを[Elm Advent Calendar 2017](https://qiita.com/advent-calendar/2017/elm)にて、掲載したいと思っています。もしよろしければ、そちらでまたお会いしましょう。今まで記事を見てくださって本当にありがとうございました！

# 追記

投稿後 @miyamo_madoka さんよりPRをいただきました。実装の怪しげな部分が一切なくなり、とてもスッキリした実装にしていただきました。私の実装で大きく間違っている部分が抽象度を気にするあまりBankの```reduce : Bank -> Currency -> Expression -> Expression```の最後の型が```Expression```のままであることでした。```reduce : Bank -> Currency -> Expression -> Money```のようにMoney型に戻してあげることで、多くの問題は解決されたと思います。例えば通貨```currency```は```Money```型しか取得できないのが当たり前で、抽象化された```Expression```型では、他通貨同士の足し算のケースもあるため一意に定まらないと言う問題が解消されました(```amount```も同様)。さらに、PRをいただいた後、私の実装と見比べいくつかリファクタリングをおこない、本当に最後の実装としました。ご指摘本当にありがとうございました。せっかくなので実装をすべて載せて終わりたいと思います。

[src/Money/Model.elm](https://github.com/ababup1192/elm-tdd/blob/master/src/Money/Model.elm)

```haskell
module Money.Model exposing (Money(..), Amount, Currency(..))


type alias Amount =
    Int


type Currency
    = USD
    | CHF


type Money
    = Money Amount Currency
```

[src/Money/Money.elm](https://github.com/ababup1192/elm-tdd/blob/master/src/Money/Money.elm)

```haskell
module Money.Money exposing (dollar, franc, currency, amount)

import Money.Model exposing (Money(..), Amount, Currency(..))


dollar : Amount -> Money
dollar amount =
    Money amount USD


franc : Amount -> Money
franc amount =
    Money amount CHF


currency : Money -> Currency
currency (Money _ c) =
    c


amount : Money -> Amount
amount (Money a _) =
    a
```

[src/Bank.elm](https://github.com/ababup1192/elm-tdd/blob/master/src/Bank.elm)

```haskell
module Bank exposing (bank, rate, Bank, addRate, (~>), reduce)

import Money.Model exposing (Currency, Money(..))
import Money.Money as Money
import EveryDict exposing (EveryDict)
import Expression exposing (Expression(..))


type alias Bank =
    EveryDict ( Currency, Currency ) Int


bank : Bank
bank =
    EveryDict.empty


(~>) : a -> b -> ( a, b )
(~>) a b =
    ( a, b )


addRate : ( Currency, Currency ) -> Int -> Bank -> Bank
addRate fromTo rate =
    EveryDict.insert fromTo rate


rate : ( Currency, Currency ) -> Bank -> Int
rate (( from, to ) as fromto) bank =
    if from == to then
        1
    else
        case EveryDict.get fromto bank of
            Just r ->
                r

            Nothing ->
                Debug.crash <| (toString from) ++ " ~> " ++ (toString to) ++ " is not found."


reduce : Bank -> Currency -> Expression -> Money
reduce bank to exp =
    case exp of
        Single (Money amnt source) ->
            let
                r =
                    rate (source ~> to) bank
            in
                Money (amnt // r) to

        Sum exp1 exp2 ->
            let
                amnt_ e =
                    Money.amount <| reduce bank to e

                a1 =
                    amnt_ exp1

                a2 =
                    amnt_ exp2
            in
                Money (a1 + a2) to
```

[src/Expression.elm](https://github.com/ababup1192/elm-tdd/blob/master/src/Expression.elm)

```haskell
module Expression exposing (Expression(..), single, ($+), ($*))

import Money.Model exposing (Money(..), Currency)


type Expression
    = Single Money
    | Sum Expression Expression


single : Money -> Expression
single =
    Single


($+) : Expression -> Expression -> Expression
($+) =
    Sum


($*) : Expression -> Int -> Expression
($*) exp multiplier =
    map (\(Money amnt c) -> Money (amnt * multiplier) c) exp


map : (Money -> Money) -> Expression -> Expression
map f exp =
    case exp of
        Single money ->
            Single <| f money

        Sum exp1 exp2 ->
            Sum (map f exp1) (map f exp2)


infixl 6 $+


infixl 7 $*
```

[tests/Tests.elm](https://github.com/ababup1192/elm-tdd/blob/master/tests/Tests.elm)

```haskell
module Tests exposing (..)

import Test exposing (..)
import TestExp exposing (..)


-- Test target modules

import Money.Money as Money exposing (..)
import Money.Model exposing (..)
import Bank exposing (..)
import Expression exposing (..)


all : Test
all =
    describe "Money Test"
        [ describe "Dollar"
            [ "Multiplication1"
                => ((single <| dollar 5) $* 2)
                === (single <| dollar 10)
            , "Multiplication2"
                => ((single <| dollar 5) $* 3)
                === (single <| dollar 15)
            , "Currency"
                => (currency <| dollar 5)
                === USD
            ]
        , describe "Franc"
            [ "Multiplication1"
                => ((single <| franc 5) $* 2)
                === (single <| franc 10)
            , "Multiplication2"
                => ((single <| franc 5) $* 3)
                === (single <| franc 15)
            , "Currency"
                => (currency <| franc 5)
                === CHF
            ]
        , describe "Equality"
            [ "Equality1"
                => dollar 10
                === dollar 10
            , "Equality2"
                => franc 10
                === franc 10
            , "Equality3"
                => dollar 1
                /== franc 1
            , "Equality4"
                => dollar 1
                /== dollar 2
            , "Equality5"
                => franc 1
                /== franc 2
            ]
        , describe "Simple Addition"
            [ "addition1"
                => let
                    five =
                        single <| dollar 5

                    sum =
                        five $+ five

                    reduced =
                        Bank.reduce bank USD sum
                   in
                    dollar 10
                        === reduced
            ]
        , describe "Reduce Sum"
            [ "addition1"
                => let
                    sum =
                        (single <| dollar 3) $+ (single <| dollar 4)

                    bank =
                        Bank.bank |> Bank.addRate (CHF ~> USD) 2

                    result =
                        Bank.reduce bank USD sum
                   in
                    dollar 7
                        === result
            ]
        , describe "Reduce Money"
            [ "reduce1"
                => let
                    single_ =
                        single <| dollar 1

                    bank =
                        Bank.bank |> Bank.addRate (CHF ~> USD) 2
                   in
                    Bank.reduce bank USD single_ === dollar 1
            ]
        , describe "Reduce Bank with Different Currency"
            [ "CHF ~> USD 2"
                => let
                    twoCHF =
                        single <| franc 2

                    bank =
                        Bank.bank |> Bank.addRate (CHF ~> USD) 2

                    result =
                        Bank.reduce bank USD twoCHF
                   in
                    result === dollar 1
            ]
        , describe "Identity rate"
            [ "USD ~> USD 1"
                => let
                    bank =
                        Bank.bank |> Bank.addRate (CHF ~> USD) 2
                   in
                    Bank.rate (USD ~> USD) bank
                        === 1
            ]
        , describe "Mixed Addition"
            [ "CHF ~> USD 2"
                => let
                    fiveBucks =
                        single <| dollar 5

                    tenFrancs =
                        single <| franc 10

                    bank =
                        Bank.bank |> Bank.addRate (CHF ~> USD) 2

                    result =
                        (fiveBucks $+ tenFrancs)
                            |> Bank.reduce bank USD
                   in
                    dollar 10 === result
            ]
        , describe "Sum Plus Money"
            [ "($5 + 10 CHF) + $5"
                => let
                    fiveBucks =
                        single <| dollar 5

                    tenFrancs =
                        single <| franc 10

                    bank =
                        Bank.bank |> Bank.addRate (CHF ~> USD) 2

                    result =
                        ((fiveBucks $+ tenFrancs) $+ fiveBucks)
                            |> Bank.reduce bank USD
                   in
                    dollar 15 === result
            ]
        , describe "Sum Times"
            [ "($5 + 10 CHF) * 2"
                => let
                    fiveBucks =
                        single <| dollar 5

                    tenFrancs =
                        single <| franc 10

                    bank =
                        Bank.bank |> Bank.addRate (CHF ~> USD) 2

                    result =
                        ((fiveBucks $+ tenFrancs) $* 2)
                            |> Bank.reduce bank USD
                   in
                    dollar 20 === result
            ]
        ]
```