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