Qu'est-ce que => et () => signifie en scala

Question

Je suis nouveau à Scala et je l’aime vraiment beaucoup, mais il m’arrive parfois de me surprendre. Par exemple:

 clickedCallbacks: List[() => Unit])
 

Quelqu'un pourrait-il me dire ce que => et () => signifient en Scala?

Answer 1

=> est sucre syntaxique pour la création des instances de fonctions. Rappelons que chaque fonction dans la scala est une instance d'une classe.

Par exemple, le type Int => String, est équivalente à la Function1[Int,String] c'est à dire une fonction qui prend un argument de type Int et renvoie un String.

  scala> val f: Function1[Int,String] = myInt => "my int: "+myInt.toString
  f: (Int) => String = <function1>

  scala> f(0)
  res0: String = my int: 0

  scala> val f2: Int => String = myInt => "my int v2: "+myInt.toString
  f2: (Int) => String = <function1>

  scala> f2(1)
  res1: String = my int v2: 1

Ici, myInt est affectée à la valeur de l'argument transmis à l' f et f2.

() => T est le type d'une fonction qui ne prend pas d'argument et renvoie un T. Il est équivalent à Function0[T]. () est appelé à zéro la liste des paramètres que je crois.

 scala> val f: () => Unit = () => { println("x")}
 f: () => Unit = <function0>

 scala> f()
 x

scala> val f2: Function0[Unit] = () => println("x2")
f: () => Unit = <function0>

scala> f2()
x2

Answer 2

=> a plusieurs significations dans la Scala, toutes liées à son sens mathématique comme implication.

• En valeur, il introduit une fonction littérale, ou lambda. par exemple, les bits à l'intérieur des accolades en List(1,2,3).map { (x: Int) => x * 2 }

• Dans un type, avec des symboles sur les deux côtés de la flèche (par exemple, A => T, (A,B) => T, (A,B,C) => T, etc.) c'est du sucre pour Function<n>[A[,B,...],T], c'est une fonction qui prend des paramètres de type A[,B...], et renvoie une valeur de type T.

  • Vide parens sur le côté gauche (par exemple, () => T) indiquent que la fonction ne prend aucun paramètre (aussi parfois appelé "thunk");

  • Vide parens sur le côté droit de désigner qui il retourne ()—la seule valeur de type Unit, dont le nom peut aussi s'écrire ()—confus encore? :)

    Une fonction qui renvoie l'Unité est également connu comme une procédure, normalement, une méthode qui est appelée uniquement pour ses effets secondaires.

• Dans la déclaration de type pour une méthode ou d'un paramètre de la fonction, avec l'absence de ce symbole sur le côté gauche (par exemple, def f(param: => T)) c'est un "par-nom de paramètre", sens qui est évalué à chaque fois qu'il est utilisé dans le corps de la fonction, et pas avant. Ordinaire "par valeur" les paramètres sont évalués avant l'entrée dans la fonction/méthode.

• En case de la clause, de la séparation de la forme (et en option de la garde) à partir de l'expression de résultat, par exemple, case x => y.

Answer 3

() => Unit signifie: "Type de fonction qui ne prend aucun paramètre et renvoie rien"

Donc, si vous déclarez une valeur f à une fonction qui ne prend aucun paramètre et ne retourne rien son type serait:

val f : () => Unit

Puisque c'est un val vous devez attribuer une valeur, par exemple une fonction qui imprime Hola mundo

val f : () => Unit  = () => println("Hola Mundo")

Qui se lit comme suit: *"f est une fonction qui ne prend aucun paramètre et ne retourne rien initialisé avec le code println("Hola Mundo")

Depuis en Scala, vous pouvez utiliser l'inférence de type, vous n'avez pas à déclarer le type de sorte que le suivant serait l'équivalent:

val f = () => println("Hola Mundo")

Pour l'invoquer, vous pouvez simplement:

f()

>"Hola mundo"

Ou, étant donné que les fonctions sont des objets que vous pouvez invoquer l' apply méthode:

f.apply()
> "Hola Mundo"

C'est pourquoi, dans votre déclaration, vous dites "je vais avoir une liste qui contiendra les fonctions sans paramètres et pas de type de retour" donc la Liste[()=>Unité]

J'espère que cette aide.

Answer 4

=> est la "flèche de fonction". Il est utilisé à la fois dans les signatures de type de fonction et dans les termes de fonction anonymes. () => Unit est un raccourci pour Function0[Unit] , qui est le type de fonction qui ne prend aucun argument et ne renvoie rien d’utile (comme void dans d’autres langues).