1. 1 Variable Declarations Global and special variables – (defvar …) – (defparameter …) – (defconstant …) – (setq var2 (list 4 5)) – (setf …) Local variables – (let ((x 10)) …) – (let* ((x 99) …)

2. 2 Global Variables Declared using defvar and defparameter: – (defvar ) >(defvar number-list nil "A list of numbers") Assigned values using setf special form: – (setf ) >(setf x 3) 3 >x 3 Imperative Paradigm Alert (why?)

3. 3 Global variables are visible throughout the program. Global variables can be created by giving a symbol and a value to defparameter or defvar. > (defparameter *foo* 1) *FOO* > *foo* 1 > (defvar *bar* (+ *foo* 1)) *BAR* > *bar* 2 > (defvar *bar* 33) *BAR* > *bar* 2 Note: (defparameter v e) creates a global variable named v and sets its value to be e. (defvar v e) is just like defparameter if no global variable named v exists. Otherwise it does nothing. Global Variables, cont.

4. 4 Global Constants and Variables Define a global constant with defconstant > (defconstant +limit+ 100) +LIMIT+ > (setf +limit+ 99) Error: can't assign a global constant readability conventions – +symbolname+ identifies symbols as constants – *symbolname* identifies global variables

5. 5 Assignment Statements Assignment operators: set, setq and setf The most general is setf It assigns both local and global variables: > (setf *blob* 89) 89 > (let ((n 10)) (setf n 2) n) 2 Initialized n to 10, then executed all the statements within the scope of let

6. 6 setf Create global variables implicitly by assigning values > (setf x (list 'a 'b 'c)) (A B C) However, it is better lisp style to use defparameter to declare global variables You can give setf any even number of arguments (setf a 1 b 2 c 3) is the same as: (setf a 1) (setf b 2) (setf c 3)

7. 7 setf cont. You can do more than just assigning values to variables! The first argument to setf can be an expression as well as a variable name. In such cases, the value of the second argument is inserted in the place referred to by the first: > x (A B C) > (setf (car x) 'n) N > x (N B C)

8. 8 > (setq a (make-array 3)) #(NIL NIL NIL) > (aref a 1) NIL > (setf (aref a 1) 3) 3 > a #(NIL 3 NIL) > (aref a 1) 3 setf Examples > (defstruct foo bar) FOO > (setq a (make-foo)) #s(FOO :BAR NIL) > (foo-bar a) NIL > (setf (foo-bar a) 3) 3 > a #s(FOO :BAR 3) > (foo-bar a) 3

9. 9 Return or Change? The function remove takes an object and a list and returns a new list where all occurrences of the object were removed > (setf lst '(b u t t e r)) (B U T T E R) > (remove 'e lst) (B U T T R) Note: remove does not remove any items from the list! The original list is untouched after the call to remove : > lst (B U T T E R) To remove the items from a list you would have to use setf : > (setf lst (remove 'e lst)) (B U T T R) Functional programming means, essentially, avoiding setf, and other assignments.

10. 10 I/O Input (read [ ]... ) –reads the printed representation of an object from a stream (read-char [ ]... ) –returns one character and advances the stream pointer (read-char-no-hang [ ]... ) –returns one character if one is available (if so, advances the stream pointer) (read-line [ ]... ) –read characters terminated by a newline, returns a string containing the characters (yes-or-no-p [format-string *] ) –ask the user a yes/no question (yes-or-no-p "set x to 3?")

11. 11 I/O Output print - prints and returns object in lisp format > (print (list "foo" "bar")) ("foo" "bar") princ - prints for readability, without control characters e.g. " ", returns object lisp format > (princ "hello") hello "hello" format - the most general output function (format * ) –stream t prints to *standard-output* –returns NIL –the second argument is a string template, –the remaining arguments are objects to be inserted into the template: > (format t "~A plus ~A equals ~A." 2 3 (+ 2 3)) 2 plus 3 equals 5. NIL

12. 12 Developing Recursive Functions Recursive function calls a copy of itself 1. Do error checking first (if needed) 2. Check for base cases (non-recursive cases) 3. Recursion must be on a smaller problem If number – closer to base case If list – shorter or less complex Avoid infinite loops!!!! out of stack space error

13. 13 Exercise - Write a filtering function A function to filter out negative numbers from a list of numbers. Examples: > (filter-negatives '(1 -1 2 -2 3 -4)) (1 2 3) > (filter-negatives '("string")) List must contain only numbers > (filter-negatives '(-1 -2 -2 -3 -4)) NIL > (filter-negatives '(9 10)) (9 10)

14. 14 Filter-negatives 1. Error checking Is argument a list? Continue End with error message 2. Test for base case(s) Is the list empty? Return the empty list () 3. Test the first item Is it a number? If not – error message Is it a negative number? Ignore it - recurse on the rest of the list and return that result Is it a positive number? Add that number to the result of recursion on the rest of the list

15. 15 Start the function (defun filter-negatives (inlist) "takes one argument, a list of numbers and returns a list containing all the non-negative numbers in the input" (cond ; make decisions ; error – not a list? ; base case – empty list? ; what are the more complex cases? ; check first item in list -- ; not a number? Error or ignore ; negative number? ; Ignore, process remaining items ; positive number? ; Add to result, process remaining items )

16. 16 filter-negatives (defun filter-negatives (inlist) "takes one argument, a list of numbers and returns a list containing all the nonnegative numbers in the input" (cond ; make decisions ((not (listp inlist); not a list? (princ "Argument must be a list" ) (terpri) ; print return after string (list)) ; return an empty list

17. 17 filter-negatives (defun filter-negatives (inlist) (cond ; make decisions ((not (listp inlist); not a list? (princ "Argument must be a list" ) (terpri) ; print return after string (list)) ; return an empty list ; base case – empty list? ((null inlist) (list)) ; return an empty list

18. 18 Recursive Cases – Not a Number ; what are the more complex cases? ; check first item in list ; not a number? Error or ignore

19. 19 Recursive cases – Negative Number ; negative number? ; Ignore, process remaining items

20. 20 Recursive Cases – Positive Number ; positive number? ; add to result, process remaining items

21. 21 filter-negatives ;;; Error checking on input - list of numbers ;;; The base case, the list is empty so return nil ;;; if first item in arg is positive, add it to the result of recursion ;;; if it is negative, throw it away, return = result of recursion (defun filter-negatives (inlist) (cond ((not (listp inlist)) ; 1st test (princ "Argument must be a list") ; print message (terpri) (list)) ; return empty list, quit ((null inlist) (list)) ; 2nd test - out of items ((not (numberp (car inlist))) ; 3rd test - not a number (princ "List must contain only numbers") ; print message (terpri) (list)) ; return empty list, quit ((>= (car inlist) 0) ; 4th test - positive number (cons (car inlist) ; add 1st to result of (filter-negatives (cdr inlist)))) ; recursion on rest ((< (car inlist) 0) ; 5th test - negative number (filter-negatives (cdr inlist)) ; ignore 1st, return value ) ) ) ; = recursion on rest ; Note: the last test could have been t (true)

22. 22 filter-negatives filter.lisp www2.hawaii.edu/~janst/313/lisp/filter.lisp

23. 23 &optional in parameter list Gives a name to additional variable(s) in a parameter list. (defun func ( arg1 &optional arg2 )…) No error if variable(s) are present or not (func 10) (func 10 20) Default value can be specified (defun func ( arg1 &optional ( arg2 init2 ))…) (func 10) = (func 10 init2 )

24. 24 &key in parameter list Several optional parameters, Keywords rather than order is used tomatch formal names to actual names > (defun func (width &key ((:height h)) ((:depth d))) (format t "w = ~d, h = ~d, d = ~d" width h d)) FUNC > (func 1 :height 2 :depth 3) w = 1, h = 2, d = 3 NIL > (func 1 :depth 3 :height 2) w = 1, h = 2, d = 3 NIL

25. 25 &rest in parameter list Allows to accept any of number of parameters Such parameters form a list > (defun list2 (&rest x) x) LIST2 > (list2 1 2 3 4 5) (1 2 3 4 5)

26. 26 Exercise: count-occurrences Write a function that takes two parameters The first is an item to look for The second parameter is a list Returns the number of times item is found Example: > (count-occurrences 'a '(a (a c d a) (c b a))) 1 www2.hawaii.edu/~janst/313/lisp/count-occurrences.lisp

27. 27 count_all_items Now write a function that takes the same two parameters The first is an item to look for The second parameter is a list The function returns the number of times the item occurs in the list at any level ofnesting Example: > (count_all_items 'a '(b (a c d a) (c a b))) should return 3

28. 28 Exercise: make-change Write a function that calculates change (in US currency) > (make-change 123) ((1 DOLLARS) (2 DIMES) (3 PENNIES)) (defconstant *us-currency* '((100 dollars) (50 half-dollars) (25 quarters) (10 dimes) (5 nickels) (1 pennies)))

29. 29 make-change (defun make-change (number) ( ; error checking ; base case(s) ; recursive case(s) www2.hawaii.edu/~janst/313/lisp/makechange.lisp