I should take a look more seriously to Scala.

Concerning the Unit syntax. As written before, I’m not sure type inference is always a good thing.

And especially as return types type declarations might be useful. Not to the compiler, but to the person who is reading a method.

val a = b.something()

is fine in my code

When someone wants to use something

def something():Int

might be easier to use than

def something()

Code is always written to be easily read and understood, not by optimizing the keys one needs to type.

Other collection types are a bit trickier, but the good news is that you don’t *really* need to convert anything, so long as you’re willing to call Scala APIs from Java (which works perfectly, it’s just not good ol’ java.util.List). Going the other direction is actually even easier (if that’s possible) since Scala includes wrappers for all of the Java Collections interfaces. These wrappers (in scala.collection.jcl) are automatically invoked (via implicit conversion) to wrap Java collections in more palatable Scala interfaces. Thus, while it is not possible to pass a java.util.List into a Scala method accepting Seq *from Java*, it should be fairly easy to just pass that same list into a Scala method which accepts that type, and then from there pass the list to the final target method (accepting Seq).

Stylistic note: any method which returns type Unit should be declared using the following special syntax. It’s not only shorter and more readable, but it can also prevent subtle mistakes when relying on type inference:

def doSomething() {
// do whatever I want
// return whatever I want…
// …because it’s thrown away
}

This is semantically identical to the following:

def doSomething(): Unit = {
// do whatever I want
// return whatever I want…
() // …because it’s thrown away
}

Obviously, the first one is nicer. :-)