Как я могу ссылаться на переменную при присвоении ей значения, сохраняя при этом неизменность?

Question

Я возился в свой воскресный день и пытаюсь создать своего рода "комнатную" структуру. По сути, объект Room имеет несколько выходов, каждый из которых ссылается на другие Room s. Теперь первое, что я пытаюсь создать, - это два Room, соединенные друг с другом, предпочтительно в одном операторе присваивания. Как это:

case class Room(title: String, exits: Map[Direction.Direction, Room])

val firstRoom = Room("A room", Map(North -> Room("Another room", Map(South -> firstRoom))))

Ergo: из первой комнаты есть выход North во вторую, из второй комнаты выход South обратно в первую.

Однако, как вы можете себе представить, это идет не так: значение firstRoom не определяется при его создании, поэтому попытка обратиться к нему во время его назначения не будет работать.

Я почти уверен, что это верно для большинства, если не для всех языков программирования. Мой вопрос: как мне решить это без , чтобы сделать мой Room объект изменяемым? Я могу просто создать несколько Room объектов и впоследствии добавить к ним выходы, но это делает изменяемым Room s, и в качестве личного упражнения я стараюсь избегать этого.

Answer 1

нерекурсивный

Я думаю, что ваш лучший вариант - сделать что-то подобное*

Рекурсивный

Построение рекурсивной структуры требует гораздо больше усилий, так как Scala не ленив по умолчанию.В частности, невозможно создать параметр lazy или call-by-name case class.Итак, для этого нам придется прибегнуть к специализированной структуре данных.

Одним из вариантов может быть использование Stream s:

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 ставится префикс фиктивной комнаты, чтобы избежать преждевременного доступа.(Поток только ленив в хвосте, но не в голове.) Специальная структура данных могла бы избежать этого.

Уточненная версия

Мы можемсделать лучше с помощью вспомогательной функции call-by-name, чтобы выполнить грязную работу:

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(), ?)))

Answer 2

Я полностью согласен с ответом Дебилски, но я не удержался, заменив метод exists на ленивое значение exists, предотвращая повторный поиск.

object Rooms {
  case class Room(title: String) {
    lazy val 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))
}

Answer 3

Альтернативное решение, которое, к сожалению (я думаю) не работает с кейс-классами:

class Room(val title: String, _exits : => Map[String, Room]) { lazy val exits = _exits }
val room1 : Room = new Room("A room", Map("N" -> room2))
val room2 : Room = new Room("Another room", Map("S" -> room1))

Другой вариант - использовать «ленивую» карту:

case class Room(val title : String, exits : Map[String, () => Room])
val room1 : Room = Room("A room", Map("N" -> (() => room2)))
val room2 : Room = Room("Another room", Map("S" -> (() => room1)))

Синтаксис был бы лучше, если бы вы создали свою собственную ленивую реализацию карты, расширяющую черту scala.collection.immutable.Map.