[racket] Sometimes (syntax-e #<syntax (lambda (x) #f)>) produces a non-list pair

Thanks, using syntax->list solved the problem.  

On Apr 17, 2014, at 12:22 AM, Carl Eastlund <carl.eastlund at gmail.com> wrote:

> Syntax objects are a rather complex data type, especially where pairs and lists are involved.  Essentially, a syntax object containing a list can be broken up with extra syntax nodes at all, some, or none of its intermediate conses, depending on how it is constructed.  For example, if you just write #'(1 2 3), there will be one syntax node at the top level and none anywhere else.  If you write #'(1 . (2 . (3 . ()))) instead, you get syntax nodes at each step along the way.  The syntax objects differ, even though '(1 2 3) and '(1 . (2 . (3 . ()))) produce the same value.
> 
> So what happened in your program?  Well, when you define f2 using proc-with-stx, the define-syntax-rule from proc-with-stx substitutes (lambda (x) #f) in for expr, and your syntax object is therefore [essentially] #'(lambda (x) #f).  It's a straightforward list, one syntax node at the top level.
> 
> When you define f using lambda-with-stx, however, the define-syntax-rule for lambda-with-stx has to substitute (x) for args and #f for body ... in (lambda args body ...).  I'm guessing the result comes out something like (lambda . ((x) . (#f . ()))); the process may just automatically put a syntax node at each cons.  Then proc-with-stx substitutes that for expr, and you get [essentially] #'(lambda . ((x) . (#f . ()))).
> 
> Basically, you can't rely on where syntax-e will split up a list into syntax objects unless you constructed it yourself.  If you want predictable results, use syntax->list or syntax->datum.
> 
> Carl Eastlund
> 
> 
> On Wed, Apr 16, 2014 at 10:33 PM, Alexander D. Knauth <alexander at knauth.org> wrote:
> Basically, I have a macro, called proc-with-stx, that captures an expression and stores it in a syntax object, and I have another macro, called lambda-with-stx, that expands to (proc-with-stx (lambda …)).
> When I use (proc-with-stx (lambda (x) #f), then the syntax-e of the syntax-object is a list, but when I use (lambda-with-stx (x) #f), which should expand to the same thing, the syntax-e of the syntax-object is a non-list pair:
> 
> #lang racket
> 
> (module+ test
>   (require rackunit))
> 
> (struct proc+stx (proc stx)
>   #:property prop:procedure (struct-field-index proc))
> 
> (define-syntax-rule (proc-with-stx expr)
>   (proc+stx expr #'expr))
> 
> (define-syntax-rule (lambda-with-stx args body ...)
>   (proc-with-stx (lambda args body ...)))
> 
> (module+ test
>   (define f
>     (lambda-with-stx (x) #f))
>   (define f2                               ; f should expand to f2
>     (proc-with-stx (lambda (x) #f)))
> 
>   (define f-stx  (proc+stx-stx f))
>   (define f2-stx (proc+stx-stx f2))
> 
>   ;; tests for f:
>   (check-true (procedure? f))
>   (check-equal? (f 1) #f)
>   (check-pred list? (syntax-e f-stx)) ; this test fails, produces '(#<syntax lambda> #<syntax (x)> . #<syntax (#f)>) instead
>   ;; same tests for f2
>   (check-true (procedure? f2))
>   (check-equal? (f2 1) #f)
>   (check-pred list? (syntax-e f2-stx)) ; this test passes, produces '(#<syntax lambda> #<syntax (x)> #<syntax #f>)
>   )
> 
> Why doesn't (syntax-e f-stx) produce a list like (syntax-e f2stx) does?
> 
> 
> 
> ____________________
>   Racket Users list:
>   http://lists.racket-lang.org/users
> 
> 

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.racket-lang.org/users/archive/attachments/20140417/16d8d569/attachment.html>