anchor.diff:  					 side-effects-2))))))
   
   (define-bst-special-form ":="
  -    (let* ((var (pop-literal))
  -	   (value-mvform (pop-single-value-form t :need-variable nil)))
  +    (let ((var (pop-literal)))
         ;;(format t "var: ~S value: ~S~%" var value-form)
         (let* ((fun (get-bst-function var))
   	     (name (bst-function-name fun))
   	     assoc)
  -	(labels ((compute-side-effects (assigned-thing)
  +	(labels ((compute-side-effects (assigned-thing value-mvform)
   		   (max-side-effects
   		    (mvform-side-effects value-mvform)
   		    (make-instance 'side-effects
  
positive.code:       ;; the tested conditions to its liking.
  
        ;; First pass: compute the arity of both branches
        (multiple-value-bind (else-form else-arg-types)
  	  (bst-compile-literal else-literal ())
  	(declare (ignore else-form))
  ;;(format t "~&;; else-form ~S is ~S --> ~S~%" else-literal else-arg-types else-res-types)
  	(multiple-value-bind (then-form then-arg-types)
  	    (bst-compile-literal then-literal ())
  	  (declare (ignore then-form))
  ;;(format t "~&;; then-form ~S is ~S --> ~S~%" then-literal then-arg-types then-res-types)
  	  ;; Now we know the arity of both branches.  We compute the
  	  ;; arg types and fill up the shorter arg list.
  	  (let ((arg-types ()))
  
negative.code: 				   :unconditionally-assigned-variables (list assigned-thing)))))
  	  (cond
  	    ((setq assoc (assoc name *lexical-variables* :test 'string-equal))
  	     (let ((var-name (variable-name (cdr assoc)))
  		   (value-mvform (pop-single-value-form t :need-variable nil)))
  	       (push-mvform :form `(setq ,var-name
  				    ,(mvform-form value-mvform))
  			    :types ()
  			    :side-effects (compute-side-effects var-name value-mvform))))
  	    ((member (bst-function-name fun) *lexicals* :test 'string-equal)
  	     (let ((var (make-variable :name (bst-name-to-lisp-name name)
  				       :type (car (bst-function-result-types fun))))
  		   (value-mvform (pop-single-value-form t :need-variable nil :when-empty nil)))
  	       (if (not value-mvform)
  		   ;; We have an assignment of a freshly popped formal
  		   ;; argument to a lexical variable.  So simply use
  		   ;; the lexical variable as the formal argument.
  		   (push var *borrowed-variables*)
  		   ;; Make a lexical binding.
  		   (push (make-binding :variables (list var)
  				       :mvform value-mvform) *form-bindings*))
  	       (push (cons name var) *lexical-variables*)))
  	    (t
  	     (let* ((setter-form-maker (bst-function-setter-form-maker fun))
  		    (value-mvform (pop-single-value-form t :need-variable nil))
  		    (setter-form (funcall setter-form-maker (mvform-form value-mvform))))
  	       (push-mvform
  		:form setter-form :types ()
  		:side-effects (compute-side-effects name value-mvform)))))))))
  
  (defun get-bst-function (name)
    (let ((function (gethash (string name) *bst-functions*)))
  