辅助模式使用编译，而不推断适当的类型。

Question

考虑以下涉及Aux-pattern的简单示例：

sealed trait AdtBase

abstract case class Foo(){
  type T <: AdtBase
}

object Foo{
  type Aux[TT] = Foo { type T = TT }
}

abstract case class Bar(){
  type T <: AdtBase
  val foo: Foo.Aux[T]
}

object Bar {
  type Aux[TT] = Bar { type T = TT }

  def apply[TT <: AdtBase](f: Foo.Aux[TT]): Bar = new Bar() {
    override type T = TT
    override val foo: Foo.Aux[T] = f
  }
}

case class Baz(foo: Foo)

def testBaz(baz: Baz) = Bar(baz.foo) //Compiles fine
def testFoo(foo: Foo) = Bar(foo) //Error: Type mismatch

斯卡斯蒂

我真的不明白为什么testBaz会编译。我也希望类型不匹配。

Answer 1

这似乎没有什么深层次的理由。

因为当您显式地指定type参数时，这两个方法都会编译

def testBaz(baz: Baz) = Bar[baz.foo.T](baz.foo) //compiles
def testFoo(foo: Foo) = Bar[foo.T](foo)         //compiles

它似乎在

def testBaz(baz: Baz) = Bar(baz.foo) //compiles
//def testFoo(foo: Foo) = Bar(foo)   //doesn't compile

在第一种情况下，baz.foo.T类型是推断出来的，而在第二种情况下，类型foo.T是不推断的。

// found   : Foo
// required: Foo.Aux[this.T]

在Scala中，总是有可能不会推断某些类型参数，因此您必须显式地指定它。

也许我找到了一个可能的原因。

密码

class testFoo2(foo: Foo) {
  // Bar(foo) // doesn't compile
}

不编译，但如果您将foo设置为val

class testFoo2(val foo: Foo) {
  Bar(foo) // compiles
}

那就有了。问题是，当foo是一个val时，它更“稳定”，在这种情况下，推断路径依赖类型foo.T“更容易”。

因此，testBaz和testFoo的区别在于，Baz是一个case类，foo是val，而在testFoo中，foo只是一个方法参数，因此不太“稳定”。

同样地，与

trait A[T]
def m[T](a: A[T]) = ???
m(??? : A[_]) // compiles

代码

trait A { type T } 
def m[_T](a: A { type T = _T}) = ??? 
m(??? : A) // doesn't compile

不编译，但如果我们提取一个变量

val a: A = ???
m(a) // compiles

那就有了。问题是，现在a是稳定的，并且可以推断a.T类型。