This document discusses parametricity and how types are useful in Clojure. It explains how parametricity prevents "fast and loose reasoning" and provides several examples of functions annotated with types to demonstrate theorems about their behavior. It also discusses escape hatches that can break parametricity as well as property-based testing to check functions when types alone are not sufficient. The key takeaways are that types can improve code quality, comments using types aid comprehension, and to write property tests before unit tests.

1. Parametricity
or why types are useful
#cljsyd - May, 2015
Leonardo Borges
@leonardo_borges
www.atlassian.com
www.leonardoborges.com

2. Here’s the plan
‣ Parametricity and Fast and loose reasoning
‣ Breaking parametricity
‣ Property-based tests

3. (ann irrelevant (All [x] [(Seq x) -> (Seq x)]))
(defn irrelevant [xs]
xs)

4. Theorem
Every element A in the result sequence appears in the input.
(ann irrelevant (All [x] [(Seq x) -> (Seq x)]))
(defn irrelevant [xs]
xs)

5. (ann irrelevant (All [a b] [a -> b]))
(defn irrelevant [a]
(irrelevant a))

6. Theorem
This function never returns because if it did, it would never have compiled
(ann irrelevant (All [a b] [a -> b]))
(defn irrelevant [a]
(irrelevant a))

7. (ann even? [Number -> Boolean])
(defn even? [p]
(= (mod p 2) 0))

8. Theorem
The even function returns either true or false
(ann even? [Number -> Boolean])
(defn even? [p]
(= (mod p 2) 0))

9. Escape hatches
‣ null (actually not an issue in core.typed)
‣ exceptions
‣ Type-casing (isInstanceOf)
‣ Type-casting (asInstanceOf)
‣ Side-effects
‣ equals/toString/hashCode
‣ notify/wait
‣ classOf/.getClass
‣ General recursion

10. Escape hatches
‣ null (actually not an issue in core.typed)
‣ exceptions
‣ Type-casing (isInstanceOf)
‣ Type-casting (asInstanceOf)
‣ Side-effects
‣ equals/toString/hashCode
‣ notify/wait
‣ classOf/.getClass
‣ General recursion

11. Theorem
Every element A in the result sequence appears in the input.
(ann irrelevant (All [x] [(Seq x) -> (Seq x)]))
(defn irrelevant [xs]
nil)

12. Theorem
Every element A in the result sequence appears in the input.
(ann irrelevant (All [x] [(Seq x) -> (Seq x)]))
(defn irrelevant [xs]
nil)
Doesn’t compile with core.typed!

13. Theorem
This function ignores its argument and consistently returns either true or false
(ann irrelevant (All [a] [a -> Boolean]))
(defn irrelevant [a]
(or (instance? Long 1)
(and (instance? String a)
(< (count a) 10))))

14. Theorem
This function ignores its argument and consistently returns either true or false
(ann irrelevant (All [a] [a -> Boolean]))
(defn irrelevant [a]
(or (instance? Long 1)
(and (instance? String a)
(< (count a) 10))))

