How to define a `StrContains.unapply` for pattern match? - scala

Question

There is a method in my code, which need to check if the passing string contain some specified chars, and then do something.
The code is looking like:
def check(str: String) = {
if(str.contains("A")) {
doSomething()
} else if(str.contains("B")) {
doSomething()
} else if(str.contains("C")) {
doSomething()
} else {
doSomething()
}
}
I want to try pattern match on it, but not very satisfied with:
def check(str: String) = str match {
case s if s.contains("A") => doSomething()
case s if s.contains("B") => doSomething()
case s if s.contains("C") => doSomething()
case _ => doSomething()
}
I hope I can define a StrContains.unapply to use it like this:
def check(str: String) = str match {
case StrContains("A") => doSomething()
case StrContains("B") => doSomething()
case StrContains("C") => doSomething()
case _ => doSomething()
}
But now sure how to do it. Any thoughts?

Answer 1

The problem is that when you do case StrContains("A"), the compiler will first call StrContains.unapply/unapplySeq (whichever way it is defined) and only then try to match the returned result against "A". The "A" literal itself will never be passed to StrContains.unapply/unapplySeq, so it has no way to perform the call s.contains("A") inside unapply/unapplySeq.
Simply put, this means you'd need to define distinct objects such as StrContainsA/StrContainsB/StrContainsC which is clearly a worse situation than simply doing case s if s.contains("A").
However, there is an alternative (and somewhat contrived) solution that allows to define a single extractor while still being able to specify inline the substring to match for, and that is to exploit the fact that scala supports defining extractors based on string interpolation:
implicit class ContainsContext (val sc : StringContext) {
object StrContains {
def unapply(str: String): Boolean = {
val substr: String = sc.parts.mkString
str.contains(substr)
}
}
}
Usage:
def check(str: String) = str match {
case StrContains"A" => doSomething()
case StrContains"B" => doSomething()
case StrContains"C" => doSomething()
case _ => doSomething()
}