Breaks

Scala 2.8 added the break control flow option. It is not implemented as a special language feature. Rather it is simply implemented as an object/trait using standard Scala mechanisms. If you are interested in creating a control flow object similar to this look at the Defining Custom Control Structures post.

The Break functionality is works basically how you would expect:

1. // Import the control flow methodsmethods
2. scala> import util.control.Breaks._
3. import util.control.Breaks._
5. // pass a function to the breakable method
6. scala> breakable {
7.      | for (i <- 1 to 10 ) {
8.      | if(i > 5) break  // call break when done
9.      | println(i)
10.      | }
11.      | }
12. 1
13. 2
14. 3
15. 4
16. 5

Pretty intuitive but beware, break only breaks out to the first enclosing breakable. Here is an example of the issue:

1. scala> def loop(f : Int => Boolean) = breakable {
2.      | for (i <- 1 to 300) if (f(i)) break else println(i)
3.      | }
4. loop: (f: (Int) => Boolean)Unit
6. // This never ends because break is caught by breakable in the loop method
7. scala> breakable {
8.      | while(true) {
9.      | loop{ i => break; true }
10.      | }
11.      | }

Fortunately the implementers provide an elegant way to handle these sorts of cases. The Breaks object extends the Breaks class. By instantiating other instances of Breaks it is possible to control which breaks capture

1. scala> import scala.util.control._
2. import scala.util.control._
4. scala> 
6. scala> def loop(f : Int => Boolean) = {
7.      |   val Inner = new Breaks
8.      |   Inner.breakable {
9.      |     for (i <- 1 to 4) if (f(i)) Inner.break else println(i)
10.      |   }
11.      | }
12. loop: (f: (Int) => Boolean)Unit
14. scala> 
16. scala> val Outer = new Breaks
17. Outer: scala.util.control.Breaks = scala.util.control.Breaks@1ba4806
19. scala> Outer.breakable {
20.      |   while(true) {
21.      |     loop{ i => if(i==4) Outer.break; false}
22.      |   }
23.      | }
24. 1
25. 2
26. 3

Introducing Structural Types

Structural types allows one to declare types based on the methods the type has. For example you could define a method that takes a class containing a close method. This is fairy analogous to duck-typing in dynamic languages. Except that it is statically enforced.

The main example used here was from a comment on the Code Monkeyism Blog. The commenter further explains that this example is in fact from Beginning Scala chapter 4 (which I would like to read but have not yet had the time.)

1. /*
2. A can be any object that has a close method.  
4. This is statically typed which makes some restrictions which are explained later
5. */
6. scala> def using[A <: {def close(): Unit}, B](param: A)(f: A => B): B = 
7.      | try {
8.      |     f(param)
9.      |   } finally {
10.      |     try {
11.      |        param.close()
12.      |     } catch { case _ => () }
13.      |   }
14. using: [A <: AnyRef{def close(): Unit},B](param: => A)(f: (A) => B)B
16. scala> using(new java.io.ByteArrayInputStream("hello world".getBytes)){ in => 
17.      | io.Source.fromInputStream(in) foreach (print)                          
18.      | }
19. hello world
21. scala> using(new java.io.ByteArrayInputStream("hello world".getBytes)){ in => 
22.      | io.Source.fromInputStream(in) mkString ""                              
23.      | }
24. res8: String = hello world

That is extremely powerful and the consequences will be visited more in the future. But because structural typing is statically enforced it is not quite as flexible as dynamic language's version of duck typing. For example you cannot do:

