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

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

Comment ces définitions diffèrent-ils? 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>

Vous devriez noter que dans le 2e bloc ci-dessus, l'évaluation de f1 dans le REPL montre la valeur statiquement lié à f1 tout en évaluant f2 et f3 montrent le résultat de l'invocation de ces méthodes. En particulier, une nouvelle Function1[Int, Int] instance est produit chaque fois que l' f2 ou f3 est invoquée, alors que f1 est la même Function1[Int, Int] pour toujours.
étant donné que le val de version n'a pas besoin d'une nouvelle fonction de l'instance, pourquoi aurait-on jamais utiliser def dans ce cas?
La seule situation que je peux me rappeler où l'on voit des defs rendement Fonctionn[...] des valeurs est dans le combinator parser. Ce n'est pas très commun de méthodes d'écriture que le rendement des fonctions et pratiquement jamais ne serait-on utiliser un def de rendement nombre de copies d'un point de vue sémantique / fonctionnellement immuable de la fonction.

InformationsquelleAutor qrest | 2010-09-05

scala

112

f1 est une fonction qui prend un entier et retourne un entier.

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

f3 est la même que f2. Vous n'êtes pas employer l'inférence de type il.
- Pourquoi f1 est un function et f2 est un method?
- une fonction est un objet avec une méthode nommée apply. Une méthode est une méthode.
- Réponse impressionnante. Question: vous dites f2 a arité zéro, mais n'est-il pas unaire? en.wikipedia.org/wiki/Arity "Un nullary fonction ne prend pas d'arguments. Unaire fonction prend un argument." Juste curieux!
- lui-même n'accepte pas d'arguments. La fonction de l'objet qu'il renvoie t.
InformationsquelleAutor missingfaktor
122

À l'intérieur d'une classe, val est évaluée lors de l'initialisation, tandis que def est évaluée uniquement lorsque, et à chaque fois, la fonction est appelée. Dans le code ci-dessous, vous verrez que x est évaluée la première fois que l'objet est utilisé, mais pas encore quand le x membre est accessible. En revanche, y est pas évalué lorsque l'objet est instancié, mais est évalué à chaque fois que le membre est accessible.
```
  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)
```
- est-ce vrai qu'à l'intérieur d'une classe?
- par exemple: scala> var b = 5 b: Int = 5 scala> val a: Int => Int) = x => x + b a: Int => Int = <fonction1> scala> (5) res48: Int = 10 scala> b = 6 b: Int = 6 scala> (5) res49: Int = 11 je m'attendais à un(5) pour revenir 10 et la valeur de b d'avoir été inline
- la fonction a est immuable et évaluées lors de l'initialisation, mais b reste une valeur mutable. Donc, la référence à b est définie lors de l'initialisation, mais la valeur stockée par b reste mutable. Pour le plaisir, vous pouvez maintenant créer un nouveau val b = 123. Après cela, votre a(5) donnera toujours 11, depuis le b est maintenant complètement une nouvelle valeur.
- merci... cela fait sens. Cela coïncide avec la définition de la "portée lexicale" puisque la fonction d'une porte une référence à l'original "var b". Je suppose que ce qui m'a fait confondre, c'est que dire: var b = 5; val c = b; b = 6; actes différemment. Je suppose que je ne devrais pas s'attendre à une définition de fonction qui porte autour de références à l'original "lexicale" portée à se comporter de la même façon qu'un Int.
InformationsquelleAutor Jack
3

De l'exécution d'une définition comme def x = e ne sera pas évaluer l'expression e. Au lieu de cela e est évalué chaque fois que x est utilisé. Sinon, Scala propose une définition de la valeur
val x = e, qui n'est d'évaluer la droite e dans le cadre de l'évaluation
de la définition. Si x est ensuite utilisé par la suite, il est immédiatement remplacé par le
pré-calculé la valeur de e, de sorte que l'expression n'a pas besoin d'être évalué de nouveau.

Scala Par Exemple
par Martin Odersky

InformationsquelleAutor Alexander

Vous devez vous connecter pour publier un commentaire.