anchor.diff:           collect (cons name (walk-form `(lambda ,args ,@body) flet env)) into bindings
            finally (setf (binds flet) bindings))
         ;;;; walk the body in the new env
  -      (setf (body flet) (walk-implict-progn flet
  -                                            body
  -                                            (loop
  -                                               with env = env
  -                                               for (name . lambda) in (binds flet)
  -                                               do (setf env (register env :flet name lambda))
  -                                               finally (return env))
  -                                            :declare t)))))
  +      (multiple-value-setf ((body flet) nil (declares flet))
  +			   (walk-implict-progn flet
  +					       body
  +					       (loop
  +						  with env = env
  +						  for (name . lambda) in (binds flet)
  +						  do (setf env (register env :flet name lambda))
  +						  finally (return env))
  +					       :declare t)))))
   
   (defwalker-handler labels (form parent env)
     (destructuring-bind (binds &body body)
  
positive.code: 
  ;;;; FLET/LABELS
  
  (defclass function-binding-form (form binding-form-mixin implicit-progn-mixin)
    ())
  
  (defclass flet-form (function-binding-form)
  
negative.code: (defclass implicit-progn-mixin ()
    ((body :accessor body :initarg :body)))
  
  (defclass implicit-progn-with-declare-mixin (implicit-progn-mixin)
    ((declares :accessor declares :initarg :declares)))
  
  (defclass binding-form-mixin ()
    ((binds :accessor binds :initarg :binds)))
  
  (defmacro multiple-value-setf (places form)
    (let ((names (loop for place in places collect (gensym))))
      `(multiple-value-bind ,names ,form
         ,@(loop for name in names for place in places if (null place) collect `(declare (ignore ,name)))
  	 (setf ,@(loop
  		    for name in names
  		    for place in places
  		    if place collect place
  		    if place collect name)))))
  
  (defun split-body (body env &key (docstring t) (declare t))
    (let ((documentation nil) 
  	(decl nil)
  	(decls nil))
      (flet ((done ()
               (return-from split-body (values body env documentation decls))))
        (loop
           for form = (car body)
           while body
  