[racket] Lazy syntax class attributes

From: Eric Dobson (eric.n.dobson at gmail.com)
Date: Fri May 31 11:35:30 EDT 2013

That seems like more syntax in the use than just #`(complicated
#,((attribute e.v))), which I can get with just thunking the
computation. The thunk it self can manipulate a promise to make sure
the effects only happen once.

I'm pretty sure I could use a rename transformer struct property and a
chaperoned struct to have any effects I want on pattern variable
lookup (as it tries to lookup the slot in the struct), but I still
need to return the original pattern variable id from the transformer,
so that doesn't let me change the final value of the lookup. Note that
this is untested.

On Fri, May 31, 2013 at 8:25 AM, J. Ian Johnson <ianj at ccs.neu.edu> wrote:
> You could also make a compile-time macro that will introduce several identifier macros to your syntax-class pattern right-hand-sides like
> (define-lazy-syntax-class blah
>   (pattern pat #:lazy-wrap [complicated (e.v ...)] rhs ...) ...)
> =>
> ;; generate ((force-e.v ...) ...)
> (define-syntax-class blah
>   (pattern pat #:do [(define-syntax (force-e.v stx)
>                       (syntax-case stx (e.v)
>                         [e.v #`(complicated #,(force (attribute e.v))])) ...]
>     rhs ...) ...)
> This way you can make the attributes promises (at compile time) to later force when using them in rhs ...
> Too much?
> -Ian
> ----- Original Message -----
> From: "Eric Dobson" <eric.n.dobson at gmail.com>
> To: "Matthias Felleisen" <matthias at ccs.neu.edu>
> Cc: users at racket-lang.org
> Sent: Friday, May 31, 2013 11:00:13 AM GMT -05:00 US/Canada Eastern
> Subject: Re: [racket] Lazy syntax class attributes
> That seems like a a workable amount of overhead, but I'm not sure what
> you are suggesting the v attribute to be bound as. It might have not
> been obvious from my my example that its value depends on the slow
> computation, so unless pattern variables can be mutated I'm not sure
> how force-all can change what e.v resolves to.
> On Fri, May 31, 2013 at 5:18 AM, Matthias Felleisen
> <matthias at ccs.neu.edu> wrote:
>> Can you prefix the #'(complicated ..) expression with a form
>> that forces all lazy computations so that complicated itself
>> remains the same?
>>   (let () (force-all) #'(complicated (form e.v)))
>> where force-all is defined via a begin in the slow syntax class?
>> -- Matthias
>> On May 31, 2013, at 2:47 AM, Eric Dobson wrote:
>>> I'm working on code (TR optimizer) that needs to match some
>>> expressions and then compute an attribute based on the expression. I
>>> would like to abstract this out as a syntax class. Example is below:
>>> #lang racket
>>> (require syntax/parse)
>>> (define-syntax-class slow
>>>  (pattern e:expr
>>>           #:with v (begin (displayln 'slow) #''e)))
>>> (syntax-parse #'(x 2)
>>>  ((e:slow 1) #'(complicated (form e.v)))
>>>  ((e:slow 2) #'(complicated (form e.v))))
>>> The issue is that computing the attribute is slow/expensive/effectful
>>> and so I only want to do the calculation in the case that I use the
>>> result. One solution is to attach a thunk as the attribute value, but
>>> this requires changing #'(complicated (form e.v)) to #`(complicated
>>> (form #,((attribute e.v)))) which quickly becomes less readable with
>>> many such attributes in the final syntax object. Is there a way to do
>>> this in a lazy manner that does not complicate the use of the syntax
>>> class? I'm fine adding complexity to the creation of the syntax class
>>> because it is a one time cost versus the many places where the syntax
>>> class would be used.
>>> ____________________
>>>  Racket Users list:
>>>  http://lists.racket-lang.org/users
> ____________________
>   Racket Users list:
>   http://lists.racket-lang.org/users

Posted on the users mailing list.