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:   (svref (proxy-values proxy) value-n))
  
  (defun proxy-ref (proxy &optional (value-n 0))
    (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)))
  
negative.code:                    for instruction-number from 0
                     do (setf (svref *instructions* instruction-number)
                              (translate-instruction instruction-number)))
               ;; Finally, convert the proxies of each level to suitable
               ;; bindings and apply the loop wrappers.
               `(lambda (.kernel. .iteration-space. &optional (.buffer-storage. #'buffer-storage))
  