如何在 Scala 中匹配函数签名而不收到类型擦除编译器警告

Question

任何人都可以重新编写此代码来执行相同的操作，但没有任何编译器警告吗？请：-

object TestTypeErasure {

  def main(args:Array[String]) {

    def myFunction(myObject:Any):Boolean = {
      true
    }

    val myVariable: (Any => Boolean) = myFunction

    myVariable match {
      case function:(Any => Boolean) => println("Match")
    }

  }
}

千谢万分，

基思

更新！！！！抱歉，对此进行了真正的哈希处理。这是我关于 SO 的第一个问题

只是为了让大师们知道我已经尝试过类似的方法也无济于事：-（无法编译它）

object TestTypeErasure {  

    def doTest(parameter: Any) = {  
        parameter match {  
            case function:Function1[_, _] => function("Whatever")  
        }  
    }  

    def main(args:Array[String]) {  
    }  

}  

我收到错误：-

TestTypeErasure.scala:6: error: type mismatch;
  found   : java.lang.String("Whatever")
  required: _
    case function:Function1[_, _] => function("Whatever")
                                                ^
one error found

再次感

谢基思

Answer 1

您可以使用清单捕获类型信息。 （为了简单起见，这里 T、R 是不变的。）

import scala.reflect._
def matchFunction[T,R](f: Function1[T,R], t : T)(implicit mt : Manifest[T], mr : Manifest[R]) = {
  val result = if ((mt.erasure, mr.erasure) == (classOf[Any], classOf[Boolean]))  "any, boolean " + f(t)
  else if((mt.erasure, mr.erasure) == (classOf[Int], classOf[Int])) "int, int " + f(t)
  else "Unknown " + f(t)
  println(result)
}

scala>     matchFunction((x : Int) => x + 1, 1)
int, int 2

scala>     matchFunction((x : Any) => true, 1 : Any)
any, boolean true

scala>     matchFunction((x : Boolean) => ! x, false)
Unknown 

对于 Scala 2.8，可以使用上下文边界，删除两个隐式参数：

import scala.reflect._
def matchFunction[T: Manifest,R : Manifest](f: Function1[T,R], t : T) = {
  val mt = implicitly[Manifest[T]]
  val mr = implicitly[Manifest[T]]
  val result = if ((mt.erasure, mr.erasure) == (classOf[Any], classOf[Boolean]))  "any, boolean " + f(t)
  else if((mt.erasure, mr.erasure) == (classOf[Int], classOf[Int])) "int, int " + f(t)
  else "Unknown " + f(t)
  println(result)
}

Answer 2

看看这个问题： 模式匹配零参数scala 中的函数：被警告迷惑了

Answer 3

有多种方法可能有效，但没有一种方法那么简单。

一种选择是使用清单，但您必须定义自己的清单感知匹配变体。您可以阅读有关清单的更多信息 此处。如果您必须经常做此类事情，那么这将是一个不错的选择，尽管此功能仍被认为是实验性的。

如果您的使用相对轻量级，另一种选择是将函数包装在某个非通用类中。例如，

object Example {
  def hasString(a:Any) = (a!=null && a.toString.length>0)

  case class AnyImpliesBoolean(f: (Any) => Boolean) { } 
  implicit def callAIB(aib: AnyImpliesBoolean) = aib.f

  def callWrapped(a: Any) {
    a match {
      case aib: AnyImpliesBoolean => println( aib("Check") )
      case _ => println("(Nothing)")
    }
  }

  def tryMe() {
    val has = AnyImpliesBoolean(hasString _)
    callWrapped( has )
    callWrapped("foo")
    callWrapped((s:String)=>true)
  }
}

scala> Example.tryMe
true
(Nothing)
(Nothing)

如果您要包装多个不同的函数，但数量不是太多，则可以创建一个基类 WrappedFunction，然后使用 AnyImpliesBoolean 扩展 WrappedFunction 之类的东西。

另一种选择是不实际传递函数，而是使用反射来传递 java.lang.Methods。方法知道它们的类型。即使有一些漂亮的 Scala 包装器，它仍然会有点笨重（而且性能不高）。

（编辑以添加我丢失的清单链接。）