Les onzes commandements de Jon Pretty (1re partie)

Suite au retour sur Scalar 2019 que nous avons fait, nous avons promis de vous en dire plus sur les onzes librairies que Jon Pretty avait présenté en vitesse lors de son passage à Scalar.Chose promise, chose due !

Jon Pretty a besoin d'aide pour gérer ses libs. Êtes-vous prêts à l'aider ?

Commençons donc sans plus tarder !

Adversaria

Adversaria permet d'obtenir des informations sur des annotations à l'aide
d'interfaces typeclass et des macros. Il y a actuellement trois
utilisations de cette lib :

• obtenir toutes les annotations appliquées à un type en particulier
• trouver un paramètre annoté dans une case class
• obtenir toutes les annotations associées à un champ d'une case class

Dans les exemples de la page github d'Adversia, on retrouve deux typeclass permettant de faire cela : TypeMetadata et FindMetadata.

Gastronomy (Doc)

Miam ! Cette lib permet de calculer des "hash digests" pour :

• des objets simples

import gastronomy._
  val intDigest: Digest = 42.digest[Md5]
  val stringDigest: Digest = "Hello world!".digest[Sha1]

• des objets plus compliqués comme des case class

import gastronomy._
  case class Person(name: String, age: Int)
  case class Group(people: List[Person])
  
  val group = Group(List(Person("Bill", 18), Person("Jane", 22)))
  val groupDigest: Digest = group.digest[Sha256]

Actuellement, les hash acceptés sont Md5, SHA1, et SHA256.

Cette lib permet également d'encoder par la suite les digest avec la fonction encode. Les encodages acceptés sont Hex et Base64.

Honeycomb

DSL pour générer du code HTML bien formé (table, tbody, tr, td, div, ...).

En bonus, les erreurs sont affichées lors de la compilation, et non pas au runtime/display !

Mercator

Grâce à l'utilisation des macros, Mercator permet d'automatiquement
construire une "preuve" qu'un type connu peut être utilisé dans un
for-comprehension (List, Option, ...). Il s'agit d'abstraire les types
similaires aux monad sans impacts sur la performance.

Par exemple normalement, il n'est pas possible de faire un for-comprehension avec en paramètre de type F[_] :

// ne compile pas
def increment[F[_]](xs: F[Int]) = for(x <- xs) yield x + 1

car le compilateur ne sait pas si F possède les méthodes map et flatMap , qui sont indispensables dans la construction d'un for-comprehension.

Avec Mercator, on peut instancier automatiquement une instance implicite Monadic[F] pour n'importe quel type F[_] possédant map et flatMap. Cela permet de fournir ces méthodes à l'instance de F[_] :

// compile !
import mercator._
def increment[F[_]: Monadic](xs: F[Int]) = for(x <- xs) yield x + 1

Pyroclastic

Permet de créer des graphes monadiques composables.

Voici un exemple de graphe, correspondant à la préparation de thé et café.

---

La suite dans un prochain article :)