map expression in case clause in scala pattern matching

问题

I have a configuration value that matches to one of the values in a map and depending on to which it matches i take an action. Here is some sample code of what i am trying to do

val x = 1         // or 2 or 3

val config = Map("c1"-> 1, "c2"-> 2, "c3"-> 3)

x match {
  case config("c1") =>
    println("1")
  case config("c2") =>
    println("2")
  case config("c3") =>
    println("3")
}

Now this should print 1 because config("c1") evaluates to 1 but it gives error

error: value config is not a case class, nor does it have an unapply/unapplySeq member
                case config("c1") =>

Similarly for the other 2 cases. Why should i have an unapply here? Any pointers?

回答1:

An expression like that looks like an extractor, hence the message about unapply/unapplySeq methods. If you don't want to use an extractor but just want to match against a plain value, you need to store that value in a stable identifier - you can't use an arbitrary expression as a match case:

val case1 = config("c1")
x match {
  case case1 => println("1")
  ...
}

回答2:

To the best of my knowledge, in Scala, x match {case config("c1") gets translated to config.unapply(x) with the branching dependent on the result of the unapply method. As Imm already mentioned in his answer, this isn't the case for stable identifiers (literals and val), and I'd encourage you to use his solution.

Nevertheless, to show you how you could solve the problem using extractors, I'd like to post a different solution:

def main(args: Array[String]): Unit = {

  object config {
    val configData = Map("c1" -> 1, "c2" -> 2, "c3" -> 3)

    def unapply(value: Int): Option[String] = configData find (_._2 == value) map (_._1)
  }

  1 to 4 foreach {
    case config("c1") => println("1")
    case config("c2") => println("2")
    case config("c3") => println("3")
    case _ => println("no match")
  }
}

I changed the match for a foreach to show the different results, but this has no effect on the implementation. This would print:

1
2
3
no match

As you can see, case config("c1") now calls the unapply method and checks whether the result is Some("c1"). Note that this is inverse to how you'd use a map: The key is searched according to the value. However, this makes sense: If in the map, "c1" and "c2" both map to 1, then 1 matches both, the same way _ matches everything, in our case even 4 which is not configured.

Here's also a very brief tutorial on extractors. I don't find it particularly good, because both, the returned type and the argument type are Int, but it might help you understand what's going on.

回答3:

As others have stated, with x match { case config("c1") => ..., scala looks for an extractor by the name of config (something with an unapply method that takes a single value and returns an Optional value); Making pattern matching work this way seems like an abuse of the pattern, and I would not use an extractor for this.

Personally, I would recommend one of the following:

if (x == config("c1"))
  println("1")
else if (x == config("c2"))
  println("2")
else ...

Or, if you're set on using a match statement, you can use conditionals like this:

x match {
  case _ if x == config("c1") =>
    println("1")
  case _ if x == config("c2") =>
    println("2")
  case _ if x == config("c3") =>
    println("3")
}

Not as clean; unfortunately, there isn't a way to invoke a method call literally where the extractor goes. You can use back-ticks to tell scala "match against the value of this variable" (rather than default behavior, which would yield the value named as that variable):

val (c1,c2,c3) = (config("c1"), config("c2"), config("c3"))
x match {
  case `c1` =>
    println("1")
  case `c2` =>
    println("2")
  case `c3` =>
    println("3")
}

Finally, if your goal is to reverse-apply a map, maybe try this instead?

scala> Map("a" -> 1).map { case (k,v) => (v,k) }
res0: scala.collection.immutable.Map[Int,String] = Map(1 -> a)

来源：https://stackoverflow.com/questions/27051030/map-expression-in-case-clause-in-scala-pattern-matching

标签

scala

pattern-matching