anchor.diff:  (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))
  +  (let ((documentation nil) 
  +	(decl nil)
  +	(decls nil))
       (flet ((done ()
  -             (return-from split-body (values body env documentation))))
  +             (return-from split-body (values body env documentation decls))))
         (loop
            for form = (car body)
            while body
  
positive.code:          (extend-env (var (rest arguments)) var `(type ,(first arguments))))
          (t
           (extend-env (var arguments) var `(type ,type))))))
    environment)
  
  (defun walk-implict-progn (parent forms env &key docstring declare)
    (multiple-value-bind (body env docstring)
        (split-body forms env :docstring docstring :declare declare)
      (values (mapcar (lambda (form)
                        (walk-form form parent env))
                      body)
              docstring)))
  
  ;;;; Atoms
  
  
negative.code: (defclass function-form (form)
    ())
  
  (defclass lambda-function-form (function-form implicit-progn-with-declare-mixin)
    ((arguments :accessor arguments :initarg :arguments)))
  
  (defclass function-object-form (form)
  