scala - 通用类型，这样一个方法的结果可以再次用作另一个方法的参数

Question

我的代码归结为工厂初始化一个对象，然后再次使用该对象执行其他操作:

trait Factory[T] {
  def initialize(): T;

  def finish(t: T): Unit;
}

据我了解，对于任何一个 Factory 实例，initialize 的结果应该始终适合传递给 finish，无论T。

工厂本身在不知道 T 是什么的地方被调用:

object Minimal {
  object StringFactory extends Factory[String] {}
  val factories = Map[Int, Factory[_]](0 -> StringFactory)

  val factory = factories(0)

  // (1)
  val obj = factory.initialize()
  factory.finish(obj)

  // (2)
  def wrapper[T](factory: Factory[T]): Unit = {
    val obj = factory.initialize()
    factory.finish(obj)
  }
  wrapper(factory)
}

虽然变体 (2) 有效，但变体 (1) 无效:

type mismatch; found : Minimal.obj.type (with underlying type Any) required: _$6

但我不知道如何解决这个问题。有可能吗？

编译器通过调用它自己搞不清楚的wrapper方法得到了什么？在我看来，obj 的类型应该是 _$6，因为编译器似乎命名了 _ 的捕获。我怎样才能让编译器意识到这一点，而不必为其引入全新的方法？

Answer 1

存在类型在将其实例分配给 val 本身后失去其存在性并成为上限，因此任何不进行此类分配的方式都将起作用，包括:

 scala> trait Factory[T] { type TT = T; def initialize(): TT; def finish(t: TT): Unit;}
 defined trait Factory

 scala> val factory: Factory[_] = new Factory[Int] {def initialize = 5; def finish(t: Int) {}}
 factory: Factory[_] = $anon$1@31d0ca61

 scala> factory.finish(factory.initialize())

这行不通:

scala> val obj = factory.initialize()
obj: Any = 5

scala> factory.finish(obj)
<console>:11: error: type mismatch;
 found   : Any
 required: factory.TT
    (which expands to)  _$1
              factory.finish(obj)
                             ^

这是因为 scala 不会将它们的类型视为相等的(除非它们是同一类型成员)，因为存在性意味着 intialize() 可以返回 Any 的任何子类，当 finish( ) 可以接受 Any 的任何(但不总是相同的)子类:

scala> trait Factory[T] { def initialize(): T; def finish(t: T): Unit;}
defined trait Factory

scala> val factory: Factory[_] = new Factory[Int] {def initialize = 5; def finish(t: Int) {}}
factory: Factory[_] = $anon$1@6e5da49

scala> factory.finish(factory.initialize())
<console>:10: error: type mismatch;
 found   : (some other)_$1(in value factory)
 required: _$1(in value factory)
              factory.finish(factory.initialize())
                                               ^

所以在这里绑定(bind)输入和输出的唯一方法是在它们之间共享类型成员。