scala 模式匹配函数 - 如何绕过类型擦除

我想模式匹配一​​个函数，问题是类型擦除。请注意下面的代码片段，尽管warning发出了一场比赛，并且出现了“错误”的比赛。

scala> def f1 = ()=>true
f1: () => Boolean

scala> val fl = f1
fl: () => Boolean = <function0>

scala>

scala> fl match {
     | case fp :Function0[Boolean] => 1
     | case _ => 2
     | }
res8: Int = 1

scala>

scala> fl match {
     | case fp :Function0[String] => 1
     | case _ => 2
     | }
<console>:11: warning: fruitless type test: a value of type () => Boolean cannot also be a () => String (but still might match its erasure)
              case fp :Function0[String] => 1
                       ^
res9: Int = 1

scala>

我能想到的是一个包装该函数的案例类。我得到了类型安全，请注意下面的错误。But，首先，这是不优雅的，其次，我不明白案例类如何强制类型，而模式匹配却不能。我唯一的猜测是案例类受编译器保护，并且匹配仅在运行时解析

scala> case class FunctionWrapper(fn: ()=>Boolean)
defined class FunctionWrapper

scala> val fw = FunctionWrapper(fl)
fw: FunctionWrapper = FunctionWrapper(<function0>)

scala> def fs = ()=>"whatever"
fs: () => String

scala> val fws = FunctionWrapper(fs)
<console>:10: error: type mismatch;
 found   : () => String
 required: () => Boolean
       val fws = FunctionWrapper(fs)
                                 ^

scala> fw match {
     | case FunctionWrapper(f) => f()
     | case _ => false
     | }
res10: Boolean = true

总而言之，我想知道是否有一种优雅的方法来模式匹配函数，并且也许理解为什么上面的示例会这样做

简短的回答：您必须通过具体化类型来撤消擦除TypeTag.

我不明白案例类如何强制类型，而模式匹配却不能。

因为您的案例类没有类型参数。仅删除泛型类型，这就是为什么它被称为“partial擦除”。

相关问题：不同类型List的通用unapply方法 https://stackoverflow.com/questions/16885199/generic-unapply-method-for-different-types-of-list。以下代码本质上与其中的答案之一相同，但使用函数而不是列表：

import scala.reflect.runtime.universe._

def foo[A : TypeTag](a: A): Int = typeOf[A] match {
  case t if t =:= typeOf[Int => Int] => a.asInstanceOf[Int => Int](0)
  case t if t =:= typeOf[Boolean => Int] => a.asInstanceOf[Boolean => Int](true)
  case _ => 3
}

foo((i: Int) => i + 1)
// res0: Int = 1

foo((b: Boolean) => if (b) 2 else 0)
// res1: Int = 2

foo((b: Boolean) => !b)
// res2: Int = 3

我不确定是否有办法编写一个提取器来使匹配块更好。

如果您需要以丢失静态类型信息的方式传递这些函数（将它们推入集合中）Function[_, _]，使用 then 作为 Akka 消息等）那么你也需要传递标签：

import scala.reflect.runtime.universe._

case class Tagged[A](a: A)(implicit val tag: TypeTag[A])

def foo[A, B](tagged: Tagged[A => B]): Int = tagged.tag.tpe match {
  case t if t =:= typeOf[Int => Int] => tagged.a.asInstanceOf[Int => Int](0)
  case t if t =:= typeOf[Boolean => Int] => tagged.a.asInstanceOf[Boolean => Int](true)
  case _ => 3
}
foo(Tagged((i: Int) => i + 1))
// res0: Int = 1

foo(Tagged((b: Boolean) => if (b) 2 else 0))
// res1: Int = 2

foo(Tagged((b: Boolean) => !b))
// res2: Int = 3