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.
PrevUpHomeNext

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] 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


PrevUpHomeNext