Два способа определения функций в Scala. В чем разница?

Нет никакой разницы между функцией def'ed и функцией val'ed:

scala> def test1 = (str: String) => str + str
test1: (String) => java.lang.String

scala> val test2 = test1
test2: (String) => java.lang.String = <function1>

scala> val test3 = (str: String) => str + str
test3: (String) => java.lang.String = <function1>

scala> val test4 = test2
test4: (String) => java.lang.String = <function1>

Видеть? Все это функции, на что указывает их тип X => Y.

scala> def test5(str: String) = str + str
test5: (str: String)java.lang.String

Вы видите тип X => Y? Если да, то идите к офтальмологу, потому что его нет. Здесь используется тип (X)Y, который обычно используется для обозначения метода.

На самом деле, test1, test2, test3 и test4 — это все методы, которые возвращают функции. test5 — это метод, который возвращает java.lang.String. Кроме того, от test1 до test4 не принимают параметры (во всяком случае, только test1 могут), а test5 принимает.

Итак, разница довольно проста. В первом случае вы пытались назначить метод val, но не заполнили параметры, которые принимает метод. Так что это не удалось, пока вы не добавили знак подчеркивания в конце, что означало превратить мой метод в функцию.

Во втором примере у вас была функция, поэтому вам больше ничего не нужно было делать.

Метод не является функцией, и наоборот. Функция — это объект одного из FunctionN классов. Метод — это дескриптор некоторого фрагмента кода, связанного с объектом.

См. различные вопросы о методах и функциях в Stack Overflow.

def объявляет метод в окружающем объекте/классе/черте, аналогично тому, как вы определяете методы в Java. Вы можете использовать def только внутри других объектов/классов/черт. В REPL вы не можете видеть окружающий объект, потому что он «спрятан», но он существует.

Вы не можете присвоить def значению, потому что def - это не значение, а метод в объекте.

(x: T) => x * x объявляет и создает экземпляр объекта-функции, который существует во время выполнения. Функциональные объекты — это экземпляры анонимных классов, которые расширяют FunctionN черты. FunctionN черты идут с apply методом. Имя apply является особенным, поскольку его можно опустить. Выражение f(x) обесахаривается до f.apply(x).

Суть в том, что поскольку объекты-функции являются значениями времени выполнения, которые существуют в куче, вы можете назначать их значениям, переменным и параметрам или возвращать их из методов в качестве возвращаемых значений.

Чтобы решить проблему назначения методов значениям (что может быть полезно), Scala позволяет использовать символ-заполнитель для создания объекта-функции из метода. Выражение test1 _ в приведенном выше примере фактически создает функцию-оболочку вокруг метода test1 - это эквивалентно x => test1(x).

Подчеркивание означает разные вещи в разных контекстах. Но его всегда можно рассматривать как вещь, которая будет здесь, но не нуждается в имени.

При применении вместо параметров эффект заключается в том, чтобы поднять метод до функции.

scala> def test1(str: String) = str + str; 
test1: (str: String)java.lang.String

scala> val f1 = test1 _
f1: (String) => java.lang.String = <function1>

Обратите внимание, метод стал функцией типа (String) => String.

Различие между методом и функцией в Scala заключается в том, что методы похожи на традиционные методы Java. Вы не можете передавать их как значения. Однако функции сами по себе являются значениями и могут использоваться в качестве входных параметров и возвращаемых значений.

Подъем может пойти дальше:

scala> val f2 = f1 _
f2: () => (String) => java.lang.String = <function0>

Поднятие этой функции приводит к другой функции. На этот раз типа () => (строка) => (строка)

Насколько я могу судить, этот синтаксис эквивалентен явной замене всех параметров символом подчеркивания. Например:

scala> def add(i: Int, j: Int) = i + j
add: (i: Int,j: Int)Int

scala> val addF = add(_, _)
addF: (Int, Int) => Int = <function2>

scala> val addF2 = add _    
addF2: (Int, Int) => Int = <function2>