anchor.diff:      (if primbuilder
           (apply primbuilder env args)
           (error "Unsupported primitive: ~A" prim))))
  +
  +;;; Special
  +;(def-compiler-primfun "unwrap" )
   
   ;;; Control
   (def-compiler-primop "if" env (condition true-form false-form)
  
positive.code: 
  (defun compile-form (form env)
    (typecase form
      (integer (llvm:const-int (llvm:int32-type) form))
      (clutter-symbol (llvm:build-load *builder* (or (split-val-llvm (lookup form env)) (error "No binding for: ~A" form)) (clutter-symbol-name form)))
      (list
         (let ((cfunc (if (listp (car form))
                          (compile-form (car form) env)
                          (lookup (car form) env))))
           (if (compiler-prim? (split-val-clutter cfunc))
               (build-prim-call (split-val-clutter cfunc) (rest form) env)
               (progn
                 ;; Ensure that the function has been compiled.
                 ;; TODO: Ensure that *the relevant specialization* has been.
                 (unless (split-val-llvm cfunc)
                   (setf (split-val-llvm cfunc)
                         (compile-func (split-val-clutter cfunc) env)))
                 (llvm:build-call *builder* (split-val-llvm cfunc)
                                  (make-array (length (rest form))
                                              :initial-contents (mapcar (rcurry #'compile-form env)
                                                                        (rest form)))
                                  "")))))))
  
  (defun clone-env-tree (env)
    (let ((result (apply #'make-env (mapcar #'clone-env-tree (env-parents env)))))
  
negative.code:   (setf *builder* (llvm:make-builder))
    (unwind-protect
         (let ((env (clone-env-tree interp-env)))
           (let ((*toplevel* t))
             (compile-form form env))
           (llvm:dump-module *module*)
           (unless (llvm:verify-module *module*)
             (llvm:write-bitcode-to-file *module* output)))
  