make-run-request run-request?
run-request-proc run-request-when
- run wrap run-wrap run-wrap-at
+ run-it wrap run run-at delay
%current-agenda
start-agenda agenda-run-once))
(queue time-segment-queue))
(define (time-segment-right-format time)
+ "Ensure TIME is in the right format.
+
+The right format means (second . microsecond).
+If an integer, will convert appropriately."
+ ;; TODO: add floating point / rational number support.
(match time
;; time is already a cons of second and microsecnd
(((? integer? s) . (? integer? u)) time)
(_ (throw 'invalid-time "Invalid time" time))))
(define* (make-time-segment time #:optional (queue (make-q)))
+ "Make a time segment of TIME and QUEUE
+
+No automatic conversion is done, so you might have to
+run (time-segment-right-format) first."
(make-time-segment-intern time queue))
(define (time< time1 time2)
+ "Check if TIME1 is less than TIME2"
(cond ((< (car time1)
(car time2))
#t)
(else #f)))
(define (time= time1 time2)
+ "Check whether TIME1 and TIME2 are equivalent"
(and (= (car time1) (car time2))
(= (cdr time1) (cdr time2))))
(define (time<= time1 time2)
+ "Check if TIME1 is less than or equal to TIME2"
(or (time< time1 time2)
(time= time1 time2)))
(usec time-delta-usec))
(define* (make-time-delta sec #:optional usec)
+ "Make a <time-delta> of SEC seconds and USEC microseconds.
+
+This is used primarily so the agenda can recognize RUN-REQUEST objects
+which are meant "
(make-time-delta-intern sec (or usec 0)))
(define tdelta make-time-delta)
(else time)))
(define (time-delta+ time time-delta)
+ "Increment a TIME by the value of TIME-DELTA"
(time-carry-correct
(cons (+ (car time) (time-delta-sec time-delta))
(+ (cdr time) (time-delta-usec time-delta)))))
(define (time-minus time1 time2)
+ "Subtract TIME2 from TIME1"
(time-carry-correct
(cons (- (car time1) (car time2))
(- (cdr time2) (cdr time2)))))
(define (time-plus time1 time2)
+ "Add TIME1 and TIME2"
(time-carry-correct
(cons (+ (car time1) (car time2))
(+ (cdr time2) (cdr time2)))))
(segments schedule-segments set-schedule-segments!))
(define* (make-schedule #:optional segments)
+ "Make a schedule, optionally pre-composed of SEGMENTS"
(make-schedule-intern (or segments '())))
(define (schedule-soonest-time schedule)
;; but at least it'll be reasonably easy to refactor to
;; a more functional setup?
(define (schedule-add! schedule time proc)
+ "Mutate SCHEDULE, adding PROC at an appropriate time segment for TIME"
(let ((time (time-segment-right-format time)))
(define (new-time-segment)
(let ((new-segment
(loop (schedule-segments schedule)))))
(define (schedule-empty? schedule)
+ "Check if the SCHEDULE is currently empty"
(eq? (schedule-segments schedule) '()))
(define (schedule-segments-split schedule time)
;;; Request to run stuff
;;; ====================
-(define-record-type <run-request>
+(define-immutable-record-type <run-request>
(make-run-request proc when)
run-request?
(proc run-request-proc)
(when run-request-when))
-(define* (run proc #:optional when)
+(define* (run-it proc #:optional when)
+ "Make a request to run PROC (possibly at WHEN)"
(make-run-request proc when))
(define-syntax-rule (wrap body ...)
+ "Wrap contents in a procedure"
(lambda ()
body ...))
-(define-syntax-rule (run-wrap body ...)
- (run (wrap body ...)))
+(define-syntax-rule (run body ...)
+ "Run everything in BODY but wrap in a convenient procedure"
+ (make-run-request (wrap body ...) #f))
+
+(define-syntax-rule (run-at body ... when)
+ "Run BODY at WHEN"
+ (make-run-request (wrap body ...) when))
+
+(define-syntax-rule (run-delay body ... delay-time)
+ "Run BODY at DELAY-TIME time from now"
+ (make-run-request (wrap body ...) (tdelta delay-time)))
-(define-syntax-rule (run-wrap-at body ... when)
- (run (wrap body ...) when))
+(define (delay run-request delay-time)
+ "Delay a RUN-REQUEST by DELAY-TIME"
+ (set-field run-request
+ (run-request-when)
+ (tdelta delay-time)))
\f
;;; Execution of agenda, and current agenda