Adding Lists/Sequences

Adding Lists/Sequences

[Nordlöw]

Is there a general function, say foo, that adds lists or, even better,
sequences together?

I want this
  (foo '("a" "b") '("c" "d"))
to evaluate to
  '("a" "b" "c" "d")

Thanks in advance,
Nordlöw

Re: Adding Lists/Sequences

[Joost Kremers]

Nordlöw wrote:
> Is there a general function, say foo, that adds lists or, even better,
> sequences together?
>
> I want this
>   (foo '("a" "b") '("c" "d"))
> to evaluate to
>   '("a" "b" "c" "d")

(info "(Elisp) Building Lists")


-- 
Joost Kremers                                      joostkremers@yahoo.com
Selbst in die Unterwelt dringt durch Spalten Licht
EN:SiS(9)

Re: Adding Lists/Sequences

[Nordlöw]

On 23 Sep, 13:52, Joost Kremers <joostkrem...@yahoo.com> wrote:
> Nordlöw wrote:
> > Is there a general function, say foo, that adds lists or, even better,
> > sequences together?
>
> > I want this
> >   (foo '("a" "b") '("c" "d"))
> > to evaluate to
> >   '("a" "b" "c" "d")
>
> (info "(Elisp) Building Lists")
>
> --
> Joost Kremers                                      joostkrem...@yahoo.com
> Selbst in die Unterwelt dringt durch Spalten Licht
> EN:SiS(9)

Great!

Thanks,
Nordlöw

Re: Adding Lists/Sequences

[Tassilo Horn]

Nordlöw <per.nordlow@gmail.com> writes:

Hi!

> Is there a general function, say foo, that adds lists or, even better,
> sequences together?
>
> I want this
>   (foo '("a" "b") '("c" "d"))
> to evaluate to
>   '("a" "b" "c" "d")

(defalias 'foo 'append) ;-)

Bye,
Tassilo

Re: Adding Lists/Sequences

[Thierry Volpiatto]

Nordlöw <per.nordlow@gmail.com> writes:

> Is there a general function, say foo, that adds lists or, even better,
> sequences together?
>
> I want this
>   (foo '("a" "b") '("c" "d"))
> to evaluate to
>   '("a" "b" "c" "d")

,----
| ELISP> (nconc '("a" "b" "c") '("d" "e" "f")) 
| ("a" "b" "c" "d" "e" "f")
`----

Note: `append' is not destructive

-- 
A + Thierry Volpiatto
Location: Saint-Cyr-Sur-Mer - France

Re: Adding Lists/Sequences

[Pascal J. Bourguignon]

Thierry Volpiatto <thierry.volpiatto@gmail.com> writes:

> Nordlöw <per.nordlow@gmail.com> writes:
>
>> Is there a general function, say foo, that adds lists or, even better,
>> sequences together?
>>
>> I want this
>>   (foo '("a" "b") '("c" "d"))
>> to evaluate to
>>   '("a" "b" "c" "d")
>
> ,----
> | ELISP> (nconc '("a" "b" "c") '("d" "e" "f")) 
> | ("a" "b" "c" "d" "e" "f")
> `----

Very bad!

(defun bad-bad (tail)
   (nconc '(a b c) tail))

(bad-bad '(1 2 3)) --> (a b c 1 2 3)
(bad-bad '(4 5 6)) --> (a b c 1 2 3 4 5 6) ; !!!

NEVER use a destructive function on literal data!


> Note: `append' is not destructive

append is much better, but be careful that it shares the tail, so you
must consider the result as a literal data, unless you have consed the
tail yourself.


-- 
__Pascal_Bourguignon__

Re: Adding Lists/Sequences

[Thierry Volpiatto]

pjb@informatimago.com (Pascal J. Bourguignon) writes:

