Question

Some claim that appending to immutable lists is more efficient. Is this true? How?

Answer 1

Producing a modified version of a list by allocating an array large enough to hold the modified version and copying over all of the unmodified elements is somewhat expensive, regardless of whether the modification is an append, an insert, a deletion, replacement, or anything else. The cost is roughly comparable to that of producing an unmodified, but distinct, copy of the list.

If an object Foo wishes to maintain a list of elements in such a way that it can only be changed when Foo changes it, there are two common approaches it can use to do so:

1. It can use an “immutable list” type which guarantees that any instance which has ever been exposed to the outside world will forever hold the same sequence of objects. The object `Foo` would be free to expose references to this list, since nobody would be able to alter it. If `Foo` wants to e.g. add an item to its list, it would generate a new immutable list which contains all the items in the list, plus the new one, and start holding a reference to that instead of the old one.
2. It can create a list object which is mutable, but is never exposed to the outside world. If anyone needs to retrieve the sequence of items from the list, `Foo` would copy the list’s contents into a new list with which the caller could use in any way it sees fit without affecting `Foo`s list..

If one uses approach #1, then every time Foo alters the list it must create a new “immutable list” instance, but Foo could answer a request for the list’s contents without having to copy it. If one uses approach #2, adding items to the list (and other modifications) will be cheaper, but answering a request for the list’s contents will require copying the list. Whether it’s better to use approach #1 or approach #2 will depend upon how often the list is updated, versus how often the application will need a copy of it.