1. Using Lisp Lisp is a interactive system
You can files to be processed as a batch file, but more often than not the programmer is the “main program”
Every expression typed a the “>” prompt is “read” and “evaluated” unless it is prefixed with an apostrophe ‘
Typing (exit) at the “>” prompt terminates the xlisp program

2. Go to computer and play with interactive LISP
The best way to learn Lisp is to go to computer and just play with functions, as you see below.
Please do this.

3. Sample Output >(a b c) error: unbound function - a
if continued: try evaluating symbol again
1> [ back to top level ]
> '(a b c)
(a b c)
> 1 1
> 1.2
1.2
> a
error: unbound variable - a

4. Sample Output > nil nil > t t > T > '(a (b c) d)
> (setq sam 'abc)
abc
> sam

5. Arithmetic Functions > (/ 2 3) 2/3 > (/ 1.0 2) 0.5 > (1+ 3) 4
> (mod 2 3) 2
> (mod 5 2) 1
> (+ (* 2 2) (/ 4.0 5) )
4.8

6. car=first and cdr=rest
> (car '(a b c)) a
> (cdr '(a b c))
(b c)
> (car nil)
nil
> (cdr nil)
> (first '(a b c))
> (car (cdr '(a b c))) b
> (cadr '(a b c))

7. List Functions > (list 'a 2 'b) (a 2 b) > (list '(a b) '(c d))
> (list sam c)
error: unbound variable - c
if continued: try evaluating symbol again
1> [ back to top level ]
> (list sam 'c)
(abc c)
> (cons 'a '(b c d))
(a b c d)
> (cons '(a b c) 'd)
((a b c) . d)
sam had a value ‘abc assigned earlier

8. List Functions > (append '(a b) '(c d)) (a b c d)
> (reverse '(a b c d))
(d c b a)
> (length '(a (b c) d))) 3
>
> (last '(a b c d))
(d)
> (subst 'a 'b '(a b c))
(a a c)
> (subst 'a 'b '(a b c b))
(a a c a)
Substitutes in list the atom b for atom a

9. eval and quote > (eval (cdr '(a + 2 3))) cdr creates list (+ 2 3) 5
> (setq a 'b) b
> a
> b
error: unbound variable - b
if continued: try evaluating symbol again
1> [ back to top level ]
> (set 'a 'b)
> (eval (eval ''a))
> 'a a
cdr creates list (+ 2 3)

10. eval and quote > (eval (eval '(quote a))) b > 'a a
> (eval '(list '* 9 6))
(* 9 6)
> (eval (eval '(list * 9 6)))
error: bad function - (* 9 6)
1> [ back to top level ]
> (eval (eval '(list '* 9 6))) 54
First eval inside creates a “program with data”, second eval (outside) calculates the value of this “program”

11. Function Definition > (defun intro (x y) (list x 'this 'is y) )
>; be careful not to quote the arguments when
>; defining the function
> (intro 2 3)
(2 this is 3)
> (intro 'stanley 'livingston)
(stanley this is livingston)

12. Predicate Functions > (atom 2) t > (atom '(a b c)) nil
> (listp 2)
> (listp '(a b c))
> (equal 2 3)
> (= 2 3)
> (equal 6 (* 2 3))

13. Predicate Functions > (setq a ‘(1 2)) (1 2) > (equal a ‘(1 2)) t
> (eql a ‘(1 2))
nil
> (null '())
> (null 2)
> nil
> (null nil)

14. Membership Functions > (member 'c '(a b c d)) (c d)
> (member 'a '((a b) c d))
nil
> (member '(d e) '((a b) c (d e) f))
> (assoc 'c '((a b) (c d) (e f)))
This member was not using equal inside
And now go to computer and check the following functions

15. Another look at recursion

16. (defun my-member(element list) (cond ((null list) nil)
Recursive Functions
Our own definitions of functions member and length
(defun my-member(element list)
(cond ((null list) nil)
((equal element (car list)) list)
(t (my-member element (cdr list)))))
(defun my-length(list)
(cond ((null list) 0)
(t (+ (my-length(cdr list)) 1))))

17. (defun count-atoms(list) (cond ((null list) 0) ((atom list) 1)
Recursive Functions
Counts atoms at all levels of a nested list
(defun count-atoms(list)
(cond ((null list) 0)
((atom list) 1)
(t (+ (count-atoms (car list))
(count-atoms (cdr list))))))
Compare this pattern with patterns of copy and equal functions; this is binary tree recursion

18. Linear or cdr recursion
(length ‘((1 2) 3 (1 (4 (5))))) 3 + 1
(length (3 (1 (4 (5))))) + 1
(length ((1 (4 (5))))) + 1
(length ())

19. Tree of recursion

20. Temporary Variable Scopes
LET is the Scheme mechanism for temporarily binding values to names
(LET (
(name_1 expression_1)
(name_2 expression_2)
<S-expressions> ))
Evaluate expression_i and bind result to name_i
Name_1 and name_2 can only be used in the <S-expressions> in the body of the LET
static scoping
name_i can’t have a different value assigned

21. More of important functions

22. let and let*

23. How to declare local variables (we are going to need this for iterative functions)?
(LET ( ( <var1> <val1> )
...
( <vark> <valk> ) )
<exp1>
<expN> )
LET is your way to set up temporary variables. You can initialize each local variable to its value concurrently, then evaluates expressions sequentially. It returns the result of evaluating the last expression.
The default value of local variables declared by LET is NIL.

24. An Example of LET
Is the situation of the party likely to be safe for you ?
That is, are there more ‘friends’ then ‘enemies’ at the party!
(defun is-safe-p ( guests )
(let ( (friendly-guests nil)
(hostile-guests nil) ) ;; initializations
(setq friendly-guests (identify-friends guests))
(setq hostile-guests (identify-enemy guests))
(> (length friendly-guests)
(length hostile-guests) )
;; are there more friendly than hostile
) )

25. Let*
Let* evaluates ALL of the expressions before ANY of the variables are bound.
Let* allows you to evaluate things in the order that they are listed (this is not necessarily true of LET)
Example of let*:
(let* ((sum ( )) ; sum needs value
(mean (/ sum 5))) ;; calculate the mean value
(* mean mean)) ;; return the mean square
***Most of the time it doesn’t matter, but check this if you keep getting errors.

26. loop The simplest form of iteration is the – LOOP (loop
(<test condition> )
(return <optional var/val>)
[body]
) ;end loop

27. IF and IF-ELSE
We will explore the control forms later, here are four to get started
if and if-else:
(if (condition) then)
(if (condition) then else)
then – what to return if the condition is true
else – what to return if the condition is false
these will usually be function calls, but could be values to return
(if (/= y 0) (/ x y) 0) – divide x by y or return 0 if y = 0

28. Example Loop (let ((counter 1)) ; initializing my variable (loop
(If (= counter 2) (return (+ counter 5))
(+ counter 1)
)))
6 is returned.
(loop
(<test condition> )
(return <optional var/val>)
[body] )

29. Another Example (defun test ( ) (let ((n 0) (lis nil)) ; initializing
(loop
(if (> n 10) (return lis)
(setq lis (cons n lis))) ; this is end of if
(setq n (+ n 1)) )))
=> (10,9,8,7,6,5,4,3,2,1,0)
(loop
(<test condition> )
(return <optional var/val>)
[body] )

30. dotimes and dolist

31. Basic Control Structures
iteration: dotimes and dolist
(dotimes (var num) …)
iterates from 0 to num-1, setting var to each value one at a time
(dotimes (i n) (print (+ i 1))) – prints the numbers 1 through n
(dolist (var lis) …)
iterates for each item in the list lis, with var assigned to each
(dolist (a lis) (print a)) – prints each item of lis one at a time

32. dotimes Use dotimes for a counted loop
(dotimes (<var--count> <intobj- upper limit> [retobj>])
<body>)
(defun test ()
(let ((sum 0))
(dotimes (x sum) ; x var initialized to 0; 5 is limit; sum is return
(print x) (print sum)
(setq sum (+ sum x)))))

33. Dolist
Use DOLIST to process elements of a list. This is like cdring down the list – recursion!
(dolist (<var><list> [<retobj>]
<body>)
Evaluates <list> ;which must be a list
The var is then bound to each item in list
Body is executed in order
<retobj> optional, is evaluated and returned

34. Example: Using dolist to calculate a list of squares
ele is the running element of the list
(defun sq-list (lst1)
(let ((lst2 nil))
(dolist (ele lst1 (reverse lst2) )
; assigns first element lst1 to ele – again ;remember that were first/resting through the list.
; will go through each element of lst1
; will return the reverse of lst2
(setq lst2 (cons (* ele ele )
lst2)))))
(sq-list ‘( )
( )
Reverse the result list lst2 before returning
Conses square of ele to the beginning of list lst2
(dolist ( <var> <list> [<retobj>]
<body>)

35. Another example of dolist:
(defun greet (people)
(dolist (person people)
(print (append ‘(so nice to see you)
(list person)))))
(setq guests ‘(sally bobo mr-potato-head))
(greet guests) ->
(so nice to see you sally)
(so nice to see you bobo)
(so nice to see you mr-potato-head)
(dolist ( <var> <list> [<retobj>]
<body>)

36. do

37. Iteration DO is an iteration construct that allows for local variables
(DO ((var init step)...) ;; assign initial values to variables
(test expr1 expr2 ...) ;; evaluate test
body1...)
if true, evaluate expr1, expr2...; return value of last expr as value of DO and terminate
if false, evaluate body1, body2,...; evaluate step expressions and assign to vars; re-evaluate test

38. Iteration Example: calculating power M to power N
(DO ((var init step)...)
(test expr1 expr2 ...)
body1...)
Initialize RESULT to 1, next multiply it byM
(DEFUN POWER (M N) ; we raise M to power N
(DO ( (RESULT 1 (* M RESULT)) ; multiple by M starting from 1
(EXPON N (- EXPON 1)) )
; subtract one from EXPON until zero
( (ZEROP EXPON) RESULT) ; NOTE NO BODY!! ) )
When variable EXPON is finally zero, return the result

39. The Do iteration The DO function
(do ( (<var1> [<init1> [<step1>]]) …
(<varn [<initn>[stepn>]]) )
(<end-pred><fn>…..<fm> <retobj >) ;; test
body-exp1
body-exp2
[<body>] )

40. Example of Do Countdown: prints numbers from max to 0
(defun iter (max)
(do ((num max (- num 1)))
; assign max to num ; subtract 1 from num in loop
((<= num 0) ‘end) ;; this is end condition.
(print num)))
(do ( (<var1> [<init1> [<step1>]]) …
(<varn [<initn>[stepn>]]) )
(<end-pred><fn>…..<fm> <retobj >) ;; test
body-exp1
body-exp2
[<body>] )

41. Another example of do Summing all integers from 0 up to max
(defun iter-sum (max)
(do ((num max (- num 1))
(sum 0 (+ sum num)))
((<= num 0) sum) ;;; test
;; no body )
In English: Assign max to number, and 0 to sum. Each time through the loop, subtract 1 from num and add sum to number. When Number is less than or equal to 0, return sum.
(do ( (<var1> [<init1> [<step1>]]) …
(<varn [<initn>[stepn>]]) )
(<end-pred><fn>…..<fm> <retobj >) ;; test
body-exp1
body-exp2
[<body>] )

42. Yet Another example of do
(defun reverse-list (ls)
( if (listp ls)
(do ( (new-ls () (cons (first old-ls) new-ls))
(old-ls ls (rest old-ls)) )
((null old-ls) new-ls) ) ) )
[user]: (reverse-list '( ))
( )
With do function, you probably don’t need a let --- because it’s in the do function.
(do ( (<var1> [<init1> [<step1>]]) …
(<varn [<initn>[stepn>]]) )
(<end-pred><fn>…..<fm> <retobj >) ;; test
body-exp1
body-exp2
[<body>] )

43. eval, apply and funcall

44. EVAL (100 X A) (EVAL <exp>) invokes the evaluation procedure.
> (EVAL (LIST ‘+ 4 5)) 9
> (SETQ A ‘X) X
> (SETQ X 100)
100
> (CONS (EVAL A) (CONS A ‘( A ) ) ) ?
Value of atom A is atom X
Value of atom X is 100
(100 X A)
Value of (EVAL A) is value of value of A which is value of atom X which is 100

45. Using EVAL to create fn at run-time
Create a function to recognize cups based on the description learned:
We define function create-cup-recognizer
(defun create-cup-recognizer ( cup-description )
(eval (list ‘defun ‘cup-recognizer ‘( obj )
(list ‘subset
(list ‘quote cup-description)
‘obj )
subset tests whether the first arg is a subset of the second arg.
> (create-cup-recognizer cup-def)
cup-recognizer
Which defines function cup-recognizer
eval actually creates the definition
(defun cup-recognizer (obj )
(subset (quote cup-description) obj)

46. What if we want to apply a function to an entire list?
(MAPCAR <fn-name> <arg1-list> <arg2-list>)
> (MAPCAR ‘+ ‘( ) ‘( ) )
( )
> (SETQ action ‘drunk)
DRUNK
> (SETQ hostile-guests (identify-enemy guests))
(MAPCAR action hostile-guests)
Write your own functions identify-enemy and action

47. APPLY (APPLY <fn-name> <arg-list> )
>(APPLY ‘CONS ‘( A ( B C ) ) )
(A B C)
> (APPLY ‘CAR ‘( (A B C) ) ) A
> (SETQ OP ‘+) +
> (APPLY OP ‘( 5 3 ) ) 8
> (SETQ OP ‘-) -
(APPLY OP ‘( 5 3 ) ) 2

48. A Better Example of APPLY
Suppose we want to ``do something’’ to an enemy identified, but the action is determined at run time (based on their actions, degree of threats, etc.).
(defun action (fn enemy) (APPLY fn (cons enemy nil) ) )
(defun seize (person) .... )
(defun kill (person) ... )
(defun drunk (person) ... )
> (action ‘seize ‘BlackKnight )

49. FUNCALL -- A sibling of APPLY
(FUNCALL <fn-name> <arg1> <arg2> ...)
>(FUNCALL ‘CONS ‘A ‘( B C ) )
(A B C)
> (FUNCALL ‘CAR ‘(A B C) ) A
> (SETQ OP ‘+) +
> (FUNCALL OP 5 3 ) 8
> (SETQ OP ‘-) -
> (FUNCALL OP )

50. Useful help facilities
(apropos ‘str)  list of symbols whose name contains ‘str
(describe ‘symbol)  description of symbol
(describe #’fn)  description of function
(trace fn)  print a trace of fn as it runs
:a  abort one level out of debugger

51. A Lisp example: Fibonacci Numbers
Writing a function to compute the nth Fibonacci number
Fibonacci sequence: 0, 1, 1, 2, 3, 5, 8, 13, …
fib(0) = 0
fib(1) = 1
fib(n) = fib(n-2) + fib(n-1)

52. Complete Version (defun fib (n) (cond ((eql n 0) 0) ; base case
(t (+ (fib (- n 1)) ; recursively compute fib(n)
(fib (- n 2))))))

53. Examples: Roulette Wheel
(DEFUN roulette-wheel (bet-1 bet-2)
(compare-with-bet (RANDOM 37) bet-1 bet-2))
(DEFUN compare-with-bet (wheel-spin bet-1 bet-2)
(IF (OR (= wheel-spin bet-1) (= wheel-spin bet-2))
(DISPLAY “You won! ”)
(DISPLAY “You lost! “))
wheel-spin)
(RANDOM X) is a built-in function that returns
a value between 0 and X
(compare-with-bet) returns wheel-spin as a
value (the last s-expression evaluated)

54. Examples: leap year, length
(DEFUN leap-year? (year)
(COND ((divisible? year 400) #t)
((divisible? year 100) #f)
((divisible? year 4) #t)
(ELSE #f)))
(DEFUN length list-of-objects)
(COND ((NULL list-of-objects) 0)
(ELSE (1+ (length (CDR list-of-objects)))))
Can use T or any atom

55. Examples (continued) (DEFUN maximum (list-nums)
(COND ((NULL (CDR list-nums))(CAR list-nums))
(ELSE (LET ((maxtail (maximum (CDR list-nums)))
(first (CAR list-nums)))
(IF (> first maxtail)
first
maxtail)))))
use recursion to find maximum value in CDR of list, compare
to first value in list - maximum is larger of those two

56. Examples (continued) (DEFUN inc-list (list-nums)
(COND ((NULL list-nums) NIL)
(ELSE (CONS (1+ (CAR list-nums))
(inc-list (CDR list-nums)) )
returns a new list containing all the values of the
argument list incremented by 1

57. Kathleen Swigger Ron Danielsen
Sources
Bruce R. Maxim
Kathleen Swigger
Ron Danielsen