An interesting peculiarity of functions like at when applied to a Forward
Sequence like list
is that what could have been linear runtime complexity effectively becomes
constant O(1) due to compiler optimization of C++ inlined functions, however
deeply recursive (up to a certain compiler limit of course). Compile time complexity
remains linear.

Associative sequences use function overloading to implement membership testing
and type associated key lookup. This amounts to constant runtime and amortized
constant compile time complexities. There is an overloaded function, f(k), for each key typek. The compiler chooses the appropriate function
given a key, k.

Unlike MPL, there
is no extensibe sequence concept in fusion. This does not mean that Fusion
sequences are not extensible. In fact, all Fusion sequences are inherently
extensible. It is just that the manner of sequence extension in Fusion is diferent
from both STL
and MPL on account
of the lazy nature of fusion Algorithms.
STL
containers extend themselves in place though member functions such as push_back and insert. MPL
sequences, on the other hand, are extended through "intrinsic" functions
that actually return whole sequences. MPL
is purely functional and can not have side effects. For example, MPL's
push_back does not actually
mutate an mpl::vector. It can't do that. Instead, it returns
an extended mpl::vector.

Like MPL, Fusion
too is purely functional and can not have side effects. With runtime efficiency
in mind, Fusion sequences are extended through generic functions that return
Views. Views
are sequences that do not actually contain data, but instead impart an alternative
presentation over the data from one or more underlying sequences. Views
are proxies. They provide an efficient yet purely functional way to work on
potentially expensive sequence operations. For example, given a vector, Fusion's push_back returns a joint_view, instead of an actual extended
vector.
A joint_view
holds a reference to the original sequence plus the appended data --making
it very cheap to pass around.

Functions that take in elemental values to form sequences (e.g. make_list) convert their arguments
to something suitable to be stored as a sequence element. In general, the element
types are stored as plain values. Example:

Sometimes the plain non-reference type is not desired. You can use boost::ref
and boost::cref to store references or const references
(respectively) instead. The mechanism does not compromise const correctness
since a const object wrapped with ref results in a tuple element with const
reference type (see the fifth code line below). Examples:

To adapt arbitrary data types that do not allow direct access to their members,
but allow indirect access via expressions (such as invocations of get- and
set-methods), fusion's BOOST_FUSION_ADAPT_xxxADTxxx-family
(e.g. BOOST_FUSION_ADAPT_ADT)
may be used. To bypass the restriction of not having actual lvalues that represent
the elements of the fusion sequence, but rather a sequence of paired expressions
that access the elements, the actual return type of fusion's intrinsic sequence
access functions (at, at_c, at_key, deref, and deref_data) is a proxy type, an instance
of adt_attribute_proxy, that
encapsulates these expressions.

adt_attribute_proxy is defined
in the namespace boost::fusion::extension and has three template arguments:

When adapting a class type, adt_attribute_proxy
is specialized for every element of the adapted sequence, with Type being the class type that is adapted,
Index the 0-based indices of
the elements, and Const both
true and false.
The return type of fusion's intrinsic sequence access functions for the Nth
element of an adapted class type type_name
is adt_attribute_proxy<type_name, N, Const>,
with Const being true
for constant instances of type_name
and false for non-constant ones.

Notation

type_name

The type to be adapted, with M attributes

inst

Object of type type_name

const_inst

Object of type type_nameconst

(attribute_typeN, attribute_const_typeN,
get_exprN, set_exprN)

Attribute descriptor of the Nth attribute of type_name as passed to the adaption
macro, 0≤N<M

proxy_typeN

adt_attribute_proxy<type_name, N, false> with N
being an integral constant, 0≤N<M

const_proxy_typeN

adt_attribute_proxy<type_name, N, true> with N
being an integral constant, 0≤N<M

proxyN

Object of type proxy_typeN

const_proxyN

Object of type const_proxy_typeN

Expression Semantics

Expression

Semantics

proxy_typeN(inst)

Creates an instance of proxy_typeN
with underlying object inst

const_proxy_typeN(const_inst)

Creates an instance of const_proxy_typeN
with underlying object const_inst

proxy_typeN::type

Another name for attribute_typeN

const_proxy_typeN::type

Another name for const_attribute_typeN

proxyN=t

Invokes set_exprN, with
t being an arbitrary
object. set_exprN may access
the variables named obj
of type type_name&, which represent the corresponding
instance of type_name,
and val of an arbitrary
const-qualified reference template type parameter Val,
which represents t.

proxyN.get()

Invokes get_exprN and forwards
its return value. get_exprN
may access the variable named obj
of type type_name& which represents the underlying
instance of type_name.
attribute_typeN may specify
the type that get_exprN denotes
to.

const_proxyN.get()

Invokes get_exprN and forwards
its return value. get_exprN
may access the variable named obj
of type type_nameconst&
which represents the underlying instance of type_name.
attribute_const_typeN may
specify the type that get_exprN
denotes to.

Additionally, proxy_typeN and const_proxy_typeN
are copy constructible, copy assignable and implicitly convertible to proxy_typeN::type
or const_proxy_typeN::type.

[13]
Note that the type of a string literal is an array of const characters, not
constchar*. To get make_list to create a list with an element of a non-const
array type one must use the ref
wrapper (see boost::ref).