anchor.diff:  ;;        usefulness of this we may be able to see a higher good in this.
   
   (defun make-stepper (step-size &optional (max-cache-size (max (* 10 step-size) 10000.0))
  -                                 (default-source *default-time-source*))
  +                                 (default-source *default-time-source*)
  +				 (allow-replace-source nil))
     "this takes absolute sources"
     ;; if max-cache-size is set to zero
     (when (< max-cache-size step-size)
       (error "Make-Stepper: max-cache-size is smaller than step-size.~%max-cache-size: ~a~%step-size: ~a~%" max-cache-size step-size))
  -  (let ((time-cache 0)
  -        (last-val (funcall default-source)))
  -    (lambda (&optional (time-source default-source))
  -      (let* ((time (abs (funcall time-source)))
  -             (dif (- time last-val)))
  -        (setf last-val time
  -              time-cache (min max-cache-size (+ time-cache dif)))
  -        (when (>= time-cache step-size)
  -          (setf time-cache (- time-cache step-size))
  -          (min 1.0 (float (/ time-cache step-size))))))))
  +  (if allow-replace-source
  +      ;;
  +      (let ((time-cache 0)
  +	    (last-val (funcall default-source)))
  +	(lambda (&optional (time-source default-source))
  +	  (let* ((time (abs (funcall time-source)))
  +		 (dif (- time last-val)))
  +	    (setf last-val time
  +		  time-cache (min max-cache-size (+ time-cache dif)))
  +	    (when (>= time-cache step-size)
  +	      (setf time-cache (- time-cache step-size))
  +	      (min 1.0 (float (/ time-cache step-size)))))))
  +      ;;
  +      (if (eq default-source *default-time-source*)
  +	  (let ((time-cache 0)
  +		(last-val (get-internal-real-time)))
  +	    (lambda ()
  +	      (let* ((time (get-internal-real-time))
  +		     (dif (- time last-val)))
  +		(setf last-val time
  +		      time-cache (min max-cache-size (+ time-cache dif)))
  +		(when (>= time-cache step-size)
  +		  (setf time-cache (- time-cache step-size))
  +		  (min 1.0 (float (/ time-cache step-size)))))))
  +	  (let ((time-cache 0)
  +		(last-val (funcall default-source)))
  +	    (lambda ()
  +	      (let* ((time (funcall default-source))
  +		     (dif (- time last-val)))
  +		(setf last-val time
  +		      time-cache (min max-cache-size (+ time-cache dif)))
  +		(when (>= time-cache step-size)
  +		  (setf time-cache (- time-cache step-size))
  +		  (min 1.0 (float (/ time-cache step-size))))))))))
   
   
   (def-t-expander each (delay &rest body)
  
positive.code:         (expire-tests (remove nil (mapcan #'expire-test compiled)))
          (funcs (remove nil (mapcan #'funcs compiled))))
      (if (and (null start-tests) (null expire-tests) (null funcs))
          `(let ((,*time-var* (,*default-time-source*)))
             (declare (ignorable ,*time-var*))
             ,@(mapcar #'body compiled))
          `(let ((,*time-var* (,*default-time-source*)))
             (declare (ignorable ,*time-var*))
             (labels (,@start-tests
                      ,@expire-tests
  
negative.code: 
  (defparameter *temporal-clause-expanders*
    (make-hash-table))
  (defparameter *default-time-source-name* 'get-internal-real-time)
  (defparameter *default-time-source* #'get-internal-real-time)
  (defparameter *time-var* '|time|)
  (defparameter *init-arg* '|start-time|)
  (defparameter *progress-var* '%progress%)
  