3

我想将具有抽象类型的类型的值赋予一个类，然后使用它的路径相关类型。看下面的例子（使用 Scala 2.10.1）：

trait Foo {
  type A
  def makeA: A
  def useA(a: A): Unit
}

object Test {

  class IntFoo extends Foo {
    type A = Int
    def makeA = 1
    def useA(a: Int) = println(a)
  }

  class FooWrap(val a: Foo) {
    def wrapUse(v: a.A) = a.useA(v)
  }

  val foo = new IntFoo

  /* Path dependent locally */
  val bar = foo  
  bar.useA(foo.makeA)   // works

  /* Path dependent through class value */
  val fooWrap = new FooWrap(foo)

  fooWrap.a.useA(foo.makeA)  // fails
  // error: type mismatch; found : Int required: Test.fooWrap.a.A

  fooWrap.wrapUse(foo.makeA) // fails
  // error: type mismatch; found : Int required: Test.fooWrap.a.A

}

首先，我不明白本地和类值情况之间的根本区别（注意公共的、不可变的值）以及类型检查失败的原因（因为很明显Test.fooWrap.a.A =:= foo.A）。这是 Scala 编译器的限制吗？

其次，我怎样才能实现我想要做的事情？

更新

似乎这可以通过使用泛型和内联类型约束来实现：

class FooWrap[T](val a: Foo { type A = T }) {
  def wrapUse(v: T) = a.useA(v)
}

但是，在我的情况下，A实际上是一种更高种类的类型，因此示例变为：

trait Foo {
  type A[T]
  def makeA[T]: A[T]
  def useA(a: A[_]): Unit
}

object Test {

  class OptFoo extends Foo {
    type A[T] = Option[T]
    def makeA[T] = None
    def useA(a: A[_]) = println(a.get)
  }

  class FooWrap(val a: Foo) {
    def wrapUse(v: a.A[_]) = a.useA(v)
  }

  val foo = new OptFoo

  /* Path dependent locally (snip) */

  /* Path dependent through class value */
  val fooWrap = new FooWrap(foo)

  fooWrap.a.useA(foo.makeA)  // fails
  // polymorphic expression cannot be instantiated to expected type;
  // found : [T]None.type required: Test.fooWrap.a.A[_]

  fooWrap.wrapUse(foo.makeA) // fails
  // polymorphic expression cannot be instantiated to expected type;
  // found : [T]None.type required: Test.fooWrap.a.A[_]

}
4

2 回答 2

3

在您最初的问题中，您的问题是 Scala 编译器无法证明结果类型foo.makeA与fooWrap.a.useA. foo要做到这一点，它需要能够证明fooWrap.a我们可以直观地看到的身份必须是这里的情况，但这对于编译器来说并不容易跟踪。

有几种方法可以解决这个问题。首先，您可以使用fooWrap.auniformly 代替foo,

scala> fooWrap.a.useA(fooWrap.a.makeA)
1

现在编译器很容易将 A ( fooWrap.a) 的前缀识别为在两次出现中都是相同的。

其次，您可以以更精确地FooWrap捕获其参数类型的方式进行参数化，Foo

scala> class FooWrap[F <: Foo](val a: F) {
     |   def wrapUse(v: a.A) = a.useA(v)
     | }
defined class FooWrap

scala> val fooWrap = new FooWrap(foo)
fooWrap: FooWrap[IntFoo] = FooWrap@6d935671

scala> fooWrap.a.useA(foo.makeA)
1

这里的类型参数FooWrap被推断为IntFoo而不是裸露Foo的，因此A被认为是精确Int的，因为它在结果类型中foo.makeA。

在您的更新中，您引入了一个额外的皱纹：您将签名更改useA为，

def useA(a: A[_]): Unit

这_是一个存在主义，它将挫败所有试图哄骗编译器证明有用的类型等式的尝试。相反，你需要一些类似的东西，

trait Foo {
  type A[T]
  def makeA[T]: A[T]
  def useA[T](a: A[T]): Unit
}

class OptFoo extends Foo {
  type A[T] = Option[T]
  def makeA[T]: A[T] = None
  def useA[T](a: A[T]) = a map println
}

class FooWrap[F <: Foo](val a: F) {
  def wrapUse[T](v: a.A[T]) = a.useA(v)
}

val foo = new OptFoo

示例 REPL 会话，

scala> val fooWrap = new FooWrap(foo)
fooWrap: FooWrap[OptFoo] = FooWrap@fcc10a7

scala> fooWrap.a.useA(foo.makeA)

scala>
于 2013-04-24T12:50:06.560 回答
0

更高种类的类型也可以作为通用参数添加到 FooWrap 中：

class FooWrap[T[V]](val a: Foo { type A[V] = T[V] }) {
  def wrapUse(v: T[_]) = a.useA(v)
}

但是（在此示例中）推理失败：

val fooWrap = new FooWrap[Option](foo)

否则：

- type mismatch; found : Test.foo.type (with underlying type Test.OptFoo) required: Foo{type A[V] = T[V]}
- inferred kinds of the type arguments (Option[V]) do not conform to the expected kinds of the type parameters (type T) in class FooWrap. Option[V]'s type parameters do not match type T's expected 
 parameters: class Option has one type parameter, but type T has one

还有其他更好的解决方案吗？

于 2013-04-23T22:49:42.657 回答