- Typeclasses in Scala allow defining common behavior (like printing) for unrelated types through implicit parameters and resolution. This avoids needing to modify types to add functionality. - They work by defining typeclass traits that take a type parameter (like Show[T]), providing implicit values that implement traits for specific types, and having methods use implicit parameters of the typeclass. - While powerful, typeclasses can cause issues like ambiguous implicits and lack consistency when multiple instances are defined. The Shapeless library addresses some limitations by allowing automatic typeclass instance derivation based on a type's structure.

1. Typeclass
Introduction, et Automatic TC derivation

2. Typeclass
1. Pourquoi les typeclass ?
2. Comment on s’en sert (Scala) ?
3. Les limites
4. Pour aller (vraiment) plus loin
2

3. Pourquoi les typeclass ?
3

4. case class Car(name: String, wheelsCount: Int)
case class Person(name: String, age: Int)
4

5. def show(c: Car): String = ???
5

6. def show(c: Car): String = s"${c.name} -> ${c.wheelsCount}"
6

7. def show(p: Person): String = ???
7

8. def show(p: Person): String = s"${p.name} -> ${p.age}"
8

9. def show[T](t: T): String = ???
9

10. trait Showable {
def show: String
}
case class Car(name: String, wheelsCount: Int) extends Showable {
override def show = s"$name -> $wheelsCount"
}
case class Person(name: String, age: Int) extends Showable {
override def show = s"$name -> $age"
}
def show[T <: Showable](t: T): String = t.show
show(Car("c", 5)) // res0: String = c -> 5
show(Person("p", 10)) // res1: String = p -> 10
10

11. 11

12. ● Doit être implémenté à la déclaration du type
● Compliqué à implémenter pour les types existants
● Complexifie la hiérarchie de types
● Mélange technique et métier
● Impossible d’implémenter un autre comportement
12

13. Comment on s’en sert ?
13

14. def show[T](t: T): String = ???
14

15. Typeclass definition
trait Show[T] {
def show(t: T): String
}
15

16. def show[T](t: T)(ev: Show[T]): String = ev.show(t)
16

17. implicits !
17

18. Résolution à la compilation
def show[T](t: T)(implicit ev: Show[T]): String = ev.show(t)
18

19. object Defaults {
implicit val defaultCarShow = new Show[Car] {
override def show(c: Car) = s"${c.name} -> ${c.wheelsCount}"
}
}
object Alternatives {
implicit val alternativeCarShow = new Show[Car] {
override def show(c: Car) = s"${c.name} with ${c.wheelsCount} wheels"
}
}
19

20. import Defaults._
show(Car("My Car", 8)) // My Car -> 8
20

21. import Alternatives._
show(Car("My Car", 8)) // My Car with 8 wheels
21

22. Sucre syntaxique
def show[T: Show](t: T): String = Show[T].show(t)
22

23. Le code est :
1. plus élégant
2. plus générique
3. plus évolutif
4. plus maintenable
5. plus modulaire
23

24. Largement utilisés
List("foo", "bar", "qix").sorted
List(3, 1, 2).sorted
BitSet(42, 84, 126).map(_ / 2L)
List(3, 7, 1).max
24

25. Les limites
25

26. “Ambiguous implicit values”
import Defaults._
import Alternatives._
show(Car("My Car", 8)) // Ne compile pas
26

27. Cohérence
class PriorityQueue[T: Ordered] {
def union(other: PriorityQueue[T]): PriorityQueue[T]
}
27

28. Multiples instances
object Defaults {
implicit val defaultCarShow = new Show[Car] {
override def show(c: Car) = s"${c.name} -> ${c.wheelsCount}"
}
implicit val defaultPersonShow = new Show[Person] {
override def show(p: Person) = s"${p.name} -> ${p.age}"
}
}
28

29. Pour aller (vraiment) plus loin
Largement inspiré du livre http://underscore.io/books/shapeless-guide/
29

30. case class Car(name: String, wheelsCount: Int)
case class Person(name: String, age: Int)
30

31. Multiples instances
object Defaults {
implicit val defaultCarShow = new Show[Car] {
override def show(c: Car) = s"${c.name} -> ${c.wheelsCount}"
}
implicit val defaultPersonShow = new Show[Person] {
override def show(p: Person) = s"${p.name} -> ${p.age}"
}
}
31

32. Produits identiques
case class Car(name: String, wheelsCount: Int)
case class Person(name: String, age: Int)
(String, Int)
32

33. Automatic typeclass derivation
Est-il possible de créer automatiquement toutes les instances de
Show pour un produit donné ?
33

34. Shapeless
Bibliothèque de programmation générique en Scala
34

35. Shapeless - HList
List(1, "String", true) // List[Any] = List(1, String, true)
1 :: "String" :: true :: HNil // ::[Int, ::[String, ::[Boolean, HNil]]] = 1 :: String :: true :: HNil
35

36. Shapeless - Generic[A]
Generic[Car].to(Car("My Car", 4)) == "My Car" :: 4 :: HNil
36

37. def show[A](a: A)(implicit s: Show[A]) = s.show(a)
37

38. implicit def genericShow[A, R](implicit gen: Generic[A] {type Repr = R},
s: Show[R]): Show[A] =
new Show[A] {
override def show(a: A) = s.encode(gen.to(a))
}
Si l’on sait transformer une classe A en HList R, et que l’on sait sérialiser une HList R, alors
on sait sérialiser une classe A
38

39. implicit val HNilShow = new Show[HNil] {
override def show(a: HNil) = ""
}
39

40. implicit def HListShow[H, T <: HList](implicit h: Show[H], t: Show[T]) =
new Show[H :: T] {
override def show(l: H :: T) = h.show(l.head) ++ " " ++ t.show(l.tail)
}
40

41. implicit val StringShow = new Show[String] {
override def show(a: String) = a
}
implicit val IntShow = new Show[Int] {
override def show(i: Int) = i.toString
}
41

42. Démonstration
42

43. Merci !
43