Extract sequences (unapplySeq)

This topic continues the previous topic on matching and Extractors. Make sure you look at Extractors 1.

The first extractor topic covered the unapply method and how it is used during matching. Today I want to visit a similar method unapplySeq, which is used to match sequences. The method def unapplySeq(param):Option[Seq[T] can be used instead of unapply.

Note: if both unapply and unapplySeq are defined only unapply is used.

When matching on Sequences the _* symbol means to match an arbitrary sequence. We use this several times in the examples below

1. scala> object FindAs {
2.      | def unapplySeq(string:String):Option[List[String]] = {
3.      |    def containsA (word:String) = word.toLowerCase contains "a"
4.      | 
5.      |    if (string.toLowerCase contains "a") {
6.      |      val words = string.split ("\\s+").
7.      |                         filter (containsA _)
8.      |      Some(words.toList)
9.      |    } else {
10.      |      None
11.      |    }
12.      | }
13.      | }
14. defined module FindAs
16. // as usual you can use extractors to assign variables
17. scala> val FindAs(a,b) = "This sentence contains 2 a-s"
18. a: String = contains
19. b: String = a-s
21. // If you only care about the first variable you can use _* to 
22. // reference the rest of the sequence that you don-t care about
23. scala>  val FindAs(a, _*) = "A crazy a sentence ack!"
24. a: String = A
26. // using b @ _* we can get the rest of the sequence assigned to b
27. scala>  val FindAs(a, b@_*) = "A crazy a sentence ack!"
28. a: String = A
29. b: Seq[String] = List(crazy, a, ack!)
31. // standard matching pattern
32. scala> "This sentence contains 2 a-s" match {          
33.      | case FindAs(a,b) => println(a,b)
34.      | case _ => println("whoops")
35.      | }
36. (contains,a-s)
38. // In this example we only care that it can match not the values
39. // so we ignore all of the actual sequence by using: _* as the parameters
40. scala> "This sentence contains 2 a-s" match {          
41.      |  case FindAs(_*) => println("a match")          
42.      | }
43. a match
45. scala> "This sentence contains 2 a-s" match {
46.      | case FindAs( first, _*) => println("first word = "+first)
47.      | }
48. first word = contains
50. scala> "A crazy a sentence ack!" match {
51.      | case FindAs( first, next, rest @ _*) => println("1=%s, 2=%s, rest=%s".format(first, next, rest) )
52.      | }
53. 1=A, 2=crazy, rest=List(a, ack!)

Extractors 1 (Unapply)

When defining a match such as case Tuple2(one, two) the methods Tuple2.unapply and Tuple2.unapplySeq are called to see if that case can match the input. If one of methods return a Some(...) object then the case is considered to be a match. These methods are called Extractor methods because they essentially decompose the object into several parameters.

I will cover unapplySeq later.

Examples are the best way to illustrate the issue:

1. // The unapply method of this object takes a string and returns an Option[String]
2. //   This means that the value being matched must be a string and the value extracted is also a string
3. scala> object SingleParamExtractor {
4.      | def unapply(v:String):Option[String] = if(v.contains("Hello")) Some("Hello") else None
5.      | }
6. defined module SingleParamExtractor
8. // this Will match since the extractor will return a Some object
9. scala> "Hello World" match { case SingleParamExtractor(v) => println(v) }
10. Hello
12. // this will not match and therefore an exception will be thrown
13. scala> "Hi World" match { case SingleParamExtractor(v) => println(v) }   
14. scala.MatchError: Hi World
15.                   at .(:7)
16.                   at .()
17.                   at RequestResult$.(:3)
18.                   at RequestResult$.()
19.                   at RequestResult$result()
20.                   at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
21.                   at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
22.                   at sun.reflect.DelegatingMethodAccessorImpl.invok...
24. // This extractor converts the string to an int if possible.
25. scala> object ConvertToInt{         
26.      | def unapply(v:String):Option[Int] = try{ Some(v.toInt) } catch { case _ => None }
27.      | }
28. defined module ConvertToInt
30. scala> "10" match { case ConvertToInt(i) => println(i)}
31. 10
33. // If you want to extract multiple elements you return an Option that contains a Tuple.  
34. //   In this example we divide the string into two parts if it has a space
35. scala> object MultipleParamExtractor {                                       
36.      |  def unapply(v:String):Option[(String,String)] = (v indexOf ' ') match {           
37.      | case x if (x>0) => Some ((v take x, v drop x+1))
38.      | case _ => None
39.      | }
40.      | }
41. defined module MultipleParamExtractor
43. scala> "hello everyone :)" match { case MultipleParamExtractor(one, two) => println(one,two) }
44. (hello,everyone :))
46. // Any object with a unapply method can be used it does not have to be defined as an object
47. // So if you have a class of extractors that needs to be parameterized you can 
48. // create a class and use instances of that class for matching
49. scala> class Splitter(sep:Char){
50.      | def unapply(v:String):Option[(String,String)] = (v indexOf sep) match {
51.      | case x if (x>0) => Some ((v take x, v drop x+1))
52.      | case _ => None
53.      | }
54.      | }
55. defined class Splitter
57. // Remember that we need the matching object start with an uppercase
58. // See http://daily-scala.blogspot.com/2009/09/case-sensitive-matching.html 
59. // for details
60. scala> val SplitOnComma = new Splitter (',')
61. SplitOnComma: Splitter = Splitter@15eb9b0d
63. // How cool now can create splitters for all sorts of things
64. scala> "1,2" match { case SplitOnComma(one,two) => println(one,two)}
65. (1,2)
67. // All extractors can also be used in assignments
68. scala> val SplitOnComma(one,two) = "1,2"                           
69. one: String = 1
70. two: String = 2

