scala - Scala 可以在参数中允许自由类型参数吗(Scala 类型参数是一等公民吗？)？

Question

我有一些 Scala 代码，它用两个不同版本的类型参数化函数做了一些漂亮的事情。我已经从我的应用程序中简化了很多，但最后我的代码充满了形式 w(f[Int],f[Double]) 的调用。哪里w()是我的魔法方法。我很想有一个更神奇的方法，比如 z(f) = w(f[Int],f[Double]) - 但我无法得到像 z(f[Z]:Z->Z) 这样的语法像(在我看来)那样工作，就像函数参数不能有自己的类型参数一样。这是 Scala 代码片段的问题。

有任何想法吗？宏可以做到这一点，但我认为这些不是 Scala 的一部分。

object TypeExample {
  def main(args: Array[String]):Unit = {
    def f[X](x:X):X = x              // parameterize fn
    def v(f:Int=>Int):Unit = { }     // function that operates on an Int to Int function
    v(f)                             // applied, types correct
    v(f[Int])                        // appplied, types correct
    def w[Z](f:Z=>Z,g:Double=>Double):Unit = {} // function that operates on two functions
    w(f[Int],f[Double])              // works
// want something like this:  def z[Z](f[Z]:Z=>Z) = w(f[Int],f[Double])
// a type parameterized function that takes a single type-parameterized function as an  
// argument and then speicalizes the the argument-function to two different types,  
// i.e. a single-argument version of w() (or wrapper)
  }
}

Answer 1

如果你很好奇，你在这里谈论的是“rank-k 多态性”。 See wikipedia .在你的情况下，k = 2。一些翻译:

当你写

f[X](x : X) : X = ... 

那么你是说 f 的类型是“forall X.X -> X”

您想要的 z 是输入“(forall Z.Z -> Z)-> Unit”。那对额外的括号有很大的不同。就维基百科文章而言，它将 forall 限定符放在 2 个箭头之前，而不仅仅是 1 个。类型变量不能仅实例化一次并继续执行，它可能必须实例化为许多不同的类型。 (这里的“实例化”并不意味着对象构造，它意味着将类型分配给类型变量以进行类型检查)。

正如 alexy_r 的回答所示，这可以在 Scala 中使用对象而不是直接函数类型进行编码，基本上使用类/特征作为括号。尽管他似乎在将其插入原始代码方面让您有些犹豫，但它是:

//这是你的代码

object TypeExample {
  def main(args: Array[String]):Unit = {
    def f[X](x:X):X = x              // parameterize fn
    def v(f:Int=>Int):Unit = { }     // function that operates on an Int to Int function
    v(f)                             // applied, types correct
    v(f[Int])                        // appplied, types correct
    def w[Z](f:Z=>Z,g:Double=>Double):Unit = {} // function that operates on two functions
    w(f[Int],f[Double])              // works

//这是新代码

    trait ForAll {
      def g[X](x : X) : X
    }

    def z(forall : ForAll) = w(forall.g[Int], forall.g[Double])
    z(new ForAll{def g[X](x : X) = f(x)})
  }
}