Re: Enhancement to the syntax system?

[Stefan Israelsson Tampe <stefan.itampe@gmail.com>]

[-- Attachment #1.1: Type: text/plain, Size: 2725 bytes --]

Ok, I coded a suggested syntax that is a quick solution but maybe not ideal
because really this should be hanlded on the psyntax level. We probably
cannot use the old syntax because it can break old code in other words one
has to introduce new language elements. Also I asked on #scheme and tried
to look into reference documentation for quasisyntax semantics. The answer
I got on #scheme was that psyntax is buggy although I do not agree on that.
I also felt that people is suspicious of my approach which is to write one
macro and then dispatch to functions in stead of writing macro after macro.
In all I don't think I am able to lift this idea to a larger community.

So I sat down and implemented a simple algorithm see attachement. with this
I can write,

scheme@(guile-user)> (use-modules (syntax unquote++))
scheme@(guile-user)>
(define (f x)
  #`(let ((x 1)) #,x))

scheme@(guile-user)>
(define-syntax g
  (lambda (x)
    (syntax-case x ()
      ((_ y)
        ##`(let ((x y))
            #.((x) (f #'x)))))))

scheme@(guile-user)> (g 4)
$1 = 4

This will explicitly state what variables to transfer to the inserted
expression. It's not ideal because I
feel that the good way to handle this is to implicitly, which demands
hacking psyntax, do this and simplify the syntax even more. also I cannot
see how to implement #.@ but to hack psyntax.

##` also allow #, and #,@ which has the old meaning.

Have fun
/Stefan

On Mon, Jul 9, 2012 at 5:52 PM, Ludovic Courtès <ludo@gnu.org> wrote:

> Hi!
>
> Stefan Israelsson Tampe <stefan.itampe@gmail.com> skribis:
>
> > You do not need gensyms if you try to mimic or implement my suggested #.
> .
> > On the
> > other hand when if you do this
> >
> > (define (f stx) #`(let ((x 1)) #,stx))
> >
> > and use this with
> >
> > #`(let ((x 2)) #,(f #'x))
>
> OK, got it, thanks!
>
> (In case others wonder, the complete example is:
>
>   (define (f stx)
>     #`(let ((x 1)) #,stx))
>   (define-syntax foo
>     (lambda (s)
>       (syntax-case s ()
>         ((_)
>          #`(let ((x 2)) #,(f #'x))))))
>
>   (foo)
>   => 1
> )
>
> The situation can be diagnosed with:
>
>   (define (f stx)
>     #`(let ((x 1))
>       #,(if (bound-identifier=? stx #'x) (error) stx)))
>
> But it doesn’t help.
>
> > (with-syntax ((x (datum->syntax stx (gensym "x")))) #`(let ((x 2)) #,(f
> > #'x))))))
>
> Often, you could use ‘generate-temporaries’, which is a bit nicer.
>
> > Hope that this makes things clear!
>
> It does, thanks!
>
> It’s true that it’s annoying that the wrong binding is silently used.
> Do you think it’s common enough to justify new syntax?
>
> Thanks,
> Ludo’.
>
>
>

[-- Attachment #1.2: Type: text/html, Size: 3457 bytes --]

[-- Attachment #2: unquote++.scm --]
[-- Type: application/octet-stream, Size: 1237 bytes --]

(define-module (syntax unquote++)
  #:export (quasisyntax++ insyntax))

(define *s* (make-fluid '()))

(define (parse stx x)
  (syntax-case x (unsyntax insyntax unsyntax-splicing)
    ((unsyntax          . _) x)
    ((unsyntax-splicing . _) x)
    ((insyntax ((p ...) c ...))
     (with-syntax ((g (datum->syntax stx (gensym "g"))))
       (fluid-set! *s* (cons #'(g (lambda (x) 
                                    (syntax-case x () 
                                      ((_ p ...) (begin c ...)))))
                             (fluid-ref *s*)))
       #'(g p ...)))
    ((x . l)
     (cons (parse stx #'x) (parse stx #'l)))
    (x #'x)))

(define-syntax quasisyntax++
  (lambda (x)
    (syntax-case x ()
      ((_ y)
       (begin
         (fluid-set! *s* '())
         (with-syntax ((statement (parse x #'y))
                       (lets      (fluid-ref *s*)))
           #'(quasisyntax (let-syntax lets statement))))))))
               
(define (rg ch stream)
  (let ((x (read-char stream)))
    (cond
     ((eqv? x #\`)
      `(quasisyntax++ ,(read stream)))
     (#t
      (error "Wrong format of # reader extension")))))

(define (rg. ch stream) `(insyntax ,(read stream)))

(read-hash-extend #\# rg)
(read-hash-extend #\. rg.)