anchor.diff:  (defun tthen+ (forms)
     (let* ((processed-forms (%process-tprogn-forms forms))
            (counter-sym (gensym "counter"))
  -         (%closed-vars (remove nil (mapcan #'fifth (copy-tree processed-forms)))))
  -    (list `(let (,(remove nil (mapcar #'fourth processed-forms)))
  +         (%closed-vars (remove nil (mapcan #'fifth (copy-tree processed-forms))))
  +         (let-forms (remove nil (mapcar #'fourth processed-forms))))
  +    (list `(let ,(when let-forms (list let-forms))
                (case ,counter-sym
                  ,@(loop :for (body test expired-test inner-let closed-vars)
                       :in processed-forms
  
positive.code: (in-package :base-time)
  
  ;;----------------------------------------------------------------------
  
  ;; (tlambda ()
  ;;     (repeat ((before (from-now 300))
  ;;              (setf (pos *e*) (lerp (pos *e*) (v! 1 2 3))))
  ;;             ((before (from-now 400))
  ;;              (setf (pos *e*) (lerp (pos *e*) (v! 0 0 0)))))
  ;;   (before (from-now (seconds 4)) (print "first 4 seconds"))
  ;;   (print "hi"))
  
  ;; (let ((~c-0 0)
  ;;       (~dl-1 (from-now (seconds 4)))
  ;;       (~dl-2 (from-now 300))
  ;;       ~dl-3)
  ;;   (lambda ()
  ;;     (case ~c-0
  ;;       (0 (if (beforep (~dl-2))
  ;;              (progn (setf (pos *e*) (lerp (pos *e*) (v! 1 2 3))))
  ;;              (setf ~c-0 1 ~dl-3 (from-now 400))))
  ;;       (1 (if (beforep (~dl-3))
  ;;              (progn (setf (pos *e*) (lerp (pos *e*) (v! 0 0 0))))
  ;;              (setf ~c-0 0 ~dl-2 (from-now 300)))))
  ;;     (when (beforep (~dl-1) (print "first 4 seconds")))
  ;;     (print "hi")))
  
  ;; (body test expired-test inner-let closed-vars)
  
  (tlambda+ (x y) (+ x y))
  
  ;;{TODO} should "every time" stil print after it expires?
  (tlambda+ ()
    ((before (from-now 100)) (print "moo"))
    (print "every time"))
  
  (tlambda+ () 
    ((and (each (seconds 1)) (before (from-now (seconds 4)))) 
     (print "hi")))
  
  ;;{TODO} I think ther are ways to have conflicting expired, address this
  ;;       I was slightly off but had the right idea...only this macro must
  
negative.code:                                 (multiple-value-list 
                                   (%compile-time-syntax+ (first form))))))))))
  
  (defun tprogn+ (forms)
    (let* ((processed-forms (%process-tprogn-forms forms))
           (expire-forms (remove nil (mapcar #'third processed-forms)))
           (let-forms (remove nil (mapcan #'fourth processed-forms))))
      (list `(let ,(when let-forms (list let-forms))
               ,@(loop :for (body test expired-test inner-let closed-vars) 
                    :in processed-forms :collect
                    (if (and (eq test t) (null expired-test))
  