Question

Just seen an interesting possibility to initialize code blocks in Scala for high order functions such as foreach or map:

(1 to 3) map {
  val t = 5
  i => i * 5
}


(1 to 3) foreach {  
  val line = Console.readLine  
  i => println(line)  
}  

Is this some documented feature or should I avoid such constructs? I could imagine, the “initialization” block comes into the constructor and the closure itself becomes an apply() method?

Thanks Pat for the original Question (http://extrabright.com/blog/2010/07/10/scala-question-regarding-readline)

Answer 1

While the features used are not uncommon, I’ll admit is is a fairly odd combination of features. The basic trick is that any block in Scala is an expression, with type the same as the last expression in the block. If that last expression is a function, this means that the block has functional type, and thus can be used as an argument to “map” or “foreach” . What happens in these cases is that when “map” or “foreach” is called, the block is evaluated. The block evaluates to a function ( i=> i*5 in the first case ), and that function is then mapped over the range.

One possible use of this construct is for the block to define mutable variables, and the resulting function mutate the variables each time it is called. The variables will be initialized once, closed over by the function, and their values updated every time the function is called.

For example, here’s a somewhat surprising way of calculating the first 6 factorial numbers

(1 to 6) map {
      var total = 1
      i => {total *= i;total}
    } 

(BTW, sorry for using factorial as an example. It was either that or fibonacci. Functional
Progamming Guild rules. You gotta problem with that, take it up with the boys down at the hall.)

A less imperative reason to have a block return a function is to define helper functions earlier in the block. For instance, if your second example were instead

(1 to 3) foreach {  
  def line = Console.readLine  
  i => println(line)  
}

The result would be that three lines were read and echoed once each, while your example had the line read once and echoed three times.