Compound Attribute Rules

Notation

The notation we will use will be 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>

reads as: given, a and b are parsers, 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. Finally, `Unused` stands for `unused_type`.

Compound Parser 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>
Expectation operator (`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): optional<A> a: A, b: B, c: Unused --> (a \| b \| c): optional<variant<A, B> > a: Unused, b: B --> (a \| b): optional<B> a: Unused, b: Unused --> (a \| b): Unused a: A, b: A --> (a \| b): A
Difference (`a - b`)	a: A, b: B --> (a - b): A a: Unused, b: B --> (a - b): Unused
Kleene (`*a`)	a: A --> a: vector<A> a: Unused --> a: Unused
Plus (`+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
`repeat(...,...)[a]`	a: A --> repeat(...,...)[a]: vector<A> a: Unused --> repeat(...,...)[a]: Unused
Sequential Or (`a \|\| b`)	a: A, b: B --> (a \|\| b): tuple<optional<A>, optional<B> > a: A, b: Unused --> (a \|\| b): optional<A> a: Unused, b: B --> (a \|\| b): optional<B> a: Unused, b: Unused --> (a \|\| b): Unused a: A, b: A --> (a \|\| b): vector<optional<A> >
Optional (`-a`)	a: A --> -a: optional<A> a: Unused --> -a: Unused
`&a`	`a: A --> &a: Unused`
`!b`	`a: A --> !a: Unused`
Permutation (`a ^ b`)	a: A, b: B --> (a ^ b): tuple<optional<A>, optional<B> > a: A, b: Unused --> (a ^ b): optional<A> a: Unused, b: B --> (a ^ b): optional<B> a: Unused, b: Unused --> (a ^ b): Unused