Question

假设一个外部类具有两个内部类的内部组合：

class Outer(val times: Int) {

  class Inner(val count: Int)
  object Inner {
    def apply(i: Int) = new Inner(i)
  }

  class InnerWrap(val i: Inner)
  object InnerWrap {
    def apply(i: Inner) = new InnerWrap(i)
  }
  def method(i: Inner) = i.count * times
}
object Outer {
  def apply(times: Int) = new Outer(times)
}

class PathDependentExpl {
  val o = new Outer(3)
  val i = o.Inner(2)
  val p = new Outer(5)
  val j = p.Inner(3)
  println(o.method(i))
  println(p.method(j))
}

一切都很好，花花公子。我们甚至可以通过编译器保护来防止从一个Outer到另一个Outer的方法通过路径依赖类型提供内容。

但语法有点烦人。我希望能够写出像

这样的东西

implicit val p = new Outer(5)
val k = Inner(3) // same as p.Inner(3)
val l = InnerWrap(Inner(3))

...省略隐式有效的块的外部实例。所以我急于使用Outer对象添加委托方法作为隐式参数。

object Outer {
  def apply(times: Int) = new Outer(times)
  def Inner(c: Int)(implicit o: Outer) = o.Inner(c)
  def InnerWrap(i: o.Inner)(implicit o: Outer) = o.InnerWrap(i)
}

最后一个InnerWrap定义产生：“非法依赖方法类型：参数出现在同一部分或更早的参数中的另一个参数的类型中”，这实际上是有意义的。我试过def InnerWrap[O <: Outer#Inner](i: O)(implicit o: Outer) = o.InnerWrap(i)和其他变种无济于事。

问题是，我怎样才能使用更清晰的语法？如何使对象InnerWrap中的Outer声明能够接受o.Inner或等同物？

Answer 1

正如我在上面的评论中所指出的，可以从p导入您需要的对象（或方法），这可能会为您提供您正在寻找的清晰语法：< / p>

scala> val p = new Outer(5)
p: Outer = Outer@4fe2fe5d

scala> import p._
import p._

scala> val k = Inner(3)
k: p.Inner = Outer$Inner@b90ffa7

scala> val l = InnerWrap(Inner(3))
l: p.InnerWrap = Outer$InnerWrap@3bd6bff7

Scala中具有隐式封闭实例的路径相关工厂

1 个答案: