Return value of a block

A common misunderstanding is that a code block (without parameters) is a function. That is not the case. A code block is a sequence of statements that are executed and result the last statement is returned. That sounds like a Function0, however, if the block is passed to a method/function only the last statement will be returned to the function/method. If that method/function expects a function as the parameter the last statement maybe returned as a function not a value, this means that the block itself is not a function.

1. scala> var count = 0                                                                                                                         
2. count: Int = 0
4. // the last statement is returned as a function so count
5. // is incremented only one during the creation of the function
6. scala> List(1,2,3,4).map{count += 1;_ + 1}
7. res9: List[Int] = List(2, 3, 4, 5)
9. scala> count
10. res10: Int = 1
12. // now the count increment is within the function
13. scala> List(1,2,3,4).map{i => count += 1;i + 1}
14. res11: List[Int] = List(2, 3, 4, 5)
16. scala> count
17. res12: Int = 5

The previous example demonstrates a Gotcha if I ever saw one. Map expects a function so the block essentially constructs a function. The last statement being the function. The first line count += 1 executed only once because it is part of creating the function not part of the resulting function. This is equivalent to:

1. scala> val x = {count += 1 ; i:Int => i +1}
2. x: (Int) => Int = < function1>
4. scala> List(1,2,3,4).map(x)
5. res15: List[Int] = List(2, 3, 4, 5)

Beginning a block with the parameter list signals that the entire block is a function.

Rule of thumb: Functions with placeholder parameters should be a single statement.

Functions using case statements

A further tip regarding using case statements to construct functions. If a case statement is assigned to a Function it will construct a Function object not a PartialFunction.

I suppose the question is why do you care about this since PartialFunction is a Function. The fact is that a PartialFunction is a Function1. But using a case statement you can construct a Function4 very easily.

1. scala> def run(f : Function1[Any,Unit]) = println(f.isInstanceOf[PartialFunction[_,_]])
2. run: (f: (Any) => Unit)Unit
4. /*
5. since run expects a Function calling run as shown here will make a 
6. Function object not a PartialFunction Object
7. */
8. scala> run({case f => ()}) 
9. false
11. scala> def pf(f : PartialFunction[Any,Unit]) = println(f.isInstanceOf[PartialFunction[_,_]]) 
12. pf: (f: PartialFunction[Any,Unit])Unit
14. // Now a PartialFunction will be created
15. scala> pf({case f => ()})                                                                         
16. true
18. scala> def run(f : Function2[Int,String,Unit]) = f(1,"2")                                     
19. run: (f: (Int, String) => Unit)Unit
21. /*
22. This demonstrates why it is important that a case creates a Function
23. when assigned to a Function. PartialFunctions are Function1 objects
24. but the following statement is creating a Function2 object.
25. */
26. scala> run({                 
27.      | case (1,b) => println(b)
28.      | case (a,b) => println(a,b)
29.      | })
30. 2

By-name-parameter to Function

Today's topic is related to Defining Custom Control Structures. By name parameters are not function objects in the same way as other functions. Normally you need to invoke a function:

1. scala> def exec(func: () => Int) = func()
2. exec: (() => Int)Int
4. // exec invokes the function so 10 is the result
5. scala> exec (() => 10)  
6. res1: Int = 10
8. scala> def exec(func: () => Int) = func
9. exec: (() => Int)() => Int
11. // here exec returns the function:
12. scala> exec (() => 10)                 
13. res2: () => Int = <function>

Compare that to a by-name-parameter function:

1. scala> def exec(func: => Int) = func   
2. exec: (=> Int)Int
4. // by-name-parameters are executed when they are referenced
5. // so the result is 10
6. scala> exec {10}                    
7. res3: Int = 10
9. // This is not legal because by-name-parameters
10. // are not normal functions
11. scala> def exec(func: => Int) = func()
12. <console>:4: error: func of type Int does not take parameters
13.        def exec(func: => Int) = func()

So the issue is how can you pass a by-name-parameter to a method that takes a function as a parameter without having to do:

1. scala> def takesFunc(func: () => Int) = println(func())
2. takesFunc: (() => Int)Unit
4. scala> def send(x: => Int) = takesFunc(() => x) 
5. send: (=> Int)Unit
7. scala> send{2}
8. 2

the alternative syntax is:

1. scala> def send(x: => Int) = takesFunc (x _)   
2. send: (=> Int)Unit
4. scala> send {2}
5. 2

