anchor.diff:               ,(when fill-var `(,fill-var ,stepv)))
             `((,stepv (make-stepper ,timestep))))))
   
  -;; {TODO} test this...do we need an unless equivilent?
  -(def-time-condition while (test &key progress) t
  +(def-time-condition while (test) t
     (let ((test-result (gensym "test-result")))
       (list test-result
  -          `(not test-result)
  -          (when progress `((,test-result ,test)))
  +          `(not ,test-result)
  +          `((,test-result ,test))
             nil)))
   
   ;;==============================================================================
  
positive.code:                           (cfunc:signal-expired)
                            ,code)
                       code)))
        `(let (,@(loop :for (a b) :in closed-vars collect (list a b)))
           (,@(if name `(defun ,name) '(lambda)) ,args
              (block tlambda-implicit-block
                (tagbody tlambda-start
                   (return-from tlambda-implicit-block
                     ,lbody))))))))
  
  (defmacro tdefun (name args &body body) (gen-time-function-body name args body))
  (defmacro tlambda (args &body body) (gen-time-function-body nil args body))
  
negative.code:                                       :if (and override (third i))
                                        :collect `(setf ,(first i) (- ,(second i) (- (funcall *default-time-source*) ,expired-test)))
                                        :else 
                                        :collect `(setf ,(first i) ,(second i)))))
                             local-vars))))))
        (make-instance
         'tcompile-obj
         :code (t-chain-expand counter-sym chain-forms)
         :run-test `(< ,counter-sym ,(length forms))
         :expired-test (when (not repeat) `(= ,counter-sym ,(length forms)))
         :closed-vars (cons `(,counter-sym 0)
  