changed integral to use syntax-parse

Author: alanb2718

reactive/reactive-thing.rkt

@@ -34,7 +34,8 @@
     ;   (while (and (<= 50 (milliseconds)) (<= (milliseconds) 100)) ...
     ; or this:
     ;   (while (and (<= 50 (milliseconds)) (>= 100 (milliseconds))) ...
-    ; plus the analogous versions for the lower bound test, so 4 possible combinations in all.  (Is there a better way to do this??)
+    ; plus the analogous versions for the lower bound test, so 4 possible combinations in all.
+    ; NOTE: this should be rewritten in better style -- see e.g. the integral macro, which uses syntax-parse
     ((while (and (<= lower (milliseconds)) (<= (milliseconds) upper)) e ...)
      (add-while-with-time-bounds lower upper e ...))
     ((while (and (<= lower (milliseconds)) (>= upper (milliseconds))) e ...)
@@ -90,18 +91,22 @@
      (with-syntax ([id (datum->syntax stx (gensym))])
        #'(send this max-min-helper fn (lambda () (send this wally-evaluate expr)) 'id (interesting-time?)))]))
 ; integral macro
+; The form is (integral expr) with additional optional keyword arguments as follows:
+;     #:var v  -- variable of integration; default is (milliseconds) -- note that an expression is allowed here
+;     #:numeric or #:symbolic -- which kind of integration to use.  Default is to try symbolic, and if that doesn't work, use numeric
+;     #:dt d -- time step (only allowed with #:numeric)
+; Example: (integral (sin x) #:var x #:numeric #:dt 0.1)
 (require (for-syntax "symbolic-integration.rkt"))  ; function to do simple symbolic integration
+(require (for-syntax syntax/parse))
 (define-syntax (integral stx)
-  (syntax-case stx ()
-    [(_ expr var)  ; case with explicit variable of integration
-     (with-syntax ([intgl (datum->syntax stx (symbolic-integral (syntax->datum #'expr) (syntax->datum #'var)))]
-                   [id (datum->syntax stx (gensym))])
-       #'(send this integral-helper (lambda () (send this wally-evaluate intgl)) 'id (interesting-time?)))]
-    [(_ expr)      ; default variable of integration is (milliseconds)
-     (with-syntax ([intgl (datum->syntax stx (symbolic-integral (syntax->datum #'expr) '(milliseconds)))]
+  (syntax-parse stx
+    [(integral e:expr (~or (~optional (~seq #:var v:expr)) (~optional #:numeric) (~optional #:symbolic) (~optional (~seq #:dt d:expr))) ...)
+     (with-syntax ([intgl (datum->syntax stx (symbolic-integral (syntax->datum #'e)
+                                                                (if (attribute v) (syntax->datum #'v) '(milliseconds))))]
                    [id (datum->syntax stx (gensym))])
        #'(send this integral-helper (lambda () (send this wally-evaluate intgl)) 'id (interesting-time?)))]))
 
+
 (define reactive-thing%
   (class abstract-reactive-thing%
     (super-new)

tests/integral-tests.rkt

@@ -129,12 +129,12 @@
        (super-new)
        (define-public-symbolic* s x1 x2 y1 y2 z1 z2 real?)
        (always (equal? s (* 2 (milliseconds))))
-       (always (equal? x1 (integral 2 (milliseconds))))
-       (always (equal? x2 (integral (milliseconds) (milliseconds))))
-       (always (equal? y1 (integral 2 (seconds))))
-       (always (equal? y2 (integral (seconds) (seconds))))
-       (always (equal? z1 (integral 2 s)))
-       (always (equal? z2 (integral s s)))))
+       (always (equal? x1 (integral 2 #:var (milliseconds))))
+       (always (equal? x2 (integral (milliseconds) #:var (milliseconds))))
+       (always (equal? y1 (integral 2 #:var (seconds))))
+       (always (equal? y2 (integral (seconds) #:var (seconds))))
+       (always (equal? z1 (integral 2 #:var s)))
+       (always (equal? z2 (integral s #:var s)))))
    (define r (new tester%))
    (send r start)
    (send-syncd r advance-time-syncd 100)