Zhao Wei

• defun
  
• defmacro
  
• defvar
  
• defparameter
  
• defconstant
  
• defstruct
  

It is poor style to use and and or for anything other than testing a logical condition. Use when, unless, if if possible.

• when
  
• unless
  
• and
  
• or
  
• case
  

• setf
  

  (setf (rest list) nil)
  

• let
  

• let*
  

  (let* ((x 6)
         (y (* x x)))
    (+ x y))
  

• treat list as stack: pop, push
  
• (incf x) = (incf x 1) = (setf x (+ x 1))
  
• (decf x) = (decf x 1) = (setf x (- x 1))
  

• dolist
  
• dotimes
  
• do, do*
  
• loop
  
• mapc, mapcar
  
• some, every
  
• find, reduce, remove
  
• member
  
• count
  
• delete
  
• position
  
• substitute
  
• recursion
  

• progn, can be used to evaluate a sequence of forms and return the value of the last one.
  Not used very much, probably only needed in 3 places
  
• 'x for (quote x)
  
• #'f for (function f)
  
• trace and untrace
  
• return can be used to break out of a block of code
  

4 steps to write macro:

1. Decide if the macro is really necesary.
   
2. Write down the syntax of the macro.
   
3. Figure out what the macro should expand into.
   
4. Use defmacro to implement the syntax/expansion correspondence.
   

A backquote indicates that what follows is mostly a literal expression but may contain some components that are to be evaluated. Anything marked by a leading comma , is evaluated and inserted into the structure. And anything marked with a leading ,@ must evaluated to a list that is spliced into the structure: each element of the list is inserted, without the top-level parameters.

(setf test1 '(a test))

`(this is ,test1)
`(this is ,@test1)
`(this is . ,test1)
;; In the middle of a list, only ,@ is a possibility.
`(this is ,@test1 -- this is only ,@test1)

(cons a b)

1. When b is not a list. The result is an object x such that (first x) => a and (rest x) => b and where x prints as (a . b).
   
2. When b is a list, the usual list notation is used for output rather than the dotted pair notation.
   

Either notation can be used for input.

A cons cell is a data structure with two fields: a first and a rest. All proper lists have a last cons cell whose rest field is nil.

The association list (a-list) is a type of list used to implement tables. An association list is a list of dotted pairs, where each pair consists of a key and a value.

(setf state-table
      '((AL . Alabama) (AK . Alaska) (AZ . Arizona) (AR . Arkansas)))

(assoc 'AK state-table)
(rassoc 'Arizona state-table)

But, dotted pairs could also be normal list.

(setf state-table
      '((AL  Alabama) (AK  Alaska) (AZ  Arizona) (AR  Arkansas)))
(assoc 'ar state-table)
;; this does work
(rassoc 'Arizona state-table)

Notice: Search the table by value rather than by key doesn’t work for normal list.

• make-hash-table
  
• gethash, retrieve the value associated with a given key.
  

A property list (p-list) is a list of alternating key/value pairs.
It is avoided because we have hash table.

• read, it is a complete lexical and syntactic parser. It is used to read and return a single lisp expression.
  
• read-char, read a single character
  
• read-line, read everything up to the next newline and returns it as a string.
  
• open
  
• with-open-stream
  

• print
  
• prin1
  
• princ
  
• write
  
• with-open-file
  
• terpri
  
• fresh-line
  
• format
  

(defun math-quiz (&optional (op '+) (range 100) (n 10))
  "Ask the user a series of math problems."
  (dotimes (i n)
    (problem (random range) op (random range))))

(math-quiz)
(math-quiz '+ 100 2)

Optional arguments are still position dependent.

(defun math-quiz (&key (op '+) (range 100) (n 10))
  "Ask the user a series of math problems."
  (dotimes (i n)
    (problem (random range) op (random range))))

(math-quiz :n 5)
(math-quiz :op '+ :n 5 :range 100)

• A symbol starting with a : is called a keyword.
  
• Keywords are constant, and cannot be used as names of variables.
  

• Key vs optional parameters
  

  key	optional
  (math-quiz :op ’+ :n 5 :range 100)	(math-quiz ’+ 100 2)
  not fixed order (very useful)	fixed order

  • Notice: &rest are used to collect a variable number of arguments. Usually, it is used after &key or optional parameters.
    
• Among the build-in functions, there are two common group of keywords:
  

  1. :test, test-not, key, for matching functions. Including
     

     • sublis
       
     • position
       
     • subst
       
     • union
       
     • intersection
       
     • set-difference
       
     • remove
       
     • remove-if
       
     • subsetp
       
     • assoc
       
     • find
       
     • member
       

     Notice: :key is used to provider a selector function such that the comparison could be make against some part of the object.
     

  2. :start, :end, :from-end, for sequence functions. Including
     
     • remove
       
     • remove-if
       
     • position
       
     • find
       

• Example of keyword parameter, find-all which find all the items matching a condition in the list.
  

  (defun find-all (item sequence &rest keyword-args
                                 &key (test #'eql) test-not &allow-other-keys)
    "Find all those elements of sequence that match item,
    according to the keywords.  Doesn't alter sequence."
    (if test-not
        (apply #'remove item sequence
               :test-not (complement test-not) keyword-args)
        (apply #'remove item sequence
               :test (complement test) keyword-args)))
  
  (find-all 1 '(1 2 3 1 1 2 3 4 5))
  
  (remove 3 '(1 2 3 4 5 6) :test #'>)
  (remove 3 '(1 2 3 4 5 6) :test #'<=)
  
  ;; #'> 's complement
  (remove 3 '(1 2 3 4 5 6) :test #'(lambda (&rest args)
                                     (not (apply #'> args))))