Diferenças entre essas três maneiras de definir uma função em Scala

92

Dadas três maneiras de expressar a mesma função f(a) := a + 1:

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

Como essas definições diferem? O REPL não indica quaisquer diferenças óbvias:

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

scala

— qrest
fonte

11

Você deve observar que no segundo bloco acima, a avaliação f1no REPL mostra o valor vinculado estaticamente f1ao avaliar f2e f3mostra o resultado da chamada desses métodos. Em particular, uma nova Function1[Int, Int]instância é produzida toda vez que f2ou f3é invocada, enquanto f1é a mesma Function1[Int, Int]para sempre.

— Randall Schulz,

@RandallSchulz dado que a versão val não requer uma nova instância de função, por que alguém usaria def neste caso?

— virtualeyes

2

@virtualeyes A única situação de que me lembro em que se vê defs produzindo valores FunctionN [...] é na biblioteca do analisador combinador. Não é muito comum escrever métodos que geram funções e virtualmente nunca alguém usaria um def para produzir muitas cópias de uma função semântica / funcionalmente imutável.

— Randall Schulz

112

f1 é uma função que pega um inteiro e retorna um inteiro.

f2é um método com aridade zero que retorna uma função que recebe um inteiro e retorna um inteiro. (Quando você digita f2em REPL mais tarde, torna-se uma chamada para o método f2.)

f3é o mesmo que f2. Você simplesmente não está empregando inferência de tipo aqui.

— faltando faktor
fonte

6

Por que f1é um functione f2é um method?

— Freewind de

17

@Freewind, uma função é um objeto com um método chamado apply. Um método, bem, é um método.

— missingfaktor

Resposta incrível. Pergunta: você diz que f2 tem aridade zero, mas não é unário? en.wikipedia.org/wiki/Arity "Uma função nula não leva argumentos. Uma função unária leva um argumento." Apenas curioso!

— Matthew Cornell

5

@MatthewCornell, por f2si só não aceita argumentos. O objeto de função que ele retorna sim.

— missingfaktor

122

Dentro de uma classe, valé avaliado na inicialização, enquanto defé avaliado apenas quando, e todas as vezes , a função é chamada. No código abaixo, você verá que x é avaliado na primeira vez que o objeto é usado, mas não novamente quando o membro x é acessado. Em contraste, y não é avaliado quando o objeto é instanciado, mas é avaliado toda vez que o membro é acessado.

  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
fonte

@JacobusR isso é verdade apenas dentro de uma classe?

— Andrew Cassidy

por exemplo: escala> var b = 5 b: Int = 5 escala> val a: (Int => Int) = x => x + ba: Int => Int = <função1> escala> a (5) res48: Int = 10 escala> b = 6 b: Int = 6 escala> a (5) res49: Int = 11 Eu esperava que a (5) retornasse 10 e o valor de b fosse embutido

— Andrew Cassidy

@AndrewCassidy a função aé imutável e avaliada na inicialização, mas bpermanece um valor mutável. Portanto, a referência a bé definida durante a inicialização, mas o valor armazenado por bpermanece mutável. Para se divertir, agora você pode criar um novo val b = 123. Depois disso, você a(5)sempre dará 11, pois bagora é um valor completamente novo.

— Jack

@JacobusR obrigado ... isso faz sentido. Isso coincide com a definição de "escopo léxico", uma vez que a função a carrega uma referência ao "var b" original. Acho que o que me deixou confuso é que dizer: var b = 5; val c = b; b = 6; age de forma diferente. Acho que não devo esperar que uma definição de função que contenha referências ao escopo "léxico" original se comporte da mesma maneira que um Int.

— Andrew Cassidy

3

Executar uma definição como def x = e não avaliará a expressão e . Em vez disso, e é avaliado sempre que x é usado. Alternativamente, Scala oferece uma definição de valor val x = e , que avalia o lado direito e como parte da avaliação da definição. Se x for usado subsequentemente, ele será imediatamente substituído pelo valor pré-calculado de e , de modo que a expressão não precise ser avaliada novamente.

Scala por exemplo de Martin Odersky

— Alexandre
fonte