Updating code blocks

I am not posting today because I am writing up a code syntax hilighter for this site so that the code is readable. The current style is a nightmare.

I will be back tomorrow.

Case-sensitive matching

One possibly surprising rule of matching is that lowercase identifiers in the case clause always have a value bound to them but if the identifier starts with an uppercase character the identifier is used as a value to match against.

1. scala> val iWantToMatch = 10
2. iWantToMatch: Int = 10
4. scala> val iDontWantToMatch = 1
5. iDontWantToMatch: Int = 1
7. scala> 10 match {
8.      | case iDontWantToMatch => "boo"
9.      | case iWantToMatch => "yay"
10.      | }
11. :7: error: unreachable code
12.        case iWantToMatch => "yay"
13.                             ^
15. // we have an error because iDontWantToMatch is treated as a parameter to the iDontWantToMatch => "boo" function.
16. // Not as a value to match against.
18. // in this example you can see how iDontWantToMatch is has 10 bound to it
20. scala> 10 match {
21.      | case iDontWantToMatch => iDontWantToMatch
22.      | }
23. res9: Int = 10
25. // back tick forces the value to be matched against
26. scala> 10 match {
27.      | case `iDontWantToMatch` => "boo"
28.      | case `iWantToMatch` => "yay"
29.      | }
30. res7: java.lang.String = yay
32. scala> val IWantToMatch = 10
33. IWantToMatch: Int = 10
35. scala> val IDontWantToMatch = 1
36. IDontWantToMatch: Int = 1
38. // also if first character is upper case it is matched against.
39. scala> 10 match {
40.      | case IDontWantToMatch => "boo"
41.      | case IWantToMatch => "yay"
42.      | }
43. res8: java.lang.String = yay

BeanProperties

In Java-land many frameworks depend on Bean style properties. Scala has an extremely handy annotation that assists in interoperating with frameworks that require bean-style interfaces. In Scala 2.7 there are only a few annotations for helping:

• @BeanProperty - Generates getters and setters for a property. (Or just a getter if the bean is a val)
• @BeanInfo - Generates the associated BeanInfo for the class

Remember that if you want frameworks to be able to create the beans you need to make a 0-arg constructor and have the bean properties as fields.

Example with bean-properties as constructor arguments. This example requires Scala 2.8 because it uses BooleanBeanProperty. You can remove that and run with Scala 2.7.x.
In this example we define a bean class and use reflection to show that all the getters and setters are generated:

1. scala> import scala.reflect._
2. import scala.reflect._    
4. scala> case class MyBean(
5.      | @BeanProperty var mutable:String,  // getter and setter should be generated
6.      | @BooleanBeanProperty var boolProp:Boolean, // is getter and normal setter should be generated
7.      | @BeanProperty val readOnly:Int) // only a getter should be generated
9. defined class MyBean
11. scala> val beanClass = classOf[MyBean]
12. beanClass: java.lang.Class[MyBean] = class MyBean
14. scala> val beanMethods = beanClass.getDeclaredMethods.filter( _.getName.matches("(get|is|set).+"))
15. beanMethods: Array[java.lang.reflect.Method] = Array(public java.lang.String MyBean.getMutable(), public boolean MyBean.isBoolProp(), public int MyBean.getReadOnly(), public void MyBean.setBoolProp(boolean\
16. ), public void MyBean.setMutable(java.lang.String))
18. scala> println( beanMethods map (_.getName) mkString("\n"))
19. getMutable
20. isBoolProp
21. getReadOnly
22. setBoolProp
23. setMutable

This next example would not run in the REPL for some reason so you must copy-paste it into a file, compile and run. Instructions:

1. copy and paste code into bean.scala
2. scalac bean.scala
3. scala -cp . MyBean

1. import scala.reflect._
3. class MyBean{
4.   @BeanProperty
5.   var mutable:String = ""
6. }
8. object MyBean{
9.   def apply(mutable:String) = {
10.     val bean = new MyBean()
11.     bean.mutable = mutable
12.     bean
13.   }
15.   def main(args:Array[String]){
17.     import java.beans._
19.     val result = new java.io.ByteArrayOutputStream
20.     val encoder = new XMLEncoder(result)
21.     val bean = MyBean("hello")
22.     encoder.writeObject( bean )
23.     encoder.close
24.     println(result.toString)
25.   }
26. }

UnfoldLeft and Right

Todays topic does not introduce anything new, it just a useful example of using a function to create a list of objects. This is NOT part of the standard library.

The methods are called unfoldRight and unfoldLeft because they are more or less the inverse of foldLeft and foldRight. foldLeft and Right run a function on each element in a list producing some result. unfoldLeft and right produce a list from a function and a seed value. The List is created from executing the function repeatedly with the result from the previous execution (or the seed value). Each function call returns a result which is the element in the list. The list is done when the function returns None rather than Some(x).

This sample is directly derived from the samples: http://paste.pocoo.org/show/140865/

Remember the performance differences between the two. Adding an element to the head of scala list is a constant operation but adding an element to the end(tail) of the list is linear time based on the size of the list. So unfoldLeft will typically suffer from worse performance.

1. scala> def unfoldRight[A, B](seed: B)(f: B => Option[(A, B)]): List[A] = f(seed) match {
2.      |   case Some((a, b)) => a :: unfoldRight(b)(f)
3.      |   case None => Nil
4.      | }
5. unfoldRight: [A,B](B)((B) => Option[(A, B)])List[A]
7. scala> unfoldRight(10) { x => if (x == 0) None else Some((x, x - 1)) }
8. res0: List[Int] = List(10, 9, 8, 7, 6, 5, 4, 3, 2, 1)
10. scala> unfoldRight("Jesse") { x => if (x.length == 0) None else Some((x, x.drop(1).toString)) }
11. res2: List[java.lang.String] = List(Jesse, esse, sse, se, e)
13. scala> def unfoldLeft[A, B](seed: B)(f: B => Option[(B, A)]) = {
14.      |   def loop(seed: B)(ls: List[A]): List[A] = f(seed) match {
15.      |     case Some((b, a)) => loop(b)(a :: ls)
16.      |     case None => ls
17.      |   }
18.      |
19.      |   loop(seed)(Nil)
20.      | }
21. unfoldLeft: [A,B](B)((B) => Option[(B, A)])List[A]
23. scala> unfoldLeft(1) { x => if (x == 11) None else Some((x + 1, x)) }
24. res0: List[Int] = List(10, 9, 8, 7, 6, 5, 4, 3, 2, 1)
26. // Notice that the result is ordered in the opposite way from unfoldRight
27. // Also notice the order of the list is reversed since the algorithm is the same but
28. // unfoldLeft adds to end of list.
29. scala> unfoldLeft("Jesse")  { x => if (x.length == 0) None else Some((x.drop(1).toString,x)) }
30. res1: List[java.lang.String] = List(e, se, sse, esse, Jesse)

Lazy Val

One nice feature built into Scala are "lazy val" values. Essentially they are the lazy initialization pattern that is very commonly implemented in Java programs (and very commonly incorrectly implemented). When a val is declared with the lazy modifier the right-hand side of the value (the definition) will not be executed until the first time the value is accessed.

A related forth coming topic is the topic on lazy collections and projections and streams. They are all ways to lazily evaluate collections.

Note: The code for today must be put in a file and executed. Lazy val's cannot be demonstrated in the REPL because after each value is declared in a REPL the variable is accessed and it is printed out in the next line. If I considered it important enough I could have defined a method in the REPL, put the code in the method and then called the method and demonstrated it and if you wish feel free to do that. But I recommend creating a file and running scala yourfile

Examples:

1. val normalVal = {
2.   println("---->>>   Initializing normal val    <<<----");
3.   "This is the normal val"
4. }
6. lazy val lazyVal = {
7.   println("---->>>   Initializing lazy val   <<<----");
8.   "This is the lazy val"
9. }
11. println ("\n\nno references have been made yet\n\n")
12. println ("Accessing normal val : ")
13. println(normalVal)
14. println ("\n\nAccessing lazy val : ")
15. println(lazyVal)
16. println ("\n\nAccessing lazy val a second time, there should be no initialization now: ")
17. println(lazyVal)

Tuples and the -> implicit method

