macro tagOpen : XmlAst.TagOpen
  syntax: lt:'<' s id:identifier attrs:attr* gt:'>' s

Z>macro attrList(attrs : params array[XmlAst.Attr]) // эквивалентно syntax attrList "(" attrs : attr* ")"
Z>{}
Z>

macro class Xml
{
  macro tagOpen : XmlAst.TagOpen
  syntax: '<' identifier attrs '>'
  where 
    attrs: attr*
  {
    TagOpen(identifier.Value, attrs.Map(x => x.Value :> Attr))
  }

  macro attr : XmlAst
  syntax: identifier '=' attrValue
  {
    Attr(identifier, attrValue)
  }
}

  macro tagOpen : XmlAst.TagOpen
  syntax: '<' identifier {attrs attr*} '>'
  {
    TagOpen(identifier.Value, attrs.Map(x => x.Value :> Attr))
  }

  macro tagOpen : XmlAst.TagOpen
  syntax: {lt '<'} identifier attrs {gt '>'}
  where 
    attrs: attr*
  {
    TagOpen(lt.StartPos, gt.EndPos, identifier.Value, attributes.Map(x => x.Value :> Attr))
  }

 '<' nospace identifier nospace '>'.

lt:'<'

macro MyMacro...
priority: SomeMacro > this > OtherMacro // т.е. текущий макрос мене приоритетный нежели SomeMacro но более приоритетный нежели OtherMacro

Z>Это пока на уровне интуиции Видится что-то типа http://rsdn.ru/forum/dotnet/3851708.1.aspx

Автор: nikov
Дата: 22.06.10

.

  macro tagOpen : XmlAst.TagOpen
  syntax: lt identifier attrs gt;
  where 
    attrs = attr*;
    lt    = '<';
    gt    = '>';
  {
    ...
  }

ТЗИ>  macro tagOpen : XmlAst.TagOpen
ТЗИ>  syntax: '<' identifier {attrs attr*} '>'
ТЗИ>  {
ТЗИ>    TagOpen(identifier.Value, attrs.Map(x => x.Value :> Attr))
ТЗИ>  }
ТЗИ>

ТЗИ>  macro tagOpen : XmlAst.TagOpen
ТЗИ>  syntax: {lt '<'} identifier attrs {gt '>'}
ТЗИ>  where 
ТЗИ>    attrs: attr*
ТЗИ>  {
ТЗИ>    TagOpen(lt.StartPos, gt.EndPos, identifier.Value, attributes.Map(x => x.Value :> Attr))
ТЗИ>  }
ТЗИ>

  macro tagOpen : XmlAst.TagOpen
  syntax: lt:'<' identifier attrs gt:'>';
  where 
    attrs = attr* // "Равно" здесь более уместно. Как вариант, можно использовать "<-" раз уж мы используем PEG
  {
    ...
  }

ТЗИ> '<' nospace identifier nospace '>'.
ТЗИ>

 '<'identifier'>'.

macro FooMacro
{
    dependencies // отдельно описать зависимости
    {
        BarMacro, 
        BazMacro
    }

    parameters // отдельно — параметры и их типы
    {
        First  : BarMacro
        Second : BazMacro
        Third  : PExpr
        Fourth : int
    }

    syntax // отдельно — синтаксис (почему бы его не описывать PEG-грамматикой, если он все равно к ней сводится)
    {
        FooMacro = ShortMode | LongMode
        ShortMode = First * 
        LongMode = Third *
    }
 
    beforeTypedMembers // отдельно — реализацию для каждой фазы компиляции
    {
         // blah blah
    }

}

language Xml
{
    macro XmlAttr: Xml.Attr
    syntax name '=' value
    where name : PExpr.Ref, value : PExpr.Expr
    {
       Xml.Attr(name.Name, value);
    }

    macro XmlNodeStart: Xml.NodeStart
    syntax '<' name attrs:attr* '>' 
    where name : PExpr.Ref, attr : Xml.Attr
    {
       Xml.NodeStart(name.Name, attrs)
    }

    macro XmlNodeEnd: Xml.NodeEnd
    syntax '</' name  '>'
    where name : PExpr.Ref
    {
       Xml.NodeEnd(name)
    }

    macro XmlNode: Xml.Node
    syntax start nodes:node* end
    where start : Xml.NodeStart, 
          node  : Xml.Node, 
          end   : Xml.NodeEnd
    {
      assert(start.Name == end.Name);
      Xml.Node(start.Name, start.Attrs, nodes)
    }
}
// program
using language Xml
{
  def x = <foo x="1">; // def x = Xml.NodeStart("foo", [Xml.Attr("x", "1")])

  def str = "1";
  def x = <foo x="1">; // def x = Xml.NodeStart("foo", [Xml.Attr("x", str)])

  def attr = Xml.Attr("x", "1");
  def x = <foo <( [attr : Xml.Attr] )> ></foo>; // def x = Xml.Node(foo, [attr], [])
}

language Xml
{
    macro XmlAttr: (Xml.Attr | PExpr)
    syntax name '=' value
    where name : PExpr.Ref, value : PExpr.Expr
    {
       | Xml.Attr => Xml.Attr(name.Name, value);
       | PExpr    => <[ Xml.Attr( $(name.Name : string), $value); ]>
    }
}