This document provides an introduction to typeclasses in Scala and functional programming. It defines typeclasses as a way to define functions that can have different implementations depending on the type of data. The document then gives examples of using typeclasses for serialization and numeric operations. It discusses how typeclasses relate to category theory and how higher kinded types allow generalizing over type constructors. Pros of typeclasses are given as decoupling functionality from types and extensibility, while a potential con is increased code complexity.

1. Introduction to Typeclasses
2015-06-05 | Egemen Kalyoncu | Amsterdam

2. Agenda
● What is typeclass?
● Example
● Category Theory
● Example
● Higher Kinded Types
● Example
● Pros/Cons

3. Type Classes
“Typeclasses define a set of functions that can
have different implementations depending on the
type of data they are given” Real World Haskell
“In computer science, a type class is a type
system construct that supports ad-hoc
polymorphism.” Wikipedia

4. Type Classes
In Haskell, typeclass is the language
feature. Every class is a typeclass.
In Scala, typeclass is a pattern.

5. What isn’t Typeclass?
● It’s not only about FP. You can use it in OOP
as well.
● It’s not only about category theory.

6. Typeclass

7. Typeclass
● scala.math.Ordering
● scala.math.Numeric
● scalaz._
● spray.json._

8. Polymorphism
● Subtype polymorphism
● Parametric polymorphism (generics)
● Ad-hoc polymorphism (decoupling)

9. Serialization Example
class Ad(id: Int, title: String)
class User(id: Int, name: String)
Let’s implement serialization of these
classes.

10. Serialization Example (subtyping)

11. Serialization Example (subtyping)
trait Serializable { def serialize: String }
def doSerialize(in: Serializable)= in.serialize
class Ad extends Serializable {
def serialize: String = "serialized ad"
}
class User extends Serializable {
def serialize: String = "serialized user"
}

12. Serialization Example (typeclass)
trait Serializable[A] { def serialize(a: A): String }
def doSerialize[A](a: A, ser: Serializable[A]) =
ser.serialize(a)

13. Serialization Example (typeclass)
trait Serializable[A] { def serialize(a: A): String }
def doSerialize[A](a: A)(implicit ser: Serializable[A]) =
ser.serialize(a)

14. Serialization Example (typeclass)
object Serializable {
implicit val adSerializable: Serializable[Ad] =
new Serializable[Ad] {
def serialize(ad: Ad) = "serialized ad"
}
implicit val userSerializable: Serializable[User] =
new Serializable[User] {
def serialize(user: User) = "serialized user"
}
}

15. Serialization Example (typeclass)
scala> doSerialize(new Ad(1, "title1"))
res0: String = serialized ad
scala> doSerialize(new User(1, "user1"))
res1: String = serialized user
scala> doSerialize("bla")
<console>:11: error: could not find implicit value for parameter ser:
Serializable[String]
doSerialize("bla")

16. Category Theory
● Branch of mathematics
● Study of concepts(collection of objects)
and arrows(morphism)
● Functional design patterns in
programming
● Categories have properties and laws
● Categories can be types, cats, cars, …

17. Category Theory
arrow : function, map, morphism,
transformation, operator

18. Category Theory
trait Functor[F[_]] {
def map[A, B](fa: F[A])(f: A => B): F[B]
}

19. Category Theory
● Abstraction is useful but...
● Don’t forget social aspect of
programming
● Check if everybody is comfortable with
these advanced techniques.

20. How to sum
def sum(l: List[Int]): Int

21. How to sum
def sum(l: List[Int]): Int = l.reduce(_ + _)

22. How to sum
It looks like working. Except empty list.

23. How to sum
What about List[Double]?

24. How to sum
def sumDouble(l: List[Double]): Double = l.reduce(_ + _)

25. How to sum
def sumNumeric[A](l: List[A])(implicit A: Numeric[A]): A =
l.reduce(A.plus)

26. How to sum
What about List[String] or List[A]?

