mrqqn.net

Le langage scala (que j'utilise pour développer Koto) propose quelques nouvelles fonctionnalités plutôt intéressantes que n'ont pas les langages objet "classiques" et entre autres les arguments implicites.

Un argument implicite est un argument qui n'est pas obligé d'être spécifié dans l'appel de la méthode et qui va à la place être recherché dans le scope de la méthode appelante. Ca peut paraitre pour une fonctionnalité crade, et utilisé à mauvais escient ca peut donner un code totalement incompréhensible, mais ça peut aussi le rendre plus lisible. L'utilité que j'en ai fait pour l'instant est pour implémenter l'agrégation d'objets.

J'ai une classe Program (un shader opengl) et contenant plusieurs Uniform (les paramètres du shader).

Sans arguments implicites, je spécifie l'instance de Program à utiliser pour chaque Uniform :

class Program 

class Uniform(val name: String, val program: Program)

object ShaderTexture extends Program {
  val texture = new Uniform("texture", this)
}

Etant donné que les uniforms ne seront initialisé qu'à l'intérieur d'un programme et qu'ils seront liés à ce même programme, autant simplifier leur initialisation en rendant l'argument programme implicite. :

class Program {
  // chaque sous classe de Program aura automatiquement 
  // une valeur implicite de type Program
  protected implicit val _me = this
} 

class Uniform(val name: String)(implicit val program: Program)

object ShaderTexture extends Program {
  // Le constructeur de Uniform cherche une variable de type Program
  // dans le scope courant : _me
  val texture = new Uniform("texture")
}

De cette manière l'initialisation des Uniform est légèrement simplifiée en n'étant plus obligé de mettre le paramètre redondant this.

Ici l'intérêt des implicits est un peu limité, mais ce n'est qu'une utilisation parmi d'autres et je ne voulais parler que d'utilisations que je rencontre actuellement.