anchor.diff:  
   ;; Usage: (when (< x 2) (set! x 2)) ??
   (defmacro (when condition . body)
  -    `(if ,condition (progn ,@body) nil))
  +    `(if ,condition
  +       (progn ,@body)
  +       nil))
   
   (defmacro (unless condition . body)
  -    `(if ,condition nil (progn ,@body)))
  -
  -(defmacro (cond condition . body)
  -    `(if ,condition nil (progn ,@body)))
  +    `(if ,condition 
  +       nil 
  +       (progn ,@body)))
  +
  +(defmacro (cond-list clauses)
  +    (clauses))
  +
  +;    `(if ,test 
  +;       (progn ,@forms)
  +;       (cond ,@(cdr clauses)))))
  +
  +(define (cond . clauses)
  +  (cond-list clauses))
  +
  +(defmacro (for-each fn seq)
  +  `(progn (map nil ,fn ,seq) t))
   
   (defmacro (and-list body)
     `(if ,body
  
positive.code:   ;; Defines the greater-than operator
  (define (> a b) (if (< a b) nil T))
  (define (abs x) (if (< x 0) (- 0 x) x))
  
negative.code:     0
      (+ 1 (length (rest list)))))
  
  (define (last list)
    (if (cdr list)
      (last (cdr list))
      (car list)))
  
  (define (list . items)
    (foldr cons nil items))
  
  (define (reverse list)
    (foldl (lambda (a x) (cons x a)) nil list))
  
  (defmacro (append . ls)
    `(foldr cons () ,@ls))
  
  (define (circular lst)
    (set! (cdr (last lst)) lst))
  
  (define (merge proc ls1 ls2 f)
    (foldr 
      (lambda(a b) 
        (if (f a b)
          (cons a b)
          (cons b a)))
      ls1 ls2))
  
  ;;; Functional things
  (define (foldl proc init list)
  