scalamatsuri.txt

| \gReducing Boilerplate and Combining Effects: 
| \gA Monad Transformer Example

| Scala Matsuri - Feb 25th, 2017


| Connie Chen - \b@coni

/
ボイラープレートの削減と作用の組み合わせ: 例で見るモナド変換子
---
| \gHello

* @coni
* Data Platform team @ Twilio
@ http://github.com/conniec

---
| \gWhat are Monad transformers?

* Monad transformers allow different monads to compose
* Combine effects of monads to great a \bSUPER MONAD
* Eg. Future[Option], Future[Either], ReaderT[Option]
* In this example, we will use the Cats library...

/
モナド変換子は異なるモナドの合成を可能とする

---

\g Future[Either[A, B]] turns into EitherT[Future, A, B]

\g Future[Option[A]] turns into OptionT[Future, A]

---

\g Example: Making coffee!

--
\b Step 1. Grind the beans
 ステップ 1. コーヒー豆を挽く

--
```
import scala.concurrent.Future
import cats.data.OptionT
import cats.implicits._
import scala.concurrent.ExecutionContext.Implicits.global

case class Beans(fresh: Boolean = true)
case class Grounds()
class GroundBeansException(s: String) extends Exception(s: String)
```
--

```
def grindFreshBeans(beans: Beans, clumsy: Boolean = false): Future[Option[Grounds]] = {
  if (clumsy) {
    Future.failed(new GroundBeansException("We are bad at grinding"))
  } else if (beans.fresh) {
    Future.successful(Option(Grounds()))
  } else {
    Future.successful(None)
  }
}
```
--

Three different kind of results
* Value found 
* Value not found 
* Future failed 

/
値が見つかる、値が見つからない、Futureの失敗という 3種類の結果

---
\b Step 2. Boil hot water
 ステップ 2. お湯を沸かす

--

```
case class Kettle(filled: Boolean = true)
case class Water()
case class Coffee(delicious: Boolean)
class HotWaterException(s: String) extends Exception(s: String)

--
def getHotWater(kettle: Kettle, clumsy: Boolean = false): Future[Option[Water]] = {
  if (clumsy) {
    Future.failed(new HotWaterException("Ouch spilled that water!"))
  } else if (kettle.filled) {
    Future.successful(Option(Water()))
  } else {
    Future.successful(None)
  }
}
```

---
\b Step 3. Combine water and coffee (it's a pourover)
  ステップ 2. お湯とコーヒー豆を組み合わせる (ハンドドリップです)
--

```
def makingCoffee(grounds: Grounds, water: Water): Future[Coffee] = {
  println(s"Making coffee with... $grounds and $water")
  Future.successful(Coffee(delicious=true))
}
```

---

\g Without Monad transformers, success scenario

```

// Step 1. def grindFreshBeans(beans: Beans, clumsy: Boolean = false): Future[Option[Grounds]]

// Step 2. def getHotWater(kettle: Kettle, clumsy: Boolean = false): Future[Option[Water]]

// Step 3. def makingCoffee(grounds: Grounds, water: Water): Future[Coffee]


val coffeeFut = for {
  beans <- grindFreshBeans(Beans(fresh=true))
  hotWater <- getHotWater(Kettle(filled=true))
  beansResult = beans.getOrElse(throw new Exception("Beans result errored. "))
  waterResult = hotWater.getOrElse(throw new Exception("Water result errored. "))
  result <- makingCoffee(beansResult, waterResult)
} yield Option(result)

coffeeFut.onSuccess {
  case Some(s) => println(s"SUCCESS: $s")
  case None => println("No coffee found?")
}

coffeeFut.onFailure {
  case x => println(s"FAIL: $x")
}
```

/
モナド変換子を使わない場合の成功シナリオ

---
\g With Monad transformers, success scenario

```
val coffeeFutMonadT = for {
  beans <- OptionT(grindFreshBeans(Beans(fresh=true)))
  hotWater <- OptionT(getHotWater(Kettle(filled=true)))
  result <- OptionT.liftF(makingCoffee(beans, hotWater))
} yield result

coffeeFutMonadT.value.onSuccess {
  case Some(s) => println(s"SUCCESS: $s")
  case None => println("No coffee found?")
}

coffeeFutMonadT.value.onFailure {
  case x => println(s"FAIL: $x")
}
```

/
モナド変換子を使った場合の成功シナリオ

---

\g Helper functions on OptionT

\b `fromOption` gives you an OptionT from Option
Internally, it is wrapping your option in a Future.successful()


\b `liftF` gives you an OptionT from Future
Internally, it is mapping on your Future and wrapping it in a Some()

/
OptionT のヘルパー関数

---

\g Without Monad transformers, failure scenario

```
val coffeeFut3 = for {
  beans <- grindFreshBeans(Beans(fresh=false))
  hotWater <- getHotWater(Kettle(filled=true))
  beansResult = beans.getOrElse(throw new Exception("Beans result errored. "))
  waterResult = hotWater.getOrElse(throw new Exception("Water result errored. "))
  result <- makingCoffee(beansResult, waterResult)
} yield Option(result)

coffeeFut3.onSuccess {
  case Some(s) => println(s"SUCCESS: $s")
  case None => println("No coffee found?")
}

coffeeFut3.onFailure {
  case x => println(s"FAIL: $x")
}
```

/
モナド変換子を使わない場合の失敗シナリオ

---
\g With Monad transformers, failure scenario

```
val coffeeFut2 = for {
  beans <- OptionT(grindFreshBeans(Beans(fresh=false)))
  hotWater <- OptionT(getHotWater(Kettle(filled=true)))
  result <- OptionT.liftF(makingCoffee(beans, hotWater))
} yield result

coffeeFut2.value.onSuccess {
  case Some(s) => println(s"SUCCESS: $s")
  case None => println("No coffee found?")
}

coffeeFut2.value.onFailure {
  case x => println(s"FAIL: $x")
}
```

/
モナド変換子を使った場合の失敗シナリオ

---

\g With Monad transformers, failure scenario with exception

```
val coffeeFut2 = for {
  beans <- OptionT(grindFreshBeans(Beans(fresh=true)))
  hotWater <- OptionT(getHotWater(Kettle(filled=true), clumsy=true))
  result <- OptionT.liftF(makingCoffee(beans, hotWater))
} yield result

coffeeFut2.value.onSuccess {
  case Some(s) => println(s"SUCCESS: $s")
  case None => println("No coffee found?")
}

coffeeFut2.value.onFailure {
  case x => println(s"FAIL: $x")
}
```

/
モナド変換子を使った場合の例外を投げる失敗シナリオ

---

\g What did we learn?

* Use monad transformers to short circut your chained monads
  連鎖したモナドをショートさせるのにモナド変換子を使う

--
* Instead of unwrapping layers of monads, monad transformers results in a new monad to flatMap with
  入れ子になったモナドを分解する代わりに、モナド変換子は flatMap 可能な新しいモナドを作る

--
* Reduce layers of x.map( y => y.map ( ... )) to just x.(map ( y => ...))
  x.map ( y => y.map ( ... ) ) と入れ子になった呼び出しも一つの map で済むようになる

---
\g What's next?

* Many other types of monad transformers: ReaderT, WriterT, EitherT, StateT
* Since monad transformers give you a monad as a result-- you can stack them too! 

/
OptionT 以外にも多くのモナド変換子がある。複数積み上げることも可能。

---
| \rThank you


| Connie Chen - \b@coni
| Twilio

| We're hiring!