anchor.diff:  	   (and it (aand ,@(cdr args))))))
   
   (mac aif2 (&rest clauses)
  -  "aif but for working with functions that have multiple return values
  -   ie gethash. See On Lisp for examples"
  +  "Equivalent to aif, but will also execute the corresponding branch
  +   if the predicate has a second return value which is non-nil. This
  +   is useful for accessing hashtables."
     (w/uniq (val win)
       (if (null clauses)
             nil
  
positive.code: 		 (aif2 ,@rest)))))))
  
  (mac case (keyform &rest clauses)
    "Same as regular CL case except there are no parens around each pair."
    `(cl:case ,keyform ,@(group clauses)))
  
  (mac ccase (keyform &rest clauses)
    "Same as regular CL ccase except there are no parens around each pair."
    `(cl:ccase ,keyform ,@(group clauses)))
  
  (mac ecase (keyform &rest clauses)
    "Same as regular CL ecase except there are no parens around each pair."
    `(cl:ecase ,keyform ,@(group clauses)))
  
negative.code:       expr))
  
  (mac whenlet (var expr &body body)
    "If EXPR returns non-nil, bind that value to VAR and execute body."
    `(iflet ,var ,expr (do ,@body)))
  
  (mac aif (expr &body branches)
     "Equivalent to iflet but automatically binds EXPR to 'it'."
    `(iflet it ,expr ,@branches))
  
  (mac awhen (expr &body body)
     "Equivalent to whenlet but automatically binds the value of EXPR
      to 'it'."
    `(whenlet it ,expr ,@body))
  
  (mac aand (&rest args)
    "Equivalent to and, but binds the value of the previous expr to 
     'it'."
    (if (no args)
          t
        (no (cdr args))
  