如何在隐式中实现使用站点差异？

Question

对原始问题的大量修改：现在我预先展示整个代码，而不显示解释我动机的变体。对造成的混乱表示歉意。

我需要一个简单的类型类，在其中一个类型的成员类型上实现投影 - 出于本示例的目的，我们让它成为一个简单的转换：

trait Subject {
    type E
    type Const 
}

object Subject {
    implicit def projection :Projection[Subject] { type Project[X] = Subject { type E = X } } = ???
}

abstract class Projection[S <: Subject] {
    type Project[X] <: Subject { type E = X }
}

implicit class ProjectSubject[S <: Subject](private val self :S) extends AnyVal {
    def project[X](implicit p :Projection[S]) :p.Project[X] = ???
}

class Box[X] extends Subject { type E = X }

object Box {
    implicit def projection[A] :Projection[Box[A]] { type Project[X] = Box[X] } = ???
}

class Adapter[S <: Subject] extends Subject { type E = S#E }

object Adapter {
    implicit def adapterProjection[S <: Subject](implicit p :Projection[S])
        :Projection[Adapter[S]] { type Project[X] = Adapter[p.Project[X]] } = ???
}

val res = new Adapter[Box["E"]].project["F"]

在上面的例子中，很明显投影应该是递归的，Subject 子类声明自己的规则。显然，我希望投影实际上是逆变的：

class Specific extends Adapter[Box["E"]]
val spec = (new Specific).project["F"] //doesn't compile

如果Specific 不提供自己的投影，则应使用Adapter 的投影，最后一个表达式计算为Adapter[Box["F"]]。如果我声明Projection[-S <: Subject]，这很好用，但问题是我需要投影来保留一些属性，这里表示为Const 成员类型：

class Projection[S <: Subject] { 
    type Project[X] <: Subject { type E = X; type Const = S#Const }
}

为了清楚起见，我从上面的代码中删除了这个约束，因为它不会导致问题。

在前面的示例中，编译器会抱怨缺少隐式Projection[Specific]，而不会尝试向上转换该值。如何使其与使用站点差异编译？

不包含存在词：

implicit class ProjectSubject[S <: Subject](private val self :S) extends AnyVal {
    def project[X](implicit p :Projection[_ >: S <: Subject]) = ???
}

我的猜测是这里的通配符等同于Subject，除了Projection[Subject]之外，不会从编译器-Xlog-implicits未删节问题的日志中搜索任何隐含（该问题具有较大的主题层次结构和更多的隐含投影声明）。

然后我尝试了使用中间逆变隐式的技巧，这有时有效：

abstract class ProjectionAvailable[-S <: T, T <: Subject] //extends (S => T)
implicit def ProjectionAvailable[S <: Subject](implicit p :Projection[S]) :ProjectionAvailable[S, S] = ??? //(s :S) => s

implicit def ProjectionSubject[S <: T, T <: Subject](s :S)(implicit witness :ProjectionAvailable[S, T]) =
    new ProjectionSubject[T](s)

class ProjectionSubject[S <: Subject](private val self :S) extends AnyVal {
    def project[X](implicit p :Projection[S]) :p.Project[X] = p.asInstanceOf[p.Project[X]]
}

这看起来很有希望，但不幸的是，编译器和以前一样：查看可用的隐式，将类型参数实例化为ProjectionAvailable[Specific, T]，并抱怨缺少Projection，而没有利用其逆变性。我尝试了一个变体

class ProjectionAvailable[S <: T, T <: Subject]

除了更明显的错误之外没有任何真正的区别。我尝试整合 将ProjectionAvailable 转换为Projection，但它也没有任何改变：

class Projection[-S <: T, T] { /* as before */ }
 

我的预感是它可能是可行的，但需要巧妙地手动指导编译器进行类型推断，目前我没有新的探索途径。

Answer 1

我无法重现您提到的行为（这就是为什么我在 cmets 中询问您如何测试 def project[X](implicit p :Projection[_ >: S <: Subject]) = ??? 或使用 ProjectionAvailable 的方法对您不起作用）。

在ProjectSubject 中使用存在Projection 的方法我另外定义了Projection[Specific] 并且代码没有编译错误

Error: ambiguous implicit values:
 both value specificProjection in object App of type App.Projection[App.Specific]{type Project[X] = App.Specific}
 and method adapterProjection in object App of type [S <: App.Subject](implicit p: App.Projection[S]): App.Projection[App.Adapter[S]]{type Project[X] = App.Adapter[p.Project[X]]}
 match expected type App.Projection[_ >: App.Specific <: App.Subject]
  val spec = (new Specific).project["F"]

所以Projection[Specific] 的隐含在候选人之中，我看不出以下内容如何正确

这里的通配符等同于Subject，不会搜索除Projection[Subject]以外的任何隐式。

如果我使adapterProjection 的优先级低于我的附加隐式Projection[Specific] 那么

println(scala.reflect.runtime.universe.reify{
  (new Specific).project["F"]
}.tree)

打印

App.this.ProjectSubject(new App.this.Specific()).project["F".type](App.this.Implicits.specificProjection)

所以选择的是Projection[Specific]。

Scala 2.13.3.

https://scastie.scala-lang.org/Ts9UOx0aSfWuQJNOoVnSAA

原始逆变器Projection（没有类型类型Const）和第一个ProjectSubject（不存在Projection）的行为是相同的。

（我在In scala 2.13, how to use implicitly[value singleton type]? 的回答可能是相关的。）

顺便说一句，对于不变的Projection 和ProjectionAvailable，我不必优先考虑隐式，并且选择了Projection[Specific]。

https://scastie.scala-lang.org/nePYqjKGSWm8IRGLmYCwAA

当我没有定义额外的隐式Projection[Specific] 时，您使用存在主义Projection 的方法似乎有效，则选择adapterProjection。这种行为有什么问题？

https://scastie.scala-lang.org/GiLoerYgT0OtxKyechezvA