Quelles sont les règles précises quand vous pouvez omettre les parenthèses, les points, les accolades, = (fonctions), etc.?

Vous semblez avoir tombé sur la réponse. De toute façon, je vais essayer de le rendre clair.

Vous pouvez omettre dot lors de l'utilisation du préfixe, infixe et postfix notations, ce que l'on appelle opérateur de notation. Alors que l'aide de l'opérateur de notation, et alors seulement, vous pouvez omettre les parenthèses s'il y a moins de deux paramètres passés à la méthode.

Maintenant, l'opérateur de la notation est une notation pour méthode d'appel, ce qui signifie qu'il ne peut pas être utilisé en l'absence de l'objet qui est appelé.

Je vais brièvement détail les notations.

Préfixe:

Seulement ~, !, + et - peut être utilisé en préfixe de notation. C'est la notation que vous utilisez lorsque vous écrivez !flag ou val liability = -debt.

Infixe:

C'est la notation où la méthode apparaît entre un objet et ses paramètres. Les opérateurs arithmétiques tous ici.

Postfix (également suffixe):

Que la notation est utilisé lorsque la méthode suit un objet et ne reçoit pas de paramètres. Par exemple, vous pouvez écrire list tail, et c'est postfix notation.

Vous pouvez la chaîne d'infixe notation des appels sans problème, tant qu'aucune méthode n'est au cari. Par exemple, j'aime utiliser le style suivant:

(list
 filter (...)
 map (...)
 mkString ", "
)

C'est la même chose que:

list filter (...) map (...) mkString ", "

Maintenant, pourquoi suis-je à l'aide de parenthèses ici, si le filtre et la carte en prendre qu'un seul paramètre? C'est parce que je suis de passage des fonctions anonymes pour eux. Je ne peux pas mélanger les les fonctions anonymes définitions avec infixe de style parce que j'ai besoin d'une limite pour la fin de ma fonction anonyme. Aussi, la définition du paramètre de la fonction anonyme qui pourrait être interprété comme le dernier paramètre de la infix méthode.

Vous pouvez utiliser infixe avec plusieurs paramètres:

string substring (start, end) map (_ toInt) mkString ("<", ", ", ">")

Fonctions curryfiées sont difficile à utiliser avec la notation infixe. Les fonctions de pliage sont un exemple clair de:

(0 /: list) ((cnt, string) => cnt + string.size)
(list foldLeft 0) ((cnt, string) => cnt + string.size)

Vous devez utiliser des parenthèses à l'extérieur de l'infixe appel. Je ne suis pas sûr exactement les règles en jeu ici.

Maintenant, nous allons parler de postfix. Postfix peut être difficile à utiliser, car il ne peut jamais être utilisé n'importe où à l'exception de la fin de l'expression. Par exemple, vous ne pouvez pas effectuer les opérations suivantes:

 list tail map (...)

Parce que la queue n'apparaît pas à la fin de l'expression. Vous ne pouvez pas le faire:

 list tail length

Vous pouvez utiliser la notation infixe en utilisant des parenthèses pour marquer la fin d'expressions:

 (list tail) map (...)
 (list tail) length

Noter que postfix notation est découragé parce que il peut être dangereux.

J'espère que cela a effacé tous les doutes. Si non, il suffit de déposer un commentaire et je vais voir ce que je peux faire pour l'améliorer.

Une collection de citations de donner un aperçu sur les différentes conditions...

Personnellement, je pensais qu'il serais plus dans le cahier des charges. Je suis sûre qu'il doit être, je ne suis pas à la recherche pour les bons mots...

Il ya un couple de sources cependant, et j'ai recueilli leur ensemble, mais rien de vraiment complet /complet /compréhensible /qui explique les problèmes ci-dessus, pour moi...:

"Si un corps de méthode a plus d'un
expression, vous devez l'entourer de
accolades {...}. Vous pouvez omettre le
accolades si le corps de la méthode n'a qu'un seul
d'expression".

De le chapitre 2, "Type Moins, Faire Plus", de la Programmation Scala:

"Le corps de la partie supérieure de la méthode vient
après le signe égal ‘=’. Pourquoi un
signe d'égalité? Pourquoi ne pas simplement des accolades
{...}, comme dans Java? Parce que des points-virgules,
fonction des types de retour, la méthode de
les arguments des listes, et même le frisé
les croisillons sont parfois omis, à l'aide d'un
signe égal empêche plusieurs
l'analyse des ambiguïtés. À l'aide d'une égale
signe nous rappelle également que, même
les fonctions sont des valeurs en Scala, qui
est compatible avec la Scala, à la soutien de
programmation fonctionnelle, décrit dans
plus en détail dans le Chapitre 8, Fonctionnelle
La programmation Scala."

De chapitre 1, "de Zéro à Soixante: Introduction à Scala", de la Programmation Scala:

"Une fonction sans paramètres peuvent être
déclaré sans parenthèses, dans lequel
cas, il doit être appelé sans
entre parenthèses. Ceci fournit un soutien pour
l'Uniforme Principe de l'Accès aux, par exemple
que l'appelant ne sais pas si l'
le symbole est une variable ou une fonction
sans paramètres.

