anchor.diff: -;;;; these are different kinds of conditionals
  +;;;; These are utilities for conditional branching.
   
   (in-package :clamp)
   
   (mac iflet (var expr &body branches)
  -  "Same as if but if a predicate is true, it is bound to var"
  +  "Same as clamp:if but if a predicate is true, the value of predicate 
  +   is bound to VAR in the corresponding branch."
     (if branches
         (w/uniq gv
   	`(let ,gv ,expr
  
positive.code:       expr))
  
  (mac whenlet (var expr &body body)
    "Analog of iflet but for when"
    `(iflet ,var ,expr (do ,@body)))
  
  (mac aif (expr &body branches)
     "iflet but uses 'it' for var"
    `(iflet it ,expr ,@branches))
  
  (mac awhen (expr &body body)
     "Analog of aif but for when"
    `(whenlet it ,expr ,@body))
  
  (mac aand (&rest args)
    "Evaluates each argument one by one. Binds the result of the previous
     expression to 'it'. Otherwise the same as and"
    (if (no args)
          t
        (no (cdr args))
  
negative.code: 		 (aif2 ,@rest)))))))
  
  (mac case (keyform &rest clauses)
    "Equivalent to cl:case except there are no parens around each 
     clause."
    `(cl:case ,keyform ,@(group clauses)))
  
  (mac ccase (keyform &rest clauses)
    "Equivalent to cl:ccase except there are no parens around each
     clause."
    `(cl:ccase ,keyform ,@(group clauses)))
  
  (mac ecase (keyform &rest clauses)
    "Equivalent to cl:ecase except there are no parens around each
     clause."
    `(cl:ecase ,keyform ,@(group clauses)))
  