anchor.diff:           (arguments (mapcar #'proxy-value argument-proxies))
            (expr
              (trivia:ematch (proxy-value operator-proxy)
  -             ((list 'quote function-name)
  +             ((list 'quote (list 'setf function-name))
  +              `(setf (,function-name ,@(rest arguments)) ,(first arguments)))
  +             ((list 'quote (and function-name (type symbol)))
                 `(,function-name ,@arguments))
  -             (value
  -              `(funcall ,value ,@arguments)))))
  +             (operator
  +              `(funcall ,operator ,@arguments)))))
       (ensure-proxy
        :level level
        :number-of-values number-of-values
  
positive.code:                     (start (proxy-value (ensure-proxy :expr `(range-start ,range) :name "START")))
                      (step (proxy-value (ensure-proxy :expr `(range-step ,range) :name "STEP")))
                      (end (proxy-value (ensure-proxy :expr `(range-end ,range) :name "END"))))
                 #+(or)
                 (ensure-proxy :expr `(print (list :range :axis ,axis :start ,start :step ,step :end ,end)))
                 (setf (svref wrap-in-loop-vector (1+ axis))
                       (if (eql info :contiguous)
                           (lambda (form)
  
negative.code:   (svref (proxy-values proxy) value-n))
  
  (defun proxy-ref (proxy &optional (value-n 0))
    (if (and (eql value-n 0)
             (eql (length (proxy-values proxy)) 1))
        proxy
        (make-proxy
         :level (proxy-level proxy)
         :values (vector (elt (proxy-values proxy) value-n))
         :expr `(nth-value ,value-n ,(proxy-expr proxy))
         :type `(values ,(nth (1+ value-n) (proxy-type proxy)) &optional))))
  
  (defun constant-proxy (form)
    (let ((value (if (constantp form) form `',form)))
  