anchor.diff: +  ;; C
  +  ;; C
     ;; Defines the greater-than operator
   (define (> a b) (if (< a b) nil T))
   (define (abs x) (if (< x 0) (- 0 x) x))
  
positive.code:     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)
  
negative.code:   (if (> 1 n)
      1
      (+ (fib (- n 1)) (fib (- n 2))))) 
  
  (define Y
    (lambda (h)
      ((lambda (x) (x x))
       (lambda (g)
         (h (lambda args (apply (g g) args)))))))
   
  (define facy
    (Y
      (lambda (f)
        (lambda (x)
          (if (< x 2)
              1
              (* x (f (- x 1))))))))
   
  (define fiby
    (Y
      (lambda (f)
        (lambda (x)
          (if (< x 2)
              x
              (+ (f (- x 1)) (f (- x 2))))))))
  
  (define (ceiling x) x)
  
  (define (merge-sort list)
    (if (small list) list
      (merge-lists
      (merge-sort (left-half list))
      (merge-sort (right-half list)))))
  
  (define (small list)
    (or (eq (length list) 0) (eq (length list) 1)))
  
  (define (right-half list)
    (last list (ceiling (/ (length list) 2))))
  
  (define (left-half list)
    (ldiff list (right-half list)))
  
  (define (merge-lists list1 list2)
    (merge 'list list1 list2 '<))
  