scala抽象类型可以保存类型参数吗？

Question

我有以下简单的演示代码，它给了我类型不匹配的错误。 我很不明白为什么会发生这个错误。谁能告诉我如何解决这个错误。进一步解释或相关的学习资源将不胜感激。

object Application extends App {
  private val foo = new Foo
  private val holder = new FooTypeHolder
  private val client = new Client(holder)
  client.showElementType(foo)
}

class Foo

trait TypeHolder[T] {
  type ElementType = T
}

class FooTypeHolder extends TypeHolder[Foo]

class Client[T <: TypeHolder[_]](val holder: T) {

  def showElementType(t: T#ElementType): Unit = {
    println("show element type " + t.toString)
    println(t.getClass)
  }
}

编译错误为：

Error:(10, 26) type mismatch;
 found   : Application.foo.type (with underlying type Foo)
 required: _$1
  client.showElementType(foo)

2018 年 3 月 15 日更新

就像 Andrey Tyukin 会对 TypeHolder 的用途感到好奇一样，它除了 T 之外什么都没有。我在这个特征上添加了一些功能。

代码如下。

object Application extends App {
  private val foo = new Foo
  private val holder = new FooTypeHolder
  private val client = new Client(holder)
  client.showElementType(foo)
}

class Foo

trait TypeHolder[T] {
  type ElementType = T

  def holderFun(): Unit = println(s"holder, type:${getClass}")

  def elementFun(ele: ElementType): Unit = println(s"element, type:${getClass}")
}

class FooTypeHolder extends TypeHolder[Foo]

class Client[T <: TypeHolder[_]](val holder: T) {

  def showElementType(t: T#ElementType): Unit = {
    println("show element type " + t.toString)
    holder.holderFun()
    holder.elementFun(t)
  }

}

编译错误如下：

Error:(10, 26) type mismatch;
 found   : o2.Application.foo.type (with underlying type o2.Foo)
 required: _$1
  client.showElementType(foo)
Error:(30, 23) type mismatch;
 found   : _$1
 required: Client.this.holder.ElementType
    (which expands to)  _$1
    holder.elementFun(t)

总的来说，我想知道的核心是：

当我通过 val client = new Client(holder) 实例化 client 而holder 的类型为：TypeHolder[Foo] scala编译器是否可以推断hoder的ElementType是“Foo”？

非常感谢@Andrey 提供各种可行的解决方案。 我检查了你的代码sn -p 1~3，并仔细对比了我的代码，这让我现在更清楚了。不过我还有一些问题。

版本 3

这个版本的代码最接近我原来的邮政编码。唯一的区别是函数showElementType的类型限制

• 我的：def showElementType(t: T#ElementType): Unit
• 您的：def showElementType(t: holder.ElementType): Unit

让我感到困惑的是，既然“(t: holder.ElementType)”有效，那么“(t: T#ElementType)”也应该有效吗？而实际上并非如此。为什么？

版本 2

这里的区别是type ElementType = T 的位置。我把它放在特征定义中，而你把它放在类型参数限制中。

• 我的：trait TypeHolder[T] { type ElementType = T}
• 您的：class Client[T, H <: TypeHolder { type ElementType = T }]

我不明白为什么特征定义中的赋值语句不起作用。

版本 1

您使用两个类型参数T 和H 分别捕获Foo 和TypeHolder 的类型。它应该绝对有效。客户端的类型也对应Client[Foo, TypeHolder[Foo]]。我的问题是，是否可以定义客户端仅使用一种类型参数，例如Client[TypeHolder[Foo]]。换句话说，编译器是否有可能从TypeHolder[Foo] 推断出ElementType 是Foo？

谢谢。

Answer 1

我不确定您在这里尝试了什么，但这是我的“可能最接近可编译 Scala 的代码投影”的版本：

import scala.language.higherKinds
object Application extends App {
  private val foo = new Foo
  private val holder = new FooTypeHolder
  private val client = new Client(holder)
  client.showElementType(foo)
}

class Foo

trait TypeHolder[T] {
  type ElementType = T
}

class FooTypeHolder extends TypeHolder[Foo]

class Client[T, H[X] <: TypeHolder[X]](val holder: H[T]) {
  def showElementType(t: T): Unit = {
    println("show element type " + t.toString)
    println(t.getClass)
  }
}

但也可能是这样的：

import scala.language.higherKinds
object Application extends App {
  private val foo = new Foo
  private val holder = new FooTypeHolder
  private val client = new Client[Foo, FooTypeHolder](holder)
  client.showElementType(foo)
}

class Foo

trait TypeHolder {
  type ElementType
}

class FooTypeHolder extends TypeHolder {
  type ElementType = Foo
}

class Client[T, H <: TypeHolder { type ElementType = T }](val holder: H) {
  def showElementType(t: T): Unit = {
    println("show element type " + t.toString)
    println(t.getClass)
  }
}

或者这个？：

import scala.language.higherKinds
object Application extends App {
  private val foo = new Foo
  private val holder = new FooTypeHolder
  private val client = new Client(holder)
  client.showElementType(foo)
}

class Foo

trait TypeHolder[T] {
  type ElementType = T
}

class FooTypeHolder extends TypeHolder[Foo]

class Client[H <: TypeHolder[_]](val holder: H) {
  def showElementType(t: holder.ElementType): Unit = {
    println("show element type " + t.toString)
    println(t.getClass)
  }
}

---

我对您的代码根本不了解的是：TypeHolder[T] 到底应该做什么？整个TypeHolder[T] 构造似乎不包含T 本身之外的任何信息，那么为什么不直接使用T，像这样呢？：

object Application extends App {
  private val foo = new Foo
  private val client = new Client[Foo]
  client.showElementType(foo)
}

class Foo

class Client[T] {
  def showElementType(t: T): Unit = {
    println("show element type " + t.toString)
    println(t.getClass)
  }
}

---

一些一般提示：

• 避免一次问多个问题
• 避免在同一个帖子中就您上一个问题的答案之一提出多个问题。
• 这可能需要一些繁重的编辑...

编辑

我将尝试按照您添加到帖子中的顺序或多或少相同的顺序回答所有其他问题：

1. 它适用于holder.ElementType，因为当您实例化Client 时，holder 的类型为TypeHolder[Foo]，因此我们知道holder.ElementType = Foo。

2. 它不适用于 T#ElementType for T <: TypeHolder[_]，因为正如签名中的存在性所说，T 可以是 TypeHolder forSome 未指定的 @987654339 @：

T <: TypeHolder[_$1] forSome { type _$1 }

T#ElementType 
  = (TypeHolder[_])#ElementType
  = (TypeHolder[_$1] forSome { type _$1 })#ElementType 
  = _$1

因此，T#ElementType 被设置为某种奇怪的合成存在类型 _$1，您会收到类似于以下内容的错误消息：

typeHolder.scala:6: error: type mismatch;
  found   : Main.foo.type (with underlying type Foo)
  required: _$1
  client.showElementType(foo)
                         ^

因此，将其设置为存在类型完全没有用，您将永远无法找到满足这种奇怪类型约束的术语。你甚至不能强制转换成这种类型，因为这种类型甚至没有可以在代码中的任何地方引用它的名称。

说实话：这似乎完全是垃圾。整个投影根本不应该编译，为什么世界上会有人想要一个存在量化的类型从它的量词下逃脱？这可能应该报告为编译器问题。

3.定义

class Client[T, H <: TypeHolder { type ElementType = T }]

之所以有效，是因为它还保持了 T 明确的类型。如果你换了 通过存在主义

class Client[T, H <: TypeHolder { type ElementType = X forSome { type X }}]

然后T 和TypeHolder 之间的每个连接都会丢失，并且它会失败的原因与上面的T#ElementType 非常相似：你只是不能用一些未知的存在替换元素类型，然后希望能把Foo传给它。

4. 关于“是否可以定义客户端只使用一种类型参数？” -- 当然，为什么不呢？

import scala.language.higherKinds
object Application extends App {
  private val foo = new Foo
  private val holder = new FooTypeHolder
  private val client = new Client(holder)
  client.showElementType(foo)
}

class Foo

trait TypeHolder {
  type ElementType
}

class FooTypeHolder extends TypeHolder {
  type ElementType = Foo
}

class Client[H <: TypeHolder](val holder: H) {
  def showElementType(t: H#ElementType): Unit = {
    println("show element type " + t.toString)
    println(t.getClass)
  }
}

只是不要在TypeHolder 中添加任何类型参数，这样你以后就不必通过existentials 删除它们。

Answer 2

经过一些修改后编译：

object Application extends App {
  private val foo = new Foo
  private val holder = new FooTypeHolder
  private val client = new Client(holder)
  // not sure why you try to use this one
  // client.showElementType(foo)
  // foo doesn't extend the Typeholder, it's just regular class

  // on the other hand this will compile
  client.showElementType(holder)
}

class Foo

trait TypeHolder[T] {
  type ElementType = T
}

class FooTypeHolder extends TypeHolder[Foo]

class Client[T <: TypeHolder[_]](val holder: T) {

  // no need to use the #ElementType
  def showElementType(t: T): Unit = {
    println("show element type " + t.toString)
    println(t.getClass)
  }
}

希望这也有帮助：

What does the `#` operator mean in Scala?

https://github.com/ghik/opinionated-scala/wiki/Generics-and-type-members

就错误 _$1 而言，它只是编译器说：“我无法弄清楚这个”