В Scala, каково различие между использованием '_' и использованием именованного идентификатора?
Почему я получаю ошибку, когда я пытаюсь использовать _ вместо того, чтобы использовать именованный идентификатор?
scala> res0
res25: List[Int] = List(1, 2, 3, 4, 5)
scala> res0.map(_=>"item "+_.toString)
<console>:6: error: missing parameter type for expanded function ((x$2) => "item
".$plus(x$2.toString))
res0.map(_=>"item "+_.toString)
^
scala> res0.map(i=>"item "+i.toString)
res29: List[java.lang.String] = List(item 1, item 2, item 3, item 4, item 5)
3 ответа
Подчеркивание, используемое вместо подобных имен переменных, является особым; N-е подчеркивание означает N-й аргумент анонимной функции. Таким образом, следующее эквивалентно:
List(1, 2, 3).map(x => x + 1)
List(1, 2, 3).map(_ + 1)
Но если вы сделаете это:
List(1, 2, 3).map(_ => _ + 1)
Затем вы сопоставите список с функцией, которая игнорирует его единственный аргумент и возвращает функцию, определенную как _ + 1 . (Этот конкретный пример не будет компилироваться, потому что компилятор не может определить, какой тип имеет второе подчеркивание.) Эквивалентный пример с именованными параметрами будет выглядеть так:
List(1, 2, 3).map(x => { y => y + 1 })
Короче говоря, использование подчеркиваний в списке аргументов функции означает «Я есть игнорируя эти аргументы в теле этой функции ". Использование их в теле означает «Компилятор, пожалуйста, сгенерируйте для меня список аргументов». Эти два использования не очень хорошо сочетаются.
Чтобы дополнить другие ответы, вот несколько примеров, показывающих, почему вы получаете "отсутствующий тип параметра" в некоторых случаях при использовании '_' в качестве параметра-заместителя.
Вывод типа в Scala рассматривает "ожидаемый" тип выражения на основе его контекста. Если контекст отсутствует, он не может определить тип параметров. Обратите внимание, что в сообщении об ошибке первый и второй экземпляры _ заменены на сгенерированные компилятором идентификаторы x$1 и x$2.
scala> _ + _
<console>:5: error: missing parameter type for expanded function ((x$1, x$2) => x$1.$plus(x$2))
_ + _
^
<console>:5: error: missing parameter type for expanded function ((x$1: <error>, x$2) => x$1.$plus(x$2))
_ + _
^
Добавление приписывания типа ко всему выражению обеспечивает достаточно контекста, чтобы помочь инференсеру:
scala> (_ + _) : ((Int, Int) => Int)
res3: (Int, Int) => Int = <function2>
В качестве альтернативы можно добавить приписывание типа к каждому параметру:
scala> (_: Int) + (_: Int)
res4: (Int, Int) => Int = <function2>
В приведенном ниже вызове функции с указанием типа аргументов контекст однозначен, и тип функции выводится.
scala> def bar[A, R](a1: A, a2: A, f: (A, A) => R) = f(a1, a2)
bar: [A,R](a1: A,a2: A,f: (A, A) => R)R
scala> bar[Int, Int](1, 1, _ + _)
res5: Int = 2
Однако, если мы попросим компилятор вывести тип параметров, он откажется:
scala> bar(1, 1, _ + _)
<console>:7: error: missing parameter type for expanded function ((x$1, x$2) => x$1.$plus(x$2))
bar(1, 1, _ + _)
^
<console>:7: error: missing parameter type for expanded function ((x$1: <error>, x$2) => x$1.$plus(x$2))
bar(1, 1, _ + _)
^
Однако мы можем помочь ему, свернув списки параметров. Здесь аргументы первого списка параметров (1, 1), сообщают выводу, что параметр типа A должен быть Int. Затем он знает, что тип аргумента f должен быть (Int, Int) => ?), а возвращаемый тип R определяется как Int, результат целочисленного сложения. Тот же подход используется в Traversable.flatMap в стандартной библиотеке.
scala> def foo[A, R](a1: A, a2: A)(f: (A, A) => R) = f(a1, a2)
foo: [A,R](a1: A,a2: A)(f: (A, A) => R)R
scala> foo[Int, Int](1, 1) { _ + _ }
res1: Int = 2
scala> foo(1, 1) { _ + _ }
res0: Int = 2
Если вы не собираетесь связывать идентификатор, просто оставьте эту часть.
res0.map("item "+_.toString)