# What is a Typeclass

first appeared in Haskell
form of ad-hoc polymorphism
- Philip Wadler and Stephen Blott:
  How to make ad-hoc polymorphism less ad hoc
allows implementing an interface for possibly unrelated types
existing code doesn't have to be modified when adding new data types or implementing functionality for new types
Typeclasses in Scala: a pattern, not a language feature

# Using Typeclasses

Scala standard lib defines some Typeclasses along with instances for common types, e.g. Ordering[T]

 // simplified
trait Ordering[T] {
  def compare(x: T, y: T): Int
}

we can implement instances of a typeclass for
- our own types
- third-party types
- and have multiple/different implementations per type

# Implementing Ordering[T] for Cat

 case class Cat(name: String, age: Int)
 
implicit val catOrdering: Ordering[Cat] = new Ordering[Cat] {
  override def compare(x: Cat, y: Cat): Int = x.age - y.age
}

 val unsortedCats = List(Cat("a", 3), Cat("b", 1), Cat("c", 7))
val sortedCats   = unsortedCats.sorted(catOrdering)
 
// sorted takes an implicit ord: Ordering[B] so we could actually write
val alsoSortedCats = unsortedCats.sorted

# Defining Typeclasses

The full Typeclass pattern includes
- the Typeclass itself: interface (trait) with type parameter
- Typeclass instances
- interface to use the Typeclass
- enriched interfaces

:: Example ::

Describable[T]

# Describable[T]

Describable[T] provides a single method `describe` that returns an informal description of T
Goal:

 // unrelated data types
case class Cat(name: String, age: Int)
case class Coffee(name: String, origin: String)
 
val garfield = Cat("Garfield", 3)
val coffee   = Coffee("Yirgacheffe", "Ethiopia")
 
println(garfield.describe)
// Cats: Furry rulers of the world. This one is named Garfield.
 
println(Describable[Coffee].describe(coffee))
// Coffee: Beans of Life. This one is from Ethiopia.

# The Typeclass Interface

interface/trait that takes a type parameter

 trait Describable[T] {
  def describe(t: T): String
}

# Typeclass Instances

works, but not very useful yet
- explicitly select instance
- not better than writing describeCat, describeCoffee,... methods

 val catDescribable: Describable[Cat] = new Describable[Cat] {
  override def describe(c: Cat): String = 
    s"Cats: Furry rulers of the world. This one is named ${c.name}"
}
 
val coffeeDescribable: Describable[Coffee] = new Describable[Coffee] {
  override def describe(c: Coffee): String = 
    s"Coffee: Beans of Life. This one is from ${c.origin}"
}
 
val cat    = Cat(...)
val coffee = Coffee(...)
 
catDescribable.describe(cat)
coffeeDescribable.describe(coffee)

# Interface - First attempt

 trait Describable[T] {
  def describe(t: T): String
}
 
val catDescribable: Describable[Cat] = ...
val coffeeDescribable: Describable[Coffee] = ...
 
object Describer {
  def describe[T](t: T, d: Describable[T]): String = d.describe(t)
}
 
val cat: Cat = ...
val coffee: Coffee = ...
 
Describer.describe(cat, catDescribable)
Describer.describe(coffee, coffeeDescribable)

# Interface - with implicits

 implicit val catDescribable: Describable[Cat] = ...
implicit val coffeeDescribable: Describable[Coffee] = ...
 
object Describer {
  def describe[T](t: T)(implicit d: Describable[T]): String = d.describe(t)
}
 
val cat: Cat = ...
val coffee: Coffee = ...
 
Describer.describe(cat)
Describer.describe(coffee)

we can pass an instance of any type T for which we have an implicit Describable[T] in scope

# Organizing Implicits

possible locations
- defined in current scope
- defined in companion object of T
- defined in companion object of Typeclass
- imported
local and imported implicits take precedence over implicits defined in companion objects
- possible to define defaults and override them

# ContextBounds

 object Describer {
  def describe[T](t: T)(implicit d: Describable[T]): String = d.describe(t)
}
 
object DescriptionPrinter {
  def print[T](t: T)(implicit d: Describable[T]) = println(Describer.describe(t))
}

often, implicit params are only passed through

 object DescriptionPrinter {
  def print[T: Describable](t: T) = println(Describer.describe(t))
}

context bounds can replace an implicit parameter that takes a type parameter of type T

# ContextBounds

 object Describer {
  def describe[T](t: T)(implicit d: Describable[T]): String = d.describe(t)
}

implicit parameter can still be summoned using implicitly

 object Describer {
  def describe[T: Describable](t: T): String = implicity[Describable[T]].describe(t)
}

# Interface - further improvements

 trait Describable[T] {
  def describe(t: T): String
}
 
object Describer {
  def describe[T](t: T)(implicit d: Describable[T]): String = d.describe(t)
}

there's clearly some repetition here
gets worse when the typeclass has multiple methods that we want to support

# Interface

 trait Describable[T] {
  def describe(t: T): String
}
 
object Describer {
  def apply[T](implicit d: Describable[T]): Describable[T] = d
}

