Quelle est la règle pour les parenthèses dans l'invocation de la méthode Scala?

Question

ToList n'est-il pas une méthode qui convertit quelque chose en liste?

Si oui, alors pourquoi ne puis-je pas utiliser de parenthèse? Je dois manquer quelque chose de plus fondamental ici.

Voici l'exemple:

 val l = Array(1,2,3).toList // works fine

val l = Array(1,2,3).toList() // gives the error below
 

Pas assez d’arguments pour la méthode s’applique: (n: Int) Int dans le trait LinearSeqOptimized. Paramètre de valeur non spécifié n.

Answer 1

Si une méthode est définie comme

def toList = { /* something */ }

ensuite, il doit être appelé comme

object.toList

sans les parenthèses. Nous disons que cette méthode a zéro des listes de paramètres.

On pourrait aussi définir une liste de paramètres, mais rien mis dedans:

def toList() = { /* something */ }

Maintenant, nous pourrions l'appeler de

object.toList()
object.toList

depuis Scala permet le raccourci d'omettre les parenthèses sur les appels de méthode.

Aussi loin que la JVM, il n'y a pas de différence entre la première définition ("zéro listes de paramètres") et la seconde ("un vide-liste des paramètres"). Mais Scala maintient une distinction. Si c'est une bonne idée ou pas, c'est discutable, mais la motivation peut être plus clair quand vous vous rendez compte que l'on peut aussi

def toList()() = { /* something */ }

qui est connu comme deux vide listes de paramètres, et ensuite appeler tout de

object.toList()()
object.toList()
object.toList

et maintenant, si nous étions à la convertir en une fonction, on tape comme

() => () => T   /* T is the return value of the something */

tandis que la deuxième définition

() => T

qui est clairement différent sur le plan conceptuel, même si pratiquement vous utiliser de la même façon (mises en rien, et tôt ou tard, une T).

De toute façon, toList n'a pas besoin de paramètres, et de la Scala, le standard est de laisser tomber les parens, à moins que la méthode des modifications de l'objet lui-même (plutôt que de simplement retourner quelque chose), il est donc def toList , sans parens par la suite. Et donc vous ne pouvez l'appeler comme object.toList.

Answer 2

Votre deuxième ligne est en fait interprétée comme

 val l = Array(1,2,3).toList.apply()
 

puisque foo(x) correspond à la syntaxe "magique" pour foo.apply(x) .

C'est pourquoi le compliant se plaint de "pas assez d'arguments", car la méthode apply sur les listes prend un argument.

Ainsi, vous pouvez écrire par exemple:

 scala> val i = Array(1, 2, 3).toList(1)
i: Int = 2
 

Answer 3

Permettez-moi de répondre Scala style de codage point de vue.

scala guide de style http://docs.scala-lang.org/style/naming-conventions.html#parentheses dit...

Omettre vide parenthèse, être utilisé uniquement lorsque la méthode en question n'a pas d'effets secondaires (purement fonctionnel). En d'autres termes, il serait possible d'omettre les parenthèses lors de l'appel de la file d'attente.la taille, mais pas lors de l'appel println().

Religieusement l'observation de cette convention permettra d'améliorer considérablement la lisibilité du code et de le rendre beaucoup plus facile à comprendre en un coup d'œil la plupart des opérations de base de toute méthode. Résister à l'envie d'omettre les parenthèses simplement pour économiser de deux personnages!