I was recently introduced to the curly brace function syntax eg:
(1 to 3).foreach{i => println(i); println(i + 10)}
1
11
2
12
3
13
Anything that gets rid of a brace pair is a great boon. I just wondered if it can ever create syntactic ambiguity.
(1 to 3).foreach({i => println(i); println(1 + 10)})
==
(1 to 3) foreach {i => println(i); println(1 + 10)}
this is called “infix notation”
Before I would have written:
(1 to 3).foreach(i => { println(i); println(i + 10) } )
or
(1 to 3).foreach(i => {
println(i)
println(i + 10)
} )
What’s particular nice is combining it with the case syntax I only discovered / rediscovered recently:
case class AAA(x: Int, y:Int)
val sp = (1 to 4) map (i => AAA(i, i + 10))
sp.foreach{case AAA(x, y) => println(x); println(y + 100) }
1
111
2
112
3
113
4
114
nafg
February 11, 2018, 11:15pm
4
Note that if you want to specify the parameter type, and/or the number of
parameters is not 1, you need parentheses around the part before the arrow;
otherwise they’re optional.
There is no ambiguity.
First, a function can either take some args like f(x,y,z)
or a single block expression like f { z }
.
The beauty of the second syntax is when f
takes a by-name arg, like Future { body }
.
An old SO post .
That is called infix, but you can write x.f(y)
or x.f{y}
or x f y
or x f { y }
. Brace syntax and infix syntax are not related.
Thanks to lightweight method call syntax, you can do:
scala> 1 to 3 foreach println
1
2
3
curoli
March 19, 2018, 5:48pm
8
I very much appreciate that in Scala, I can write x+y z*, instead of
x.+(y. (z))*. Apart from that, I like the dots, parentheses and braces.
I find this more obvious and therefore easier to read:
(1 to 3).foreach { println }
than this
1 to 3 foreach println
Best, Oliver
Fully agreed. The only codebase that does this consistently that I know of is scala/scala - and it still is a significant speed bump in reading the code for me, especially since there is plenty of other stuff going on there.