15. Theorem
Every A element in the result list appears in the input list
(ann irrelevant (All [x] [(Seq x) -> (Seq x)]))
(defn irrelevant [xs]
(cons (cast "abc" 'x) xs))

16. Theorem
Every A element in the result list appears in the input list
(ann irrelevant (All [x] [(Seq x) -> (Seq x)]))
(defn irrelevant [xs]
(cons (cast "abc" 'x) xs))
Doesn’t compile with core.typed!

17. Theorem
This function only ever does one thing —return its argument
(ann irrelevant (All [a] [a -> a]))
(defn irrelevant [x]
(prn "hi")
x)

18. Theorem
This function only ever does one thing —return its argument
(ann irrelevant (All [a] [a -> a]))
(defn irrelevant [x]
(prn "hi")
x)

19. Theorem
This function ignores its argument to return one of 2^32 values.
(ann irrelevant (All [a] [a -> Int]))
(defn irrelevant [x]
(-> x
str
(.length)))

20. Theorem
This function ignores its argument to return one of 2^32 values.
(ann irrelevant (All [a] [a -> Int]))
(defn irrelevant [x]
(-> x
str
(.length)))

21. Theorem
This function always returns Nil and so cannot possibly reverse the list
(ann reverse (All [a b] [(Seq a) -> (Seq b)]))
(defn reverse [as]
(reduce (fn [acc a]
(conj acc (cast b a))) nil as))

22. Theorem
This function always returns Nil and so cannot possibly reverse the list
(ann reverse (All [a b] [(Seq a) -> (Seq b)]))
(defn reverse [as]
(reduce (fn [acc a]
(conj acc (cast b a))) nil as))
Doesn’t compile with core.typed!

23. Escape hatches
‣ null (actually not an issue in core.typed)
‣ exceptions
‣ Type-casing (isInstanceOf)
‣ Type-casting (asInstanceOf)
‣ Side-effects
‣ equals/toString/hashCode
‣ notify/wait
‣ classOf/.getClass
‣ General recursion

24. [2] http://www.cse.chalmers.se/~nad/publications/danielsson-et-al-popl2006.pdf
[1] http://ttic.uchicago.edu/~dreyer/course/papers/wadler.pdf
Where does this thinking come from?
‣ Theorems for Free, Philip Wadler [1]
‣ Fast and Loose reasoning is Morally correct, John Hughes et al. [2]

25. Where does this thinking come from?

26. What about docstrings?

27. Example: repeat
(defn repeat
"Returns a lazy (infinite!, or length n if supplied) sequence of xs."
([x] (clojure.lang.Repeat/create x))
([n x] (clojure.lang.Repeat/create n x)))

28. Example: repeat
(defn repeat
"Returns a lazy (infinite!, or length n if supplied) sequence of xs."
([x] (clojure.lang.Repeat/create x))
([n x] (clojure.lang.Repeat/create n x)))

29. Example: repeat
(ann repeat (All [x]
(IFn [x -> (ASeq x)]
[AnyInteger x -> (ASeq x)])))
(defn repeat
"Returns a lazy (infinite!, or length n if supplied) sequence of xs."
([x] (clojure.lang.Repeat/create x))
([n x] (clojure.lang.Repeat/create n x)))

30. Example: iterate
(ann iterate (All [x]
[[x -> x] x -> (ASeq x)]))
(defn iterate
"Returns a lazy sequence of x, (f x), (f (f x)) etc. f must be free of
side-effects"
[f x] (clojure.lang.Iterate/create f x) )

31. Example: iterate
(ann iterate (All [x]
[[x -> x] x -> (ASeq x)]))
(defn iterate
"Returns a lazy sequence of x, (f x), (f (f x)) etc. f must be free of
side-effects"
[f x] (clojure.lang.Iterate/create f x) )

32. Example: iterate
(ann iterate (All [x]
[[x -> x] x -> (ASeq x)]))
(defn iterate
"Returns a lazy sequence of x, (f x), (f (f x)) etc. f must be free of
side-effects"
[f x] (clojure.lang.Iterate/create f x) )

33. Some other core.typed niceties
(ann underage? [(HMap :mandatory {:name String
:age Num}) -> Boolean])
(defn underage? [p]
(< (:age p) 18))

34. Some other core.typed niceties
(t/defalias Person (HMap :mandatory {:name String
:age Num}))
(ann underage? [Person -> Boolean])
(defn underage? [p]
(< (:age p) 18))

35. Some other core.typed niceties
(underage? {:age 32})
Type error:
Domains:
Person
Arguments:
(t/HMap :mandatory {:age (t/Val 17)} :complete? true)
Ranges:
java.lang.Boolean

36. Some other core.typed niceties
(underage? {:name "Leo" :age 32})

37. So types can check everything, right?

38. So types can check everything, right?
nope

39. Property based testing
(ann does-not-reverse (All [a] [(Seq a) -> (Seq a)]))
(defn does-not-reverse [xs]
...)

40. Property based testing
(def does-not-reverse-prop-1
(prop/for-all [x (gen/vector gen/simple-type)]
(= (does-not-reverse (does-not-reverse x))
x)))
(def does-not-reverse-prop-2
(prop/for-all [x (gen/vector gen/simple-type)
y (gen/vector gen/simple-type)]
(= (does-not-reverse (concat x y))
(concat (does-not-reverse x)
(does-not-reverse y)))))

41. Takeaway points
‣ Don’t dismiss types too quickly. They can improve code comprehension
and quality
‣ Even comments expressed in terms of types can be a big help when
reading foreign code
‣ Write property-based tests first, unit tests second

42. Thanks
Questions?
Leonardo Borges
@leonardo_borges
www.atlassian.com
www.leonardoborges.com