Scala定义功能标准

Question

The following are equivalent:

scala> val f1 = {i: Int => i == 1}
f1: Int => Boolean = <function1>

scala> val f2 = (i: Int) => i == 1
f2: Int => Boolean = <function1>

I am more familiar with the former (coming from Groovy), but the latter form is much more common, AFAIK, the standard way to define a function in Scala.

Should I forget the past (Groovy) and adopt the 2nd form? The 1st form is more natural for me as it looks similar to Groovy/Ruby/Javascript way of defining closures (functions)

EDIT
See Zeiger's answer in this thread , for an example where groovy/ruby/javascript closure {=>} syntax seems more natural than () => I assume both can be used interchangeably with same performance, ability to pass around, etc. and that the only difference is syntax

Answer 1

I think that this is the matter of taste (scala styleguide recommends first one). The former one allow you to write multiline (>2 lines in body) functions:

val f1 = { i: Int =>
  val j = i/2
  j == 1
}

Sometimes it is useful

Answer 2

Actually, both versions are simplified forms of the "full" version.

Full version: multiple parameters, multiple statements.

scala> val f0 = { (x: Int, y: Int) => val rest = x % y; x / y + (if (rest > 0) 1 else 0) }
f0: (Int, Int) => Int = <function2>

The "groovy" version: one parameter, multiple statements.

scala> val f1 = { x: Int => val square = x * x; square + x }
f1: Int => Int = <function1>

The "scala" version: multiple parameters, one statement.

scala> val f2 = (x: Int, y: Int) => x * y
f2: (Int, Int) => Int = <function2>

A version with a single parameter and a single statement does not exist, because it is not syntactically valid (ie, the grammar for that doesn't quite work).