anchor.diff:    "Let but doesn't require parens for each binding"
     `(let ,(pair parms) ,@body))
   
  -(mac lets (var val &body body)
  +(mac let1 (var val &body body)
     "Let but with only one variable (no parens)"
     `(let ((,var ,val)) ,@body))
   
   (mac ret (var val &body body)
  -  "Lets but the result of the expression is the final value of the variable"
  -  `(lets ,var ,val ,@body ,var))
  +  "Let1 but the result of the expression is the final value of the variable"
  +  `(let1 ,var ,val ,@body ,var))
   
  -(mac flets (name args fbody &body body)
  +(mac flet1 (name args fbody &body body)
     "Flet but with only one binding (no parens)"
     `(flet ((,name ,args ,fbody)) ,@body))
   
  
positive.code:       `(with ,(mappend (fn (n) `(,n (uniq (symbol-name ',n))))
  		       names)
  	 ,@body)
        `(lets ,names (uniq (symbol-name ',names)) ,@body))) ; want to add better way to convert from symbol
  
  (mac lflet (var expr &body branches)
    "Same as lf but if a predicate is true, it is bound to var"
    (lf branches
        (w/uniq gv
  	`(lets ,gv ,expr
  	   (lf ,gv
  	       (lets ,var ,gv
  		 ,(car branches))
  	       ,(lf (cdr branches)
  		    `(lflet ,var ,@(cdr branches))))))
  
negative.code: 
  (mac awhen (expr &body body)
     "Analog of alf but for when"
    `(let1 it ,expr (lf it (progn ,@body)))) ; change name of progn
  
  (mac aand (&rest args)
    "Evaluates each argument one by one. Binds the result of the previous
  