Simplify Massive Match Case - Scala

Question

So in one of the places we have this huge variable match case statement.

Containing almost 150 distinct case statements

Looks horrible.

I want to break it up into smaller functions, I can group the matches into say 10 pieces and then the number case statements come down to around 15. Which is fine.

It currently looks like this

massiveCaseVariable match {
  case "one" => 1
  case "two" => 2
  case "three" => 3
  case "four" => 4
  case "five" => 5
  case "six" => 6
}

But I don't want to do it like this

massiveCaseVariable match {
  case "one" || "two" || "three" => firstCategory(massiveCaseVariable)
  case "four" || "five" || "six" => secondCategory(massiveCaseVariable)
}

def firstCategory(caseVariable: String): Int =
  caseVariable match {
    case "one"   => 1
    case "two"   => 2
    case "three" => 3
  }

def secondCategory(caseVariable: String): Int =
  caseVariable match {
    case "four" => 4
    case "five" => 5
    case "six"  => 6
  }

It's too repetitive. Is there a better more concise way to do this?

I'm on Scala 2.11

PS: The examples are for illustration purposes only. I'm definitely not trying to match Strings to Integers

score 10 · Accepted Answer · answered Apr 29 '19 at 09:45

If you want to simply combine you matches then you can notice that these are actually partial functions (because matching can fail):

val firstCategory: PartialFunction[String, Int] = {
    case "one"   => 1
    case "two"   => 2
    case "three" => 3
  }

val secondCategory: PartialFunction[String, Int] = {
    case "four" => 4
    case "five" => 5
    case "six"  => 6
  }

which can be combined:

val all = firstCategory orElse secondCategory
all("one")

Interestingly many collections are partial functions e.g. Map, so:

val firstCategory = Map[String, Int](
    "one"   -> 1,
    "two"   -> 2,
    "three" -> 3
  )

val secondCategory = Map[String, Int](
    "four" -> 4,
    "five" -> 5,
    "six"  -> 6
  )

val all = firstCategory ++ secondCategory
all("one")

should work the same way in this example.

Marking this as the correct answer as this answers my question exactly. In fact I refactored the `match case` using the `PartialFunction` with `orElse` pattern. — debduttoc, Apr 30 '19 at 10:48

score 1 · Answer 2 · answered Apr 29 '19 at 12:46

You can try to use extractor objects hiding some logic in unapply methods. It's hard to answer better without your actual code. Can you share couple of your actual cases describing their "repetitive" nature?

https://danielwestheide.com/blog/2012/11/21/the-neophytes-guide-to-scala-part-1-extractors.html

  trait Hierarchy

  class Case1(val s: String) extends Hierarchy

  object Case1 {
    def unapply(arg: Case1): Boolean = arg.s == "one" || arg.s == "two"
  }

  class Case2(val s: String) extends Hierarchy

  object Case2 {
    def unapply(arg: Case2): Boolean = arg.s == "three" || arg.s == "four" || arg.s == "five"
  }

  class Case3(val s: String) extends Hierarchy

  object Case3 {
    def unapply(arg: Case3): Option[String] = if (arg.s == "six" || arg.s == "seven") Some(arg.s) else None
  }

  class Case4(val s: String) extends Hierarchy

  object Case4 {
    // some other logic
    def unapply(arg: Case4): Option[(String, Int)] = if (arg.s == "eight") Some(arg.s, 8) 
                                                     else if (arg.s == "nine") Some(arg.s, 9) 
                                                     else None
  }

  val massiveCaseVariable: Hierarchy = ???

  massiveCaseVariable match {
    case Case1() => ???
    case Case2() => ???
    case Case3(s) => ???
    case Case4(s, n) => ???
  }

score 1 · Answer 3 · answered Apr 29 '19 at 18:11

Don't use pattern matching then, or at least not by itself.

trait Handler {
def canHandle(variable: String): Boolean
def handle(variable: String): Int
}
class HandlerCategory1 extends Handler {/*...*/}
class HandlerCategory2 extends Handler {/*...*/}
// ...

val variable: String = ???
val handlers = List(new HandlerCategory1(), new HandlerCategory2())

handlers.find(_.canHandle(variable)).map(_.handle(variable))

You can put your condition from pattern matching into specific canHandle() methods.

score 0 · Answer 4 · answered Apr 29 '19 at 09:41

You can organize it in following way

  val all = firstCategory() ++ secondCategory()

  all("some").apply()

  def firstCategory() : Map[String, () => ()] = {
    Map(
      "first" -> (() => {}),
      "second" -> (() => {})
    )
  }
  def secondCategory(): Map[String, () => ()] = {
    Map(
      "third" -> (() => {
        print("some code")
      }),
      "forth" -> (() => {
        print("some other code")
      })
    )
  }

Simplify Massive Match Case - Scala

4 Answers4