TechDay: Functional DDD - Alessandro Melchiori

Functional
Domain Driven Design
disclaimer: is still a “work in progress”

Focus on the domain and
domain logic rather than
technology
(Eric Evans)

Why not with a functional approach?

A monad is a triple (T,
η,
μ) where T is an
endofunctor T:
X-‐>X and η:
I-‐>T and μ:
T
x
T-‐>T
are 2 natural transformations satisfying these laws:
•  Identity law: μ(η(T))
=
T
=
μ(T(η))

•  Associative law: μ(μ(T
×
T)
×
T))
=
μ(T
×
μ(T

×
T))
A monad in X is just a monoid in the category
of endofunctors of X, with product × replaced
by composition of endofunctors and unit set
by the identity endofunctor
What is a monad?

software developer @ codiceplastico
@amelchiori
alessandro@codiceplastico.com
About me

let
myString
=
"original
value"

let
myString
=
"new
value”

Immutability: values, not variables!
Duplicate definition of value ‘myString’

let
add
x
y
=
x
+
y

add
2
2

x:int
-‐>
y:int
-‐>
int

Type inference

void
ProcessItems(Item[]
items,
Action<Item>
action)

{

for(int
i
=
0;
i
<
items.Length;
i++)

{

var
item
=
items[i];

action(item);

}

}

Recursion

let
rec
processItems
action
=
function

|
[]

-‐>
()

|
head
::
tail
-‐>

action
head;

processItems
tail

Recursion

let
add
x
y
=
x
+
y

x:int
-‐>
y:int
-‐>
int

Partial function application
let
add5
x
=
add
5

x:int
-‐>
int

let
value
=
add5
10

(value
=
15)

let
f
x
=
x
*
x

x:int
-‐>
int

let
g
x
=
-‐x/2
+
5

x:int
-‐>
int

Functions composition
let
(<<)
f
g
x
=
f
(g
x)

