QConTokyo 2015の講演スライドです。

1. Monadic
Programmingのススメ!
Functional Reactive Programming
へのアプローチ
2015年年4⽉月21⽇日
Everforth
浅海智晴

2. 自己紹介
• 1985年年富⼠士通(株)⼊入社
• UNIXワークステーション/サーバーのOS、分散基盤、Web基盤の開発
に従事
• 2001年年9⽉月に独⽴立立
• Java, XML, UMLを中⼼心に活動
• 2005年年4⽉月より2007年年3⽉月まで
• 稚内北北星学園⼤大学東京サテライト校教授
• 現在
• (株) 匠BusinessPlace 取締役チーフコンサルタント
• (株) Everforth 取締役CTO
• 著作
• 上流流⼯工程UMLモデリング(⽇日経BP)
• マインドマップではじめるモデリング講座(翔泳社)
http://www.apparel-cloud.com/
http://www.takumi-businessplace.co.jp/

3. ApparelCloud
データを一元化することで、多様な情報を、様々なメディア・デバイスを
通じて
消費者に届け、真のＣＲＭを実現する仕組み。
http://www.apparel-cloud.com/

4. ApparelCloud
クーポン
ブランドサイト
オンラインストア ブログ
ブランド
アプリ
ニュース ブログ ショップ
コンテンツ 集計・分析
ダッシュボード
複数メディア・コンテンツを⼀一元管理理し、クオリティの統⼀一と運⽤用コストの低減を実現。
コンテンツを⼆二重三重に登録する必要もなく、データ分析などの⼀一元化も可能。

5. ApparelCloud
システム構成
メディア
アプリケーション
管理
アプリケーション
WebConsole
Primefaces
(JSF)
WebAPI
play
PUSHSender
play
EmailSender
play
EverforthEngine
play
BatchEngine
Shell
Analysis
Engine
Finagle
Stream
Engine
Finagle
Scala
Java
その他Web
iOS
Android
Web
iOS
Android
Coordination
Engine
ServiceMix
Camel
開発中
開発中

6. Scala利用の文脈
Object-Functional
Analysis and Design
Object-Functional
Programming
Service Platform as-a-Service
要求
Cloud Service
プログラム カスタマイズ
モデル
Model
Summay Model
要求
Apparel Cloud
Service
Regular Model
WireFrame
(+ Usage)
Mindmap Model
API Usage List
Use case Model
Domain Model
プログラム
(開発)
プログラム
(自動生成)
カスタマイズ
Service Description
参考: Everforthのモデル体系
http://modegramming.blogspot.jp/2015/04/ofadeverforth.html

7. アジェンダ
背景
関数型プログラミング
Monadic Programming
Functional Reactive
Programming

8. キーワード
• Monad
• Monadic Programming
• Functional Reactive Programming

9. 背景

10. 新しい現実
• メニーコア、⼤大容量量メモリ、SSD
• 並列列プログラミング
ハードウェア
• クラウド・サービス、スマート・デバイス
• 故障、遅延
• ⼤大規模データ、⼤大規模演算
• ⾼高頻度度イベント、ストリーミング
• ⾮非同期、並列列、分散
• NoSQL、インメモリデータベース
• CQRS、Event Sourcing、Microservice
クラウド・プラットフォーム

11. The Reactive Manifest
• http://www.reactivemanifesto.org/
• ⽇日本語訳
• http://okapies.hateblo.jp/entry/2014/12/03/025921
• Responsive
• 応答性：すぐ応答する
• Resilient
• 耐故障性：回復復⼒力力に富む、⽴立立ち直りが早い
• Elastic
• 弾⼒力力性：伸縮⾃自在の
• Message Driven
• メッセージ駆動
• 関連: Reactive Streams
• http://www.reactive-streams.org/

12. Reactiveの実現
Service Cluster
CPU Core
Function
Service
Message
Message
Message
Function
Function
Function
Function
Function
Service
Service
Service
Service
Function
Reactive
Concurrent
Parallel
Distributed
Responsive
Resillience
Elasticity
Message Driven
Concurrent
Parallel
Distributed

