2

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

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)了其他变体无济于事。

问题是，我怎样才能使用更简洁的语法？怎样才能使InnerWrapin object的声明Outer接受o.Inners 或等价物？

4

1 回答 1

2

正如我在上面的评论中指出的那样，可以从 导入您需要的对象（或方法）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
于 2012-09-27T18:14:24.100 回答