Functional and Algebraic Domain Modeling

Functional and Algebraic Domain
Modeling
Debasish Ghosh
@debasishg
関数型、代数的なドメイン・モデリングの方法
Saturday, 30 January 16

Domain Modeling
ドメイン・モデリング

Domain Modeling(Functional)
関数型なドメイン・モデリング

What is a domain model ?
A domain model in problem solving and software engineering is a
conceptual model of all the topics related to a speciﬁc problem. It
describes the various entities, their attributes, roles, and
relationships, plus the constraints that govern the problem domain.
It does not describe the solutions to the problem.
Wikipedia (http://en.wikipedia.org/wiki/Domain_model)
特定の問題領域に関する概念モデル
エンティティ／関連／制約などを記述

The Functional Lens ..
“domain API evolution through algebraic
composition”
関数型レンズ
代数的合成を通じたドメイン API の進化

「サーバを関数として考える」

Twitter 社でのサーバソフトウェアの構成は fp と同じ理念
（不変性、関数の合成、副作用の分離）に基づく

Your domain model is a
function
ドメインモデルは関数である

function
ドメインモデルは関数（...であって欲しい）

collection of functions
ドメインモデルは関数の集合である

collection of functions
some simpler models are ..
具体例で考えると...

https://msdn.microsoft.com/en-us/library/jj591560.aspx
カンファレンス管理システム

A Bounded Context
• has a consistent vocabulary
• a set of domain behaviors modeled as
functions on domain objects
implemented as types
• related behaviors grouped as modules
境界づけられたコンテキストは、統一された語彙を持つ
ドメインの振る舞いは関数、オブジェクトは型として実装するSaturday, 30 January 16

Domain Model = ∪(i) Bounded Context(i)

Bounded Context = { f(x) | p(x) ∈ Domain Rules }

• domain function
• on an object of type x
• composes with other functions
• closed under composition
• business rules
f はドメイン関数で、他の関数と合成できる
p はビジネスルール

• Functions / Morphisms
• Types / Sets
• Composition
• Rules / Laws
関数と射、型と集合、合成、ルールと法則

• Functions / Morphisms
• Types / Sets
• Composition
• Rules / Laws
algebra
要は代数ということ

Domain Model Algebra
ドメインモデルの代数

(algebra of types, functions & laws)
型と関数と法則の代数

explicit
• types
• type constraints
• expression in terms of other generic algebra
これを明示的にすると、型、型の制約、他の代数を用いた表現

explicit veriﬁable
• types
• expr in terms of other generic algebra
• more constraints if you have DT
• algebraic property based testing
確認可能なのは型制約、代数的プロパティーベースのテスト
依存型があればより強い制約を検証できる

Problem Domain
問題ドメインの例として証券取引口座を考察する

Bank
Account
Trade
Customer
...
...
...
Problem Domain
...
entities
エンティティとなるのは、口座、顧客、取引、銀行

Bank
Account
Trade
Customer
...
...
...
do trade
process
execution
place
order
Problem Domain
...
entities
behaviors
振る舞いとなるのは、注文、取引、執行処理

Bank
Account
Trade
Customer
...
...
...
do trade
process
execution
place
order
Problem Domain
...
market
regulations
tax laws
brokerage
commission
rates
...
entities
behaviors
laws
法則となるのは株式市場規則、税法、手数料

do trade
process
execution
place
order
Solution Domain
...
behaviors
Functions
(Type => Type)
ソリューションドメインでは、振る舞いは関数 (型型)

Bank
Account
Trade
Customer
...
...
...
do trade
process
execution
place
order
Solution Domain
...
entities
behaviors
functions
(Type => Type)
algebraic data type
エンティティは代数的データ型

Bank
Account
Trade
Customer
...
...
...
do trade
process
execution
place
order
Solution Domain
...
market
regulations
tax laws
brokerage
commission
rates
...
entities
behaviors
laws
functions
(Type => Type)
algebraic data type business rules / invariants
法則はビジネス・ルールもしくは不変関係

Bank
Account
Trade
Customer
...
...
...
do trade
process
execution
place
order
Solution Domain
...
market
regulations
tax laws
brokerage
commission
rates
...
entities
behaviors
laws
functions
(Type => Type)
Monoid
Monad
...
モノイドやモナドといった型クラス

Bank
Account
Trade
Customer
...
...
...
do trade
process
execution
place
order
Solution Domain
...
market
regulations
tax laws
brokerage
commission
rates
...
entities
behaviors
laws
functions
(Type => Type)
Monoid
Monad
...
これを全部やるとドメイン代数
Domain Algebra

• domain function
• on an object of type x
• composes with other functions
• closed under composition
• business rules
Domain Algebra
Domain Algebra
「境界づけられたコンテキスト」はドメイン代数のこと

Client places order
- ﬂexible format
1
クライアントが注文を出す
フォーマットは様々

Client places order
- ﬂexible format
Transform to internal domain
model entity and place for execution
1 2
内部でのドメインモデルエンティティに変換して、
実際に注文を出す

Client places order
- ﬂexible format
Transform to internal domain
model entity and place for execution
Trade & Allocate to
client accounts
1 2
3
取引し、結果をクライアントのアカウントに紐づける

def clientOrders: ClientOrderSheet => List[Order]
def execute: Market => Account => Order => List[Execution]
def allocate: List[Account] => Execution => List[Trade]

def execute[Account <: BrokerAccount]: Market => Account
=> Order => List[Execution]
def allocate[Account <: TradingAccount]: List[Account]
=> Execution => List[Trade]

Types out of thin air No implementation till now
Type names resonate domain language
どこからともなく降ってきた型。今の所実装の話はゼロ。
型の名前はドメイン言語を反映

•Types (domain entities)
• Functions operating on types (domain behaviors)
• Laws (business rules)
型 (エンティティ)、関数 (ドメインの振る舞い)、
法則 (ビジネス・ルール)

•Types (domain entities)
• Functions operating on types (domain behaviors)
• Laws (business rules)
Algebra of the API
これが API の代数

trait Trading[Account, Trade, ClientOrderSheet, Order,
Execution, Market] {
def tradeGeneration(market: Market, broker: Account,
clientAccounts: List[Account]) = ???
}
parameterized on typesmodule
モジュール、型パラメータ

Algebraic Design
• The algebra is the binding contract of the
API
• Implementation is NOT part of the algebra
• An algebra can have multiple interpreters
(aka implementations)
• One of the core principles of functional
programming is to decouple the algebra from
the interpreter
代数的設計手法: 代数は API が準拠する制約
実装は代数に含まれず、実装からは分離されている

let’s do some algebra ..
代数の練習

def execute(m: Market, broker: Account): Order => List[Execution]
def allocate(accounts: List[Account]): Execution => List[Trade]
let’s do some algebra ..

def f: A => List[B]
def g: B => List[C]
def h: C => List[D]
.. a problem of composition ..
これは ... 合成の問題だ

.. a problem of
composition with effects ..
def f: A => List[B]
def g: B => List[C]
def h: C => List[D]
これは ... 作用付きの合成の問題だ

def f[M: Monad]: A => M[B]
def g[M: Monad]: B => M[C]
def h[M: Monad]: C => M[D]
.. a problem of composition with
effects that can be generalized ..
これはモナドとして抽象化できる作用付きの合成の問題だ

case class Kleisli[M[_], A, B](run: A => M[B]) {
def andThen[C](f: B => M[C])
(implicit M: Monad[M]): Kleisli[M, A, C] =
Kleisli((a: A) => M.flatMap(run(a))(f))
}
.. function composition with
Effects ..
It’s a Kleisli !
作用付きの関数の合成と言えば、Kleisli！

def clientOrders: Kleisli[List, ClientOrderSheet, Order]
def execute(m: Market, b: Account): Kleisli[List, Order, Execution]
def allocate(acts: List[Account]): Kleisli[List, Execution, Trade]
Follow the types
Effects ..
def execute(m: Market, broker: Account): Order => List[Execution]
def allocate(accounts: List[Account]): Execution => List[Trade]
型に任せて考える

Domain algebra composed with the
categorical algebra of a Kleisli Arrow
Effects ..
Klieisli 射によって合成されたドメイン代数

.. that implements the semantics of our
domain algebraically ..
Effects ..
ドメインの意味論を代数的に実装する作用付きの関数の合成

def tradeGeneration(
market: Market,
broker: Account,
clientAccounts: List[Account]) = {
clientOrders andThen
execute(market, broker) andThen
allocate(clientAccounts)
}
Implementation follows the speciﬁcation
.. the complete trade generation
logic ..
実装は仕様に従う

def tradeGeneration(
market: Market,
broker: Account,
}
Implementation follows the speciﬁcation
and we get the Ubiquitous Language for
free :-)
.. the complete trade generation
logic ..
実装は仕様に従い、
そこからユビキタス言語を読み取ることが出来る

