anchor.diff:  (defvar *compiler-prims* (make-hash-table :test 'eq))
   (defun compiler-prim? (clutter-val)
     (nth-value 1 (gethash clutter-val *compiler-prims*)))
  -(defmacro def-compiler-prim (name env-var lambda-list &body body)
  +(defmacro def-compiler-primop (name env-var lambda-list &body body)
     `(setf (gethash (lookup (cs ,name)) *compiler-prims*) #'(lambda ,(cons env-var lambda-list) ,@body)))
  +(defmacro def-compiler-primfun (name lambda-list &body body)
  +  (let ((env-var (gensym "ENV"))
  +        (args (gensym "ARGS")))
  +   `(setf (gethash (lookup (cs ,name)) *compiler-prims*)
  +          #'(lambda (,env-var &rest ,args)
  +              (apply (lambda ,lambda-list ,@body) (mapcar (rcurry #'compile-form ,env-var)
  +                                                          ,args))))))
   
   (defun build-prim-call (prim args env)
     (let ((primbuilder (gethash prim *compiler-prims*)))
  
positive.code:         (apply primbuilder env args)
          (error "Unsupported primitive: ~A" prim))))
  
  (defun build-arith-op (name identity func args env)
    (reduce (rcurry (curry #'funcall func *builder*) name)
            args
            :key (rcurry #'compile-form env)
            :initial-value identity))
  
  ;;; Control
  (def-compiler-prim "if" env (condition true-form false-form)
    (let* ((prev-block (llvm:insertion-block *builder*))
           (func (llvm:basic-block-parent prev-block))
           (true-block (llvm:append-basic-block func "if-true"))
  
negative.code: (defun clone-env-tree (env)
    (let ((result (apply #'make-env (mapcar #'clone-env-tree (env-parents env)))))
      (mapenv (lambda (symbol value)
                (cond
                  ((compiler-prim? value)
                   (extend result symbol (split-val (combiner-name value) value)))
                  ((primitive? value)
                   ;; (warn "Unsupported primitive: ~A" value)
                   )
                  (t (extend result symbol (split-val nil value)))))
              env)
      result))
  
  