scala:创建对象时循环引用？

Question

我不小心遇到了这种情况(简化了示例以隔离问题):

abstract class Element(val other: Element)

case object First extends Element(Second)
case object Second extends Element(First)

object Main {
  def main(arguments: Array[String]) {
    val e1 = First
    val e2 = Second
    println("e1: "+e1+"   e1.other: "+e1.other)
    println("e2: "+e2+"   e2.other: "+e2.other)
  }
}

有人想猜输出吗？ :-)

e1: First   e1.other: Second
e2: Second   e2.other: null

输出很有意义。显然，在创建第二个对象时，第一个对象尚不存在，因此分配了 null。问题是...错了!我花了几个小时才找到它。编译器是否应该对此有所告知？
有趣的是，当我尝试将其作为Scala脚本运行(相同的代码，减去 object Main和 def main行，并关闭 })时，我得到了一个无限序列(不是真的无限-在某些时候列表停止了，我想这是由于对异常跟踪深度的某种限制，或类似的异常):

vilius@blackone:~$ scala 1.scala
...
at Main$$anon$1.Main$$anon$$Second(1.scala:4)
at Main$$anon$1$First$.<init>(1.scala:3)
at Main$$anon$1.Main$$anon$$First(1.scala:3)
at Main$$anon$1$Second$.<init>(1.scala:4)
at Main$$anon$1.Main$$anon$$Second(1.scala:4)
at Main$$anon$1$First$.<init>(1.scala:3)
...

我希望在运行时至少获得一些有益的信息...

好的。我说完了。现在我想我应该问点事。 :)
因此，您能为案例对象相互指向推荐任何不错的设计吗？顺便说一句，在我的实际情况下，有多个对象以循环方式指向下一个和上一个实例(最后一个指向第一个，反之亦然)。

使用Scala 2.8.1-final

编辑:
我找到了解决我主要问题的方法:

abstract class Element {
  val other: Element
}
case object First extends Element {
  val other = Second
}
case object Second extends Element {
  val other = First
}

这似乎在编译版本中有效(但不能作为Scala脚本!)。任何人都可以对这里发生的事情有所了解吗？

编辑2:这可以作为脚本使用(同一件事，只是使用 def):

abstract class Element { def other: Element }
case object First extends Element { def other = Second }
case object Second extends Element { def other = First }

Answer 1

通常的方式是这样的(更改嵌套后，您可以将其粘贴到REPL中):

object Main{
  abstract class Element(other0: => Element) {
    lazy val other = other0
  }

  case object First extends Element(Second)
  case object Second extends Element(First)

  def main(arguments: Array[String]) {
    val e1 = First
    val e2 = Second
    println("e1: "+e1+"   e1.other: "+e1.other)
    println("e2: "+e2+"   e2.other: "+e2.other)
  }
}

也就是说，采用一个by-name参数并将其粘贴到一个懒惰的val中，以备将来引用。

编辑:找到的修复程序有效，因为对象本身是惰性的，因为您可以引用它们，但是只有在使用它们之后才能创建它们。因此，一个对象可以将自己指向另一个对象，而无需已经初始化了另一个对象。