usage:

 // usage
Describer[Cat].describe(someCat)
Describer[Coffee].describe(someCoffee)
 
def printDescription[T : Describable](t: T): Unit = 
  println(Describer[T].describe(t))

we can get rid of the intermediate interface if we just want to call the methods defined on the typeclass

implicit instances need to be in scope

# Interface - Conclusion

using implicit parameters we can use a common interface for a type T if
- the interface is implemented for T (typeclass instance)
- the implementation is in implicit scope
by using implicit instances we can
- have multiple implementations for a single type
- choose an implementation by bringing the specific instance into scope

# Type Enrichment

define an interface that acts like a method defined on the type

 // interface syntax
Describer[Cat].describe(someCat)
Describer[Coffee].describe(someCoffee)
 
// with type enrichment
someCat.describe
someCoffee.describe

# Type Enrichment

can be achieved using an implicit class

 implicit class DescriberOps[T](val t: T) extends AnyVal {
  def describe(implicit d: Describable[T]): String = d.describe(t)
}

# Putting it all together

 // typeclass
trait Describable[T] {
  def describe(t: T): String
}
 
// interface
object Describer {
  def apply[T](implicit d: Describable[T]): Describable[T] = d
}
 
// type enrichment
implicit class DescriberOps[T](val t: T) extends AnyVal {
  def describe(implicit d: Describable[T]): String = d.describe(t)
}
 
// instances
implicit val catDescribable: Describable[Cat] = ...
implicit val coffeeDescribable: Describable[Coffee] = ...
 
// usage
val garfield = Cat("garfield", 3)
println(garfield.describe)

# Conclusion: Good Parts

implementation of interfaces for possibly unrelated types
multiple implementations per type (selection via implicits)
implementation for external code
add new data and new functionality without modifying existing code

# Typeclasses: Not-so-good parts

