Scala 简单问题-“；错误：缺少方法“的参数列表”；

我有一个简单的类和一个带有重载apply方法的伴生对象：

case class A(val s: String,
         val x: Int,
         val y: Int,
         val z: Int,
         val foo: Int => Int,
         val l: Option[List[String]])

object A {
    def apply(s: String, x: Int, y: Int, z: Int, foo: Int => Int) =
        new A(s, x, y, z, foo, None)

    def apply(s: String, x: Int, y: Int, z: Int, foo: Int => Int, l: List[String]) =
        new A(s, x, y, z, foo, Some(l))
}

让我们定义一个函数：

def foo(x: Int): Int = x + 1

使用第一个构造函数可以：

scala> val a1 = A("a1", 1, 2, 3, foo)
a1: A = A(a1,1,2,3,$$Lambda$1842/2112068307@598e02f0,None)

但是，使用第二种方法不会：

val a2 = A("a1", 1, 2, 3, foo, List("b1", "b2"))
<console>:24: error: missing argument list for method foo
Unapplied methods are only converted to functions when a function type is expected.
You can make this conversion explicit by writing `foo _` or `foo(_)` instead of `foo`.
       val a2 = A("a1", 1, 2, 3, foo, List("b1", "b2"))

vala2=A（“a1”、1、2、3、foo、List（“b1”、“b2”））
：24:错误：缺少方法foo的参数列表
未应用的方法仅在需要函数类型时才会转换为函数。
您可以通过编写'foo'或'foo（）`而不是'foo'，来明确此转换。
val a2=A（“a1”、1、2、3、foo、列表（“b1”、“b2”））

---

问题：我为什么需要通过

foo\u

或

foo（\u）

而不是像

a1

示例中那样只通过foo？另外，我是否可以重新定义我的类，使其能够只使用

foo

？

如果

foo

声明为函数

val

scala> val foo = (x: Int) => x + 1
foo: Int => Int = <function1>

scala> val a1 = A("a1", 1, 2, 3, foo)
a1: A = A(a1,1,2,3,<function1>,None)

scala> val a2 = A("a1", 1, 2, 3, foo, List("b1", "b2"))
a2: A = A(a1,1,2,3,<function1>,Some(List(b1, b2)))

scala>valfoo=（x:Int）=>x+1
foo:Int=>Int=
scala>vala1=A（“a1”，1，2，3，foo）
a1:A=A（a1,1,2,3，无）
scala>vala2=A（“a1”、1、2、3、foo、List（“b1”、“b2”））
a2:A=A（a1,1,2,3，，一些（列表（b1，b2）））

为什么

def foo

对

a1

很好，我不确定，但这可能与

case类A

期望函数而不是方法有关，因为在scala中这显然是两件不同的事情

---

我无法解释这一点。我的第一个想法是它与类型擦除有关，如前所述，但随后我更仔细地观察了签名，即使在擦除之后，它们都没有相同的类型签名：

案例类别

适用

：

String, Int, Int, Int, Function1, Option

伴生对象

apply

1：

String, Int, Int, Int, Function1

伴生对象

apply

2：

String, Int, Int, Int, Function1, List

所以，我看不出这是怎么回事

我注意到，如果您将第二个

apply

方法重命名为其他方法，它将正常工作：

scala> val a1 = A("a1", 1, 2, 3, foo)
a1: A = A(a1,1,2,3,$$Lambda$1286/1904652802@6b649efa,None)

scala> val a2 = A.apply2("a1", 1, 2, 3, foo, List("b1", "b2"))
a2: A = A(a1,1,2,3,$$Lambda$1287/866073173@2dd63e3,Some(List(b1, b2)))

或者定义两种

apply

方法（不在伴生对象中）：

object B {

    def apply(s: String, x: Int, y: Int, z: Int, foo: Int => Int): A =
      new A(s, x, y, z, foo, None)

    def apply(s: String, x: Int, y: Int, z: Int, foo: Int => Int, l: List[String]): A =
      new A(s, x, y, z, foo, Some(l))
}

答复:

如前所述，将

foo

定义为函数literal

（x:Int）=>x+1

的第三种方法也解决了这个问题。但是，它不必是

val

，也可以是

def

：

def foo = (x: Int) => x + 1

---

我在第二篇

apply

的正文中用

Some（l）

部分来概括它。很抱歉，我错过了这一点，并删除了我以前的评论realised@toni057我设法找出了一个描述同样问题的问题：（你只需要

apply

s而不是

r

s）很奇怪为什么定义一个对象B有助于我最初打算做的事情。有什么线索可以解释为什么它不能作为一个伴随对象工作吗？只要阅读帖子，似乎

a

需要一个函数而不是一个方法。有没有人能证实这一点？

def foo = (x: Int) => x + 1