> Thierry Volpiatto <thierry.volpiatto@gmail.com> writes:
>
>> Nordlöw <per.nordlow@gmail.com> writes:
>>
>>> Is there a general function, say foo, that adds lists or, even better,
>>> sequences together?
>>>
>>> I want this
>>>   (foo '("a" "b") '("c" "d"))
>>> to evaluate to
>>>   '("a" "b" "c" "d")
>>
>> ,----
>> | ELISP> (nconc '("a" "b" "c") '("d" "e" "f")) 
>> | ("a" "b" "c" "d" "e" "f")
>> `----
>
> Very bad!
>
> (defun bad-bad (tail)
>    (nconc '(a b c) tail))
>
> (bad-bad '(1 2 3)) --> (a b c 1 2 3)
> (bad-bad '(4 5 6)) --> (a b c 1 2 3 4 5 6) ; !!!
>
> NEVER use a destructive function on literal data!

Good tip, Thank you.

>
>> Note: `append' is not destructive
>
> append is much better, but be careful that it shares the tail, so you
> must consider the result as a literal data, unless you have consed the
> tail yourself.

-- 
A + Thierry Volpiatto
Location: Saint-Cyr-Sur-Mer - France

Re: Adding Lists/Sequences

[David Kastrup]

Thierry Volpiatto <thierry.volpiatto@gmail.com> writes:

> Nordlöw <per.nordlow@gmail.com> writes:
>
>> Is there a general function, say foo, that adds lists or, even better,
>> sequences together?
>>
>> I want this
>>   (foo '("a" "b") '("c" "d"))
>> to evaluate to
>>   '("a" "b" "c" "d")
>
> ,----
> | ELISP> (nconc '("a" "b" "c") '("d" "e" "f")) 
> | ("a" "b" "c" "d" "e" "f")
> `----
>
> Note: `append' is not destructive

This is so bad that I can't believe it.