Defining Custom Control Structures

Scala has only a handful of built-in control structures: for, while, try-catch, if, etc... However it is quite simple to define custom control structures. There are several good examples in the Scala 2.8 library. For some examples look at the classes in the scala.util.control package.

For this topic, we will develop a simplified version of the Exception class. First a demonstration of the 2.8 version.

1. scala> import scala.util.control.Exception._
2. import scala.util.control.Exception._
4. scala> val numberFormat = catching(classOf[NumberFormatException])
5. numberFormat: util.control.Exception.Catch[Nothing] = Catch(java.lang.NumberFormatException)
7. scala> val result = numberFormat opt { "10".toInt }               
8. result: Option[Int] = Some(10)
10. scala> result match {
11.      | case Some(n) => // do something
12.      | case None => // handle this situation
13.      |

A question that often arises when presented with the Exception control flow is why not use try-catch. There are two main reasons in my opinion.

First, people coming from certain functional style languages find that form more comfortable (so I have heard.) So in this case it is a style issue.

The other reason (and the one more pertinent to Java developers), is that it provides a nice way to handle common exceptions. Why do I say nice? First it declares when exceptions are handled before the code and that provides more context while reading the code. In addition, if you create the Catch object and assign it to a nicely named variable then it is clear what the intent is. For example there may be several reasons to catch a runtime exception and they should be handled differently. A few well-named variables can really assist in readability. A final point is that several of these variables can be defined in on object and shared throughout a project adding some consistency to a project.

Back to the topic at hand.

We will develop a simplified version: a catching method that will return Some(...) if no exception occurs or None if one of the declared exceptions has occurred or throw exception if the exception is not one we declare as handling. Now this is not what I would necessarily call a custom control flow because it does not offer a choice of execution flows. To do that I would add more components like int the Exceptions object. However, this is a good demonstration of the parts required to create a custom control struction. The key is the => in def method(arg: => T) This is a special type construct which means that a no param function is passed in but is not executed until called within the method. A few comparisons:

1. scala> def method(arg: =>Int) = println(arg)
2. method: (arg: => Int)Unit
4. scala> def method2(arg: =>Int) = println("not calling arg")
5. method2: (arg: => Int)Unit
7. scala> var x = 1
8. x: Int = 1
10. // when method is called x is incremented because method calls the argument
11. scala> method { x += 1; x }                                
12. 2
14. scala> println(x)          
15. 2
17. // when method2 is called x is not incremented because 
18. // the argument is not called/referenced
19. scala> method2 { x += 1; x }
20. not calling arg
22. scala> println(x)           
23. 2
25. // arg is referenced 2 times in method three so x is incremented 2 times
26. scala> def method3(arg: => Int) = println("first call="+arg+" second call="+arg)
27. method3: (arg: => Int)Unit
29. scala> method3 { x += 1; x }                                                   
30. first call=3 second call=4
32. // Now demonstrate the standard way of defining arguments
33. // the value passed is calculated before calling the method
34. // so is at most called once
35. scala> def byValue(arg: Int) = println(arg)
36. byValue: (arg: Int)Unit
38. scala> def byValue2(arg: Int) = println("not calling arg")
39. byValue2: (arg: Int)Unit
41. scala> def byValue3(arg: Int) = println("first call="+arg+" second call="+arg)
42. byValue3: (arg: Int)Unit
44. scala> byValue{ x += 1; x }
45. 5
47. scala> byValue2{ x += 1; x }
48. not calling arg
50. scala> println(x)
51. 6
53. scala> byValue3{ x += 1; x }
54. first call=7 second call=7
56. // And finally show the normal way to pass in a function. 
57. // This has the benefit of allowing the reader of the code to
58. // realize that the argument is a function
59. // but is not a nice syntax for control flow
60. scala> def stdFunc(arg: ()=>Int) = println(arg())
61. stdFunc: (arg: () => Int)Unit
63. scala> def stdFunc2(arg: ()=>Int) = println("not calling arg")
64. stdFunc2: (arg: () => Int)Unit
66. scdef stdFunc3(arg: ()=>Int) = println("first call="+arg()+" second call="+arg()) 
67. stdFunc3: (arg: () => Int)Unit
69. scala> stdFunc {() => x += 1; x }  
70. 8
72. scala> stdFunc2 {() => x += 1; x }
73. not calling arg
75. scala> println(x)
76. 8
78. scala> stdFunc3 {() => x += 1; x }
79. first call=9 second call=10

Now for the complete catching example:

1. scala> def catching[T](exceptions: Class[_]*)(body: => T) = {
2.      | try {                                                 
3.      | Some (body)                                           
4.      | } catch {
5.      | case e if (exceptions contains e.getClass) => None
6.      | }                
7.      | }
8. catching: [T](exceptions: Class[_]*)(body: => T)Option[T]
10. scala> val runtime = catching[Number](classOf[NullPointerException], classOf[NumberFormatException])_
11. runtime: (=> java.lang.Number) => Option[java.lang.Number] = < function1>
13. scala> runtime { "".toInt }                                                                          
14. res2: Option[java.lang.Number] = None
16. scala> runtime { "10".toInt }
17. res3: Option[java.lang.Number] = Some(10)
19. scala> runtime { throw new NullPointerException }
20. res6: Option[java.lang.Number] = None
22. scala> runtime { throw new RuntimeException }
23. java.lang.RuntimeException
24.         at $anonfun$1.apply(< console>:10)
25.         at $anonfun$1.apply(< console>:10)
26.         at .catching(< console>:9)
27.         at $anonfun$1.apply(< console>:8)
28.         at $anonfun$1.apply(< console>:8)
29.         at .< init>(< console>:10)
30.         at .< clinit>(< console>)
31.         at RequestResult$.< init>(< console>:4)
32.         at RequestResult$.< clinit>(< console>)
33.         at RequestResult$result(< console>)
34.         ...

Using objects as functions

A fun but easily overlooked fact is that many classes inherit from a Function class and therefore can be used where "normal" functions can be used.

1. scala> List(1,2) map (Map(1->"one",2->"two"))
2. res0: List[java.lang.String] = List(one, two)
4. scala> List(3,3,2) map (List('a', 'b', 'c','d'))
5. res2: List[Char] = List(d, d, c)

Function._

If you have not looked at the Function object I would recommend you do. It contains several useful methods for combining and converting functions.

Examples:

1. cala> def twoParamFunc( i:Int, j:String) = println(i,j)
2. twoParamFunc: (i: Int,j: String)Unit
4. // the tupled method converts the function with n parameters into
5. // a function that takes one tupleN
6. scala> val tupled = Function tupled twoParamFunc _
7. tupled: ((Int, String)) => Unit = < function1>
9. scala> tupled (1 -> "one") 
10. (1,one)
12. // A practical use-case is to convert an existing method
13. // for use with a Map
15. // Example with out using the tupled method
16. scala> Map( 1 -> "one", 2 -> "two") map (entry => twoParamFunc(entry._1, entry._2)) 
17. (1,one)
18. (2,two)
19. res5: scala.collection.immutable.Iterable[Unit] = List((), ())
21. // example using tupled
22. scala> Map( 1 -> "one", 2 -> "two") map (tupled)  
23. (1,one)
24. (2,two)
25. res7: scala.collection.immutable.Iterable[Unit] = List((), ())
27. // and for balance the opposite
28. scala> val untupled = Function untupled tupleParamFunc _
29. untupled: (Int, String) => Unit = < function2>
31. scala> untupled(1, "one") 
32. tuple = (1,one)
34. // Chain is for chaining together an arbitrary number of functions
36. scala> def inc(i:Int) = i + 1 
37. inc: (i: Int)Int
39. scala> def double(i:Int) = i*i
40. double: (i: Int)Int
42. scala> def decr(i:Int) = i - 1
43. decr: (i: Int)Int
45. scala> (Function chain List(inc _, double _, decr _, double _, inc _, inc _))(3)
46. res10: Int = 227
48. // Now examples curries two methods then chains them together
50. // define basic methods
51. scala> def inc(step:Int,i:Int) = i + step 
52. inc: (step: Int,i: Int)Int
54. scala> def multiply(i:Int, j:Int) = i * j
55. multiply: (i: Int,j: Int)Int
57. // Convert them to methods where the first argument is 3
58. scala> val inc3 = (Function curried inc _)(3)
59. inc3: (Int) => Int = < function1>
61. scala> val multiplyBy3 = (Function curried multiply _)(3)
62. multiplyBy3: (Int) => Int = < function1>
64. // chain the resulting Function1 objects together and execute chain with parameter 3
65. // (3 + 3)*3 = 18
66. scala> chain(List(inc3, multiplyBy3))(3)
67. res12: Int = 18