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