anchor.diff:    (prog1 (apply #'pr args)
            (terpri)))
   
  +
   (def firstn (n xs)
     "Evaluates to the first n elements of the list xs"
     (lf (no n)           xs
  
positive.code: ;;;; rewrite mac so it allows autouniq
  ;;;; break apart functions into groups and put them in seperate files
  ;;;;   (ie iteration, higher-order-functions, etc)
  
  (mac lf (&body rest)
    "Cond but doesn't require parens for each clause"
  
negative.code: (def bestn (n f seq)
    "Finds the first n elements of seq if it was sorted using f"
    (firstn n (sort seq f)))
  
  (def last1 (xs)
    (car (last xs)))
  
  (def compose (&rest fns)
    "Composes the arguments which are functions"
    (lf fns
        (with (fn1 (last1 fns)
  	     fns (butlast fns))
  	(fn (&rest args)
  	  (reduce #'funcall fns
  		  :from-end t
  		  :initial-value (apply fn1 args))))
        #'identity))
  
  (def flf (&rest funs)
    "Returns a function which applies each 'test' in sequence
     and if it passes the test calls the next function"
    (case (len funs)
      (0 #'identity)
      (1 (car funs))
      (t (withs ((test fun . rest) funs
  	       restfun (apply #'flf rest))
  	 (fn (&rest a) (lf (apply test a) (apply fun a)
  			   (apply restfun a)))))))
  
  (def andf (fn &rest fns)
    "Returns a predicate function which returns true when all of the
     functions passed in as arguments would return true"
    (lf (null fns)
        fn
        (let1 chain (apply #'andf fns)
  	(fn (x)
  	  (and (funcall fn x) (funcall chain x))))))
  
  (def orf (fn &rest fns)
    "Returns a predicate function which returns true when any of the
     functions passed in as arguments would return true"
    (lf (null fns)
        fn
        (let1 chain (apply #'orf fns)
  	(fn (x)
  	  (or (funcall fn x) (funcall chain x))))))
  
  
  