1. Introduction to LISP

2. Lisp Extensible: It lets you define new operators yourself Lisp programs are expressed as lisp data structures –You can write programs that write programs (macros)

3. Prefix notation >(+ 2 3) 5 >(+ 2 3 4 5) 14 >(/ (- 7 1) (- 4 2)) 3

4. Prefix notation evaluation >(/ (- 7 1) (- 4 2)) 3 1.Arguments from left to right 2.Arguments are passed to the function

5. Data Integer >256 256 Strings >"hello world“ "hello world“ Symbols Symbols are words >’hello HELLO –Usually converted to uppercases –Lisp is case insensitive Lists

6. Quote >(quote (+ 3 5)) (+ 3 5) >(’ (+ 3 5)) (+ 3 5) quote is a special operator (distinct evaluation rule) Protects expressions from evaluation

7. Lists Lists are zero or more elements enclosed in parentheses >(list 3 2 1) (3 2 1) >’(3 2 1) (3 2 1) >(list '(+ 2 1) (+ 2 1)) ((+ 2 1) 3)

8. Lists Lisp programs are expressed as lists This is why we need the quote –Quoted list: returns the list itself –Unquoted list: trated as code and returns its evaluation

9. List operations >(cons ‘a ‘(b c d)) (A B C D) >(car ‘(a b c d)) A >(cdr ‘(a b c d)) (B C D) >(car (cdr ‘(a b c d))) B second, third, nth

10. Truth T, NIL, null, not >(listp ‘(a b c)) T (>listp 27) NIL >(null nil) T >(not nil) T numberp, listp, stringp, …

11. Conditionals (if (listp ‘(a b c)) (+ 1 2) (+ 5 6)) 3 (if (listp 27) (+ 2 3)) NIL

12. AND / OR (and t NIL) NIL (and t (+ 1 3)) 3 (or t NIL) T (or t (+ 1 3)) T

13. Functions (defun our-third (x) (car (cdr (cdr x))) >(our-third ‘(A B C D)) C

14. Recursion (defun our-member (obj lst) (if (null lst) nil (if (eql (car lst) obj) T (our-member obj (cdr lst)))))

15. Iteration (defun show-squares (start end) (do ((i start (+ i 1 ))) ((> I end) ‘done) (format t “~s ~s ~%” i (* i i)))) We do not always need recursion. When we want to do something repeatedly, iteration is sometimes more natural A typical case is to generate some sort of table or iterating over an array Prints out the squares of the integers from start to end

16. Recursive show-squares For comparison, here is a recursive version of show-squares. (defun show-squares (i end) (if (> i end) ‘done (progn (format t “~s ~s ~%” i (* i i)) (show-squares (+ i 1) end)))) Note: progn is an special operator that evaluates its arguments in order and returns the value(s) of the last.

17. Functional programming >(setf lst ‘(c a r a t)) (C A R A T) (remove ‘a lst) (C R T) Removes does not remove an object from a list (not literally) The function returns a new list containing everything on the original list but the object Use (setf x (remove ‘a x)) instead

18. Functions as objects In Lisp, functions are regular objects (like symbols or strings or lists) Like any other kind of object, we can pass functions as arguments. One example of a function that takes a function as parameter is apply >(apply #’+ ‘(1 2 3)) 6 #’ (sharp-quote) is an abbreviation for function just as ‘ is an abbreviation for quote >(apply (function +) ‘(1 2 3)) 6 The function funcall does the same thing but does not need the arguments to be packaged in a list: >(funcall #’+ 1 2 3) 6

19. Equality > (eql '(1 2) '(1 2)) NIL > (equal '(1 2) '(1 2)) T > (eql 1 1) T > (equal 1 1) T > (= 1 1) T > (= 1 1.0) T > (eql 1 1.0) NIL > (equal 1 1.0) NIL

20. Mapping functions > (mapcar #'sqrt '(4 9 16)) (2 3 4) Mapcar takes a function and a list and returns the result of applying the function to every element from the list. Other map functions –maplist, mapcan, mapcon, …

21. Some functions you might need car cdr defun if lambda list listp stringp loop mapcar not defvar setf setq numberp funcall remove defmacro

22. Some useful functions for the homework Instantiate the game class –(setq mypuzzle (make-instance 'game :board *easy-test* :name “easy”)) –Creates an instance of the class game and sets the att board to *easy- test* and the att name to “easy” –To access the atts (above we just set them when creating the instance), use the accessors defined in the defclass (game-board mypuzzle) (game-name mypuzzle)

23. Some useful functions for the homework Use the functions provided. Particularly row- groups, column-groups, and block-groups: (setq rows (ROW-GROUPS (game-board mypuzzle))) (setq cols (COLUMN-GROUPS (game-board mypuzzle))) (setq blocks (BLOCK-GROUPS (game-board mypuzzle))) game-board is the accessor to the board attribute in the game class You can print the lists: >(print rows) ((2 4 3 1) (1 3 4 2) (4 2 1 3) (3 1 2 -))

24. Some useful functions for the homework (not (member t (mapcar 'duplicate-values rows))) no duplicate values on the rows of the board (rows is a list of lists as you can see on previous slide) (defun duplicate-values (lst) (has-duplicates (sort (remove '- lst) #'<))) has-duplicates should be a recursive function similar to our- member defined on previous slides. The logic is: –return NIL for lists of size 1 or less –return true if the first and second element are equal –call has-duplicates on the rest of the list

25. Some useful functions for the homework Removes the dashes from the list lst –(remove ‘- lst) Member which returns NIL if the list does not contain the element –> (member 1 '(2 3 4)) –NIL –(not (member t (mapcar 'duplicate-values rows))) no duplicate values on the rows of the board (rows is a list of lists as you can see on previous slide)

26. Some useful functions for the homework iota creates a list of numbers within a range > (iota 10 1) (1 2 3 4 5 6 7 8 9 10) sort returns a the list sorted according to a comparison function > (sort '(5 3 4 1 9) #'<) (1 3 4 5 9) To check if a list (e.g. a row, a column, a block) has all the values from 1 to MAXX (useful function for defining goalp): (defun all-values (lst) (equal (iota MAXX 1) (sort (remove '- lst) #'<) ))

27. From the code from the book http://aima.cs.berkeley.edu/ Use utilities.lisp if you want to use the iota function You might want to use queue.lisp too (includes functions for queues maniulations) You might want to check simple.lisp for the general search (an idea of how to implement it)