renault - scala vs java

Funciones sin argumentos, con unidad como argumento en scala.

Question

 def foo(x:Int, f:Unit=>Int) = println(f())
foo(2, {Unit => 3+4}
//case1
def loop:Int = 7
foo(2, loop) //does not compile
changing loop to
//case 2
def loop():Int = 7
foo(2, loop) // does not compile
changing loop to
//case 3
def loop(x:Unit): Int = 7 //changing according to Don''s Comments
foo(2,loop) // compiles and works fine

¿No deberían funcionar también el caso 1 y el caso 2? ¿Por qué no están trabajando?

definiendo foo como

def foo(x:Int, y:()=>Int)

entonces el caso 2 funciona pero no el caso 1.

No se supone que todos trabajen, definiendo las funciones de cualquier manera.

// también creo que () => Int en foo es un estilo malo, y: => Int no funciona, ¿comentarios?

Answer 1

() => Int es Function0 [Int] mientras que Unit => Int es Function1 [Unit, Int]

scala> val function0: () => Int = () => 5
function0: () => Int = <function0>
scala> val function1: Unit => Int = u => 5
function1: (Unit) => Int = <function1>
scala> function0()
res0: Int = 5
scala> function1("anything")
res1: Int = 5
scala> function1(100)
res2: Int = 5
scala>

También tenga en cuenta que () es un objeto de la Unidad.

scala> function1(())
res11: Int = 5
scala> function1 ()
res12: Int = 5
scala> function1()
res13: Int = 5
scala> val unit = ()
unit: Unit = ()
scala> function1(unit)
res15: Int = 5
scala> function1 apply unit
res16: Int = 5
scala>

Answer 2

En los casos 1 y 2 anteriores, el valor de retorno del bucle en lugar del bucle en sí es del tipo comprobado para el segundo argumento de foo y falla: Int! = Unidad => Int

El cambio a bucle tiene un error tipográfico.

Answer 3

Scala distingue entre las siguientes cosas:

• Funciones / métodos sin listas de parámetros ("parámetro por nombre" si es una función)
• Funciones con una lista de parámetros vacía
• Funciones con un parámetro de tipo Unit.

Ninguno de estos es equivalente, aunque como conveniencia, Scala le permite eludir listas de parámetros vacías. (Por cierto, dos listas de parámetros vacías tampoco son las mismas).

Entonces, aunque Unit () Unit está escrito () , esto no es lo mismo que la función argumento parens () para una función o método. En su lugar, piensa en () como un Tuple0 .

Entonces, si dices f: Unit => Int , lo que quieres decir es "f toma un parámetro, pero es un parámetro realmente aburrido porque es Unit , que siempre debe ser el mismo valor aburrido de Tuple0 () ". Lo que estás escribiendo es realmente corto para f: (Unit) => Int .

Si dices f: () => Int , entonces quieres decir que "f no toma parámetros y produce un Int ".

Si dice f: => Int , entonces quiere decir que "retrasar la ejecución de cualquier declaración produce un valor Int hasta que lo utilicemos en este código (y lo reevaluemos cada vez)". Funcionalmente, esto termina siendo básicamente el mismo que f: () => Int (e internamente se convierte en la misma clase Function0 ), pero tiene un uso diferente, probablemente para permitir una forma más compacta de cierres (siempre se omite el => en el código de llamada).