Re: Opaque syntax objects

[Jens Axel Søgaard <jensaxel@xxxxxxxxxxxx>]

Andre van Tonder wrote:
> On Sun, 14 Aug 2005, [ISO-8859-1] Jens Axel Søgaard wrote:
>
> > What should I do if I want to give a piece of (expanded) syntax the
> > same source information as, say, the macro call?
>
> There can be a primitive for that.  E.g.,
>   annotate : (syntax-object, syntax-object) -> syntax-object
> In the hash-table, this would insert a new entry for the pair 
> representing the second syntax object, copying the annotation of the first.
>
> > > Of course.  Syntax objects are still ordinary pairs.  No change to 
> > > car/cdr is required.  The hash table with source information is kept 
> > > separately.
> >
> > Hmm. How do you represent identifiers?
>
> The same way, once you give them a wrap to give them separate identities.

So identifiers are represented as a special type. How about atoms?
Can I annotate a piece of syntax representing, say, a number?

> > I believe with-syntax behaves that way in order to be (more) compatible
> > with the psyntax-implementation. Note that the source location
> > information for stx-expr in
> >
> >  (with-syntax ((pattern stx-expr) ...) expr)
> >
> > is taken from stx-expr, when stx-expr is not returning a list. That
> > is the source location is still tracked.
>
> Do you know what location is assigned when stx-expr is a list?

(with-syntax ((a-list #'(1 2 3))) (syntax-position #'a-list))
evaluates to 25

(with-syntax ((a-list (list 1 2 3))) (syntax-position #'a-list))
evalutes to #f

(with-syntax ((a-list (list #'x)))
  (syntax-case #'a-list ()
    [(y)
     (syntax-position #'y)]))
evaluates to 31

> As an aside, it is sometimes easy to throw away too much information 
> when using the destructuring idiom.  For example, in
>
>   (define-syntax let1
>     (lambda (form)
>       (syntax-case form ()
>         ((_ ((i e) ...) e1 e2 ...)
>          (syntax (let ((i e) ...) e1 e2 ...))))))
>
> it is unlikely that most implementations would keep the location of the 
> input subnode ((i e) ...) in the result.

Keeping them makes it possible to give much better error messages.
As a quick test this:

(define-syntax let1
  (lambda (form)
    (syntax-case form ()
      ((_ ((i e) ...) e1 e2 ...)
       (syntax (let2 ((i e) ...) e1 e2 ...))))))

(define-syntax let2
  (lambda (form)
    (syntax-case form ()
      ((_ ((i e) ...) e1 e2 ...)
       (with-syntax (((i1 . _) #'(i ...)))
         (display "line: ")
         (display (syntax-line #'i1))
         (display " col: ")
         (display (syntax-column #'i1))
         (newline)
         #'(let ((i e) ...) e1 e2 ...))))))

(let1 ((x 41))
  (+ x 1))

prints  "line: 19 col: 8" and evaluates to 42 in DrScheme.

--
Jens Axel Søgaard