131

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:

  1. 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?

  2. 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.

Improve this question
2
  • Related: stackoverflow.com/questions/7083502/… Commented Apr 21, 2013 at 13:56
  • 4
    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. Commented Jun 26, 2017 at 16:22

2 Answers 2

Reset to default
263

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.

Improve this answer
Sign up to request clarification or add additional context in comments.

5 Comments

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.
@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.
This rule also makes it easy to shadow unwanted variables, e.g. NonEmptyList.from(list) match { case None => Left("List was empty"); case Some(list) => /* Re-use the name 'list' for the NonEmptyList, so the original List can't be referenced accidentally */ }
2

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") } }
Improve this answer

Comments

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.