DELETE является разрушительным - но не всегда?

Question

Я немного запутался в разрушительной DELETE функции Common Lisp. Это, кажется, работает, как и следовало ожидать, ибо если элемент является первым элементом в списке, за исключением:

CL-USER> (defvar *test* (list 1 2 3)) 
*TEST* 
CL-USER> (delete 1 *test*) 
(2 3) 
CL-USER> *test* 
(1 2 3) 
CL-USER> (delete 2 *test*) 
(1 3) 
CL-USER> *test* 
(1 3) 

Answer 1

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

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

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

Answer 2

DELETE работа путем изменения CDR в предыдущих минусах ячейки списка, чтобы указать на один мимо элемент (s) удаляется. Но если вы удаляете первый элемент списка, для изменения нет предыдущей ячейки 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.

Answer 3

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

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

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

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

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