Advantages of Lisp 

 Recursion: A program can call itself as a subroutine. Dynamic type

checking makes recursion more useful.
 Garbage Collection: automatically recycles memory.
 Uniform Representation: Programs and data are the same.
o Programs can examine other programs.
o Programs can write programs.
o Programs can modify themselves (learn).
o Data structures can contain programs; programs can contain data
structures.
 Interaction: User can combine program writing, compilation, testing,
debugging, running in a single interactive session.

Lisp Code 

Lisp code is based on a few simple rules:

 Parentheses enclose a function name and its arguments: (sqrt x)

 All operations are done by function calls: (+ x y)
 The assignment operator is called setq: 
(setq area (* pi (expt radius 2)))
 Every function call returns a value.

 (defun abs (x)
 (if (> = x 0)
 x
 (- x)))
 Local variables are declared by a let: 
(let (x y) (setq x 3) ... )
 Quick Lisp 

 int myfn (a, b) (defun myfn (a b)
 { int i = 3; float x; (let ((i 3) x)
 ... } ... ))

 { statement; ... } (progn statement ... )

 i = j + 2; (setq i (+ j 2))

 sqrt(x) (sqrt x)

 if ( i > j j > k ) (if (and (> i j)
 (> j k))
 statement1 statement1
  else statement2; statement2)

 for (i=0; i< n; i++) ... (dotimes (i n) ...)

 while ( i < n ) statement; (while (< i n)
 statements)

 printf("%d\n", i); (print i)
Lisp Data 

 Symbols may contain letters, numerals, and some special characters + - * / @

$ % ^ & _ < > ~ . ?

 MASS CS343 WIDGET-ALIGNMENT-SCREW ?X
 Numbers: floating-point, complex, integer (including bignums or big numbers),
rational: 1/3.
 Atoms include symbols and numbers.
 S-expressions (symbolic expressions) are defined recursively as follows:
o An atom is an S-expression.
o If x1 ... xn are S-expressions, then (x1 ... xn ), called a list of x1 ... xn, is an
S-expression.

 ONTOGENY
 (THIS IS A LIST)
 (* PI (EXPT R 2))
 (ALL X (IF (HUMAN X) (MORTAL X)))
 () ((())) ((()())())
The empty list () is equivalent to the symbol NIL.

Variable Values in Lisp 

We can think of a symbol as a data structure that includes a value cell containing

a pointer to the value of the atom. The value of the symbol can be set using the
function SET:

(SET 'PRESIDENT 'JEFFERSON)

If we now evaluate PRESIDENT, we get the value JEFFERSON.

Since the first argument of SET is usually quoted, there is a special function SETQ that
does this automatically.

(SETQ PRESIDENT 'JEFFERSON)

(SETQ RADIUS 5.0)

(* PI (EXPT RADIUS 2))
Combinations of CAR and CDR 

Since combinations of CAR and CDR are frequently used, all combinations up to four

uses of CAR and CDR are defined as functions of the form CxxxR:

(CAAR X) = (CAR (CAR X))

(CADR X) = (CAR (CDR X))

(CADDR X) = (CAR (CDR (CDR X)))

It's worth memorizing common combinations:

CAR or FIRST = First element of a list

CADR or SECOND = Second element
CADDR or THIRD = Third element
CADDDR or FOURTH = Fourth element

Functions FIRST through TENTH are defined in Common Lisp.

List Manipulation Functions 

APPEND makes a new list consisting of the members of its argument lists. APPEND takes

any number of arguments.

(APPEND '(A) '(B)) = (A B)

(APPEND '(A B) '(C D)) = (A B C D)

(APPEND '(A) '(B) '(C)) = (A B C)

REVERSE makes a new list that is the reverse of the top level of the list given as its
argument.

(REVERSE '(A B)) = (B A)

(REVERSE '((A B)(C D))) = ((C D)(A B))

LENGTH returns the length of the top level of the list given as its argument.
(LENGTH '(A)) = 1
(LENGTH '(A B)) = 2
(LENGTH '((A B))) = 1
Constructing List Structure 

The basic function that constructs new list structure is the function CONS.

If Y is a list, then we can think of (CONS X Y) as adding the new element X to the front
of the list Y.

(CONS 'A '(B)) = (A B)

(CONS 'A NIL) = (A)

(CONS 'A '()) = (A)

(CONS '(A) '(B)) = ((A) B)

(CONS 'A 'B) = (A . B)

The following axioms always hold:

1. (CAR (CONS x y)) = x

2. (CDR (CONS x y)) = y