You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
272 lines
9.1 KiB
Racket
272 lines
9.1 KiB
Racket
#lang racket/base
|
|
(require
|
|
racket/function
|
|
(for-syntax racket/base
|
|
syntax/parse
|
|
br/private/syntax-flatten
|
|
syntax/define))
|
|
(provide (all-defined-out)
|
|
(for-syntax with-shared-id))
|
|
|
|
(module+ test
|
|
(require rackunit))
|
|
|
|
|
|
(define-syntax (define+provide stx)
|
|
(with-syntax ([(id lambda-exp)
|
|
(let-values ([(id-stx body-exp-stx)
|
|
(normalize-definition stx (datum->syntax stx 'λ) #t #t)])
|
|
(list id-stx body-exp-stx))])
|
|
#'(begin
|
|
(provide id)
|
|
(define id lambda-exp))))
|
|
|
|
|
|
(begin-for-syntax
|
|
(define (upcased-and-capitalized? sym)
|
|
(define str (symbol->string sym))
|
|
(and (equal? (string-upcase str) str)
|
|
(let ([first-letter (substring str 0 1)])
|
|
(or (and (string->number first-letter) #t) ; leading digit OK
|
|
(not (equal? (string-downcase first-letter) first-letter))))))
|
|
|
|
(define (generate-literals pats)
|
|
;; generate literals for any symbols that are not ... or _
|
|
(define pattern-arg-prefixer "_")
|
|
(for*/list ([pat-arg (in-list (syntax-flatten pats))]
|
|
[pat-datum (in-value (syntax->datum pat-arg))]
|
|
#:when (and (symbol? pat-datum)
|
|
(not (member pat-datum '(... _))) ; exempted from literality
|
|
(not (upcased-and-capitalized? pat-datum))))
|
|
pat-arg)))
|
|
|
|
(begin-for-syntax
|
|
;; expose the caller context within br:define macros with syntax parameter
|
|
(require (for-syntax racket/base) racket/stxparam)
|
|
(provide caller-stx)
|
|
(define-syntax-parameter caller-stx (λ(stx) (error 'caller-stx-not-parameterized))))
|
|
|
|
|
|
(define-syntax (define-cases stx)
|
|
(syntax-parse stx
|
|
#:literals (syntax)
|
|
[(_ id:id)
|
|
(raise-syntax-error 'define-cases "no cases given" (syntax->datum #'id))]
|
|
[(_ id:id [(_ . pat-args:expr) . body:expr] ...)
|
|
#'(define id
|
|
(case-lambda
|
|
[pat-args . body] ...
|
|
[rest-pat (apply raise-arity-error 'id (normalize-arity (map length '(pat-args ...))) rest-pat)]))]
|
|
[else (raise-syntax-error
|
|
'define-cases
|
|
"no matching case for calling pattern"
|
|
(syntax->datum stx))]))
|
|
|
|
|
|
(module+ test
|
|
(define-cases f
|
|
[(_ arg) (add1 arg)]
|
|
[(_ arg1 arg2) (+ arg1 arg2)]
|
|
[(_ . any) 'boing])
|
|
(check-equal? (f 42) 43)
|
|
(check-equal? (f 42 5) 47)
|
|
(check-equal? (f 42 5 'zonk) 'boing)
|
|
|
|
(define-cases f-one-arg
|
|
[(_ arg) (add1 arg)])
|
|
(check-exn exn:fail:contract:arity? (λ _ (f-one-arg 1 2 3))))
|
|
|
|
|
|
(define-syntax-rule (debug-define-macro (ID . PAT-ARGS) BODY)
|
|
(define-macro (ID . PAT-ARGS)
|
|
#`(begin
|
|
(for-each displayln
|
|
(list
|
|
(format "input pattern = #'~a" '#,'(ID . PAT-ARGS))
|
|
(format "output pattern = #'~a" (cadr '#,'BODY))
|
|
(format "invoked as = ~a" (syntax->datum #'(ID . PAT-ARGS)))
|
|
(format "expanded as = ~a" '#,(syntax->datum BODY))
|
|
(format "evaluated as = ~a" #,BODY)))
|
|
#,BODY)))
|
|
|
|
|
|
(module+ test
|
|
(require rackunit racket/port)
|
|
(parameterize ([current-output-port (open-output-nowhere)])
|
|
(check-equal? (let ()
|
|
(debug-define-macro (foo X Y Z)
|
|
#'(apply + (list X Y Z)))
|
|
(foo 1 2 3)) 6)
|
|
(check-equal? (let ()
|
|
(debug-define-macro (foo X ...) #'(apply * (list X ...)))
|
|
(foo 10 11 12)) 1320)))
|
|
|
|
|
|
(begin-for-syntax
|
|
(begin-for-syntax
|
|
(require (for-syntax racket/base))
|
|
(define-syntax-rule (make-shared-syntax-macro caller-stx)
|
|
#'(syntax-rules stx
|
|
[(_ form)
|
|
#'(datum->syntax caller-stx (if (syntax? form)
|
|
(syntax-e form)
|
|
form))]))))
|
|
|
|
(module+ test
|
|
(define-macro (dirty-maker ARG)
|
|
(with-syntax ([dirty-bar (datum->syntax caller-stx 'dirty-bar)])
|
|
#'(define dirty-bar (* ARG 2))))
|
|
(dirty-maker 42)
|
|
(check-equal? dirty-bar 84))
|
|
|
|
|
|
(begin-for-syntax
|
|
(define-syntax-rule (with-shared-id (id ...) . body)
|
|
(with-syntax ([id (datum->syntax caller-stx 'id)] ...)
|
|
. body)))
|
|
|
|
|
|
;; `syntax-parse` classes shared by `define-macro` and `define-macro-cases`
|
|
(begin-for-syntax
|
|
(require syntax/parse)
|
|
(define-syntax-class syntaxed-id
|
|
#:literals (syntax quasisyntax)
|
|
#:description "id in syntaxed form"
|
|
(pattern ([~or syntax quasisyntax] name:id)))
|
|
|
|
(define-syntax-class syntaxed-thing
|
|
#:literals (syntax quasisyntax)
|
|
#:description "some datum in syntaxed form"
|
|
(pattern ([~or syntax quasisyntax] thing:expr)))
|
|
|
|
(define-syntax-class else-clause
|
|
#:literals (else)
|
|
(pattern [else . body:expr]))
|
|
|
|
(define-syntax-class transformer-func
|
|
#:literals (lambda λ)
|
|
(pattern ([~or lambda λ] (arg:id) . body:expr))))
|
|
|
|
|
|
(define-syntax (define-macro stx)
|
|
(syntax-parse stx
|
|
[(_ id:id stxed-id:syntaxed-id)
|
|
#'(define-syntax id (make-rename-transformer stxed-id))]
|
|
[(_ id:id func:transformer-func)
|
|
#'(define-syntax id func)]
|
|
[(_ id:id func-id:id)
|
|
#'(define-syntax id func-id)]
|
|
[(_ id:id stxed-thing:syntaxed-thing)
|
|
#'(define-macro id (λ (stx) stxed-thing))]
|
|
[(_ (id:id . patargs:expr) . body:expr)
|
|
#'(define-macro-cases id [(id . patargs) (begin . body)])]
|
|
[else (raise-syntax-error
|
|
'define-macro
|
|
"no matching case for calling pattern"
|
|
(syntax->datum stx))]))
|
|
|
|
|
|
(define-syntax (define-macro-cases stx)
|
|
(syntax-parse stx
|
|
[(_ id:id)
|
|
(raise-syntax-error 'define-macro-cases "no cases given" (syntax->datum #'id))]
|
|
[(_ id:id leading-pat:expr ... else-pat:else-clause trailing-pat0:expr trailing-pat:expr ...)
|
|
(raise-syntax-error 'define-macro-cases "`else` clause must be last" (syntax->datum #'id))]
|
|
[(_ id:id (pat:expr . result-exprs:expr) ... else-clause:else-clause)
|
|
(with-syntax ([LITERALS (generate-literals #'(pat ...))])
|
|
#'(define-macro id
|
|
(λ (stx)
|
|
(define result
|
|
(syntax-parameterize ([caller-stx (make-rename-transformer #'stx)])
|
|
(syntax-case stx LITERALS
|
|
[pat . result-exprs] ...
|
|
else-clause)))
|
|
(if (syntax? result)
|
|
result
|
|
(datum->syntax #'id result)))))]
|
|
[(_ id:id pat-clause:expr ...) ; macro without `else` clause will reach this branch
|
|
#'(define-macro-cases id
|
|
pat-clause ...
|
|
[else (raise-syntax-error
|
|
'id
|
|
"no matching case for calling pattern"
|
|
(syntax->datum caller-stx))])]
|
|
[else (raise-syntax-error
|
|
'define-macro-cases
|
|
"no matching case for calling pattern"
|
|
(syntax->datum stx))]))
|
|
|
|
|
|
(module+ test
|
|
(define-macro plus (λ(stx) #'+))
|
|
(check-equal? (plus 42) +)
|
|
(define-macro plusser #'plus)
|
|
(check-equal? (plusser 42) +)
|
|
(check-equal? plusser +)
|
|
(define-macro (times [nested ARG]) #`(* ARG ARG))
|
|
(check-equal? (times [nested 10]) 100)
|
|
(define-macro timeser #'times)
|
|
(check-equal? (timeser [nested 12]) 144)
|
|
(define-macro fortytwo #`42)
|
|
(check-equal? fortytwo 42)
|
|
(check-equal? (let ()
|
|
(define-macro (foo X)
|
|
(with-syntax ([zam +])
|
|
#'(zam X X))) (foo 42)) 84)
|
|
(begin
|
|
(define-macro (redefine ID) #'(define ID 42))
|
|
(redefine zoombar)
|
|
(check-equal? zoombar 42))
|
|
|
|
;; use caller-stx parameter to introduce identifier unhygienically
|
|
(define-macro (zam ARG1 ARG2 ARG3)
|
|
(with-syntax ([dz (datum->syntax caller-stx 'dirty-zam)])
|
|
#`(define dz 'got-dirty-zam)))
|
|
|
|
(zam 'this 'that 42)
|
|
(check-equal? dirty-zam 'got-dirty-zam)
|
|
|
|
(define-macro (add X) #'(+ X X))
|
|
(check-equal? (add 5) 10)
|
|
(define-macro (add-b 9X) #'(+ 9X 9X))
|
|
(check-equal? (add-b 5) 10)
|
|
(define-macro-cases add-again [(_ X) #'(+ X X)])
|
|
(check-equal? (add-again 5) 10)
|
|
(define-macro-cases add-3rd [(_ X) #'(+ X X)])
|
|
(check-equal? (add-3rd 5) 10)
|
|
(define-macro add-4th #'add-3rd)
|
|
(check-equal? (add-4th 5) 10)
|
|
(define foo-val 'got-foo-val)
|
|
(define (foo-func) 'got-foo-func)
|
|
(define-macro-cases op
|
|
[(_ "+") #''got-plus]
|
|
[(_ ARG) #''got-something-else]
|
|
[(_) #'(foo-func)]
|
|
[_ #'foo-val])
|
|
|
|
(check-equal? (op "+") 'got-plus)
|
|
(check-equal? (op 42) 'got-something-else)
|
|
(check-equal? (op) 'got-foo-func)
|
|
(check-equal? op 'got-foo-val)
|
|
|
|
(define-macro-cases elseop
|
|
[(_ ARG) #''got-arg]
|
|
[else #''got-else])
|
|
|
|
(check-equal? (elseop "+") 'got-arg)
|
|
(check-equal? (elseop "+" 42) 'got-else)
|
|
|
|
(check-exn exn:fail:syntax? (λ _ (expand-once #'(define-macro-cases no-cases))))
|
|
|
|
(check-exn exn:fail:syntax? (λ _ (expand-once #'(define-macro-cases badelseop
|
|
[else #''got-else]
|
|
[(_ _arg) #''got-arg]))))
|
|
|
|
(define-macro-cases no-else-macro
|
|
[(_ ARG) #''got-arg])
|
|
(check-exn exn:fail:syntax? (λ _ (expand-once #'(no-else-macro 'arg1 'arg2)))))
|
|
|
|
(define-macro (define-unhygienic-macro (ID PAT ...) BODY ... STX-OBJECT)
|
|
#'(define-macro (ID PAT ...)
|
|
BODY ...
|
|
(datum->syntax caller-stx (syntax->datum STX-OBJECT)))) |