scala - 如何在多态 unapply 中使用提取器？

Question

我真的不明白这个小东西。我有一个抽象类 Box
有几个不同类型的子类。例如

abstract class Box
class StringBox(val sValue : String) extends Box

Box 的伴随对象中的 apply 方法很简单:

object Box{
    def apply(s: String)  = new StringBox(s)
    def apply(b: Boolean) = new BooleanBox(b)
    def apply(d: Double)  = new DoubleBox(d)
}

所以我可以写

    val sb = Box("StringBox)

好吧，写 unapply 会带来一些麻烦。我的第一个想法是在类型上使用模式匹配，如下所示:

def unapply(b: Box) = b match {
  case sb: StringBox => Some(sb.sValue)
  case bb: BooleanBox => Some(bb.bValue)
  case db: DoubleBox => Some(db.dValue)
  case _ => None

}

由于类型删除，这根本不起作用。

第二次尝试是一个泛型 Box[T] 具有类型 T 和重新定义的抽象类型成员
在每个子类中。例如:

 abstract class Box[T] {def value : T}
 class StringBox(val sValue : String)  extends Box[String] { 
   override def value : String = sValue
 }

因此，我可以将我的 unapply 重新写为:

def unapply[T](b: Box[T]) = b match {
  case sb: Box[String]  => Some(sb.value)
  case bb: Box[Boolean] => Some(bb.value)
  case db: Box[Double]  => Some(db.value)
  case _ => None

不幸的是，这也不起作用。所以我猜是显式类型引用
在 Box[String] 中也被删除，所以我需要改用类型 list 。
也许是这样的:

def unapply[T](b: Box[_])(implicit target: Manifest[T]): Option[T] = {

   if(b.value ==  target) Some(b.value.asInstanceOf[T])
   else None 
}

此代码编译 (2.10) 但仍然没有所需的隐式转换。
为什么？

简单的问题，有没有办法不使用反射进行值提取
还是 list ？

真正让我感到困惑的是，是否有一种简单的(r)方法来组合
多态和模式匹配？如果没有，Scala 中是否还有其他方法可以
达到类似的效果？

有什么想法或建议吗？

非常感谢。

Answer 1

Prolly你可以试试这个..:)

  abstract class Box[T](val v: T)

  object Box {
    def apply(s: String) = new StringBox(s)
    def apply(b: Boolean) = new BooleanBox(b)
    def apply(d: Double) = new DoubleBox(d)

  }

  class StringBox(sValue: String) extends Box(sValue)
  object StringBox {
    def unapply(b: StringBox) = Some(b.v)
  }

  class BooleanBox(sValue: Boolean) extends Box(sValue)
  object BooleanBox {
    def unapply(b: BooleanBox) = Some(b.v)
  }

  class DoubleBox(sValue: Double) extends Box(sValue)
  object DoubleBox {
    def unapply(b: DoubleBox) = Some(b.v)
  }

你可以把它用作——

  def useCase[T](box: Box[T]) = box match {
    case StringBox("StringBoxxx") => "I found the StringBox!"
    case StringBox(s) => "Some other StringBox"
    case BooleanBox(b) => {
             if (b)  "Omg! its true BooleanBox !"
             else "its false BooleanBox :("
             }
    case DoubleBox(x) => {
                if (x > 3.14)  "DoubleBox greater than pie !"
                else if (x == 3.14) "DoubleBox with a pie !"
                else "DoubleBox less than a pie !"
    }
    case _ => "What is it yaa ?"
  }                                             

  useCase(Box("StringBoxxx")) //> res0: String = I found the StringBox!
  useCase(Box("Whatever !"))  //> res1: String = Some other StringBox
  useCase(Box(true))          //> res2: String = Omg! its true BooleanBox !
  useCase(Box(false))         //> res3: String = its false BooleanBox :(
  useCase(Box(4))             //> res4: String = DoubleBox greater than pie !
  useCase(Box(3.14))          //> res5: String = DoubleBox with a pie !
  useCase(Box(2))             //> res6: String = DoubleBox less than a pie !