# Extending and Reversing Lists¶

The title of this section is a little bit misleading as the discussed procedures do not actually modify the lists but return a modified copy of the original list(s). However, they are nevertheless very useful in common programming tasks.

## Appending Lists to Lists¶

`append` takes (at least) two lists and returns a new list that concatenates them:

``````guile>(define a '(1 2 3))
guile>(define b '(4 5 6))
guile>(define c '(a b c))
guile>(append a c b)
(1 2 3 a b c 4 5 6)
``````

Note that the lists defined as `a`, `b` and `c` are not changed through these operations. In order to make use of the resulting list you will have to bind it to something else:

``````guile>(define c (append a b))
guile>c
(1 2 3 4 5 6)
``````

### Appending a Single Element to a List¶

Of course it is possible to append single elements to a list, and in fact this is a very common task. However, there is a caveat that can lead to a very typical error:

``````guile> (append '(1 2 3) 4)
(1 2 3 . 4)
``````

Appending a single element seems to create an improper list! But if we take a step back and consider what actually happens when lists are concatenated it is clearly correct behaviour.

We know that lists in Scheme are chained pairs, with the `car` of each pair holding the data of the element and the `cdr` pointing to the next element's pair. The last element of a proper list is also a pair, with the `cdr` being the empty list `()`. What `append` actually does is pointing that trailing empty list to the appended list, making the first element of the second list a natural member of the first. Consequently, when we append the simple value `4` to a list the `cdr` of the last list element becomes `4` - making the first list an improper list.

Fortunately the “solution” is very easy - just something one tends to forget most of the time. “`append` takes (at least) two lists” is what I wrote at the top, and you have to take that literally: you need a list, even if it consists of only one element. So the proper way would have been to write

``````guile>(append '(1 2 3) '(4))
(1 2 3 4)
``````

NOTE: As an exercise you can figure out how to achieve that result by not appending a list but a pair.

## Reversing Lists¶

As with the above `reverse` does not change the list itself but returns a new list with the same elements in reverse order. The behaviour is not surprising at all:

``````guile>(reverse '(1 2 3 4))
(4 3 2 1)
``````

Apart from simply reverting the order of a complete list `reverse` can be made useful for accessing list elements from the end. For example the second-to-last element of a list with unknown length can be accessed through `(second (reverse '(1 2 3 4)))` (which would evaluate to `3`). The same result could be achieved using `(list-ref '(1 2 3 4 ) (- (length '(1 2 3 4)) 2))`, but apart from needing to refer to the list twice this may be semantically less straightforward, and often you'd prefer juggling with reversed lists. As another example you can retrieve all the elements of a list except the last through

``````guile> (reverse (cdr (reverse '(1 2 3 4))))
(1 2 3)
``````

First we reverse the list, then we apply `cdr` (giving us all elements except the first one (i.e. the last one of the original list)), and finally we reverse the order again. As an exercise you should try achieving the same result using `list-head`.

Last update: November 3, 2022