algebraic & functional
• Just Pure Functions. Lower cognitive load -
don’t have to think of the classes & data
members where behaviors will reside
• Compositional. Algebras compose - we
deﬁned the algebras of our domain APIs in
terms of existing, time tested algebras of
Kleislis and Monads
代数的かつ関数型の設計は、
純粋関数のみで構成する、合成可能な設計

.. our algebra still doesn’t handle errors
that may occur within our domain
behaviors ..
Effects ..
そう言えばエラー処理どうする?

more algebra,
more types
代数と型、大盛りで追加！

return type constructor
List は戻り値の型コンストラクタ

return type constructor
What happens in case the operation fails ?
演算が失敗したらどうなる?

Error handling as an
Effect
• pure and functional
• with an explicit and published algebra
• stackable with existing effects
モナド作用としてのエラー処理
純粋で関数型に。明示的な代数。既存の作用と積み上げ可能。

.. stacking of effects ..
M[List[_]]
作用の積み上げ

M[List[_]]: M is a Monad
List をエラー処理のためのモナド M で囲む

type Response[A] = String / Option[A]
val count: Response[Int] = some(10).right
for {
maybeCount <- count
} yield {
for {
c <- maybeCount
// use c
} yield c
}
Monad Transformers
モナド変換子

for {
maybeCount <- count
} yield {
for {
c <- maybeCount
// use c
} yield c
}
type Error[A] = String / A
type Response[A] = OptionT[Error, A]
val count: Response[Int] = 10.point[Response]
for{
c <- count
// use c : c is an Int here
} yield (())
Monad Transformers

