Question

我有以下代码：

trait M[Type[_]]{
  type T[X] = Type[X]
  def from[A](f: T[A]): A
}
class ListM extends M[List]{ def from[A](f: T[A]) = f.head }

class Trans[A, X[_], B <: M[X]](val r: X[Option[A]])
trait CurriedTrans[X[_], B <: M[X]]{ type Type[A] = Trans[A, X, B] }
class TransM[X[_], B <: M[X]](val b: B) extends M[CurriedTrans[X, B]#Type]{
  def from[A] = (f: T[A]) => b.from(f.r).get
}

我可以用两种方式实例化TransM类型的变量：

val x1 = new TransM[List, ListM](new ListM)
val x2 = new TransM[ListM#T, ListM](new ListM)

我认为ListM＃T是冗余类型参数，所以我试图消除它：

trait M{
  type T[X]
  def from[A](f: T[A]): A
}
class ListM extends M {
  type T[X] = List[X]
  def from[A](f: T[A]) = f.head
}

class Trans[A, B <: M](val r: B#T[Option[A]])
class TransM[B <: M](val b: B) extends M {
  type T[X] = Trans[X, B]
  def from[Y] = (f: T[Y]) => b.from(f.r).get
}

将变量实例化为

val x = new TransM[ListM](new ListM)

不幸的是，由于类型不匹配错误，无法编译第二个实现：

type mismatch;
 found   : f.r.type (with underlying type B#T[Option[Y]])
 required: TransM.this.b.T[?]
      def from[Y] = (f: T[Y]) => b.from(f.r).get
                                          ^

我可以解决这个问题并简化我的代码，还是应该在所有地方编写样板ListM＃T？

Answer 1

@ziggystar说：放弃绑定B并直接使用M[X]：

class TransM[X[_]](val b: M[X]) extends M[CurriedTrans[X, M[X]]#Type] {
  def from[A](f: T[A]) = b.from(f.r).get
}

val x1 = new TransM(new ListM)

您可以考虑对Trans和CurriedTrans执行相同的操作。如果您需要内部类型M，则始终可以通过Trans和CurriedTrans的类型成员公开它。

Scala：更高级的类型，类型投影和类型不匹配错误

1 个答案: