anchor.diff:  		    `(lflet ,var ,@(cdr branches))))))
         expr))
   
  -(mac whenlet (var expr &body body)
  +(defmacro whenlet (var expr &body body)
     "Analog of lflet but for when"
     `(lflet ,var ,expr (progn ,@body)))
   
  -(mac alf (expr &body branches)
  +(defmacro alf (expr &body branches)
      "lflet but uses 'it' for var"
     `(lflet it ,expr ,@branches))
   
  -(mac awhen (expr &body body)
  +(defmacro awhen (expr &body body)
      "Analog of alf but for when"
     `(whenlet it ,expr ,@body))
   
  -(mac aand (&rest args)
  +(defmacro aand (&rest args)
     "Evaluates each argument one by one. Binds the result of the previous
      expression to 'it'. Otherwise the same as and"
     (lf (no args)
  
positive.code: ;;;; these are different kinds of conditionals
  
  (mac lf (&body rest)
    "Cond but doesn't require parens for each clause"
    `(cond ,@(pair rest)))
  
  (mac check (x test &optional alt)
    "If x passes the test, otherwise evaluate alt"
    (w/uniq gx
      `(let1 ,gx ,x
  
negative.code: 	   ,gx
  	   ,alt))))
  
  (defmacro lflet (var expr &body branches)
    "Same as lf but if a predicate is true, it is bound to var"
    (lf branches
        (w/uniq gv
  