Question

我正在尝试使用非常通用的类型参数来参数化一些方法。

例如，在REPL中我首先定义：

trait Term
case class FunctionalTerm[+T <: Term](t: T) extends Term

直观地说，下面的方法接受一个Term和一个FunctionalTerm，并返回类型为传递的术语类型的最小上限和FunctionalTerm的参数类型的东西：

def ex1[T1 <: Term, T3 <: X, FunctionalTerm[T1] <: X, X <: R, R <: Term](t1: FunctionalTerm[T1], s: T3): R = sys.error("TODO")

到目前为止，REPL非常好。

然后我将ex2定义为一个便捷函数，它执行与ex1相同的操作，但是交换了输入参数：

def ex2[T2 <: Term, T3 <: X, FunctionalTerm[T2] <: X, X <: R, R <: Term](s: T3, t2: FunctionalTerm[T2]): R = ex1(t2,s)

尝试在REPL中定义ex2会出现以下错误：

error: inferred type arguments [T2,T3,FunctionalTerm,T3,T3] do not conform to method ex1's type parameter bounds [T1 <: Term,T3 <: X,FunctionalTerm[T1] <: X,X <: R,R <: Term]
         ex1(t2,s)
         ^
error: type mismatch;
 found   : FunctionalTerm[T2]
 required: FunctionalTerm[T1]
         ex1(t2,s)
             ^
error: type mismatch;
 found   : T3(in method ex2)
 required: T3(in method ex1)
         ex1(t2,s)
                ^
error: type mismatch;
 found   : R(in method ex1)
 required: R(in method ex2)
         ex1(t2,s)
            ^

我花了大约两天的时间试图找出解决方案，现在我完全陷入了困境。我在Google上找不到更多内容。

由于ex2的类型参数列表与ex1的类型参数列表相同，但交换了T1和T2，我不明白是错误的，或者如何解决它。

非常感谢任何帮助！

更新

最小上限是红鲱鱼。这个例子可以进一步提炼。

可以在REPL中定义以下两个函数而不会出现错误：

def ex1[T1 <: Term, FunctionalTerm[T1] <: Term](t1: FunctionalTerm[T1]): Term = sys.error("TODO: ex1")
def ex2[T2 <: Term, FunctionalTerm[T2] <: Term](t2: FunctionalTerm[T2]): Term = ex1(t2)

引入额外参数X似乎会导致问题。我可以在REPL中定义以下内容：

def ex3[T1 <: Term, FunctionalTerm[T1] <: X, X <: Term](t1: FunctionalTerm[T1]): Term = sys.error("TODO: ex3")

但是试图随后定义：

def ex4[T2 <: Term, FunctionalTerm[T2] <: X, X <: Term](t2: FunctionalTerm[T2]): Term = ex3(t2)

给出错误：

error: inferred type arguments [T2,FunctionalTerm,Nothing] do not conform to method ex3's type parameter bounds [T1 <: Term,FunctionalTerm[T1] <: X,X <: Term]
       def ex4[T2 <: Term, FunctionalTerm[T2] <: X, X <: Term](t2: FunctionalTerm[T2]): Term = ex3(t2)
                                                                                               ^
error: type mismatch;
 found   : FunctionalTerm[T2]
 required: FunctionalTerm[T1]
       def ex4[T2 <: Term, FunctionalTerm[T2] <: X, X <: Term](t2: FunctionalTerm[T2]): Term = ex3(t2)
                                                                                                   ^

所以，我想问题就变成了：为什么签名中未使用的参数X会产生这种效果？

Answer 1

我不确定你是否遇到了一个bug，但我很确定你的生活会变得更加困难。你可以依靠协方差和统一来为你做所有艰苦的工作，

scala> trait Term
defined trait Term

scala> case class FunctionalTerm[+T <: Term](t: T) extends Term
defined class FunctionalTerm

scala> def ex1[T <: Term](t1 : FunctionalTerm[T], s : T) : T = s
ex1: [T <: Term](t1: FunctionalTerm[T], s: T)T

scala> class A extends Term ; class B extends A ; class C extends A
defined class A
defined class B
defined class C
scala> ex1(new FunctionalTerm(new B), new C)
res0: A = C@4ceeb514

请注意推断的结果类型（相当于原始更复杂定义的R）... A，即B和{{1}的LUB }。

现在翻转的版本很简单，Just Works，

Answer 2

我要简化你的例子（我使用的是2.9.1）：

scala> trait Term; case class FunctionalTerm[+T <: Term](t: T) extends Term;
defined trait Term
defined class FunctionalTerm

scala> def ex1[T1 <: Term, T3 <: X, FunctionalTerm[T1] <: X, X <: R, R <: Term](t1: FunctionalTerm[T1], s: T3): R = sys.error("TODO")
ex1: [T1 <: Term, T3 <: X, FunctionalTerm[T1] <: X, X <: R, R <: Term](t1: FunctionalTerm[T1], s: T3)R

现在声明第二种方法：

scala> def ex2[T2 <: Term, T3 <: X, FunctionalTerm[T2] <: X, X <: R, R <: Term](s: T3, t2: FunctionalTerm[T2]): R = ex1(t2, s)
<console>:11: error: inferred type arguments [T2,T3,FunctionalTerm,T3,T3] do not conform to method ex1's type parameter bounds [T1 <: Term,T3 <: X,FunctionalTerm[T1] <: X,X <: R,R <: Term]
       def ex2[T2 <: Term, T3 <: X, FunctionalTerm[T2] <: X, X <: R, R <: Term](s: T3, t2: FunctionalTerm[T2]): R = ex1(t2, s)
                                                                                                                    ^

可疑事（对我来说）是推断类型[T2,T3,FunctionalTerm,T3,T3] - 特别是FunctionalTerm。 FunctionalTerm是类型的构造函数 * -> *，但该方法需要在此位置使用类型*。

我会说这（大概）是一个错误，因此您应该将其提交给scala-user邮件列表（在提高票证之前） - Adriaan Moors 和 Miles Sabin < / strong>更有可能得到关于我是否正确的详细答案。

Scala类型：最小上限

2 个答案: