scala – 在保留不变性的同时分配值时如何引用变量？

我认为你最好的选择是做这样的事情

object Rooms {
  case class Room(title: String) {
    def exits = exitMap(this)
  }
  val first:Room = Room("first")
  val second:Room = Room("second")

  private val exitMap = Map(first -> Map("S" -> second),second -> Map("N" -> first))
}

scala> Rooms.first.title
res: String = first

scala> Rooms.first.exits
res: scala.collection.immutable.Map[java.lang.String,Rooms.Room] = Map(S -> Room(second))

这是完全不变的，你避免讨厌的递归。

递归

构造递归结构需要更多的关心，因为Scala默认情况下不会懒惰。具体来说，不可能创建一个lazy或call-by-name case类参数。因此，我们必须为此采取专门的数据结构。

一个选择可能是使用Streams：

case class LazyRoom(title: String,exits: Stream[LazyRoom])

object LazyRooms {
  lazy val nullRoom: LazyRoom = LazyRoom("nullRoom",Stream.empty)
  lazy val first: LazyRoom = LazyRoom("first",nullRoom #:: second #:: Stream.empty)
  lazy val second: LazyRoom = LazyRoom("second",nullRoom #:: first #:: Stream.empty)
}

scala> LazyRooms.first.exits(1).title
res> String: second

为了节省开支，我在每个Stream之前设置一个虚拟的房间，以避免过早访问。 (A Stream只在尾部懒惰，但不在其头部。)专用的数据结构可能能够避免这种情况。

清理版本

我们可以通过调用名称帮助函数做更好的做肮脏的工作：

case class LazyRoom(title: String,exitMap: Stream[Map[String,LazyRoom]]) {
  def exits = exitMap(1) // skip the Streams empty head
}

def _exitMap(mappedItems: => Map[String,LazyRoom]) = {
  Map[String,LazyRoom]() #::
  mappedItems #::
  Stream.empty
}

object LazyRooms {
  lazy val first: LazyRoom = LazyRoom("first",_exitMap(Map("South" -> second)))
  lazy val second: LazyRoom = LazyRoom("second",_exitMap(Map("North" -> first)))
}

scala> LazyRooms.first.exits
res: Map[String,LazyRoom] = Map(South -> LazyRoom(second,Stream(Map(),?)))