Boilerplate: repetitive pattern needs to be manually implemented
- syntax improvements coming in Dotty
- Typeclass derivation (for instances)
Hard to model some scenarios
- e.g. List of objects that are Describable

	class Box(private val element: Any) {
	def peek: Any = element
	}

	val i: Int = 3
	val b = new Box(i)

	val peeked: Any = b.peek

	class Box[T](private val element: T) {
	def peek: T = element
	}

	val i: Int = 3
	val b = new Box(i)

	val peeked: Int = b.peek

	case class Dog(name: String, age: Int, favoriteToy: String)

	val listOfDogs: List[Dog] = List(
	Dog("max", 2, "ball"),
	...
	)

	listOfDogs.foreach(dog => println(s"${dog.name}'s favorite toy is ${dog.favoriteToy}"))

	def second[T](l: List[T]): Option[T] = l match {
	case _ :: second :: _ => Some(second)
	case _ => None
	}

	val secondDog: Option[Dog] = second(listOfDogs)

	def combine(a: Int, b: Int): Int = a + b
	def combine(a: String, b: String): String = s"$a$b"
	def combine(a: Boolean, b: Boolean): Boolean = a && b

	combine(1, 3)
	combine("abc", "def")
	combine(true, false)
	combine(List(123), List(456)) // ooops...this one won't compile

	class Box[T](private val element: T) {
	def peek(): T = element
	}

	// oops...doesn't compile!
	def combine(l: List[Int]): String = l.sum.toString
	def combine(l: List[String]): String = l.mkString(",")

	[error] def combine(l: List[Int]): String at line 30 and
	[error] def combine(l: List[String]): String at line 32
	[error] have same type after erasure: (l: List)String

	// oops...doesn't compile!
	def combine(l: List[Int]): Int = l.sum
	def combine(l: List[String]): String = l.mkString(",")

	trait Animal {
	def name: String
	}

	final case class Dog(name: String) extends Animal
	final case class Cat(name: String) extends Animal

	def greeting(a: Animal): String = s"hello animal named ${a.name}"
	def greeting(d: Dog): String = s"hello dog named ${d.name}"
	def greeting(c: Cat): String = s"hello cat named ${c.name}"

	val d1: Dog = Dog("max")
	val d2: Animal = Dog("max")
	val c1: Cat = Cat("garfield")

	println(greeting(d1))
	println(greeting(d2))
	println(greeting(c1))

	hello dog named max
	hello dog named max
	hello cat named garfield

	hello dog named max
	hello animal named max
	hello cat named garfield

	trait Animal {
	def name: String
	def greeting: String = s"hello animal named $name"
	}

	case class Dog(name: String) extends Animal {
	override val greeting: String = s"hello dog named $name"
	}

	case class Cat(name: String) extends Animal {
	override val greeting: String = s"hello cat named $name"
	}

	sealed trait Animal {
	def name: String
	}
	final case class Dog(name: String, favoriteToy: String) extends Animal
	final case class Cat(name: String, favoriteFood: String) extends Animal

	trait Box[T] {
	...
	}

	trait Box[A] {
	def put(a: A): Unit
	def peek(): A
	}

	// can we use a Box[Dog] wherever we expect a Box[Animal]?
	val dogBox: Box[Dog] = ...
	val myAnimal: Animal = dogBox.peek // that's ok

	val myCat: Cat = ...
	def putAnimalInsideBox(animal: Animal, box: Box[Animal]) = ...

	putAnimalInsideBox(myCat, dogBox) // that doesn't look good!

	class Box[+A](element: A) {
	def peek: A = element
	}

	def runIt(): Unit = {
	val bA: Box[Animal] = new Box(a)
	val bD: Box[Dog] = new Box(d)
	val bX: Box[Animal] = bD // works
	val myAnimal: Animal = bD.peek // it's ok to store a Dog in myAnimal
	}

	trait Greeter[-A] {
	def greet(a: A): String
	}

	class AnimalGreeter extends Greeter[Animal] {
	override def greet(a: Animal): String = s"hello ${a.name}"
	}

	def doGreeting(greeter: Greeter[Dog]): Unit = {
	println(greeter.greet(dog))
	}

	val greeter = new AnimalGreeter
	doGreeting(greeter)

	// simplified
	trait Ordering[T] {
	def compare(x: T, y: T): Int
	}

	case class Cat(name: String, age: Int)

	implicit val catOrdering: Ordering[Cat] = new Ordering[Cat] {
	override def compare(x: Cat, y: Cat): Int = x.age - y.age
	}

	val unsortedCats = List(Cat("a", 3), Cat("b", 1), Cat("c", 7))
	val sortedCats = unsortedCats.sorted(catOrdering)

	// sorted takes an implicit ord: Ordering[B] so we could actually write
	val alsoSortedCats = unsortedCats.sorted

	// unrelated data types
	case class Cat(name: String, age: Int)
	case class Coffee(name: String, origin: String)

	val garfield = Cat("Garfield", 3)
	val coffee = Coffee("Yirgacheffe", "Ethiopia")

	println(garfield.describe)
	// Cats: Furry rulers of the world. This one is named Garfield.

	println(Describable[Coffee].describe(coffee))
	// Coffee: Beans of Life. This one is from Ethiopia.

	val catDescribable: Describable[Cat] = new Describable[Cat] {
	override def describe(c: Cat): String =
	s"Cats: Furry rulers of the world. This one is named ${c.name}"
	}

	val coffeeDescribable: Describable[Coffee] = new Describable[Coffee] {
	override def describe(c: Coffee): String =
	s"Coffee: Beans of Life. This one is from ${c.origin}"
	}

	val cat = Cat(...)
	val coffee = Coffee(...)

	catDescribable.describe(cat)
	coffeeDescribable.describe(coffee)

	trait Describable[T] {
	def describe(t: T): String
	}

	val catDescribable: Describable[Cat] = ...
	val coffeeDescribable: Describable[Coffee] = ...

	object Describer {
	def describe[T](t: T, d: Describable[T]): String = d.describe(t)
	}

	val cat: Cat = ...
	val coffee: Coffee = ...

	Describer.describe(cat, catDescribable)
	Describer.describe(coffee, coffeeDescribable)

	implicit val catDescribable: Describable[Cat] = ...
	implicit val coffeeDescribable: Describable[Coffee] = ...

	object Describer {
	def describe[T](t: T)(implicit d: Describable[T]): String = d.describe(t)
	}

	val cat: Cat = ...
	val coffee: Coffee = ...

	Describer.describe(cat)
	Describer.describe(coffee)

	object Describer {
	def describe[T](t: T)(implicit d: Describable[T]): String = d.describe(t)
	}

	object DescriptionPrinter {
	def print[T](t: T)(implicit d: Describable[T]) = println(Describer.describe(t))
	}

	object DescriptionPrinter {
	def print[T: Describable](t: T) = println(Describer.describe(t))
	}

	object Describer {
	def describe[T: Describable](t: T): String = implicity[Describable[T]].describe(t)
	}

	// usage
	Describer[Cat].describe(someCat)
	Describer[Coffee].describe(someCoffee)

	def printDescription[T : Describable](t: T): Unit =
	println(Describer[T].describe(t))

	// interface syntax
	Describer[Cat].describe(someCat)
	Describer[Coffee].describe(someCoffee)

	// with type enrichment
	someCat.describe
	someCoffee.describe

	implicit class DescriberOps[T](val t: T) extends AnyVal {
	def describe(implicit d: Describable[T]): String = d.describe(t)
	}

	// typeclass
	trait Describable[T] {
	def describe(t: T): String
	}

	// interface
	object Describer {
	def apply[T](implicit d: Describable[T]): Describable[T] = d
	}

	// type enrichment
	implicit class DescriberOps[T](val t: T) extends AnyVal {
	def describe(implicit d: Describable[T]): String = d.describe(t)
	}

	// instances
	implicit val catDescribable: Describable[Cat] = ...
	implicit val coffeeDescribable: Describable[Coffee] = ...

	// usage
	val garfield = Cat("garfield", 3)
	println(garfield.describe)

	object Describable {
	def apply[T] given Describable[T] = the[Describable[T]]
	}

	delegate for Describable[Cat] {
	def (c: Cat) describe: String = ...
	}