The textual representation of a list is composed of an opening parenthesis, a sequence of Lush objects separated by blanks and closing parenthesis. The empty list is thus written as () .

The second element (cdr) of a pair is not necessary a list. A special dotted pair notation is used for representing such a pair. This notation is composed of an opening parenthesis, the first Lush objects, a blank separated dot, the second Lush object and a closing parenthesis.

Examples:

       (1 2 3)               ; car=2 and cdr=(2 3)
       ((q w) 2)       ; car=(q w) and cdr=2
       (1 2 (e r))     ; car=1 and cdr=(2 (e r))
       (a . b)               ; car=a and cdr=b

Example:

? (car '(a b c d))
= a

Example:

? (cdr '(a b c d))
= (b c d)

Example:

? (cadr '(a b c d))
= b

Example:

? (cons '+ '(2 3))
= (+ 2 3)

? (cons 'a 'b)
= (a . b)

Example:

? (list 'a '(b c) 'd)
= (a (b c) d)

Example:

? (makelist 4 'e)
= (e e e e)

Example:

? (range 2 5)
= (2 3 4 5)

Example:

? (length '(a b c d e))
= 5

This function is able to detect that list l is circular. The value -1 is returned when such a condition occurs.

Example:

? (append '(1 2 3) '(4 5 6))
= (1 2 3 4 5 6)

Example:

? (reverse '(1 2 3))
= (3 2 1)

Example:

? (nth 3 '(a b c d e))
= d

Example:

? (nthcdr 3 '(a b c 3 e f))
= (3 e f)

Example:

? (last '(a b c 3 e f))
= f

Example:

? (lastcdr '(a b c 3 e f))
= (f)

When n is greater than 0 , this function returns the n first elements of l . When the length of the list is lower than n , a copy of the list is returned.

When n is lower than 0 , this function returns all elements but the n last. When the length of the list is lower than the absolute value of n , the empty list is returned. If l is a circular list , an error occurs.

There is a single equality test in Lush that is able to recursively compare lists and strings.

Example:

? (member 'e (range 1 4))
= ()

? (member 'e '(a b c d e f g h i j))
= (e f g h i j)

Example:

? (flatten '2)
= (2)

? (flatten '(1 2 (3 (6 7)) 4))
= (1 2 3 6 7 4)

Function assoc is useful for searching an ``alist''. An alist is a list of pairs (key . value) representing associations between a search key key and a value value .

Function assoc returns the first pair of alist whose first element is equal to key . The empty list is returned when no matching pair is found. Once the pair is located, you can acess the value associated with the key using function cdr . You can also change the value using function rplacd .

Remark: Alists should be only used for small numbers of key-value pairs. We suggest using hash tables as soon as the association involves more that twelve key-value pairs. Hash tables indeed require more memory but are much faster and much more convenient.

This function is defined as follows:

 (de alist-add(key value alist)
   (let ((pair (assoc key alist)))
      (if pair
         (rplacd pair value)       
        (setq alist (cons (cons key value) alist)) )
      alist ) )

This function is defined as follows:

 (de alist-get(key alist)
   (let ((pair (assoc key alist)))
      (when pair
         (cdr pair) ) ) )

? (sort-list '(12 3 1 2 3 4 5 6) >)
= (1 2 3 3 4 5 6 12)

This function returns a list wich elements of are indices of l such that its components are ranked from the biggest to the lowest.

The list l is assumed to be homogeneous, which means that the length of its member sublists have all the same length, and this in a recursive way. In other word, list l is the list counterpart of a multidimensional array.

? (lbound1 '(1 2 (3 4) 5))
= (4)

All lists, even unhomogeneous, are supported.

? (lboundn '(1 2 (3 4) 5))
= (4 2)

• 1 List l may be splitted into several sublists of equal size. When n is () , list l is used as it is (without being splitted). Otherwise argument n defines a format for splitting list l which is then considered as a flat list.

  When n is an integer, l is splitted into sublists of length n .

  When n is a list, it describes the dimensions of the splitted list following the semantic of msplit-dim .
  

• 2 From the shaped list is extracted a rectangular sublist. Arguments s1 ... sn define the selected subscripts. They follow the same subscripts semantic as submatrix .
  
• 3 The sublist is returned in a flat format.
  

The following example takes a list of numbers from 0 to 99, considered as an array 5 * 20, and extracts the items in the intersection of lines 1, 2 and columns 4, 5, 6, 7.

? (sublist (range 100) '(5 ()) '(1 2) '(4 7))))
= (25 26 27 28 45 46 47 48)

? (sublist (range 0 29) 5 () '(2 3))))
= (2 3 7 8 12 13 17 18 22 23 27 28)

See: (submatrix mat s1 ...[ sn ])
See: (msplit-dim m targetdim newdims )

Side effects should be expected when another lisp object points to the argument of such a physical list modification function. The modification then appears in both places.

Physical list manipulation functions can be used to construct lists that reference themselves. Some Lush functions are able to test this condition (e.g. length ) and avoid an infinite loop. Some Lush functions however (e.g. print , flatten ) will loop forever when processing such a list. You can interrupt these loops by typing Ctrl-C or Break .

See: (length l )
See: (== n1 n2 )

Example:

? (setq a '(1 2 3))
= (1 2 3)
? (setq b (cdr a))
= (2 3)
? (rplaca b 'e)    ; this is fast
= (e 3)
? a                ; but causes side effects
= (1 e 3)

Example:

? (setq a '(a b c d e))
= (a b c d e)
? (nconc1 a 'f)
= (a b c d e f)