for {
maybeCount <- count
} yield {
for {
c <- maybeCount
// use c
} yield c
}
type Error[A] = String / A
type Response[A] = OptionT[Error, A]
val count: Response[Int] = 10.point[Response]
for{
c <- count
// use c : c is an Int here
} yield (())
Monad Transformers
richer algebra
代数として扱いやすいのは OptionT を使った方

Monad Transformers
• collapses the stack and gives us a single
monad to deal with
• order of stacking is important though
モナド変換子は積み上げたモナドを一つに潰すことができる
ただし積み上げる順番は大切

case class ListT[M[_], A] (run: M[List[A]]) { //..
ListT モナド変換子を使う

これは代数にとって小さな一歩だが、
ドメインモデルにとっては巨大な跳躍である

type StringOr[A] = String / A
type Valid[A] = ListT[StringOr, A]

def clientOrders: Kleisli[Valid, ClientOrderSheet, Order]
def execute(m: Market, b: Account): Kleisli[Valid, Order, Execution]
def allocate(acts: List[Account]): Kleisli[Valid, Execution, Trade]

def clientOrders: Kleisli[Valid, ClientOrderSheet, Order]
def execute(m: Market, b: Account): Kleisli[Valid, Order, Execution]
def allocate(acts: List[Account]): Kleisli[Valid, Execution, Trade]
.. a small change in algebra, a huge step
for our domain model ..

def execute(market: Market, brokerAccount: Account) =
kleisli[List, Order, Execution] { order =>
order.items.map { item =>
Execution(brokerAccount, market, ..)
}
}

private def makeExecution(brokerAccount: Account,
item: LineItem, market: Market): String / Execution = //..
def execute(market: Market, brokerAccount: Account) =
kleisli[Valid, Order, Execution] { order =>
listT[StringOr](
order.items.map { item =>
makeExecution(brokerAccount, market, ..)
}.sequenceU
)
}

List
(aggregates)
Algebra of types
型の代数
集約のための List

List
(aggregates)
Disjunction
(error accumulation)
Algebra of types
エラー蓄積のためのDisjunction

List
(aggregates)
Disjunction
Kleisli
(dependency injection)
Algebra of types
依存性注入のための Kleisli

List
(aggregates)
Disjunction
Kleisli
Future
(reactive non-blocking computation)
Algebra of types
リアクティブでノンブロッキングな処理のための Future

List
(aggregates)
Disjunction
Kleisli
Future
Algebra of types
Monad
モナド

List
(aggregates)
Disjunction
Kleisli
Future
Algebra of types
Monad
Monoid
モノイド

List
(aggregates)
Disjunction
Kleisli
Future
Algebra of types
Monad
Monoid
Compositional
合成可能

List
(aggregates)
Disjunction
Kleisli
Future
Algebra of types
Monad
Monoid
Offers a suite of functional
combinators
さまざまな関数型コンビネータを提供する

List
(aggregates)
Disjunction
Kleisli
Future
Algebra of types
Monad
Monoid
Handles edge cases so your
domain logic remains clean
ドメインロジックを綺麗保てるように、
エッジケースはこっちで処理する

List
(aggregates)
Disjunction
Kleisli
Future
Algebra of types
Monad
Monoid
Implicitly encodes quite a bit
of domain rules
暗黙的にかなり多くのドメインルールをエンコードする

.. the algebra ..
代数的な考え方

.. the algebra ..
functions
関数

.. the algebra ..
types
型

.. the algebra ..
composition
def tradeGeneration(market: Market, broker: Account,
}
合成

.. the algebra ..
trait OrderLaw {
def sizeLaw: Seq[ClientOrder] => Seq[Order] => Boolean =
{ cos => orders =>
cos.size == orders.size
}
def lineItemLaw: Seq[ClientOrder] => Seq[Order] => Boolean =
{ cos => orders =>
cos.map(instrumentsInClientOrder).sum ==
orders.map(_.items.size).sum
}
}
laws of the algebra
(domain rules)
代数の法則

Domain Rules as
Algebraic Properties
• part of the abstraction
• equally important as the actual
abstraction
• veriﬁable as properties
代数的プロパティとしてのドメインルール
プロパティとして検証可能となる

.. domain rules veriﬁcation ..
property("Check Client Order laws") =
forAll((cos: Set[ClientOrder]) => {
val orders = for {
os <- clientOrders.run(cos.toList)
} yield os
sizeLaw(cos.toSeq)(orders) == true
lineItemLaw(cos.toSeq)(orders) == true
})
property based testing FTW ..
プロパティベーステスト最強

https://www.manning.com/books/functional-and-reactive-
domain-modeling
本書いてます

ThankYou!

Functional and Algebraic Domain Modeling

More Related Content

Similar to Functional and Algebraic Domain Modeling (6)

More from Debasish Ghosh (8)

Recently uploaded (20)

Functional and Algebraic Domain Modeling