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!