Slide 1

Slide 1 text

Totally Typed Domain When dependent types meets DDD

Slide 2

Slide 2 text

Why? Type driven development and Dependent types look cool! Model the domain closely ! Make impossible states impossible ! Some guarantees

Slide 3

Slide 3 text

Type ... Define ... Refine

Slide 4

Slide 4 text

Dependent types

Slide 5

Slide 5 text

?Holes

Slide 6

Slide 6 text

Nice compiler Interactive Strict but helpful

Slide 7

Slide 7 text

Proof search

Slide 8

Slide 8 text

%default total

Slide 9

Slide 9 text

Unit tests It compiles so it's obviously correct right? NO

Slide 10

Slide 10 text

Unit tests It compiles so it's obviously correct right? YES Unit tests implemented in the type system

Slide 11

Slide 11 text

Small types Big types ~= inheritance Small types ~= composition Compose well

Slide 12

Slide 12 text

Ok fancy types, but all inputs are string Validate user input => Strong typing Strong typing => enforces validation A type can be a permission to do something

Slide 13

Slide 13 text

Tic Tac Toe placeMark : (freePos: List Pos) -> Pos-> List Pos vs
 
 placeMark : (freePos: Vect (S n) Pos) // available positions, (S n) means n+1 
 -> (p: Pos) // position to be marked
 -> (Elem p freePos) // proof that position p is in freePos
 -> Vect n Pos // remaining positions, 1 less than input

Slide 14

Slide 14 text

TypeDD ~ TestDD

Slide 15

Slide 15 text

Fast feedback? Dynamic No compilation Can hack Static All branches Type mistakes Autocomplete

Slide 16

Slide 16 text

Recursive types

Slide 17

Slide 17 text

Sometimes the types are clean But not the code

Slide 18

Slide 18 text

Conclusions ! Types are proofs ! Compilers ~ tests ! Small types ! Qualified types <=> encoded knowledge ! Feedback ! Compilers will evolve