Dom λ Blog - Latest Comments

Re: Lesson learned: never modify literals, quote lists only for constant data

Dom De Felice — Wed, 09 Feb 2011 00:52:11 -0000

Yes.. usually I use eq just for symbols comparison. To be sure that two lists are the same (aka same elements, even if different instances) better to use equal

Re: Lesson learned: never modify literals, quote lists only for constant data

Dom De Felice — Wed, 09 Feb 2011 00:47:09 -0000

Yes, modifying destructively a literal object has always undefined consequences. It is defined by the language specs themselves. Every lisp compiler could have a different behaviour.
For a literal object to be modified as a data structure it is always better to copy it as it was a "shape" with copy-list or copy-tree and then work on it :-)

Re: Lesson learned: never modify literals, quote lists only for constant data

Aloys Lisp — Tue, 08 Feb 2011 15:46:31 -0000

Another important problem with that stuff is the eq problem...

Well truing to imagine a compiled implementation of our quote :

static CONS quote1 = list(symbol("a"), symbol("b"), symbol("c"));
...
return SETQ( symbol("a"), quote1);

in the case of (setq a '(a b c))

We could change for changing the initialisation :

return SETQ( symbol("a"), list(symbol("a"), symbol("b"), symbol("c")));

but as pointer out by λ, list is not the same as quote... returned value is eq in the first case, not in the second as it's another instance of a cons if function is called more than once... And I know symbol("a") has no meaning except render back the original lisp sentence... ;)

Re: Lesson learned: never modify literals, quote lists only for constant data

Aloys Lisp — Tue, 08 Feb 2011 15:13:00 -0000

Just one link, saying the same thing : http://www.lispforum.com/vi...

Re: Lesson learned: never modify literals, quote lists only for constant data

Aloys Lisp — Tue, 08 Feb 2011 08:02:41 -0000

In fact as you point out, the quoted thing is in your code and if you modify it you modify your code.

The result is impredictable means that it depends if the litteral stuff is put in a protected place.

In c you put :

char *text = "blah blah";

You perfectly have the right to write into your string... :D. But if you launch the program again, constant string is initialized back. If you rerun (w/o loading) your program in lisp and you can change your litterals, it will be in the last modification state...

If your code is compiled... interesting question. As quote is a special operator it will will be 'specialy' processed... good thing to think about...

In fact you cannot mark cons as litteral :
(setq a '(a b c))
(setq b (cdr a))
(rplaca b 'r)

mhhhh ? taking the pointers, that's always code that's changed, juste the second element of the list...

Funny, I didn't pointed it out.

Re: Lesson learned: never modify literals, quote lists only for constant data

Dom De Felice — Sun, 06 Feb 2011 06:46:45 -0000

Corrected. Thanks for reporting. :-)

Re: Lesson learned: never modify literals, quote lists only for constant data

Foo — Sun, 06 Feb 2011 06:37:19 -0000

(quote foo bar baz) is wrong. QUOTE takes only one form, not three.