Pattern matching over non-case class in Scala

问题:

Lets assume that I have a plain third party (i.e. I cannot modify it) class defined like:

class Price(var value: Int)

Is this possible to match instances of this class with some patterns?

For example, I want to implement function:

def printPrice(price: Price) = {
    // implementation here
}

... that prints price is {some value} for every price that has value <= 9000 and price is over 9000 in all other cases.

For example, calling:

printPrice(new Price(10))
printPrice(new Price(9001))

should print:

price is 10
price is over 9000

How can I implement printPrice using pattern matching?

回答1:

You can create custom extractor:

package external {
    class Price(var value: Int)
}

object Price {
    def unapply(price: Price): Option[Int] = Some(price.value)
}

def printPrice(price: Price) = price match {
    case Price(v) if v <= 9000 => println(s"price is $v")
    case _ => println("price is over 9000")
}

printPrice(new Price(10))
printPrice(new Price(9001))

For case classes compiler generates it automaticaly. I think in your case extractors is overkill, but may be it's only simplified sample.

回答2:

Thinked about accepting flavian's solution but came up with slightly better one by myself.

Here is how one could implement printPrice (without need to use wrapper objects and modifying original class):

def printPrice(price: Price) = price match {
    case p: Price if (p.value <= 9000) => println("price is " + p.value)
    case p: Price => println("price is over 9000")
}

PS: credits to flavian for showing that you can use if in pattern. Upvoting your answer for this.

回答3:

You could get away with a PIMP my library pattern:

case class RichPrice(value: Int) {}
  implicit def priceToRichPrice(price: Price): RichPrice = RichPrice(price.value)

  def printPrice(x: RichPrice): Unit = {
    x match {
      case RichPrice(value) if (value <= 9000) => println("below 9000")
      case RichPrice(value) if (value > 9000) => println("over 9000")
      case _ => println("wtf")
    }
  }
println(printPrice(new Price(10)))
println(printPrice(new Price(9001)))

The point of using a case class is to let Scala define the apply method and unapply magic used for pattern matching.