anchor.diff:  (defun clone-env-tree (env)
     (let ((result (apply #'make-env (mapcar #'clone-env-tree (env-parents env)))))
       (mapenv (lambda (symbol value)
  -              (if (compiler-prim? value)
  -                  (extend result symbol (split-val (combiner-name value) value))
  -                  (extend result symbol (split-val nil 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))
   
  
positive.code: (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)
    `(setf (gethash (lookup (cs ,name)) *compiler-prims*) #'(lambda ,(cons env-var lambda-list) ,@body)))
  
  (defun build-prim-call (prim args env)
    (let ((primbuilder (gethash prim *compiler-prims*)))
  
negative.code:     return-value))
  
  ;;; Arithmetic
  (defun build-arith-op (name initial func args)
    (reduce (rcurry (curry #'funcall func *builder*) name)
            args
            :initial-value initial))
  (def-compiler-primfun "+" (first &rest args)
    (build-arith-op "sum" first #'llvm:build-add args))
  (def-compiler-primfun "-" (first &rest args)
    (if args
        (build-arith-op "difference" first #'llvm:build-sub (rest args))
        (llvm:build-neg *builder* first "negation")))
  (def-compiler-primfun "*" (first &rest args)
    (build-arith-op "product" first #'llvm:build-mul args))
  (def-compiler-primfun "/" (first &rest args)
    (build-arith-op "product" first #'llvm:build-s-div args))
  
  ;;; Arithmetic comparison
  (def-compiler-primfun "=?" (a b)
    (llvm:build-i-cmp *builder* := a b "equality"))
  
  (defun compile-form (form env)
    (typecase form
  