anchor.diff:  (in-package :serapeum)
   
   ;;;# `lret'
  +
  +(defmacro lret-aux (let (&rest bindings) &body body)
  +  (if (null bindings)
  +      `(,let ()
  +         ,@body)
  +      (multiple-value-bind (body decls)
  +          (parse-body body)
  +        (let ((last-binding (ensure-car (lastcar bindings))))
  +          `(,let ,bindings
  +             ,@decls
  +             (prog1 ,last-binding
  +               ,@body))))))
   
   (defmacro lret ((&rest bindings) &body body)
     "Return the initial value of the last binding in BINDINGS. The idea
  
positive.code: forgetting to return it).
  
  Cf. `aprog1' in Anaphora."
    (if (null bindings)
        `(let ()
           ,@body)
        (multiple-value-bind (body decls)
            (parse-body body)
          `(let ,bindings
             ,@decls
             (prog1 ,(ensure-car (lastcar bindings))
               ,@body)))))
  
  (defmacro lret* ((&rest bindings) &body body)
    "Cf. `lret'."
    (if (null bindings)
        `(let* ()
           ,@body)
        (multiple-value-bind (body decls)
            (parse-body body)
          `(let* ,bindings
             ,@decls
             (prog1 ,(ensure-car (lastcar bindings))
               ,@body)))))
  
  ;;;# `letrec'
  
  
negative.code: 
  Note that `letrec' only binds variables: it can define recursive
  functions, but can't bind them as functions. (But see `fbindrec'.)"
    `(letrec-with psetq ,bindings
       ,@body))
  
  (defmacro letrec* ((&rest bindings) &body body)
    "Like LETREC, but the bindings are evaluated in order.
  See Waddell et al., *Fixing Letrec* for motivation.
  
  Cf. `fbindrec*'."
    `(letrec-with setq ,bindings
       ,@body))
  
  (defmacro receive (formals expr &body body)
    "Stricter version of `multiple-value-bind'.
  