Question

我试图表达一个约束：

in a method def run[A, B](...), B must be equal to A#SomeInner

这是我的示例代码：

trait Wrapper {
  type Implementation
  implicit val instance: Data[Implementation]
}

trait Data[A] {
  def create : A
}

object DataInstances {
  implicit object IntData extends Data[Int] { def create = 0}
  implicit object StringData extends Data[String] { def create = "<empty>"}
  implicit object FloatData extends Data[Float] { def create = 0.5F}
}


import DataInstances._

object IntWrapper extends Wrapper { type Implementation = Int; implicit val instance = IntData }
object StringWrapper extends Wrapper { type Implementation = String; implicit val instance = StringData}
object FloatWrapper extends Wrapper { type Implementation = Float; implicit val instance = FloatData}



object Test extends App {

  def run[W <: Wrapper, D](wrapper: W)(implicit data: Data[D], ev: D =:= W#Implementation) : D = {
    data.create
  }

  run(StringWrapper)
}

在这里我收到编译错误：

Error:(31, 6) ambiguous implicit values:
              both object IntData in object DataInstances of type DataInstances.IntData.type
              and object StringData in object DataInstances of type DataInstances.StringData.type
              match expected type Data[D]
              run(StringWrapper)
                ^

你能解释一下为什么编译器发现它不明确吗？从我所知道的（以及我试图表达的内容）是当我通过StringWrapper时，根据类型相等证据，D的唯一可能值是String，因此只有data的可能值为StringData。

但显然编译器并不这么认为：）

正确表达这种约束的方法是什么？

Answer 1

我没有看到在方法运行中引入类型D的原因。没有它，方法签名看起来更简单并且成功编译

def run[W <: Wrapper](wrapper: W)(implicit data: Data[W#Implementation]) : W#Implementation = {
     data.create
}

+++

顺便说一句，如果你改变原始方法中的含义顺序，它也会编译，看起来像是＆＃39; ev＆＃39;帮助＆＃34;类型绑定＆＃34;隐含的数据解析

  def run[W <: Wrapper, D](wrapper: W)(implicit ev: D =:= W#Implementation, data: Data[D]) : D = {
    data.create
  }

Scala类型相等和路径相关类型

1 个答案: