anchor.diff:  	((find-anywhere item (first tree)))
   	((find-anywhere item (rest tree)))))
   
  +;;we can probably generalize this.
  +;;we can probably also detect if it's in the
  +;;tail position.
  +(defun find-recur (tree)
  +  (progn ;(pprint tree)
  +    (cond ((atom tree) nil)
  +          ((listp tree)
  +           (case (first tree)
  +             (recur tree)
  +             ((fn loop lambda* lambda) nil)
  +             (t (cond ((find-recur (first tree)))
  +                      ((find-recur (rest tree))))))))))
  +
  +;;naive way to explode the body and search for a lexical recur form
  +(defun detect-recur (body)
  +  (find-recur (sb-cltl2:macroexpand-all body)))
   
   ;; Tail positions and recur targets
   ;; ---------------------------------+-------------------------------------------------------------------+---------------
  
positive.code: 
  
  (defun tail-children (expr)
    (case (first expr)
      ((lambda let let* flet labels)  (destructuring-bind (l binds &rest body) expr                
                                        (destructuring-bind (tail &rest xs) (reverse body)
                                          (cons (list :tail tail) (mapcar (lambda (x) (list :non-tail x)) xs)))))
      (progn   (destructuring-bind (l &rest body) expr                
                  (destructuring-bind (tail &rest xs) (reverse body)
                    (cons (list :tail tail) (mapcar (lambda (x) (list :non-tail x)) xs)))))
      (if       (destructuring-bind (i pred l &optional r) expr
                  (cons (list :tail l) (when r (list (list :tail r))))))
      (when     (destructuring-bind (i pred l) expr
                  (list (list :tail l))))
      ((case ecase ccase)    (destructuring-bind (l binds) expr                
                               (mapcar (lambda (lr)
                                         (list :tail (second lr))) binds)))
      ((or and) (destructuring-bind (l &rest body) expr                
                  (destructuring-bind (tail &rest xs) (reverse body)
                    (cons (list :tail tail) (mapcar (lambda (x) (list :non-tail x)) xs)))) )
      (defun     (destructuring-bind (l nm binds &optional docstring  &rest body) expr                
                   (destructuring-bind (tail &rest xs) (reverse body)
                     (cons (list :tail tail) (mapcar (lambda (x) (list :non-tail x)) xs))))) 
      ))
      ;;('with-recur     )
      ;;           
      ;;('if       )
      ;;('when     )
      ;;('or 'and  )
  ;;('case     )))
  
  (defun valid-tail     (expr))
  (defun valid-non-tail (expr))
  
  ;; (defun tail-call (form)
  ;;   (case (first form)
  ;;     (('lambda*        ) 
  ;;      ('with-recur     )
  ;;      ;('defun    )     
  ;;      ;('let 'flet 'labels)
  ;;      ('progn    )
  ;;      ('if       )
  ;;      ('when     )
  ;;      ('or 'and  )
  ;;      ('case     )
  ;;      )))
  
  ;;we can probably generalize this.
  ;;we can probably also detect if it's in the
  ;;tail position.
  (defun find-recur (tree)
    (progn ;(pprint tree)
           (cond ((atom tree) nil)
                 ((listp tree)
                  (case (first tree)
                    ('recur tree)
                    (('fn 'loop 'lambda* 'lambda) nil)
                    (t (cond ((find-recur (first tree)))
                             ((find-recur (rest tree))))))))))
  
  ;;naive way to explode the body and search for a lexical recur form
  (defun detect-recur (body)
    (find-recur (sb-cltl2:macroexpand-all body)))
  
  ;;Beginnings of a foundation for loop/recur,
  ;;and automated (recur ..) constructs in functions.
  (defmacro with-recur (bindings &rest body)
    "A form that acts akin to clojure's loop/recur, 
     where given a sequence of (arg1 init arg2 init ...)
     arguments bound to initial values, evaluates body 
     in a form with a lexically defined function 'recur',
     which has the same args as bindings, and effectively
     jumps back to the beginning of the recur point, 
     carrying arguments forward, evaluating body again
     until a non-recur branch is evaluated."
    (let* ((pairs (partition! 2 bindings))
           (args  (mapcar (lambda (xy) (first xy)) pairs))
           (recur-sym  (intern "RECUR")) ;HAVE TO CAPITALIZE!
           ;; (local-args (mapcar (lambda (x)
           ;;                       (intern (symbol-name x))) args))
           (res        (gensym "res"))
           (continue?  (gensym "continue"))
           (recur-from (gentemp "recur-from"))
           (recur-args (mapcar (lambda (x) (gensym (symbol-name x))) args
                               ))         
           (bindings   (mapcar (lambda (xy)
                                 `(setf ,(car xy) ,(cdr xy))) (pairlis args recur-args))))
      `(let ((,continue? t)
             (,res)
             ,@pairs
             )
         (flet ((,recur-sym ,recur-args
                  (progn ,@bindings
                         (setf ,continue? t))
                  ))
           (tagbody ,recur-from
              (progn 
                (setf ,res ,@body)
                (when ,continue?
                  (setf ,continue? nil)
                  (go ,recur-from))))
           ,res))))
  
  ;;not properly tail recursive....maybe needs to be compiled.
  ;; (defmacro with-recur (args &rest body)
  ;;   (let* ((recur-sym  (intern "RECUR")) ;HAVE TO CAPITALIZE!
  ;;          )
      
  ;;     `(labels ((,recur-sym ,args
  ;;                 ,@body))
  ;;        (,recur-sym ,@args))))
  
negative.code:         with state = 0
          do (setf state (1+ state))
          finally
          (return i))))
  
  ;; (defmacro with-recur (args &rest body)
  ;;   (list* 'labels (quote recur) args
  