DELETE разрушительно, но не всегда?

«Разрушительный» не означает «действующий на месте». Это означает, что структура обрабатываемого значения может быть изменена произвольным и часто неопределенным образом. В некоторых случаях реализации и случаи могут иметь эффект, как если бы он был «на месте». Однако на это, как правило, нельзя полагаться.

Если вы используете деструктивный оператор, вы сообщаете компилятору, что вас не интересует предыдущее значение переменной после завершения операции. Вы должны предположить, что это значение впоследствии искажено до неузнаваемости, и больше не использовать его. Вместо этого следует использовать возвращаемое значение операции.

(let ((a (list 1 2 3)))
  (let ((b (delete 2 a)))
    (frob b))
  a)

=> You were eaten by a grue.

Если вы не уверены в безопасности деструктивных операций, используйте их недеструктивные аналоги (в данном случае remove).

(let ((a (list 1 2 3)))
  (let ((b (remove 2 a)))
    (frob b))
  a)

=> (1 2 3)

Если вы действительно хотите изменить содержимое переменной, установите для них возвращаемое значение операции:

(let ((a (list 1 2 3)))
  (setf a (delete 2 a))
  a)

=> (1 3)

Имейте в виду, что DELETE должен работать со списком, а не с переменной. DELETE передается список (указатель на первый минус), а не переменная.

Поскольку delete не имеет доступа к переменной *test*, он не может ее изменить. «Это» здесь означает его привязки. *test* будет указывать на ту же ячейку cons, что и раньше. Единственное, что можно изменить, — это содержимое cons-ячейки или содержимого других cons-ячеек, на которые указывает первая cons-ячейка.

Одно можно сказать наверняка: независимо от того, что делает DELETE, *test* всегда будет указывать на одну и ту же cons-ячейку.

Что из этого следует? Если вы хотите, чтобы *test* указывало на результат операции удаления, вы должны явно указать это:

(setq *test* (delete 1 *test*))

DELETE работает, изменяя CDR предыдущей cons-ячейки списка так, чтобы она указывала на ячейку, расположенную после удаляемых элементов. Но если вы удаляете первый элемент списка, предыдущая ячейка cons для изменения отсутствует.

Хотя эта реализация на самом деле не указана в стандарте языка, так работает практически каждая реализация.

Поскольку при удалении первого элемента списка нет предыдущей ячейки cons, которую нужно изменить, он просто возвращает вторую ячейку cons. Таким образом, несмотря на то, что DELETE разрешено изменять список, вы все равно должны присвоить результат своей переменной, чтобы обработать этот случай. Кроме того, следует подчеркнуть, что деструктивное поведение только разрешено по стандарту, а не требуется. Таким образом, существует отдаленная вероятность того, что какая-то реализация вообще не реализует его деструктивно, и вы также должны допустить это.

И даже если DELETE сработало, изменив CAR вместо CDR, все же есть случай, когда он не может сделать деструктивно: удаление всех элементов списка, например.

(setq *test* (list 'a 'a))
(delete 'a *test*)

Это приводит к пустому списку, т.е. NIL. Но *test* по-прежнему содержит ячейку cons, которая была головой исходного списка, и DELETE никак не может это изменить. Итак, вы должны сделать:

(setq *test* (delete 'a *test*))

чтобы установить *test* на NIL.