Путаница с изменением на месте в R

Оператор [[<- привязывает объект к второму имени. Согласно определению языка ваш код идентичен этому:

`*tmp*` <- x #binding to a second name
x <- "[[<-"(`*tmp*`, 1, value = x)
rm(`*tmp*`)

Мы можем показать, что он действительно создает и удаляет это временное имя:

`*tmp*` <- 1
`*tmp*`
#[1] 1
x <- list()
x[[1]] <- x
`*tmp*`
#Error: object '*tmp*' not found

Я несколько не согласен с «правильным» ответом, данным «Advanced R Solutions». Ответ имеет два аспекта: определенное поведение и детали реализации низкого уровня.

Основная причина, по которой ваш код не создает циклическую ссылку, заключается в том, что R имеет семантику значений, а не семантику ссылок. В R, если вы привязываете значение (посредством присваивания или путем передачи его функции), это значение копируется. И вот что здесь происходит: назначение x[[1]] <- x создает копию x, назначенную x[[1]].

И это ответ. Все остальное — детали реализации. Но давайте углубимся:

Проблема с «наивной» реализацией семантики значений заключается в том, что она очень неэффективна. Фактически, большой объем кода постоянно копирует, а копирование больших объектов по-прежнему очень неэффективно даже на современных архитектурах ЦП. Обычно мы хотим максимально избежать копирования памяти.

Таким образом, R реализует оптимизацию: вместо копирования значения, как только оно присваивается чему-то другому, R просто создает дополнительную ссылку на существующее значение и увеличивает его счетчик ссылок.

Счетчик ссылок — это буквально целое число, которое сообщает R, из скольких мест происходит ссылка на значение. При попытке изменить значение R проверяет счетчик ссылок. И если счетчик ссылок равен 1, R выполняет модификацию на месте. Но если счетчик ссылок >1, R сначала создает копию значения, а затем вместо этого изменяет эту копию. Эта оптимизация известна как копирование при записи (CoW).

Обратите внимание, что выше не говорится об «именах»: потому что не имеет значения, привязаны ли эти ссылки к именам. Важно количество ссылок на значение, а не количество имен, с которыми оно связано.

Для иллюстрации вот ситуация перед заданием:

+---+      [C]-[T]----.
| x | ---> | 1 | list |
+---+      ·----------·

x — переменная, которая ссылается на значение. Значения в R несут некоторую дополнительную информацию, включая счетчик ссылок (C) и флаг, определяющий тип (T) — это радикально упрощено, но здесь это все, что имеет значение.

Теперь, как только мы присваиваем значение другому имени, мы увеличиваем счетчик ссылок; например: y <- x вызовет такую ​​ситуацию:

+---+
| x | --.
+---+   |   [C]-[T]----.
        +-> | 2 | list |
+---+   |   ·----------·
| y | --·
+---+

Теперь счетчик ссылок равен 2, и любое изменение значения потребует копирования, например. x[[1]] = 5:

+---+      [C]-[T]----.---.
| x | ---> | 1 | list | 5 |
+---+      ·----------·---·

+---+      [C]-[T]----.
| y | ---> | 1 | list |
+---+      ·----------·

(Обратите внимание, что после копирования счетчик ссылок возвращается к 1.)

Но ситуация, о которой мы здесь говорим, более сложная. Во-первых, назначение вызывает увеличение количества ссылок, прежде чем что-либо еще будет сделано:¹

+---+      [C]-[T]----.
| x | ---> | 2 | list |
+---+      ·----------·

На этом этапе счетчик ссылок увеличивается, но ссылка еще не назначена, поскольку для того, чтобы присвоить ее чему-то (x[[1]]), сначала необходимо изменить значение. Это происходит дальше и запускает копирование, поскольку счетчик ссылок >1:

           [C]-[T]----.
           | 1 | list |
           ·----------·

+---+      [C]-[T]----.
| x | ---> | 1 | list |
+---+      ·----------·

Вновь созданная копия будет изменена и присвоена x, как указано стрелкой выше. Исходная версия значения остается неизмененной и пока не упоминается в коде R; но у интерпретатора R есть внутренняя переменная, которая содержит эту ссылку.²

Теперь происходит изменение скопированного значения. Сначала список расширяется, чтобы освободить место для нового значения:

           [C]-[T]----.
           | 1 | list |
           ·----------·

+---+      [C]-[T]----.---.
| x | ---> | 1 | list |   |
+---+      ·----------·---·

И затем, наконец, происходит фактическое присвоение, и ссылка на исходное значение x помещается во вновь созданный элемент:

           [C]-[T]----.
           | 1 | list |-\
           ·----------· |
                        v
+---+      [C]-[T]----.---.
| x | ---> | 1 | list |   |
+---+      ·----------·---·

³Кроме окружения.

¹ Это происходит глубоко внутри интерпретатора R, и это произойдет независимо от того, как присвоение реализовано в R. То есть промежуточное присваивание `*tmp*` — которое действительно происходит, как показано в ответе Роланда — не требуется для запуска этого. Где и как именно это происходит, немного сложно, потому что в зависимости от конкретной ситуации для этого может быть несколько мест. Я считаю, что в этой конкретной ситуации это происходит в applydefine , который вызывается, когда левая часть присваивания представляет собой сложное выражение (как в данном случае). И что интересно, это происходит до того, как `*tmp*` определен, а затем R отключает подсчет ссылок для `*tmp*`, так что наличие `*tmp*` фактически не влияет на то, создаем ли мы копию!

² Фактически, после создания копии ей присваивается `*tmp*`. Я пропускаю этот шаг, чтобы избежать необходимости рисовать еще три диаграммы, и это не меняет результата.