0

我有以下代码：

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？

4

1 回答 1

0

@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，您始终可以通过Transand的类型成员公开它CurriedTrans。

于 2013-06-08T00:01:34.270 回答