Question

请考虑以下代码：为什么S.|.NotOrNot.OUT不等于S.Not？

sealed trait S
object S {
  trait Not extends S
  trait A extends S
  trait B extends S
  trait C extends S
  trait |[X <: S, Y <: S] { type OUT <: S }
  trait LowerPriorityImplicits {
    // implicit def XorNot[X <: S] = |[X, Not, X]
    // implicit def NotOrX[X <: S] = |[Not, X, X]
  }
  object | extends LowerPriorityImplicits {
    def apply[X <: S, Y <: S, Z <: S]: X | Y = new |[X, Y] { type OUT = Z }
    // implicit def XorX[X <: S] = |[X, X, X]
    implicit lazy val NotOrNot = |[Not, Not, Not]
  }
}

import S._
def foo[X <: S, Y <: S](implicit ev: X | Y): ev.OUT = null.asInstanceOf[ev.OUT]
val bar = foo[Not, Not]
val baz: Not = foo[Not, Not] // found: S.|.NotOrNot.OUT  required: S.Not

编辑：

或者是一个浓缩的例子：

trait T { type Out }
object T {
  def apply[X]: T = new T { type Out = X }  
}
val t = T[Int]
val i: t.Out = 5 // found: Int(5)  required: t.Out

但这很好：

trait T[O] { type Out = O }
object T {
  def apply[X]: T[X] = new T[X] {}
}
val t = T[Int]
val i: t.Out = 5

Answer 1

您的apply方法表示返回类型为T，类型成员Out未指定。

以下完全指定了类型：

trait T { type Out }
object T {
  def apply[X]: T { type Out = X } = new T { type Out = X }  
}
val t = T[Int]
val i: t.Out = 5 // ok

依赖方法类型的问题

1 个答案: