[stringtemplate-interest] [ST4] How to avoid map key iteration?

[Udo Borkowski]

Hi Sam,

your suggestion of using a syntax like "line2(adr)" to invoke an anonymous template goes exactly in a direction I was thinking for a while now: 

(Start of dreams of the future)

The "Unified ST4 template" syntax 

Currently we defined "normal" templates like

    t1(p1,p2) ::= <<…>> 

or 

    t1(p1,p2) ::= "…"

Anonymous templates (or sub templates) are defines like 

    {p1,p2| …}.


What about defining a "normal" template like this:

    t1 = {p1,p2| …}

I.e. a "normal" template is just an anonymous template with a name, i.e. the template can be referenced through this name.

To invoke a template use the same syntax as before:  

    <t1(x,y)>

However one can also just *reference* a template (without invoking it), just by naming it without the (...).

The "iterate" feature would work on a (named or anonymous) template (as now), but would get a slightly different syntax for named templates:

    <x,y:t1>     

I.e. no "t1()" as with a template invocation, but just "t1" to reference the template. This perfectly fits into the "<x,y:{…}>" syntax: here the "{…}" is not written as "{…}()", too.

This changed syntax also makes the difference between a normal template call:

	<t2()>

and the iterate feature:

	<x,y:t1>

a little bit more obvious. (Another way to see this: the () behind the template name in an iterate feature serve no real purpose, they will always be empty).

To come back to my initial question "how to avoid map key iteration" I could imagine an extension to the "iterate" syntax:

Either

	<x*,y:t1>

Meaning: only the x parameter is used as an iterator, the other parameters are just passed to the template unchanged.

Or

	<x,y!:t1>

Meaning: every parameter not marked with "!" is used as an iterator.

( '*' and '!' are just used as examples. Use your favorite syntax here to mark a parameter either as "iterator" or as "pure value").


(End of dreams of the future)


Udo


On 14.02.2011, at 15:35, Sam Harwell wrote:

> Hi Udo,
>  
> The problem is the operation in use when you write it the way you originally did – the ‘:’ is a map operation as opposed to a pass to a function method. In theory, the following syntax could solve the problem:
>  
> t2(adr,line2={x|<x.zip> <x.city>}) ::= <<
> <adr.firstname> <adr.lastname>
> <line2(adr)>
> >> 
>  
> I know this syntax doesn’t work in ST3, and I’m guessing it doesn’t in ST4 either. Considering the way parameters and local variables work in many languages, I don’t think allowing this would be unexpected.
>  
> Sam
>  
> From: Udo Borkowski [mailto:ub at abego-software.de] 
> Sent: Monday, February 14, 2011 3:21 AM
> To: Sam Harwell
> Cc: stringtemplate-interest List
> Subject: Re: [stringtemplate-interest] [ST4] How to avoid map key iteration?
>  
> Hi Sam,
>  
> If you write it this way:
>  ...
>  <t2(adr=p,line2={<adr.city>, <adr.zip>})>
>  
> Good point.
>  
> I guess it is just my personal style (and background) that makes me raise the issue. Inside a subtemplate I'd prefer to access the parameters of the subtemplate (the {p1,p2|…}) over the access of something outside of the subtemplate, especially with the dynamic name lookup of ST4 in mind.
>  
>  
> Udo
>  

-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://www.antlr.org/pipermail/stringtemplate-interest/attachments/20110214/5be6e251/attachment.html