anchor.diff:  			     (apply restfun args))))))
   
   (def andf (f &rest fns)
  -  "Returns a predicate function which returns true when all of the
  -   functions passed in as arguments would return true"
  +  "Returns a function which lazily applies each function in sequence
  +   and returns whatever the last function would return if all of the
  +   other functions return non-nil. For example 
  +
  +   (andf #'integerp #'even #'1+) 
  +
  +   will return a function which increments even integers, and
  +   returns nil for anything else."
     (if (null fns)
         f
         (let chain (apply #'andf fns)
  
positive.code: 	  (and (apply f args) (apply chain args))))))
  
  (def orf (f &rest fns)
    "Returns a predicate function which returns true when any of the
     functions passed in as arguments would return true"
    (if (null fns)
        f
        (let chain (apply #'orf fns)
  	(fn (&rest args)
  	  (or (apply f args) (apply chain args))))))
  
  (def curry (f &rest args1)
    "Returns a function with its left most arguments passed in and 
     waiting for the rest"
    (fn (&rest args2) (apply f (append args1 args2))))
  
  (def rcurry (f &rest args1)
    "Returns a function with its right most arguments passed in and
     waiting for the rest"
    (fn (&rest args2) (apply f (append args2 args1))))
  
negative.code: ;;;; These are utilities for working with functions.
  
  (in-package :clamp)
  
  (def compose (&rest fns)
    "Composes functions. For example 
  
     (compose #'1+ #'length) 
  
     will return a function which returns one plus the length of a 
     list."
    (if fns
        (with (fn1 (last1 fns)
  	     fns (butlast fns))
  