anchor.diff:  
   (defun expex-move-args (x)
     (with ((moved new-expr) (assoc-splice (@ #'expex-move (expex-guest-filter-arguments x))))
  -    (values (apply #'append moved) new-expr)))
  +    (values (apply #'+ moved) new-expr)))
   
   
   ;;;; EXPRESSION EXPANSION
  
positive.code: 
  (defun expex-argexpand (x)
    (with (new?   (%new? x)
  		 fun    (? new? .x. x.)
  		 args   (? new? ..x .x)
  	     eargs  (? (defined-function fun)
                     (compiled-arguments fun (expex-argdef fun) args)
                     args))
  	`(,@(& new? '(%new)) ,fun ,@(expand-literal-characters eargs))))
  
  
  ;;;;; MOVING ARGUMENTS
  
  (defun expex-move-inline (x)
    (with ((moved new-expr) (expex-move-args x))
  	(. moved new-expr)))
  
  (defun expex-move-%%block (x)
    (!? (%%block-body x)
        (let s (expex-add-var)
          (. (expex-body ! s) s))
  	  (. nil nil)))
  
  (defun expex-move-std (x)
    (with (s                 (expex-add-var)
           (moved new-expr)  (expex-expr x))
      (. (append moved
                 (? (has-return-value? new-expr.)
                    (make-%= s new-expr.)
                    new-expr))
         s)))
  
  (defun expex-inlinable? (x)
  
negative.code:   (expex-guest-filter-setter `(%= ,p ,(? (%=? v)
                                           (%=-place v)
                                           v))))
  
  (define-gensym-generator expex-sym e)
  
  (defun expex-add-var ()
    (funinfo-var-add *funinfo* (expex-sym)))
  