And Case Statements

Recently I encountered a good question on Stack Overflow about matching.
http://stackoverflow.com/questions/2261358/pattern-matching-with-conjunctions-patterna-and-patternb.

As mentioned in an earlier post Matching with Or case expressions suppose 'or' expression combination using the '|' character. However 'and' combinations are not possible.

One solution is to build an && extractor object as follows:

1. scala> case object && {  def unapply[A](a: A) = Some((a, a))}
2. defined module $amp$amp
4. scala> object StartsWith {  def unapply(s: String) = s.headOption}
5. defined module StartsWith
7. scala> object EndsWith {  def unapply(s: String) = s.reverse.headOption}
8. defined module EndsWith
10. scala> "foo" match {  case StartsWith('f') && EndsWith('o') => println("f*o") }
11. f*o

Note: this is a scala 2.7 solution Scala 2.8 can be used to improve the EndsWith extractor by using the method lastOption instead of s.reverse.headOption.

Overcoming Type Erasure in matching 1

Since Scala runs on the JVM (it also runs on .NET but we this tip is aimed at Scala on the JVM) much of the type information that is available at compile-time is lost during runtime. This means certain types of matching are not possible. For example it would be nice to be able to do the following:

1. scala> val x : List[Any] = List(1.0,2.0,3.0)
2. x: List[Any] = List(1, 2, 3)
4. scala> x match { case l : List[Boolean] => l(0) }

If you run this code the list matches the list of ints which is incorrect (I have ran the following with -unchecked so it will print the warning about erasure):

1. scala> val x : List[Any] = List(1.0,2.0,3.0)
2. x: List[Any] = List(1, 2, 3)
4. scala> x match { case l : List[Boolean] => l(0) }         
6. < console>:6: warning: non variable type-argument Boolean in type pattern List[Boolean] is unchecked since it is eliminated by erasure
7.        x match { case l : List[Boolean] => l(0) }
8.                           ^
9. java.lang.ClassCastException: java.lang.Double cannot be cast to java.lang.Boolean
10. at scala.runtime.BoxesRunTime.unboxToBoolean(Unknown Source)
11. at .< init>(< console>:6)

Another example is trying to match on structural types. Wouldn't it be nice to be able to do the following (We will solve this in a future post):

1. scala> "a string" match {
2.      | case l : {def length : Int} => l.length
3.      | }
4. < console>:6: warning: refinement AnyRef{def length: Int} in type pattern AnyRef{def length: Int} is unchecked since it is eliminated by erasure
5.        case l : {def length : Int} => l.length
6.                 ^
7. res5: Int = 8

So lets see what we can do about this. My proposed solution is to create an class that can be used as an extractor when instantiated to do the check.

This is a fairly advanced tip so make sure you have read up on Matchers and Manifests:

• Extractor 1
• Manifests
• Comparing Manifests

The key parts of the next examples are the Def class and the function 'func'. 'func' is defined in the comments in the code block.

The Def class is the definition of what we want to match. Once we have the definition we can use it as an Extractor to match List[Int] instances.

The Def solution is quite generic so it will satisfy may cases where you might want to do matching but erasure is getting in the way.

The secret is to use manifests:

• When the class is created the manifest for the class we want is captured.
• Each time a match is attempted the manifest of the class being matched is captured
• In the unapply method, the two manifests are compared and when they match we can return the matched element but cast to the desired type for the compiler

It is critical to notice the use of the typeArguments of the manifest. This returns a list of the manifests of each typeArgument. You cannot simply compare desired == m because manifest comparisons are not deep. There is a weakness in this code in that it only handles generics that are 1 level deep. For example:

List[Int] can be matched with the following code but List[List[Int]] will match anything that is List[List[_]]. Making the method more generic is an exercise left to the reader.

