Generally these kinds of macros are not a good idea, because it's
difficult to combine them with other macros. It's probably better to
use a syntax-parameter like the suggestion in the other message.
The problem in your macro is that with syntax-case can't search bar
when it's nested at any deep level. It only looks for it in a specific
position. To search at any level of parenthesis nesting you should
create an auxiliary function that analyzes recursively the expression,
and then reconstruct the new version.
;----------------
#lang racket
(define-syntax (define-foo stx)
(define (replace-bar stx)
(syntax-case stx (bar)
[(bar . body)
(syntax (+ 3 . body))]
[(proc other . rest)
(with-syntax ([new-other (replace-bar #'other)])
(syntax (proc new-other . rest)))]))
(syntax-case stx ()
[(_ (name param) body)
(with-syntax ([new-body (replace-bar #'body)])
(syntax (define (name param) new-body)))]))
(define-foo (foof env)
(displayln (bar (+ 1 2))))
(foof #f) ;==>6
(define-foo (foog env)
(displayln (+ (bar (- 1 (+ 1 2))) 15)))
(foog #f) ;==>16
;----------------
This only search for bar in the first argument branch. So
(define-foo (foog env) (+ (bar 1) 2)) ; works but
(define-foo (foog env) (+ 2 (bar 1))) ; don't.
It's not difficult to extend the idea to handle this kind of cases.
If you want to do more complex transformations with the code between
define-foo and bar (body1 in your code), then you will need a more
complex macro.
Gustavo
On Tue, Aug 27, 2013 at 5:33 AM, Chad Albers <calb...@neomantic.com> wrote:
> I'm still trying to grok macros - which are amazing, but hard. I'd like to
> know if it is possible capture part of the following expression
>
> (display (+ 2 (bar (+ 1 2))))
>
> if "bar" is a literal in the macro, I would like to capture body0 as (+ 1 2)
> and body1 as (display (+ 2 ...)).
>
> This is a totally artificial example.
>
> Here's what I have:
>
> (define-syntax (define-foo stx)
> (syntax-case stx (bar)
> ([_ (name param) (body1 (bar . body0))]
> (syntax (define (name param)
> (body1 (+ 3 . body0)))))))
>
> (define-foo (foof env)
> (display (bar (+ 1 2))))
>
> This works...and expands to.
>
> (define (foof env)
> (display (+ 3 (- 1 (+ 1 2)))))
>
> (Note that -1 has been substitute for the "bar" literal").
>
> This expression fails with "bad syntax"
>
> (define-foo (foog env)
> (display (+3 (bar (- 1 (+ 1 2))))))
>
> I don't seem be to able to capture (display (+3 )) as separate from (bar (-1
> (+ 1 2)))
>
> Is this possible to capture?
>
> Thanks for any help and insights into macros
> Chad
>
>
> ____________________
> Racket Users list:
> http://lists.racket-lang.org/users
>
____________________
Racket Users list:
http://lists.racket-lang.org/users
