I’m trying to wrap my head around Scala, and one thing that keeps throwing me is the ordering of a variable/value declaration when specifying the type.
val a = 0
makes perfect sense. This looks pretty much like any other language.
val a: Int = 0
parses really weird in my head; it just seems nonsensical. Why is the type immediately on the left of the assignment operator? When I cut this in my head, I see “… Int = 0”, which obviously doesn’t make any sense.
Is there a logical reason behind this that I can refer to? Obviously, as I look at Scala code more, I will adjust to it, but I’m also curious why Martin Odersky would choose to arrange it as such. It can’t be just to stand out from other languages, where (as far as I know of), the type identifier, if there is one, precedes the declaration.
9
stand out from other languages
No. As Jörg already commented, this form is actually used in many languages. It is probably the most common form of variable declaration by number of languages that use it. It was used back then with Pascal and related languages and it is now being used by all the new ones like TypeScript, Go, Rust—and Scala.
type identifier, if there is one, precedes the declaration
The
type identifier [
=value ]
form of declaration in C was in some respects a big mistake. Its serious problem is that it makes the grammar of the language contextual. Type and object identifiers look the same syntactically, but this form of declaration cannot be recognized without knowing that the first identifier identifies a type. So the compiler can’t build the syntax tree without referring to the table of already defined types. This causes problems to templates, because the interpretation may depend on the parameter, so the compiler can’t know whether it is looking at a type yet.
In C++ this means you have to use typename keyword in the ambiguous cases. Java and C# dodge this by not having typedefs, so you can’t have related types, but that seriously limits usefulness of their templates. And it still complicates the compiler anyway.
On the other hand with declarations in the form
keyword identifier [
:type ] [=value ]
the identifier after : (and some keywords like new) always means type and identifier in any other place never does and the grammar is context-free and everything is much simpler.
It is also more regular when the type is optional. You just omit it. In the C form, you have to replace it with special keyword.
3
You’re thinking about it the wrong way. The type isn’t immediately to the left of the assignment, it’s immediately to the right of the declarator. This syntax has the advantage of being unambiguous, whereas for example val a = 0 : Int is ambiguous: does the type specifier refer to the literal, the declaration, or the entire statement? And if the initializer is more complicated than just a literal, it gets really confusing.
1