Scala 通用函数值(匿名函数)- 缺少参数类型(错误) [英] Scala Generic Function Values (Anonymous Function) - Missing Parameter Type (Error)

问题描述

我是 Scala 的新手(Scala 代码运行器版本 2.7.7.final)，我真的不明白为什么在我们使用高订单功能.

I'm new to Scala (Scala code runner version 2.7.7.final), and I really don't understand why it requires the caller to provide the parameter type when we are using high order functions.

在下面的示例中，我有一个具有一个功能的独立对象 ( Util ).但是在Main块中，调用者必须将参数类型传递给匿名函数.

In the sample below, I have one stand alone object ( Util ) that has one function. But in the Main block, the caller must pass the parameter type to the anonymous function.

为什么 Scala 不从 Array 类型(即 String)推断函数的类型?有没有办法做到这一点?

Why does Scala not infer the type of the function from the Array type (i.e. String)? Is there any way to do that ?

object Util {

 // Just for fun! Suppose that the arrayOne and arrayTwo are all the same length.
 // will swap the elements from arrayOne to ArrayTwo.
  def swap[T](arrayOne:Array[T], arrayTwo:Array[T] , f:(T,T) =>(T,T)) {
    for(i <- 0 until (arrayOne.length min arrayTwo.length)){
      val (left, right) = f(arrayOne(i),arrayTwo(i))
      arrayOne(i) = left
      arrayTwo(i) = right
    }
  }
}

object Main extends Application {

   val arrayOne = Array("A","B","C")
   val arrayTwo = Array("D","E","F")

 //If not specified the type String,the compiler throws "Missing Parameter Type" error

Util swap(arrayOne, arrayTwo,(elem1:String,elem2:String)=>(elem2,elem1))

}

推荐答案

它不会推断 T 的类型，因为此时它唯一需要经过的是 arrayOne 和 arrayTwo.然而，Scala 不使用一个参数的类型来推断另一个参数的类型，可能是因为它会导致方法重载的问题.但是，如果你咖喱它，它会起作用:

It doesn't infer the type of T because the only thing it has to go by at this point would be arrayOne and arrayTwo. However, Scala does not use the type of one parameter to infer the type of another, probably because it would cause problems with method overloading. However, it works if you curry it:

Object Util {

 // Just for fun! Suppose that the arrayOne and arrayTwo are all the same length.
 // will swap the elements from arrayOne to ArrayTwo.
   def swap[T](arrayOne:Array[T], arrayTwo:Array[T])(f:(T,T) =>(T,T)) : Unit = {
     var i = 0   
        var tuple :Tuple2[T,T] = null
       while(i < arrayOne.length && i < arrayTwo.length){
         tuple =f(arrayOne(i),arrayTwo(i))
         arrayOne(i) = tuple._1
         arrayTwo(i) = tuple._2
         i+=1
        }
      }
}

object Main extends Application {

   // val works fine below -- the object is mutable
   val arrayOne = Array("A","B","C")
   val arrayTwo = Array("D","E","F")

   (Util swap(arrayOne, arrayTwo))((elem1,elem2)=>(elem2,elem1))
   // The weird parenthesis is caused by mixing operator notation and currying
   // One could also write it like this:
   // Util.swap(arrayOne, arrayTwo)((elem1,elem2)=>(elem2,elem1))
}

如果你使用柯里化它可以正常工作的原因是柯里化方法实际上是一个接收第一个参数列表并返回一个需要其他(或其他)参数列表的函数的方法.因此，可以在第一个参数列表中决定重载，因此第二个参数列表可以利用推断类型.

The reason why it works fine if you curry it is that a curried method is actually a method receiving the first parameter list and returning a function that requires the other (or others) parameter list. Because of that, overloading can be decided in the first parameter list, so the second parameter list can take advantage of inferred types.

这篇关于Scala 通用函数值(匿名函数)- 缺少参数类型(错误)的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！