Déduction automatique d'instance de typeclass

avec shapeless

Couritas Etienne

@courieti

1. Les types classes
2. Représentation générique
3. Déduction automatique d'instances

par Dave Gurnell

@davegurnell

Un guide

Il y a même une traduction française !

Pourquoi voudrait-on faire de la programmation générique?

• Faire du code qui ne dépend pas de types précis
• Éviter les répétitions
• Pour pouvoir se reposer encore plus sur les types 

• Les Writer[T]/Reader[T] de PlayJson
• Les Encoder[T]/Decoder[T]
• Comparator<T>
• Numeric[T]
• Ordering[T]

QUELQUES EXEMPLES

Notre interface d'ordering

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

Utilisation de notre type classe

def prettyCompare[T](x : T, y : T)
(implicit ordering : Ordering[T]) = {
    ordering.compare(x,y) match {
        case 0          => "x est égal à y"
        case i if i > 0 => "x est plus grand que y"
        case i if i < 0 => "x est plus petit que y"
    }
}

Implémentation pour Int

implicit val intOrdering : Ordering[Int] =
    new Ordering[Int] {
        def compare(x: Int, y: Int): Int = {
            Integer.compare(x, y)
        }
    }

Comment faire pour ne pas avoir à écrire

soit-même chaque type classe ?

Shapeless

Les types de données algébriques ou ADTs

sealed trait Forme
final case class Rectangle(largeur: Double, hauteur: Double) extends Forme
final case class Cercle(rayon: Double) extends Forme

La déduction automatique

Revenons à notre type classe

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

Commençons par definir quelques outils

object Ordering {
    import shapeless.{::, HList, HNil}
    //summoner method
    def apply[A](implicit ordering: Ordering[A]) = ordering

    def createOrdering[T](f : (T,T) => Int) =
        new Ordering[T] {
            def compare(a: T, b: T) : Int = f(a,b)
        }

    implicit class OrderingOps[T](a : T)(implicit ord : Ordering[T]){
        def compare(b: T) : Int = ord.compare(a,b)
    }
}

La définition des types primitifs

implicit val intOrdering : Ordering[Int] =
  createOrdering((a,b) => a.compare(b))

implicit val doubleOrdering : Ordering[Double] =
  createOrdering((a,b) => a.compare(b))

implicit val stringOrdering : Ordering[String] =
  createOrdering((a,b) => a.compare(b))

implicit val booleanOrdering : Ordering[Boolean] =
  createOrdering((a,b) => a.compare(b))

L'instance d'ordering de HNil

implicit val hNilOrdering : Ordering[HNil] =
    createOrdering((a,b) => 0)

Implicit Scope

Ordering[ Int ]

Ordering[ String ]
Ordering[ Boolean ]

Ordering[ Double ]

Ordering[ HNil ]

Ordering[ H :: T ]

Maintenant comment convertir nos case classes en HList

implicit def genericOrdering[T]( 
    implicit
    gen      : Lazy[Generic[T]],
    ordering : Ordering[gen.Repr]): Ordering[T] = 
{
  createOrdering((a: T,b: T) =>
    ordering.value.compare(gen.to(a), gen.to(b))
  )
}

On peut imaginer comparer des éléments d'une famille scellée entre eux. Pour l'exemple on utilisera juste l'ordre de déclaration.

Comme pour HList la définition de l'élément est très simple.

implicit def cNilOrdering: Ordering[CNil] =
    createOrdering((a,b) =>
        throw new Exception("imposiburu!")
    )

/!\ Il n'y a pas d'instance de CNil donc ce code ne sera jamais éxécuté.

Il est juste là pour aider à la compilation.

L'instance pour un Ordering de coproduct

implicit def coproductOrdering[H, T <: Coproduct] (
  implicit
  hOrdering : Lazy[Ordering[H]],
  tOrdering : Ordering[T]
): Ordering[H :+: T] =
  createOrdering ((a,b) =>
    (a,b) match {
      case (Inl(a), Inl(b)) => hOrdering.value.compare(a,b)
      case (Inr(a), Inr(b)) => tOrdering.compare(a,b)
      case (Inr(a), Inl(b)) => 1
      case (Inl(a), Inr(b)) => -1
    }
)

Traitement similaire aux HList

Utilisation 

scala>   val a : Forme = Cercle(2.0)
a: Forme = Cercle(2.0)
scala>   val b : Forme = Cercle(1.0)
b: Forme = Cercle(1.0)
scala>   a.compare(b)
res0: Int = 1

sealed trait Forme
final case class Rectangle(largeur: Double, hauteur: Double) extends Forme
final case class Cercle(rayon: Double)extends Forme

scala>   val c: Forme = Rectangle(1.0, 2.0)
c: Forme = Rectangle(1.0,2.0)
scala>   c.compare(a)
res3: Int = 1
scala>   c.compare(c)
res4: Int = 0

Shapeless Ops.

Défini dans le package shapeless.ops

C'est un ensemble de type classes prédéfinies, « Fonctions à types dépendants »

Pour HList cela ressemble à l'api des iterables

• Last
• ToList
• Union
• Size

Utilisation récursive d'`Implicitly` à la recherche de la typeclass manquante

Utiliser `reify`, s'il y a encore des types génériques ou des Any/Nothing, c'est qu'il y a un problème

Développer avec shapeless

Aller plus loin

• Lire type astronaute guide to shapeless
• Lire le code shapeless
• Liste de ressources lunatech

Questions ?

https://github.com/crakjie/shapeless-guide