13. Functional Reactive Programming
へのアプローチ
Object-Oriented Programming
並列処理アプリケーション
Actor
Object-Oriented Programming
Monadic Programming
Functional Programming
Object-Functional Programming
Functional Reactive Programming
並列処理アプリケーション

14. 関数型プログラミング

15. 関数型⾔言語の技術マップ
抽象代数学
数理論理学
直感主義命題論理＆
自然演繹
単純型付ラムダ計算
純粋関数型言語
命題
型クラス
群論
Hask圏
(プログラム圏)
永続データ構造
関数型言語
手続き型言語
代数的データ型
Curry-Haward対応
オブジェクト
指向言語
証明
述語論理
様相論理
圏論
直積 直和
不変
副作用なし
参照透過性
置換モデル
モノイド モナド
型
計算

16. Scala
Scala
OOP
(Java + α)
Functional
Programming
(Haskell – α)
モダン⽂文法
(e.g. Ruby)
DSL
(Scalable)
Java VM

17. 代数的構造デザインパターン
• 半群 (semigroup)
• モノイド (monoid)
• 群 (group)
結合律律 (associative law)
• 可換半群
• 可換モノイド
• 可換群(アーベル群)
可換律律 (commutative law)
• 環 (ring)
• 体 (field)
分配律律 (distributive law)
(a + b) + c = a + (b + c)
a + b = b + a
a * (b + c) = a * b + a * c

18. 圏論論デザインパターン
圏 (category)
• Hask圏 (Scala圏?)
• クライスリ圏
(kleisli category)
射 (arrow,
morphism)
関⼿手
(functor)
Applicative
functor
モナド
(monad)

19. 基本概念
• 再帰 (recursion)
• ⾼高階関数 (high-order function)
• 不不変データ (immutable data)
• 遅延評価 (lazy evaluation)
• 参照透過性 (referential transparency)
• (項)書換えモデル (substitution model)
• 等式推論論 (equational reasoning)
• 代数的データ型 (algebraic data type)
• 直積, 直和 (direct product, direct sum)
• 永続データ構造 (persistent data structure)
• エフェクト (effect)
• 型クラス (type class)
• モナド (monad)
Object-Oriented Programming
Monadic Programming
Functional Programming
Object-Functional Programming
Functional Reactive Programming
並列処理アプリケーション

20. Monadic Programming

21. モナド
• 計算機科学におけるモナド（Monads）とは、計算機科学者の
Eugenio Moggiによって提案されたモジュール性を持たせた
表⽰示的意味論論の枠組みを⾔言う。プログラムとはクライスリ圏
の射である（a program is an arrow of a Kleisli category）、
という要請から合成規則としてクライスリトリプル(Kleisli
triple)というモナドと等価なものが⽤用いられる。(Wikipedia)
• In functional programming, a monad is a structure that
represents computations defined as sequences of steps: a
type with a monad structure defines what it means to
chain operations, or nest functions of that type together.
This allows the programmer to build pipelines that
process data in steps, in which each action is decorated
with additional processing rules provided by the monad.
(Wikipedia)
• ⾮非常に難しい概念念
• 使うのは(慣れれば)それほど難しくない
• モダンな関数型プログラミングの中核概念念

22. 再利利⽤用メカニズムの⽐比較
アプリ
手続き型
サブルーチン
アプリ
オブジェクト指向
フレームワーク
オブジェクト
アプリ
関数型(Monadic)
型クラス
関数
A→B
Functor
Monad
A→M[B]

23. モナドの⽤用途
• コンテナ
• コレクション(List, Vector)
• 成功失敗⽂文脈(Option)
• インタープリタ
• Freeモナド, Operationalモナド
• DI(Dependency Injection)
• Readerモナド
• 状態機械
• Stateモナド
• Processモナド
• 問合せ
• Slick
• Spark RDD(Resilient Distributed Dataset)

24. モナドの種類(⾮非公式分類)
• コンテナ型
• 値を格納
• コンビネータを実⾏行行すると即時に評価が⾏行行われる
• インタープリタ型
• 関数を格納
• コンビネータを実⾏行行すると関数を合成したモナド(インター
プリタ)が返ってくる
• 純粋関数型のセマンティクス
• runメソッドなどでインタープリタを実⾏行行する
• 外部⼊入出⼒力力など⾮非純粋関数型処理理はこちらで⾏行行う
• 外部⼊入出⼒力力など副作⽤用を伴う処理理はインタープリタ型モナ
ドで対応
• IOモナド

25. コンテナ型モナド
• Option
• 成功/失敗状態を扱うモナド
• List
• データ列列を扱うモナド(シーケンシャルアクセス向け)
• Vector
• データ列列を扱うモナド(ランダムアクセス対応)
• Stream
• 遅延評価によるデータ列列を扱うモナド
• Try
• 例例外発⽣生状態を扱うモナド
• Future
• 並列列実⾏行行を扱うモナド

26. インタープリタ型モナド
• Stateモナド
• 状態を表現するモナド
• IOモナド
• 外部⼊入出⼒力力を扱うモナド
• Processモナド
• 状態機械を表現するモナド
• ストリーム処理理を実現

27. Monadic Programmingの
⾮非公式定義
• ⼀一義的にはモナドを活⽤用したプログラミング
• 本セッションでは以下の型クラス(Scalaz)を活⽤用したプ
ログラミングまでスコープを広げています
• Functor
• Applicative Functor
• Monad
• MonadはApplicative FunctorおよびFunctorでもある
• Monadを⽬目的によってApplicative Functorまたは
Functorとして使うことも多い

28. Functor, Applicative Functor, Monad
⾮非公式理理解
Functor
Applicative Functor
Monad
F.point(x).map(f).map(g).map(h)
(A.point(x) |@| A.point(y) |@| A.point(z))(i(_, _, _))
f g h
f
f
g
g
h
h
i
x
x
y
z
M.point(x).flatMap(f).flatMap(g).flatMap(h)
for {
a <- M.point(x)
b <- f(a)
c <- g(b)
d <- h(c)
} yield d
^^(A.point(x), A.point(y), A.point(z))(i(_, _, _))
x
Option(1).map(f).map(g).map(h)
(Option(1) |@| Option(2) |@| Option(3))(i(_, _, _))
Option(1).flatMap(f).flatMap(g).flatMap(h)

29. 型クラス&Monadの使い所
型クラス
&
Monad
クラス
予約 販売 顧客管理 分析
ロギング
並列処理
故障耐性
機能要求
非機能要求
セキュリティ
トランザクション
分散処理
例外処理
OOPではAOPやDIによっ
て実現してきた機能要求
と⾮非機能要求の分離離を細
粒粒度度、型安全に実現

30. Scalaz
• https://github.com/scalaz/scalaz
• キャッチフレーズ
• 昔: Scalaz: Type Classes and Pure Functional Data
Structures for Scala
• 今: An extension to the core Scala library for functional
programming. http://typelevel.org
• 最新の関数型プログラミングを可能にする機能群を
Scala向けに⽤用意
• 型クラス
• 純粋関数型データ構造
• Haskellで実績のある機能群をScalaで実現

31. Monadicプログラミングの効⽤用
def validate(name: String, age: Int): ValidationNEL[Throwable, (String,
Int)] = {!
val a = validateName(name) !
val b = validateAge(age) !
if (a.isSuccess && b.isSuccess) { !
val a1 = a.asInstanceOf[Success[NonEmptyList[Throwable], String]].a !
val b1 = b.asInstanceOf[Success[NonEmptyList[Throwable], Int]].a !
Success((a1, b1)) !
} else if (a.isSuccess) { !
b.asInstanceOf[Failure[NonEmptyList[Throwable], (String, Int)]] !
} else if (b.isSuccess) { !
a.asInstanceOf[Failure[NonEmptyList[Throwable], (String, Int)]] !
} else { !
val a1 = a.asInstanceOf[Failure[NonEmptyList[Throwable], String]].e !
val b1 = b.asInstanceOf[Failure[NonEmptyList[Throwable], Int]].e !
Failure(a1 |+| b1) !
} !
}!
Java⾵風

