resume in hdl-tst

beautiful-racket-lib/br/cond.rkt

@@ -1,27 +1,27 @@
 #lang racket/base
-(require (for-syntax racket/base))
+(require (for-syntax racket/base br/syntax)
+         br/define)
 (provide (all-defined-out))
 
-(define-syntax-rule (until COND EXPR ...)
+(define-macro (until COND EXPR ...)
-  (let loop ()
+  #'(let loop ()
       (unless COND
         EXPR ...
         (loop))))
 
-(define-syntax-rule (while COND EXPR ...)
+(define-macro (while COND EXPR ...)
-  (let loop ()
+  #'(let loop ()
       (when COND
         EXPR ...
         (loop))))
 
-(define-syntax (forever stx)
+(define-macro (forever . EXPRS)
-  (syntax-case stx ()
-    [(_ . EXPRS)
   ;; todo: would be better with a syntax parameter
-     (with-syntax ([stop (datum->syntax #'EXPRS 'stop)])
+  (with-pattern
+   ([stop (datum->syntax #'EXPRS 'stop)])
    #'(let/ec stop
        (while #t
-                  . EXPRS)))]))
+              . EXPRS))))
 
 (module+ test
   (require rackunit)

beautiful-racket-lib/br/debug.rkt

@@ -1,27 +1,26 @@
 #lang racket/base
-(require (for-syntax racket/base racket/syntax))
+(require (for-syntax racket/base br/syntax)
+         br/define)
 (provide (all-defined-out))
 
-(define-syntax (report stx)
+(define-macro-cases report
-  (syntax-case stx ()
   [(_ EXPR) #'(report EXPR EXPR)]
   [(_ EXPR NAME)
    #'(let ([expr-result EXPR]) 
        (eprintf "~a = ~v\n" 'NAME expr-result)
-         expr-result)]))
+       expr-result)])
 
-(define-syntax (report-datum stx)
+(define-macro-cases report-datum
-  (syntax-case stx ()
   [(_ STX-EXPR)
-     (with-syntax ([datum (syntax->datum #'STX-EXPR)])
+   (with-pattern ([datum (syntax->datum #'STX-EXPR)])
      #'(report-datum STX-EXPR datum))]
   [(_ STX-EXPR NAME)
    #'(let () 
        (eprintf "~a = ~v\n" 'NAME (syntax->datum STX-EXPR))
-         STX-EXPR)]))
+       STX-EXPR)])
 
-(define-syntax-rule (define-multi-version MULTI-NAME NAME)
+(define-macro (define-multi-version MULTI-NAME NAME)
-  (define-syntax-rule (MULTI-NAME x (... ...))
+  #'(define-macro (MULTI-NAME X (... ...))
-    (begin (NAME x) (... ...))))
+      #'(begin (NAME X) (... ...))))
 
 (define-multi-version report* report)

beautiful-racket-lib/br/reader-utils.rkt

@@ -1,17 +1,15 @@
 #lang racket/base
-(require (for-syntax racket/base racket/syntax) syntax/strip-context)
+(require (for-syntax racket/base racket/syntax br/syntax) br/define syntax/strip-context)
 (provide define-read-and-read-syntax)
 
 ;; `define-read-functions` simplifies support for the standard reading API,
 ;; which asks for `read` and `read-syntax`.
 ;; in general, `read` is just the datum from the result of `read-syntax`.
 
-(define-syntax (define-read-and-read-syntax calling-site-stx)
+(define-macro (define-read-and-read-syntax (PATH PORT) BODY ...)
-  (syntax-case calling-site-stx ()
-    [(_ (PATH PORT) BODY ...)
   (let ([internal-prefix (gensym)])
-       (with-syntax ([READ (datum->syntax calling-site-stx 'read)]
+    (with-syntax ([READ (datum->syntax caller-stx 'read)]
-                     [READ-SYNTAX (datum->syntax calling-site-stx 'read-syntax)]
+                  [READ-SYNTAX (datum->syntax caller-stx 'read-syntax)]
                   ;; use prefixed names to prevent namespace collisions with possibly existing `read` & `read-syntax`
                   [INTERNAL-READ (format-id #'here "~a-~a" internal-prefix 'read)]
                   [INTERNAL-READ-SYNTAX (format-id #'here "~a-~a" internal-prefix 'read-syntax)])
@@ -40,4 +38,4 @@
                                 (let ([output (calling-site-function #f port)])
                                   (if (syntax? output)
                                       (syntax->datum output)
-                                         output))) 'READ)))))]))
+                                      output))) 'READ))))))