Does it make any sense to use pattern matching in Scala with really simple cases?

Question

In 'Programming in Scala, Second Edition' at page 410 you can find class Simulation which have the following method:

private def next() {
  (agenda: @unchecked) match {
    case item :: rest =>
      agenda = rest
      curtime = item.time
      item.action()
  }
}

I'm curious why Odersky implemented this with pattern matching rather than just like that:

private def next() {
  val item = agenda.head
  agenda = agenda.tail
  curtime = item.time
  item.action()
}

Is pattern matching so efficient that it doesn't matter at all? Or it was just not so perfect example?

score 9 · Accepted Answer · answered Dec 26 '11 at 18:57

Normally I'd write it the way you did. (Even though pattern matching is quite efficient, it is not as efficient as head/tail.) You'd use pattern matching if

You wanted to practice pattern matching
You wanted a MatchException instead of a NoSuchElementException
You were going to fill in other cases later.

score 4 · Answer 2 · answered Dec 26 '11 at 18:42

There are a couple reasons:

Part of the point of the book is to get you thinking in Scala (functional) terms; pattern matching is the functional-programming equivalent.
Pattern matching and the functional approach are the natural pattern in Scala, and allow things like concurrency in a natural way; learn that pattern and your Scala programs will be ready for more advanced uses.

Don Roby · Answer 3 · 2011-12-26T20:08:07.300

3

Pattern matching is more idiomatic in Scala, and more easily protects you from boundary conditions.

In the code

private def next() {
  val item = agenda.head
  agenda = agenda.tail
  curtime = item.time
  item.action()
}

Both agenda.head and agenda.tail will throw a NoSuchElementException exception if agenda is an empty list, so to make it actually work you need to add a check for that.

The pattern matching version actually has a similar issue (as noted in th comments), but I find the fix cleaner, as all you have to do is add another pattern:

private def next() {
  (agenda: @unchecked) match {
    case item :: rest =>
      agenda = rest
      curtime = item.time
      item.action()
    case _ => {}
  }
}

edited Dec 26 '11 at 20:08

answered Dec 26 '11 at 18:55

Don Roby

40,677
6
91
113

the pattern matching version will throw MatchException if the pattern don't match – gerferra Dec 26 '11 at 19:43
@gerferra: I stand corrected. But the pattern matching version at any rate has a simple fix. I'll update the answer. – Don Roby Dec 26 '11 at 20:01
3

The other version also has a simple fix: either wrap in `if (!agenda.isEmpty)`, or use `agenda.headOption.foreach{ item => agenda = agenda.tail; curtime = item.time; item.action() }` – Rex Kerr Dec 26 '11 at 22:47

score 0 · Answer 4 · answered Jan 15 '17 at 02:28

My guess is first that exceptions are not a worry here, there is probably some check before this "next" method is called. In fact, this is probably the reason for the "unchecked" annotation too, so he can really not have to put an extra case _ =>. I think the reasoning was more that he wanted to use "unapply". An alternative here without the pattern matching, but also without head and tail could be something like:

private def next() {  
    val item :: rest = agenda
    agenda = rest
    curtime = item.time
    item.action()
}

Does it make any sense to use pattern matching in Scala with really simple cases?

4 Answers4