Demystifying Scala Type System

Demystifying Scala
Type System
David Galichet
CTO @ CoachClub

jeudi 29 novembre 12

Schedule
Scala Types 101
Types Variance and Type bounds
Abstract Type members
Ad-Hoc Polymorphism
Existential Types
Generalized Type Constraints

What is a type system ?

“A type system is a tractable syntactic method for
proving the absence of certain program behaviors by
classifying phrases according to the kinds of values
they compute.“ – Benjamin Pierce


What is a type ?
A Type deﬁnes a set of values a variable can posses and a set
of functions that can be applied to these values
Set of values can be deﬁned as
Cartesian product Types (like case classes or Tuples)
Sum Types (like Either)
Types can be Abstract and/or Polymorph


What is a type ?

In Functional Languages like Scala, a Function is also a Type
that can be assigned to a variable or (higher order) function
or returned by a (higher order) function


Why typing ?
“Make illegal states unrepresentable“ - Yaron Minsky
“Where static typing ﬁts, do it every time because it
has just fantastic maintenance beneﬁts.” - Simon Peyton
Jones
Compiler can use Type informations to optimize compiled
code


Scala Types 101

Scala is Object Oriented and Functional
Scala has a strong and static Type System
Types are checked at compile time

Types can be inferred by the compiler

Functions are Types : A => B


Scala Types 101

Types are used to deﬁne
[abstract] classes
objects
traits


Scala Types 101 Any
⟙

Scala types hierarchy AnyVal AnyRef

Enclosed by : Primitive Types
All Types
wrappers

Top type ⟙ (Any)

Bottom type ⟘ (Nothing)
Nothing
⟘

Java Primitive Types are wrapped under AnyVal
(Unit, Long, Double, Boolean ...)
Since 2.10, you can deﬁne your own AnyVal

Scala Types 101

Scala Types can be parameterized
List[A]
Either[A, B]

Functions can also take type parameters
def show[A](a:A):String = a.toString


Type Variance and Bounds

Type Variance goal is to deﬁne inheritance relation
By default, Type Parameters are invariant
They can also be deﬁned as co-variant or contra-variant



Co-Variance(M[+T]) B M[B]

if A extends B then M[A] extends M[B] A M[A]

Contra-Variance (M[-T])
if A extends B then M[B] extends M[A]
B M[A]

A M[B]



Some examples of Types with varying type parameters
List[+A]
Writer[-A]
Function1[-T, +R]



scala> class Test[+A] {
| def test(a: A): String = a.toString
| }
<console>:8: error: covariant type A occurs in
contravariant position in type A of value a

WTF ?


First of all, take a look at Functions :
Function1[-T,+R]

Functions are Co-Variant on return type (+R) and Contra-
Variant on parameters (-T) !
We can substitute Function1[A,D] by
Function1[B,C] : B D Function1[A, D]

⋀
A C Function1[B, C]


This is a Function1 instance !
class Test[+A] {
def test(a: A): String = a.toString
}

Type A should be either Invariant or Contra-Variant but it’s
Co-Variant


Solution : introduce a bounded Type

class Test[+A] {
def test[B >: A](b: B): String = b.toString
}

Lower Type Bound : this new Type B is a super Type of A

Method test will accept A or any super Type of A

Implementation of a List
trait List[+T] {
def ::[U >: T](u: U): List[U] = Cons(u,
this)
}
case class Cons[T](head: T, tail: List[T])
extends List[T]

case object Nil extends List[Nothing]

Inherit from any List[T]

Variance is not applicable to mutable state :
trait Mutable[+T] {
var t: T // generate a setter:
// def t_=(t: T) {this.t = t}
}

Co-Variant parameter in Contra-Variant position

⇒ A mutable List can’t be Co-Variant !

Implementation of a Writer - Part1
class B { def toString = "I’m B" }
class A extends B { def toString = "I’m A" }
Inherit from any List[T]
trait Writer[-T] { def write(t: T): String }

val bWriter = new Writer[B] { def write(b:
B): String = b.toString }

def write[T](t: T)(w: Writer[T]) = w.write(t)


Implementation of a Writer - Part2
write(new B)(bWriter)
res> String = I’m B We need a Writer[A]

write(new A)(bWriter)
res> String = I’m A

B Write[A]

Fortunately, Writer[B] extends Writer[A]:
A Write[B]


Type member
Concrete Types can be deﬁned in a class, trait or object
type Color = String // type Alias
type Valid[X] = Either[Throwable, X]
// Valid is parametrized with X

