Which Elisp types are mutable?

Which Elisp types are mutable?

[Marcin Borkowski]

Well, the subject says it all.  I could find an explicit, comprehensive
list of mutable (or immutable) types in the Elisp manual.  Is it there
somewhere?

TIA,

-- 
Marcin Borkowski
http://mbork.pl

Re: Which Elisp types are mutable?

[Philipp]

> Am 03.06.2021 um 06:03 schrieb Marcin Borkowski <mbork@mbork.pl>:
> 
> Well, the subject says it all.  I could find an explicit, comprehensive
> list of mutable (or immutable) types in the Elisp manual.  Is it there
> somewhere?

Mutability is a property of objects, not types.
Some objects (numbers) are always immutable, others (markers, buffers, ...) are always mutable.  But objects of most "interesting" types (strings, lists, vectors, symbols) can be either mutable or immutable.
Some time ago, I filed https://debbugs.gnu.org/cgi/bugreport.cgi?bug=43557 to document which objects are mutable, but unfortunately it's not yet fixed.

Re: Which Elisp types are mutable?

[Marcin Borkowski]

On 2021-06-03, at 14:11, Philipp <p.stephani2@gmail.com> wrote:

>> Am 03.06.2021 um 06:03 schrieb Marcin Borkowski <mbork@mbork.pl>:
>> 
>> Well, the subject says it all.  I could find an explicit, comprehensive
>> list of mutable (or immutable) types in the Elisp manual.  Is it there
>> somewhere?
>
> Mutability is a property of objects, not types.
> Some objects (numbers) are always immutable, others (markers, buffers, ...) are always mutable.  But objects of most "interesting" types (strings, lists, vectors, symbols) can be either mutable or immutable.
> Some time ago, I filed https://debbugs.gnu.org/cgi/bugreport.cgi?bug=43557 to document which objects are mutable, but unfortunately it's not yet fixed.

Thanks.  However, I still don't understand.  How can a list be
immutable?  What about a string?  I thought these are _always_ mutable
(although in some cases you must not mutate them, because if you do, bad
things could happen - see e.g. my blog post here:
http://mbork.pl/2016-05-23_Literal_values_and_destructive_functions).

Also, I thought symbols are immutable.  Can you provide an example
showing that they aren't?

TIA,

-- 
Marcin Borkowski
http://mbork.pl

Re: Which Elisp types are mutable?

[Philipp]

> Am 05.06.2021 um 13:22 schrieb Marcin Borkowski <mbork@mbork.pl>:
> 
> 
> On 2021-06-03, at 14:11, Philipp <p.stephani2@gmail.com> wrote:
> 
>>> Am 03.06.2021 um 06:03 schrieb Marcin Borkowski <mbork@mbork.pl>:
>>> 
>>> Well, the subject says it all.  I could find an explicit, comprehensive
>>> list of mutable (or immutable) types in the Elisp manual.  Is it there
>>> somewhere?
>> 
>> Mutability is a property of objects, not types.
>> Some objects (numbers) are always immutable, others (markers, buffers, ...) are always mutable.  But objects of most "interesting" types (strings, lists, vectors, symbols) can be either mutable or immutable.
>> Some time ago, I filed https://debbugs.gnu.org/cgi/bugreport.cgi?bug=43557 to document which objects are mutable, but unfortunately it's not yet fixed.
> 
> Thanks.  However, I still don't understand.  How can a list be
> immutable?  What about a string?  I thought these are _always_ mutable
> (although in some cases you must not mutate them, because if you do, bad
> things could happen

"You must not mutate them" is the definition of immutable.

> Also, I thought symbols are immutable.  Can you provide an example
> showing that they aren't?

Symbols are probably a weird case terminology-wise.  Here I define "mutable symbol" as symbol whose value and function slots can be changed (true for most symbols except keywords).  However, arguably other definitions are possible, depending on whether you see their values and function slots as "part of a symbol" or as something they refer to.  (The manual doesn't specify this.)

Re: Which Elisp types are mutable?

[Stefan Monnier via Users list for the GNU Emacs text editor]

> "You must not mutate them" is the definition of immutable.

Not necessarily: where I come from "immutable" means that the object
cannot and will not be mutated.


        Stefan

Re: Which Elisp types are mutable?

[Marcin Borkowski]

On 2021-06-05, at 14:58, Philipp <p.stephani2@gmail.com> wrote:

>> Am 05.06.2021 um 13:22 schrieb Marcin Borkowski <mbork@mbork.pl>:
>> 
>> 
>> On 2021-06-03, at 14:11, Philipp <p.stephani2@gmail.com> wrote:
>> 
>>>> Am 03.06.2021 um 06:03 schrieb Marcin Borkowski <mbork@mbork.pl>:
>>>> 
>>>> Well, the subject says it all.  I could find an explicit, comprehensive
>>>> list of mutable (or immutable) types in the Elisp manual.  Is it there
>>>> somewhere?
>>> 
>>> Mutability is a property of objects, not types.
>>> Some objects (numbers) are always immutable, others (markers, buffers, ...) are always mutable.  But objects of most "interesting" types (strings, lists, vectors, symbols) can be either mutable or immutable.
>>> Some time ago, I filed https://debbugs.gnu.org/cgi/bugreport.cgi?bug=43557 to document which objects are mutable, but unfortunately it's not yet fixed.
>> 
>> Thanks.  However, I still don't understand.  How can a list be
>> immutable?  What about a string?  I thought these are _always_ mutable
>> (although in some cases you must not mutate them, because if you do, bad
>> things could happen
>
> "You must not mutate them" is the definition of immutable.

Well, in my book, "you can't mutate them" is.  You always /can/ mutate
a string, but of you do it in certain circumstances, you're asking for
trouble.

>> Also, I thought symbols are immutable.  Can you provide an example
>> showing that they aren't?
>
> Symbols are probably a weird case terminology-wise.  Here I define "mutable symbol" as symbol whose value and function slots can be changed (true for most symbols except keywords).  However, arguably other definitions are possible, depending on whether you see their values and function slots as "part of a symbol" or as something they refer to.  (The manual doesn't specify this.)

Ah, I see.  For me, a symbol is one thing, and what is in its
function/value/properties cells is another.

Best,

-- 
Marcin Borkowski
http://mbork.pl

RE: [External] : Re: Which Elisp types are mutable?

[Drew Adams]

> > Symbols are probably a weird case terminology-wise.  Here I define "mutable
> symbol" as symbol whose value and function slots can be changed (true for
> most symbols except keywords).  However, arguably other definitions are
> possible, depending on whether you see their values and function slots as
> "part of a symbol" or as something they refer to.  (The manual doesn't
> specify this.)
> 
> Ah, I see.  For me, a symbol is one thing, and what is in its
> function/value/properties cells is another.

Do you say the same about a cons cell?  Certainly
the container is one thing and what it contains
is another, in one sense.  That's true of any kind
of container, from a file to a defstruct.

Mutability of list structure is all about changing
the contents (car, cdr) of cons cells.  It has no
other meaning.

Lisp symbols are a kind of object.  They have
attributes, including name, value (as a variable),
function definition, and an unlimited slew of
other attributes: their `symbol-properties'.

Re: [External] : Re: Which Elisp types are mutable?

[Dmitry Gutov]

On 05.06.2021 23:17, Drew Adams wrote:
> Lisp symbols are a kind of object.  They have
> attributes, including name, value (as a variable),
> function definition, and an unlimited slew of
> other attributes: their `symbol-properties'.

A symbol does not contain its properties. They're stored in some alist 
externally.

RE: [External] : Re: Which Elisp types are mutable?

[Drew Adams]

> > Lisp symbols are a kind of object.  They have
> > attributes, including name, value (as a variable),
> > function definition, and an unlimited slew of
> > other attributes: their `symbol-properties'.
> 
> A symbol does not contain its properties. They're
> stored in some alist externally.

You're missing the point, it seems.  The distinction
is conceptual, not implementation.  Contain / have /
point to ... distinctions don't matter here.  And
their possible implementations matter even less.

By your criterion a cons cell doesn't contain its
cdr either - or its car.  A symbol is a thing that
has properties / attributes, whatever you want to
call them.  How it has them / where they're stored
is a completely different matter (and irrelevant here).

"Parts" of both a cons and a symbol are changeable.
They're both mutable, and that's the case using just
Lisp.  ("Parts", not "the parts".  Not all parts of
a symbol are changeable - e.g., the name isn't.)

Re: Which Elisp types are mutable?

[Philipp]

> Am 05.06.2021 um 16:25 schrieb Stefan Monnier via Users list for the GNU Emacs text editor <help-gnu-emacs@gnu.org>:
> 
>> "You must not mutate them" is the definition of immutable.
> 
> Not necessarily: where I come from "immutable" means that the object
> cannot and will not be mutated.
> 

Then there are no immutable objects, because all objects are stored in mutable memory.  It's just that mutating some of them is a bit harder than others.  So this definition of "immutable" isn't very useful.

Re: Which Elisp types are mutable?

[Philipp]

> Am 05.06.2021 um 21:19 schrieb Marcin Borkowski <mbork@mbork.pl>:
> 
> 
> On 2021-06-05, at 14:58, Philipp <p.stephani2@gmail.com> wrote:
> 
>>> Am 05.06.2021 um 13:22 schrieb Marcin Borkowski <mbork@mbork.pl>:
>>> 
>>> 
>>> On 2021-06-03, at 14:11, Philipp <p.stephani2@gmail.com> wrote:
>>> 
>>>>> Am 03.06.2021 um 06:03 schrieb Marcin Borkowski <mbork@mbork.pl>:
>>>>> 
>>>>> Well, the subject says it all.  I could find an explicit, comprehensive
>>>>> list of mutable (or immutable) types in the Elisp manual.  Is it there
>>>>> somewhere?
>>>> 
>>>> Mutability is a property of objects, not types.
>>>> Some objects (numbers) are always immutable, others (markers, buffers, ...) are always mutable.  But objects of most "interesting" types (strings, lists, vectors, symbols) can be either mutable or immutable.
>>>> Some time ago, I filed https://debbugs.gnu.org/cgi/bugreport.cgi?bug=43557 to document which objects are mutable, but unfortunately it's not yet fixed.
>>> 
>>> Thanks.  However, I still don't understand.  How can a list be
>>> immutable?  What about a string?  I thought these are _always_ mutable
>>> (although in some cases you must not mutate them, because if you do, bad
>>> things could happen
>> 
>> "You must not mutate them" is the definition of immutable.
> 
> Well, in my book, "you can't mutate them" is.  You always /can/ mutate
> a string, but of you do it in certain circumstances, you're asking for
> trouble.

You can mutate all objects, because all of them are stored in mutable memory.
For a reference manual, "you're asking for trouble" isn't a terribly useful statement.

Re: Which Elisp types are mutable?

[Eli Zaretskii]

> From: Philipp <p.stephani2@gmail.com>
> Date: Mon, 5 Jul 2021 20:41:58 +0200
> Cc: Help Gnu Emacs mailing list <help-gnu-emacs@gnu.org>
> 
> > Well, in my book, "you can't mutate them" is.  You always /can/ mutate
> > a string, but of you do it in certain circumstances, you're asking for
> > trouble.
> 
> You can mutate all objects, because all of them are stored in mutable memory.

Not if you put it in read-only memory: you'd get a segfault with any
modern OS.

> For a reference manual, "you're asking for trouble" isn't a terribly useful statement.

And "you must not mutate them" is?  At least "you're asking for
trouble" explains why not, especially if it actually describes some of
the trouble.

Re: Which Elisp types are mutable?

[tomas]

[-- Attachment #1: Type: text/plain, Size: 1267 bytes --]

On Mon, Jul 05, 2021 at 09:48:51PM +0300, Eli Zaretskii wrote:
> > From: Philipp <p.stephani2@gmail.com>
> > Date: Mon, 5 Jul 2021 20:41:58 +0200
> > Cc: Help Gnu Emacs mailing list <help-gnu-emacs@gnu.org>

[...]

> > You can mutate all objects, because all of them are stored in mutable memory.
> 
> Not if you put it in read-only memory: you'd get a segfault with any
> modern OS.
> 
> > For a reference manual, "you're asking for trouble" isn't a terribly useful statement.
> 
> And "you must not mutate them" is?  At least "you're asking for
> trouble" explains why not, especially if it actually describes some of
> the trouble.

I think putting things into absolute terms is what creates trouble here.
Mutable makes sense wit respect to a language model. In Python, for
example, strings are immutable because the language model doesn't provide
mutating operations. If you write a C library to poke holes in a Python
string, you are extending the language model and thus moving the
goalposts. Your game, have fun :-)

In Emacs Lisp, typical immutable objects are symbols, keywords, numbers
(although bignums technically could be made mutable, I don't think it'd
make much sense :)

Perhaps there are some I missed.

Cheers
 - t

[-- Attachment #2: Digital signature --]
[-- Type: application/pgp-signature, Size: 198 bytes --]

RE: [External] : Re: Which Elisp types are mutable?

[Drew Adams]

> In Emacs Lisp, typical immutable objects are symbols, keywords, numbers

We've been around this block a few times already,
and I don't really want to stir the pot here.

But I'll mention that a Lisp symbol is a kind of
mutable "object".  It has various properties, some
of which are predefined (whether or not they have
non-nil values) and any number of which others can
be created.  Predefined properties include the
symbol name, value as a variable, and value as a
function.

All except the symbol name can be changed.  Is a
symbol something immutable?  Not IMO, but the
answer depends on what one means by "immutable".

https://www.gnu.org/software/emacs/manual/html_node/elisp/Symbol-Components.html

Re: [External] : Re: Which Elisp types are mutable?

[tomas]

[-- Attachment #1: Type: text/plain, Size: 699 bytes --]

On Mon, Jul 05, 2021 at 07:26:23PM +0000, Drew Adams wrote:
> > In Emacs Lisp, typical immutable objects are symbols, keywords, numbers
> 
> We've been around this block a few times already,
> and I don't really want to stir the pot here.
> 
> But I'll mention that a Lisp symbol is a kind of
> mutable "object".  It has various properties [...]

Oh, Elisp doesn't differentiate  between the symbol proper
and its bindings?

> All except the symbol name can be changed.  Is a
> symbol something immutable?  Not IMO, but the
> answer depends on what one means by "immutable".
> 
> https://www.gnu.org/software/emacs/manual/html_node/elisp/Symbol-Components.html

Thanks :)

-- t

[-- Attachment #2: Digital signature --]
[-- Type: application/pgp-signature, Size: 198 bytes --]

RE: [External] : Re: Which Elisp types are mutable?

[Drew Adams]

> > But I'll mention that a Lisp symbol is a kind of
> > mutable "object".  It has various properties [...]
> 
> Oh, Elisp doesn't differentiate  between the symbol proper
> and its bindings?

Sure, it does.  Though I may not understand what you
mean by its bindings.

The symbol is an object - a complex/compound thing.
It has various properties.  One of the properties is
its value as a variable, which is accessible using
function `symbol-value'.  As a variable, that's the
symbol's variable (global) "binding".

Re: [External] : Re: Which Elisp types are mutable?

[tomas]

[-- Attachment #1: Type: text/plain, Size: 848 bytes --]

On Mon, Jul 05, 2021 at 08:03:14PM +0000, Drew Adams wrote:
> > > But I'll mention that a Lisp symbol is a kind of
> > > mutable "object".  It has various properties [...]
> > 
> > Oh, Elisp doesn't differentiate  between the symbol proper
> > and its bindings?
> 
> Sure, it does.  Though I may not understand what you
> mean by its bindings.
> 
> The symbol is an object - a complex/compound thing.
> It has various properties.  One of the properties is
> its value as a variable, which is accessible using
> function `symbol-value'.  As a variable, that's the
> symbol's variable (global) "binding".

Hm. If you change a variable's value... does that count
as "mutating the symbol"? If you change the binding (e.g.
by entering another scope or by leaving it)?

Yes, there are those other pesky properties...

Cheers
 - t

[-- Attachment #2: Digital signature --]
[-- Type: application/pgp-signature, Size: 198 bytes --]

Re: Which Elisp types are mutable?

[Stefan Monnier]

Philipp [2021-07-05 20:40:01] wrote:
>> Am 05.06.2021 um 16:25 schrieb Stefan Monnier via Users list for the GNU
>> Emacs text editor <help-gnu-emacs@gnu.org>:
>>> "You must not mutate them" is the definition of immutable.
>> Not necessarily: where I come from "immutable" means that the object
>> cannot and will not be mutated.
> Then there are no immutable objects, because all objects are stored in
> mutable memory.

You're confusing a language and its implementation.

E.g. ELisp bytecode objects are immutable vectors.  Technically there is
some potential way to mutate them because they're stored in the normal
mutable memory, but efforts were made so that ELisp code cannot
mutate them.

For the same reason, ELisp code cannot "transmute" a marker into an
overlay, even though nothing stops you from doing it at the C level.

> So this definition of "immutable" isn't very useful.

I think most language designers would beg to differ.


        Stefan

RE: [External] : Re: Which Elisp types are mutable?

[Drew Adams]

> Hm. If you change a variable's value... does that count
> as "mutating the symbol"? If you change the binding (e.g.
> by entering another scope or by leaving it)?

(Changing a symbol's binding, with `let' etc.
is more complicated.  I mentioned global value.)

If you look at a Lisp symbol as being an object
with properties, then yes; changing its variable
value changes the object - its mutable state.

There's nothing very special involved here.  It's
just that people unused to Lisp won't necessarily
think that a symbol is a complex thing, and that
it "owns" its value as a variable (and its value
as a function, which for a Lisp-2 is separate).

The symbol is not its name.  In many languages
you have only to think about a name and its
binding to a value.  At a lower level you think
of a memory location (address) and the value at
that address.

In Lisp a source-code name can refer to a symbol
object.  That object itself has other things /
properties, besides a value as a variable.

Re: Which Elisp types are mutable?

[Emanuel Berg via Users list for the GNU Emacs text editor]

Stefan Monnier wrote:

>> So this definition of "immutable" isn't very useful.
>
> I think most language designers would beg to differ.

What would you say is the "problem" with Elisp?

And is this at the implementation or language level?

-- 
underground experts united
https://dataswamp.org/~incal

Re: Which Elisp types are mutable?

[Stefan Monnier via Users list for the GNU Emacs text editor]

Emanuel Berg via Users list for the GNU Emacs text editor [2021-07-05 22:44:11] wrote:
> Stefan Monnier wrote:
>>> So this definition of "immutable" isn't very useful.
>> I think most language designers would beg to differ.
> What would you say is the "problem" with Elisp?

It's too sexy for its shirt,


        Stefan

Re: [External] : Re: Which Elisp types are mutable?

[Emanuel Berg via Users list for the GNU Emacs text editor]

Drew Adams wrote:

>> Hm. If you change a variable's value... does that count as
>> "mutating the symbol"? If you change the binding (e.g.
>> by entering another scope or by leaving it)?
>
> (Changing a symbol's binding, with `let' etc. is more
> complicated. I mentioned global value.)
>
> If you look at a Lisp symbol as being an object with
> properties, then yes; changing its variable value changes
> the object - its mutable state.

You can change the symbol as a practically employed instance
but not as a concept...

-- 
underground experts united
https://dataswamp.org/~incal

Re: Which Elisp types are mutable?

[Emanuel Berg via Users list for the GNU Emacs text editor]

Stefan Monnier via Users list for the GNU Emacs text editor wrote:

>> What would you say is the "problem" with Elisp?
>
> It's too sexy for its shirt,

Haha, maybe...

-- 
underground experts united
https://dataswamp.org/~incal