# ANSI Common Lisp 3. Lists 20 June 2003. Lists Conses List Functions Trees Sets Stacks Dotted Lists Assoc-lists.

## Presentation on theme: "ANSI Common Lisp 3. Lists 20 June 2003. Lists Conses List Functions Trees Sets Stacks Dotted Lists Assoc-lists."— Presentation transcript:

ANSI Common Lisp 3. Lists 20 June 2003

Lists Conses List Functions Trees Sets Stacks Dotted Lists Assoc-lists

Conses (cons, car and cdr) Cons Combine two objects into a two-part pair. The first part is car and the second is cdr. >(setf x (cons a b)) (A. B) >(car x) A >(cdr x) B Box notation

Conses (lists) Lists can be represented as conses. >(cons a nil) (A) >(cons 'a (cons 'b (cons 'c nil))) (A B C) A list can have any kind of object as elements, including another list (nested list). > (setf x (list a (list b c) d) (A (B C) D)

List Functions list > (list a b c) (A B C) car and cdr > (car (a b c)) A > (cdr (a b c)) (B C) listp (returns T if the argument is either a cons or a NIL) >(listp (a b c)) T

List Functions consp (returns T for any cons) >(consp (a b c)) T atom (returns T for any none-cons) >(atom NIL) T append (concatenates any number of lists) >(append '(a (b c)) '(d e)) (A (B C) D E)

List Functions -- Equality eq (returns T iff object1 and object2 are in the same memory location.) >(eq x x) T >(eq (cons 1 2) (cons 1 2)) NIL eql (returns T iff object1 and object2 are eq or the same character/number.) >(eql x x) T >(eql (cons 1 2) (cons 1 2)) NIL

List Functions -- Equality equal (returns T if its arguments prints same.) >(equal (cons 1 2) (cons 1 2)) T > (equal '(a b c) '(a (b) c)) NIL equalp (returns T iff object1 and object2 are equal, char-equal, or=, or are cons whose cars and cdrs are equalp; or are hash tables with same test function and number of entries whose keys are all associated with equalp values.)

List Functions copy-list The new list has the same elements as the original, but not eql to. >(setf x (a b c) y (copy-list x)) (A B C)

List Functions Difference between copy-list and setf >(setf x (a b c)) (A B C) >(setf y x) (A B C) >(eql x y) T >(setf (car y) 'aa) >x (AA B C)

List Functions -- Access first, second, third, fourth, …, tenth >(third (a b c d)) C cxxxxr (cadr, caddr, cadddr…) >(caddr '(a b c d e f)) C nth >(nth 0 (a b c)) A nthcdr >(nthcdr 2 (a b c)) (C)

List Functions – mapping functions mapcar Takes a function and one or more lists, and returns the result of applying the function to elements taken from each list, until some list runs out. >(mapcar #list (1 2 3 4) (a b c)) ((1 A) (2 B) (3 C)) maplist Takes the same arguments as mapcar, but applies the function on successive cdrs of the lists. >(maplist #(lambda (x) x) (a b c)) ((A B C) (B C) (C))

List Functions length >(length (a b c d)) 4 subseq The 2 nd argument (required) is the position of the 1 st element to be included. The 3 rd argument (optional) is the position of the first element not to be included. >(subseq (a b c d) 1 3) (B C) >(subseq (a b c d) 1) (B C D)

List Functions reverse >(reverse (a (b c) d)) (D (B C) A) sort Takes a sequence and a comparison function of two arguments, and returns a sequence with the same elements sorted according to function. The sort function is destructive. The sequence given to sort may be modified. >(sort (4 3 7 5 1) #>) (7 5 4 3 1)

List Functions every and some Take a predicate and one or more sequences. If given only one sequence, they test whether the elements satisfy the predicate. If given more then one sequences, they test whether the elements, drawn one at a time from all sequences, satisfy the predicate. >(every #oddp (1 3 5)) T (some #evenp (1 2 3)) T >(every #< (1 2 3) (4 5 6)) T

Trees The conses (lists) can be considered as binary trees, where the car represents the left sub-tree and the cdr represents the right sub-tree.

Trees General Operation Forms on Trees Recursing down both the car and cdr. >(copy-tree (a (b c) d)) (A (B C) D) (defun copy-tree (tr) (if (atom tr) tr (cons (copy-tree (car tr)) (copy-tree (cdr tr)))))

Trees Substitution >(setf x '(and (integerp x) (zerop (mod x 2)))) (AND (INTEGERP X) (ZEROP (MOD X 2))) >(substitute 'y 'x x) (AND (INTEGERP X) (ZEROP (MOD X 2))) >(subst 'y 'x x) (AND (INTEGERP Y) (ZEROP (MOD Y 2)))

Sets Lists can be considered as sets. Each element of a list is a member of the set it represents. adjoin >(adjoin b (a b c)) (A B C) >(adjoin d (a b c)) (D A B C) union >(union (a b c) (c b s)) (A C B S)

Sets intersection >(intersection (a b c) (b b c)) (B C) set-difference >(set-difference (a b c d e) (b e)) (A D C) The union, intersection and set-difference functions dont guarantee the original order of elements will be preserved.

Sets -- member member function Tests whether an object is a member of a set. If yes, it returns the part of list beginning with the object its looking for. By default, it compares objects using eql. The :test keyword lets you change the comparison function. >(member (a) ((b) (a) (z))) NIL >(member (a) ((b) (a) (z)) :test #equal) ((A) (Z))

Sets -- member member function The :key keyword is used to specify a function to be applied to each element of the list before comparison. >(member a ((a b) (c d)) :key #car) ((A B) (C D)) If theres an element whose car is a. member-if Find an element satisfying some predicate. >(member-if #oddp (2 3 4)) (3 4)

Stacks Lists can be considered as stacks (FILO). push and pop (push x y) pushes x onto the front of list y; pop(y) removes and returns the 1 st element of list y. >(setf x (a)) >(push b x) (B A) >(pop x) B

Stacks pushnew Takes the same arguments as push(x, y). If object x already exists in list y, then x wont be pushed in anymore. >(setf x (a)) >(push b x) (B A) >(pushnew b x) (B A)

Dotted Lists Proper lists Either a NIL or a cons whose cdr is a proper list. Dotted Lists >(setf pair (cons a b)) (A. B) Lists can be represented as dotted lists. >(a. (b. (c. nil))) (A B C)

Assoc-lists Assoc-list is a list of conses. It can be used as mapping or hash table. >(setf trans ((+. add) (-. subtract))) ((+. add) (-. subtract)) >(assoc + trans) (+. add) The assoc function can take :key and :test keywords.

Download ppt "ANSI Common Lisp 3. Lists 20 June 2003. Lists Conses List Functions Trees Sets Stacks Dotted Lists Assoc-lists."

Similar presentations