scala type classes: basics and more

Type Classes: Basics and More

Sukant Hajra

April 10, 2015

Sukant Hajra Type Classes: Basics and More April 10, 2015 1 / 36

Outline

1 Introduction

2 Motivation by Examples

3 Encoding type classes in Scala

4 A Glance at Scalaz (Scaladoc, Demo)

5 Wrap-up


Section 1

Introduction


A show of hands

How many of you are very new to type classes?

This talk is yours, so interrupt and participate!


Some background

Type classes

come from Haskell

use the word �class� di�erently from OO languages

started o� a way to improve ad hoc polymorphism

evolved into a modular way to abstract invariants/contracts.


Types of polymorphism

parametric polymorphism (generics)

Foo[A]

subtype polymorphism

Foo extends Bar

ad hoc polymorphism (overloading)

def baz(foo: Foo): Baz

def baz(bar: Bar): Baz


Section 2

Motivation by Examples


Before we start with examples

Don't get caught up in the details

We'll cover details in a later section


Problem: ad hoc polymorphism

given

def size(foo: Foo): Int

def size(bar: Bar): Int

hard to generalize/extend, have to continue overloading

def size_doubled(foo: Foo) = size(foo: Foo) * 2

def size_doubled(bar: Bar) = size(bar: Bar) * 2

or maybe use a sum type like Either

def size_doubled(fooOrBar: Either[Foo, Bar]) =

fooOrBar.fold(size(_), size(_)) * 2


Solving with type classes: ad hoc polymorphism

we have an interface

trait HasSize[A] { def size(a: A): Int }

which we can use as a constraint

def sizeDoubled[A : HasSize](a: A) =

HasSize[A].size(a) * 2

but only if we have instances

implicit val fooHasSize: HasSize[Foo] =

new HasSize[Foo] { def size(f: Foo) = f.size }

implicit val barHasSize: HasSize[Bar] =

new HasSize[Bar] { def size(b: Bar) = b.size }

Note the nice separation of concerns.


type classes catch errors statically

given

case class Foo(size: Int)

case class Bar(size: Int)

Example (using HasSize)

scala> sizeDoubled(Foo(5))

res0: Int = 5

scala> sizeDoubled(Bar(3))

res0: Int = 3

scala> sizeDoubled("wat?")

<console>:25: error: could not find implicit value for

evidence parameter of type HasSize[String]

sizeDoubled("wat?")

^


Nicer error messages

Using @implicitNotFound on the type class interface

@annotation.implicitNotFound(

"instance of type class HasSize not found: ${A}")

trait HasSize[A] { def size(a: A): Int }

Example (we can get more human-friendly messages)

scala> sizeDoubled("wat?")

<console>:14: error: instance of type class HasSize

not found: String

sizeDoubled("wat?")

^


Problem: equality

A typical equals

class This {

override def equals(that: Any): Boolean =

if (! that.isInstanceOf[This])

false

else

...

}

leads to obligatory boilerplate

the compiler should sometimes prevent equality comparison


Solving with type classes: equality


trait Equal[A] { def eq(a1: A, a2: A): Boolean }


def member[A : Equal](as: List[A], a: A) =

as.foldLeft(false) { _ || Equal[A].eq(_, a) }

but only if we have instances

implicit val fooEqual: Equal[Foo] =

new Equal[Foo] {

def eq(f1: Foo, f2: Foo) = f1.x == f2.x

}


Using type classes for type enrichment

EqualOps.scala

implicit class EqualOps[A : Equal](a1: A) {

def ===(a2: A): Boolean = Equal[A].eq(a1, a2)

}

implicit vals/defs for type class instances

implicit classes for type enrichment


Type class equality is safer

Example (Using the equality type class)

scala> new Foo(1) == new Foo(1)

res0: Boolean = false

scala> new Foo(1) == "wat?"

res1: Boolean = false

scala> new Foo(1) === new Foo(1)

res2: Boolean = true

scala> new Foo(1) === "wat?"

<console>:24: error: type mismatch;

found : String("wat?")

required: Foo

new Foo(1) === "wat?"


Example: Monoid


trait Monoid[A] {

def mappend(a1: A, a2: A): A

def mempty: A

}


def empty[A : Monoid]: A = Monoid[A].mempty

implicit class MonoidOps[A : Monoid](a1: A) {

def |+|(a2: A): A = Monoid[A].mappend(a1, a2)

}


Monoid instances

here's some monoid instances

implicit val stringMonoid: Monoid[String] =

new Monoid[String] {

def mappend(s1: String, s2: String) = s1 + s2

def mempty = ""

}

implicit def pairMonoid[A : Monoid, B : Monoid]

: Monoid[(A, B)] =

new Monoid[(A, B)] {

def mappend(p1: (A, B), p2: (A, B)) =

(p1._1 |+| p2._1, p1._2 |+| p2._2)

def mempty = (empty[A], empty[B])

}


Automatic derivation

Example (Using the equality type class)

scala> "a" |+| "1"

res0: String = a1

scala> ("a", "b") |+| ("1", "2")

res1: (String, String) = (a1,b2)

scala> ("a", ("b", "c")) |+| ("1", ("2", "3"))

res2: (String, (String, String)) = (a1,(b2,c3))

scala> empty[String]

res3: String = ""

scala> empty[(String, (String, String))]

res4: (String, (String, String)) = ("", ("", ""))


Relation to objects

dispatch of interfaces (though static, not dynamic)

same principles, but more

single responsibilityopen/close principleinterface segregationstrong contracts


Lawful type classes: strong contracts

Equality Laws

For all a, b, and c of any type with an Equal constrant

Re�exivity: eq(a, a)

Symmetry: eq(a, b) ≡ eq(b, a)

Transitivity: eq(a, b) ∧ eq(b, c) ≡ eq(a, c)

Monoid Laws

For all a, b, and c of any type with a Monoid constrant

Left Identity: mappend(mempty , a) ≡ a

Right Identity: mappend(a,mempty) ≡ a

Associativity:mappend(a,mappend(b, c)) ≡ mappend(mappend(a, b), c)


What a type class is

De�nition (Type Class)

A type class is a constraint/interface that can be speci�ed on a typesignature for a parametric type. At the call site, the correspondinginstance/implementation is statically (at compile-time) derived, provided,and guaranteed to always be the same.

Ideally

Type classes should be lawful.


Example: Functor


trait Functor[F[_]] {

def fmap[A](fa: F[A], f: A=>B): F[B]

}

with the following laws

Identity: fmap(fa, identity) ≡ fa

Composition: fmap(fa, a andThen b) ≡ fmap(fmap(fa, a), b)


Is this a good type class?

type class for an isomorphism

trait Iso[A, B] {

def to(a: A): B

def from(b: B): A

}

it has laws

to(from(b)) ≡ bfrom(to(a)) ≡ a

but is it going to be unique?


Summary of type class bene�ts

an improved alternative to ad hoc polymorphism

nicely externally extensible (separation of concerns)

automatic derivation of type class instances

strong invariants with lawful type classes


Section 3

Encoding type classes in Scala


Uses and abuses of implicits

Good usage:

type enrichment

type class encoding

Easily abused usage:

type conversion (beyond scope, but basically an implicit function)

Terrible usage:

dependency injection framework encoding


Implicits, illustrated

In Scala, we encode type classes with implicits, so let's cover those �rst.

Example (implicits in Scala)

scala> case class Foo(name: String)

scala> implicit val defaultFoo = Foo("default")

scala> def fooPair(i: Int)(implicit foo: Foo) = (i, foo)

scala> fooPair(3)

res0: (Int, Foo) = (3,Foo(default))

The implicit parameter doesn't need an argument explicitly passed if a valuefor the type has been implicitly de�ned and can be found by the compiler.


Implicit extras

useful, and in the standard library

def implicitly[A](implicit a: A): A = a

context bound syntax sugar; these are the same

def foo[A](implicit ev: TC[A]) = ...

def foo[A : TC] = {

val ev = implicitly[TC[A]]

...

}


Implicit extra extras

using implicitly with context bounds is tedious

def foo[A : HasSize] = {

... implicitly[HasSize[A]].size ...

}

we can get better syntax

def foo[A : HasSize] = {

... HasSize[A].size ...

}

with an apply method on the type class's companion object

object HasSize {

def apply[A](implicit ev: HasSize[A]): HasSize[A] = ev

}


Implicit scope resolution for type class encoding

Implicit scope resolution is kind of complex.

For type class instances keep it simple and put them in

companion objects of the types you controlpackage objects for types you don't control

When searching for an implicit A[B], companion objects for both A

and B will be searched.

Remember to have one and only one instance to �nd (otherwise you'renot encoding a proper type class!)


Example encoding with companion objects

HasSize.scala

trait HasSize[A] { def size[A](a: A): Int }

object HasSize {

@inline

def apply[A](implicit ev: HasSize[A]): HasSize[A] = ev

implicit def listHasSize[A]: HasSize[List[A]] =

new HasSize[List[A]] { def size(l: List[A]) = l.size }

}

Foo.scala

case class Foo(size: Int)

object Foo {

implicit val hasSize: HasSize[Foo] =

new HasSize[Foo] { def size(f: Foo) = f.size }

}


Example encoding with package objects

Instances.scala

trait Instances {

implicit def listHasSize[A]: HasSize[List[A]] =

new HasSize[List[A]] { def size(l: List[A]) = l.size }

}

object Instances extends Instances

package.scala

package object myproject extends Instances

useful when you control neither the type class nor the data type

to avoid compilation complexity, some people never put instances ontype class companion objects (just the data type)


Section 4

A Glance at Scalaz (Scaladoc, Demo)


Section 5

Wrap-up


Thanks!

Any questions? Comments?

References

Wadler, Blott, How to make ad-hoc polymorphism less ad hoc

Hudak, Hughes, Jones, Wadler, A History of Haskell: Being Lazy With

Class

Kmett, Type Classes vs. the World,https://youtu.be/hIZxTQP1ifo

Yang, Type classes: con�uence, coherence, and global uniqueness

Jones, Jones, Meijer, Type classes: an exploration of the design space


https://youtu.be/hIZxTQP1ifo

scala type classes: basics and more

Software