(defun ugh () (nconc '("a" "b" "c") '("d" "e" "f")))
(ugh) -> ("a" "b" "c" "d" "e" "f")
(ugh) -> ("a" "b" "c" "d" "e" "f" . #3)

The latter is a tail-cyclic list.

(ugh) -> hangs

-- 
David Kastrup, Kriemhildstr. 15, 44793 Bochum

Re: Adding Lists/Sequences

[Thierry Volpiatto]

David Kastrup <dak@gnu.org> writes:

> Thierry Volpiatto <thierry.volpiatto@gmail.com> writes:
>
>> Nordlöw <per.nordlow@gmail.com> writes:
>>
>>> Is there a general function, say foo, that adds lists or, even better,
>>> sequences together?
>>>
>>> I want this
>>>   (foo '("a" "b") '("c" "d"))
>>> to evaluate to
>>>   '("a" "b" "c" "d")
>>
>> ,----
>> | ELISP> (nconc '("a" "b" "c") '("d" "e" "f")) 
>> | ("a" "b" "c" "d" "e" "f")
>> `----
>>
>> Note: `append' is not destructive
>
> This is so bad that I can't believe it.
>
> (defun ugh () (nconc '("a" "b" "c") '("d" "e" "f")))
> (ugh) -> ("a" "b" "c" "d" "e" "f")
> (ugh) -> ("a" "b" "c" "d" "e" "f" . #3)
>
> The latter is a tail-cyclic list.
>
> (ugh) -> hangs
We speak of what is bad and very bad but didn't answer to what is good
or not, i send here a bad exemple as i constat i never used that in my
programs (nconc), idem for `nreverse'.And when i read again my commonlisp
book it say that is very delicate to use destructives functions.
So can you explain when it is good (if it is) to use these destructive
functions.

Here an example of the use of append that is safe.


,----
| ELISP> (setq A '(a b c))
| (a b c)
| 
| ELISP> (setq B '(1 2 3))
| (1 2 3)
| 
| ELISP> (defun quite-good (beg tail)
|          (append beg tail))
| quite-good
| ELISP> (quite-good A B)
| (a b c 1 2 3)
| 
| ELISP> (setq C (quite-good A B))
| (a b c 1 2 3)
| 
| ELISP> A
| (a b c)
| 
| ELISP> B
| (1 2 3)
| 
| ELISP> C
| (a b c 1 2 3)
`----

-- 
A + Thierry Volpiatto
Location: Saint-Cyr-Sur-Mer - France

Re: Adding Lists/Sequences

[Nikolaj Schumacher]

Thierry Volpiatto <thierry.volpiatto@gmail.com> wrote:

> So can you explain when it is good (if it is) to use these destructive
> functions.

Generally, speed.  Non-destructive operations often create or copy a lot
of new cons cells.  So in time critical regions of code, when you're
only handling self-created data, and are very careful, that's the
advantage in using them.


regards,
Nikolaj Schumacher

Re: Adding Lists/Sequences

[Thierry Volpiatto]

Nikolaj Schumacher <me@nschum.de> writes:

> Thierry Volpiatto <thierry.volpiatto@gmail.com> wrote:
>
>> So can you explain when it is good (if it is) to use these destructive
>> functions.
>
> Generally, speed.  Non-destructive operations often create or copy a lot
> of new cons cells.  So in time critical regions of code, when you're
> only handling self-created data, and are very careful, that's the
> advantage in using them.
>
Thats clear, thank you.
-- 
A + Thierry Volpiatto
Location: Saint-Cyr-Sur-Mer - France

RE: Adding Lists/Sequences

[Drew Adams]

>> explain when it is good (if it is) to use these destructive functions.
>
> Generally, speed.  Non-destructive operations often create 
> or copy a lot of new cons cells.

Or when you want to share Lisp structure. A special case is a circular
structure, which shares part(s) of itself with itself.

Re: Adding Lists/Sequences

[David Kastrup]

Thierry Volpiatto <thierry.volpiatto@gmail.com> writes:

> "Drew Adams" <drew.adams@oracle.com> writes:
>
>>>> explain when it is good (if it is) to use these destructive functions.
>>>
>>> Generally, speed.  Non-destructive operations often create 
>>> or copy a lot of new cons cells.
>>
>> Or when you want to share Lisp structure. A special case is a circular
>> structure, which shares part(s) of itself with itself.
>>
> Can you provide a small example ?

(let ((x (list 1 2 3))) (nconc x x))

-- 
David Kastrup

Re: Adding Lists/Sequences

[Thierry Volpiatto]

"Drew Adams" <drew.adams@oracle.com> writes:

>>> explain when it is good (if it is) to use these destructive functions.
>>
>> Generally, speed.  Non-destructive operations often create 
>> or copy a lot of new cons cells.
>
> Or when you want to share Lisp structure. A special case is a circular
> structure, which shares part(s) of itself with itself.
>
Can you provide a small example ? 
-- 
A + Thierry Volpiatto
Location: Saint-Cyr-Sur-Mer - France

RE: Adding Lists/Sequences

[Drew Adams]

> >>> explain when it is good (if it is) to use these 
> >>> destructive functions.
> >>
> >> Generally, speed.  Non-destructive operations often create 
> >> or copy a lot of new cons cells.
> >
> > Or when you want to share Lisp structure. A special case is 
> > a circular structure, which shares part(s) of itself with itself.
>
> Can you provide a small example ? 

(I meant "list structure", not "Lisp structure" BTW.)

Real examples are best for this kind of thing. Grep for any of these destructive
functions in the Emacs installation `lisp' directory and its subdirectories:
`nconc', `setcdr', `setcar', `delq', `(delete' (you'll get too many hits for
just `delete'), `nreverse', or `sort' . 

You will see in the code that such functions are used _judiciously_, never
wantonly, and you will likely be able to see why, in context. Sometimes comments
explain the need for structure modification or sharing in a particular context.
If you don't understand the existing code, however, then I'd say stay away from
using list modification in your own code. 

Also, see node `Modifying Lists' and its subnodes in the Elisp manual. They give
how-to examples and explain the use. Likewise, see node `Circular Objects'.

If you really need to modify or share list structure for some reason, you will
probably know about it. ;-) IOW, a real need will lead you to finding out more
about it. If not, it's a good idea to stay away from using it. 

And, other things being equal, it's generally a bad idea to try using
modification just to speed up your code. IOW, don't try substituting `nconc' for
`append' liberally, thinking that you are optimizing things. It is more likely
that you are breaking things. (Of course, breaking things can sometimes be a
good way to learn, but beware that debugging code that is broken because of list
modification can be confusing.)

Re: Adding Lists/Sequences

[Thierry Volpiatto]

"Drew Adams" <drew.adams@oracle.com> writes:

>> >>> explain when it is good (if it is) to use these 
>> >>> destructive functions.
>> >>
>> >> Generally, speed.  Non-destructive operations often create 
>> >> or copy a lot of new cons cells.
>> >
>> > Or when you want to share Lisp structure. A special case is 
>> > a circular structure, which shares part(s) of itself with itself.
>>
>> Can you provide a small example ? 
>
> (I meant "list structure", not "Lisp structure" BTW.)
>
> Real examples are best for this kind of thing. Grep for any of these destructive
> functions in the Emacs installation `lisp' directory and its subdirectories:
> `nconc', `setcdr', `setcar', `delq', `(delete' (you'll get too many hits for
> just `delete'), `nreverse', or `sort' . 
>
> You will see in the code that such functions are used _judiciously_, never
> wantonly, and you will likely be able to see why, in context. Sometimes comments
> explain the need for structure modification or sharing in a particular context.
> If you don't understand the existing code, however, then I'd say stay away from
> using list modification in your own code. 
>
> Also, see node `Modifying Lists' and its subnodes in the Elisp manual. They give
> how-to examples and explain the use. Likewise, see node `Circular Objects'.
>
> If you really need to modify or share list structure for some reason, you will
> probably know about it. ;-) IOW, a real need will lead you to finding out more
> about it. If not, it's a good idea to stay away from using it. 
>
> And, other things being equal, it's generally a bad idea to try using
> modification just to speed up your code. IOW, don't try substituting `nconc' for
> `append' liberally, thinking that you are optimizing things. It is more likely
> that you are breaking things. (Of course, breaking things can sometimes be a
> good way to learn, but beware that debugging code that is broken because of list
> modification can be confusing.)
>
>
Thank you a lot for this, that's very instructive.
I already "grep" a lot source code in emacs to learn more, your code too ;)
-- 
A + Thierry Volpiatto
Location: Saint-Cyr-Sur-Mer - France

Re: Adding Lists/Sequences

[Thierry Volpiatto]

David Kastrup <dak@gnu.org> writes:

> Thierry Volpiatto <thierry.volpiatto@gmail.com> writes:
>
>> "Drew Adams" <drew.adams@oracle.com> writes:
>>
>>>>> explain when it is good (if it is) to use these destructive functions.
>>>>
>>>> Generally, speed.  Non-destructive operations often create 
>>>> or copy a lot of new cons cells.
>>>
>>> Or when you want to share Lisp structure. A special case is a circular
>>> structure, which shares part(s) of itself with itself.
>>>
>> Can you provide a small example ?
>
> (let ((x (list 1 2 3))) (nconc x x))

Ok, thanks for this example.
-- 
A + Thierry Volpiatto
Location: Saint-Cyr-Sur-Mer - France

Re: Adding Lists/Sequences

[Tim X]

Thierry Volpiatto <thierry.volpiatto@gmail.com> writes:

> David Kastrup <dak@gnu.org> writes:
>
>> Thierry Volpiatto <thierry.volpiatto@gmail.com> writes:
>>
>>> Nordlöw <per.nordlow@gmail.com> writes:
>>>
>>>> Is there a general function, say foo, that adds lists or, even better,
>>>> sequences together?
>>>>
>>>> I want this
>>>>   (foo '("a" "b") '("c" "d"))
>>>> to evaluate to
>>>>   '("a" "b" "c" "d")
>>>
>>> ,----
>>> | ELISP> (nconc '("a" "b" "c") '("d" "e" "f")) 
>>> | ("a" "b" "c" "d" "e" "f")
>>> `----
>>>
>>> Note: `append' is not destructive
>>
>> This is so bad that I can't believe it.
>>
>> (defun ugh () (nconc '("a" "b" "c") '("d" "e" "f")))
>> (ugh) -> ("a" "b" "c" "d" "e" "f")
>> (ugh) -> ("a" "b" "c" "d" "e" "f" . #3)
>>
>> The latter is a tail-cyclic list.
>>
>> (ugh) -> hangs
> We speak of what is bad and very bad but didn't answer to what is good
> or not, i send here a bad exemple as i constat i never used that in my
> programs (nconc), idem for `nreverse'.And when i read again my commonlisp
> book it say that is very delicate to use destructives functions.
> So can you explain when it is good (if it is) to use these destructive
> functions.
>
> Here an example of the use of append that is safe.
>
>
> ,----
> | ELISP> (setq A '(a b c))
> | (a b c)
> | 
> | ELISP> (setq B '(1 2 3))
> | (1 2 3)
> | 
> | ELISP> (defun quite-good (beg tail)
> |          (append beg tail))
> | quite-good
> | ELISP> (quite-good A B)
> | (a b c 1 2 3)
> | 
> | ELISP> (setq C (quite-good A B))
> | (a b c 1 2 3)
> | 
> | ELISP> A
> | (a b c)
> | 
> | ELISP> B
> | (1 2 3)
> | 
> | ELISP> C
> | (a b c 1 2 3)
> `----

I think there are possibly two different issues here that need to be
considered. 

1. Modifying 'literal' lists is usually risky. Weird things can happen
because on some levels, you are modifying what is best considered a
constant. This is the difference between '(1 2 3) and (list 1 2 3). 

2. The destructive operators manipulate the structure of the list rather
than creating a new copy with its own structure. This can have two
problems. Firstly, you can create circular lists as David points out and
more generally, you can get unexpected 'side effects' if that structure is
also bound to another symbol. In general, I think yo should only use the
destructive operators on a structure which you know is not shared. For
example, you could define your function so that it makes a copy of the
list and then applies a distructive operation to the list and return the
new list rather than just applying the destructive operation to the list
that is passed in. Of course, the problem with tis is that often the
destructive functions are used for performance reasons and having to
make a copy each time may cause its own performance problems.

HTH

Tim


-- 
tcross (at) rapttech dot com dot au

Re: Adding Lists/Sequences

[David Kastrup]

Tim X <timx@nospam.dev.null> writes:

> 1. Modifying 'literal' lists is usually risky. Weird things can happen
> because on some levels, you are modifying what is best considered a
> constant.

That's all very vague and fuzzy, but there are no vague or fuzzy
semantics involved.

> This is the difference between '(1 2 3) and (list 1 2 3).

The difference is that the first form is turned into a list by the Lisp
reader, each time it is passed through the reader (in most cases, once).
In interactive use, it is perfectly equivalent to the second form.  When
put into function definitions or bound to anything, it isn't.

-- 
David Kastrup, Kriemhildstr. 15, 44793 Bochum

Re: Adding Lists/Sequences

[Pascal J. Bourguignon]

David Kastrup <dak@gnu.org> writes:

> Tim X <timx@nospam.dev.null> writes:
>
>> 1. Modifying 'literal' lists is usually risky. Weird things can happen
>> because on some levels, you are modifying what is best considered a
>> constant.
>
> That's all very vague and fuzzy, but there are no vague or fuzzy
> semantics involved.

Yes, there is vague and fuzzy semantics involved.

The vagueness and fuzzyness is not very well characterised, because
emacs lisp is not defined by a "standard", only by a (couple of)
implementation(s). 

Nonetheless, nowhere can you see documented what the compiler does
with literal objects.  It could merge or duplicate them at will.
Therefore self modifying code won't behave the same when interpreted
and when compiled.


>> This is the difference between '(1 2 3) and (list 1 2 3).
>
> The difference is that the first form is turned into a list by the Lisp
> reader, each time it is passed through the reader (in most cases, once).
> In interactive use, it is perfectly equivalent to the second form.  When
> put into function definitions or bound to anything, it isn't.

Yes, another fuzzyness.

-- 
__Pascal Bourguignon__                     http://www.informatimago.com/

HANDLE WITH EXTREME CARE: This product contains minute electrically
charged particles moving at velocities in excess of five hundred
million miles per hour.