Domain Driven Design with the F# type System -- NDC London 2013

Prologue: how many things are wrong?

type Contact = {

FirstName: string
MiddleInitial: string
LastName: string
EmailAddress: string
IsEmailVerified: bool
// true if ownership of
}
// email address is confirmed
Domain Driven Design with the F# type system

Prologue: which values are optional?

type Contact = {
FirstName: string
LastName: string
}

Prologue: what are the constraints?

type Contact = {
FirstName: string
LastName: string
}

Prologue: what groups are atomic?
type Contact = {

FirstName: string
LastName: string
}

Prologue: domain logic?
type Contact = {

FirstName: string
LastName: string
}

Prologue: F# can help
type Contact = {
FirstName: string
LastName: string
}

Domain Driven Design
with the F# type system
Scott Wlaschin
@ScottWlaschin
fsharpforfunandprofit.com /ddd

What is DDD?

What is F#?

What is DDD and F#?

“F# is a mature, open
source, cross-platform,
functional-first programming
language which empowers
users and organizations to
tackle complex computing
problems with simple,
maintainable and robust
code.”
— fsharp.org

Domain Driven Design with the F# type System -- NDC London 2013

What I’m going talk about:

• Functional programming for real
world applications
• F# vs. C# for domain driven design
• Understanding the F# type system
• Designing with types

Functional programming
for real world applications

Functional programming is...
... good for mathematical and scientific tasks
... good for complicated algorithms
... really good for parallel processing
... but you need a PhD in computer science 

Functional programming is good for...

Boring
Line Of Business
Applications
(BLOBAs)

Must haves for BLOBA development...
• Express requirements clearly
• Rapid development cycle
• High quality deliverables
• Fun

F# vs. C#
for Domain Driven Design
Values vs. Entities

Values vs. Entities

Photo credit: http://www.flickr.com/photos/anacooke/

Values vs. Entities

Examples of Values:
• Personal name
• Email address
• Postal address
• Product code
uneaten apple

Examples of Entities:
• Customer
• Order
• Product
half eaten apple

How do you implement a Value object?

Equality based on comparing all properties
PersonalName:
FirstName = "Alice"
LastName = "Adams"

PersonalName:
FirstName = "Alice"
Equal LastName = "Adams"

 Therefore must be immutable

Value object definition in C#
class PersonalName
{
public PersonalName(string firstName, string lastName)
{
this.FirstName = firstName;
this.LastName = lastName;
}
public string FirstName { get; private set; }
public string LastName { get; private set; }

}

Value object definition in C# (extra code for equality)
class PersonalName
{
// all the code from above, plus...
public override int GetHashCode()
{
return this.FirstName.GetHashCode() + this.LastName.GetHashCode();
}
public override bool Equals(object other)
{
return Equals(other as PersonalName);
}
public bool Equals(PersonalName other)
{
if ((object) other == null)
{
return false;
}
return FirstName == other.FirstName && LastName == other.LastName;
}

Value object definition in F#
type PersonalName = {FirstName:string; LastName:string}

Value object definition in F# (extra code for equality)

This page intentionally left blank

How do you implement an Entity object?

Equality based on some sort of id
Person:
Equal Person:
Id = 1
Id = 1
Name = "Alice Adams" X
Name = "Bilbo Baggins"

 Generally has mutable content

Entity object definition in C# (part 1)
class Person
{
public Person(int id, PersonalName name)
{
this.Id = id;
this.Name = name;
}
public int Id { get; private set; }
public PersonalName Name { get; set; }
}

Entity object definition in C# (part 2)
class Person
{
// all the code from above, plus...
{
return this.Id.GetHashCode();
}
{
return Equals(other as Person);
}
public bool Equals(Person other)
{
{
return false;
}
return Id == other.Id;
}
}

Entity object definition in F# with equality override
[<CustomEquality; NoComparison>]
type Person = {Id:int; Name:PersonalName} with
override this.GetHashCode() = hash this.Id
override this.Equals(other) =
match other with
| :? Person as p -> (this.Id = p.Id)
| _ -> false

Entity object definition in F# with no equality allowed
[<CustomEquality; NoComparison>]
[<NoEquality; NoComparison>]
type Person = {Id:int; Name:PersonalName}

Entity immutability
type Person = { ... ... ... }

let tryCreatePerson name =
// validate on construction
// if input is valid return something
// if input is not valid return error




Entity object definition in F# with mutability
type Person = {Id:int; mutable Name:PersonalName}

Reviewing the C# code so far...

: IValue

class PersonalName
{
public PersonalName(string firstName, string lastName)
{
this.FirstName = firstName;
this.LastName = lastName;
}

: IEntity

class Person
{
public Person(int id, PersonalName name)
{
this.Id = id;
this.Name = name;
}

public string FirstName { get; private set; }
public string LastName { get; private set; }

public int Id { get; private set; }
public PersonalName Name { get; set; }

{
return this.FirstName.GetHashCode() +
this.LastName.GetHashCode();
}

{
return this.Id.GetHashCode();
}
{
return Equals(other as Person);
}

{
return Equals(other as PersonalName);
}
public bool Equals(PersonalName other)
{
{
return false;
}
return FirstName == other.FirstName &&
LastName == other.LastName;
}
}

public bool Equals(Person other)
{
{
return false;
}
return Id == other.Id;
}
}

Reviewing the F# code so far...

[<StructuralEquality;NoComparison>]
type PersonalName = {
FirstName : string;
LastName : string }

type Person = {
Id : int;
Name : PersonalName }

Comparing C# vs. F#

C#

Value objects?
Entity objects?
Value objects by default?
Immutable objects by default?
Can you tell Value objects
from Entities at a glance?
Understandable by
non-programmer?

F#

Non-trivial
Non-trivial
No
No
No

Easy
Easy
Yes
Yes
Yes

No

Yes

F# for Domain Driven Design
Communicating a domain model

Communication is hard...

U-N-I-O-N-I-Z-E

Communication in DDD: “Bounded Context”

Supermarket
Marketing
Sales
Business
Customer
unionize
Product
Spam

Email System
Warehouse
Finance
Chemistry
Customer
un-ionize
Product
Spam

Communication in DDD: “Ubiquitous Language”

Warehouse
Chemistry
Sales
IonProduct MoleculeTransfer Depot Tracking
Product Stock
Atom
Promotion Customer Tracking
Polymer Compound Bond

module CardGame =
type Suit = Club | Diamond | Spade | Heart

Ubiquitous language

type Rank = Two | Three | Four | Five | Six | Seven | Eight
| Nine | Ten | Jack | Queen | King | Ace
type Card = Suit * Rank
type Hand = Card list
type Deck = Card list
type Player = {Name:string; Hand:Hand}
type Game = {Deck:Deck; Players: Player list}
type Deal = Deck –› (Deck * Card)
type PickupCard = (Hand * Card) –› Hand

module CardGame =

Ubiquitous language


'*' means a pair. Choose one from each type
list type is built in


module CardGame =

Understanding the F# type system
An introduction to “algebraic” types

Understanding the F# type system
An introduction to “composable” types

Creating new types in F#

New types in F# are constructed by combining
other types using two basic operations:
type typeW = typeX "times" typeY
type typeZ = typeX "plus" typeY

Creating new types in F#

1
2
3
4

(aAddOne
function)
int –› int

2
3
4
5

Representing pairs

(1,2)
(2,3)
(3,4)
(4,5)

AddPair
? –› int

3
5
7
9

Representing pairs

(1,2)
(2,3)
(3,4)
(4,5)

=

1
2
3
4

×

2
3
4
5

Representing pairs

(true, false)
(true, true)
(false, false)
(false, true)

=

true
false

×

true
false

Representing pairs

pair of ints
written int * int
pair of bools
written bool * bool

Using tuples for data

Alice, Jan 12th
Bob, Feb 2nd
Carol, Mar 3rd

=

Set of
people

×

Set of
dates

Using tuples for data

Alice, Jan 12th
Bob, Feb 2nd
Carol, Mar 3rd

=

Set of
people

×

Set of
dates

type Birthday = Person * Date

Representing a choice

Temp F

or
Temp C

IsFever
? –› bool

true
false


Temp F

or
Temp C

98˚ F
99˚ F
100˚ F
101˚ F

= +
37.0˚ C
37.5˚ C
38.0˚ C
38.5˚ C


Temp F

or
Temp C

98˚ F
99˚ F
100˚ F
101˚ F

= +
37.0˚ C
37.5˚ C
38.0˚ C
38.5˚ C

type Temp =
| F of int
| C of float

Tag these with “C”

Using choices for data

type PaymentMethod =
| Cash
| Cheque of int
| Card of CardType * CardNumber

Working with a choice type
type PaymentMethod =
| Cash
| Cheque of int
| Card of CardType * CardNumber
let printPayment method =
match method with
| Cash –›
printfn “Paid in cash"
| Cheque checkNo –›
printfn “Paid by cheque: %i" checkNo
| Card (cardType,cardNo) –›
printfn “Paid with %A %A" cardType cardNo

What are types for in F#?

An annotation to a value for type checking
type AddOne: int –› int

Domain modelling tool

Designing with types
What can we do with this type system?

Required vs. Optional

type PersonalName =
{
FirstName: string;
MiddleInitial: string;
LastName: string;
}

required
optional
required

Null is not the same as “optional”

“a”
“b”
“c”
null

Length
string –› int

1
2
3

Spock, set
phasers to null!

That is illogical,
Captain

Null is not allowed in F#

“a”
“b”
“c”
null
X

Length
string –› int

1
2
3

A better way for optional values

“a”
“b”
“c”
or

“a”
“b”
“c”

= +

type OptionalString =
| SomeString of string
| Nothing

missing
Tag with “Nothing”

The built-in “Option” type

type Option<'T> =
| Some of 'T
| None
type PersonalName =
{
FirstName: string
LastName: string
}


type Option<'T> =
| Some of 'T
| None
type PersonalName =
{
FirstName: string
MiddleInitial: Option<string>
LastName: string
}


type Option<'T> =
| Some of 'T
| None
type PersonalName =
{
FirstName: string
MiddleInitial: string option
LastName: string
}

Single choice types

type Something =
| ChoiceA of A
type Email =
| Email of string
type CustomerId =
| CustomerId of int

Wrapping primitive types

Is an EmailAddress just a string?
Is a CustomerId just a int?
Use single choice types to keep them distinct
type EmailAddress = EmailAddress of string
type PhoneNumber = PhoneNumber of string
type CustomerId = CustomerId of int
type OrderId = OrderId of int

Creating the EmailAddress type

let createEmailAddress (s:string) =
if Regex.IsMatch(s,@"^S+@S+.S+$")
then (EmailAddress s)
else ?
createEmailAddress:
string –› EmailAddress

Creating the EmailAddress type

let createEmailAddress (s:string) =
if Regex.IsMatch(s,@"^S+@S+.S+$")
then Some (EmailAddress s)
(EmailAddress s)
else None
?
createEmailAddress:
string –› EmailAddress option

Constrained strings

type String50 = String50 of string

let createString50 (s:string) =
if s.Length <= 50
then Some (String50 s)
else None
createString50 :
string –› String50 option

Constrained numbers

Qty: – 999999 +

Add To Cart

Constrained numbers

type OrderLineQty = OrderLineQty of int

let createOrderLineQty qty =
if qty >0 && qty <= 99
then Some (OrderLineQty qty)
else None
createOrderLineQty:
int –› OrderLineQty option

The challenge, revisited

type Contact = {

FirstName: string
LastName: string
}


type Contact = {

FirstName: string
MiddleInitial: string option
LastName: string
}


type Contact = {

FirstName: String50
MiddleInitial: String1 option
LastName: String50
EmailAddress: EmailAddress
}

FirstName: String50
LastName: String50 }

