Why does pattern matching in Scala not work with variables?

scala pattern-matching match

Take the following function:

def fMatch(s: String) = {
    s match {
        case "a" => println("It was a")
        case _ => println("It was something else")
    }
}

This pattern matches nicely:

scala> fMatch("a")
It was a

scala> fMatch("b")
It was something else

What I would like to be able to do is the following:

def mMatch(s: String) = {
    val target: String = "a"
    s match {
        case target => println("It was" + target)
        case _ => println("It was something else")
        }
}

This gives off the following error:

fMatch: (s: String)Unit
<console>:12: error: unreachable code
               case _ => println("It was something else")

I guess this is because it thinks that target is actually a name you'd like to assign to whatever the input is. Two questions:

Why this behaviour? Can't case just look for existing variables in scope that have appropriate type and use those first and, if none are found, then treat target as a name to patternmatch over? Is there a workaround for this? Any way to pattern match against variables? Ultimately one could use a big if statement, but match case is more elegant.

Related: stackoverflow.com/questions/7083502/…

I believe this question, code and answers are outdated as of Scala 2.12.x. It would be nice if the version to which is applies was mentioned as part of the question.

Ben James

What you're looking for is a stable identifier. In Scala, these must either start with an uppercase letter, or be surrounded by backticks.

Both of these would be solutions to your problem:

def mMatch(s: String) = {
    val target: String = "a"
    s match {
        case `target` => println("It was" + target)
        case _ => println("It was something else")
    }
}

def mMatch2(s: String) = {
    val Target: String = "a"
    s match {
        case Target => println("It was" + Target)
        case _ => println("It was something else")
    }
}

To avoid accidentally referring to variables that already existed in the enclosing scope, I think it makes sense that the default behaviour is for lowercase patterns to be variables and not stable identifiers. Only when you see something beginning with upper case, or in back ticks, do you need to be aware that it comes from the surrounding scope.

I bet this comes from Erlang, where variables start with a capital letter and symbols with a lower-case.

Notice that target is a value (val), and not a variable (var). It doesn't work with variables.

Uppercase? Shades of FORTRAN. Weak, Martin, weak.

@Emil Actually, capitalized identifiers in Scala denote constants. So a pattern matching on an uppercase identifier is taken to mean comparing to a constant. It seriously helps with stuff like Nil, which I bet is the real reason.

Seems like one can't use this as a stable identifier to pattern match against it, only way seems to be using an equality guard like case x if x == this =>. Probably a syntactical limitation, otherwise it should semantically work at least within objects.

Raptor0009

You can also assign it to a temporary variable inside the case and then compare it, that will also work

def mMatch(s: String) = {
    val target: String = "a"
    s match {
        case value if (value ==target) => println("It was" + target) //else {} optional
        case _ => println("It was something else")
    }
}