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

Click here to view the latest version of this page.
PrevUpHomeNext

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


PrevUpHomeNext