Question

当我尝试编译小例子时：

trait Foo[A,B] {
  type F[_,_]
  def foo(): F[A,B]
}

class Bar[A,B] extends Foo[A,B] {
  type F[D,E] = Bar[D,E]
  def foo() = this
}

object Helper {
  def callFoo[A,B,FF <: Foo[A,B]]( f: FF ): FF#F[A,B] =
    f.foo()
}

object Run extends App {
  val x = new Bar[Int,Double]
  val y = Helper.callFoo(x)
  println( y.getClass )
}

我收到错误：

[error] src/Issue.scala:20: inferred type arguments
[Nothing,Nothing,issue.Bar[Int,Double]] do not conform to method callFoo's type
parameter bounds [A,B,FF <: issue.Foo[A,B]]
[error]       val y = Helper.callFoo(x)

显然，类型推断机制无法推断Bar [A，B]中的A和B.但是，如果我手动传递所有类型，它就可以工作：

val y = Helper.callFoo[Int,Double,Bar[Int,Double]](x)

我有办法避免明确传递类型吗？

Answer 1

您必须将callFoo的签名更改为：

def callFoo[A, B, FF[A, B] <: Foo[A, B]](f: FF[A, B]): FF[A, B]#F[A, B] =

您必须告诉编译器FF实际上是参数化类型。

Answer 2

使用类型成员而不是参数吗？

trait Foo {
  type A
  type B
  type F
  def foo(): F
}

class Bar extends Foo {
  type F = Bar
  def foo() = this
}

object Helper {
  def callFoo[FF <: Foo]( f: FF ): FF#F =
    f.foo()
}

object Run extends App {
  val x = new Bar{type A=Int; type B=Double}
  val y = Helper.callFoo(x)
  println( y.getClass )
}

当使用类型成员时，知道它们可以使用细化作为类型参数浮出来是有用的，如Miles Sabin对：Why is this cyclic reference with a type projection illegal?的回答

另请参阅最近的问题，该问题与您的问题类似：Scala fails to infer the right type arguments

在Scala中输入Nothing的类型

2 个答案: