A quick note. ScalaDays Rocks! Wish you were here :)

This topic just demonstrates a cute little trick that can occasionally be quite useful:

1. scala> List(1,2,3) ++ Some(4)
2. res0: List[Int] = List(1, 2, 3, 4)
4. scala> List(1,2,3) ++ None   
5. res1: List[Int] = List(1, 2, 3)

Options are implicitly converted to Iterables, so Options can be appended to collections.

1. scala> val x : Iterable[Int] = None       
2. x: Iterable[Int] = List()
4. scala> val x : Iterable[Int] = Some(4)
5. x: Iterable[Int] = List(4)

Operators

Since Scala allows one to define the behavior of operators there are some rules involving operators and assignment like +=. One of the standard method calls in most languages is i += 1.

Since i+=1(no spaces) is also valid, Scala has some rules regarding how statements like i+=1 should be broken up. Obviously we know it should be 'i' '+=' and '1'. So there is a special class of characters called operators. I don't know all of them but a few are: + - ^ * / % ! | & =( ':' is sort of part of this group but has some special properties as well).

These characters can be method names but they cannot be combined with other identifier characters.

Update: These characters can be combined with other identifier characters if there is an under score so:

1. def x+ = 3   // not valid
2. def x_+ = 3  // valid
3. def +x = 3   // not valid

However these characters are special because they can be combined in a special way with '=' for a special assignment construct as shown in the next post.

(end update)

1. scala> case class MyClass(i:Int) {
2.      | def +(j:Int) = new MyClass(j + i)
3.      | def -(j:Int) = new MyClass(i - j)
4.      | def ^(j:Int) = MyClass(j)
5.      | def +|(j:Int) = new MyClass(j + i / 3)
6.      | }
7.  
8.  scala> val c = MyClass(3)
9.  c: MyClass = MyClass(3)
11.  scala> c + 4
12.  res26: MyClass = MyClass(7)
14.  scala> c-2 
15.  res27: MyClass = MyClass(1)
17.  scala> c -6
18.  res28: MyClass = MyClass(-3)
20.  scala> c ^ 3
21.  res29: MyClass = MyClass(3)
23.  scala> c+|5
24.  res31: MyClass = MyClass(6)

Assert, Require, Assume

Very simple but useful are the methods assert, require and assume which are built into the Predef object. As you might expect they are methods for performing certain checks during runtime to verify certain conditions. They do not use the Java assert framework and therefore are always evaluated regardless of whether or not assertions are enabled.

Update: Scala 2.8 has an annotation called elidable that will (when 2.8 is complete) allow one to remove method calls at compile time by setting a compiler flag. The assert, etc... methods are all marked with this flag and as a result can be removed at compile time for production environments.

Scala2.8

1. scala> var called = 0
2. called: Int = 0
4. scala> called
5. res0: Int = 0
7. /*
8. assert, require and assume have call by name parameters so the message is only 
9. calculated when the assertion fails.
10. */
11. scala> assert (called == 0, {called += 1; println("called is not 0")})
13. scala> require (called == 0, {called += 1; println("called is not 0")})
15. scala> assume (called == 0, {called += 1; println("called is not 0")}) 
17. scala> called = 1
18. called: Int = 1
20. // demonstrating that the method is in fact called when the assertion fails
21. scala> assert (called == 0, {called += 1; println("called is not 0")}) 
22. called is not 0
23. java.lang.AssertionError: assertion failed: ()
24. at scala.Predef$.assert(Predef.scala:95)
25. ...
27. scala> called
28. res4: Int = 2
30. /*
31. Require is intended to be used as a precondition of a method so 
32. it throws an IllegalArgumentException, not an AssertionError
33. */
34. scala> require (called == 0, {called += 1; println("called is not 0")})
35. called is not 0
36. java.lang.IllegalArgumentException: requirement failed: ()
37. at scala.Predef$.require(Predef.scala:117)
38. ...
40. scala> called                                                          
41. res6: Int = 3
43. scala> assume (called == 0, {called += 1; println("called is not 0")}) 
44. called is not 0
45. java.lang.AssertionError: assumption failed: ()
46. at scala.Predef$.assume(Predef.scala:107)
47. ...
49. scala> called                                                         
50. res8: Int = 4

scala 2.7.7

1. /*
2. In Scala 2.7 the parameter is evaluated before the 
3. method is called so the side effect of the message causes
4. the assertion to fail
5. */
6. scala> assert (called == 0, {called += 1; println("called is not 0")})
7. called is not 0
9. scala> called
10. res2: Int = 1

Unzip

_ Scala 2.8 only tip _

Unzip is a handy companion to partition.
- Partition divides a traversable into two traversables by a boolean predicate.
- Unzip divides a traversable into two by dividing each element into two parts (each becomes an element in one traversable). If an element is a Tuple2 then each tuple is divided into two otherwise a function is required to divide an element into two.

1. // basic usage
2. scala> List((1,2),(2,3)).unzip
3. res2: (List[Int], List[Int]) = (List(1, 2),List(2, 3))
5. /* 
6. tuples can be of different types 
7. and the resulting traversables reflect the differing types
8. */
9. scala> List((2,"a"),(3,"b")).unzip
10. res3: (List[Int], List[java.lang.String]) = (List(2, 3),List(a, b))
12. // Maps are Traversable[Collection] so unzip works with them
13. scala> Map(1 -> 2, 3 -> 4).unzip
14. res1: (scala.collection.immutable.Iterable[Int], scala.collection.immutable.Iterable[Int]) = (List(1, 3),List(2, 4))
16. // Of course sets result in sets and duplicates are collected to a single element
17. scala> Set((1,2),(2,2)).unzip
18. res7: (scala.collection.immutable.Set[Int], scala.collection.immutable.Set[Int]) = (Set(1, 2),Set(2))
20. /*
21. Arbitrary elements can be unziped if a method is provided to decompose each element
22. */
23. scala> List("one word", "another word").unzip {e => (e takeWhile {_ != ' '}, e dropWhile {_ != ' '})} 
24. res6: (List[String], List[String]) = (List(one, another),List( word,  word))
26. /*
27. The following shows the same function 
28. applied with map.  It results in a single
29.  list of Tuples rather than two lists of single elements
30.  */
31. scala> List("one word", "another word").map {e => (e takeWhile {_ != ' '}, e dropWhile {_ != ' '})}  
32. res8: List[(String, String)] = List((one, word), (another, word))

Chaining Options with orElse

A simple but handy use for Option is to select the first valid option from a selection of possible choices. Sound vague? Well it is because it can be used in many different situations. The one presented here is: the program needs a directory that can be set by the user either as a system variable, and environment variable or the default value. The java code is a nightmare of if (xxx == null) statements. The Scala code is beautiful.

1. scala> val propsTemplates = Option(System getProperty "MVN_CREATOR_TEMPLATES")
2. propsTemplates: Option[java.lang.String] = None
4. scala> val envTemplates = Option(System getenv "MVN_CREATOR_TEMPLATES")
5. envTemplates: Option[java.lang.String] = None
7. scala> val defaultHome = Some(System getProperty "user.home")
8. defaultHome: Some[java.lang.String] = Some(/Users/jeichar)
10. /* 
11. chain the different options together in order of priority and get the value
13. I am taking a small liberty here because I am assuming that user.home is always available
14. */
16. scala> propsTemplates.orElse(envTemplates).orElse(defaultHome).get
17. res0: java.lang.String = /Users/jeichar
19. // alternative form:
20. scala> propsTemplates orElse envTemplates orElse defaultHome get
21. res1: java.lang.String = /Users/jeichar

Guard Sugar

This topic is a simple tip for a cleaner syntax for guards. Guards/filters are statements in for-comprehensions and case statements that guard or filter matches. Often you will see them as follows:

1. scala> for (i <- 1 to 10; if (i % 2 == 1)) yield i
2. res0: scala.collection.immutable.IndexedSeq[Int] = IndexedSeq(1, 3, 5, 7, 9)
4. scala> util.Random.nextInt(10) match {
5.      | case i if(i>5) => println("hi")
6.      | case _ => println("low")
7.      | }
8. low

However you have the option to apply a little sugar to the statements cleaning them up a little:

1. scala> for (i <- 1 to 10; if i % 2 == 1) yield i  
2. res2: scala.collection.immutable.IndexedSeq[Int] = IndexedSeq(1, 3, 5, 7, 9)
4. scala> util.Random.nextInt(10) match {          
5.      | case i if i>5 => println("hi")           
6.      | case _ => println("low")                 
7.      | }
8. hi

As you can see the brackets are optional. That is because in both cases the brackets are not required for the parser to determine the start and end of the guard statements. They are added so that the "normal" syntax used in the typical if statements will compile.

