Re: guile-syntax-parse

[Stefan Israelsson Tampe]

Hi,

syntax-parse is quite a heavy where it basically defines a syntax-case + verifying logic from the beginning.

What I have played with a lighter version of that code and a kind of system around it that worked by
piggy-pack on guiles syntax-case.

It's not much code needed to get something that is acceptable for my uses here so this is what I did.

I redefined matchers so that one could enter validators inside the matcher like

(syntax-parse x () ((_ x y : list-of-symbols) #'(cons x y)))

If you did not have this information you would use syntax-case and write a verifier-function (list-of-symbols)
that is called in the first possition and send #'(x y) as the first argument to this function. This is what I
basically do as well.

So the gain is a clearer specification of what is allowed in the matcher. So not much logic here
to meet my humble need. The code does get significantly more self documented by this though.

I did try to get line-numbers in the error outputs but I somehow failed to do this correctly right now I just
get the function location where the error appear.

I have used this system quite alot and are found of it. And I strongly advocate to enter such a system into
guile. You get qute a lot of code readability and code patterns from quite a limitid amount of code.

I will try to writeup something more meaty the next days' but I hope you got a feeling for the general 
approach I took.

Oh, it really pay's off to write specifications for macros and report on errors reasonable exact. It really cut's down on debugging time.

Here is an example of how I use it
(define-syntax <const>
  (lambda (x)

    (define <tp>     (mk-type-vd         #t '<const>))
    (define <id>     (mk-identifier-vd   #t '<const>))
    (define <arg3> (mk-arg-vd          #t '<const> 3))

    (reg-form x)

    (syntax-parse x ()
      ((_ (t : <tp>) (s : <id>)  v : <arg3>)
       #'(begin
           (define s (mk-var (auto-type t)
                             (auto-t s)
                             (auto v)
                             'no-gensym))
           
           (set! *clambda*
                 (cons (c-const (c-var (auto-type t) (s #t) (v #t)))
                       *clambda*)))))))

(t : <tp>)

when there is only one element the the left of : then this is inetrpreted as (<tp> #'t) but idf we would have
(t1 t2 : <tp>) I would interpret it as (<tp> #'(t1 t2))

Regards
Stefan

On Wed, Nov 23, 2011 at 10:47 PM, Andy Wingo <address@hidden> wrote:

On Mon 09 May 2011 14:11, Stefan Israelsson Tampe <address@hidden> writes:

> Hi, check out guile-syntax-parse at
> https://gitorious.org/guile-syntax-parse/guile-syntax-parse

How is this going?  Are you still using it?

You didn't get any responses, but I'm still curious to see it working.
Syntax-parse sounds like a useful facility.  I'm offline at the moment,
but I would be interested in hearing about your experiences with this.

Cheers,

Andy
--
http://wingolog.org/