1. scala> val i:Any = new java.io.ByteArrayInputStream("hello world".getBytes)
2. i: Any = java.io.ByteArrayInputStream@145a25f3
4. /*
5. This does not work because 'i' is defined as type Any.  Not a type that is closeable.  
7. Casting can be used to get around this issue.  I will address that in its own post
8. */
9. scala> using(i){ in => 
10.      | io.Source.fromInputStream(in) mkString ""
11.      | }
12. < console>:8: error: inferred type arguments [Any,B] do not conform to method using's type parameter bounds [A <: AnyRef{def close(): Unit},B]
13.        using(i){ in =>

An alternative to the first using example is to use call by name to construct the closeable. The reason one might want to do that is because it allows currying of the method:

1. scala> def using[A <: {def close(): Unit}, B](param: =>A)(f: A => B): B = 
2.      | val closeable = param  // notice param is only referenced once
3.      | try {
4.      |     f(closeable)
5.      |   } finally {
6.      |     try {
7.      |        closeable.close()
8.      |     } catch { case _ => () }
9.      |   }
10. using: [A <: AnyRef{def close(): Unit},B](param: => A)(f: (A) => B)B
12. /*
13. if this was accessing a database a new connection would be made automatically each time this function was used
14. */
15. scala> val usingTheWorld = using[BStream,Int](new java.io.ByteArrayInputStream("hello world".getBytes))_
16. usingTheWorld: ((java.io.ByteArrayInputStream) => Int) => Int = < function1>
18. scala> usingTheWorld { s => io.Source.fromInputStream(s).length}  
19. res3: Int = 11
21. scala> usingTheWorld { s => io.Source.fromInputStream(s).getLines().length}
22. res5: Int = 0

Comparing Manifests

Manifests are Scala's solution to Java's type erasure. It is not a complete solution as of yet but it does have several useful applications. Manifests were originally added to Scala 2.7 in an extremely limited form but have been improved a great deal for Scala 2.8. Now more powerful comparisons of manifests are possible. For another introduction to Manifests (2.7 manifests) see Manifests.

This post looks at a few ways to create manifests as well as how to compare manifests. The goal is to create a method that can be used in testing to require that a certain exception is thrown during a code block:

1. scala> intercepts[Exception] {println("hi :)")}                                            
2. hi :)
3. Expected java.lang.Exception but instead no exception was raised

The code snippet above is a failure because println does not throw an exception. In addition to requiring manifests this code snippet also is a custom control structure, for more information on those see Control Structure Tag

But before writing the intercepts methods a short inspection of the new manifest comparison operators:

1. scala> import scala.reflect.{
2.      |   Manifest, ClassManifest
3.      | }
4. import scala.reflect.{Manifest, ClassManifest}
6. // from class creates a manifest object given a class object
7. scala> import ClassManifest.fromClass
8. import ClassManifest.fromClass
10. // several comparisons using <:<
11. scala> fromClass(classOf[Exception]) <:< fromClass(classOf[Exception])
12. res4: Boolean = true
14. scala> fromClass(classOf[Exception]) <:< fromClass(classOf[RuntimeException])
15. res5: Boolean = false
17. scala> fromClass(classOf[Exception]) <:< fromClass(classOf[AssertionError])         
18. res6: Boolean = false
20. // now the opposite operator >:>
21. scala> fromClass(classOf[Exception]) >:> fromClass(classOf[AssertionError])
22. res7: Boolean = false
24. scala> fromClass(classOf[Exception]) >:> fromClass(classOf[RuntimeException])
25. res8: Boolean = true
27. scala> fromClass(classOf[Exception]) >:> fromClass(classOf[Error])           
28. res9: Boolean = false
30. scala> fromClass(classOf[Exception]) >:> fromClass(classOf[Throwable])
31. res10: Boolean = false
33. // the method singleType creates a manifest given an object
34. scala> ClassManifest.singleType(new RuntimeException())
35. res12: scala.reflect.Manifest[Nothing] = java.lang.RuntimeException.type
37. scala> ClassManifest.singleType(new RuntimeException()) <:< fromClass(classOf[Throwable])
38. res13: Boolean = true
40. scala> fromClass(classOf[Exception]) <:< fromClass(classOf[Throwable])                   
41. res14: Boolean = true

Now the implementation of intercepts:

