Это:
x foreach println(_ + 1)
эквивалентно этому:
x.foreach(println(x$1 => x$1 + 1))
Нет никаких указаний относительно того, что может быть типом x$1, и, честно говоря, бессмысленно печатать функцию.
Вы, очевидно (для меня) хотели напечатать x$0 + 1, где x$0 будет параметром, переданным foreach, вместо этого. Но давайте рассмотрим это ... foreach принимает в качестве параметра Function1[T, Unit], где T - параметр типа списка. Вместо этого вы передаете foreach println(_ + 1), которое является выражением, которое возвращает Unit.
Если бы вы написали вместо x foreach println, вы бы пропустили совершенно другую вещь. Вы передадите функцию (*) println, которая принимает Any и возвращает Unit, что соответствует требованиям foreach.
Это немного запутано из-за правил расширения _. Он расширяется до самого внутреннего разделителя выражений (круглые или фигурные скобки), за исключением случаев, когда они находятся вместо параметра, и в этом случае это означает другое: частичное применение функции.
Чтобы объяснить это лучше, посмотрите на следующие примеры:
def f(a: Int, b: Int, c: Int) = a + b + c
val g: Int => Int = f(_, 2, 3) // Partial function application
g(1)
Здесь мы применяем второй и третий аргументы к f и возвращаем функцию, требующую только оставшийся аргумент. Обратите внимание, что это сработало только потому, что я указал тип g, в противном случае мне пришлось бы указать тип аргумента, который я не применял. Давайте продолжим:
val h: Int => Int = _ + 1 // Anonymous function, expands to (x$1: Int => x$1 + 1)
val i: Int => Int = (_ + 1) // Same thing, because the parenthesis are dropped here
val j: Int => Int = 1 + (_ + 1) // doesn't work, because it expands to 1 + (x$1 => x$1 + 1), so it misses the type of `x$1`
val k: Int => Int = 1 + ((_: Int) + 1) // doesn't work, because it expands to 1 + (x$1: Int => x$1 + 1), so you are adding a function to an `Int`, but this operation doesn't exist
Давайте обсудим k более подробно, потому что это очень важный момент. Напомним, что g - это функция Int => Int, верно? Итак, если бы я набрал 1 + g, это имело бы смысл? Вот что было сделано в k.
Что смущает людей, так это то, что они действительно хотели:
val j: Int => Int = x$1 => 1 + (x$1 + 1)
Другими словами, они хотят, чтобы x$1, заменяющий _, перепрыгивал на за пределами в скобках и в нужное место. Проблема здесь в том, что, хотя им может показаться очевидным, каково правильное место, компилятору это не очевидно. Рассмотрим этот пример, например:
def findKeywords(keywords: List[String], sentence: List[String]) = sentence.filter(keywords contains _.map(_.toLowerCase))
Теперь, если бы мы расширили это до скобок, мы получили бы это:
def findKeywords(keywords: List[String], sentence: List[String]) = (x$1, x$2) => sentence.filter(keywords contains x$1.map(x$2.toLowerCase))
Что точно не то, что мы хотим. На самом деле, если _ не ограничен самым внутренним разделителем выражений, никогда нельзя использовать _ с вложенными map, flatMap, filter и foreach.
Теперь вернемся к путанице между анонимной функцией и частичным применением, посмотрите здесь:
List(1,2,3,4) foreach println(_) // doesn't work
List(1,2,3,4) foreach (println(_)) // works
List(1,2,3,4) foreach (println(_ + 1)) // doesn't work
Первая строка не работает из-за того, как работает нотация операций. Scala просто видит, что println возвращает Unit, а это не то, что foreach ожидает.
Вторая строка работает, потому что скобка позволяет Scala оценивать println(_) в целом. Это приложение с частичной функцией, поэтому оно возвращает Any => Unit, что приемлемо.
Третья строка не работает, потому что _ + 1 - анонимная функция, которую вы передаете в качестве параметра println. Вы не делаете println частью анонимной функции, чего вы и хотели.
Наконец, то, что мало кто ожидает:
List(1,2,3,4) foreach (Console println _ + 1)
Это работает. Почему это так, оставлено читателю в качестве упражнения. : -)
(*) На самом деле, println - это метод. Когда вы пишете x foreach println, вы не передаете метод, потому что методы не могут быть переданы. Вместо этого Scala создает замыкание и передает его. Расширяется так:
x.foreach(new Function1[Any,Unit] { def apply(x$1: Any): Unit = Console.println(x$1) })