web-dev-qa-db-fra.com

Types de paramètres de fonction et =>

Que signifie exactement ce paramètre de déclaration de méthode:

def myFunc(param: => Int) = param

Quelle est la signification de => en définition supérieure?

scalaparametersdeclaration
38
PrimosK

C'est ce qu'on appelle passe-par-nom . Cela signifie que vous passez une fonction qui devrait retourner Int mais qui est principalement utilisée pour implémenter l'évaluation paresseuse des paramètres. Il est quelque peu similaire à:

def myFunc(param: () => Int) = param

Voici un exemple. Considérons une fonction answer retournant une valeur Int:

def answer = { println("answer"); 40 }

Et deux fonctions, une prenant Int et une prenant Int par nom :

def eagerEval(x: Int)   = { println("eager"); x; }
def lazyEval(x: => Int) = { println("lazy");  x; }

Exécutez maintenant les deux en utilisant answer:

eagerEval(answer + 2)
> answer
> eager

lazyEval(answer + 2)
> lazy
> answer

Le premier cas est évident: avant d'appeler eagerEval()answer est évalué et affiche la chaîne "answer". Le deuxième cas est beaucoup plus intéressant. Nous passons en fait une fonction à lazyEval(). lazyEval affiche d'abord "lazy" Et évalue le paramètre x (en fait, appelle la fonction x passée en paramètre).

Voir également

57
Tomasz Nurkiewicz

Juste pour vous assurer qu'il existe une réponse qui utilise le terme approprié: la spécification de langue Scala utilise le terme appel par nom :

Le type d'un paramètre de valeur peut être préfixé par =>, par ex. x: => T. Le type d'un tel paramètre est alors le type de méthode sans paramètre => T. Cela indique que l'argument correspondant n'est pas évalué au point d'application de la fonction, mais est évalué à chaque utilisation dans la fonction. Autrement dit, l'argument est évalué à l'aide de appel par nom .

- Section 4.6.1 de la Spécification du langage Scala

12
Wilfred Springer

Pour ajouter à la réponse de Tomasz Nurkiewicz ci-dessus, la différence que je rencontre entre () => Int et => Int est que le second permet d'appeler avec des blocs nus:

scala> def myfunc(f : () => Int ) = println("Evaluated: " + f )
myfunc: (f: () => Int)Unit

scala> def myfunc2(f : => Int ) = println("Evaluated: " + f )
myfunc2: (f: => Int)Unit

scala> myfunc({1})
<console>:9: error: type mismatch;
 found   : Int(1)
 required: () => Int
              myfunc({1})
                  ^

scala> myfunc2({1})
Evaluated: 1
7
mo-seph