1. scala> import scala.reflect.{
2.      |   Manifest, ClassManifest
3.      | }
4. import scala.reflect.{Manifest, ClassManifest}
6. scala> 
8. scala> import ClassManifest.singleType
9. import ClassManifest.singleType
11. scala>  def intercepts[E <: Throwable](test : => Unit)(implicit m:Manifest[E]) : Unit = {
12.      |     import Predef.{println => fail}
13.      |     try {
14.      |       test
15.      |       // this is a failure because test is expected to throw an exception
16.      |       fail("Expected "+m.toString+" but instead no exception was raised")
17.      |     }catch{
18.      |       // this checks that the expected type (m) is a superclass of the class of e
19.      |       case e if (m >:> singleType(e)) => ()
20.      |       // any other error is handled here
21.      |       case e => fail("Expected "+m.toString+" but instead got "+e.getClass)
22.      |     }
23.      |   }
24. intercepts: [E <: Throwable](test: => Unit)(implicit m: scala.reflect.Manifest[E])Unit
26. scala> intercepts[Exception] {println("hi :)")}                                            
27. hi :)
28. Expected java.lang.Exception but instead no exception was raised
30. scala> intercepts[Exception] { throw new IllegalArgumentException("why not throw this :)")}
32. scala> intercepts[Exception] { throw new AssertionError("The method should complain")}     
33. Expected java.lang.Exception but instead got class java.lang.AssertionError

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.         ...

Java vs Scala Control Structures

This topic is mainly for completeness. We will quickly cover the standard control structures you find in Java and see how they are the same or different in Scala.

The first thing to note is that in Scala 2.7 there is no break keyword. In Scala 2.8 there is a break control structure but it is slightly different than the Java break keyword. We will encounter that topic in a later lesson. The control structures I will quickly cover are: do-while, while, for and if.

For information about the Java case statement take a look at the several matching topics covered now and in the future.

Note: The Java ternary if statement does not exist in Scala instead the standard if statement is to be used. It is slightly more verbose but returns a value in the same way as a ternary if statement.

1. scala> var i = 0;
2. i: Int = 0
4. scala> while( i<3 ){
5.      | println( i )
6.      | i += 1
7.      | }
8. 0
9. 1
10. 2
12. scala> i = 0
13. i: Int = 0
15. scala> do {
16.      | println( i )
17.      | i += 1
18.      | } while (i<3)
19. 0
20. 1
21. 2
23. scala> for(j <- 0 until 3) println (j)  
24. 0
25. 1
26. 2
28. scala> if (i<3)
29. more
31. scala> val result = if (i<3)
32. result: Int = 10
34. scala> println (result)
35. 10
36. scala> if (i>10) println(1)
38. scala> if (i<10)
39. 1
41. // Note that the return value is ().  You can only get a meaningful return value if there is an else-clause.
42. scala> val r = if (i<10)>
43. r: Unit = ()
45. scala> println(r)
46. ()

Return values

As with most functional languages, most control structures ( if, for, try ) return values. The common java idiom:

1. String name=null;
2. if( xxx ) name="yyy";
3. else name="zzz";

can be replaced by

1. val name = if( xxx ) "yyy"; else "zzz";

The benefit (other than less boiler plate code) is that name can now be a val instead of a var.

Another other point about returns: The return keyword is not required when returning a value from methods or control structures. The last value is always the return value. This is why you will get an error if the last line in a method or control structure is an assignment.

Examples:

1. scala> val name = if( 1==2 ) "Jesse" else "Mauricio"
2. name: java.lang.String = Mauricio
4. scala> println(name)
5. Mauricio
7. scala> val collection = for( i <- 1 to 100; if(i%20 == 3) ) yield i
8. collection: Seq.Projection[Int] = RangeFM(3, 23, 43, 63, 83)
10. scala> collection.foreach( i => print( i +" ") )
11. 3 23 43 63 83
13. scala> val someObj:AnyRef = "Hello"
14. someObj: AnyRef = Hello
16. scala> val choice = someObj match {
17.      | case _:java.io.File => "File"
18.      | case _:String => "String"
19.      | case _ => "Dunno"
20.      | }
21. choice: java.lang.String = String
23. scala> val result = try {
24.      | "two".toInt
25.      | }catch{
26.      | case e:NumberFormatException => -1
27.      | case _ => 0
28.      | }
29. result: Int = -1
30. scala> var i=0
31. i: Int = 0
33. // while and do-while do not have return values
34. scala> while( i<4 ){
35.      | "22"
36.      | i += 2
37.      | }
39. scala> println( if(i>0) "great" else "less" )
40. great
42. // code blocks return the last statement
43. scala> val m = {
44.      | val x = 1
45.      | x + 2
46.      | }
47. m: Int = 3