Append

In computer programming, codice_1 is the operation for concatenating linked lists or arrays in some high-level programming languages.
Lisp.
codice_2 originates in the Lisp programming language. The codice_1 procedure takes zero or more (linked) lists as arguments, and returns the concatenation of these lists.
Since the codice_1 procedure must completely copy all of its arguments except the last, both its time and space complexity are O("n") for a list of formula_1 elements. It may thus be a source of inefficiency if used injudiciously in code.
The codice_5 procedure (called codice_6 in Scheme) performs the same function as codice_1, but destructively: it alters the cdr of each argument (save the last), pointing it to the next list.
Implementation.
codice_2 can easily be defined recursively in terms of codice_9. The following is a simple implementation in Scheme, for two arguments only:
(define append
 (lambda (ls1 ls2)
 (if (null? ls1)
 ls2
 (cons (car ls1) (append (cdr ls1) ls2)))))
Append can also be implemented using fold-right:
(define append
 (lambda (a b)
 (fold-right cons b a)))
Other languages.
Following Lisp, other high-level languages which feature linked lists as primitive data structures have adopted an codice_1. Haskell uses the codice_11 operator to append lists. OCaml uses the codice_12 operator to append lists.
Other languages use the codice_13 or codice_11 symbols for nondestructive string/list/array concatenation. 
Prolog.
The logic programming language Prolog features a built-in codice_1 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.
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.
This right-fold has the same effect as the Scheme implementation above:
append :: [a] -> [a] -> [a]
append xs ys = foldr (:) ys xs
This is essentially a reimplementation of Haskell's codice_11 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])
print l + [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].
Bash.
In Bash the append redirect is the usage of "»" for adding a stream to something, like in the following series of shell commands:
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: