Append

In computer programming, append is the operation for concatenating linked lists or arrays in some high-level programming languages.

Lisp

Append originates in the programming language Lisp. The append procedure takes zero or more (linked) lists as arguments, and returns the concatenation of these lists.

(append'(123)'(ab)'()'(6));Output: (1 2 3 a b 6)

Since the append procedure must completely copy all of its arguments except the last, both its time and space complexity are O(n) for a list of ${\displaystyle n}$ elements. It may thus be a source of inefficiency if used injudiciously in code.

The nconc procedure (called append! in Scheme) performs the same function as append, but destructively: it alters the cdr of each argument (save the last), pointing it to the next list.

Implementation

Append can easily be defined recursively in terms of cons . The following is a simple implementation in Scheme, for two arguments only:

(defineappend(lambda(ls1ls2)(if(null?ls1)ls2(cons(carls1)(append(cdrls1)ls2)))))

Append can also be implemented using fold-right:

(defineappend(lambda(ab)(fold-rightconsba)))

Other languages

Following Lisp, other high-level programming languages which feature linked lists as primitive data structures have adopted an append. To append lists, as an operator, Haskell uses ++, OCaml uses @.

Other languages use the + or ++ symbols to nondestructively concatenate a string, list, or array.

Prolog

The logic programming language Prolog features a built-in append predicate, which can be implemented as follows:

append([],Ys,Ys).append([X|Xs],Ys,[X|Zs]):-append(Xs,Ys,Zs).

This predicate can be used for appending, but also for picking lists apart. Calling

?-append(L,R,[1,2,3]).

yields the solutions:

L = [], R = [1, 2, 3] ; L = [1], R = [2, 3] ; L = [1, 2], R = [3] ; L = [1, 2, 3], R = []

Miranda

In Miranda, this right-fold, from Hughes (1989:5-6), has the same semantics (by example) as the Scheme implementation above, for two arguments.

append a b = reduce cons b a

Where reduce is Miranda's name for fold, and cons constructs a list from two values or lists.

For example,

append [1,2] [3,4] = reduce cons [3,4] [1,2]     = (reduce cons [3,4]) (cons 1 (cons 2 nil))     = cons 1 (cons 2 [3,4]))         (replacing cons by cons and nil by [3,4])     = [1,2,3,4]

Haskell

In Haskell, this right-fold has the same effect as the Scheme implementation above:

append::[a]->[a]->[a]appendxsys=foldr(:)ysxs

This is essentially a reimplementation of Haskell's ++ operator.

Perl

In Perl, the push function is equivalent to the append method, and can be used in the following way.

my@list;push@list,1;push@list,2,3;

The end result is a list containing [1, 2, 3]

The unshift function appends to the front of a list, rather than the end

my@list;unshift@list,1;unshift@list,2,3;

The end result is a list containing [2, 3, 1]

When opening a file, use the ">>" mode to append rather than over write.

open(my$fh,'>>',"/some/file.txt");print$fh"Some new text\n";close$fh;

Note that when opening and closing file handles, one should always check the return value.

Python

In Python, use the list method "extend" or the infix operators + and += to append lists.

l=[1,2]l.extend([3,4,5])printl+[6,7]

After executing this code, l is a list containing [1, 2, 3, 4, 5], while the output generated is the list [1, 2, 3, 4, 5, 6, 7].

Do not confuse with the list method "append", which adds a single element to a list:

l=[1,2]l.append(3)

Here, the result is a list containing [1, 2, 3].

The append() function, when appending a list to another list, will have the (often undesirable) result of having the entire second list become a single final item of the first list ^[1] :

# Create a listfruits=['apple','banana','cherry']# Create another listmore_fruits=['dragonfruit','elderberry']# Append the second listfruits.append(more_fruits)print(fruits)# Output:# ['apple', 'banana', 'cherry', ['dragonfruit', 'elderberry']]

Bash

In Bash the append redirect is the usage of ">>" for adding a stream to something, like in the following series of shell commands:

echoHelloworld!>text;echoGoodbyeworld!>>text;cattext 

The stream "Goodbye world!" is added to the text file written in the first command. The ";" implies the execution of the given commands in order, not simultaneously. So, the final content of the text file is:

Hello world!
Goodbye world!

References

1. Python Append Function

• Hughes, John (1989). "Why functional programming matters" (PDF). Computer Journal . 32 (2): 98–107. Archived from the original (PDF) on 2007-04-13.
• Steele, Guy L. Jr. (1990). "Common Lisp: The Language" (2nd ed.): 418.{{cite journal}}: Cite journal requires |journal= (help) Description of append.