Symbols

Scala has what are called symbolic literals. A symbol is very similar to a String except that they are cached. So symbol 'hi will be the same object as 'hi declared a second time. In addition there is special syntax for creating symbols that requires only a single quote.

As odd as this may appear at first glance there are some good use cases for symbols.

• Save memory
• Extra semantics. Semantically they are the same object where "hi" is not necessarily the same as "hi" so 'hi has some extra semantics meaning this is the one an only 'hi object.
• Shorter syntax. This can be useful when designing DSLs
• Identifier syntax. When using the simpler syntax the symbol will be a valid Scala identifier so it can be good when intending to reference methods or variable, perhaps in a heavily reflection based framework

I hope that makes sense :)

1. // This is the long way to create a symbol object
2. scala> Symbol("hi")
3. res10: Symbol = 'hi
5. // This is the short way.  The symbol must be a legal Scala symbol (like a method name or value/variable name)
6. scala> 'hi
7. res11: Symbol = 'hi
9. // If you *need* characters in a symbol that are not legal in Scala identifiers the Symbol 
10. // object has a factory method for that purpose
11. scala> Symbol("hi there")
12. res12: Symbol = 'hi there
14. // Not legal
15. scala> 'hi there
16. < console>:5: error: value there is not a member of Symbol
17.        'hi there
18.            ^
20. // quotes are not legal for identifiers
21. scala> '"hi there"
22. < console>:1: error: unclosed character literal
23.        '"hi there"
24.        ^
25. < console>:1: error: unclosed string literal
26.        '"hi there"
27.                  ^
29. scala> 'hi\ there 
30. < console>:5: error: value \ is not a member of Symbol
31.        'hi\ there
32.        ^
34. // You can extract out the string from the symbol if desired quite easily
35. scala> 'hi match { case Symbol(b) => b}        
36. res14: String = hi
38. // A simpler way to get the string
39. scala> 'hi.toString drop 1
40. res0: String = hi

Product

As a response to a comment on a previous post about about Tuples this topic is about Products and the most common subclasses of Tuples.

I should preface this post by saying that I am not going to attempt any scholastic style discussions, instead I am going to try to explain Product in practical terms and stay away from theory. That said on can think of Products as (potentially) heterogenous collections (non-resizable collections). There are several Product classes (Product, Product1, Product2...). All Product classes extend Product, which contains the common methods. Product has the methods for accessing the Product members and the subclass adds type information about the Members.

A good way to think about Product is to look at Tuple which is a Product. There is a good stack overflow question that is worth looking at.

To give more context consider other well known subclasses of Product:

• All case classes
• List
• Option

1. scala> val product : Product = (1,'2',3)
2. product: Product = (1,2,3)
4. scala> product.productIterator.foreach {println _}
5. 1
6. 2
7. 3
9. scala> product.productArity                       
10. res1: Int = 3
12. scala> product.productElement(2)
13. res2: Any = 3
15. scala> product.productPrefix    
16. res3: java.lang.String = Tuple3
18. scala> product.toString
19. res4: java.lang.String = (1,2,3)
21. scala> val product3 = product.asInstanceOf[Product3[Int,Char,Int]]
22. product3: Product3[Int,Char,Int] = (1,2,3)
24. scala> product3._2
25. res5: Char = 2
27. scala> product3._3
28. res6: Int = 3
30. scala> case class Test(name:String, passed:Boolean, error:String)
31. defined class Test
33. scala> Test("Chicken Little", false, "the sky is falling")
34. res7: Test = Test(Chicken Little,false,the sky is falling)
36. scala> res7.productArity
37. res8: Int = 3
39. scala> res7.productIterator mkString ", "   
40. res9: String = Chicken Little, false, the sky is falling

Tuples are (not?) Collections

Tuples are quite handy but a potential annoyance is that at a glance they seem list-like but appearances can be deceiving. The normal collection methods are not supported by Tuples. For example suppose you like the simple syntax: (1,2,3) better than List(1,2,3). With the Tuple you cannot do the maps, filters, etc... (with good reason) but there is a use-case for being able to convert a Tuple to a Traversable.

Word of warning. Unlike collections Tuples are very often not homogeneous. IE you do not have Tuple2[Int] you have Tuple2[A,B]. So the best you can do is to map a tuple to an Iterator[Any].

Note: this was done with Scala 2.8 so results may be slightly different with 2.7. But I believe the syntax is valid.

1. // the productIterator method gives access to an iterator over the elements
2. scala> (1,2,3).productIterator.map {_.toString} mkString (",")
3. res1: String = 1,2,3
5. scala> (1,2,3).productIterator foreach {println _}            
6. 1
7. 2
8. 3
10. // if you know the tuple is heterogeneous then you can use partial functions
11. // for casting the elements to a particular type.  
12. scala> (1,2,3).productIterator map {case i:Int => i + 2} foreach {println _}
13. 3
14. 4
15. 5
17. // To get a full Traversable out of the deal you use one of the many
18. // to* methods to convert to Seq, List, Array, etc...
19. scala> (1,2,3).productIterator.toList map {case i:Int => i + 2}      
20. res15: List[Int] = List(3, 4, 5)
22. // and if you want you can use an implicit to clean up the syntax a bit
24. // Problem with this is you need an implicit for each Tuple length
25. scala> implicit def tupleToTraversable[T](t:(T,T,T)) = t.productIterator.toList map { case e:T => e}
26. warning: there were unchecked warnings; re-run with -unchecked for details
27. tupleToTraversable: [T](t: (T, T, T))List[T]
29. scala> (1,2,3) foreach {println _}
30. 1
31. 2
32. 3
34. /* 
35. EDIT:  Dan pointed out that the methods I am using are inherited from the
36. Product super class of Tuple.  So you can do something similar as follows.
38. Note:  I am using the same name as the previous method so that they don't interfer 
39. with one another
40. */
41. scala> implicit def tupleToTraversable[T](t:Product) = t.productIterator.toList map { case e:T => e} 
42. warning: there were unchecked warnings; re-run with -unchecked for details
43. tupleToTraversable: [T](t: Product)List[T]
45. scala> (1,2,3) foreach {println _}
46. 1
47. 2
48. 3
50. // this is interesting... it does cast to int unless required
51. scala> (1,2,'t') foreach {println _}
52. 1
53. 2
54. t
56. // lets verify we are getting correct conversion
57. scala> def inc(l:List[Int]) = l map {_ + 1} 
58. inc: (l: List[Int])List[Int]
61. scala> inc ( (1,2,3))                              
62. res4: List[Int] = List(2, 3, 4)
64. // yep this I expected
65. scala> inc ( (1,2,'t'))
66. java.lang.ClassCastException: java.lang.Character cannot be cast to java.lang.Integer
67. at scala.runtime.BoxesRunTime.unboxToInt(Unknown Source)
68. at $anonfun$inc$1.apply(< console>:7)
69. at scala.collection.TraversableLike$$anonfun$map$1.apply(TraversableLike.scala:238)
70. at .< clinit>(< console>)
72. scala> def inc(l:List[Int]) = l foreach {println _}
73. inc: (l: List[Int])Unit
75. scala> def p(l:List[Int]) = l foreach {println _}  
76. p: (l: List[Int])Unit
78. scala> p ( (1,2,'t'))                              
79. 1
80. 2
81. t

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

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

Danger: Shadowed member values

It is possible (although not recommended) to declare a public property in a super class and have a private value or variable in a subclass:

1. scala> class X (val i:Int)
2. defined class X
4. scala> class Y(i:Int) extends X(19) {
5.      | println(i)
6.      | }
7. defined class Y
9. scala> val y = new Y(100)
10. 100
11. y: Y = Y@3e55a58f
13. scala> y.i
14. res7: Int = 19

This begs the question: how can the subclass access the superclass instance of i? Let me re-iterate. Just because it is possible this is a bad idea. This pattern seems like it is begging to create bugs. But who knows there is probably some reason out there where this is required.

The way to access the X.i value from Y is to declare which value you want using the syntax this:X :

1. scala> class Y(i:Int) extends X(19) {
2.      | println("Y.i"+i)              
3.      | println("X.i"+(this:X).i)
4.      | }
5. defined class Y
7. scala> new Y(39)
8. Y.i39
9. X.i19
10. res8: Y = Y@451dfada

Repeat: Watch out! Because I learned this danger while writing this topic:

1. scala> class Y(i:Int) extends X(19) {
2.      | println("1. "+i)              
3.      | println("2. "+this.i)         
4.      | println("3. "+(this:Y).i)     
5.      | println("4. "+(this:X).i)     
6.      | }
7. defined class Y
9. scala> new Y(44)
10. 1. 44
11. 2. 44
12. 3. 19  // this is created via (this:Y).i !
13. 4. 19
14. res0: Y = Y@338bd37a

It seems that the syntax (this:X).i accesses the public accessor for i. The public access is a method call I think so it always obtains the value for the property. Shocking!

XML transformations 2

This topic is a continuation of XML Transformations. The previous topic showed a method of creating transformation rules then combining the rules to create a transformation that could be applied to an XML datastructure. This topic takes a different approach of
using a match statement an a recursive method to iterate through the tree.

1. scala> val xml = <library>
2.      | <videos>
3.      | <video type="dvd">Seven</video>
4.      | <video type="blue-ray">The fifth element</video>
5.      | <video type="hardcover">Gardens of the moon</video>
6.      | </videos>
7.      | <books>
8.      | <book type="softcover">Memories of Ice</book>
9.      | </books>
10.      | </library>
11. xml: scala.xml.Elem = 
12. <library>
13.        <videos>
14.        <video type="dvd">Seven</video>
15.        <video type="blue-ray">The fifth element</video>
16.        <video type="hardcover">Gardens of the moon</video>
17.        </videos>
18.        <books>
19.        <book type="softcover">Memories of Ice</book>
20.        </books>
21.        </library>
23. scala> import scala.xml._
24. import scala.xml._
26. scala> def moveElements (node:Node) : Node = node match {
27.      | case n:Elem if (n.label == "videos") => 
28.      |   n.copy( child = n.child diff mislabelledBooks)
29.      | case n:Elem if (n.label == "books") =>
30.      |   val newBooks = mislabelledBooks map { e => e.asInstanceOf[Elem].copy(label="book") }
31.      |   n.copy( child = n.child ++ newBooks)
32.      | case n:Elem => 
33.      |   val children = n.child map {moveElements _}
34.      |   n.copy(child = children)
35.      | case n => n
36.      | }
37. moveElements: (node: scala.xml.Node)scala.xml.Node
39. scala> moveElements(xml)
40. res1: scala.xml.Node = 
41. <library>
42.               <videos>
43.               <video type="dvd">Seven</video>
44.               <video type="blue-ray">The fifth element</video>
45.               
46.               </videos>
47.               <books>
48.               <book type="softcover">Memories of Ice</book>
49.               <book type="hardcover">Gardens of the moon</book></books>
50.               </library>