32. def validate(name: String, age: Int):
ValidationNEL[Throwable, (String, Int)] = { !
validateName(name) match { !
case Success(a) => validateAge(age) match { !
case Success(b) => Success((a, b)) !
case Failure(e) => Failure(e) !
} !
case Failure(e1) => validateAge(age) match { !
case Success(b) => Failure(e1) !
case Failure(e2) => Failure(e1 |+| e2) !
} !
} !
} !
def validate(name: String, age: Int):
ValidationNEL[Throwable, (String, Int)] = { !
(validateName(name) ⊛ validateAge(age))((_, _)) !
}!
Scala (関数型プログラミング)
Scalaz (Monadicプログラミング)
参考: Scala Tips / Validation (10) - applicative
http://modegramming.blogspot.jp/2012/04/scala-tips-validation-10-applicative.html

33. プログラミング例例
• 3つの関数を並⾏行行動作させ、それぞれの実⾏行行結果を引数
にした関数を実⾏行行して最終結果を計算
• calcString(x: Int): String
• calcInt(x: Int): Int
• calcFloat(x: Int): Float
• finalCalc(x: String, y: Int, z: Float): String
• 並列列処理理はFutureモナドで実現

34. 準備
object Util {
import java.net.URL
import scala.concurrent.duration._
import scalax.io.JavaConverters._
def go[T](label: String)(body: => T) {
val ts = System.currentTimeMillis
val r = body
val elapse = System.currentTimeMillis - ts
println(s"$label ($elapse ms): $r")
}
def getPageLength(url: String): Int = {
new URL(url).asInput.bytes.size
}
Scala流流のDSLの例例
go (“bigCalc”) {
val r = bigCalc(1000)
Await.result(r, 1.minute)
}

35. def calcString(n: Int): String = {
Thread.sleep(n)
n.toString
}
def calcInt(n: Int): Int = {
Thread.sleep(n)
n
}
def calcFloat(n: Int): Float = {
Thread.sleep(n)
n.toFloat
}
def finalCalc(s: String, i: Int, f: Float): String = {
s"$s-$i-$f"
}
}

36. 基本形
def bigCalc(n: Int): String = {
val a = calcString(n)
val b = calcInt(n)
val c = calcFloat(n)
finalCalc(a, b, c)
}
bigCalc (3003 ms): 1000-1000-1000.0
> go(“bigCalc”)(bigCalc(1000))

37. Optionモナド
def bigCalcO(n: Int): Option[String] = {
for {
a <- Option(calcString(n))
b <- Option(calcInt(n))
c <- Option(calcFloat(n))
} yield finalCalc(a, b, c)
}
Monad
f g h
x
bigCalcO (3005 ms): 1000-1000-1000.0
> go(“bigCalcO”)(bigCalcO(1000))
for式(for ... yield)でmonadicな
パイプラインを構築
参考: Scala Tips/Option Index
http://modegramming.blogspot.jp/2012/02/scala-tips-option-index.html

38. Optionモナド
Monadic関数版
def calcStringO(n: Int): Option[String] = {
Option(calcString(n))
}
def calcIntO(n: Int): Option[Int] = {
Option(calcInt(n))
}
def calcFloatO(n: Int): Option[Float] = {
Option(calcFloat(n))
} def bigCalcO2(n: Int): Option[String] = {
for {
a <- calcStringO(n)
b <- calcIntO(n)
c <- calcFloatO(n)
} yield finalCalc(a, b, c)
}
Monad
f g h
x
bigCalcO2 (3005 ms): 1000-1000-1000.0
> go(“bigCalcO2”)(Await.result(bigCalcO2(1000), 1.minute))
A->M[B]
モナディック関数
for式にモナディック
関数を組み合わせるの
がイディオム

