anchor.diff:  
   
   (defun+ def-dispatch-func (name init-func-name stage-keys context
  -                          primitive uniform-assigners)
  +                                primitive uniform-assigners static)
     (let* ((ctx *pipeline-body-context-var*)
            (uniform-names (mapcar #'first (aggregate-uniforms stage-keys)))
            (u-uploads (mapcar #'gen-uploaders-block uniform-assigners))
            (u-cleanup (mapcar #'gen-cleanup-block (reverse uniform-assigners)))
            (typed-uniforms (loop :for name :in uniform-names :collect
  -                            `(,name t nil))))
  +                            `(,name t nil)))
  +         (def (if static 'defn 'defun+))
  +         (signature (if static
  +                        `(((,ctx cepl-context)
  +                            (stream (or null buffer-stream))
  +                           ,@(when uniform-names `(&key ,@typed-uniforms)))
  +                          (values))
  +                        `((,ctx
  +                            stream
  +                            ,@(when uniform-names `(&key ,@uniform-names)))))))
       (values
        `(eval-when (:compile-toplevel :load-toplevel :execute)
           (define-compiler-macro ,name (&whole whole ,ctx &rest rest)
  
positive.code:        ',name)))
  
  (defun+ %def-complete-pipeline (name stage-keys stage-pairs aggregate-uniforms
                                 post context
                                 &optional suppress-compile)
    (let* ((uniform-assigners (mapcar #'make-arg-assigners aggregate-uniforms))
           ;; we generate the func that compiles & uploads the pipeline
           ;; and also populates the pipeline's local-vars
  
negative.code:   (defn use-program ((program-id gl-id)) gl-id
      (unless (= program-id program-cache)
        (%gl:use-program program-id)
        (setf program-cache program-id))
      program-id)
    (defn force-use-program ((program-id gl-id)) gl-id
      (%gl:use-program program-id)
      (setf program-cache program-id)))
  