anchor.diff:                                              :initial-contents (mapcar (rcurry #'compile-form env)
                                                                         (rest form)))
                                   "")))))))
  -
  -(defun compile-func (split env)
  -  (let* ((op (clutter-function-operator (split-val-clutter split)))
  -         (args (clutter-operator-args op))
  -         (argtypes (make-array (length args) :initial-element (llvm:int32-type)))
  -         (ftype (llvm:function-type (llvm:int32-type) argtypes))
  -         (fobj (llvm:add-function *module* (clutter-symbol-name (clutter-operator-name op)) ftype))
  -         (fenv (make-env env)))
  -    (setf (split-val-llvm split) fobj)
  -    (llvm:position-builder-at-end *builder*
  -                                  (llvm:append-basic-block fobj "entry"))
  -    (mapc (lambda (arg name)
  -            (setf (llvm:value-name arg) (clutter-symbol-name name))
  -            (extend fenv name
  -                    (split-val (llvm:build-alloca *builder* (llvm:type-of arg) (clutter-symbol-name name))
  -                               nil))
  -            (llvm:build-store *builder* arg (split-val-llvm (lookup name fenv))))
  -          (llvm:params fobj)
  -          args)
  -    (let ((ret))
  -      (mapc (compose (lambda (x) (setf ret x))
  -                     (rcurry #'compile-form fenv))
  -            (clutter-operator-body op))
  -      (llvm:build-ret *builder* (llvm:build-int-cast *builder* ret (llvm:int32-type) "ret")))))
   
   (defun clone-env-tree (env)
     (let ((result (apply #'make-env (mapcar #'clone-env-tree (env-parents env)))))
  
positive.code:     (llvm:position-builder-at-end *builder* continue-block)
      return-value))
  
  ;;; Arithmetic
  (defun build-arith-op (name initial func args)
    (reduce (rcurry (curry #'funcall func *builder*) name)
  
negative.code:   (build-arith-op "product" first #'llvm:build-s-div args))
  
  ;;; Arithmetic comparison
  (def-compiler-primfun "=?" (first &rest rest)
    (build-arith-op "equality" first
                    (lambda (b l r n) (llvm:build-i-cmp b := l r n))
                    rest))
  
  (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.
  