1. scala> 10 match { case i if i == 1 || i == 10 => "obviously this is a match"} 
2. res4: java.lang.String = obviously this is a match
4. /*
5. In case statements you can split the if almost any way you want because it is very clearly bound by the if and the => that is required for all case statements with a guard
6. */
7. scala> 10 match { case i if i == 1 ||                                        
8.      | i == 10 => "obviously this is a match"}
9. res5: java.lang.String = obviously this is a match
11. scala> 10 match {        
12.      | case i
13.      | if
14.      | i == 1
15.      | ||
16.      | i == 10 
17.      | => "matched"
18.      | }
19. res6: java.lang.String = matched
21. /*
22. For-comprehensions are not as flexible since it is harder for the compiler to determine where the guard ends. So try to keep it on one line or otherwise make it a function.  That is probably good advice for case statements as well.
23. */
24. scala> for { 
25.      | x <- 1 to 10
26.      | if
27.      | x > 10
28.      | || x == 2 } yield x
29. < console>:5: error: '<-' expected but integer literal found.
30.        || x == 2 } yield x
31.                ^
32. < console>:5: error: illegal start of simple expression
33.        || x == 2 } yield x
34.                  ^
36. scala> for {              
37.      | x <- 1 to 10       
38.      | if x == 1 || x == 10 } yield x
39. res7: scala.collection.immutable.IndexedSeq[Int] = IndexedSeq(1, 10)

Specs BDD Testing framework

This is the second Scala test framework topic and focuses on the excellent Specs framework. The other topic was on ScalaTest, another excellent testing framework for Scala.

Specs is focussed on BDD testing (Behaviour Driven Design) and is the inspiration for ScalaTests WordSpec. From what I understand Specs was in-turn inspired by RSpec the Ruby BDD testing framework.

Specs has some truly unique features to it which we will encounter in future topics. But for now just the basics. The following example tests a couple of Scala's XML support in order to demonstract the general pattern followed when writing Specs' tests.

1. # scala -classpath ~/.m2/repository/org/scala-tools/testing/specs/1.6.1/specs-1.6.1.jar
3. scala> import org.specs._
4. import org.specs._
6. scala> object XmlSpec extends Specification {
7.      |  val sample = <library>
8.      |         <videos>
9.      |         <video type="dvd">Seven</video>
10.      |         <video type="blue-ray">The fifth element</video>
11.      |         <video type="hardcover">Gardens of the moon</video>
12.      |         </videos>
13.      |         <books>
14.      |         <book type="softcover">Memories of Ice</book>
15.      |         </books>
16.      |         </library>
17.      |  "Scala XML" should {
18.      |   "allow xpath-like selection" in {
19.      |    (sample \\ "video").size must be (3)    
20.      |   }
21.      |   "select child nodes" in {
22.      |    // This test fails because child is a sequence not a string
23.      |    // See the results of the tests
24.      |    sample.child must contain (<videos/>)
25.      |   }
26.      |  }
27.      |  }
28. defined module XmlSpec
30. scala> XmlSpec.main(Array[String]())
31. Specification "XmlSpec"
32.   Scala XML should
33.   + allow xpath-like selection
34.   x select child nodes <-- x indicates failure.
35.     'ArrayBuffer(
36.                    , <videos>
37.                    <video type="dvd">Seven</video>
38.                    <video type="blue-ray">The fifth element</video>
39.                    <video type="hardcover">Gardens of the moon</video>
40.                    </videos>, 
41.                    , <books>
42.                    <book type="softcover">Memories of Ice</book>
43.                    </books>, 
44.                    )' doesn't contain '<videos></videos>' (< console>:24)
46. Total for specification "XmlSpec":
47. Finished in 0 second, 52 ms
48. 2 examples, 2 expectations, 1 failure, 0 error

Varargs

Both Java and Scala have varargs. In Scala the syntax for a varargs argument is def method (param:String*). In the off-chance you are not aware of what varargs are; they allow an arbitrary number of values to be passed to the method. Some restrictions on when varargs can be used are:

• The vararg parameter must be the last parameter in the list
• There can not be default values for any parameters in the method containing the varargs (Scala 2.8+)

From the caller's point of view; varargs can be called as follows: method("p1", "p2", "p3") where the number of values is not limited. However, the () must be used.

In Java (if I remember right) only arrays can be passed in place of varargs:

1. class C {
2.   public static void main(String... args) {
3.     System.out.println(args.length)
4.   }
5. }
6. String[] args = new String[]{"arg1", "arg2"}
7. C.main (args)

However Scala is more general and allows any sequence to be passed to varargs, with a caveat. When a sequence is passed to varargs a hint must be provided to indicate that you are intending to have the sequence be expanded to be the varargs.

1. def method (args:Int*) = println(args)
2. val list = List(1,2,3)
3. method (list:_*)  // note the use of _*

Examples:

1. scala> def method(varargs:Int*)(more:String*) = println(varargs,more)
2. method: (Int*)(String*)Unit
4. scala> method(1,2,3,4)("one")
5. (Array(1, 2, 3, 4),Array(one))
7. scala> method(1,2,3,4)       
8. < console>:6: error: missing arguments for method method in object $iw;
9. follow this method with '_' if you want to treat it as a partially applied function
10.        method(1,2,3,4)
11.        ^
13. scala> method(1,2,3,4)()
14. (Array(1, 2, 3, 4),Array())
16. scala> method()("one")  
17. (Array(),Array(one))
19. scala> method("one")  
20. < console>:6: error: type mismatch;
21.  found   : java.lang.String("one")
22.  required: Int
23.        method("one")
24.               ^
26. scala> method()()     
27. (Array(),Array())
29. scala> val method2 = method(1,2,3)_  
30. method2: (String*) => Unit = < function>
32. scala> val paramList = List("hi","ho")
33. paramList: List[java.lang.String] = List(hi, ho)
35. scala> method2(paramList)
36. < console>:8: error: type mismatch;
37.  found   : List[java.lang.String]
38.  required: String
39.        method2(paramList)
40.                ^
42. scala> method2(paramList:_*)
43. (Array(1, 2, 3),List(hi, ho))
45. scala> val range = (1 to 5) map {_.toString} 
46. range: RandomAccessSeq.Projection[java.lang.String] = RangeM(1, 2, 3, 4, 5)
48. scala> method2(range:_*)                     
49. (Array(1, 2, 3),RangeM(1, 2, 3, 4, 5))

Options

Scala is forced to have a "null" value because it interoperates with Java. However unlike Java APIs the recommended way to hand cases where there may or may not be a value (IE a return value) is to return an Option object. Compare the Scala and Java idioms for handling a possible null (or None) return value:

Note: The Option class have been updated in Scala 2.8 so I am going to use some of the scala 2.8 methods. Most of the examples will work with Scala 2.7 but not all; the principal is the same for 2.7 and 2.8.

Java:

1. /**
2.  * Returns the annotation with the given name or null if there is no annotation
3.  * on the objects class with the given name.
4.  */
5. public static < A extends java.lang.annotation.Annotation> Annotation annotation(Object obj, Class< A> annotationCls) {
6.   return obj.getClass().getAnnotation(annotationCls)
7. }

Scala:

1. import java.lang.annotation.Annotation
2. /**
3.  * Returns the annotation with the given name.
4.  */
5. def annotation[A <: Annotation](obj:Object, annotationCls:Class[A]) : Option[Annotation] = {
6.    Option (obj.getClass.getAnnotation (annotationCls))
7. }

In the Scala version it is obvious the use of the API (and the compiler) that there are two types of legal return types. Some or None and the compiler will force you to deal with this fact. Where in Java it is very easy to forget to check for null.

Also not that it is very easy to Wrap a null in an Option using the Option objects apply method. If the parameter is a null then None is return otherwise Some is returned.

The other important aspect is how to deal with the Option object and obtain the data from the object if it is present. This is both simple and non-simple. There are a large number of possible useage patterns that can be applied to it.

Examples:

1. scala> import java.lang.annotation.Annotation
2. import java.lang.annotation.Annotation
4. kscala> def annotation[A <: Annotation](obj:Object, annotationCls:Class[A]) : Option[Annotation] = { 
5.      |    Option (obj.getClass.getAnnotation (annotationCls))                                      
6.      | }
7. annotation: [A <: java.lang.annotation.Annotation](obj: java.lang.Object,annotationCls: Class[A])Option[java.lang.annotation.Annotation]
9. // strings do not have the Documented annotation so None is returned
10. scala> annotation("x", classOf[java.lang.annotation.Documented])                                   
11. res0: Option[java.lang.annotation.Annotation] = None
13. // None is not defined
14. scala> res0.isDefined
15. res1: Boolean = false
17. // None IS empty 
18. scala> res0.isEmpty
19. res26: Boolean = true
21. // We need a some example so LineNumberInputStream has Deprecated annotation
22. // we will use that in order to 
23. scala> val in = new LineNumberInputStream(new ByteArrayInputStream("hello".getBytes))
24. in: java.io.LineNumberInputStream = java.io.LineNumberInputStream@8ca9a2d
26. scala> annotation(in, classOf[Deprecated])                                           
27. res2: Option[java.lang.annotation.Annotation] = Some(@java.lang.Deprecated())
29. // Some(...) is always defined even if it contains null
30. scala> res2.isDefined
31. res3: Boolean = true
33. scala> val nullSome = Some(null)
34. nullSome: Some[Null] = Some(null)
36. scala> nullSome.isDefined
37. res28: Boolean = true
39. // Some is never empty
40. scala> res2.isEmpty
41. res4: Boolean = false
43. // You can also test particular values as follows
44. scala> if(res0 == None) println("its ok to use")
45. its ok to use
47. scala> if (res2.map {a => "found"} == Some("found")) println ("it is deprecated dont use!")
48. it is deprecated dont use!
50. scala> res0 match {                                                       
51.      | case None => println("its ok to use")                              
52.      | case Some(x:Deprecated) => println ("it is deprecated dont use!") 
53.      | }
54. its ok to use
56. scala> res2 match {                                                      
57.      | case None => println("its ok to use")                             
58.      | case Some(x:Deprecated) => println ("it is deprecated dont use!")
59.      | }
60. it is deprecated dont use!
62. scala> if(Some("hi") == Some("hi")) println("a match")    
63. a match
65. scala> if(Some("hi") == Some("ho")) println("a match")
68. // After you have tested you can use get to obtain the value
69. // but becareful, you will get an exception if you forget to test.
70. scala> res0.get
71. java.util.NoSuchElementException: None.get
72.                           at scala.None$.get(Option.scala:169)
73.                           at scala.None$.get(Option.scala:167)
74.                           at .< init>(< console>:12)
75.                           at .< clinit>(< console>)
76.                           [snip]
78. scala> res2.get
79. res10: java.lang.annotation.Annotation = @java.lang.Deprecated()
81. // a potentially better way of optaining the value is to provide a default if 
82. // the value does not exists
83. scala> res2.getOrElse(classOf[java.lang.annotation.Documented])
84. res13: java.lang.Object = @java.lang.Deprecated()
86. scala> res0.getOrElse(classOf[java.lang.annotation.Documented])
87. res14: java.lang.Object = interface java.lang.annotation.Documented
89. // A Option is a "monad" (dont worry too much about the term if 
90. // you dont know it) a very (VERY) simplified meaning of that is that 
91. // option behaves a bit like a collection of size 1 or 0
92. // you can use similar methods on an Option as a collection.  
93. // So exists tests each element in the Option to see if it matches 
94. // the function passed in as the parameter
96. // res2 has an object that is an instanceOf Annotation 
97. scala> res2.exists {_.isInstanceOf[Annotation]}  
98. res7: Boolean = true
100. // None always returns false to exists
101. scala> res0.exists {_.isInstanceOf[Annotation]}
102. res8: Boolean = false
104. scala> res2.exists {_.toString == "hi"}
105. res29: Boolean = false
107. // Similarly you can use the filter method that is present in all collections
108. scala> res2.filter {_.toString == "hi"}    
109. res30: Option[java.lang.annotation.Annotation] = None
111. scala> res2.filter {_.isInstanceOf[Annotation]}
112. res32: Option[java.lang.annotation.Annotation] = Some(@java.lang.Deprecated())
114. // apart from just filtering you can convert the type contained 
115. // in the Option by using map to map from one type of Option to
116. // another type of Option in this examples we map from 
117. // Option[Annotation] to Option[String]
118. scala> res0.map {_.toString}.getOrElse("does not exist")                        
119. res15: java.lang.String = does not exist
121. scala> res2.map {_.toString}.getOrElse("does not exist")
122. res16: java.lang.String = @java.lang.Deprecated()
124. // Another very handy and safe way to access the value is to use foreach
125. // this will call the function with the parameter from the Option if
126. // the Option is Some but a noop will occur if the Option is None.
127. scala> res2.foreach { println _ }
128. @java.lang.Deprecated()
130. scala> res0.foreach { println _ }
132. // orElse is simply a method to ensure that the Option is a Some
133. scala> res0.orElse(Some(classOf[java.lang.annotation.Documented]))
134. res22: Option[java.lang.Object] = Some(interface java.lang.annotation.Documented)
136. scala> res2.orElse(Some(classOf[java.lang.annotation.Documented]))
137. res23: Option[java.lang.Object] = Some(@java.lang.Deprecated())

BigInt in Scala

One of the best examples of why it is so great to use Scala for API design is BigInt. Using BigInt in Java is a real headache because of the limitations of Java with regards to API design. Scala in comparison makes using BigInt no different than using Ints (with execution that there is not a BigInt literal).

1. // BigInt objects can be created from ints
2. scala> val x = BigInt(1500)
3. x: BigInt = 1500
5. // or longs
6. scala> val y = BigInt(8839200231L)
7. y: BigInt = 8839200231
9. // or strings
10. scala> val z = BigInt("1234566789008723457802308972345723470589237507")
11. z: BigInt = 1234566789008723457802308972345723470589237507
13. // then thanks to scala you can multiply/divide/add/subtract etc...
14. // as if it was a Scala literal
15. scala> x * y * z
16. res0: BigInt = 16368874569886254973831932331037537269641764816982396175500
18. // by importing implicits you can also directly multiply big ints with integers and longs
19. // however remember to put the big in first so that the int is converted to big int
20. // because you cannot do Int * BigInt.  It must be BigInt * Int
21. scala> import BigInt._
22. import BigInt._
24. scala> x * y * z * 124
25. res1: BigInt = 2029740446665895616755159609048654621435578837305817125762000