('b
-‐>
'c)
-‐>
('a
-‐>
'b)
-‐>
'a
-‐>
’c

let
h
x
=
f
<<
g

x:int
-‐>
int

let
square
x
=
x
*
x

let
add
x
y
=
x
+
y

let
toString
x
=
x.ToString()

let
complexFunction
x
=
toString
(add
5
(square
x))

Pipeline operator
let
(|>)
x
f
=
f
x

let
complexFunction
x
=
x
|>
square
|>
add
5
|>
toString

let
div
x
y
=
x
/
y

x:int
-‐>
y:int
-‐>
int

div
10
5

//
2

div
10
0

//
System.DivideByZeroException

Option type
let
safeDiv
x
y
=

if
y
=
0
then
None

else
Some(x/y)

x:int
-‐>
y:int
-‐>
int
option

let
safeDiv
x
y
=

match
y
with

|
0
-‐>
None

|
_
-‐>
Some(x/y)

Pattern matching
let
safeDiv
x
y
=

match
y
with

|
0
-‐>
None

|
1
-‐>
Some(x/y)

Incomplete pattern matches on this expression.
For example, the value '2' may indicate a case not covered by
the pattern(s)

type
State
=

|
On

|
Off

let
x
=
On

let
y
=
Off

Discriminated unions

let
div
(x,
y)
=
…

(int
*
int)
-‐
>
int

Tuples
let
div
(x,
y)
=

match
(x,
y)
with

|
(_,
0)
-‐>
None

|
(_,
_)
-‐>
Some(x/
y)

type
site
=
{
Title
:
string;
Url
:
string
}

Records
let
homepage
=

{
Title
=
"Google";
Url
=
"http://www.google.com"
}

let
next
=
{
homepage
with
Title
=
"NextPage"
}

public
class
Company

{

public
String
BusinessName
{
get;
set;
}

public
String
TaxCode
{
get;
set;
}

public
String
VatNumber
{
get;
set;
}

public
String
AssignedBank
{
get;
set;
}

public
Boolean
IsBankAuthorized
{
get;
set;
}

}

Value object
An immutable object, like money or a date
range, whose equality isn't based on identity
(in general equality is based on all fields
equality)
Martin Fowler

public
class
CompanyProfile

{

public
String
BusinessName
{
get;
private
set;
}

public
String
TaxCode
{
get;
private
set;
}

public
String
VatNumber
{
get;
private
set;
}

public
CompanyProfile(String
businessName,
String
taxCode,

String
vatNumber=null)

{

//
check
if
parameters
are
valid

BusinessName
=
businessName;

TaxCode
=
taxCode;

VatNumber
=
vatNumber;

}

}

Value object

public
class
CompanyProfile

{

//
same
as
before…

public
override
Boolean
Equals(Object
other)

{

var
target
=
other
as
CompanyProfile;

return
target
==
null
?
false
:

target.BusinessName
==
this.BusinessName

&&
target.TaxCode
==
this.TaxCode

&&
target.VatCode
==
this.VatCode;

}

public
override
Int32
GetHashCode()

{

//
...

}

}

Value object’s equality

type
CompanyProfile
=
{

BusinessName
:
string;

TaxCode
:
string;

VatNumber
:
string

}

Value object in F#
option;

let
profile
=
{

BusinessName
=
“CodicePlastico”;

TaxNumber
=
“1234567890”;

}

Ubiquitous Language is the concept of
defining a language (spoken and written) that
is equally used across developers and domain
experts
Ubiquitous language

public
class
Company

{

...

public
String
AssignedBank
{
get;
set;
}

public
Boolean
IsBankAuthorized
{
get;
set;
}

}

Ubiquitous language

Rule 1:
A company must have a bank to work with
Rule 2:
A company can be authorized to work with its
assigned bank
Rule 3:
A company can be not authorized to work with
its assigned bank
Business logic

Make illegal states unrepresentable
Ubiquitous language

type
Bank
=
Bank
of
string

type
UnauthorizedBank
=
UnauthorizedBank
of
Bank

type
AuthorizedBank
=
AuthorizedBank
of
Bank

type
AssignedBank
=

|
Unauthorized
of
UnauthorizedBank

|
Authorized
of
AuthorizedBank

Business logic in F#

type
CompanyProfile
=
{

BusinessName:
string,

TaxCode:
string,

VatCode:
string
option

}

type
Bank
=
Bank
of
string

type
UnauthorizedBank
=

UnauthorizedBank
of
Bank

type
AuthorizedBank
=

AuthorizedBank
of
Bank

type
AssignedBank
=

|
Unauthorized
of
UnauthorizedBank

|
Authorized
of
AuthorizedBank

type
Company
=
{

Profile:
CompanyProfile,

Bank:
AssignedBank

}

Ubiquitous language to the rescue

The central idea of specification is to
separate the statement of how to match
a candidate, from the candidate object
that it is matched against
Specification

type
SpecificationResult
=

|
Success

|
Failure
of
string

type
Spec<'a>
=
'a
-‐>
SpecificationResult

Specification

type
Category
=

|
Default

|
Premium

|
Gold

type
Customer
=
{

Name:
string;

Category:
Category;

}

Specification: our (simple) domain
type
Item
=
{

Code:
string;

Quantity:
int;

}

type
Order
=
{

Number:
string;

Customer:
Customer;

Items:
Item
list;

}

let
isOrderFullFilled
:
Spec<Order>
=

let
p
order
=

match
Seq.isEmpty
order.Items
with

|
true
-‐>
Failure("Items'
list
empty")

|
false
-‐>
Success

in
p

let
isGoldCustomer
:
Spec<Customer>
=

let
p
customer
=

match
customer.Category
with

|
Gold
-‐>
Success

|
_
-‐>
Failure("No-‐gold
customer")

in
p

Specification

let
And
(left:
Spec<'a>)
(right:
Spec<'a>)
:
Spec<'a>
=

let
p
entity
=

match
left
entity
with

|
Success
-‐>
right
entity

|
_
-‐>
Failure("And
specification
is
not
satisfied")

in
p

Specification

A single model cannot be appropriate for
reporting, searching and transactional
behavior
Greg Young
CQRS

State transition are an important part of our
problem space and should be modeled within
our domain
Greg Young
Event Sourcing

public
void
AddItemToCart(Item
item)

{

//
validation

if
(item
==
null)

throw
new
ArgumentNullException();

//
execution

_items.Add(item.Id);

}

Commands, events and…fold (step 1)

public
void
AddItemToCart(Item
item)

{

if
(item
==
null)

throw
new

var
domainEvent
=
new
ItemAddedToCart

{
CartId
=
this.Id,
ItemId
=
item.Id
};

Apply(domainEvent)

}

private
void
Apply(ItemAddedToCart
domainEvent)

{

_items.Add(domainEvent.ItemId);

}


public
void
AddItemToCart(Item
item)

{

if
(item
==
null)

throw
new

var
domainEvent
=
new
ItemAddedToCart

{
CartId
=
this.Id,
ItemId
=
item.Id
};

Apply(this,
domainEvent)

}

private
void
Apply(Cart
target,
ItemAddedToCart
domainEvent)

{

target._items.Add(domainEvent.ItemId);

}


public
static
Cart
Apply(Cart
target,
CartCreated
domainEvent)

{

return
new
Cart
{
Id
=
domainEvent.CartId,
_items
=
new
String[0]
};

}

public
static
Cart
Apply(Cart
target,
ItemAddedToCart
domainEvent)

{

var
items
=
target._items.ToList();

items.Add(domainEvent.ItemId);

return
new
Cart
{
Id
=
domainEvent.CartId,
_items
=
items
};

}

public
static
Cart
Apply(Cart
target,
ItemRemovedFromCart
domainEvent)

{

var
items
=
target._items.ToList();

items.Remove(domainEvent.ItemId);

return
new
Cart
{
Id
=
domainEvent.CartId,
_items
=
items
};

}


Cart.Apply(null,
new
CartCreated
{
CartId=1
})


Cart.Apply(

Cart.Apply(null,
new
CartCreated
{
CartId=1}),

new
ItemAddedToCart
{
CartId
=
1,
ItemId
=
"A"
}

)


Cart.Apply(

Cart.Apply(

Cart.Apply(null,
new
CartCreated
{
CartId=1}),

new
ItemAddedToCart
{
CartId
=
1,
ItemId
=
"A"
}

),

new
ItemAddedToCart
{
CartId
=
1,
ItemId
=
"B"
}

)


Cart.Apply(

Cart.Apply(

Cart.Apply(

Cart.Apply(null,
new
CartCreated
{
CartId=1}),

new
ItemAddedToCart
{
CartId
=
1,
ItemId
=
"A"
}

),

new
ItemAddedToCart
{
CartId
=
1,
ItemId
=
"B"
}

),

new
ItemRemovedFromCart
{
CartId
=
1,
ItemId
=
"A"
}

)


Executing a command:
type
Exec
=

(
CartState
*
Command
)
-‐>
DomainEvent

Applying an event:
type
Apply
=

(
CartState
*
DomainEvent
)
-‐>
CartState


type
CartState
=
{

Name:
string;

Items:
List<int>;

Active:
bool;

}

let
apply
state
=
function

|
Created
x
-‐>
{
Cart.empty
with
Name
=
x
}

|
ItemAdded
x
-‐>
{
state
with
Items
=
List.append
state.Items
[x]
}

|
ItemRemoved
x
-‐>

{
state
with
Items
=
List.filter
(fun
i
-‐>
i
<>
x
)
state.Items
}

|
Removed
_
-‐>
{
state
with
Items
=
List.empty
}

|
Checkedout
_
-‐>
{
state
with
Active
=
false
}


let
domainEvents
=
[

Created("cart1");

ItemAdded(1);

ItemAdded(2);

Removed;

ItemAdded(3);

Checkedout;

]

let
state
=
List.fold
apply
Cart.empty
domainEvents


Tackling Complexity in the
Heart of Software
Eric Evans
…but, when DDD?

TechDay: Functional DDD - Alessandro Melchiori

TechDay: Functional DDD - Alessandro Melchiori

Recomendados

Recomendados

Más contenido relacionado

Más de Codemotion

Más de Codemotion (20)

TechDay: Functional DDD - Alessandro Melchiori