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 specific 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)

特定の問題領域に関する概念モデルエンティティ／関連／制約などを記述Saturday, 30 January 16

http://en.wikipedia.org/wiki/Domain_model

http://en.wikipedia.org/wiki/Domain_model

The Functional Lens ..

“domain API evolution through algebraic composition”

関数型レンズ代数的合成を通じたドメイン API の進化Saturday, 30 January 16

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


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

Your domain model is a function

ドメインモデルは関数である


Your domain model is a function

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


Your domain model is a collection of functions

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


Your domain model is a 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 はビジネスルールSaturday, 30 January 16

• 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 verifiable• types• type constraints• expr in terms of other generic algebra

• type constraints• more constraints if you have DT• algebraic property based testing

確認可能なのは型制約、代数的プロパティーベースのテスト依存型があればより強い制約を検証できるSaturday, 30 January 16

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

...

behaviorsFunctions

(Type => Type)

ソリューションドメインでは、振る舞いは関数 (型 ⇒ 型)


Bank

Account

Trade

Customer

......

...

do trade

process execution

place order

Solution Domain

...

entities

behaviorsfunctions

(Type => Type)

algebraic data type

エンティティは代数的データ型


Bank

Account

Trade

Customer

......

...

do trade

process execution

place order

Solution Domain

...

market regulations

tax laws


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


rates

...

entities

behaviors

laws



Monoid

Monad

...

モノイドやモナドといった型クラス


Bank

Account

Trade

Customer

......

...

do trade

process execution

place order

Solution Domain

...

market regulations

tax laws


rates

...

entities

behaviors

laws



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- flexible format

1

クライアントが注文を出すフォーマットは様々Saturday, 30 January 16


Transform to internal domainmodel entity and place for execution

1 2

内部でのドメインモデルエンティティに変換して、実際に注文を出すSaturday, 30 January 16


Transform to internal domainmodel entity and place for execution

Trade & Allocate toclient 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

どこからともなく降ってきた型。今の所実装の話はゼロ。型の名前はドメイン言語を反映Saturday, 30 January 16




• Types (domain entities)• Functions operating on types (domain behaviors)• Laws (business rules)

型 (エンティティ)、関数 (ドメインの振る舞い)、法則 (ビジネス・ルール)Saturday, 30 January 16




• 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 が準拠する制約実装は代数に含まれず、実装からは分離されているSaturday, 30 January 16




let’s do some algebra ..

代数の練習



def execute(m: Market, broker: Account): Order => List[Execution]

def allocate(accounts: List[Account]): Execution => List[Trade]























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





型に任せて考える





Domain algebra composed with the categorical algebra of a Kleisli Arrow


Klieisli 射によって合成されたドメイン代数





.. that implements the semantics of our domain algebraically ..


ドメインの意味論を代数的に実装する作用付きの関数の合成


def tradeGeneration( market: Market, broker: Account, clientAccounts: List[Account]) = {

clientOrders andThen execute(market, broker) andThen allocate(clientAccounts)

}

Implementation follows the specification

.. the complete trade generation logic ..

実装は仕様に従う


def tradeGeneration( market: Market, broker: Account, clientAccounts: List[Account]) = {

clientOrders andThen execute(market, broker) andThen allocate(clientAccounts)

} Implementation follows the specification and we get the Ubiquitous Language for

free :-)

.. the complete trade generation logic ..

実装は仕様に従い、そこからユビキタス言語を読み取ることが出来るSaturday, 30 January 16

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 defined the algebras of our domain APIs in terms of existing, time tested algebras of Kleislis and Monads

代数的かつ関数型の設計は、純粋関数のみで構成する、合成可能な設計Saturday, 30 January 16




.. our algebra still doesn’t handle errors that may occur within our domain

behaviors ..


そう言えばエラー処理どうする?


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


モナド作用としてのエラー処理純粋で関数型に。明示的な代数。既存の作用と積み上げ可能。Saturday, 30 January 16


.. 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).rightfor { maybeCount <- count} yield { for { c <- maybeCount // use c } yield c}

Monad Transformers

モナド変換子



val count: Response[Int] = some(10).rightfor { 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



val count: Response[Int] = some(10).rightfor { 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

モナド変換子は積み上げたモナドを一つに潰すことができるただし積み上げる順番は大切Saturday, 30 January 16



case class ListT[M[_], A] (run: M[List[A]]) { //..

ListT モナド変換子を使う


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

type StringOr[A] = String \/ Atype 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

型の代数集約のための ListSaturday, 30 January 16

List(aggregates)

Disjunction(error accumulation)

Algebra of types

エラー蓄積のためのDisjunction


List(aggregates)


Kleisli(dependency injection)

Algebra of types

依存性注入のための Kleisli


List(aggregates)



Future(reactive non-blocking computation)

Algebra of types

リアクティブでノンブロッキングな処理のための Future


List(aggregates)




Algebra of types

Monad

モナド


List(aggregates)




Algebra of types

Monad Monoid

モノイド


List(aggregates)




Algebra of types

Monad MonoidCompositional

合成可能


List(aggregates)




Algebra of types

Monad Monoid

Offers a suite of functional combinators

さまざまな関数型コンビネータを提供する


List(aggregates)




Algebra of types

Monad Monoid

Handles edge cases so your domain logic remains clean

ドメインロジックを綺麗保てるように、エッジケースはこっちで処理するSaturday, 30 January 16

List(aggregates)




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, clientAccounts: List[Account]) = {

clientOrders andThen execute(market, broker) andThen allocate(clientAccounts)}

合成


.. 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

• verifiable as properties

代数的プロパティとしてのドメインルールプロパティとして検証可能となるSaturday, 30 January 16

.. domain rules verification ..

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

本書いてます






Thank You!


Software

Functional and Algebraic Domain Modeling