anchor.diff:  (defun transpiler-can-import? (tr name)
     (& (transpiler-import-from-environment? tr)
        (function? (symbol-function name))
  +     (not (builtin? name))
        (not (transpiler-defined? tr name))))
   	
   (defun transpiler-add-wanted-function (tr x)
  
positive.code:         (transpiler-import-exported-closures tr))))
  
  (defun transpiler-import-wanted-function (tr x)
    (unless (transpiler-defined-function tr x)
      (let fun (symbol-function x)
        (transpiler-frontend tr `((defun ,x ,(transpiler-host-function-arguments tr x)
                                   ,@(function-body fun)))))))
  
  (defun transpiler-import-wanted-functions (tr)
    (with-queue q
      (awhile (pop (transpiler-wanted-functions tr))
              nil
        (awhen (transpiler-import-wanted-function tr !)
          (enqueue q !)))
      (apply #'+ (queue-list q))))
  
  (defun transpiler-import-wanted-variables (tr)
  
negative.code: 	          (transpiler-wanted-variables tr))))
  
  (defun transpiler-import-from-environment (tr)
    (with (funs     (transpiler-import-wanted-functions tr)
           exported (transpiler-import-exported-closures tr)
           vars     (transpiler-import-wanted-variables tr))
      (? (| funs exported vars)
         (+ funs exported vars (transpiler-import-from-environment tr))
         (transpiler-delayed-var-inits tr))))
  