Append

---

title: "Append" type: doc version: 1 created: 2026-02-28 author: "Wikipedia contributors" status: active scope: public tags: ["functional-programming", "lisp-(programming-language)", "programming-constructs", "articles-with-example-code", "articles-with-example-haskell-code", "articles-with-example-perl-code", "articles-with-example-python-(programming-language)-code", "dos-on-ibm-pc-compatibles"] description: "Operation for concatenating linked lists or arrays in some high-level programming languages" topic_path: "general/functional-programming" source: "https://en.wikipedia.org/wiki/Append" license: "CC BY-SA 4.0" wikipedia_page_id: 0 wikipedia_revision_id: 0

::summary Operation for concatenating linked lists or arrays in some high-level programming languages ::

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. ::code[lang=lisp] (append '(1 2 3) '(a b) '() '(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 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](cons). The following is a simple implementation in Scheme, for two arguments only: ::code[lang=scheme] (define append (lambda (ls1 ls2) (if (null? ls1) ls2 (cons (car ls1) (append (cdr ls1) ls2))))) ::

Append can also be implemented using fold-right: ::code[lang=scheme] (define append (lambda (a b) (fold-right cons b a))) ::

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: ::code[lang=prolog] 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 ::code[lang=prolog] ?- 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: ::code[lang=haskell] append :: [a] -> [a] -> [a] append xs ys = foldr (:) ys xs ::

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. ::code[lang=perl] 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 ::code[lang=perl] 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. ::code[lang=perl] 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 or the infix operators and to append lists. ::code[lang=pycon]

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

Do not confuse with the list method , which adds a single element to a list: ::code[lang=pycon]

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

::

Bash

In Bash the append redirect is the usage of "" for adding a stream to something, like in the following series of shell commands: ::code[lang=bash] echo Hello world! >text; echo Goodbye world! >>text; cat text ::

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

• Description of append.

::callout[type=info title="Wikipedia Source"] This article was imported from Wikipedia and is available under the Creative Commons Attribution-ShareAlike 4.0 License. Content has been adapted to SurfDoc format. Original contributors can be found on the article history page. ::