Utilisations valides des paramètres implicites

Question

La suite example de Un tour de Scala montre comment implicite peut être utilisé pour fournir les membres manquants appropriés (ajouter et unité) en fonction du type. Le compilateur choisira le bon objet implicite dans la portée. La bibliothèque utilise également cela avec List.sortBy et Ordering ou List.sum et Numeric par exemple.

est cependant l'utilisation suivante en classe B une utilisation valide/recommandée des paramètres implicites (par opposition à ne pas utiliser implicite dans la classe A):

class I 

class A { 
    def foo(i:I) { bar(i) } 
    def bar(i:I) { baz(i) } 
    def baz(i:I) { println("A baz " + i) } 
} 
(new A).foo(new I) 

class B { 
    def foo(implicit i:I) { bar } 
    def bar(implicit i:I) { baz } 
    def baz(implicit i:I) { println("B baz " + i) } 
} 
(new B).foo(new I) 

Là où je l'utilise principalement l'implicite pour me sauver de la frappe sur le site d'appel lors du passage d'un paramètre le long de la pile.

Answer 1

C'est un très bon cas d'utilisation. Je recommande réellement ceci quand la portée détermine le paramètre à utiliser. Il fournit un moyen élégant de transmettre une sorte de contexte dans une classe Plugin afin que les fonctions utilitaires utilisent le contexte. Par exemple:

trait Context 

object UtilityLib { 
    def performHandyFunction(implicit x : Context) : SomeResult = ... 
} 

trait Plugin { 
    def doYourThing(implicit ctx : Context) : Unit 
} 

class MyPlugin extends Plugin { 
    def doYourThing(implicit ctx : Context) : Unit = { 
    UtilityLib.performHandyFunction 
    } 
} 

SomePluginAPI.register(new MyPlugin) 

Vous pouvez voir un exemple dans un database migration system I was toying. Découvrez la classe Migration et son MigrationContext.

Answer 2

Cela ne ressemble pas vraiment à une utilisation idiomatique d'implicits, qui tendent à être adaptés aux classes de types et à l'injection de dépendances. Il n'y a absolument aucune raison de passer sur une classe sans membres ...

Il est également plus fréquent de définir un val implicite ou objet de type I avant de faire l'appel à (new B).foo

Ceci étant dit, vous avez fourni un exemple évidemment très abstrait. Donc, il n'est pas trop difficile d'imaginer un cas d'utilisation raisonnable pour implicits qui suit un modèle similaire.