anchor.diff:  ;; it is going to have to look inside the lexical scope of the 
   ;; closure...this sounds ugly.
   
  -;; time-buffer relative real time since last call
  -;; time-cache relative time since made(/last reset?)
  +;; time-buffer - converts absolute time to relative time
  +;; time-cache - converts relative time to absolute time
   ;;
   ;; both of these have time sources.
   ;; time-cache can be made using time-buffer so may not be equal
  
positive.code: (defun expired (temporal-lambda)
    (funcall temporal-lambda :*expired?*))
  
  ;; look into variable capture as is not currently portable for regular
  ;; lambdas (passing :*expired?* will crash them.
  
  (defvar *expired?* nil)
  
  
negative.code: ;; I'm trying to discover some kind of decent way of handling 
  ;; time that is lispy and tranparent to other code. Expressive
  ;; enough to handle all time conditions in games and simple
  ;; enough that it can be combined so we can compose new 
  ;; time functionality..should be a doddle...<cough>..*tumbleweed*
  
  ;; ideas for terminology
  ;; '(until before between within at when unless by)
  
  ;;---------------------------------------------------------------
  
  ;; ignore these two...on te wrong track here
  
  (defmacro within ((end-time &optional (start-time 0)) &body body)
    (let ((time-cache (gensym "time-cache")))
  