Defined in the Predef object are several implicit methods. All implicit methods defined in the Predef method are applicable to all programs without importing them. One such method is the -> method. This method is applicable to all objects and creates a Tuple2.

Examples:

1. // normal way to make a Tuple2
2. scala> (1,2)
3. res3: (Int, Int) = (1,2)
5. // another way to make a Tuple2 using the implicit -> method
6. scala> 1 -> 2
7. res2: (Int, Int) = (1,2)
9. // Creating a map using the normal tuples creation mechanism
10. scala> Map (("one",1),
11.      |      ("two",2))
12. res5: scala.collection.immutable.Map[java.lang.String,Int] = Map(one -> 1, two -> 2)
14. // -> syntax allows a second "prettier" way of creating the Map
15. scala> Map("one" -> 1,
16.      |     "two" -> 2)
17. res6: scala.collection.immutable.Map[java.lang.String,Int] = Map(one -> 1, two -> 2)

Matching Regular expressions

This topic is derived from the blog post: Using pattern matching with regular expressions in Scala

The Regex class in Scala provides a very handy feature that allows you to match against regular expressions. This makes dealing with certain types of regular expression very clean and easy to follow.

What needs to be done is to create a Regex class and assign it to a val. It is recommended that the val starts with an Uppercase letter, see the topic of matching about the assumptions matching makes based on the first letter of the Match case clause.

There is nothing like examples to help explain an idea:

1. // I normally use raw strings (""") for regular expressions so that I don't have to escape all \ characters
2. // There are two ways to create Regex objects.
3. // 1. Use the RichString's r method
4. // 2. Create it using the normal Regex constructor
5. scala> val Name = """(\w+)\s+(\w+)""".r
6. Name: scala.util.matching.Regex = (\w+)\s+(\w+)
8. scala> import scala.util.matching._
9. import scala.util.matching._
11. // Notice the val name starts with an upper case letter
12. scala> val Name = new Regex("""(\w+)\s+(\w+)""")
13. Name: scala.util.matching.Regex = (\w+)\s+(\w+)
15. scala> "Jesse Eichar" match {
16.      | case Name(first,last) => println("found: ", first, last)
17.      | case _ => println("oh no!")
18.      | }
19. (found: ,Jesse,Eichar)
21. scala> val FullName = """(\w+)\s+(\w+)\s+(\w+)""".r
22. FullName: scala.util.matching.Regex = (\w+)\s+(\w+)\s+(\w+)
24. // If you KNOW that the match will work you can assign it to a variable
25. // Only do this if you are sure the match will work otherwise you will get a MatchError
26. scala> val FullName(first, middle, last) = "Jesse Dale Eichar"
27. first: String = Jesse
28. middle: String = Dale
29. last: String = Eichar

Syntactic sugar

In the spirit of making Scala scalable from scripts up to systems, Scala contains some syntactic sugar to make scripting and internal DSLs a bit easier to write. For example there are several situations where the '.' and '()' for method calls are optional. Semi-colons are optional (except for single-line statements).

There are some corner cases but the basic rule is that you need an odd number of arguments if you wish leave out the '.'.
Examples:

1. scala> "hello" substring (1,3)
2. res0: java.lang.String = el
4. scala> "hello" substring 1
5. res1: java.lang.String = ello
7. scala> 1 toString ()
8. res2: java.lang.String = 1

Precendence runs left to right so:

1. "hello" contains "hello world" toString ()

becomes

1. "hello".contains("hello world").toString()

Another example:

1. scala> "hello" contains "hello world" toString () substring 4
2. res6: java.lang.String = e
4. scala> "hello".contains("hello world").toString().substring(4)
5. res7: java.lang.String = e

There is some operator precendence which we will cover later. Operator precedence allows statements like the following:

1. scala> "hello" substring 6 - 4
2. res8: java.lang.String = llo
4. scala> "hello" substring  (6 - 4)
5. res9: java.lang.String = llo
7. scala> "hello".substring  (6 - 4)
8. res10: java.lang.String = llo

Factory Methods and Companion Objects

One of the most common uses of a companion object (See Companion Objects for more) is as a factory for creating instances of the class. For example, there may be several overloaded apply methods which provide different ways of instantiating the object. This is often preferred to adding many constructors because Scala places restrictions on constructors that Java does not have.

One built in example of Factory methods in a companion object are when you create a case class.

Examples:

1. scala> case class Data(p1:Int, p2:String)
2. defined class Data
4. // This is using the generated (or synthetic) factory method.
5. // call case classes have a factory method generated
6. scala> Data(1,"one")
7. res0: Data = Data(1,one)
9. // This is the normal new syntax.
10. // case-classes are normal object so they have one of these too
11. scala> new Data(1,"one")
12. res1: Data = Data(1,one)
14. scala> class MyClass(val p1:Int, val p2:String)
15. defined class MyClass
17. // MyClass is a normal class so there is no
18. // synthetic factory method
19. scala> MyClass(1,"one")
20. :5: error: not found: value MyClass
21.        MyClass(1,"one")
22.        ^
24. // but of course you can create an instance normally
25. scala> new MyClass(1,"one")
26. res3: MyClass = MyClass@55444319
28. // create the companion object with an apply factory method
29. scala> object MyClass{
30.      | def apply(p1:Int, p2:String)=new MyClass(p1,p2)
31.      | }
32. defined module MyClass
34. // now you can create MyClass as if it was a case-class
35. // It is not a case-class so you still don't have the other
36. // synthetic methods like: equals, hash-code, toString, etc...
37. scala> MyClass(1,"one")
38. res4: MyClass = MyClass@2c5e5c15

Scala .Net

Just an interesting tidbit you may not know. Scala is also available on the .Net platform. Although to be sure it is not as complete as the Java version. But the point is that there is an additional value add to learning Scala.

http://www.scala-lang.org/node/168

Assignments

Assignment in Scala follows more or less the same rules as Java and other related rules. There are some differences.

Increment operators do not work (i++). As I understand it the rational is that it is too specific an idiom. There is not an easy way to generalize it. Instead you must use i += 1.

Assignments do not return a value. For example you cannot do val i = j = 2 or while( (i = read(buffer)) > 0 ){...}.

One feature that is fairly unique in Scala is the ability to expand a case-class or other class that has an associated extractor. For details look at the previous topic Assignment and Parameter Objects.

Examples:

1. scala> val i,j=2
2. i: Int = 2
3. j: Int = 2
5. scala> val (i,j) = (1,2)
6. i: Int = 1
7. j: Int = 2
9. scala> val (i,j,k) = (1,"two",3.0)
10. i: Int = 1
11. j: java.lang.String = two
12. k: Double = 3.0
14. scala> case class Data( name:String, age:Int, weight:Float)
15. defined class Data
17. scala> val Data(name, age, weight) = Data("Jesse", 133, 100f)
18. name: String = Jesse
19. age: Int = 133
20. weight: Float = 100.0
22. scala> val value = 1
23. value: Int = 1
25. scala> i += 1
26. :10: error: reassignment to val
27.        i += 1
28.          ^
30. scala> var variable = 1
31. variable: Int = 1
33. scala> variable += 1
35. scala> println(variable)
36. 2

Using objects to access trait functionality

Today's topic is based on an article by Bill Venners. http://www.artima.com/scalazine/articles/selfless_trait_pattern.html. I recommend reading that article as it goes into much more detail. I also recommend taking a look at the earlier topic that covers companion objects.

The normal way to use a trait is to mix it in to an object. However there can be a problem mixing two traits containing methods with equal signatures. If the two traits are not designed to work together then you will get a compile error. Otherwise one method will override the other. Either way you cannot access both methods. There is an additional way to access the functionality of a trait. You can create an object (not instance) that extends the trait and import the methods when you need them.

If the trait is stateless then the object can be shared if not then make sure that sharing the object is carefully handled.

Examples:

1. scala> trait T1 {
2.      | def talk = "hi"
3.      | }
4. defined trait T1
6. scala> trait T2 {
7.      | def talk = "hello"
8.      | }
9. defined trait T2
11. // Cannot extend C with T1 and T2 because they are not designed to work together
12. scala> class C extends T1 with T2
13. :6: error: error overriding method talk in trait T1 of type => java.lang.String;
14.  method talk in trait T2 of type => java.lang.String needs override modifier
15.        class C extends T1 with T2
16.              ^
18. scala> class C extends T1
19. defined class C
21. // objects can have state so becareful how you share them
22. scala> object Obj1 extends T1
23. defined module Obj1
25. scala> object Obj2 extends T2
26. defined module Obj2
28. // You can give aliases to the imported methods and use them in the class
29. scala> class C {
30.      | import Obj1.{talk => hi}
31.      | import Obj2.{talk => hello}
32.      | def sayHi = hi
33.      | def sayHello = hello
34.      | }
35. defined class C
37. scala> val c = new C
38. c: C = C@54d8fd1a
40. scala> c.sayHi
41. res0: java.lang.String = hi
43. scala> c.sayHello
44. res1: java.lang.String = hello
46. scala> class C extends T1 {
47.      | import Obj2.{talk => hello}
48.      | def helloTalk = hello
49.      | }
50. defined class C
52. scala> val c2 = new C
53. c2: C = C@2ee634bf
55. scala> c2.talk
56. res2: java.lang.String = hi
58. scala> c2.helloTalk
59. res5: java.lang.String = hello

