Scala 重载和子类

通常，如果我们有一个提取器，其参数类型为

A

，并且我们使用它来匹配

B>类型的对象：A

，那么在将该对象不适当地传递到提取器的

之前，将首先检查该对象是否是
A
的实例：

trait Foo
class SomeFoo extends Foo

object FooBar {
  def unapply(foo: SomeFoo) = true
}

def foo(foo: Foo): Unit = foo match {
  case FooBar() => println("ok")
}

调用
foo（newsomefoo）
应打印
ok

但是，如果我们在FooBar中重载方法
而不使用它
，它将不再工作：

object Test {

  trait Foo
  class SomeFoo extends Foo

  trait Bar
  class SomeBar extends Bar

  object FooBar {
    def unapply(foo: SomeFoo) = true
    def unapply(bar: SomeBar) = true
  }

  def foo(foo: Foo): Unit = foo match {
    case FooBar() => println("foo")
    case _        =>
  }

  def bar(bar: Bar): Unit = bar match {
    case FooBar() => println("bar")
    case _        =>
  }

  def main(args: Array[String]): Unit = {
    foo(new SomeFoo)
    bar(new SomeBar)
  }
}

我们得到一个错误：

overloaded method value unapply with alternatives:
 (bar: Test.SomeBar)Boolean <and>
 (foo: Test.SomeFoo)Boolean
cannot be applied to (Test.Foo)
    case FooBar() => println("foo")

然后像这样使用它：

term match {
  case x !: e => // ...
  case f % a => // ...
}

typedTerm match {
  case (x :: t) !: e => // ...
  case f % a => // ...
}

也许有一个不同的解决方案？
def unapply（t:Any）=t match{case\uuuu:TypedLambda=>TypedLambda.unapply（t）；…}
？嗯，我不知道我怎么没有想到这个…
def unapply（t:Any）=t match{case\uuuu:TypedLambda=>TypedLambda.unapply（t）；…}
？嗯，我不知道我怎么没有想到这个。。。
term match {
  case x !: e => // ...
  case f % a => // ...
}

typedTerm match {
  case (x :: t) !: e => // ...
  case f % a => // ...
}