1

MWE（obs。：我避免每次调用c时都必须实例化一个类，这就是需要函数的原因）：

object Main extends  App {
     def a(s:String, i:Int) ={
        s + i * i         //some complex op that yields String
     }

     def b(i:Int) ={
        i / 3             //another complex op that yields Int
     }

     def c(f: Any => Any) = { 
        val L = List(1,2,3,4) //list of complex elements
        L map f               //apply f within some complex loop
     }

     println(c(a))
     /*
        scala: type mismatch;
        found   : (String, Int) => String
        required: Any => Any
        println(c(a))
                  ^
      */

     println(c(b))
     /*
        scala: type mismatch;
        found   : Int => Int
        required: Any => Any
        println(c(b))
                  ^
     */
}

也许一个等效的问题是“是否有某种函数继承？”，比如

def f
def fa(i: Int):String extends f
def fb(s: String):Int extends f
4

2 回答 2

2

您尝试做的不是类型安全的，因为如果是，您可以将 a 传递String给带有Int参数的函数：

例如

def c(f: Any => Any) = { 
    val L = List("a", "b", "c")
    L map f
}

c(a)

但是，您可以使用 type 的函数Int => Any，因为将更派生的类型分配给 是安全的Any。

def c(f: Int => Any) = {
    val l = List(1,2,3,4)
    l.map(f)
}

现在是安全的：

val bList: List[Any] = c(b)

但是，您仍然无法传递a给c，因为它需要两个参数而不是一个。您可以部分应用第一个String参数并传递：

val cList = c(a("SomeString", _:Int))
于 2013-02-02T19:08:20.207 回答
1

如果您发现自己在使用Any,

  1. 你可能做错了什么，并且
  2. 你很可能需要泛型。

在你的情况下

def c[X,Y](f: X => Y) = { ... }

可能会成功，具体取决于您在该复杂循环中的内容。

于 2013-02-02T21:27:48.080 回答