anchor.diff: -(define (> a b)
     ;; Defines the greater-than operator
  -  (if (< a b) nil T))
  +(define (> a b) (if (< a b) nil T))
   (define (abs x) (if (< x 0) (- 0 x) x))
   (define (min x y) (if (> x y) y x))
   (define (max x y) (min y x))
  +(define (null? x) (eq? x nil))
  +(define (not a) (if a nil T))
   
  -;; This is probably not correct
  -(defmacro (set! a b)
  -  (define a b))
  +;;; List stuff
  +(define (first sx) (car sx))
  +(define (rest sx) (cdr sx))
   
  -(define (not a)
  -  (if a nil T))
  +(define (length list)
  +  (if (null list)
  +    0
  +    (+ 1 (length (rest list)))))
   
  +(define (list . items)
  +  (foldr cons nil items))
  +
  +(define (reverse list)
  +  (foldl (lambda (a x) (cons x a)) nil list))
  +
  +;;; Functional things
   (define (foldl proc init list)
     (if list
         (foldl proc
  
positive.code:     (car list)
      (nth (- pos 1) (cdr list))))
  
  (define (caar x) (car (car x)))
  (define (cadr x) (car (cdr x)))
  (define (cdar x) (cdr (car x)))
  (define (cddr x) (cdr (cdr x)))
  
  (define (macro-expand expr)
    (if (not (pair? expr))
  
negative.code:                     (list 'quasiquote (cdr x)))))
        (list 'quote x)))
  
  (defmacro (let defs . body)
    `((lambda ,(map car defs) ,@body)
      ,@(map cadr defs)))
  