type Contact = {
Name: PersonalName
Email: EmailContactInfo }

type EmailContactInfo = {
IsEmailVerified: bool }

Encoding domain logic

type EmailContactInfo = {
IsEmailVerified: bool }
Rule 1: If the email is changed, the verified flag
must be reset to false.
Rule 2: The verified flag can only be set by a
special verification service

Encoding domain logic

type VerifiedEmail = VerifiedEmail of EmailAddress
type VerificationService =
(EmailAddress * VerificationHash) –› VerifiedEmail option

type EmailContactInfo =
| Unverified of EmailAddress
| Verified of VerifiedEmail

The challenge, completed
type EmailAddress = ...
type VerifiedEmail =
VerifiedEmail of EmailAddress

FirstName: String50
LastName: String50 }

type EmailContactInfo =
| Unverified of EmailAddress
| Verified of VerifiedEmail

type Contact = {
Name: PersonalName
Email: EmailContactInfo }

Making illegal states unrepresentable

New rule:
“A contact must have an email or a postal address”

type Contact = {
Name: Name
Email: EmailContactInfo
Address: PostalContactInfo
}


New rule:

type Contact = {
Name: Name
Email: EmailContactInfo option
Address: PostalContactInfo option
}


implies:
• email address only, or
• postal address only, or
• both email address and postal address


type ContactInfo =
| EmailOnly of EmailContactInfo
| AddrOnly of PostalContactInfo
| EmailAndAddr of EmailContactInfo * PostalContactInfo
type Contact = {
Name: Name
ContactInfo : ContactInfo }


BEFORE: Email and address separate

type Contact = {
Name: Name
Email: EmailContactInfo
Address: PostalContactInfo
}

AFTER: Email and address merged into one type

type Contact = {
Name: Name
ContactInfo : ContactInfo }

type ContactInfo =
| EmailOnly of EmailContactInfo
| AddrOnly of PostalContactInfo
| EmailAndAddr of
EmailContactInfo * PostalContactInfo

“A contact must have at leastemail or of postalcontacted”
“A contact must have an one way a being address”
type ContactInfo =
| Email of EmailContactInfo
| Addr of PostalContactInfo
type Contact = {
Name: Name
PrimaryContactInfo: ContactInfo
SecondaryContactInfo: ContactInfo option }

Stuff I haven’t had time to cover:
• Services
• States and transitions
• CQRS
• The functional approach to use cases
• Domain events
• Error handling
• And much more...

F# is low risk

Enterprise
development

Mobile
development

F# on over
2 billion devices

F# is the safe choice for functional-first development

credit: @7sharp9 @MattDrivenDev

Thank you!

fsharpforfunandprofit.com/ddd
fsharp.org/testimonials
tryfsharp.org
try F# in your web browser!

@ScottWlaschin
#fsharp on Twitter

Domain Driven Design with the F# type System -- NDC London 2013

More Related Content

What's hot (20)

Similar to Domain Driven Design with the F# type System -- NDC London 2013 (20)

More from Scott Wlaschin (17)

Recently uploaded (20)

Domain Driven Design with the F# type System -- NDC London 2013