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

Equals, Tuples and Case-classes

This is mostly a quick tip (or opportunity for refactoring).

Most of Scala's built in classes implement a useful equals and hashcode. The very commonly used case-classes and Tuple classes are the examples that spring to mind. So this enables the following options:

1. // Assume Box is out of your control and you cannot refactor it into a case class
2. scala> class Box(val name:String, val minx:Int, val miny:Int, val maxx:Int, val maxy:Int)
3. defined class Box
5. scala> val box = new Box("mybox", 0, 0, 10, 10)
6. box: Box = Box@568bf3ec
8. // before:
9. scala> box.minx == 0 && box.miny == 0 && box.maxx == 10 && box.maxy == 10      
10. res3: Boolean = true
12. // after
13. scala> import box._
14. import box._
16. scala> (minx,miny,maxx,maxy) == (0,0,10,10)
17. res5: Boolean = true
19. // another box definition:
20. scala> case class Box2 (name:String, ul:(Int,Int), lr:(Int,Int)) 
21. defined class Box2
23. // case classes have nice equals for comparison
24. scala> box2 == Box2("a nicer box", (0,0), (10,10))
25. res6: Boolean = true
27. // but what if you don't want to compare names
28. scala> import box2._
29. import box2._
31. scala> (ul,lr) == ((0,0),(10,10))
32. res7: Boolean = true

Function._

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

Examples:

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

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)

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

Assignment and Parameter Objects

One of the principle design goals of Scala is to be "deep" not wide, which means the language attempts to have a small set of rules that can be applied in many different ways in different situations. Pattern matching is one of my favourite examples of this. Pattern matching is commonly seen in match { case... } statements but you will also see it frequently in exception handling, function declaration and, most important for this post, assignment.

Scala does not have multiple assignment like some languages. Instead it has tuples and matching. Tuples are a light-weight way of grouping data in a simple data object. (1,2.0,'c',"string", true). A simple example of a 5 element tuple. Tuples can be up to 22 elements long and can be homogenous or heterogenous. Using this for multiple assignement works something like:

1. val (firstname, lastname) = ("Jesse","Eichar")

This is pattern matching.

1. scala> ("Jesse","Eichar") match {
2.      | case (firstname,lastname) => println(firstname,lastname)
3.      | }
4. (Jesse,Eichar)

Notice that in both cases you need the brackets around firstname, lastname. This instructs the compiler that you are matching against a Tuple.

Now the interesting use is with parameter objects. Tuples are a poor substitute for parameter objects because they do not have context. Changing:

1. def myMethod( firstname:String, middlename:String, lastname:String) = {...}

to

1. def myMethod( name:(String,String,String)) = {...}

Is not a good change because you loose context. What are the 3 strings? The information must go in the Javadocs. A better option:

1. case class Name(first:String, middle:String, last:String)
3. def myMethod( name:Name ) = {
4.   val Name(first, middle, last) = name
6.   // do something with first middle last
7. }

The beauty is that you have an object that you can pass around easily. It is a case class therefore extracting the information is incredibly easy and unlike a tuple it has context and can have methods added easily.

Yes it is longer to write but if you need to reuse the data in several locations the trade off is well worth it in clarity.

Examples:

1. // define name data object.
2. // Notice toString is a lazy val.  This means value is calculated only once.
3. scala> case class Name(first:String, middle:String, last:String) {
4.      | override lazy val toString="%s, %s %s" format (last, first,middle)
5.      | }
6. defined class Name
8. // toString formats name nicely.
9. scala> Name("Jesse","Dale","Eichar")
10. res1: Name = Eichar, Jesse Dale
12. scala> def readName() = {
13.      | //maybe load from a file or database
14.      | Name("Jesse","Dale","Eichar") :: Name("Jody","","Garnett") :: Name("Andrea","","Antonello"):: Nil
15.      | }
16. readName: ()List[Name]
18. scala> def firstLastName(name:Name) = {
19.      |  // we are putting _ because we don't care about middle name
20.      | val Name( first, _, last ) = name
21.      | (first, last)
22.      | }
23. firstLastName: (Name)(String, String)
25. // convert the list of Names to a list of tuples of first and last name
26. scala> readName().map( firstLastName _ )
27. res2: List[(String, String)] = List((Jesse,Eichar), (Jody,Garnett), (Andrea,Antonello))
29. // print all first names starting with J
30. scala> for( Name(first,_,_) <- readName; if (first.startsWith("J"))) println(first)
31. Jesse
32. Jody
34. // print the first and middle parts of the first name in the list
35. scala> readName() match {
36.      | // the :: _ indicates that we are matching against a list but we don't care about the rest of the list
37.      | case Name(f,m,_) ::  _ => println( f, m)
38.      | case _ => println("Not a list of names")
39.      | }
40. (Jesse,Dale)