Le corps de la fonction est précédé par "="
si elle renvoie une valeur (c'est à dire le retour
le type est autre chose que de l'Unité),
mais le type de retour et le "=" peut être
omis lorsque le type est l'Unité (c'est à dire qu'il
ressemble à une procédure, par opposition à un
la fonction).

Accolades autour du corps ne sont pas
nécessaire (si le corps est un seul
expression); plus précisément, le corps
d'une fonction est une expression,
et tout l'expression de plusieurs parties
doit être délimitée par des accolades (un
expression avec une partie peut
éventuellement être placé entre accolades)."

"Fonctions avec zéro ou un seul argument
peut être appelé sans le point et
entre parenthèses. Mais toute expression peut
ont des parenthèses autour de lui, de sorte que vous pouvez
omettre le point et d'utiliser
entre parenthèses.

Et puisque vous pouvez utiliser des accolades n'importe où
vous pouvez utiliser des parenthèses, vous pouvez omettre
le point et de mettre en accolades, ce qui peut
contenir plusieurs instructions.

Fonctions sans arguments peuvent être
appelé sans les parenthèses. Pour
exemple, la longueur() de la fonction
La chaîne peut être invoquée comme "abc".longueur
plutôt que de "abc".longueur(). Si l'
la fonction est un Scala fonction définie
sans parenthèses, alors la fonction
doit être appelée sans parenthèses.

Par convention, les fonctions sans
des arguments qui ont des effets secondaires, tels
comme println, sont appelés à
entre parenthèses; les sans-côté
les effets sont appelés sans
entre parenthèses."

De blog Scala Syntaxe Apprêt:

"Une définition de la procédure est une fonction
définition où le type de résultat et
le signe égal sont omis; ses
la définition de l'expression doit être un bloc.
E. g., def f (ps) {statistiques} est
l'équivalent de def f (ps): Unit =
{statistiques}.

Exemple 4.6.3 Ici est une déclaration
et un de?la définition d'une procédure nommée
écrire:

trait Writer {
    def write(str: String)
}
object Terminal extends Writer {
    def write(str: String) { System.out.println(str) }
}

Le code ci-dessus est implicitement terminé
pour le code suivant:

trait Writer {
    def write(str: String): Unit
}
object Terminal extends Writer {
    def write(str: String): Unit = { System.out.println(str) }
}"

À partir de la spécification du langage:

"Avec des méthodes qui prennent seulement un seul
paramètre, Scala permet au développeur
pour remplacer la . avec un espace et d'omettre
les parenthèses, permettant à l'opérateur
syntaxe décrite dans notre opérateur d'insertion
exemple. Cette syntaxe est utilisée dans d'autres
lieux dans de la Scala API, tels que
la construction de la Gamme instances:

val firstTen:Range = 0 to 9

Ici encore, à(Int) est une vanille
méthode déclarée à l'intérieur d'une classe
(il y a effectivement quelques plus implicite
les conversions de type ici, mais vous obtenez le
la dérive)."

De Scala pour Java Réfugiés Partie 6: Arriver Sur Java:

"Maintenant, lorsque vous essayez de "m 0", Scala
les rejets étant un opérateur unaire, sur
les motifs de ne pas être valide
(~, !, - et +). Elle constate que "m" est
un objet valide -- c'est une fonction,
pas une méthode, et toutes les fonctions sont
objets.

En tant que "0" n'est pas valide Scala
identifiant, il ne peut être ni un
infix ni d'un suffixe de l'opérateur.
Par conséquent, la Scala se plaint qu'il
prévu ";" -- ce qui serait distinct
deux (presque) valide les expressions: "m"
et "0". Si vous avez inséré, puis il
se qui m nécessite
un argument, ou, à défaut, un "_"
pour le transformer en une application partielle de la
la fonction".

"Je crois que l'opérateur de style de syntaxe
ne fonctionne que lorsque vous avez l'explicite
objet sur le côté gauche. L'
la syntaxe est destiné à vous permettre d'exprimer
"opérande de l'opérateur opérande" style
les opérations d'une manière naturelle."

Les caractères qui puis-je omettre dans Scala?

Mais également ce qui me confond est cette citation:

"Il doit y avoir un objet à
recevoir un appel de méthode. Par exemple,
vous ne pouvez pas faire “println “Hello World!”"
comme la println besoin d'un objet
destinataire. Vous pouvez le faire “de la Console
println “Hello World!”" qui
répond à la nécessité."

Car autant que je peux voir, il y a est un objet pour recevoir l'appel...

Il n'y en a pas. Vous serez susceptibles de recevoir des conseils autour de si oui ou non la fonction a des effets secondaires. C'est faux. La correction est de ne pas utiliser d'effets secondaires à l'raisonnable de la mesure permise par la Scala. Dans la mesure où il ne peut pas, alors tous les paris sont éteints. Tous paris. L'utilisation de parenthèses est un élément de l'ensemble "ensemble" et le superflu. Il ne fournit pas de valeur une fois que tous les paris sont éteints.

Ce conseil est essentiellement une tentative de effet système qui échoue (à ne pas confondre avec: il est moins utile que les autres de l'effet des systèmes).

Essayez de ne pas d'effets secondaires. Après cela, d'accepter que tous les paris sont éteints. Se cachant derrière une de facto syntaxique notation pour un effet de système peut et ne, seulement causer des dommages.