Définitions de classe:
val ou var peuvent être omis dans les paramètres de classe qui permettra de rendre le paramètre privé.
L'ajout de var ou val va l'amener à être public (c'est la méthode des accesseurs et des mutateurs sont générées).
{} peut être omis si la classe n'a pas de corps, qui est
class EmptyClass
L'instanciation de classe:
Les paramètres génériques peuvent être omises si elles peuvent être déduites par le compilateur. Toutefois, si vos types ne correspondent pas, alors le paramètre type est toujours inférer de sorte qu'il corresponde. Donc, sans en préciser le type, vous ne pouvez pas obtenir ce que vous attendez - que, compte tenu de
class D[T](val x:T, val y:T);
Cela vous donnera une erreur de type (Int trouvé, Chaîne attendue)
var zz = new D[String]("Hi1", 1) // type error
Alors que cela fonctionne très bien:
var z = new D("Hi1", 1)
== D{def x: Any; def y: Any}
Parce que le paramètre de type T, on déduit que la moins fréquente supertype des deux - Tout.
La définition d'une fonction:
= peut être supprimé si la fonction renvoie l'Unité (rien).
{} pour le corps de la fonction peut être supprimé si la fonction est un seul état, mais seulement si l'instruction renvoie une valeur (vous avez besoin de l' = signe), qui est,
def returnAString = "Hi!"
mais cela ne fonctionne pas:
def returnAString "Hi!" // Compile error - '=' expected but string literal found."
Le type de retour de la fonction peut être omise si elle peut être déduite (une méthode récursive doit avoir son type de retour spécifiée).
() peut être supprimé si la fonction ne prend aucun argument, qui est,
def endOfString {
return "myDog".substring(2,1)
}
qui par convention est réservée à des méthodes qui n'ont pas d'effets secondaires - plus sur cela plus tard.
() n'est pas réellement chuté en soi lors de la définition d'un passage par nom paramenter, mais il est en fait un assez sémantiquement différente de la notation, qui est,
def myOp(passByNameString: => String)
Dit pop prend un laissez-passer-par-nom de paramètre, ce qui résulte en une Chaîne de caractères (qui est, il peut être un bloc de code qui retourne une chaîne de caractères), par opposition aux paramètres de la fonction,
def myOp(functionParam: () => String)
qui dit myOp prend une fonction qui a zéro des paramètres et retourne une Chaîne de caractères.
(Vous l'esprit, de passer par paramètres de nom compilé en fonctions; il est tout simplement la syntaxe plus agréable.)
() peuvent être déposés dans le paramètre de la fonction de définition si la fonction ne prend qu'un seul argument, par exemple:
def myOp2(passByNameString:(Int) => String) { .. } // - You can drop the ()
def myOp2(passByNameString:Int => String) { .. }
Mais si elle a plus d'un argument, vous devez inclure la (les):
def myOp2(passByNameString:(Int, String) => String) { .. }
Déclarations:
. peuvent être déposés à l'utilisation de l'opérateur de notation, qui peut seulement être utilisé pour des opérateurs infixes (opérateurs de méthodes qui prennent des arguments). Voir la réponse de Daniel pour plus d'informations.
. peut également être supprimée pour les fonctions de postfix
liste de queue
() peut être supprimée pour les opérateurs de suffixe
liste.queue
-
() ne peut pas être utilisé avec les méthodes définies comme suit:
def aMethod = "hi!" // Missing () on method definition
aMethod // Works
aMethod() // Compile error when calling method
Parce que cette notation est réservée par la convention pour les méthodes qui n'ont pas d'effets secondaires, comme le numéro de Liste de la queue (qui est, l'invocation d'une fonction, sans effets secondaires signifie que la fonction n'a aucun effet observable, à l'exception de sa valeur de retour).
() peut être abandonnée pour l'opérateur de notation lors du passage dans un seul argument
() peut être nécessaire d'utiliser postfix opérateurs qui ne sont pas à la fin d'une instruction
() peut être nécessaire de désigner des instructions imbriquées, les extrémités des fonctions anonymes, ou pour les opérateurs qui prennent plus d'un paramètre
Lorsque vous appelez une fonction qui prend une fonction, vous ne pouvez pas omettre le () de l'intérieur de la définition de la fonction, par exemple:
def myOp3(paramFunc0:() => String) {
println(paramFunc0)
}
myOp3(() => "myop3") // Works
myOp3(=> "myop3") // Doesn't work
Lorsque vous appelez une fonction qui prend un paramètre de nom, vous ne pouvez pas spécifier l'argument comme un paramètre moins fonction anonyme. Par exemple, étant donné:
def myOp2(passByNameString:Int => String) {
println(passByNameString)
}
Vous devez l'appeler comme:
myOp("myop3")
ou
myOp({
val source = sourceProvider.source
val p = myObject.findNameFromSource(source)
p
})
mais non:
myOp(() => "myop3") // Doesn't work
L'OMI, de l'utilisation excessive de l'abandon des types de retour peuvent être nocifs pour le code pour être ré-utilisé. Il suffit de regarder la spécification pour un bon exemple de la réduction de la lisibilité en raison du manque d'informations explicites dans le code. Le nombre de niveaux d'indirection pour réellement comprendre ce que le type d'une variable est peut être les noix. Nous espérons de meilleurs outils possible d'éviter ce problème et de garder notre code concis.
(OK, dans la quête de compiler une plus complète, concise réponse (si j'ai oublié quelque chose, ou bien quelque chose de faux ou inexact s'il vous plaît commentaire), j'ai ajouté au début de la réponse. Veuillez noter que ce n'est pas un langage de spécification, donc je ne suis pas en train de faire exactement académiquement correct - juste plus comme une carte de référence.)
