A gentle introduction to Type Classes made for an internal Wealthfront Tech Talk.

1. Type Classes
Wealthfront Engineering

2. Type Class
Type system construct that supports ad-hoc
polymorphism, achieved by adding constraints
to type variables in parametrically
polymorphic types

3. Type Class
Type system construct that supports ad-hoc
polymorphism, achieved by adding constraints
to type variables in parametrically
polymorphic types

4. Type Class
Type system construct that supports ad-hoc
polymorphism, achieved by adding constraints
to type variables in parametrically
polymorphic types

5. Type Class
Type system construct that supports ad-hoc
polymorphism, achieved by adding constraints
to type variables in parametrically
polymorphic types

6. Type Class
Type system construct that supports ad-hoc
polymorphism, achieved by adding constraints
to type variables in parametrically
polymorphic types

7. pol•y•mor•phism ¦ päli môr fizəm¦
nounthe occurrence of something in several
different forms
New Oxford American Dictionary

8. In particular:
Polymorphism is a programming language
feature that allows values of different data
types to be handled using a uniform interface

9. Several Types of Polymorphism
• Ad-hoc polymorphism
• Inclusion polymorphism
• Parametric polymorphism
• Bounded parametric polymorphism

10. Several Types of Polymorphism
• Ad-hoc polymorphism
– Operator and method overloading
• Inclusion polymorphism
• Parametric polymorphism
• Bounded parametric polymorphism

11. Several Types of Polymorphism
• Ad-hoc polymorphism
• Inclusion polymorphism
– Subtyping
• Parametric polymorphism
• Bounded parametric polymorphism

12. Several Types of Polymorphism
• Ad-hoc polymorphism
• Inclusion polymorphism
• Parametric polymorphism
– Generics
• Bounded parametric polymorphism

13. Several Types of Polymorphism
• Ad-hoc polymorphism
• Inclusion polymorphism
• Parametric polymorphism
• Bounded parametric polymorphism
– Generics with bounded wildcards

14. Ad-hoc polymorphism
Control moving through one named function is
dispatched to various other functions without
having to specify the exact function being
called

15. Ad-hoc polymorphism
String greet() {
return "Hello, World!";
}

16. Ad-hoc polymorphism
String greet(String name) {
return "Hello," + name + "!";
}

17. Ad-hoc polymorphism
String greet(int count) {
return "Hello, World" + repeat("!", count);
}

18. Ad-hoc polymorphism
> greet();
Hello, World!
> greet("Wealthfront");
Hello, Wealthfront!
> greet(3);
Hello, World!!!

19. Parametric polymorphism
A function or a data type can be written
generically so that it can handle values
identically without depending on their type

20. Parametric polymorphism
size :: a . [a] → int
size [] = 0
size (x:xs) = 1 + size xs

21. Parametric polymorphism
> size [1, 2]
2
> size ["hello", "hi", "yo"]
3

22. Bounded parametric polymorphism
A function or a data type require some
knowledge of its data types but can otherwise
work parametrically

23. Bounded parametric polymorphism
<T extends Comparable<T>> List<T> sort(List<T> list) {
return …
}

24. Type Class
Type system construct that supports ad-hoc
polymorphism, achieved by adding constraints
to type variables in parametrically
polymorphic types

25. Type Class
Type system construct that supports ad-hoc
polymorphism, achieved by adding constraints
to type variables in parametrically
polymorphic types

26. Type Class
Type system construct that supports ad-hoc
polymorphism, achieved by adding constraints
to type variables in parametrically
polymorphic types

27. Type Class
Type system construct that supports ad-hoc
polymorphism, achieved by adding constraints
to type variables in parametrically
polymorphic types

28. Type Class Eq
class Eq a where
eq :: a → a → bool
ne :: a → a → bool

29. Implementation for int
instance Eq int where
eq m n = m == n
ne m n = m != n

30. Implementation for Instrument
instance Eq Instrument where
eq x {id = xid} y {id = yid} = xid == yid
ne x {id = xid} y {id = yid} = xid != yid

31. Usage
member :: (Eq a) ⇒ a → [a] → bool
member y [] = false
member y (x:xs) = (eq x y) || member y xs

32. Ad-hoc polymorphism
member :: (Eq a) ⇒ a → [a] → bool
member y [] = false
member y (x:xs) = (eq x y) || member y xs

33. Parametric polymorphism
member :: (Eq a) ⇒ a → [a] → bool
member y [] = false
member y (x:xs) = (eq x y) || member y xs

34. Constraint on type variable
member :: (Eq a) ⇒ a → [a] → bool
member y [] = false
member y (x:xs) = (eq x y) || member y xs

35. Type Classes vs. Interfaces?
Similar, yet different:
• Implementation is separate
• Subtyping is not entailed
• Static dispatch (ad-hoc polymorphism) vs.
dynamic single dispatch

36. Return type-based dispatch
foo :: (Parseable a) ⇒ a → String → a
foo x s = x + parse s

37. Return type-based dispatch
> foo "Hello, " "World!"
Hello, World!
> foo 2 "3"
5

38. Return type-based dispatch
class String implements Parseable {
String parse() {
return this;
}
int parse() {
return Integer.parseInt(this);
}
}

39. Type Class in Scala
trait Parseable[T] {
def parse(s: String): T
}

40. Implementation in Scala for Int
implicit object ParseableInt extends Parseable[Int] {
def parse(s: String) = Integer.parseInt(s)
}

41. Usage in Scala
def foo[T: Parseable](t: T, s: String): T =
t + implicitly[Parseable[T]].parse(s)

42. Usage in Scala
> foo("Hello, ", "World!");
Hello, World! : String
> foo(2, "3");
5 : Int

43. Usage in Scala
def foo[T: Parseable](s: String): T =
implicitly[Parseable[T]].parse(s)

44. Usage in Scala
> "Hello, " + foo("World!");
Hello, World! : String
> 2 + foo("3");
5 : Int
> foo[Int]("3");
3 : Int

45. The End
FYI, Monad is a Type Class.