1. scala> import reflect._ 
2. import reflect._
4. /*
5. This is the key class
6. */
7. scala> class Def[C](implicit desired : Manifest[C]) {
8.      | def unapply[X](c : X)(implicit m : Manifest[X]) : Option[C] = {
9.      |   def sameArgs = desired.typeArguments.zip(m.typeArguments).forall {case (desired,actual) => desired >:> actual}
10.      |   if (desired >:> m && sameArgs) Some(c.asInstanceOf[C])
11.      |   else None
12.      | }
13.      | }
14. defined class Def
16. // first define what we want to match
17. scala> val IntList = new Def[List[Int]]
18. IntList: Def[List[Int]] = Def@6997f7f4
20. /*
21. Now use the object as an extractor.  the variable l will be a typesafe List[Int]
22. */
23. scala> List(1,2,3) match { case IntList(l) => l(1) : Int ; case _ => -1 }
24. res36: Int = 2
26. scala> List(1.0,2,3) match { case IntList(l) => l(1) : Int ; case _ => -1 }
27. res37: Int = -1
29. // 32 is not a list so it will fail to match
30. scala> 32 match { case IntList(l) => l(1) : Int ; case _ => -1 }
31. res2: Int = -1
33. scala> Map(1 -> 3) match { case IntList(l) => l(1) : Int ; case _ => -1 }
34. res3: Int = -1
36. /*
37. The Def class can be used with any Generic type it is not restricted to collections
38. */
39. scala> val IntIntFunction = new Def[Function1[Int,Int]]
40. IntIntFunction: Def[(Int) => Int] = Def@5675e2b4
42. // this will match because it is a function
43. scala> ((i:Int) => 10) match { case IntIntFunction(f) => f(3); case _ => -1}
44. res38: Int = 10
46. // no match because 32 is not a function
47. scala> 32 match { case IntIntFunction(f) => f(3); case _ => -1}
48. res39: Int = -1
50. // Cool Map is a function so it will match
51. scala> Map(3 -> 100) match { case IntIntFunction(f) => f(3); case _ => -1}
52. res6: Int = 100
54. /*
55. Now we see both the power and the limitations of this solution.
57. One might expect that:
58.    def func(a:Any) = {...} 
59. would work.  
61. However, if the function is defined with 'Any' the compiler does not pass in the required information so the manifest that will be created will be a Any manifest object.  Because of this the more convoluted method declaration must be used so the type information is passed in. 
63. I will discuss implicit parameters in some other post
64. */
65. scala> def func[A](a:A)(implicit m:Manifest[A]) = {
66.      |   a match {
67.      |     case IntList(l) => l.head                   
68.      |     case IntIntFunction(f) => f(32)             
69.      |     case i:Int => i                             
70.      |     case _ => -1                                
71.      |   } 
72.      | }
73. func: [A](a: A)(implicit m: Manifest[A])Int
75. scala> func(List(1,2,3))                           
76. res16: Int = 1
78. scala> func('i')                                   
79. res17: Int = -1
81. scala> func(4)
82. res18: Int = 4
84. scala> func((i:Int) => i+2)
85. res19: Int = 34
87. scala> func(Map(32 -> 2))
88. res20: Int = 2

Boolean Extractors

As discussed in other topics there are several ways to create custom extractors for objects. See

• Extractors Introduction
• Extract Sequences
• Operator Style Extractors

There is one more custom extractor that can be defined. Simple boolean extractors. They are used as follows:

1. scala> "hello world" match {                   
2.      | case HasVowels() => println("Vowel found")
3.      | case _ => println("No Vowels")            
4.      | }
5. Vowel found

A boolean extractor is an object that returns Boolean from the unapply method rather than Option[_].

Examples:

1. scala> object HasVowels{ def unapply(in:String):Boolean = in.exists( "aeiou" contains _ ) }
2. defined module HasVowels
4. // Note that HasVowels() has ().
5. // This is critical because otherwise the match checks whether
6. // the input is the HasVowels object.
7. // The () forces the unapply method to be used for matching
8. scala> "hello world" match {
9.      | case HasVowels() => println("Vowel found")
10.      | case _ => println("No Vowels")
11.      | }
12. Vowel found
14. // Don't forget the ()
15. scala> "kkkkkk" match {    
16.      | case HasVowels() => println("Vowel found")
17.      | case _ => println("No Vowels")
18.      | }
19. No Vowels
21. scala> class HasChar(c:Char) {           
22.      | def unapply(in:String) = in.contains(c)
23.      | }
24. defined class HasChar
26. scala> val HasC = new HasChar('c')
27. HasC: HasChar = HasChar@3f2f529b
29. // Don't forget the () it is required here as well
30. scala> "It actually works!" match {
31.      | case HasC() => println("a c was found")
32.      | case _ => println("no c found")  
33.      | }
34. a c was found
36. // Don't forget the ()
37. scala> "hello world" match { 
38.      | case HasC() => println("a c was found")
39.      | case _ => println("no c found")       
40.      | }
41. no c found

Extractors 3 (Operator Style Matching)

One of the blessings and curses of Scala the several rules for creating expressive code (curse because it can be used for evil.) One such rule is related to extractors that allows the following style of match pattern:

1. List(1,2,3) match {
2.   case 1 :: _ => println("found a list that starts with a 1")
3.   case _ => println("boo")
4. }

The rule is very simple. An extractor object that returns Option[Tuple2[_,_]] (or equivalently Option[(_,_)]) can be expressed in this form.

In other words: object X {def unapply(in:String):Option[(String,String)] = ...} can be used in a case statement like: case first X head => ... or case "a" X head => ....

Example to extract out the vowels from a string:

1. scala> object X { def unapply(in:String):Option[(RichString,RichString)] = Some(in.partition( "aeiou" contains _ )) }
2. defined module X
4. scala> "hello world" match { case head X tail => println(head, tail) }
5. (eoo,hll wrld)
7. // This is equivalent but a different way of expressing it
8. scala> "hello world" match { case X(head, tail) => println(head, tail) }       
9. (eoo,hll wrld)

Example for Matching the last element in a list. Thanks to 3-things-you-didnt-know-scala-pattern.html:

1. scala> object ::> {def unapply[A] (l: List[A]) = Some( (l.init, l.last) )}
2. defined module $colon$colon$greater
4. scala> List(1, 2, 3) match {
5.      | case _ ::> last => println(last)
6.      | }
7. 3
9. scala> (1 to 9).toList match {
10.      | case List(1, 2, 3, 4, 5, 6, 7, 8) ::> 9 => "woah!"
11.      | }
12. res12: java.lang.String = woah!
14. scala> (1 to 9).toList match {
15.      | case List(1, 2, 3, 4, 5, 6, 7) ::> 8 ::> 9 => "w00t!"
16.      | }
17. res13: java.lang.String = w00t!

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

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"))