Quelle est la règle pour la parenthèse dans l’invocation de la méthode Scala?

N’est-ce pas une méthode qui convertit quelque chose en une liste?

Si oui, pourquoi ne puis-je pas utiliser des parenthèses? 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 appliquer la méthode: (n: Int) Int dans trait LinearSeqOptimized. Paramètre de valeur non spécifié n.

Si une méthode est définie comme

 def toList = { /* something */ } 

alors il faut l’appeler comme

 object.toList 

sans parenthèses supplémentaires. On dit que cette méthode n’a aucune liste de parameters .

On pourrait aussi définir une liste de parameters mais n’y mettre rien:

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

Maintenant, nous pourrions appeler l’un des

 object.toList() object.toList 

Scala permet de raccourcir les parenthèses sur les appels de méthode.

En ce qui concerne la JVM, il n’y a pas de différence entre la première définition (“liste de parameters zéro”) et la seconde (“une liste de parameters vide”). Mais Scala maintient une distinction. Que ce soit une bonne idée ou non est discutable, mais la motivation pourrait être plus claire lorsque vous réaliserez que nous pouvons aussi

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

qui s’appelle deux listes de parameters vides , puis appelle l’un des

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

et maintenant, si nous devions le convertir en une fonction, nous le taperions comme

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

alors que la deuxième définition serait

 () => T 

ce qui est clairement différent sur le plan conceptuel, même si, en pratique, vous l’utilisez de la même manière (ne mettez rien et tôt ou tard sortez un T ).

Quoi qu’il en soit, toList n’a pas besoin de parameters, et la norme Scala est de laisser les parens à moins que la méthode ne modifie l’object lui-même (plutôt que de renvoyer quelque chose). Et vous ne pouvez donc l’appeler que object.toList .

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

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

puisque foo(x) est la syntaxe “magic” pour foo.apply(x) .

C’est pourquoi le complicateur se plaint de “pas assez d’arguments”, car la méthode d’application sur les listes prend un argument.

Ainsi, vous pouvez écrire par exemple:

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

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

Le guide de style Scala dit …

Omettre les parenthèses vides, à utiliser uniquement lorsque la méthode en question n’a pas d’effets secondaires (purement fonctionnels). En d’autres termes, il serait acceptable d’omettre les parenthèses lors de l’appel de queue.size, mais pas lors de l’appel de println ().

L’observation religieuse de cette convention améliorera considérablement la lisibilité du code et facilitera grandement la compréhension en un coup d’œil du fonctionnement le plus élémentaire d’une méthode donnée. Résistez à l’envie d’omettre les parenthèses simplement pour enregistrer deux caractères!