cómo simplificar la función literal de Scala de esta manera?

Question

Soy nuevo en scala y trato de escribir una función literal que verifique si un entero determinado es impar o no. mi primer intento es:

val isOdd = (x:Int) => (x & 1) == 1

funciona muy bien, y, puesto que el parámetro sólo aparece una vez x dentro de esta función literal, estoy tentado a usar el "_" notación para simplificar aún más, al igual esto:

val isOdd = ((_:Int) & 1) == 1

sin embargo esta vez el compilador se queja:

warning: comparing a fresh object using `==' will always yield false 
val isOdd = ((_:Int) & 1) == 1 

¿Qué significa esta advertencia? ¿por qué el compilador reconoce ((_ :Int) & 1) como un objeto nuevo en lugar de una operación en modo bit que da como resultado un valor? ¿hay alguna forma de escribir esta función literal usando la notación "_"?

Answer 1

El problema es, básicamente, que la Scala tiene que decir la diferencia entre

val isOdd = ((_:Int) & 1) == 1 

donde desea que todo a la derecha del signo igual sea un lambda, y

val result = collection.map(_ + 1) 

donde desea solamente la materia dentro de los paréntesis a ser un lambda

Scala ha decidido que cuando se utiliza el guión para crear una lambda, que va a recoger el paréntesis internos como los límites de ese lambda. Hay una excepción: (_:Int) no cuenta como el paréntesis más interno porque su propósito es solo agrupar el tipo de declaración con el marcador de posición _.

Por lo tanto:

val isOdd = ((_:Int) & 1) == 1 
      ^^^^^^^^^^^^^^ 
      this is the lambda 

val result = collection.map(_ + 1) 
          ^^^^^^^ 
          this is the lambda 

val result = collection.map((_ + 1)/2) 
          ^^^^^^^^ 
          this is the lambda 
          and the compiler can't infer the type of the _ 

val result = somemap.map((_ + 1)/2 * _) 
         ^^^^^^^^ 
         this is an inner lambda with one parameter 
         and the compiler can't infer the type of the _ 
         ^^^^^^^^^^^^^^^^^ 
         this is an outer lambda with one parameter 

Este último caso le permite hacer cosas como

_.map(_ + 1) 

y has que se traducen en

x => x.map(y=> y + 1) 

Answer 2

Lo Scala está haciendo es la siguiente:

• se ve ((_:Int) & 1) y crea un objeto de tipo (Int) => Int, es decir, una función.
• A continuación, aplica el operador de comparación == comparar esta función con el valor 1

Una función no es igual al valor 1. Por lo tanto el resultado es false, por lo que su código es equivalente a:

val isOdd = false 

Lo que podría hacer es crear otra función anónima que haga la parte == 1 de su cálculo. Esto es feo:

val isOdd = ((_: Int) & 1)(_: Int) == 1 

Esto es equivalente a la más prolija (y tal vez más fácil de entender):

val isOdd = (x: Int) => 1 == ((_: Int) & 1)(x) 

Answer 3

Hay que ir:

val isOdd = ((_: Int) & 1) andThen (1 ==) 

Answer 4

Sólo un poco trampa:

val isOdd = (_: Int) % 2 == 1 

:-)

Answer 5

Un enfoque diferente

val isOdd = (_:Int).&(1) == 1