LISP primitives on sequences FIRST (or CAR) and REST (or CDR) take lists apart. Consider the list (First day of the semester). * (first '(First day of the semester)) FIRST * (rest '(First day of the semester)) (DAY OF THE SEMESTER) First Rest A (B C) (A B C)

Examples * (first ( )) NIL * (rest ( )) * (first '((a b) (c d)) (A B) * (rest '((a b) (c d)) ((C D)) * (car '(a . b)) A * (cdr '(a . b)) B

The QUOTE mark ' stops evaluation * (first (rest '(a b c))) ;second returns B ;the 2nd element * (first '(rest (a b c))) ;third returns REST ;the 3rd element,... * (first (rest (a b c))) ;tenth returns ? ;the 10th element >>> Error:Undefined function: A while evaluating: (A B C) (#<COMPILED-FUNCTION 3:E196> ...) Debugger 1>

Examples * (first (first (rest '(rest ((a b)(c d)(e f)))))) (A B) * (first '(((a b) (c d) (e f)))) ((A B) (C D) (E F)) Given (apple (orange)((pear))(((kiwi))))), write a sequence of FIRST and REST which returns PEAR. * (first (first (first (rest (rest '(apple (orange) ((pear)) (((kiwi))))))))))))) PEAR * (rest '(apple (orange) ((pear)) (((kiwi))))))))) ((ORANGE) ((PEAR)) (((KIWI)))) * (rest '((orange) ((pear)) (((kiwi))))) (((PEAR)) (((KIWI)))) * (first (first (first '(((pear)) (((kiwi)))))))

The SETF / SETQ primitives The process of reserving a place in memory to store a value is called binding. The process of storing a value for a symbol is called assignment. The process of recovering a value from memory is called evaluation. SETF / SETQ assign values to symbols * (setf ab-list '(a b)) (a b) * ab-list * (setf ab-list '(a b) cd-list '(c d)) (c d) ; accepts multiple symbol-value pairs, ; but returns only the last assignment

SETF alters the contents of the cons cell storing the symbol. * (setf fact1 '(CS462 is a fun course)) (CS462 IS A FUN COURSE) * fact1 fact1 CS462 is a fun course

fact1 CS463 is a fun course * (first fact1) CS462 * fact1 * (setf (first fact1) 'CS463) CS463 is a fun course fact1 * fact1 (CS463 IS A FUN COURSE)

CONS, APPEND and LIST primitives construct lists * (cons 'a '(b c)) (A B C) FIRST REST CONS (A B C) A (B C) * (append '(a b c) '(x y z)) ;combines elements (A B C X Y Z) * (list '(a b c) '(x y z)) ;combines lists ((A B C) (X Y Z))

CONS, APPEND and LIST do not alter symbol values. * (append 'list1 'list2) ; does not accept atoms as arguments ERROR * (list 'list1 ' (x y z)) ; arguments can be both atoms and lists (LIST1 (X Y Z)) CONS, APPEND and LIST do not alter symbol values.

REST, NTHCDR, BUTLAST and LAST shorten lists * (rest '(a b c d)) (B C D) ; list without its first element * (nthcdr 2 '(a b c d)) (C D) ; list without ‘n’ first elements. * (nthcdr 4 '(a b c d)) NIL * (butlast '(a b c d) 2) (A B) ; list without ‘n’ last elements. * (butlast '(a b c d)) (A B C) ; list without its last element. * (last '(a b c d)) (D) ; list of just the last element. * (last '((a b) (c d) (e f))) ((E F))

More examples Add D at the end of the list (A B C) * (append '(a b c) (list 'd)) (A B C D) Add D at the beginning of the list (A B C) * (cons 'd '(a b c)) (D A B C) Add D as a second element in the list (A B C) * (append (list (first '(a b c))) (list 'd) (nthcdr 1 '(a b c))) (A D B C) Create a list of D and the last element of (A B C) * (setf new-list (list 'd (first (last '(a b c)))) ) (D C) * new-list

LENGTH counts the number of top-level elements, REVERSE reverses the order of top-level elements * (length '(a b ((c d) (e f)))) 3 * (length (append '(a b ((c d) (e f))) '(x y z))) 6 * (reverse '(a b ((c d) (e f)))) (((C D) (E F)) B A) * (reverse (append '(a b ((c d) (e f))) '(x y z))) (Z Y X ((C D) (E F)) B A)

User-defined procedures: the DEFUN primitive Build a list (a d) out of the list (a b c d). I way: Use the CONS primitive * (cons (first '(a b c d)) (last '(a b c d))) (A D) II way: Create a new procedure both-ends * (both-ends '(a b c d)) * (defun both-ends (whole-list) (cons (first whole-list) (last whole-list))) BOTH-ENDS

General form of the DEFUN primitive (defun <procedure name> (<parameter list>) <form 1> <form 2> … <form n>) DEFUN does not evaluate its arguments, it only establishes the procedure definition.

Example (cont.) * (setf whole-list '(a b c d)) (A B C D) * whole-list * (both-ends whole-list) (A D) (A B C D) ; the value was not affected by both-ends which used the same atom as argument.

LISP distinguishes between local (lexical) and special (global) variables Parameters in procedures are local variables. They are bound to argument value only inside the procedure. Values of global variables are set with the SETF primitive. Example: * (defun both-ends-global ( ) (setf whole-list (cons (first whole-list)(last whole-list)))) BOTH-ENDS-GLOBAL * whole-list (A B C D) * (both-ends-global) (A D)

Procedures may have any number of parameters * (defun both-ends-two-parameters (x y) (cons (first x) (last y))) BOTH-ENDS-TWO-PARAMETERS * (setf x '(a b) y '(c d)) (C D) * (both-ends-two-parameters x y) (A D)

Procedures may produce side effects * (defun both-end-with-side-effect (x y) (setf side-effect-1 '(This is a side effect)) (setf side-effect-2 '(Another side effect)) (cons (first x) (last y))) BOTH-END-WITH-SIDE-EFFECT * side-effect-1 Unbound symbol: SIDE-EFFECT-1 * side-effect-2 Unbound symbol: SIDE-EFFECT-2 * (both-end-with-side-effect x y) (A D) (THIS IS A SIDE EFFECT) (ANOTHER SIDE EFFECT)