Curly braces in Scala method call

Question

In Scala, we can have:

println { "Hello, world!" }

And from the book 'Programming in Scala':

The purpose of this ability to substitute curly braces for parentheses for passing in one argument is to enable client programmers to write function literals between curly braces. This can make a method call feel more like a control abstraction.

What does this statement mean?

Posted here too:https://users.scala-lang.org/t/curly-braces-in-scala-method-call/2588 — Mandroid, Apr 07 '18 at 11:15

score 15 · Accepted Answer · answered Apr 07 '18 at 11:27

15

This is syntactic sugar just for look and feel. When a function takes a function as argument like in

def doWith[A, B](todo: A => B): B = ???

You would normally have to call it like

doWith( input => ... )
// or even
doWith({ input => ... })

In scala it is allowed to replace parenthesis with with curlies, so

doWith { input =>
  ...
}

Has the look and feel of a control structure like

if (...) {
  ...
}

Imho, that makes calling higher order functions like 'map' or 'collect' much more readable:

someCollection.map { elem =>
  ...
  ...
}

which is essentially the same as

someCollection.map({ elem =>
  ...
  ...
})

with less chars.

answered Apr 07 '18 at 11:27

Sascha Kolberg

7,092
1
31
37

Note also that semicolon inference happens between `{` and `}` but not `(` and `)`. – Seth Tisue Apr 07 '18 at 15:48
Is there a way to make this work with a `val` instead of a `def`? https://stackoverflow.com/q/56866965/14955 – Thilo Jul 03 '19 at 09:54
1

@Thilo Answered there. – Alexey Romanov Jul 03 '19 at 10:05

score 3 · Answer 2 · answered Apr 07 '18 at 11:24

"Control abstractions" are e.g. if, while, etc. So you can write a function

def myIf[A](cond: Boolean)(ifTrue: => A)(ifFalse: => A): A = 
    if (cond) ifTrue else ifFalse

(if you aren't familiar with : => Type syntax, search for "by-name parameters") you can call it as

val absX = myIf(x < 0) { -x } { x }

and it looks very similar to normal if calls. Of course, this is much more useful when the function you write is more different from the existing control structures.

score 2 · Answer 3 · answered Apr 08 '18 at 18:20

In addition to (regular) functions and by-name arguments, braces also help with partial functions:

processList(l) {
  case Nil => ...
  case h :: t => ...
}

and sequences of expressions:

doSomething {
  thing1;
  thing2
}

Note that (thing1; thing2) is not a valid expression in Scala like it would be in, say, ML.

score 1 · Answer 4 · edited Mar 10 '23 at 01:24

The difference between curly braces {} and parenthesis () is that you can write multiple lines in the curly braces, while in parenthesis you cannot write more than one line for example.

val x :[List[Int]]=List(1,2,3,4,5,6,7,8)
x.map(y=> y*5) //it will work fine
x.map(y=> 
case temp:Int=>println(temp)
case _ => println(“NOT Int”)) //it will not work

x.map{y=> 
case temp:Int=>println(temp)
case _ => println(“NOT Int”)} //it willwork

So we can say it’s just the synthetic sugar to allow developer to write more then none line without ; that’s it it may have some other reason too.

Curly braces in Scala method call

4 Answers4

Linked