anchor.diff:    (with ((moved new-expr) (expex-filter-and-move-args (list ..x.)))
       (values moved `((%%go-nil ,.x. ,@new-expr)))))
   
  -(defun expex-expr-%=-0 (place val)
  -  (expex-import-variable place)
  -  (with ((moved new-expr) (expex-move-args (list val)))
  -    (values moved (expex-make-%= place new-expr.))))
  -
   (defun expex-expr-%= (x)
     (with-%= place val x
       (? (%=? val)
  -       (values nil (expex-body `(,val
  -                                 (%= ,place ,(%=-place val)))))
  -       (expex-expr-%=-0 place val))))
  +       (return (values nil (expex-body `(,val
  +                                         (%= ,place ,(%=-place val)))))))
  +    (expex-import-variable place)
  +    (with ((moved new-expr) (expex-move-args (list val)))
  +      (values moved (expex-make-%= place new-expr.)))))
   
   (defun expex-expr-std (x)
     (expex-import-function x)
  
positive.code:   (| (funinfo-get-local-function-args *funinfo* fun)
       (transpiler-function-arguments *transpiler* fun)))
  
  (defun expex-argexpand-0 (fun args)
    (expand-literal-characters
        (? (defined-function fun)
           (argument-expand-values-compiled fun (expex-argdef fun) args)
           args)))
  
  (defun expex-argexpand (x)
    (with (new?   (%new? x)
  		 fun    (? new? .x. x.)
  		 args   (? new? ..x .x)
  	     eargs  (expex-argexpand-0 fun args))
  	`(,@(& new? '(%new)) ,fun ,@eargs)))
  
  
  ;;;;; MOVING SINGLE ARGUMENTS
  
  (defun expex-move-atom (x)
    (let s (expex-add-var)
      (. (expex-make-%= s x) s)))
  
  (defun expex-move-inline (x)
    (with ((p a) (expex-move-args x))
  
negative.code:                                                    val)))))
  
  (defun expex-add-var ()
    (funinfo-var-add *funinfo* (expex-sym)))
  
  
  ;;;; PREDICATES
  