Access modifiers (public, private, protected)

By default classes, objects and class members (fields, methods) are all public.
IE:

1. object PublicObject {
2.   val publicVal
3.   var publicVar
4.   def publicMethod = 1
5. }

In this example everything is public. Similar to Java there is private and protected (there is no public because that is default). Private works as it does in Java but protected is dramatically different.

• The first difference is that protected can have two forms: protected and protected[foo]. Where foo can be a class, package or object.


• The second difference is that the non-parameterized protected for is only visible from subclasses not from the same package.

1. scala> class Class1 {
2.      | protected def pMethod = "protected"
3.      | }
4. defined class Class1
6. scala> class Class2 { 
7. // pMethod is not accessible because Class2 is not a subclass of Class1
8.      | new Class1().pMethod 
9.      | }
10. <console>:6: error: method pMethod cannot be accessed in Class1
11.        new Class1().pMethod
12.                     ^
14. scala> class Class3 extends Class1 {
15. // also unlike Java, protected restricts to the same object
16.      | new Class1().pMethod
17.      | }
18. <console>:6: error: method pMethod cannot be accessed in Class1
19.        new Class1().pMethod
20.                     ^
22. scala> class Class3 extends Class1 {
23.      | pMethod
24.      | }
25. defined class Class3

If the protected is parameterized then only classes that fall into the parameter category can access the parameter:

1. scala> class Class1 {                                
2. // protected[Class1] is equivalent to private
3.      | protected[Class1] def method() = println("hi")
4.      | method()
5.      | }
6. defined class Class1
8. scala> new Class1()
9. hi
10. res0: Class1 = Class1@dc44a6d
12. // this does not work because method is only accessible in Class1
13. scala> class Class2 extends Class1 { method() }      
14. <console>:5: error: not found: value method
15.        class Class2 extends Class1 { method() }
16.                                      ^
17. scala> object Module {                                         
18.      |   object Inner1 {                                         
19.      |     protected[Inner1] def innerMethod = println("hi")       
20.      |     protected[Module] def moduleMethod = println("moduleMethod")
21.      |
22.      |     object InnerInner { 
23.      |       // InnerInner is within Inner1 so the access works
24.      |       def callInner = innerMethod
25.      |     }
26.      |   }
27.      |   // module method is protected[Module] so anything in Module can access it
28.      |   def callModuleMethod = Inner1.moduleMethod
29.      |
30.      |   object Inner2 {
31.      |     // Inner1.module method is protected[Module] and 
32.      |     // Inner2 is within module so therefore has access
33.      |     def callModuleMethod = Inner1.moduleMethod
34.      |   }
35.      | }
36. defined module Module
38. scala> Module.callModuleMethod
39. moduleMethod
41. scala> Module.Inner1.InnerInner.callInner
42. hi
44. scala> Module.Inner1.innerMethod         
45. <console>:6: error: method innerMethod cannot be accessed in object Module.Inner1
46.        Module.Inner1.innerMethod
47.                      ^
49. scala> Module.Inner1.moduleMethod
50. <console>:6: error: method moduleMethod cannot be accessed in object Module.Inner1
51.        Module.Inner1.moduleMethod

The following example shows how package access works in Scala 2.8. They have to be compiled as 2 files.

Root.scala:

1. package root
3. class Class1 {
4.   protected[root] def rootMethod = println("rootMethod")
5. }
7. class Class2 {
8.   // same package so this is legal
9.   new Class1().rootMethod
10. }

Subpackage.scala

1. package root.sub
3. class Class3 {
4.   // Class3 is in a subpackage of root so 
5.   // it can access all objects protected by
6.   // protected[root] as well as objects
7.   // protected by protected[root.sub]
8.   new root.Class1().rootMethod
9. }

Multiple Constructors

In Scala there is a primary constructor: class MyClass(constructorParam:Any). Unlike Java, that constructor must be called. The question that often arises is, "How can one define multiple constructors?" There is a simple way to do this, however often a factory companion object can be used to remove the need for multiple constructors. Factory Companion Objects are covered in a previous post but I will review the pattern here quickly.

First multiple constructors:

1. scala> class HelloConstructor(param1:Int, param2:Int) {
2.      | def this(onlyParam:Int) = this(onlyParam,onlyParam)
3.      | def this(p1:String, p2:String, p3:String) = this(p1.length, p2.length + p3.length)
4.      | def this(onlyParam:String) = this(onlyParam.length)
5.      | }
6. defined class HelloConstructor

In Java if a constructor calls another constructor that call must be the first statement in the constructor. Scala is the same except that in Scala the primary constructor must be called. Notice that all constructors call this(param1,param2) at some point. In addition any method defined in the class HelloConstructor is not available until after the primary constructor is invoked. The following examples are not valid.

