具有类型成员的隐式包装特征无法编译

Question

由于最后一行，以下内容无法编译：

object ImplicitWrappedTraitWithType {

  trait Wrapper[+T] {
    def unwrap: T
  }

  object Wrapper {
    def apply[T](implicit w: Wrapper[T]): Wrapper[T] = w
  }

  trait IO[In] {
    type Out

    def out: Out
  }

  implicit def decoder[In]: Wrapper[IO[In] {type Out = String}] = new Wrapper[IO[In] {type Out = String}] {
    override def unwrap: IO[In] {type Out = String} = new IO[In] {
      override type Out = String
      override val out: Out = "yeah"
    }
  }

  val wrap = Wrapper[IO[String]]
  val io: IO[String] = wrap.unwrap
  val out: String = io.out //actual type: unwrap.Out
}

我该怎么做才能让编译器相信val out 是String？

---

预编辑 - 忽略此

示例 1 - 无法编译：

object ImplicitWrappedTraitWithType {
  class Wrapper[T]
  object Wrapper {
    def apply[T](implicit w: Wrapper[T]): Wrapper[T] = w
  }
  trait IO[In] {
    type Out
  }
  implicit def decoder[In]: Wrapper[IO[In] {type Out = String}] = null

//client code
  Wrapper[IO[String]]
}

示例 2 - 而这样做：

object ImplicitWrappedTraitWithType {
  class Wrapper[T]
  object Wrapper {
    def apply[T](implicit w: Wrapper[T]): Wrapper[T] = w
  }
  trait IO[In] {
    type Out
  }
  implicit def decoder[In]: Wrapper[IO[In]] = null

//client code
  Wrapper[IO[String]]
}

在客户端代码中，我不知道Out 的类型是什么，但是当我从Wrapper 提取IO 的实例时我需要能够访问它（未显示的代码)。

必须如何更改“示例 1”才能编译，同时以客户端代码可见的方式保留 Out 参数。

（如果这个表述不清楚，请评论）

Answer 1

您只需要对代码进行两次小修改。

trait Wrapper[+T] {
  def unwrap: T
}

object Wrapper {
  def apply[T](implicit w: Wrapper[T]): w.type = w
}

trait IO[In] {
  type Out

  def out: Out
}

implicit def decoder[In]: Wrapper[IO[In] {type Out = String}] = new Wrapper[IO[In] {type Out = String}] {
  override def unwrap: IO[In] {type Out = String} = new IO[In] {
    override type Out = String
    override val out: Out = "yeah"
  }
}

val wrap = Wrapper[IO[String]]
val io = wrap.unwrap
val out: String = io.out

最重要的是将apply方法的返回类型改为w.type。这样，w 的完整类型（包括所有改进）将被保留。如果您将Wrapper[T] 写为返回类型，并要求T 等于IO[String] 的Wrapper[T]，您将获得Wrapper[IO[String]]，并且所有额外的知识（如{type Out = String}）都将丢失。

第二：在val io: IO[String] = wrap.unwrap 中，你说io 是IO[String]。同样，所有额外的知识都丢失了。所以只要让编译器推断io的类型。

另一件事：如果您不希望 Wrapper 在 T 中是协变的，您可以省略方差注释并更改您的 apply 方法。

trait Wrapper[T] {
  def unwrap: T
}

object Wrapper {
  def apply[T](implicit w: Wrapper[_ <: T]): w.type = w
}

这样编译器仍然知道如果您调用Wrapper.apply[IO[String]]，它必须寻找IO[String] 的子类型。因为IO[String]{type out = String} 是IO[String] 的子类型，所以它们不相等。

Answer 2

不清楚您要达到什么目标，但这能解决您的问题吗？ （注意 Wrapper 中的 -T）

object ImplicitWrappedTraitWithType {
  class Wrapper[-T]
  object Wrapper {
    def apply[T](implicit w: Wrapper[T]): Wrapper[T] = w
  }
  trait IO[In] {
    type Out
  }
  implicit def decoder[In]: Wrapper[IO[In]] = null


}
import ImplicitWrappedTraitWithType._

trait IOString[In] extends IO[In] { 
  type Out = String
}
//client code
Wrapper[IOString[Int]]

在尝试为其查找隐式解码器时，我不会对 Out 类型施加任何限制。

用户是否定义了它自己的解码器，在这种情况下你不关心In和Out，或者你有一些基本的解码器并且你提供了它，例如：IO[Int, String], IO[ Int, Boolean] 等。