Scala pattern matching case is skipped

4
votes

Thanks for the excellent example, I tried it and it works as I expected. Nice to see someone understood the nature of the problem. However, I think I should have tagged the problem with Lift as I'm using the Lift framework and that is where this problem is (still) occurring (although I still think it might be related to extraction in scala). Since I don't want to reproduce the entire Lift setup here as it will be too much code, I'm going to hope someone familiar with Lift can understand what I'm doing here. I've removed more variables so it might be easier (for some) to see the problem:

lazy val dispatch: LiftRules.DispatchPF = {
  // Explicitly setting guard to false to trigger the scenario
  case req: Req if false => () => println("shouldn't match"); Empty
  // This should match since previous case will never match
  case Req(_, _, _) => () => println("should match"); Empty
  // This is actually called...
  case _ => () => println("shouldn't reach here"); Empty
}

As before, if I comment out the first case the second case is matched as expected.

For those interested, a simple workaround is:

lazy val dispatch: LiftRules.DispatchPF = {
  case req: Req => {
    if (false) { // Obviously you put something more useful than false here...
      () => println("shouldn't match"); Empty
    } else req match {
      // This matches
      case Req(_, _, _) => () => println("should match"); Empty
      // This is now never called
      case other => () => println("shouldn't reach here"); Empty
    }
  }
}

ORIGINAL POST

I'm new to scala, so I may be doing something wrong here, but I have a pattern matching expression that seems to be skipped over. Here's the code:

lazy val dispatch: LiftRules.DispatchPF = {
   // Explicitly setting guard to false to trigger the scenario
   case req: Req if false => () => Full(...)
   // This should match since previous case will never match
   case Req("api" :: "test" :: Nil, suffix, GetRequest) => () => Full(...)
   // This is actually called...
   case _ => () => println("not sure what's going on"); Empty
}

If I take out the first case expression, everything works as expected. I'm tempted to think this is a bug (https://issues.scala-lang.org/browse/SI-2337), but does anyone know of a workaround?

3
scalapattern-matchinglift
Why do you think the second case should match? What are you puttin in as an argument? - Jens Schauder
You need to reduce the "bug" to a reproducible REPL session, in this case. For example, define your types/classes, inputs etc. Also, in the fall-through case statement, print the value of the thing being sent in! - oxbow_lakes
If everything works as expected by taking out the first case, then that would be a workaround, wouldn't it? Why would you want the first case anyway, since, without the if false, it matches every Req so you'll never get to the second case? And to reiterate the very very obvious point of the previous two comments, the second case will only match a very specific item but you have provided no evidence or check that the match is actually being done on such an item. And this bears little or no resemblance to SI-2337, where the first case is an extractor (which req:Req is not). - Jim Balter
I think it is a bug indeed. There are bugs like that in the matcher, unfortunately. - Daniel C. Sobral
Can you put a test case code that works in REPL and gives the wrong match. Too many things are left out. "api" :: "test" :: Nil, suffix, GetRequest might be the problem. Are you missing a match somerwhere also? - Jus12

3 Answers

2
votes

At the very least, change the last line:

case other => () => { println("not sure what's going on " + other); Empty }

and tell us what it prints

1
votes

I just typed up an example which seems to be the same scenario you've got in your code, and it works as expected in Scala 2.9:

case class Foo(x:String)
val bar = Foo("bar")
bar match {
    case x:Foo if false => println("Impossible")
    case Foo(x) => println("Expected: " + x)
    case _ => println("Should not happen")
}

Which outputs Expected: bar

See if you can reproduce the bug in a self-contained example like this, so maybe we (or if it is a bug, the Scala Dev Team, can figure out what is going wrong :)

Note: Seems like I misread your question the first time, sorry for that. I'm not going to delete this part anyway, because it might be helpful to someone else.

When using pattern matching, the first case-statement that matches will be executed, and after that, the match is complete and all other case statements will be ignored!

Your problem here is, that the first statement

case req:Req =>

matches every instance of Req. After matching the first statement and executing its code, Scala just jumps out of the match expression because it is finished. The second case-statement would match, but it is never executed for any given instance of Req because the first one matches. As far as I remember, this is known as shadowing a case statement.

So move your second case statement before the first one, and you should be fine.

Note that this is why in pattern matching, the more specific match cases need to come first and the more general case statements have to go last.

0
votes

This is indeed the bug you are referencing in the Scala bug tracker. Req is a non-case class with a companion extractor methods, so the bug manifests itself here. The workaround you introduced seems fine.

For those interested, here is a sample case where the bug manifests itself:

class Sample(val a: String)

object Sample {
    def apply(a: String) = new Sample(a)
    def unapply(s: Sample) = Option(s.a)
}

val s = new Sample("a")

val r = s match {
    case n: Sample if false => "Wrong 1: " + n
    case Sample(_) => "Yay" 
    case n => "Wrong 2: " + n
}

println("Found " + r)
assert(r == "Yay")