Blog post

braces-repl.scala

val s1 = {"hello"}     // s1: String = hello
val s = "hello"        // s: String = hello

func-val.scala

val f1 = (x : Int => x * x)    // invalid - compiler error (can't resolve x)
val f2 = (x : Int) => x * x    // valid
val f3 = {x : Int => x * x}    // valid

map-traversable-like.scala

def map[B, That](f: A => B)(implicit bf: CanBuildFrom[Repr, B, That]): That = {
  def builder = { // extracted to keep method size under 35 bytes, so that it can be JIT-inlined
    val b = bf(repr)
    b.sizeHint(this)
    b
  }
  val b = builder
  for (x <- this) b += f(x)
  b.result
}

map1.scala

val list = List(1, 2, 3, 4)
list.map(x => x * x)

map2.scala

val list = List(1, 2, 3, 4)
list.map { x => x * x }

map3.scala

val list = List(1, 2, 3, 4)
list.map(x => x * x)
list.map({x => x * x})

map4.scala

val list = List(1, 2, 3, 4)

// not valid (compile-error)
list.map(x =>
  val y = x * x
  val z = y * x
  Math.sin(z / x)
)

// valid
list.map{x =>
  val y = x * x
  val z = y * x
  Math.sin(z / x)
}

normal-function.scala

def echo(x: String) = println(x)

echo{"hello"}    // valid
echo("hello")    // valid


def echoName(name: String, x: String) = println("$name: $x")

echoName{"John", "hello"}        // invalid
echoName("John", "hello")        // valid
echoName({"John"}, {"hello"})    // valid