Type Classes

Type Classes

Wealthfront Engineering

Type Class

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

pol•y•mor•phism ¦ päli môr ﬁzəm¦

nounthe occurrence of something in several
different forms

New Oxford American Dictionary

In particular:

Polymorphism is a programming language
feature that allows values of different data
types to be handled using a uniform interface

Several Types of Polymorphism

•  Ad-hoc polymorphism
•  Inclusion polymorphism
•  Parametric polymorphism
•  Bounded parametric polymorphism


–  Operator and method overloading


–  Subtyping


–  Generics


–  Generics with bounded wildcards

Ad-hoc polymorphism

Control moving through one named function is
dispatched to various other functions without
having to specify the exact function being
called

Ad-hoc polymorphism

String greet() {
return "Hello, World!";
}

Ad-hoc polymorphism

String greet(String name) {
return "Hello," + name + "!";
}

Ad-hoc polymorphism

String greet(int count) {
return "Hello, World" + repeat("!", count);
}

Ad-hoc polymorphism

> greet();
Hello, World!
> greet("Wealthfront");
Hello, Wealthfront!
> greet(3);
Hello, World!!!

Parametric polymorphism

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


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


> size [1, 2]
2
> size ["hello", "hi", "yo"]
3

Bounded parametric polymorphism

A function or a data type require some
knowledge of its data types but can otherwise
work parametrically

Bounded parametric polymorphism

<T extends Comparable<T>> List<T> sort(List<T> list) {
return …
}

Type Class Eq

class Eq a where
eq :: a → a → bool
ne :: a → a → bool

Implementation for int

instance Eq int where
eq m n = m == n
ne m n = m != n

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

Usage

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

Ad-hoc polymorphism

member y [] = false


member y [] = false

Constraint on type variable

member y [] = false

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

Return type-based dispatch

foo :: (Parseable a) ⇒ a → String → a
foo x s = x + parse s


> foo "Hello, " "World!"
Hello, World!
> foo 2 "3"
5

class String implements Parseable {
String parse() {
return this;
}
int parse() {
return Integer.parseInt(this);
}
}

Type Class in Scala

trait Parseable[T] {
def parse(s: String): T
}

Implementation in Scala for Int

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

Usage in Scala

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

Usage in Scala

> foo("Hello, ", "World!");
Hello, World! : String
> foo(2, "3");
5 : Int

Usage in Scala

def foo[T: Parseable](s: String): T =
implicitly[Parseable[T]].parse(s)

Usage in Scala

> "Hello, " + foo("World!");
Hello, World! : String
> 2 + foo("3");
5 : Int
> foo[Int]("3");
3 : Int

The End

FYI, Monad is a Type Class.

Type Classes

More Related Content

What's hot (19)

Similar to Type Classes (20)

Recently uploaded (20)

Type Classes