Companion Object

A companion object is an object with the same name as a class or trait and is defined in the same source file as the associated file or trait. A companion object differs from other objects as it has access rights to the class/trait that other objects do not. In particular it can access methods and fields that are private in the class/trait.

An analog to a companion object in Java is having a class with static methods. In Scala you would move the static methods to a Companion object.

One of the most common uses of a companion object is to define factory methods for class. An example is case-classes. When a case-class is declared a companion object is created for the case-class with a factory method that has the same signature as the primary constructor of the case class. That is why one can create a case-class like: MyCaseClass(param1, param2). No new element is required for case-class instantiation.

A second common use-case for companion objects is to create extractors for the class. I will mention extractors in a future topic. Basically extractors allow matching to work with arbitrary classes.

NOTE: Because the companion object and the class must be defined in the same source file you cannot create them in the interpreter. So copy the following example into a file and run it in script mode:

scala mysourcefile.scala


Example:

1. class MyString(val jString:String) {
2.   private var extraData = ""
3.   override def toString = jString+extraData
4. }
6. object MyString {
7.   def apply(base:String, extras:String) = {
8.     val s = new MyString(base)
9.     s.extraData = extras
10.     s
11.   }
12.   def apply(base:String) = new MyString(base)
13. }
15. println(MyString("hello"," world"))
16. println(MyString("hello"))

Collection/Iterable/Iterator foldRight and foldLeft

Folding and reducing are two types of operations that are both very important with dealing with collections in Scala (and other functional languages). This topic covers the fold operations. The reduce topic was previously covered.

A simplistic explanation is they allow processing of the collections. I think about foldRight and foldLeft to be very similar to a visitor that visits each element and performs a calculation. It does not change the values of the collection instead it calculates a result from visiting each element. In Java you might see the following pattern:

1. class Collection {
2.   pubic Result op( Result startingValue, Op operation){...}
3. }
5. interface Op{
6.   public Result op( Object nextCollectionElem, Result lastCalculatedResult)
7. }

To a Java programmer this is pretty obvious how you use it. This is essentially the fold operation. The difference is we are using closures so there is almost no boilerplate and all collection/Iteratore/Iterable interfaces have the fold methods.

One last point before examples. For fold and reduce operations there are both foldLeft and foldRight and similarly reduceLeft and reduceRight. These indicate the order that a collection is processed. Note that for certain collections one direction is more performant that the other. Lists, for example, are better to process left to right because of the datastructure used.

Some tasks that are suited to fold are:

• Find the 5 smallest elements in a list
• Sum all the values of a Map together
• Sum the lengths of the Strings contained in the collection

There are a number of ways that fold can be written syntactically. The following examples are ways to sum together the integers of a Map. Note that /: is an alias for foldLeft and :/ is an alias for foldRight. Normally foldLeft and foldRight should be used unless the rest of the developers who will be reading the code are quite confortable reading Scala.

1. // fold right processes from left to right
2. scala> val m = Map(1 -> "one", 2 -> "two", 3 -> "three")
3. m: scala.collection.immutable.Map[Int,java.lang.String] = Map(1 -> one, 2 -> two, 3 -> three)
5. scala> m.foldRight(0)((kv: (Int, String), a : Int) => a+kv._2.length)
6. res1: Int = 11
8. scala> (m :\ 0)((kv: (Int, String), a : Int) => a+kv._2.length)
9. res5: Int = 11
11. scala> m.foldRight(0){ case ((key, value), a) => a+value.length}
12. res7: Int = 11
14. scala> m.foldRight(0){ case (kv, a) => a+kv._2.length} }}
15. res8: Int = 11
17. // fold left processes from right to left (usually slower than foldRight)
18. scala> val m = Map("a" -> 1, "b" -> 2, "c" -> 3)
19. m: scala.collection.immutable.Map[java.lang.String,Int] = Map(a -> 1, b -> 2, c -> 3)
21. scala> m.foldLeft(0)( (accum, kv) => accum + kv._2 )
22. res9: Int = 6
24. scala> m.foldLeft(0){case (accum, (key, value)) => accum + value}
25. res5: Int = 6
27. scala> (0 /: m){case (accum, (key, value)) => accum + value}
28. res4: Int = 6

Collection/Iterable/Iterator reduceRight and reduceLeft

Folding and reducing are two types of operations that are both very important when dealing with collections in Scala (and other functional languages). This topic covers the reduce operations. The fold topic will be covered shortly.

A simplistic (probably over-simplistic) explanation is they allow processing of the collections. One can consider foldRight and foldLeft to be very similar to a visitor that visits each element and performs a calculation. It does not change the values of the collection, instead it calculates a result from visiting each element. In Java you might see the following pattern:

1. class Collection {
2.   pubic Result op( Result startingValue, Op operation){...}
3. }
5. interface Op{
6.   public Result op( Object nextCollectionElem, Result lastCalculatedResult)
7. }

To a Java programmer this is pretty obvious how you use it. Reduce operations are similar but very narrow in scope. They only return values that are of the same type as the original collection (IE a list of Int will return an Int from reduce) and there is no initial seed value. The first two inputs are the first and second elements of the collection. If there is only one element then that element is returned.

Reduce might look like the following in Java:

1. class Collection {
2.   pubic Integer op(Op operation){...}
3. }
5. interface Op{
6.   public Integer op( Integer nextElem, Int lastCalculatedResult)
7. }

One last point before examples. For fold and reduce operations there are both foldLeft and foldRight and similarly reduceLeft and reduceRight. These indicate the order that a collection is processed. Note that for certain collections one direction is more performant that the other. Lists, for example, are better to process left to right because of the datastructure used.

Some problems that are ideally suited to reduce:

• Calculate the minimum value of a collection
• Calculate the sum of a collection

1. scala> val list = List("one", "two", "three")
2. list: List[java.lang.String] = List(one, two, three)
4. scala> list reduceRight ((elem, result) => {if (elem.length < result.length ) elem else result})
5. res2: java.lang.String = two
7. // reduce left has the order of parameter reversed.
8. scala> list reduceLeft ((result, elem) => {if (elem.length < result.length ) elem else result})
9. res4: java.lang.String = one
11. // if only 1 element that element is returned
12. scala> List("one") reduceRight ((elem, result) => {if (elem.length < result.length ) elem else result})
13. res3: java.lang.String = one
15. // the two following are equivalent.  _ indicates one arguement.  If there are two arguments the first _ is the first argument and the second _ is the second argument
16. scala> List(1,2,3) reduceRight ((elem, result) => {elem + result})
17. res6: Int = 6
19. scala> List(1,2,3) reduceRight ( _ + _ )
20. res5: Int = 6
22. // find minimum.  Four equivalent ways to write it
23. scala> List(1,2,3) reduceRight ((elem, result) => {elem.min(result)})
24. res11: Int = 1
26. scala> List(1,2,3) reduceRight ((elem, result) => {elem min result})
27. res12: Int = 1
29. scala> List(1,2,3) reduceRight (_.min(_))
30. res10: Int = 1
32. scala> List(1,2,3) reduceRight ( _ min _ )
33. res9: Int = 1

Exception handling

In Scala exceptions are not checked so effectively all exceptions are runtime exceptions. When you want to handle exceptions you use a try {...} catch {...} block like you would in Java except that the catch block uses matching to identify and handle the exceptions. This creates a very powerful but light-weight way to handle exceptions:

1. scala> def handle( f: => Unit ) = {
2.      | try { f } catch {
3.      | case _:AssertionError => println ("Whoops an assertion error")
4.      | case r:RuntimeException => println ("Runtime Exception: "+ r.getStackTraceString)
5.      | case e if (e.getMessage == null) => println ("Unknown exception with no message")
6.      | case e => println ("An unknown error has been caught" + e.getMessage)
7.      | }
8.      | }
9. handle: (=> Unit)Unit
11. scala> handle { throw new AssertionError("big bad error") }
12. Whoops an assertion error
14. scala> handle { throw new IllegalArgumentException("Sooooo illegal") }
15. Runtime Exception: line9$object$$iw$$iw$$iw$$anonfun$1.apply(:8)
16. line9$object$$iw$$iw$$iw$$anonfun$1.apply(:8)
17. line7$object$$iw$$iw$$iw$.handle(:7)
18. line9$object$$iw$$iw$$iw$.(:8)
19. line9$object$$iw$$iw$$iw$.()
20. RequestResult$line9$object$.(:3)
21. RequestResult$line9$object$.()
22. RequestResult$line9$object.result()
23. sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
24. sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
25. sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
26. java.lang.reflect.Method.invoke(Method.java:597)
27. scala.tools.nsc.Interpreter$Request.loadAndRun(Interpreter.scala:889)
28. scala.tools.nsc.Interpreter.interpret(Interpreter.scala:508)
29. scala.tools.nsc.Interpreter.interpret(Interpreter.scala:494)
30. scala.tools.nsc.InterpreterLoop.interpretStartingWith(InterpreterLoop.scala:242)
31. scala.tools.nsc.InterpreterLoop.command(InterpreterLoop.scala:230)
32. scala.tools.nsc.InterpreterLoop.repl(InterpreterLoop.scala:142)
33. scala.tools.nsc.InterpreterLoop.main(InterpreterLoop.scala:298)
34. scala.tools.nsc.MainGenericRunner$.main(MainGenericRunner.scala:141)
35. scala.tools.nsc.MainGenericRunner.main(MainGenericRunner.scala)
37. scala> handle{ throw new java.io.IOException("cant read something") }
38. An unknown error has been caughtcant read something

