Соответствуйте нескольким классам случаев в scala
любой метод хеширования, который равномерно распределяет значение хэш-функции по возможному диапазону, является хорошей реализацией. Посмотрите эффективный Java ( http://books.google.com.au/books?id=ZZOiqZQIbRMC&dq=effective+java&pg=PP1&ots=UZMZ2siN25&sig=kR0n73DHJOn-D77qGj0wOxAxiZw&hl=en&sa=X&oi=book_result&resnum=1&ct=result ), существует хороший совет там для реализации хэш-кода (объект 9, я думаю...).
3 ответа
Похоже, вы не заботитесь о значениях параметров 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"
}
}
There are a couple of ways that I can see to achieve what you are after, if you have some commonality between case classes. The first is to have the case classes extend a trait which declares the commonality, the second is to use a structural type which removes the need to extend your case classes.
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))
}
}
The structural type method generates a warning about erasure which, at present I'm not sure how to eliminate.
Ну, в этом нет никакого смысла, не так ли? 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"
}