Download Lisp slides

CS 63
LISP
Philip Greenspun's Tenth* Rule of Programming:
"Any sufficiently complicated C or Fortran
program contains an ad-hoc, informally-specified
bug-ridden slow implementation of half of
Common Lisp.“
* Note: there aren’t actually nine other rules, just the tenth one.
Something I stumbled across…
“…teaching Lisp by showing
you how to write several
complete Lisp-based
games, including a text
adventure, an evolution
simulation, and a robot
battle.”
Disclaimer: I’m not endorsing
this book, I just liked the
cover.
Why Lisp?
• Because it’s the most widely used AI
programming language
• Because it’s good for writing production
software (Graham article)
• Because it’s got lots of features other
languages don’t
• Because you can write new programs and
extend old programs really, really quickly in
Lisp
Great! How can I get started?
• Run /usr/bin/clisp
• From http://clisp.cons.org you can
download CLISP for your own PC
(Windows or Linux)
• Great Lisp resource page:
http://www.apl.jhu.edu/~hall/lisp.html
Why all those parentheses?
• Surprisingly readable if you indent properly (use
built-in Lisp editor in emacs!)
• Makes prefix notation manageable
• An expression is an expression is an expression,
whether it’s inside another one or not
• (+ 1 2)
• (* (+ 1 2) 3)
• (list (* 3 5) ‘atom ‘(list inside a list)
(list 3 4) ‘(((very) (very) (very) (nested
list))))
Lisp basics
• Lisp syntax: parenthesized prefix notation
• Lisp interpreter: read-eval-print loop
• Nested evaluation
• Preventing evaluation (quote and other
special forms)
• Forcing evaluation (eval)
–Allows us to evaluate code contained in a Lisp
variable!
Basic Lisp types
• Numbers (integers, floating-point, complex)
–27 -2 7.519
• Characters, strings (arrays of chars)
–#\x #\- #\B
–“This is a string!”
• Symbols, which have property lists
–‘a ‘x ‘jon
• Lists (linked cells)
– Empty list: nil
–‘(a b c)
‘(2 3 jon)
– cons structure has car (first) and cdr (rest)
Built-in functions
• For numbers
– + - * / incf decf
• A diversion: destructive functions
– (setf x 1)
– (setf y (+ x 1)) vs. (setf y (incf x))
• For lists
– car (first) cdr (rest)
fourth
– length nth
– cons append nconc list
– mapcar mapcan
– find remove remove-if
second
third
Built-in functions (cont’d)
• Printing: print, format
– (print “string”)  print output
– (format …)  formatted output
• Advanced list processing: assoc, mapcar
• Predicates: listp, numberp, stringp,
atom, null, equal, eql, and, or, not
• Special forms: setq/setf, quote, defun,
defparameter, defconstant, if, cond,
case, progn, loop
More Lisp types
• Arrays (with zero or more dimensions)
• Hash tables
• Streams (for reading and writing)
• Structures
• Functions, including lambda functions
–(defun incBy10 (n) (+ n 10))
–(mapcar #’(lambda (n) (+ n 10))
‘(1 2 3 4 5))
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
A Lisp example
• 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)
Complete Version
(defun fib (n)
(cond ((eql n 0)
((eql n 1)
(t (+ (fib
(fib
0)
; base case
1)
; base case
(- n 1)) ; recursively compute fib(n)
(- n 2))))))
Complete Version with Error
Checking and Comments
(defun fib (n)
"Computes the nth Fibonacci number."
(cond ((or (not (integerp n)) (< n 0)) ; error case
(error "~s must be an integer >= 0.~&" n))
((eql n 0) 0)
; base case
((eql n 1) 1)
; base case
(t (+ (fib (- n 1)) ; recursively compute fib(n)
(fib (- n 2))))))
Now you’ve been enlightened!
…well, sort of…
Cartoon from xkcd.com