Adding methods using Traits

One useful application of a trait is the case where you want to add functionality to an existing class. In this example I have a class provided by a third party library (in this just a simple StringReader class from the Java library). But I want to be able to read lines as well as use the standard read methods.

One solution is to create a trait and when I instantiate the StringReader mix in the new trait. Code like new StringReader() with Lines results in a new class that extends StringReader and the trait Lines. As a result we have all the methods of StringReader and Lines. The biggest benefit is that we can define the trait to work with any Reader and then when we create the real instance we can mix it in to any class that extends Reader.

The other solution that can be used is to create an implicit conversion from StringReader to some other class. There are two draw backs here:

• It is harder to tell what is happening
• A trait can contain state but a "view" (which is what you get when one class is implicitly converted to another class) has no state it is just a view of the original class. In this example a view would work but in other examples like creating a pushback reader, it would not work.

Here is a simple example:

1. scala> trait Lines {
2.      | // the self type declares what type of class the trait can be applied to
3.      | // if there is no self type then it is assumed it can be applied to Any type
4.      | self:java.io.Reader =>
5.      | def nextLine:Option[String] = {
6.      | val builder = new scala.collection.mutable.StringBuilder()
7.      |
8.      | var next = read()
9.      |
10.      | while( next != -1 && next.toByte.toChar != '\n' ){
11.      | builder += next.toByte.toChar
12.      | next = read()
13.      | }
14.      |
15.      | if( builder.isEmpty ) None
16.      | else Some(builder.toString)
17.      | }
18.      | }
19. defined trait Lines
21. // Strings starting and ending with (""") are called raw strings.  All characters 
22. // within """ """ are automatically escaped.
23. // I am creating a reader and mixing in the Lines trait on construction
24. scala> val reader = new java.io.StringReader( """line one
25.      | line two""" with Lines
26. reader: java.io.StringReader with Lines = $anon$1@3850620f
28. scala> reader.nextLine
29. res0: Option[String] = Some(line one)
31. scala> reader.nextLine
32. res1: Option[String] = Some(line two)
34. scala> reader.nextLine
35. res2: Option[String] = None
37. scala> reader.nextLine
38. res3: Option[String] = None
40. // we can define a method that takes a reader with lines
41. scala> def toCollection( reader:java.io.StringReader with Lines) = {
42.      | def collect:List[String] = reader.nextLine match {
43.      |   case None => Nil
44.      |    // we do not need to worry about stack overflow
45.      |    // because of tail recursion.  This method cannot be
46.      |    // extended and collect is the last like in the collect
47.      |    // method so this method will be transformed into a loop
48.      |   case Some( line ) => line :: collect
49.      | }
50.      |
51.      | collect
52.      | }
53. toCollection: (reader: java.io.StringReader with Lines)List[String]
55. scala> toCollection( new java.io.StringReader( "line one\nlinetwo" ) with Lines).size
56. res8: Int = 2

Refactoring if to match

One of the refactorings I find myself doing quite often in Scala is converting large branching if trees into an easy to read match statement. The reasoning is that it is much easier to read a match statement because it is like reading bullet points rather than trying to follow the flow of information through a tree of if statements.

Before you complain, I realize there are other ways to refactor a tree of if-statements but I find the match statements the easiest to reason about and the quickest to write with the least amount of boiler plate.

Here is an example where I need to see if the file is dirty and needs to be regenerated, if it is clean or if some one has modified the generated file (which results in a CONFLICT).

1. object State extends Enumeration {
2.   final val DIRTY, CLEAN, CONFLICT = Value
3. }
6. if( !pom.file.exists ){
7.   DIRTY;
8. }else if (checksum.file.exists) {
9.   val sha = new String(MessageDigest.getInstance("SHA").digest( pom.slurp.getBytes ))
10.   if( sha == checksum.slurp ) CLEAN
11.   else DIRTY
12. } else {
13.   CONFLICT
14. }
18. pomFile(massFile) match {
19.   case (pom, checksum) if (!pom.file.exists) => DIRTY
20.   case (pom, checksum) if (!checksum.file.exists) => CONFLICT
21.   case (pom, checksum) => {
22.     val sha = new String(MessageDigest.getInstance("SHA").digest( pom.slurp.getBytes ))
23.     if( sha == checksum.slurp ) CLEAN
24.     else DIRTY
25.   }
26. }