Различия между этими тремя способами определения функции в Scala

Question

Различия между этими тремя способами определения функции в Scala

92

Учитывая три способа выражения одной и той же функции f(a) := a + 1:

val f1 = (a:Int) => a + 1
def f2 = (a:Int) => a + 1
def f3:(Int => Int) = a => a + 1

Как эти определения различаются? REPL не указывает на очевидные отличия:

scala> f1
res38: (Int) => Int = <function1>
scala> f2
res39: (Int) => Int = <function1>
scala> f3
res40: (Int) => Int = <function1>

qrest 05 сен. 2010, в 17:27

Источник

11

Следует отметить, что во втором блоке выше при оценке f1 в REPL показано значение, статически привязанное к f1 а при оценке f2 и f3 - результат вызова этих методов. В частности, новый экземпляр Function1[Int, Int] создается каждый раз, когда вызывается f2 или f3 , в то время как f1 всегда одна и та же Function1[Int, Int] .
Randall Schulz 05 сен. 2010, в 19:12
0

@RandallSchulz, учитывая, что версия val не требует нового экземпляра функции, зачем в этом случае использовать def?
virtualeyes 01 июнь 2012, в 14:04
2

@virtualeyes Единственная ситуация, которую я могу вспомнить, когда можно увидеть определения, приводящие к получению значений FunctionN [...], - это библиотека анализатора комбинатора. Нечасто писать методы, которые выдают функции, и практически никогда не использовать def для получения множества копий семантически / функционально неизменяемой функции.
Randall Schulz 05 июнь 2012, в 00:18

Показать ещё 1 комментарий

Теги:

scala

3 ответа

116

Внутри класса val оценивается при инициализации, а def оценивается только тогда, когда и каждый раз вызывается функция. В приведенном ниже коде вы увидите, что x оценивается при первом использовании объекта, но не снова при доступе к члену x. Напротив, y не оценивается, когда объект создается, но оценивается каждый раз, когда к нему обращаются.

  class A(a: Int) {
    val x = { println("x is set to something"); a }
    def y = { println("y is set to something"); a }
  }

  // Prints: x is set to something
  val a = new A(1)

  // Prints: "1"
  println(a.x)

  // Prints: "1"                               
  println(a.x)

  // Prints: "y is set to something" and "1"                                  
  println(a.y)

  // Prints: "y is set to something" and "1"                                                                                   
  println(a.y)

Jack 12 окт. 2012, в 10:42

0

@JacobusR это правда только внутри класса?
Andrew Cassidy 26 авг. 2014, в 16:58
0

например: scala> var b = 5 b: Int = 5 scala> val a: (Int => Int) = x => x + ba: Int => Int = <function1> scala> a (5) res48: Int = 10 scala> b = 6 b: Int = 6 scala> a (5) res49: Int = 11 Я ожидал, что a (5) вернет 10, а значение b было встроено
Andrew Cassidy 26 авг. 2014, в 16:59
0

@AndrewCassidy функция a является неизменной и вычисляется при инициализации, но b остается изменяемым значением. Таким образом, ссылка на b устанавливается во время инициализации, но значение, сохраненное в b остается изменяемым. Для интереса вы можете теперь создать новый val b = 123 . После этого ваше a(5) всегда будет давать 11, поскольку b теперь является совершенно новым значением.
Jack 28 авг. 2014, в 05:57
0

@JacobusR спасибо ... это имеет смысл. Это совпадает с определением «лексического контекста», поскольку функция a содержит ссылку на исходный «var b». Я думаю, что меня смутило то, что говорят: var b = 5; val c = b; б = 6; действует по-другому. Думаю, я не должен ожидать, что определение функции, которое содержит ссылки на исходную «лексическую» область видимости, будет вести себя так же, как Int.
Andrew Cassidy 28 авг. 2014, в 13:49

Показать ещё 2 комментария

3

Выполнение определения, такого как def x = e, не будет оценивать выражение e. Вместо этого e оценивается всякий раз, когда используется x. Альтернативно, Scala предлагает определение стоимости val x = e, который оценивает правую часть e как часть оценки определения. Если затем используется x, оно немедленно заменяется предварительно вычисленное значение e, так что выражение не нужно снова оценивать.

Scala Пример Мартин Одерский

Alexander 10 март 2016, в 13:09

Ещё вопросы

Следует отметить, что во втором блоке выше при оценке f1 в REPL показано значение, статически привязанное к f1 а при оценке f2 и f3 - результат вызова этих методов. В частности, новый экземпляр Function1[Int, Int] создается каждый раз, когда вызывается f2 или f3 , в то время как f1 всегда одна и та же Function1[Int, Int] .
@RandallSchulz, учитывая, что версия val не требует нового экземпляра функции, зачем в этом случае использовать def?
@virtualeyes Единственная ситуация, которую я могу вспомнить, когда можно увидеть определения, приводящие к получению значений FunctionN [...], - это библиотека анализатора комбинатора. Нечасто писать методы, которые выдают функции, и практически никогда не использовать def для получения множества копий семантически / функционально неизменяемой функции.
@JacobusR это правда только внутри класса?
например: scala> var b = 5 b: Int = 5 scala> val a: (Int => Int) = x => x + ba: Int => Int = <function1> scala> a (5) res48: Int = 10 scala> b = 6 b: Int = 6 scala> a (5) res49: Int = 11 Я ожидал, что a (5) вернет 10, а значение b было встроено
@AndrewCassidy функция a является неизменной и вычисляется при инициализации, но b остается изменяемым значением. Таким образом, ссылка на b устанавливается во время инициализации, но значение, сохраненное в b остается изменяемым. Для интереса вы можете теперь создать новый val b = 123 . После этого ваше a(5) всегда будет давать 11, поскольку b теперь является совершенно новым значением.
@JacobusR спасибо ... это имеет смысл. Это совпадает с определением «лексического контекста», поскольку функция a содержит ссылку на исходный «var b». Я думаю, что меня смутило то, что говорят: var b = 5; val c = b; б = 6; действует по-другому. Думаю, я не должен ожидать, что определение функции, которое содержит ссылки на исходную «лексическую» область видимости, будет вести себя так же, как Int.

missingfaktor · Accepted Answer · 2010-09-05T17-14-00.000Z

f1 - это функция, которая принимает целое число и возвращает целое число.

f2 - это метод с нулевой активностью, который возвращает функцию, которая принимает целое число и возвращает целое число. (Когда вы набираете f2 в REPL позже, он становится вызовом метода f2.)

f3 совпадает с f2. Вы просто не используете там вывод типа.

@Freewind, функция - это объект с методом apply . Метод, ну, это метод.
Потрясающий ответ. Вопрос: вы говорите, что у f2 нулевая арность, но разве это не унарный? en.wikipedia.org/wiki/Arity "Нулевая функция не принимает аргументов. Унарная функция принимает один аргумент." Просто любопытно!
@ MatthewCornell, f2 сама не принимает аргументов. Функциональный объект, который он возвращает, делает.