anchor.diff:  
   (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))))
  +       (let ((cfunc (if (clutter-symbol-p (car form))
  +                        (lookup (car form) env)
  +                        (compile-form (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)
  +               ;; TODO: Ensure that *the relevant specialization* has been compiled.
  +               (llvm:build-call *builder* (or (split-val-llvm cfunc)
  +                                              (error "Undefined combiner: ~A" (car form)))
                                   (make-array (length (rest form))
                                               :initial-contents (mapcar (rcurry #'compile-form env)
                                                                         (rest form)))
  -                                "")))))))
  +                                "")))))
  +    (integer (llvm:const-int (llvm:int32-type) form))
  +    (t form)))
   
   (defun clone-env-tree (env)
     (let ((result (apply #'make-env (mapcar #'clone-env-tree (env-parents env)))))
  
positive.code:     (if primbuilder
          (apply primbuilder env args)
          (error "Unsupported primitive: ~A" prim))))
  
  ;;; Control
  (def-compiler-primop "if" env (condition true-form false-form)
  
negative.code:     return-value))
  
  (def-compiler-primop "lambda" env (vau-list &rest body)
    (let* ((*toplevel* nil)
           (argtypes (make-array (length vau-list) :initial-element (llvm:int32-type)))
           (ftype (llvm:function-type (llvm:int32-type) argtypes))
           (fobj (llvm:add-function *module* "lambda" ftype))
           (fenv (make-env env)))
  