39. Futureモナド
val executorService = Executors.newFixedThreadPool(10)
implicit val executionContext = ExecutionContext.fromExecutorService(executorService)
def bigCalcP(n: Int): Future[String] = {
for {
a <- Future(calcString(n))
b <- Future(calcInt(n))
c <- Future(calcFloat(n))
} yield finalCalc(a, b, c)
}
Monad
f g h
x
bigCalcP (3017 ms): 1000-1000-1000.0
> go(“bigCalcP”)(Await.result(bigCalcP(1000), 1.minute))

40. Futureモナド
改良良版
def bigCalcP2(n: Int): Future[String] = {
val fa = Future(calcString(n))
val fb = Future(calcInt(n))
val fc = Future(calcFloat(n))
for {
a <- fa
b <- fb
c <- fc
} yield finalCalc(a, b, c)
}
Monad
f g h
x
bigCalcP2 (1005 ms): 1000-1000-1000.0
> go(“bigCalcP2”)(Await.result(bigCalcP2(1000), 1.minute))
モナディック処理理の前
にFutuerを開始

41. Future Applicative
def bigCalcP3(n: Int): Future[String] = {
import scalaz._, Scalaz._
(Future(calcString(n)) |@| Future(calcInt(n)) |@| Future(calcFloat(n)))(finalCalc)
}
def bigCalcP31(n: Int): Future[String] = {
import scalaz._, Scalaz._
^^(Future(calcString(n)), Future(calcInt(n)), Future(calcFloat(n)))(finalCalc)
}
Applicative Functor
f
g
h
i
x
y
z
bigCalcP3 (1162 ms): 1000-1000-1000.0
bigCalcP31 (1004 ms): 1000-1000-1000.0
>go(“bigCalcP3”)(Await.result(bigCalcP3(1000), 1.minute))
> go(“bigCalcP31”)(Await.result(bigCalcP31(1000), 1.minute))
Applicativeを使うと綺
麗麗に記述できる

42. Future Applicative
改良良版
def bigCalcA[A[_]](n: Int)(implicit C: Applicative[A]): A[String] = {
^^(
C.point(calcString(n)),
C.point(calcInt(n)),
C.point(calcFloat(n))
)(finalCalc)
}
Applicative Functor
f
g
h
i
x
y
z
bigCalcAF (1003 ms): 1000-1000-1000.0
bigCalcAI (3001 ms): 1000-1000-1000.0
>go(“bigCalcAF”)(Await.result(bigCalcA[Future](1000), 1.minute))
> go(“bigCalcAI”)(bigCalcA[Id](1000), 1.minute))
型クラスを利利⽤用し任意
のApplicativeを使える
ように汎⽤用化
Applicativeのpointメソッド
はvirtual constructor
ロジック(機能要求)からApplicativeとして
パラメタ化した⾮非機能要求を分離離

43. Functional Reactive
Programming

44. Reactiveの実現(再掲)
Service Cluster
CPU Core
Function
Service
Message
Message
Message
Function
Function
Function
Function
Function
Service
Service
Service
Service
Function
Reactive
Concurrent
Parallel
Distributed
Responsive
Resillience
Elasticity
Message Driven
Concurrent
Parallel
Distributed

45. Functional Reactive
Programmingで実現したいこと
• 関数型プログラミングのメリットを享受
• 参照透過性
• 関数による部品化/部品の組⽴立立て
• パイプラインのセマンティクス
• イベント駆動処理理
• Callback hellの排除
• ストリーム処理理
• リソース管理理
• フロー制御
• ⼤大規模データ処理理
• リソース管理理
• 省省メモリ

46. Functional Reactive Programming
の候補
• RxJava – Scala
• https://github.com/ReactiveX/RxJava
• Observableモナド
• Scalaz Stream
• https://github.com/scalaz/scalaz-stream
• Processモナド
• Akka Stream
• https://typesafe.com/blog/typesafe-announces-akka-
streams
• Akka actor

47. scalaz stream
• ScalazベースのStreaming I/Oライブラリ
• https://github.com/scalaz/scalaz-stream
• ⽤用途
• ⼊入出⼒力力処理理フレームワーク
• パイプライン
• 部品化、部品合成によるロジック記述
• ⼤大規模データ⼀一括処理理
• ストリーム処理理
• Processモナド
• 参照透過性：副作⽤用なし
• 部品化：パイプラインによる関数の合成
• リソースの獲得・解放
• フロー制御
• 状態機械

