come semplificare letteralmente la funzione di scala in questo modo?

Question

Sono nuovo in scala e sto provando a scrivere una funzione letterale che controlla se un intero dato è dispari o no. il mio primo tentativo è:

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

funziona benissimo, e, dal momento che il parametro X appare solo una volta all'interno di questa funzione letterale, sono tentato di utilizzare il "_" notazione per semplificare ulteriormente, come questo:

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

tuttavia questa volta il compilatore si lamenta:

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

cosa significa questo avvertimento? perché il compilatore riconosce ((_ :Int) & 1) come oggetto fresco anziché un'operazione bit a bit che genera un valore? c'è un modo per scrivere questa funzione letterale usando la notazione "_"?

Answer 1

Il problema è fondamentalmente che Scala ha bisogno di capire la differenza tra

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

dove desideri che tutto a destra del segno di uguale sia una lambda e

val result = collection.map(_ + 1) 

in cui si desidera solo la roba all'interno delle parentesi per essere una lambda

Scala ha deciso che quando si utilizza la sottolineatura per creare una lambda, che sta andando a prendere la parentesi più interne, come i confini di quel lambda. C'è un'eccezione: (_:Int) non conta come le parentesi più interne perché il suo scopo è solo quello di raggruppare la dichiarazione di tipo con il segnaposto _.

qui:

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 

Quest'ultimo caso ti permette di fare cose come

_.map(_ + 1) 

e hanno che vengono tradotti in

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

Answer 2

Cosa Scala sta facendo è questo:

• vede ((_:Int) & 1) e crea un oggetto di tipo (Int) => Int, vale a dire, una funzione.
• poi applica l'operatore di confronto per confrontare == tale funzione al valore 1

una funzione non è uguale al valore 1. Quindi il risultato è false, in modo che il codice è equivalente a:

val isOdd = false 

Che cosa si potrebbe fare è creare un'altra funzione anonima che comporti la parte == 1 del calcolo. Questo è brutto:

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

Ciò equivale alla più dettagliato (e forse più facile da capire):

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

Answer 3

Ci si va:

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

Answer 4

Solo un po 'barare:

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

:-)

Answer 5

Un approccio diverso

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