27. Let’s make it generic!
We need a typeclass to sum any type of A

28. How to sum
trait Addable[A] {
def plus(x: A, y: A): A
}

29. How to sum
object Addable {
implicit def numericAddable[A](implicit A: Numeric[A]): Addable[A] =
new Addable[A] {
def plus(x: A, y: A): A = A.plus(x, y)
}
implicit val stringAddable: Addable[String] =
new Addable[String] {
def plus(x: String, y: String): String = x + y
}
}

30. How to sum
def sumGeneric[A](l: List[A])(implicit A: Addable[A]): A =
l.reduce(A.plus)

31. How to sum
trait AddableWithZero[A] extends Addable[A] { def zero: A }
object AddableWithZero {
implicit def numericAddableZero[A](implicit A: Numeric[A]): AddableWithZero[A] =
new AddableWithZero[A] {
def plus(x: A, y: A): A = A.plus(x, y)
def zero: A = A.zero
}
implicit val stringAddableZero: AddableWithZero[String] =
new AddableWithZero[String] {
def plus(x: String, y: String): String = x + y
def zero: String = ""
}
}

32. How to sum
def sumGeneric[A](l: List[A])(implicit A: AddableWithZero[A]): A
= l.foldLeft(A.zero)(A.plus)

33. Semigroup and Monoid
● Abstract algebra
● Addable => Semigroup
● AddableWithZero => Monoid

34. Semigroup
trait Semigroup[A] {
def append(a: A, b: A): A
}
● Simple typeclass
● Law: Associativity
o append(a1, append(a2, a3) == append(append(a1, a2), a3)

35. Monoid
trait Monoid[A] extends Semigroup[A] {
def zero : A
}
● Identity element on top of semigroup
● Laws: Identity law
o zero append a == a
o a append zero == a

36. How to sum with Scalaz
import scalaz.Monoid
def sumGeneric[A](l: List[A])(implicit A: Monoid[A]): A =
l.foldLeft(A.zero)((x, y) => A.append(x, y))

37. Higher Kinded Types
● HKT gives us the ability to
generalize across type constructors
● Reduces code duplication
● parser combinators, DSL,
comprehensions are written using HKT

38. Higher Kinded Types

39. Higher Kinded Types
import scalaz.Monoid
def sumGeneric[A](l: List[A])(implicit A: Monoid[A]): A =
l.foldLeft(A.zero)((x, y) => A.append(x, y))
What if we want to sum over Vector, Tree or Map?

40. Higher Kinded Types
trait Foldable[F[_]] {
def fold[M](fa: F[M])(implicit M: Monoid[M]): M
}
object Foldable {
implicit val listFoldable: Foldable[List] =
new Foldable[List] {
def fold[M](fa: List[M])(implicit M: Monoid[M]): M =
fa.foldLeft(M.zero)((acc, elem) => M.append(acc, elem))
}
}

41. Higher Kinded Types
def sumGeneric2[F[_], A](fa: F[A])(implicit F: Foldable[F], A: Monoid[A]): A =
F.fold(fa)

42. Pros
● Unlike subtype polymorphism, type classes
work at compile time.
● Decouple functionality from types
● Extensible

43. Cons
● code complexity?
● performance penalty?
http://stackoverflow.com/questions/9327465/what-is-the-performance-impact-of-using-the-type-class-pattern-in-scala

44. References
● http://eed3si9n.com/learning-scalaz/polymorphism.html
● https://speakerdeck.com/marakana/ne-scala-2012-the-typeclass-pattern-an-alternative-to-inheritance
● http://typelevel.org/blog/2013/10/13/towards-scalaz-1.html
● http://typelevel.org/blog/2013/12/15/towards-scalaz-2.html
● https://www.haskell.org/tutorial/classes.html
● Scala in Depth
● Programming Scala 2nd Edition
● Generics of a Higher Kind - Adriaan Moors, Frank Piessens, and Martin Odersky