| Home | Libraries | People | FAQ | More

#### Compound Attribute Rules

###### Notation

The notation we use is of the form:

    a: A, b: B, ... --> composite-expression: composite-attribute

`a`, `b`, etc. are the operands. `A`, `B`, etc. are the operand's attribute types. `composite-expression` is the expression involving the operands and `composite-attribute` is the resulting attribute type of the composite expression.

For instance:

    a: A, b: B --> (a << b): tuple<A, B>

which reads as: given, `a` and `b` are generators, and `A` is the type of the attribute of `a`, and `B` is the type of the attribute of `b`, then the type of the attribute of `a << b` will be `tuple<A, B>`.

| Important

In the attribute tables, we will use `vector<A>` and `tuple<A, B...>` as placeholders only. The notation of `vector<A>` stands for any STL container holding elements of type `A` and the notation `tuple<A, B...>` stands for any Boost.Fusion sequence holding `A`, `B`, ... etc. elements. The notation of `variant<A, B, ...>` stands for a Boost.Variant capable of holding `A`, `B`, ... etc. elements. Finally, `Unused` stands for `unused_type`.

###### Compound Generator Attribute Types

Expression | Attribute
--- | ---

Sequence (`<<`) (`a << b`)

    a: A, b: B --> (a << b): tuple<A, B>
    a: A, b: Unused --> (a << b): A
    a: Unused, b: B --> (a << b): B
    a: Unused, b: Unused --> (a << b): Unused

    a: A, b: A --> (a << b): vector<A>
    a: vector<A>, b: A --> (a << b): vector<A>
    a: A, b: vector<A> --> (a << b): vector<A>
    a: vector<A>, b: vector<A> --> (a << b): vector<A>

Alternative (`|`) (`a | b`)

    a: A, b: B --> (a | b): variant<A, B>
    a: A, b: Unused --> (a | b): A
    a: Unused, b: B --> (a | b): B
    a: Unused, b: Unused --> (a | b): Unused
    a: A, b: A --> (a | b): A

Kleene (`*a`)

    a: A --> *a: vector<A>
    a: Unused --> *a: Unused

Plus (unary `+`) (`+a`)

    a: A --> +a: vector<A>
    a: Unused --> +a: Unused

List (`%`) (`a % b`)

    a: A, b: B --> (a % b): vector<A>
    a: Unused, b: B --> (a % b): Unused

Repetition (`repeat[]`)

    a: A --> repeat(...,...)[a]: vector<A>
    a: Unused --> repeat(...,...)[a]: Unused

Optional (unary `-`) (`-a`)

    a: A --> -a: optional<A>
    a: Unused --> -a: Unused

And predicate (unary `&`) (`&a`) | `a: A --> &a: A`
Not predicate (unary `!`) (`!a`) | `a: A --> !a: A`