We can deﬁne these types with their kind :
Color or String has kind *

Valid or Option has kind * ➞ *

Either has kind * ➞ * ➞ *

We can deﬁne Abstract Type in abstract classes or traits
Abstract Types are another way to parameterize Types
trait Food
class Grass extends Food
class Fish extends Food

trait Species {
type SuitableFood <: Food
}

trait Animal extends Species

class Cow extends Animal {
type SuitableFood = Grass
}

The parameterized type way :

trait Food

trait Species[T <: Food]
trait Animal[T <: Food] extends Species[T]

class Cow extends Animal[Grass]


Ad-Hoc Polymorphism
Ad-Hoc polymorphism is a way to add behavior to an existing
class without modifying it
In Haskell, polymorphism is achieved using typeclasses

Typeclasses

abs :: (Num a, Ord a) => a -> a
abs x = if x < 0 then -x else x


Ad-Hoc Polymorphism

In Scala, we can achieve Ad-Hoc polymorphism using
implicits
implicits are used in two places
implicit conversion to convert a type to another
implicit parameter


Ad-Hoc Polymorphism
In Scala, we can achieve Ad-Hoc polymorphism using
implicits
Scala library deﬁnes many Typeclasses to achieve Ad-Hoc
polymorphism : Integral, Numeric, Ordering ...
def abs[T](x: T)(implicit num: Numeric[T]): T =
if(num.lt(x, num.zero)) num.negate(x) else x

def max[T: Ordering](x: T, y: T): T =
implicitly[Ordering[T]].max(x, y)


Ad-Hoc Polymorphism
We can deﬁne our own instances of existing typeclasses
case class Student(name: String, score: Float)

implicit object StudentOrdering extends
Ordering[Student] {
def compare(x: Student, y: Student) =
x.score.compareTo(y.score)
}

scala> max(Student("Bob", 5.6F), Student("Alice",
5.8F))
res0: Student = Student(Alice,5.8)


Ad-Hoc Polymorphism
We can deﬁne our own instances of typeclasses

implicit class Printable[A](a: A) { // since Scala
2.10
def printOut(): Unit = println(a.toString)
}

scala> "test".printOut
test


Ad-Hoc Polymorphism
A more concrete example - Part 1
trait Searchable[T] {
val id: String
val indexedContent: String
}

class SearchEngine[T](defaultBuilder: String => T){
def index(searchable: Searchable[T]) { /* ... */ }
def search(query: String)(builder: String => T =
defaultBuilder): T = builder("0")
}


Ad-Hoc Polymorphism
A more concrete example - Part 2
case class Person(id: Long, name: String)

implicit def person2Searchable(p: Person) =
new Searchable[Person] {
val id = p.id.toString
val indexedContent = p.name
}

val fakeEngine = new SearchEngine[Person]( id =>
Person(id.toLong, "retrieved content") )


Ad-Hoc Polymorphism
Polymorphic Typeclasses instance deﬁnition
class Hour[X] private (val x: X) { /* ... */ }

object Hour {
def apply[X](x: X)(implicit int: Integral[X]):Hour[X]=
new Hour(int.rem(int.plus(int.rem(x,
int.fromInt(12)), int.fromInt(12)), int.fromInt(12)))
}

implicit def hour2Monoid[X](implicit int: Integral[X]):
Monoid[Hour[X]] = new Monoid[Hour[X]] {
def append(f1: Hour[X], f2: => Hour[X]) =
Hour(int.rem(int.plus(f1.x, f2.x), int.fromInt(12)))
def zero = Hour(int.zero)
}

Existential Types
Existential types are reference to type parameter that is
unknown
The Scala existential type in M[_] is the dual of Java
wildcard M<?>
They can be deﬁned using :
M[T] forSome { type T }

or M[_]

Existential Types

We can bound existential types :
M[T] forSome { type T <: AnyRef }

or M[_ <: AnyRef]


Constrain type using an implicit
=:= same type

<:< lower type

>:> super type


Example :
trait Food

trait Animal[SuitableFood <: Food] {
def fish(implicit ev: SuitableFood =:= Fish){
println("I'm fishing")
}
}

class Cow extends Animal[Grass]
class Bear extends Animal[Fish]


Demystifying Scala Type System

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (20)

More from David Galichet

More from David Galichet (6)

Recently uploaded

Recently uploaded (20)

Demystifying Scala Type System