in Scala there is syntactic sugar by calling a method when the method call is in operator position. For example (5).+(3)
can be written as 5 + 3
. The rule for this is <object>.<method>(<parameter>)
. It this rule is true the dot and the parentheses can be left. But I found an exception of this rule: it is not able to write the super-keyword in operator position:
class X {
def x(i: In开发者_开发技巧t) = i * 2
}
class Y extends X {
override def x(i: Int) = super.x(i + 1)
}
When I leave the dot behind the super I get a compiler error. Here, super
is the object, x
the method and i + 1
the parameter therefore I don't understand why I get an error. Can anyone explain it?
I believe it is because the super
keyword must (but see the comment by huynhjl and details below) be followed with a .
and then followed with a valid member identifier -- it seems to be grammar production rule.
Consider that val expr = (super)
has no useful meaning and should always be invalid (in this regard it is quite different from this
which is a valid expression by itself). Requiring the super.member
form at the grammar level is likely intentional, but it would require some digging. intentional per the wording the specification (see the comment by huynhjl) and per the grammar "summary" rules.
class X {
def x(): X = this
}
class Y extends X {
// Still kaboom of course -- message is effectively the same
// and indicates a grammar production has been violated.
// Message: error: '.' expected but '}' found.
override def x(): X = super
}
Happy coding.
Update (references):
From the Scala Language Specification 2.8 discussing super
in Section 6.5:
A reference
super.m
refers statically to a method or typem
in the least proper supertype of the innermost template containing the reference. It evaluates to the member in the actual supertype of that template which is equal tom
or which overridesm
. The statically referenced memberm
must be a type or a method ... The super prefix may be followed by a trait qualifier[T]
, as inC.super[T].x
. This is called a static super reference. In this case, the reference is to the type or method ofx
in the parent trait ofC
whose simple name isT
.
And from the Scala Syntax Summary (Chapter A):
stableId ::= id | Path ‘.’ id | [id ’.’] ‘super’ [ClassQualifier] ‘.’ id
精彩评论