`car', `cdr', `cons', `append', `reverse', `length'
---------------------------------------------------

car(LIST)
     :: The first element of the given non-null list LIST.

cdr(LIST)
     :: A list obtained by removing the first element of the given
     non-null list LIST.

cons(OBJ,LIST)
     :: A list obtained by adding an element OBJ to the top of the
     given list LIST.

append(LIST1,LIST2)
     :: A list obtained by adding all elements in the list LIST2
     according to the order as it is to the last element in the list
     LIST1.

reverse(LIST)
     :: reversed list of LIST.

length(LIST)
     :: Number of elements in a list LIST.

RETURN
     `car()' : arbitrary, `cdr()', `cons()', `append()', `reverse()' :
     list,  `length()' : non-negative integer

LIST LIST1 LIST2
     list

OBJ
     arbitrary

   * A list is written in Asir as [OBJ1,OBJ2,...].  Here, OBJ1 is the
     first element.

   * Function `car()' outputs the first element of a non-null list.
     For a null list, the result should be undefined. In the current
     implementation, however, it outputs a null list.  This treatment
     for a null list may subject to change in future, and users are
     suggested not to use the tentative treatment for a null list for
     serious programming.

   * Function `cdr()' outputs a list obtained by removing the first
     element from the input non-null list.  For a null list, the result
     should be undefined. In the current implementation, however, it
     outputs a null list.  This treatment for a null list may subject
     to change in future, and users are suggested not to use the
     tentative treatment for a null list for serious programming.

   * Function `cons()' composes a new list from the input list LIST and
     an arbitrary object OBJ by adding OBJ to the top of LIST.

   * Function `append()' composes a new list, which has all elements of
     LIST1 in the same ordering followed by all elements of LIST2 in
     the same ordering.

   * Function `reverse()' returns a reversed list of LIST.

   * Function `length()' returns a non-negative integer which is the
     number of elements in the input list LIST.  Note that function
     `size' should be used for counting elements of VECTOR and MATRIX.

   * Lists are read-only objects in Asir.  There elements cannot be
     modified.

   * The N-th element in a list can be referred to by applying the
     function `cdr()' N times repeatedly and `cdr()' at last.  A more
     convenient way to access to the N-th element is the use of bracket
     notation, that is, to attach an index `[N]' like vectors and
     matrices.  The system, however, follow the N pointers to access
     the desired element. Subsequently, much time is spent for an
     element located far from the top of the list.

   * Function `cdr()' does not create a new cell (a memory quantity).
     Function `append()', as a matter of fact, repeats `cons()' for as
     many as the length of LIST1 the first argument.  Subsequently,
     `append()' consumes much memory space if its first argument is
     long.  Similar argument applies to function `reverse()'.

     [0] L = [[1,2,3],4,[5,6]];
     [[1,2,3],4,[5,6]]
     [1] car(L);
     [1,2,3]
     [2] cdr(L);
     [4,[5,6]]
     [3] cons(x*y,L);
     [y*x,[1,2,3],4,[5,6]]
     [4] append([a,b,c],[d]);
     [a,b,c,d]
     [5] reverse([a,b,c,d]);
     [d,c,b,a]
     [6] length(L);
     3
     [7] L[2][0];
     5

