Différences entre ces trois façons de définir une fonction en Scala

Question

Étant donné trois façons d'exprimer la même fonction f(a) := a + 1 :

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

En quoi ces définitions diffèrent-elles ? Le REPL n'indique pas de différences évidentes :

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

Answer 1

A l'intérieur d'une classe, val est évalué à l'initialisation tandis que def n'est évalué que lorsque, et à chaque fois la fonction est appelée. Dans le code ci-dessous, vous verrez que x est évalué la première fois que l'objet est utilisé, mais pas à nouveau lorsque le membre x est accédé. En revanche, y n'est pas évalué lorsque l'objet est instancié, mais il l'est à chaque fois que l'on accède au membre.

  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)

Answer 2

f1 est une fonction qui prend un nombre entier et renvoie un nombre entier.

f2 est une méthode d'arité zéro qui renvoie une fonction qui prend un entier et renvoie un entier. (Lorsque vous tapez f2 au REPL plus tard, il devient un appel à la méthode f2 .)

f3 est identique à f2 . Vous n'employez pas l'inférence de type là.

Answer 3

L'exécution d'une définition telle que def x = e n'évaluera pas l'expression e . Au lieu de cela, e est évalué chaque fois que x est utilisé. Alternativement, Scala propose une définition de valeur val x = e qui évalue le côté droit e dans le cadre de l'évaluation de la définition. Si x est utilisé par la suite, il est immédiatement remplacé par l'élément valeur précalculée de e de sorte que l'expression ne doit pas être évaluée à nouveau.

Scala par exemple par Martin Odersky