Boost C++ Libraries

...one of the most highly regarded and expertly designed C++ library projects in the world. — Herb Sutter and Andrei Alexandrescu, C++ Coding Standards

This is the documentation for an old version of Boost. Click here to view this page for the latest version.

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