Parámetros implícitos y conversiones en Scala

Tras haber repasado los artículos anteriores sobre Habr, los tyts y tyts no pudieron comprender rápidamente lo que implícito hace en Scala. Intentemos resolverlo juntos.


Entonces, implícito en Scala le permite evitar llamar a métodos o referencias explícitas a variables, y en su lugar le permite al compilador encontrar los datos implícitos necesarios.

Por ejemplo, podríamos escribir una función para convertir de Float a Int (FloatToInt) y, en lugar de llamar explícitamente a esta función, el compilador lo haría implícitamente por nosotros:

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

Confundido? Pongamos todo en orden.

Entonces, hoy nos fijamos en dos categorías implícitas, a saber:

• Parámetros implícitos (valores). Son pasados ​​automáticamente por los valores del compilador declarados por implícito.
• Conversión implícita Si el tipo del parámetro esperado no coincide con el parámetro de entrada, el compilador busca cualquier método en el ámbito que esté marcado implícito y con el parámetro esperado y el parámetro de entrada necesarios en esta situación y lo pasa automáticamente.

Parámetro implícito

Un parámetro implícito es un parámetro de función precedido por la palabra clave implícita. Significa que si no se pasa ningún valor cuando se llama a la función, el compilador buscará personalmente el parámetro implícito y nos lo pasará.

Por ejemplo, una función que toma un valor de parámetro implícito como entrada y lo duplica:

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

Sin un parámetro implícito, fallará con un error:

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

Con un parámetro explícito pasado, funcionará:

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

Con un parámetro implícito, se verá así:

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

Pero debes tener cuidado:

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

Y finalmente, un ejemplo con pasar def como parámetro implícito:

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

Es decir al final tendremos éxito

 double(cappucinoPrice()) 

Notas de sintaxis:

 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) //   

Conversión implícita

Volviendo al ejemplo de Float a Int:

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

Al llamar a double, tenemos una falta de coincidencia de tipo del parámetro esperado (Int) con el parámetro de entrada (Float). Por lo tanto, el compilador está buscando cualquier método en el alcance, marcado implícito y con el parámetro esperado (Int) y el parámetro de entrada (Float) necesarios en esta situación. Encuentra FloatToInt, realiza la conversión y pasa el valor deseado al doble.

Ahora, espero, se ha vuelto más claro. Todo el éxito en el dominio de Scala!