48. Processモナド
既存部品 アプリケーション・ロジック
リソース管理
トランザクション管理
フロー制御
Function Function
Process
Monad
Process
Monad
Channel Sink
Channel Sink
Process Monad

49. プログラミング例例
• パイプラインを流流れてくるデータを以下のルールでパ
ケット化
• 3つで⼀一つのパケットにする
• パケットにシーケンス番号をつける
• “start”データの前のパケットにエンドマークをつける
• 上記アルゴリズムを実現した部品を⼤大規模データ処理理と
ストリーミング処理理の両⽅方に適⽤用する
参考: [scalaz-stream] シーケンス番号とエンドマーク
http://modegramming.blogspot.jp/2015/03/scalaz-stream.html

50. 準備
case class Packet(seqno: Int, end: Boolean, content: String)
def sink: Sink[Task, Packet] = {
io.channel((a: Packet) => Task.delay(println(a)))
}
参考: [scalaz-stream] ストリーミングで状態機械
http://modegramming.blogspot.jp/2015/04/scalaz-stream.html
参考: [scalaz-stream] Scala的状態機械/OOP編
http://modegramming.blogspot.jp/2015/03/scalaoop.html
参考: [scalaz-stream] Scala的状態機械/FP編
http://modegramming.blogspot.jp/2015/03/scalafp.html

51. アプリケーション・ロジック
def buildTextToPacket[M[_]: Monad](source: Process[M, String]):
Process[M, Packet] = {
source.
chunk(3). // 3個ずつチャンク化
pipe(zipWithNext). // 次のパケットを同時に取得
pipe(zipWithIndex). // インデックを採番
map(toPacket)
}
def toPacket(x: ((Vector[String], Option[Vector[String]]), Int)):
Packet = {
val ((current, next), index) = x
val content = current.mkString("-")
val isend = next.cata(_.headOption === Some("start"), true)
Packet(index + 1, isend, content)
}
既存部品とアプリケーションロ
ジックを組合せてパイプライン
を構築
以下のロジックを実現
- 3つで⼀一つのパケットにする
- パケットにシーケンス番号をつける
- “start”データの前のパケットにエン
ドマークをつける

52. ⼤大規模データ処理理
val source = io.linesR("data.txt")
val pipeline = buildTextToPacket(source).to(sink)
pipeline.run.run
Packet(1,false,1-2-3)
Packet(2,true,4-5-6)
Packet(3,true,start-8-9)
1
2
3
4
5
6
start
8
9
汎⽤用部品を⼤大規模データ処理理に
適⽤用
リソース管理
フロー制御
chunk
zipWith
Next
zipWith
Index
toPacketChannel Sink
Process Monad

53. EventProcessor
val queue = EventProcessor.q
val source = Vector("1", "2", "3", "4", "5", "6", "start", "8", "9")
source foreach { x =>
queue.enqueueOne(x).run
Thread.sleep(2000)
}
object EventProcessor {
val q = async.unboundedQueue[String]
val eventStream: Process[Task, String] = q.dequeue
}
参考: [scalaz-stream] ストリーミングで状態機械
http://modegramming.blogspot.jp/2015/04/scalaz-stream.html

54. ストリーム処理理
val source = EventProcessor.eventStream
val pipeline = buildTextToPacket(source).to(sink)
pipeline.run.run
Packet(1,false,1-2-3)
Packet(2,true,4-5-6)
汎⽤用ロジックをストリーミング
処理理に適⽤用
リソース管理
フロー制御
chunk
zipWith
Next
zipWith
Index
toPacketChannel Sink
Process Monad

55. まとめ
• モナド
• マイクロ・フレームワーク
• DSL(Domain Specific Language)
• Monadic Programming
• モナドベースのパイプラインプログラミング
• 関数による部品化、部品の組み⽴立立て
• Functional Reactive Programming
• Futureモナド
• Processモナド

56. END