Hi,

I’d like to use the Racket macro expander to translate programs from a given 
source language to a target language (both scheme-ish).

However, the expansion that `raco expand` does is too violent for my 
purposes---I would need a way to specify macro hiding (as in the macro 
stepper), in order to control the level of abstraction of the expanded code. Is 
that possible?
[see example below]

Thanks,

— Éric

; test.rkt
(define-syntax-rule (swap x y)
  (let ([tmp x])
    (set! x y)
    (set! y tmp)))

(define a 10)
(define b 20)
(swap a b)

; I’d like to obtain:

…prelude…
(define a 10)
(define b 20)
(let ([tmp a])
    (set! a b)
    (set! b tmp)))

; but raco expand gives me the full story:

(module test play
  (#%module-begin
   (module configure-runtime '#%kernel
     (#%module-begin (#%require racket/runtime-config) (#%app configure '#f)))
   (#%provide b swap a)
   (define-syntaxes
    (swap)
    (lambda (user-stx)
      (let-values (((arg) user-stx))
        (let-values (((rslt)
                      (#%app
                       (lambda (e)
                         (if (#%app stx-pair? e)
                           (if (#%app (lambda (e) null) (#%app stx-car e))
                             (#%app
                              (lambda (e)
                                (if (#%app stx-pair? e)
                                  (#%app
                                   cons/#f
                                   (#%app stx-car e)
                                   (#%app
                                    (lambda (e)
                                      (if (#%app stx-pair? e)
                                        (let-values (((mh) (#%app stx-car e)))
                                          (if mh
                                            (if (#%app
                                                 stx-null/#f
                                                 (#%app stx-cdr e))
                                              mh
                                              '#f)
                                            '#f))
                                        '#f))
                                    (#%app stx-cdr e)))
                                  '#f))
                              (#%app stx-cdr e))
                             '#f)
                           '#f))
                       arg)))
          (if rslt
            (let-values (((sc1) (#%app unsafe-car rslt))
                         ((sc2) (#%app unsafe-cdr rslt)))
              (let-values ()
                (#%app
                 syntax-protect
                 (let-values (((loc) (#%app check-loc 'syntax/loc user-stx)))
                   (#%app
                    t-subst
                    loc
                    (quote-syntax (let _ (set! _ _) (set! _ tmp)))
                    '(1 recur 2 recur 3)
                    (#%app
                     t-resyntax
                     '#f
                     (quote-syntax STX)
                     (#%app
                      t-list
                      (#%app t-subst '#f (quote-syntax (tmp _)) '(1) sc1)))
                    (#%app list '(1 2) sc1 sc2)
                    (#%app list '(1) sc2))))))
            (let-values (((rslt) (#%app (lambda (e) null) arg)))
              (if rslt
                (let-values ()
                  (let-values () (#%app pattern-failure user-stx '(x y))))
                (#%app raise-syntax-error '#f '"bad syntax" arg))))))))
   (define-values (a) '10)
   (define-values (b) '20)
   (#%app
    call-with-values
    (lambda () (let-values (((tmp) a)) (set! a b) (set! b tmp)))
    print-values)))

-- 
You received this message because you are subscribed to the Google Groups 
"Racket Users" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to [email protected].
To view this discussion on the web visit 
https://groups.google.com/d/msgid/racket-users/94E20736-F1F7-4073-B3FA-505ADD71DB4F%40dcc.uchile.cl.

Reply via email to