Paramètres implicites et conversions dans Scala

Après avoir parcouru les articles précédents sur Habr, les tyts et les tyts n'ont pas pu comprendre rapidement ce que fait implicitement Scala. Essayons de le comprendre ensemble.


Ainsi, implicite dans Scala vous permet d'éviter d'appeler des méthodes ou des références explicites à des variables, et de permettre au compilateur de trouver lui-même les données implicites nécessaires.

Par exemple, nous pourrions écrire une fonction pour convertir de Float en Int (FloatToInt) et, au lieu d'appeler cette fonction explicitement, le compilateur le ferait implicitement pour nous:

def double(value: Int) = value * 2 implicit def FloatToInt(value: Float):Int = value.toInt println(double(2.5F)) 

Confus? Mettons tout en ordre.

Aujourd'hui, nous examinons donc deux catégories implicites, à savoir:

• Paramètres implicites (valeurs). Ils sont automatiquement passés par les valeurs du compilateur déclarées via implicite.
• Conversion implicite Si le type du paramètre attendu ne correspond pas au paramètre d'entrée, le compilateur recherche toute méthode dans la portée qui est marquée implicite et avec le paramètre attendu et le paramètre d'entrée nécessaires dans cette situation et le transmet automatiquement.

Paramètre implicite

Un paramètre implicite est un paramètre de fonction précédé du mot clé implicite. Cela signifie que si aucune valeur n'est transmise lors de l'appel de la fonction, le compilateur recherchera personnellement le paramètre implicite et le transmettra pour nous.

Par exemple, une telle fonction qui prend une valeur de paramètre implicite en entrée et la double:

 def double(implicit value: Int) = value * 2 

Sans paramètre implicite, il échouera avec une erreur:

 def double(implicit value: Int) = value * 2 println(double) // error: could not find implicit value for parameter value 

Avec un paramètre explicite passé, cela fonctionnera:

 def double(implicit value: Int) = value * 2 println(double(3)) // 6 

Avec un paramètre implicite, cela ressemblera à ceci:

 def double(implicit value: Int) = value * 2 implicit val multiplier = 2 println(double) // 4 

Mais vous devez être prudent:

 def double(implicit value: Int) = value * 2 implicit val multiplier = 2 implicit val multiplier2 = 1 println(double) // error: ambiguous implicit values 

Et enfin, un exemple avec le passage de def comme paramètre implicite:

 def double(implicit value: Int) = value * 2 val cappucinoLarge: Boolean = false implicit def cappucinoPrice: Int = if (cappucinoLarge) 200 else 100 println(double) // 200 

C'est-à-dire à la fin nous réussirons

 double(cappucinoPrice()) 

Notes de syntaxe:

 def func1(implicit value1: Int) // value1  def func2(implicit value1: Int, value2: Int) // value1  value2  def func3(value1: Int, implicit value2: Int) //   def func4(value1: Int)(implicit value2: Int) //  value2  def func5(implicit value1: Int)(value2: Int) //   def func6(implicit value1: Int)(implicit value2: Int) //   

Conversion implicite

Revenons à l'exemple de Float à Int:

 def double(value: Int) = value * 2 implicit def FloatToInt(value: Float):Int = value.toInt println(double(2.5F)) 

Lors de l'appel double, nous avons une incompatibilité de type du paramètre attendu (Int) avec le paramètre d'entrée (Float). Par conséquent, le compilateur recherche n'importe quelle méthode dans la portée, marquée implicite et avec le paramètre attendu (Int) et le paramètre d'entrée (Float) nécessaires dans cette situation. Trouve FloatToInt, effectue la conversion et transmet la valeur souhaitée pour doubler.

Maintenant, j'espère, c'est devenu plus clair. Tous les succès dans la maîtrise de Scala!