This is the talk I gave at FunctionalConf 2016. http://functionalconf.com/

1. Dependent Types
with
Abdulsattar

2. Motivation
def first(arr) do
List.first arr
end
Points of Failure:
1. arr is not an array
2. arr is null
3. arr is empty

3. Motivation
public int first(int[] arr)
{
return arr[0];
}
Points of Failure:
1. arr is not an array
2. arr is null
3. arr is empty

4. Motivation
first :: [Int] -> Int
first arr = arr !! 0
Points of Failure:
1. arr is not an array
2. arr is null
3. arr is empty

5. Actual Requirement
arr must be an array of at least 1 length

6. Problem
first :: [Int] -> Int
first arr = arr !! 0
public int first(int[] arr)
{
return arr[0];
}
def first(arr) do
List.first arr
end
anything → anything (or runtime error)
array or null → int (or runtime error)
array → int (or runtime error)

7. Problem
Types don’t capture all the invariants

8. Dependent Types
Dependent Types allow types to depend on values.
e.g. length of a list can be part of the type of the list

9. Natural Numbers
data Nat = Z | S Nat
zero = Z
one = S Z
two = S (S Z)
…

10. Operations
plus : Nat -> Nat -> Nat
plus Z y = y
plus (S k) y = S (plus k y)
0 + y = y
(1 + x) + y = 1 + (x + y)
0 ✕ y = 0
(1 + x) ✕ y = y + (x ✕ y)
mult : Nat -> Nat -> Nat
mult Z y = Z
mult (S k) y = plus y (mult k y)

11. Vectors
data Vect : Nat -> Type -> Type where
Nil : Vect Z a
(::) : a -> Vect k a -> Vect (S k) a
zeroVect : Vect 0 Int
zeroVect = Nil
oneVect : Vect 1 Int
oneVect = 3 :: Nil
threeVect : Vect 3 String
threeVect = "I" :: "hope" :: "i'm not confusing you" :: Nil

12. Solution
first : Vect (S k) a -> a
first (x::xs) = x
Points of Failure:
1. arr is not an array
2. arr is null
3. arr is empty

13. Concatenation
(++) : Vect n a -> Vect m a -> Vect (n + m) a
(++) Nil ys = ys
(++) (x :: xs) ys = x :: xs ++ ys

14. Concatenation
(++) : Vect n a -> Vect m a -> Vect (n + m) a
(++) Nil ys = ys
(++) (x :: xs) ys = x :: xs ++ xs
Error: Expected Vect (n + m) a; Got Vect (n + n) a
* Not actual error message

15. Interactive Editing
DEMO

16. First-Class Types
A : Type
A = Int
b : A
b = 3

17. First-Class Types
A : Bool -> Type
A True = Int
A False = String
b : A True
b = 3
c : A True
c = "Idris"

18. Type-safe Printf
printf "Hello %s" "world"
printf "%d times" 1
printf "%d times" 3 3
ERROR!

19. Type-safe Printf
printf "Hello %s" "world"
printf "%d times" 1

20. Type-safe Printf
printf "Hello %s" : String -> String
printf "%d times" : Int -> String

21. Type-safe Printf
printf : (str : String) -> <Function type depending on str>

22. Type-safe Printf
printf : (str : String) -> PrintfType str

23. Type-safe Printf
printf : (str : String) -> PrintfType (toFormat (unpack str))
toFormat : List Char -> Format
PrintfType : Format -> Type

24. Type-safe Printf
data Format = Number Format
| Str Format
| Lit Char Format
| End
> toFormat (unpack "a%s")
Lit 'a' (Str End) : Format
> toFormat (unpack "%d")
Number End

25. Type-safe Printf
toFormat : (xs : List Char) -> Format
toFormat [] = End
toFormat ('%' :: 's' :: xs) = Str (toFormat xs)
toFormat ('%' :: 'd' :: xs) = Number (toFormat xs)
toFormat (x :: xs) = Lit x (toFormat xs)

26. Type-safe Printf
PrintfType : Format -> Type
PrintfType (Number fmt) = Int -> PrintfType fmt
PrintfType (Str fmt) = String -> PrintfType fmt
PrintfType (Lit x fmt) = PrintfType fmt
PrintfType End = String

27. Type-safe Printf
printf : (str : String) -> PrintfType (toFormat (unpack str))
printf str = printfFmt _ ""
where
printfFmt : (fmt : Format) -> (acc : String) -> PrintfType fmt
printfFmt (Number fmt) acc = i => printfFmt fmt (acc ++ show i)
printfFmt (Str fmt) acc = s => printfFmt fmt (acc ++ s)
printfFmt (Lit x fmt) acc = printfFmt fmt (acc ++ (singleton x))
printfFmt End acc = acc

28. Type-safe File Handles
DEMO

29. Even Numbers
data Even : Nat -> Type where
EZ : Even Z
ES : Even k -> Even (S (S k))
zeroIsEven : Even 0
zeroIsEven = EZ
twoIsEven : Even 2
twoIsEven = ES EZ

30. Proofs
Theorem: 4 is even
0 is even
0 + 2 is even
(0 + 2) + 2 is even
fourIsEven : Even 4
fourIsEven = ES (ES EZ)
Idris

31. Curry Howard Correspondence
Theorems correspond to Types
Proofs correspond to Programs

32. Equality
data (=) : a -> b -> Type where
Refl : x = x
twoIsTwo : 2 = 2
twoIsTwo = Refl
3Plus2IsFive : 3 + 2 = 5
3Plus2IsFive = Refl

33. Falsity or the Empty Type
twoPlusTwoIsNotFive : 2 + 2 = 5 -> Void
twoPlusTwoIsNotFive Refl impossible
data Void : Type where

34. Takeaway
Make illegal state unrepresentable

35. Thank You!
Abdulsattar
asattar.md@gmail.com