I've been looking for an excuse to learn more Scala for a while. Currently, I am working on implementing the TAPL interpreters in Scala.
I ran into a problem that took me a while to figure out. To illustrate, I'll give a simple example. Consider this main method:
def main(args: Array[String]) = {
var sum = 0
for (s <- args) { sum += s.toInt }
if (args.length > 0) {sum/args.length} else 0
}
This simply averages a list of numbers specified from the command line. But when I try to run it, I get this error:
Exception in thread "main" java.lang.NoSuchMethodError: main
Java Result: 1
With a very slight change, this will work:
def main(args: Array[String]) = {
var sum = 0
for (s <- args) { sum += s.toInt }
println(if (args.length > 0) {sum/args.length} else 0)
}
This just prints out the average, no complaints.
So what is the difference? Why does printing out the result make a difference? The answer requires a little understanding of the way that Scala works.
Scala relies on type inference. This means that it tries to determine the types of your variables (including methods) from analyzing your program. This is not the same as dynamically typed languages like Perl or Ruby -- the type checking is still done at compile time. The compiler is smart enough to infer the types of your variables from the context.
But there is a problem here. It also has implicit returns. The program will automatically return the last executed expression in the program. This has been a popular feature in many programming languages, including the Lisps, Ruby, and the various ML dialects (of which Scala itself is something of a shirttail cousin). Personally I despise this feature, but I am in the minority.
Combining these features with Java programmer expectations leaves a nice little trap. The main method must not return anything. (Or if you rather, its return type must be Unit). If we copy the second version into the interpreter, we will see this:
main: (Array[String])Unit
The second version works because it prints out the results -- println has a return type of Unit. However, the if statement in this example has a return type of Int. The first version of the program, although it looks nearly identical, has a different type:
main: (Array[String])Int
As a result, Scala looks for main: (Array[String])Unit but cannot find it and returns an error message. This is easy to fix:
def main(args: Array[String]): Unit = { ... }
Or better yet, we can just remove the equals sign from the original:
def main(args: Array[String]) { ... }
Interestingly, the original version actually catches a problem in my code; I am calculating an average, but then I do nothing with it. More often than not, if you see this error, you are probably doing something wrong -- why calculate a value for no reason?
Still, when you are learning a language, a stumbling block like this can be confusing. The error message is clear enough to anyone who understands Scala. My only suggestion would be to add a special case for main specifically. It is a slight hair in the implementation, but it can save clueless newbies (like me) a little frustration, and really... what other kind of method would be named "main"?