anchor.diff:                     ,body)
                 body)))))
   
  -(defun %compile-time-syntax+ (form)
  -  (if (atom form) (values form nil nil nil)
  +(defun %compile-time-syntax (form)
  +  (if (atom form) (list form nil nil nil)
         (let* ((tname (first form))
  -             (state nil)
  -             (expiredp nil)
  -             (anaphora nil)
  +             (closed-arg-vars nil)
  +             (arg-expire-tests nil)
  +             (local-arg-vars nil)
                (body (loop :for item :in (rest form) :collect
  -                      (multiple-value-bind (c e a s) (%compile-time-syntax+ item)
  -                        (setf state (append s state))
  -                        (setf anaphora (append a anaphora))
  -                        (when e (push e expiredp))
  -                        c))))
  -        (multiple-value-bind (c s e a) (time-syntax-expand tname body)
  -          (values c 
  -                  (if (and (symbolp e) expiredp) (cons e expiredp) e)
  -                  (remove nil (append a (reverse anaphora)))
  -                  (remove nil (append s (reverse state))))))))
  -
  -(defun %process-tprogn-forms (forms)
  -  (loop :for form :in forms :collect
  -     (if (atom form) (list form t)
  -         (case (first form)
  -           (repeat (trepeat+ (rest form)))
  -           (then (tthen+ (rest form)))
  -           (progn (tprogn+ (rest form)))
  -           (otherwise (if (or (atom (first form))
  -                              (eq (caar form) 'lambda))
  -                          (list form t)
  -                          (cons (second form)
  -                                (multiple-value-list 
  -                                 (%compile-time-syntax+ (first form))))))))))
  -
  -(defun tprogn+ (forms)
  +                      (destructuring-bind (&optional code expired-test
  +                                                     local-vars closed-vars
  +                                                     override)
  +                          (%compile-time-syntax item)
  +                        (declare (ignore override))
  +                        (setf closed-arg-vars (append closed-vars closed-arg-vars))
  +                        (setf local-arg-vars (append local-vars local-arg-vars))
  +                        (when expired-test (push expired-test arg-expire-tests))
  +                        code
  +                        ))));;{TODO} handle override here
  +        (destructuring-bind (&optional code expired-test local-vars closed-vars
  +                                       override) 
  +            (time-syntax-expand tname body)
  +          (list code
  +                ;;{TODO} what if not symb and arg-expire-tests?
  +                (if (and (symbolp expired-test) arg-expire-tests) 
  +                    (cons expired-test arg-expire-tests) 
  +                    expired-test)
  +                (remove nil (append local-vars (reverse arg-expire-tests)))
  +                (remove nil (append closed-vars (reverse closed-arg-vars)))
  +                override)))))
  +
  +(tlambda () ((before 100) (print "hi")))
  +
  +(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))))
  
positive.code: 
  (defun beforep (time &optional (time-source *default-time-source*))
    (let ((current-time (funcall time-source)))
      (when (< current-time time) current-time)))
  
  (defun afterp (time &optional (time-source *default-time-source*))
    (let ((current-time (funcall time-source)))
      (when (> current-time time) current-time)))
  
  (defun betweenp (start-time end-time
                  &optional (time-source *default-time-source*))
    (let ((current-time (funcall time-source)))
      (when (and (>= current-time start-time)
                 (<= current-time end-time)) 
        current-time)))
  
  ;;--------------------------------------------------------------------
  
  
negative.code: 
  (defun make-time-source (&key (parent *default-time-source*) (transform nil))
    (if transform
        (lambda () (funcall transform (funcall parent)))
        (lambda () (funcall parent))))
  
  (defmacro with-time-source (time-source &body body)
    `(let ((*default-time-source* ,time-source))
  