Tiny Types - Static Typing Gone Mad

jan-molak.github.io/tiny-types@JanMolak @JsRoundabout
Static Typing Gone Mad

Jan Molak
independent consultant 
technical coach
janmolak.com
github.com/jan-molak

Tiny Types

Tiny Types:
the encapsulation of simple built-in types 
within domain-speciﬁc classes

- Darren Hobbs, Tiny Types, 2007

Tiny Types by example

Online payments
As a bank account holder 
I want to be able to make my payments online  
So that I can do so at the time that suits me best

function makePayment(from, to, reference, amount) {
// …
}

function makePayment( 
from: string,  
to: string,  
reference: string, 
amount: string, 
) { /* … */ }

function makePayment( 
from: PayerAccountDetails,  
to: PayeeAccountDetails,  
reference: PaymentReference, 
amount: Money, 
) { /* … */ }

Implementing Tiny Types

new PaymentReference(`Invoice No. 2018Q4`)

class PaymentReference {
public reference: string;
constructor(reference: string) {
this.reference = reference; 
}
}

public readonly reference: string;
constructor(reference: string) {
this.reference = reference; 
}
}

constructor(public readonly reference: string) { 
}
}

Consolidated Validation

constructor(public readonly reference: string) {
// is it really any string?
}
}

if(reference === undefined) { throw new Error(…); } 
}
}

if(reference === undefined) { throw new Error(…); }
if(reference.length > 18) { throw new Error(…); } 
}
}

Composite types

class Money {
constructor(
public readonly amount: AmountOfMoney,
public readonly currency: Currency,
) { 
}
}
PoEAA , Fowler, 2003

class Money {
constructor(
public readonly amount: AmountOfMoney,
public readonly currency: Currency,
) {
if(! amount) { throw new Error(…); }
if(! currency) { throw new Error(…); } 
}
}

Low-level domain logic

class Money {
/* … */
add(another: Money): Money { /* … */ }
subtract(another: Money): Money { /* … */ }
equals(another: Money): boolean { /* … */ }
}

class Money {
add(another: Money): Money {
if (! this.currency.equals(another.currency)) {
throw new Error(…); 
}
return new Money( 
this.amount.add(another.amount), 
this.currency, 
);
}
/* … */
}

npm install tiny-types

Predicates

import { ensure, isDefined, isLessThan, property }  
from 'tiny-types';
constructor(public readonly reference: string) { 
ensure('reference', reference,
isDefined(),
property('length', isLessThan(18)),
); 
} 
}

new PaymentReference() 
> Error: reference should be defined
new PaymentReference(‘way too many characters’);
> Error: reference should have length that is less than 18

Value equality

import { equal } from 'tiny-types/lib/objects';
class Money {
constructor(public readonly amount: AmountOfMoney, 
public readonly currency: Currency, 
) { /* … */ }
equals(another: any): boolean {
return equal(this, another);
} 
}

import { TinyType } from 'tiny-types';
class Money extends TinyType {
constructor(public readonly amount: AmountOfMoney, 
public readonly currency: Currency, 
) { /* … */ } 
}

const GBP = new Currency(‘GBP’);
const m1 = new Money(new AmountOfMoney(’10.50’), GBP);
const m2 = new Money(new AmountOfMoney(’10.50’), GBP);
m1.equals(m2);
> true

Serialisation

const m = new Money(new AmountOfMoney(’10.50’), GBP);
m.toJSON();
{
amount: ’10.50’,
currency: ‘GBP’, 
}

No more [object Object]

const m = new Money(new AmountOfMoney(’10.50’), GBP);
m.toString();
> Money(amount=AmountOfMoney(10.50),currency=Currency(GBP))

Big Benefits of Tiny Types

clarity of intent

clarity of intent
better tooling support

clarity of intent
immutability

clarity of intent
immutability
consolidated validation

clarity of intent
immutability
consolidated validation
encapsulation

Thanks!
@JanMolak
janmolak.com
jan-molak.github.io/tiny-types/

Tiny Types - Static Typing Gone Mad

Recomendados

Recomendados

Más contenido relacionado

Último

Último (20)

Destacado

Destacado (20)

Tiny Types - Static Typing Gone Mad