Совпадение нескольких классов дел в Scala - PullRequest
Новая
       10

Совпадение нескольких классов дел в Scala

97 голосов
/ 03 декабря 2009

Я выполняю сопоставление с некоторыми классами наблюдений и хотел бы обработать два случая одинаково. Примерно так: 

abstract class Foo
case class A extends Foo
case class B(s:String) extends Foo
case class C(s:String) extends Foo


def matcher(l: Foo): String = {
  l match {
    case A() => "A"
    case B(sb) | C(sc) => "B"
    case _ => "default"
  }
}

Но когда я делаю это, я получаю ошибку: 

(fragment of test.scala):10: error: illegal variable in pattern alternative
    case B(sb) | C(sc) => "B"

Я могу заставить его работать, я удаляю параметры из определения B и C, но как я могу сопоставить с параметрами?

Ответы [ 3 ]

141 голосов
/ 03 декабря 2009

Похоже, вы не заботитесь о значениях параметров String и хотите обрабатывать B и C одинаково, поэтому: 

def matcher(l: Foo): String = {
  l match {
    case A() => "A"
    case B(_) | C(_) => "B"
    case _ => "default"
  }
}

Если вы должны, должны, должны извлечь параметр и обработать их в одном и том же блоке кода, вы можете: 

def matcher(l: Foo): String = {
  l match {
    case A() => "A"
    case bOrC @ (B(_) | C(_)) => {
      val s = bOrC.asInstanceOf[{def s: String}].s // ugly, ugly
      "B(" + s + ")"
    }
    case _ => "default"
  }
}

Хотя я чувствую, что было бы намного чище включить это в метод: 

def doB(s: String) = { "B(" + s + ")" }

def matcher(l: Foo): String = {
  l match {
    case A() => "A"
    case B(s) => doB(s)
    case C(s) => doB(s)
    case _ => "default"
  }
}
9 голосов
/ 03 декабря 2009

Есть несколько способов добиться того, чего вы хотите, если у вас есть общие черты между классами дел. Во-первых, классы падежей должны расширять черту, которая объявляет общность, во-вторых, использовать структурный тип, который устраняет необходимость расширять классы падежей. 

 object MuliCase {
   abstract class Foo
   case object A extends Foo

   trait SupportsS {val s: String}

   type Stype = Foo {val s: String}

   case class B(s:String) extends Foo
   case class C(s:String) extends Foo

   case class D(s:String) extends Foo with SupportsS
   case class E(s:String) extends Foo with SupportsS

   def matcher1(l: Foo): String = {
     l match {
       case A        => "A"
       case s: Stype => println(s.s); "B"
       case _        => "default"
     }
   }

   def matcher2(l: Foo): String = {
     l match {
       case A            => "A"
       case s: SupportsS => println(s.s); "B"
       case _            => "default"
     }
   }

   def main(args: Array[String]) {
     val a = A
     val b = B("B's s value")
     val c = C("C's s value")

     println(matcher1(a))
     println(matcher1(b))
     println(matcher1(c))

     val d = D("D's s value")
     val e = E("E's s value")

     println(matcher2(d))
     println(matcher2(e))
   }
 }

Метод структурного типа генерирует предупреждение об удалении, которое в настоящее время я не знаю, как устранить.

6 голосов
/ 03 декабря 2009

Ну, это не имеет смысла, не так ли? B и C являются взаимоисключающими, поэтому sb или sc связываются, но вы не знаете, какой, поэтому вам потребуется дополнительная логика выбора, чтобы решить, какой из них использовать (учитывая, что они были связаны с Option [String], строка). Так что ничего не получилось за это: 

  l match {
    case A() => "A"
    case B(sb) => "B(" + sb + ")"
    case C(sc) => "C(" + sc + ")"
    case _ => "default"
  }

Или это: 

  l match {
    case A() => "A"
    case _: B => "B"
    case _: C => "C"
    case _ => "default"
  }
...