RE: [External] : Re: [Elisp][Question] How to modify a list by index while preserving value outside of scope?

[Drew Adams <drew.adams@oracle.com>]

> In short: a "list" is in fact a "pointer", i.e., an "adress in memory"
> where the first cons of that list lives.

A NON-empty list is a cons, that is, a structure
with two pointers: to the list head and its tail.

An EMPTY list is NOT a cons; it's the symbol `nil',
which can also be written and read as `()'.

A true/proper list is one whose last tail is `nil'.

A dotted list is one whose last tail is not `nil'.
(It can be any value other than `nil'.)

Every non-empty list can be written using dot
notation: e.g., (a . (b . c)), whether or not c is
nil.  That's usually abbreviated as (a b . c), or
if c is nil, as (a b c).

> If you want to work on a "local" version of a list, you can copy that
> list yourself.  `append' is one way to do it;

`C-h f append' tells you:

 The last argument is NOT copied, just used as the
 tail of the new list.

This is important.  The tail of the result is last
argument.  So you can't copy a list by passing it
alone to `append':

 (let ((xs  (list 1 2 3))) (eq xs (append xs)))
 ; ==> t

But you can copy a list by appending nil to it:

 (let ((xs  (list 1 2 3))) (eq xs (append xs ())))
 ; ==> nil

> `cl-copy-list' is another.

Or `copy-sequence' or its alias `cl-copy-seq'.
___

You can think in terms of pointers, if that helps.
But Lisp doesn't have pointers in the usual sense
of the term.  You can't pass explicit pointers as
arguments, etc.  The "pointers" are used implicitly.

What's true is that when you pass a value, a _copy_
of the value is not created and passed.  So yes, a
pointer to the value is passed, but not explicitly
- not a pointer as such.  Such pointers are not
values/objects in the language.

In Lisp we think of the thing itself (which is a
Lisp value/object) as what is passed - not a copy,
and not a pointer to it.  The thing _is_ its
pointer (which of course is exactly what you said
in your first sentence).