1. scala> class HelloConstructor(param1:Int, param2:Int) {                                  
2.      | def x = 1
3.      | def this() = this(x,3)
4.      | }
5. <console>:6: error: not found: value x
6.        def this() = this(x,3)
8. scala> class HelloConstructor(param1:Int, param2:Int) {
9.      | def this() = {
10.      | println("constructing")  // the REPL won't even let me finish method definition
11. <console>:3: error: 'this' expected but identifier found.
12.        println("constructing")
13.        ^

Factory companion objects can be used to work around these restrictions:

1. scala> class HelloConstructor(param1:Int, param2:Int)  
2. defined class HelloConstructor
4. scala> object HelloConstructor {                             
5.      | def apply() = {
6.      | println("constructing object")
7.      | new HelloConstructor(1,2)
8.      | }
9.      | }
10. defined module HelloConstructor
12. scala> HelloConstructor()
13. constructing object
14. res1: HelloConstructor = HelloConstructor@5b0010ec

Since companion objects can access private members of the class the factory methods can be as powerful as a constructor without the restrictions.

One last idea that is useful when designing classes is Scala 2.8 default arguments:

1. scala> class HelloConstructor(param1: Int = 1, param2: Int = 2)
2. defined class HelloConstructor
4. scala> new HelloConstructor()
5. res0: HelloConstructor = HelloConstructor@7cd47880
7. scala> new HelloConstructor(1)
8. res1: HelloConstructor = HelloConstructor@3834a1c8
10. scala> new HelloConstructor(param1 = 1)
11. res2: HelloConstructor = HelloConstructor@3b3e3940
13. scala> new HelloConstructor(param2 = 1)
14. res3: HelloConstructor = HelloConstructor@6dee2ea8
16. scala> new HelloConstructor(3,4)       
17. res4: HelloConstructor = HelloConstructor@397b6074
19. scala> new HelloConstructor(param1 = 3, param2=4)
20. res5: HelloConstructor = HelloConstructor@20272fec

Groupby - collection processing

Iterator and Iterable have most of the most useful methods when dealing with collections. Fold, Map, Filter are probably the most common. But other very useful methods include grouped/groupBy, sliding, find, forall, foreach, and many more. I want to cover Iterable's groupBy method in this topic.

This is a Scala 2.8 and later method. It is similar to partition in that it allows the collection to be divided (or partitioned). Partition takes a method with returns a boolean and partitions the collection into two depending on a result. GroupBy takes a function that returns an object and returns a Map with the key being the return value. This allows an arbitrary number of partitions to be made from the collection.

Here is the method signature:

1. def groupBy[K](f : (A) => K) : Map[K, This]

A bit of context is require to understand the three Type parameters A, K and This. This method is defined in a super class of collections called TraversableLike (I will briefly discuss this in the next topic.) TraversableLike takes two type parameters: the type of the collection and the type contained in the collection. Therefore in this method definition, 'This' refers to the collection type (List for example) and A refers to contained type (perhaps Int). Finally K refers to the type returned by the function and are the keys of the groups formed by the method.

Examples:

1. scala> val groups = (1 to 20).toList groupBy {
2.      | case i if(i<5) => "g1"
3.      | case i if(i<10) => "g2"
4.      | case i if(i<15) => "g3"
5.      | case _ => "g4"
6.      | }
7. res4: scala.collection.Map[java.lang.String,List[Int]] = Map(g1 -> List(1, 2, 3, 4), g2 -> List(5, 6, 7, 8, 9), g3 -> List(10, 11, 12, 13, 14), g4 -> List(15, 16, 17, 18, 19, 20))
9. scala> groups.keySet
10. res6: scala.collection.Set[java.lang.String] = Set(g1, g2, g3, g4)
12. scala> groups("g1")
13. res7: List[Int] = List(1, 2, 3, 4)
15. scala> val mods = (1 to 20).toList groupBy ( _ % 4 )
16. mods: scala.collection.Map[Int,List[Int]] = Map(1 -> List(1, 5, 9, 13, 17), 2 -> List(2, 6, 10, 14, 18), 3 -> List(3, 7,
17.  11, 15, 19), 0 -> List(4, 8, 12, 16, 20))
19. scala> mods.keySet
20. res9: scala.collection.Set[Int] = Set(1, 2, 3, 0)
22. scala> mods(1)
23. res11: List[Int] = List(1, 5, 9, 13, 17)

Strings

This topic simply shows several things that can be done with strings. It is not exhaustive and focusses of things that cannot as easily be done with java strings.

Note: Because I am using Scala 2.7 we often need to use mkString to convert the processed string from a sequence of characters to a string. In scala 2.8 this is not required.

1. /*
2.    Making use of raw strings to create a multi line string
3.    I add a | at the beginning of each line so that we can line up the quote nicely 
4.    in source code then later strip it from the string using stripMargin
5. */
6. scala> val quote = """|I don-t consider myself a pessimist.                                                                                                
7.      |                |I think of a pessimist as someone who is waiting for it to rain.
8.      |                |And I feel soaked to the skin.
9.      | 
10.      |                |Leonard Cohen"""
11. quote: java.lang.String = 
12. |I don-t consider myself a pessimist. 
13.                       |I think of a pessimist as someone who is waiting for it to rain.
14.                       |And I feel soaked to the skin.
15.        
16.                       |Leonard Cohen
19. // capilize the first character of each line
20. scala> val capitalized = quote.lines.
21.      |                         map( _.trim.capitalize).mkString("\n")
22. capitalized: String = 
23. |I don-t consider myself a pessimist.
24. |I think of a pessimist as someone who is waiting for it to rain.
25. |And I feel soaked to the skin.
27. |Leonard Cohen
29. // remove the margin of each line
30. scala> quote.stripMargin        
31. res1: String = 
32. I don-t consider myself a pessimist. 
33. I think of a pessimist as someone who is waiting for it to rain.
34. And I feel soaked to the skin.
35.        
36. Leonard Cohen
38. // this is silly.  I reverse the order of each word but keep the words in order
39. scala> quote.stripMargin.         
40.      |       lines.               
41.      |       map( _.split(" ").   
42.      |              map(_.reverse).
43.      |              mkString (" ")).
44.      |      mkString("\n")
45. res16: String = 
46. I t-nod redisnoc flesym a .tsimissep
47. I kniht fo a tsimissep sa enoemos ohw si gnitiaw rof ti ot .niar
48. dnA I leef dekaos ot eht .niks
50. dranoeL nehoC
52. scala> val myPatch = "-->This is my patch<--"                
53. myPatch: java.lang.String = -->This is my patch<--
55. // I replace the characters from point 10 in the string to myPatch.length 
56. // (the full patch string)
57. scala> quote.patch(10, myPatch, myPatch.length).mkString     
58. res21: String = 
59. |I don-t c-->This is my patch<--mist.
60.                       |I think of a pessimist as someone who is waiting for it to rain.
61.                       |And I feel soaked to the skin.
62.        
63.                       |Leonard Cohen
65. // drop the first 3 lines of the string.  
66. // there is also a take method
67. scala> quote.lines.drop(3).mkString("\n").stripMargin 
68. res25: String = 
69.        
70. Leonard Cohen
72. // a bunch of examples of converting strings
73. scala> "1024".toInt
74. res26: Int = 1024
76. scala> "1024".toFloat
77. res27: Float = 1024.0
79. scala> "1024".toDouble
80. res28: Double = 1024.0
82. scala> "1024".toLong  
83. res29: Long = 1024
85. scala> "102".toByte 
86. res31: Byte = 102
88. scala> "true".toBoolean
89. res32: Boolean = true
91. // format uses the java.util.Formatter class to format a string
92. scala> "Hello %s,\nThe date is %2$tm %2$te,%2$tY".format("Jesse", new java.util.Date()) 
93. res35: String = 
94. Hello Jesse,
95. The date is 09 30,2009
97. /*
98.    More silliness
99.    I am replacing every other character with the character of the reversed string
100.   
101.    this is done by 
102.    1. convert string to a list and zip it together with its reverse
103.       We may still need to cover zipping.  It basically matches up the 
104.       corresponding elements of two lists into one list
105.       so 1,2,3 and one,two,three zipped would be (1,one),(2,two),(3,three)
106.    2. Add an index to each element in the list with zipWithIndex
107.    3. Use map to check if the element is an odd element using the index and return either the original element or the reversed element
108.   
109.    Not useful but interesting use of functional idioms
110. */
111. scala> quote.toList.                                          
112.      |       zip(quote.reverse.toList).                       
113.      |       zipWithIndex.                                    
114.      |       map {                                            
115.      |            case ((original,reversed),index) if(index % 2 == 0) => original
116.      |            case ((original,reversed),index) => reversed                   
117.      |           }.                                                              
118.      |       mkString                                                            
119. res42: String = |e oo -r noes|d r m s l     e s m s .        . i s e t o   e|a shlne  f anp|s i i t a   o e n   h  .siwrioi gifrrfig ioirwis.  h   n e o   a t i i s|pna f  enlhs a|e   o t e s i .        . s m s e     l s m r d|seon r- oo e|
121. // filter out all non-vowels
122. scala> quote.filter( "aeiou" contains _ ).mkString
123. res51: String = ooieeaeiiioaeiiaoeoeoiaiioioaieeoaeoeieoaoe