Как упростить функцию словаря scala как это?

Question

Я новичок в scala и пытаюсь написать литерал функции, который проверяет, является ли заданное целое число нечетным или нет. моя первая попытка:

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

он прекрасно работает, и, так как параметр х появляется только один раз в этой функции буквальный, я соблазн использовать «_» обозначения для упрощения его дальше, как это:

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

однако на этот раз компилятор жалуется:

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

Что означает это предупреждение? почему компилятор распознает ((_ :Int) & 1) как новый объект, а не поразрядную операцию, которая приводит к значению? есть ли способ записать этот литерал функции, используя нотацию «_»?

Answer 1

Проблема заключается в основном, что Scala должен сказать разницу между

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

, где вы хотите все, что находится справа от знака равенства, чтобы быть лямбдой, и

val result = collection.map(_ + 1) 

где вы хотите только вещи внутри скобок быть лямбда

Scala решил, что при использовании подчеркивание, чтобы создать лямбда, что он собирается выбрать самый внутренний набор скобок как границы, что лямбда. Есть одно исключение: (_:Int) не считается ближайшими скобками, поскольку его цель состоит только в том, чтобы группировать объявление типа с помощью заполнителя _.

Следовательно:

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 

Этот последний случай позволяет делать такие вещи, как

_.map(_ + 1) 

и что переводятся в

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

Answer 2

Что Scala делает это:

• видит ((_:Int) & 1) и создает объект типа (Int) => Int, то есть, функция.
• тогда применяется оператор сравнения == сравнить эту функцию к значению 1

функция не равна значению 1. Поэтому результат false, так что ваш код эквивалентен:

val isOdd = false 

Что вы можете сделать, это создать еще одну анонимную функцию, которая выполняет часть ваших вычислений == 1. Это некрасиво:

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

Это эквивалентно более многословным (и, возможно, легче понять):

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

Answer 3

Там вы идете:

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

Answer 4

только немного обмана:

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

:-)

Answer 5

Другой подход

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