[/==============================================================================
    Copyright (C) 2001-2011 Joel de Guzman
    Copyright (C) 2006 Dan Marsden

    Use, modification and distribution is subject to the Boost Software
    License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
    http://www.boost.org/LICENSE_1_0.txt)
===============================================================================/]
[section Container]

Fusion provides a few predefined sequences out of the box. These
/containers/ actually hold heterogeneously typed data; unlike
__views__. These containers are more or less counterparts of those in __stl__.

[heading Header]

    #include <boost/fusion/container.hpp>
    #include <boost/fusion/include/container.hpp>

[section vector]

[heading Description]

`vector` is a __random_access_sequence__ of heterogeneous typed data
structured as a simple `struct` where each element is held as a member
variable. `vector` is the simplest of the Fusion sequence container (a
vector with N elements is just a struct with N members), and in many
cases the most efficient.

[heading Header]

    #include <boost/fusion/container/vector.hpp>
    #include <boost/fusion/include/vector.hpp>
    #include <boost/fusion/container/vector/vector_fwd.hpp>
    #include <boost/fusion/include/vector_fwd.hpp>

    // numbered forms
    #include <boost/fusion/container/vector/vector10.hpp>
    #include <boost/fusion/include/vector10.hpp>
    #include <boost/fusion/container/vector/vector20.hpp>
    #include <boost/fusion/include/vector20.hpp>
    #include <boost/fusion/container/vector/vector30.hpp>
    #include <boost/fusion/include/vector30.hpp>
    #include <boost/fusion/container/vector/vector40.hpp>
    #include <boost/fusion/include/vector40.hpp>
    #include <boost/fusion/container/vector/vector50.hpp>
    #include <boost/fusion/include/vector50.hpp>

[heading Synopsis]

[*Numbered forms]

    struct vector0;

    template <typename T0>
    struct vector1;

    template <typename T0, typename T1>
    struct vector2;

    template <typename T0, typename T1, typename T2>
    struct vector3;

    ...

    template <typename T0, typename T1, typename T2..., typename TN>
    struct vectorN;

[important Numbered forms will be deprecated in C++11 and it will be provided
           via aliasing templates. It means that your partial specialization
           might be compile error. You can detect whether it is aliasing
           templates or not, using `BOOST_FUSION_HAS_VARIADIC_VECTOR`.]

[*Variadic form]

    template <
        typename T0 = __unspecified__
      , typename T1 = __unspecified__
      , typename T2 = __unspecified__
        ...
      , typename TN = __unspecified__
    >
    struct vector;

The numbered form accepts the exact number of elements. Example:

    vector3<int, char, double>

For C++11 compilers, the variadic function interface has no upper bound.

For C++03 compilers, the The variadic form accepts `0` to
`FUSION_MAX_VECTOR_SIZE` elements, where `FUSION_MAX_VECTOR_SIZE` is a
user definable predefined maximum that defaults to `10`. Example:

    vector<int, char, double>

You may define the preprocessor constant `FUSION_MAX_VECTOR_SIZE` before
including any Fusion header to change the default. Example:

    #define FUSION_MAX_VECTOR_SIZE 20

[heading Template parameters]

[table
    [[Parameter]            [Description]               [Default]]
    [[`T0`...`TN`]          [Element types]             [__unspecified__]]
]

[heading Model of]

* __random_access_sequence__

[variablelist Notation
    [[`v`]              [Instance of `vector`]]
    [[`V`]              [A `vector` type]]
    [[`e0`...`en`]      [Heterogeneous values]]
    [[`s`]              [A __forward_sequence__]]
]

[heading Expression Semantics]

Semantics of an expression is defined only where it differs from, or is not
defined in __random_access_sequence__.

[table
    [[Expression]           [Semantics]]
    [[`V()`]                [Creates a vector with default constructed elements.]]
    [[`V(e0, e1,... en)`]   [Creates a vector with elements `e0`...`en`.]]
    [[`V(s)`]               [Copy constructs a vector from a __forward_sequence__, `s`.]]
    [[`v = s`]              [Assigns to a vector, `v`, from a __forward_sequence__, `s`.]]
]

[heading Example]

    vector<int, float> v(12, 5.5f);
    std::cout << __at_c__<0>(v) << std::endl;
    std::cout << __at_c__<1>(v) << std::endl;

[endsect]

[section cons]

[heading Description]

`cons` is a simple __forward_sequence__. It is a lisp style recursive list
structure where `car` is the /head/ and `cdr` is the /tail/: usually
another cons structure or `nil`: the empty list. Fusion's __list__ is built
on top of this more primitive data structure. It is more efficient than
__vector__ when the target sequence is constructed piecemeal (a data at a
time). The runtime cost of access to each element is peculiarly constant
(see __recursive_inline__).

[heading Header]

    #include <boost/fusion/container/list/cons.hpp>
    #include <boost/fusion/include/cons.hpp>

[heading Synopsis]

    template <typename Car, typename Cdr = nil>
    struct cons;

[heading Template parameters]

[table
    [[Parameter]            [Description]               [Default]]
    [[`Car`]                [Head type]                 [ ]]
    [[`Cdr`]                [Tail type]                 [`nil`]]
]

[heading Model of]

* __forward_sequence__

[variablelist Notation
    [[`nil`]            [An empty `cons`]]
    [[`C`]              [A `cons` type]]
    [[`l`, `l2`]        [Instances of `cons`]]
    [[`car`]            [An arbitrary data]]
    [[`cdr`]            [Another `cons` list]]
    [[`s`]              [A __forward_sequence__]]
    [[`N`]              [An __mpl_integral_constant__]]
]

[heading Expression Semantics]

Semantics of an expression is defined only where it differs from, or is not
defined in __forward_sequence__.

[table
    [[Expression]           [Semantics]]
    [[`nil()`]              [Creates an empty list.]]
    [[`C()`]                [Creates a cons with default constructed elements.]]
    [[`C(car)`]             [Creates a cons with `car` head and default constructed tail.]]
    [[`C(car, cdr)`]        [Creates a cons with `car` head and `cdr` tail.]]
    [[`C(s)`]               [Copy constructs a cons from a __forward_sequence__, `s`.]]
    [[`l = s`]              [Assigns to a cons, `l`, from a __forward_sequence__, `s`.]]
    [[`__at__<N>(l)`]           [The Nth element from the beginning of the sequence; see __at__.]]
]

[note `__at__<N>(l)` is provided for convenience and compatibility
with the original __tuple__ library, despite `cons` being a
__forward_sequence__ only (`at` is supposed to be a
__random_access_sequence__ requirement). The runtime complexity of __at__ is
constant (see __recursive_inline__).]

[heading Example]

    cons<int, cons<float> > l(12, cons<float>(5.5f));
    std::cout << __at_c__<0>(l) << std::endl;
    std::cout << __at_c__<1>(l) << std::endl;

[endsect]

[section list]

[heading Description]

`list` is a __forward_sequence__ of heterogeneous typed data built on top of
__cons__. It is more efficient than __vector__ when the target sequence is
constructed piecemeal (a data at a time). The runtime cost of access to
each element is peculiarly constant (see __recursive_inline__).

[heading Header]

    #include <boost/fusion/container/list.hpp>
    #include <boost/fusion/include/list.hpp>
    #include <boost/fusion/container/list/list_fwd.hpp>
    #include <boost/fusion/include/list_fwd.hpp>

[heading Synopsis]

    template <
        typename T0 = __unspecified__
      , typename T1 = __unspecified__
      , typename T2 = __unspecified__
        ...
      , typename TN = __unspecified__
    >
    struct list;

For C++11 compilers, the variadic function interface has no upper bound.

For C++03 compilers, the variadic class interface accepts `0` to
`FUSION_MAX_LIST_SIZE` elements, where `FUSION_MAX_LIST_SIZE` is a user
definable predefined maximum that defaults to `10`. Example:

    list<int, char, double>

You may define the preprocessor constant `FUSION_MAX_LIST_SIZE` before
including any Fusion header to change the default. Example:

    #define FUSION_MAX_LIST_SIZE 20

[heading Template parameters]

[table
    [[Parameter]            [Description]               [Default]]
    [[`T0`...`TN`]          [Element types]             [__unspecified__]]
]

[heading Model of]

* __forward_sequence__

[variablelist Notation
    [[`L`]              [A `list` type]]
    [[`l`]              [An instance of `list`]]
    [[`e0`...`en`]      [Heterogeneous values]]
    [[`s`]              [A __forward_sequence__]]
    [[`N`]              [An __mpl_integral_constant__]]
]

[heading Expression Semantics]

Semantics of an expression is defined only where it differs from, or is not
defined in __forward_sequence__.

[table
    [[Expression]           [Semantics]]
    [[`L()`]                [Creates a list with default constructed elements.]]
    [[`L(e0, e1,... en)`]   [Creates a list with elements `e0`...`en`.]]
    [[`L(s)`]               [Copy constructs a list from a __forward_sequence__, `s`.]]
    [[`l = s`]              [Assigns to a list, `l`, from a __forward_sequence__, `s`.]]
    [[`__at__<N>(l)`]           [The Nth element from the beginning of the sequence; see __at__.]]
]

[note `__at__<n>(l)` is provided for convenience and compatibility
with the original __tuple__ library, despite `list` being a
__forward_sequence__ only (__at__ is supposed to be a
__random_access_sequence__ requirement). The runtime complexity of __at__ is
constant (see __recursive_inline__).]

[heading Example]

    list<int, float> l(12, 5.5f);
    std::cout << __at_c__<0>(l) << std::endl;
    std::cout << __at_c__<1>(l) << std::endl;

[endsect]

[section deque]

[heading Description]

`deque` is a simple __bidirectional_sequence__ that supports
constant-time insertion and removal of elements at both ends. Like the
__list__ and __cons__, `deque` is more efficient than __vector__
(especially at compile time) when the target sequence is constructed
piecemeal (a data at a time, e.g. when constructing expression
templates). Like the __list__ and __cons__, runtime cost of access to
each element is peculiarly constant (see __recursive_inline__).

Element insertion and removal are done by special `deque` helper classes
__front_extended_deque__ and __back_extended_deque__.

[heading Header]

    #include <boost/fusion/container/deque.hpp>
    #include <boost/fusion/include/deque.hpp>
    #include <boost/fusion/container/deque/deque_fwd.hpp>
    #include <boost/fusion/include/deque_fwd.hpp>

[heading Synopsis]

    template <typename ...Elements>
    struct deque;

For C++11 compilers, the variadic class interface has no upper bound.

For C++03 compilers, the variadic class interface accepts `0` to
`FUSION_MAX_DEQUE_SIZE` elements, where `FUSION_MAX_DEQUE_SIZE` is a
user definable predefined maximum that defaults to `10`. Example:

    deque<int, char, double>

You may define the preprocessor constant `FUSION_MAX_DEQUE_SIZE` before
including any Fusion header to change the default. Example:

    #define FUSION_MAX_DEQUE_SIZE 20

[heading Template parameters]

[table
    [[Parameter]            [Description]               [Default]]
    [[`Elements`]           [Element types]             [ ]]
]

[heading Model of]

* __bidirectional_sequence__

[variablelist Notation
    [[`D`]              [A `deque` type]]
    [[`d`, `d2`]        [Instances of `deque`]]
    [[`e0`...`en`]      [Heterogeneous values]]
    [[`s`]              [A __forward_sequence__]]
    [[`N`]              [An __mpl_integral_constant__]]
]

[heading Expression Semantics]

Semantics of an expression is defined only where it differs from, or is not
defined in __bidirectional_sequence__.

[table
    [[Expression]           [Semantics]]
    [[`D()`]                [Creates a deque with default constructed elements.]]
    [[`D(e0, e1,... en)`]   [Creates a deque with elements `e0`...`en`.]]
    [[`D(s)`]               [Copy constructs a deque from a __forward_sequence__, `s`.]]
    [[`d = s`]              [Assigns to a deque, `d`, from a __forward_sequence__, `s`.]]
    [[`__at__<N>(d)`]       [The Nth element from the beginning of the sequence; see __at__.]]
]

[note `__at__<N>(d)` is provided for convenience, despite
`deque` being a __bidirectional_sequence__ only (`at` is supposed to be
a __random_access_sequence__ requirement). The runtime complexity of
__at__ is constant (see __recursive_inline__). `deque` element access
utilizes operator overloading with argument dependent lookup (ADL) of
the proper element getter function given a static constant index
parameter. Interestingly, with modern C++ compilers, this lookup is very
fast and rivals recursive template instantiations in compile time-speed,
so much so that `deque` relies on ADL for all element access (indexing)
as well as iteration.]

[heading Example]

    deque<int, float> d(12, 5.5f);
    std::cout << __at_c__<0>(d) << std::endl;
    std::cout << __at_c__<1>(d) << std::endl;

[endsect]

[section front_extended_deque]

[heading Description]

`front_extended_deque` allows a __deque__ to be front extended. It shares
the same properties as the __deque__.

[heading Header]

    See __deque__

[heading Synopsis]

    template <typename Deque, typename T>
    struct front_extended_deque;

[heading Template parameters]

[table
    [[Parameter]            [Description]               [Default]]
    [[`Deque`]              [Deque type]                [ ]]
    [[`T`]                  [Element type]              [ ]]
]

[note `Deque` can be a __deque__, a __front_extended_deque__ or a
__back_extended_deque__]

[heading Model of]

* __bidirectional_sequence__

[variablelist Notation
    [[`D`]              [A `front_extended_deque` type]]
    [[`e`]              [Heterogeneous value]]
    [[`N`]              [An __mpl_integral_constant__]]
]

[heading Expression Semantics]

Semantics of an expression is defined only where it differs from, or is
not defined in __bidirectional_sequence__.

[table
    [[Expression]           [Semantics]]
    [[`D(d, e)`]            [Extend `d` prepending `e` to its front.]]
    [[`__at__<N>(d)`]       [The Nth element from the beginning of the sequence; see __at__.]]
]

[note See __deque__ for further details.]

[heading Example]

    typedef deque<int, float> initial_deque;
    initial_deque d(12, 5.5f);
    front_extended_deque<initial_deque, int> d2(d, 999);
    std::cout << __at_c__<0>(d2) << std::endl;
    std::cout << __at_c__<1>(d2) << std::endl;
    std::cout << __at_c__<2>(d2) << std::endl;

[endsect]

[section back_extended_deque]

[heading Description]

`back_extended_deque` allows a __deque__ to be back extended. It shares
the same properties as the __deque__.

[heading Header]

    See __deque__

[heading Synopsis]

    template <typename Deque, typename T>
    struct back_extended_deque;

[heading Template parameters]

[table
    [[Parameter]            [Description]               [Default]]
    [[`Deque`]              [Deque type]                [ ]]
    [[`T`]                  [Element type]              [ ]]
]

[note `Deque` can be a __deque__, a __back_extended_deque__ or a
__back_extended_deque__]

[heading Model of]

* __bidirectional_sequence__

[variablelist Notation
    [[`D`]              [A `back_extended_deque` type]]
    [[`e`]              [Heterogeneous value]]
    [[`N`]              [An __mpl_integral_constant__]]
]

[heading Expression Semantics]

Semantics of an expression is defined only where it differs from, or is
not defined in __bidirectional_sequence__.

[table
    [[Expression]           [Semantics]]
    [[`D(d, e)`]            [Extend `d` prepending `e` to its back.]]
    [[`__at__<N>(d)`]       [The Nth element from the beginning of the sequence; see __at__.]]
]

[note See __deque__ for further details.]

[heading Example]

    typedef deque<int, float> initial_deque;
    initial_deque d(12, 5.5f);
    back_extended_deque<initial_deque, int> d2(d, 999);
    std::cout << __at_c__<0>(d2) << std::endl;
    std::cout << __at_c__<1>(d2) << std::endl;
    std::cout << __at_c__<2>(d2) << std::endl;

[endsect]

[section set]

[heading Description]

set is an __associative_sequence__ of heterogeneous typed data elements.
Type identity is used to impose an equivalence relation on keys. The
element's type is its key. A set may contain at most one element for each
key. Membership testing and element key lookup has constant runtime
complexity (see __overloaded_functions__).

[heading Header]

    #include <boost/fusion/container/set.hpp>
    #include <boost/fusion/include/set.hpp>
    #include <boost/fusion/container/set/set_fwd.hpp>
    #include <boost/fusion/include/set_fwd.hpp>

[heading Synopsis]

    template <
        typename T0 = __unspecified__
      , typename T1 = __unspecified__
      , typename T2 = __unspecified__
        ...
      , typename TN = __unspecified__
    >
    struct set;

For C++11 compilers, the variadic function interface has no upper bound.

For C++03 compilers, the variadic class interface accepts `0` to
`FUSION_MAX_SET_SIZE` elements, where `FUSION_MAX_SET_SIZE` is a user
definable predefined maximum that defaults to `10`. Example:

    set<int, char, double>

You may define the preprocessor constant `FUSION_MAX_SET_SIZE` before
including any Fusion header to change the default. Example:

    #define FUSION_MAX_SET_SIZE 20

[heading Template parameters]

[table
    [[Parameter]            [Description]               [Default]]
    [[`T0`...`TN`]          [Element types]             [__unspecified__]]
]

[heading Model of]

* __associative_sequence__
* __forward_sequence__

[variablelist Notation
    [[`S`]              [A `set` type]]
    [[`s`]              [An instance of `set`]]
    [[`e0`...`en`]      [Heterogeneous values]]
    [[`fs`]             [A __forward_sequence__]]
]

[heading Expression Semantics]

Semantics of an expression is defined only where it differs from, or is not
defined in __random_access_sequence__ and __associative_sequence__.

[table
    [[Expression]           [Semantics]]
    [[`S()`]                [Creates a set with default constructed elements.]]
    [[`S(e0, e1,... en)`]   [Creates a set with elements `e0`...`en`.]]
    [[`S(fs)`]              [Copy constructs a set from a __forward_sequence__ `fs`.]]
    [[`s = fs`]             [Assigns to a set, `s`, from a __forward_sequence__ `fs`.]]
]

[heading Example]

    typedef set<int, float> S;
    S s(12, 5.5f);
    std::cout << __at_key__<int>(s) << std::endl;
    std::cout << __at_key__<float>(s) << std::endl;
    std::cout << __result_of_has_key__<S, double>::value << std::endl;

[endsect]

[section map]

[heading Description]

map is an __associative_sequence__ of heterogeneous typed data elements.
Each element is a key/data pair (see __fusion_pair__) where the key has no
data (type only). Type identity is used to impose an equivalence relation
on keys. A map may contain at most one element for each key. Membership
testing and element key lookup has constant runtime complexity (see
__overloaded_functions__).

[heading Header]

    #include <boost/fusion/container/map.hpp>
    #include <boost/fusion/include/map.hpp>
    #include <boost/fusion/container/map/map_fwd.hpp>
    #include <boost/fusion/include/map_fwd.hpp>

[heading Synopsis]

    template <
        typename T0 = __unspecified__
      , typename T1 = __unspecified__
      , typename T2 = __unspecified__
        ...
      , typename TN = __unspecified__
    >
    struct map;

For C++11 compilers, the variadic function interface has no upper bound.

For C++03 compilers, the variadic class interface accepts `0` to
`FUSION_MAX_MAP_SIZE` elements, where `FUSION_MAX_MAP_SIZE` is a user
definable predefined maximum that defaults to `10`. Example:

    map<__pair__<int, char>, __pair__<char, char>, __pair__<double, char> >

You may define the preprocessor constant `FUSION_MAX_MAP_SIZE` before
including any Fusion header to change the default. Example:

    #define FUSION_MAX_MAP_SIZE 20

[heading Template parameters]

[table
    [[Parameter]            [Description]               [Default]]
    [[`T0`...`TN`]          [Element types]             [__unspecified__]]
]

[heading Model of]

* __associative_sequence__
* __random_access_sequence__

[variablelist Notation
    [[`M`]              [A `map` type]]
    [[`m`]              [An instance of `map`]]
    [[`e0`...`en`]      [Heterogeneous key/value pairs (see __fusion_pair__)]]
    [[`s`]              [A __forward_sequence__]]
]

[heading Expression Semantics]

Semantics of an expression is defined only where it differs from, or is not
defined in __forward_sequence__ and __associative_sequence__.

[table
    [[Expression]           [Semantics]]
    [[`M()`]                [Creates a map with default constructed elements.]]
    [[`M(e0, e1,... en)`]   [Creates a map with element pairs `e0`...`en`.]]
    [[`M(s)`]               [Copy constructs a map from a __forward_sequence__ `s`.]]
    [[`m = s`]              [Assigns to a map, `m`, from a __forward_sequence__ `s`.]]
]

[heading Example]

    typedef map<
        __pair__<int, char>
      , __pair__<double, std::string> >
    map_type;

    map_type m(
        __fusion_make_pair__<int>('X')
      , __fusion_make_pair__<double>("Men"));

    std::cout << __at_key__<int>(m) << std::endl;
    std::cout << __at_key__<double>(m) << std::endl;

[endsect]

[section Generation]

These are the functions that you can use to generate various forms of
__containers__ from elemental values.

[heading Header]

    #include <boost/fusion/container/generation.hpp>
    #include <boost/fusion/include/generation.hpp>

[section Functions]

[section make_list]

[heading Description]

Create a __list__ from one or more values.

[heading Synopsis]

    template <typename T0, typename T1,... typename TN>
    typename __result_of_make_list__<T0, T1,... TN>::type
    make_list(T0 const& x0, T1 const& x1... TN const& xN);

For C++11 compilers, the variadic function interface has no upper bound.

For C++03 compilers, the variadic function accepts `0` to
`FUSION_MAX_LIST_SIZE` elements, where `FUSION_MAX_LIST_SIZE` is a user
definable predefined maximum that defaults to `10`. You may define the
preprocessor constant `FUSION_MAX_LIST_SIZE` before including any Fusion
header to change the default. Example:

    #define FUSION_MAX_LIST_SIZE 20

[heading Parameters]

[table
    [[Parameter]        [Requirement]                   [Description]]
    [[`x0, x1,... xN`]  [Instances of `T0, T1,... TN`]  [The arguments to `make_list`]]
]

[heading Expression Semantics]

    make_list(x0, x1,... xN);

[*Return type]: __result_of_make_list__`<T0, T1,... TN>::type`

[*Semantics]: Create a __list__ from `x0, x1,... xN`.

[heading Header]

    #include <boost/fusion/container/generation/make_list.hpp>
    #include <boost/fusion/include/make_list.hpp>

[heading Example]

    make_list(123, "hello", 12.5)

[heading See also]

__note_ref_wrappers__

[endsect]

[section make_cons]

[heading Description]

Create a __cons__ from `car` (/head/) and optional `cdr` (/tail/).

[heading Synopsis]

    template <typename Car>
    typename __result_of_make_cons__<Car>::type
    make_cons(Car const& car);

    template <typename Car, typename Cdr>
    typename __result_of_make_cons__<Car, Cdr>::type
    make_cons(Car const& car, Cdr const& cdr);

[heading Parameters]

[table
    [[Parameter]        [Requirement]                   [Description]]
    [[`car`]            [Instance of `Car`]             [The list's head]]
    [[`cdr`]            [Instance of `Cdr`]             [The list's tail (optional)]]
]

[heading Expression Semantics]

    make_cons(car, cdr);

[*Return type]: __result_of_make_cons__`<Car, Cdr>::type` or
__result_of_make_cons__`<Car>::type`

[*Semantics]: Create a __cons__ from `car` (/head/) and optional `cdr` (/tail/).

[heading Header]

    #include <boost/fusion/container/generation/make_cons.hpp>
    #include <boost/fusion/include/make_cons.hpp>

[heading Example]

    make_cons('x', make_cons(123))

[heading See also]

__note_ref_wrappers__

[endsect]

[section make_vector]

[heading Description]

Create a __vector__ from one or more values.

[heading Synopsis]

    template <typename T0, typename T1,... typename TN>
    typename __result_of_make_vector__<T0, T1,... TN>::type
    make_vector(T0 const& x0, T1 const& x1... TN const& xN);

For C++11 compilers, the variadic function interface has no upper bound.

For C++03 compilers, the variadic function accepts `0` to
`FUSION_MAX_VECTOR_SIZE` elements, where `FUSION_MAX_VECTOR_SIZE` is a
user definable predefined maximum that defaults to `10`. You may define
the preprocessor constant `FUSION_MAX_VECTOR_SIZE` before including any
Fusion header to change the default. Example:

    #define FUSION_MAX_VECTOR_SIZE 20

[heading Parameters]

[table
    [[Parameter]        [Requirement]                   [Description]]
    [[`x0, x1,... xN`]  [Instances of `T0, T1,... TN`]  [The arguments to `make_vector`]]
]

[heading Expression Semantics]

    make_vector(x0, x1,... xN);

[*Return type]: __result_of_make_vector__`<T0, T1,... TN>::type`

[*Semantics]: Create a __vector__ from `x0, x1,... xN`.

[heading Header]

    #include <boost/fusion/container/generation/make_vector.hpp>
    #include <boost/fusion/include/make_vector.hpp>

[heading Example]

    make_vector(123, "hello", 12.5)

[heading See also]

__note_ref_wrappers__

[endsect]

[section make_deque]

[heading Description]

Create a __deque__ from one or more values.

[heading Synopsis]

    template <typename ...Elements>
    typename __result_of_make_deque__<Elements...>::type
    make_deque(Elements const&... elements);

For C++11 compilers, the variadic function interface has no upper bound.

For C++03 compilers, the variadic function accepts `0` to
`FUSION_MAX_DEQUE_SIZE` elements, where `FUSION_MAX_DEQUE_SIZE` is a
user definable predefined maximum that defaults to `10`. You may define
the preprocessor constant `FUSION_MAX_DEQUE_SIZE` before including any
Fusion header to change the default. Example:

    #define FUSION_MAX_DEQUE_SIZE 20

[heading Parameters]

[table
    [[Parameter]            [Description]               [Description]]
    [[`elements`]           [Instances of `Elements`]   [The arguments to `make_deque`]]
]

[heading Expression Semantics]

    make_deque(elements...);

[*Return type]: __result_of_make_deque__`<Elements...>::type`

[*Semantics]: Create a __deque__ from `elements...`.

[heading Header]

    #include <boost/fusion/container/generation/make_deque.hpp>
    #include <boost/fusion/include/make_deque.hpp>

[heading Example]

    make_deque(123, "hello", 12.5)

[heading See also]

__note_ref_wrappers__

[endsect]

[section make_set]

[heading Description]

Create a __set__ from one or more values.

[heading Synopsis]

    template <typename T0, typename T1,... typename TN>
    typename __result_of_make_set__<T0, T1,... TN>::type
    make_set(T0 const& x0, T1 const& x1... TN const& xN);

For C++11 compilers, the variadic function interface has no upper bound.

For C++03 compilers, the variadic function accepts `0` to
`FUSION_MAX_SET_SIZE` elements, where `FUSION_MAX_SET_SIZE` is a user
definable predefined maximum that defaults to `10`. You may define the
preprocessor constant `FUSION_MAX_SET_SIZE` before including any Fusion
header to change the default. Example:

    #define FUSION_MAX_SET_SIZE 20

[heading Parameters]

[table
    [[Parameter]        [Requirement]                   [Description]]
    [[`x0, x1,... xN`]  [Instances of `T0, T1,... TN`]  [The arguments to `make_set`]]
]

[heading Expression Semantics]

    make_set(x0, x1,... xN);

[*Return type]: __result_of_make_set__`<T0, T1,... TN>::type`

[*Semantics]: Create a __set__ from `x0, x1,... xN`.

[*Precondition]: There may be no duplicate key types.

[heading Header]

    #include <boost/fusion/container/generation/make_set.hpp>
    #include <boost/fusion/include/make_set.hpp>

[heading Example]

    make_set(123, "hello", 12.5)

[heading See also]

__note_ref_wrappers__

[endsect]

[section make_map]

[heading Description]

Create a __map__ from one or more key/data pairs.

[heading Synopsis]

    template <
        typename K0, typename K1,... typename KN
      , typename T0, typename T1,... typename TN>
    typename __result_of_make_map__<K0, K0,... KN, T0, T1,... TN>::type
    make_map(T0 const& x0, T1 const& x1... TN const& xN);

For C++11 compilers, the variadic function interface has no upper bound.

For C++03 compilers, the variadic function accepts `0` to `FUSION_MAX_MAP_SIZE` elements,
where `FUSION_MAX_MAP_SIZE` is a user definable predefined maximum that
defaults to `10`. You may define the preprocessor constant
`FUSION_MAX_MAP_SIZE` before including any Fusion header to change the
default. Example:

    #define FUSION_MAX_MAP_SIZE 20

[heading Parameters]

[table
    [[Parameter]        [Requirement]                   [Description]]
    [[`K0, K1,... KN`]  [The key types]                 [Keys associated with `x0, x1,... xN`]]
    [[`x0, x1,... xN`]  [Instances of `T0, T1,... TN`]  [The arguments to `make_map`]]
]

[heading Expression Semantics]

    make_map<K0, K1,... KN>(x0, x1,... xN);

[*Return type]: __result_of_make_map__`<K0, K0,... KN, T0, T1,... TN>::type`

[*Semantics]: Create a __map__ from `K0, K1,... KN` keys and
`x0, x1,... xN` data.

[*Precondition]: There may be no duplicate key types.

[heading Header]

    #include <boost/fusion/container/generation/make_map.hpp>
    #include <boost/fusion/include/make_map.hpp>

[heading Example]

    make_map<int, double>('X', "Men")

[heading See also]

__note_ref_wrappers__, __fusion_pair__

[endsect]

[section Tiers]

Tiers are sequences, where all elements are reference types. They are
constructed with a call to a couple of /tie/ function templates. The
succeeding sections document the various /tier/ flavors.

* __list_tie__
* __vector_tie__
* __map_tie__
* __deque_tie__

Example:

    int i; char c; double d;
      ...
    __vector_tie__(i, c, d);

The __vector_tie__ function creates a __vector__ of type
`__vector__<int&, char&, double&>`. The same result could be achieved with the call
__make_vector__(__boost_ref_call__(i), __boost_ref_call__(c), __boost_ref_call__(d))
[footnote see __boost_ref__ for details about `ref`].

A /tie/ can be used to 'unpack' another tuple into variables. E.g.:

    int i; char c; double d;
    __vector_tie__(i, c, d) = __make_vector__(1,'a', 5.5);
    std::cout << i << " " <<  c << " " << d;

This code prints 1 a 5.5 to the standard output stream. A sequence
unpacking operation like this is found for example in ML and Python. It is
convenient when calling functions which return sequences.

[heading Ignore]

There is also an object called /ignore/ which allows you to ignore an
element assigned by a sequence. The idea is that a function may return a
sequence, only part of which you are interested in. For example:

    char c;
    __vector_tie__(ignore, c) = __make_vector__(1, 'a');

[endsect]

[section list_tie]

[heading Description]

Constructs a tie using a __list__ sequence.

[heading Synopsis]

    template <typename T0, typename T1,... typename TN>
    __list__<T0&, T1&,... TN&>
    list_tie(T0& x0, T1& x1... TN& xN);

For C++11 compilers, the variadic function interface has no upper bound.

For C++03 compilers, the variadic function accepts `0` to
`FUSION_MAX_LIST_SIZE` elements, where `FUSION_MAX_LIST_SIZE` is a user
definable predefined maximum that defaults to `10`. You may define the
preprocessor constant `FUSION_MAX_LIST_SIZE` before including any Fusion
header to change the default. Example:

    #define FUSION_MAX_LIST_SIZE 20

[heading Parameters]

[table
    [[Parameter]        [Requirement]                       [Description]]
    [[`x0, x1,... xN`]  [Instances of `T0, T1,... TN`]      [The arguments to `list_tie`]]
]

[heading Expression Semantics]

    list_tie(x0, x1,... xN);

[*Return type]: __list__<T0&, T1&,... TN&>

[*Semantics]: Create a __list__ of references from `x0, x1,... xN`.

[heading Header]

    #include <boost/fusion/container/generation/list_tie.hpp>
    #include <boost/fusion/include/list_tie.hpp>

[heading Example]

    int i = 123;
    double d = 123.456;
    list_tie(i, d)

[endsect]

[section vector_tie]

[heading Description]

Constructs a tie using a __vector__ sequence.

[heading Synopsis]

    template <typename T0, typename T1,... typename TN>
    __vector__<T0&, T1&,... TN&>
    vector_tie(T0& x0, T1& x1... TN& xN);

For C++11 compilers, the variadic function interface has no upper bound.

For C++03 compilers, the variadic function accepts `0` to
`FUSION_MAX_VECTOR_SIZE` elements, where `FUSION_MAX_VECTOR_SIZE` is a
user definable predefined maximum that defaults to `10`. You may define
the preprocessor constant `FUSION_MAX_VECTOR_SIZE` before including any
Fusion header to change the default. Example:

    #define FUSION_MAX_VECTOR_SIZE 20

[heading Parameters]

[table
    [[Parameter]        [Requirement]                       [Description]]
    [[`x0, x1,... xN`]  [Instances of `T0, T1,... TN`]      [The arguments to `vector_tie`]]
]

[heading Expression Semantics]

    vector_tie(x0, x1,... xN);

[*Return type]: __vector__<T0&, T1&,... TN&>

[*Semantics]: Create a __vector__ of references from `x0, x1,... xN`.

[heading Header]

    #include <boost/fusion/container/generation/vector_tie.hpp>
    #include <boost/fusion/include/vector_tie.hpp>

[heading Example]

    int i = 123;
    double d = 123.456;
    vector_tie(i, d)

[endsect]

[section map_tie]

[heading Description]

Constructs a tie using a __map__ sequence.

[heading Synopsis]

    template <typename K0, typename K1,... typename KN, typename D0, typename D1,... typename DN>
    __map__<__pair__<K0, D0&>, __pair__<K1, D1&>,... __pair__<KN, DN&> >
    map_tie(D0& d0, D1& d1... DN& dN);

For C++11 compilers, the variadic function interface has no upper bound.

For C++03 compilers, the variadic function accepts `0` to
`FUSION_MAX_MAP_SIZE` elements, where `FUSION_MAX_MAP_SIZE` is a user
definable predefined maximum that defaults to `10`, and a corresponding
number of key types.  You may define the preprocessor constant
`FUSION_MAX_MAP_SIZE` before including any Fusion header to change the
default. Example:

    #define FUSION_MAX_MAP_SIZE 20

[heading Parameters]

[table
    [[Parameter]        [Requirement]                       [Description]]
    [[`K0, K1,... KN`]  [Any type][The key types associated with each of the `x1,x2,...,xN` values]]
    [[`x0, x1,... xN`]  [Instances of `T0, T1,... TN`]                      [The arguments to `map_tie`]]
]

[heading Expression Semantics]

    map_tie<K0, K1,... KN>(x0, x1,... xN);

[*Return type]: __map__<__pair__<K0, D0&>, __pair__<K1, D1&>,... __pair__<KN, DN&> >

[*Semantics]: Create a __map__ of references from `x0, x1,... xN` with keys `K0, K1,... KN`

[heading Header]

    #include <boost/fusion/container/generation/map_tie.hpp>
    #include <boost/fusion/include/map_tie.hpp>

[heading Example]

    struct int_key;
    struct double_key;
    ...
    int i = 123;
    double d = 123.456;
    map_tie<int_key, double_key>(i, d)

[endsect]

[section deque_tie]

[heading Description]

Constructs a tie using a __deque__ sequence.

[heading Synopsis]

    template <typename ...Elements>
    __deque__<Elements&...>
    deque_tie(Elements&... elements);

For C++11 compilers, the variadic function interface has no upper bound.

For C++03 compilers, the variadic function accepts `0` to
`FUSION_MAX_DEQUE_SIZE` elements, where `FUSION_MAX_DEQUE_SIZE` is a
user definable predefined maximum that defaults to `10`. You may define
the preprocessor constant `FUSION_MAX_DEQUE_SIZE` before including any
Fusion header to change the default. Example:

    #define FUSION_MAX_DEQUE_SIZE 20

[heading Parameters]

[table
    [[Parameter]            [Description]               [Description]]
    [[`elements`]           [Instances of `Elements`]   [The arguments to `deque_tie`]]
]

[heading Expression Semantics]

    deque_tie(elements...);

[*Return type]: __deque__<Elements&...>

[*Semantics]: Create a __deque__ of references from `elements...`.

[heading Header]

    #include <boost/fusion/container/generation/deque_tie.hpp>
    #include <boost/fusion/include/deque_tie.hpp>

[heading Example]

    int i = 123;
    double d = 123.456;
    deque_tie(i, d)

[endsect]

[endsect]

[section MetaFunctions]

[section make_list]

[heading Description]

Returns the result type of __make_list__.

[heading Synopsis]

    template <typename T0, typename T1,... typename TN>
    struct make_list;

For C++11 compilers, the variadic function interface has no upper bound.

For C++03 compilers, the variadic function accepts `0` to
`FUSION_MAX_LIST_SIZE` elements, where `FUSION_MAX_LIST_SIZE` is a user
definable predefined maximum that defaults to `10`. You may define the
preprocessor constant `FUSION_MAX_LIST_SIZE` before including any Fusion
header to change the default. Example:

    #define FUSION_MAX_LIST_SIZE 20

[heading Parameters]

[table
    [[Parameter]        [Requirement]       [Description]]
    [[`T0, T1,... TN`]  [Any type]          [Template arguments to `make_list`]]
]

[heading Expression Semantics]

    result_of::make_list<T0, T1,... TN>::type

[*Return type]: A __list__ with elements of types converted following the
rules for __element_conversion__.

[*Semantics]: Create a __list__ from `T0, T1,... TN`.

[heading Header]

    #include <boost/fusion/container/generation/make_list.hpp>
    #include <boost/fusion/include/make_list.hpp>

[heading Example]

    result_of::make_list<int, const char(&)[7], double>::type

[endsect]

[section make_cons]

[heading Description]

Returns the result type of __make_cons__.

[heading Synopsis]

    template <typename Car, typename Cdr = nil>
    struct make_cons;

[heading Parameters]

[table
    [[Parameter]        [Requirement]               [Description]]
    [[`Car`]            [Any type]                  [The list's head type]]
    [[`Cdr`]            [A `cons`]                  [The list's tail type (optional)]]
]

[heading Expression Semantics]

    result_of::make_cons<Car, Cdr>::type

[*Return type]: A __cons__ with head element, `Car`, of type converted
following the rules for __element_conversion__, and tail, `Cdr`.

[*Semantics]: Create a __cons__ from `Car` (/head/) and optional `Cdr` (/tail/).

[heading Header]

    #include <boost/fusion/container/generation/make_cons.hpp>
    #include <boost/fusion/include/make_cons.hpp>

[heading Example]

    result_of::make_cons<char, result_of::make_cons<int>::type>::type

[endsect]

[section make_vector]

[heading Description]

Returns the result type of __make_vector__.

[heading Synopsis]

    template <typename T0, typename T1,... typename TN>
    struct make_vector;

For C++11 compilers, the variadic function interface has no upper bound.

For C++03 compilers, the variadic function accepts `0` to
`FUSION_MAX_VECTOR_SIZE` elements, where `FUSION_MAX_VECTOR_SIZE` is a user
definable predefined maximum that defaults to `10`. You may define the
preprocessor constant `FUSION_MAX_VECTOR_SIZE` before including any Fusion
header to change the default. Example:

    #define FUSION_MAX_VECTOR_SIZE 20

[heading Parameters]

[table
    [[Parameter]        [Requirement]       [Description]]
    [[`T0, T1,... TN`]  [Any type]          [Template arguments to `make_vector`]]
]

[heading Expression Semantics]

    result_of::make_vector<T0, T1,... TN>::type

[*Return type]: A __vector__ with elements of types converted following the
rules for __element_conversion__.

[*Semantics]: Create a __vector__ from `T0, T1,... TN`.

[heading Header]

    #include <boost/fusion/container/generation/make_vector.hpp>
    #include <boost/fusion/include/make_vector.hpp>

[heading Example]

    result_of::make_vector<int, const char(&)[7], double>::type

[endsect]

[section make_deque]

[heading Description]

Returns the result type of __make_deque__.

[heading Synopsis]

    template <typename ...Elements>
    struct make_deque;

For C++11 compilers, the variadic template interface has no upper bound.

For C++03 The variadic function accepts `0` to `FUSION_MAX_DEQUE_SIZE`
elements, where `FUSION_MAX_DEQUE_SIZE` is a user definable predefined
maximum that defaults to `10`. You may define the preprocessor constant
`FUSION_MAX_DEQUE_SIZE` before including any Fusion header to change the
default. Example:

    #define FUSION_MAX_DEQUE_SIZE 20

[heading Parameters]

[table
    [[Parameter]        [Requirement]               [Description]]
    [[`Elements`]       [Variadic template types]   [Template arguments to `make_deque`]]
]

[heading Expression Semantics]

    result_of::make_deque<Elements...>::type

[*Return type]: A __deque__ with elements of types converted following the
rules for __element_conversion__.

[*Semantics]: Create a __deque__ from `Elements...`.

[heading Header]

    #include <boost/fusion/container/generation/make_deque.hpp>
    #include <boost/fusion/include/make_deque.hpp>

[heading Example]

    result_of::make_deque<int, const char(&)[7], double>::type

[endsect]

[section make_set]

[heading Description]

Returns the result type of __make_set__.

[heading Synopsis]

    template <typename T0, typename T1,... typename TN>
    struct make_set;

For C++11 compilers, the variadic function interface has no upper bound.

For C++03 compilers, the variadic function accepts `0` to
`FUSION_MAX_SET_SIZE` elements, where `FUSION_MAX_SET_SIZE` is a user definable
predefined maximum that defaults to `10`. You may define the preprocessor
constant `FUSION_MAX_SET_SIZE` before including any Fusion header to change
the default. Example:

    #define FUSION_MAX_SET_SIZE 20

[heading Parameters]

[table
    [[Parameter]        [Requirement]       [Description]]
    [[`T0, T1,... TN`]  [Any type]          [The arguments to `make_set`]]
]

[heading Expression Semantics]

    result_of::make_set<T0, T1,... TN>::type

[*Return type]: A __set__ with elements of types converted following the
rules for __element_conversion__.

[*Semantics]: Create a __set__ from `T0, T1,... TN`.

[*Precondition]: There may be no duplicate key types.

[heading Header]

    #include <boost/fusion/container/generation/make_set.hpp>
    #include <boost/fusion/include/make_set.hpp>

[heading Example]

    result_of::make_set<int, char, double>::type

[endsect]

[section make_map]

[heading Description]

Returns the result type of __make_map__.

The implementation depends on the support of variadic templates.

When variadic templates are not supported, make_map is a metafunction of the form:

[heading Synopsis]

    template <
        typename K0, typename K1,... typename KN
      , typename T0, typename T1,... typename TN>
    struct make_map;

For C++11 compilers, the variadic function interface has no upper bound.

For C++03 compilers, the variadic function accepts `0` to `FUSION_MAX_MAP_SIZE` elements,
where `FUSION_MAX_MAP_SIZE` is a user definable predefined maximum that
defaults to `10`. You may define the preprocessor constant
`FUSION_MAX_MAP_SIZE` before including any Fusion header to change the
default. Example:

    #define FUSION_MAX_MAP_SIZE 20

When variadic templates are supported, make_map is a metafunction class of the form:

[heading Synopsis]

    template <
        typename K0, typename K1,... typename KN>
    struct make_map
    {
        struct apply<
        typename T0, typename T1,... typename TN>
    };

[heading Parameters]

[table
    [[Parameter]        [Requirement]           [Description]]
    [[`K0, K1,... KN`]  [Any type]              [Keys associated with `T0, T1,... TN`]]
    [[`T0, T1,... TN`]  [Any type]              [Data associated with keys `K0, K1,... KN`]]
]

[heading Expression Semantics]

    #if !defined(BOOST_FUSION_HAS_VARIADIC_MAP)
    resulf_of::make_map<K0, K1,... KN, T0, T1,... TN>::type;
    #else
    resulf_of::make_map<K0, K1,... KN>::apply<T0, T1,... TN>::type;
    #endif

[*Return type]: __result_of_make_map__`<K0, K0,... KN, T0, T1,... TN>::type`
when variadic templates are not supported, or
__result_of_make_map__`<K0, K0,... KN>::apply<T0, T1,... TN>::type`
when variadic templates are supported.

[*Semantics]: A __map__ with __fusion_pair__ elements where the
`second_type` is converted following the rules for __element_conversion__.

[*Precondition]: There may be no duplicate key types.

[heading Header]

    #include <boost/fusion/container/generation/make_map.hpp>
    #include <boost/fusion/include/make_map.hpp>

[heading Example]

    #if !defined(BOOST_FUSION_HAS_VARIADIC_MAP)
    result_of::make_map<int, double, char, double>::type
    #else
    result_of::make_map<int, double>::apply<char, double>::type
    #endif

[heading See also]

__fusion_pair__

[endsect]

[section list_tie]

[heading Description]

Returns the result type of __list_tie__.

[heading Synopsis]

    template <typename T0, typename T1,... typename TN>
    struct list_tie;

For C++11 compilers, the variadic function interface has no upper bound.

For C++03 compilers, the variadic function accepts `0` to
`FUSION_MAX_LIST_SIZE` elements, where `FUSION_MAX_LIST_SIZE` is a user
definable predefined maximum that defaults to `10`. You may define the
preprocessor constant `FUSION_MAX_LIST_SIZE` before including any Fusion
header to change the default. Example:

    #define FUSION_MAX_LIST_SIZE 20

[heading Parameters]

[table
    [[Parameter]        [Requirement]       [Description]]
    [[`T0, T1,... TN`]  [Any type]          [The arguments to `list_tie`]]
]

[heading Expression Semantics]

    result_of::list_tie<T0, T1,... TN>::type;

[*Return type]: __list__<T0&, T1&,... TN&>

[*Semantics]: Create a __list__ of references from `T0, T1,... TN`.

[heading Header]

    #include <boost/fusion/container/generation/list_tie.hpp>
    #include <boost/fusion/include/list_tie.hpp>

[heading Example]

    result_of::list_tie<int, double>::type

[endsect]

[section vector_tie]

[heading Description]

Returns the result type of __vector_tie__.

[heading Synopsis]

    template <typename T0, typename T1,... typename TN>
    struct vector_tie;

For C++11 compilers, the variadic function interface has no upper bound.

For C++03 compilers, the variadic function accepts `0` to
`FUSION_MAX_VECTOR_SIZE` elements, where `FUSION_MAX_VECTOR_SIZE` is a user
definable predefined maximum that defaults to `10`. You may define the
preprocessor constant `FUSION_MAX_VECTOR_SIZE` before including any Fusion
header to change the default. Example:

    #define FUSION_MAX_VECTOR_SIZE 20

[heading Parameters]

[table
    [[Parameter]        [Requirement]       [Description]]
    [[`T0, T1,... TN`]  [Any type]          [The arguments to `vector_tie`]]
]

[heading Expression Semantics]

    result_of::vector_tie<T0, T1,... TN>::type;

[*Return type]: __vector__<T0&, T1&,... TN&>

[*Semantics]: Create a __vector__ of references from `T0, T1,... TN`.

[heading Header]

    #include <boost/fusion/container/generation/vector_tie.hpp>
    #include <boost/fusion/include/vector_tie.hpp>

[heading Example]

    result_of::vector_tie<int, double>::type

[endsect]

[section deque_tie]

[heading Description]

Returns the result type of __deque_tie__.

[heading Synopsis]

    template <typename ...Elements>
    struct deque_tie;

For C++11 compilers, the variadic template interface has no upper bound.

For C++03 compilers, the variadic function accepts `0` to
`FUSION_MAX_DEQUE_SIZE` elements, where `FUSION_MAX_DEQUE_SIZE` is a
user definable predefined maximum that defaults to `10`. You may define
the preprocessor constant `FUSION_MAX_DEQUE_SIZE` before including any
Fusion header to change the default. Example:

    #define FUSION_MAX_DEQUE_SIZE 20

[heading Parameters]

[table
    [[Parameter]        [Requirement]               [Description]]
    [[`Elements`]       [Variadic template types]   [Template arguments to `deque_tie`]]
]

[heading Expression Semantics]

    result_of::deque_tie<Elements...>::type;

[*Return type]: __deque__<Elements&...>

[*Semantics]: Create a __deque__ of references from `Elements...`.

[heading Header]

    #include <boost/fusion/container/generation/deque_tie.hpp>
    #include <boost/fusion/include/deque_tie.hpp>

[heading Example]

    result_of::deque_tie<int, double>::type

[endsect]

[section map_tie]

[heading Description]

Returns the result type of __map_tie__.

[heading Synopsis]

    template <typename K0, typename K1,... typename KN, typename D0, typename D1,... typename DN>
    struct map_tie;

For C++11 compilers, the variadic function interface has no upper bound.

For C++03 compilers, the variadic function accepts `0` to
`FUSION_MAX_MAP_SIZE` elements, where `FUSION_MAX_MAP_SIZE` is a user definable
predefined maximum that defaults to `10`. You may define the preprocessor
constant `FUSION_MAX_MAP_SIZE` before including any Fusion header to change
the default. Example:

    #define FUSION_MAX_MAP_SIZE 20

[heading Parameters]

[table
    [[Parameter]        [Requirement]       [Description]]
    [[`K0, K1,... KN`]  [Any type]          [The key types for `map_tie`]]
    [[`D0, D1,... DN`]  [Any type]          [The arguments types for `map_tie`]]
]

[heading Expression Semantics]

    result_of::map_tie<K0, K1,... KN, D0, D1,... DN>::type;

[*Return type]: __map__<__pair__<K0, D0&>, __pair__<K1, D1&>,... __pair__<KN, DN&> >

[*Semantics]: Create a __map__ of references from `D0, D1,... DN` with keys `K0, K1,... KN`

[heading Header]

    #include <boost/fusion/container/generation/map_tie.hpp>
    #include <boost/fusion/include/map_tie.hpp>

[heading Example]

    struct int_key;
    struct double_key;
    ...
    result_of::map_tie<int_key, double_key, int, double>::type

[endsect]

[endsect]

[endsect]

[section Conversion]

All fusion sequences can be converted to one of the __containers__ types
using one of these conversion functions.

[heading Header]

    #include <boost/fusion/include/convert.hpp>

[section Functions]

[section as_list]

[heading Description]

Convert a fusion sequence to a __list__.

[heading Synopsis]

    template <typename Sequence>
    typename result_of::as_list<Sequence>::type
    as_list(Sequence& seq);

    template <typename Sequence>
    typename result_of::as_list<Sequence const>::type
    as_list(Sequence const& seq);

[heading Parameters]

[table
    [[Parameter]    [Requirement]               [Description]]
    [[`seq`]        [An instance of Sequence]   [The sequence to convert.]]
]

[heading Expression Semantics]

    as_list(seq);

[*Return type]: __result_of_as_list__`<Sequence>::type`

[*Semantics]: Convert a fusion sequence, `seq`, to a __list__.

[heading Header]

    #include <boost/fusion/container/list/convert.hpp>
    #include <boost/fusion/include/as_list.hpp>

[heading Example]

    as_list(__make_vector__('x', 123, "hello"))

[endsect]

[section as_vector]

[heading Description]

Convert a fusion sequence to a __vector__.

[heading Synopsis]

    template <typename Sequence>
    typename result_of::as_vector<Sequence>::type
    as_vector(Sequence& seq);

    template <typename Sequence>
    typename result_of::as_vector<Sequence const>::type
    as_vector(Sequence const& seq);

[heading Parameters]

[table
    [[Parameter]    [Requirement]               [Description]]
    [[`seq`]        [An instance of Sequence]   [The sequence to convert.]]
]

[heading Expression Semantics]

    as_vector(seq);

[*Return type]: __result_of_as_vector__`<Sequence>::type`

[*Semantics]: Convert a fusion sequence, `seq`, to a __vector__.

[heading Header]

    #include <boost/fusion/container/vector/convert.hpp>
    #include <boost/fusion/include/as_vector.hpp>

[heading Example]

    as_vector(__make_list__('x', 123, "hello"))

[endsect]

[section as_deque]

[heading Description]

Convert a fusion sequence to a __deque__.

[heading Synopsis]

    template <typename Sequence>
    typename result_of::as_deque<Sequence>::type
    as_deque(Sequence& seq);

    template <typename Sequence>
    typename result_of::as_deque<Sequence const>::type
    as_deque(Sequence const& seq);

[heading Parameters]

[table
    [[Parameter]    [Requirement]               [Description]]
    [[`seq`]        [An instance of Sequence]   [The sequence to convert.]]
]

[heading Expression Semantics]

    as_deque(seq);

[*Return type]: __result_of_as_deque__`<Sequence>::type`

[*Semantics]: Convert a fusion sequence, `seq`, to a __deque__.

[heading Header]

    #include <boost/fusion/container/deque/convert.hpp>
    #include <boost/fusion/include/as_deque.hpp>

[heading Example]

    as_deque(__make_vector__('x', 123, "hello"))

[endsect]

[section as_set]

[heading Description]

Convert a fusion sequence to a __set__.

[heading Synopsis]

    template <typename Sequence>
    typename result_of::as_set<Sequence>::type
    as_set(Sequence& seq);

    template <typename Sequence>
    typename result_of::as_set<Sequence const>::type
    as_set(Sequence const& seq);

[heading Parameters]

[table
    [[Parameter]    [Requirement]               [Description]]
    [[`seq`]        [An instance of Sequence]   [The sequence to convert.]]
]

[heading Expression Semantics]

    as_set(seq);

[*Return type]: __result_of_as_set__`<Sequence>::type`

[*Semantics]: Convert a fusion sequence, `seq`, to a __set__.

[*Precondition]: There may be no duplicate key types.

[heading Header]

    #include <boost/fusion/container/set/convert.hpp>
    #include <boost/fusion/include/as_set.hpp>

[heading Example]

    as_set(__make_vector__('x', 123, "hello"))

[endsect]

[section as_map]

[heading Description]

Convert a fusion sequence to a __map__.

[heading Synopsis]

    template <typename Sequence>
    typename result_of::as_map<Sequence>::type
    as_map(Sequence& seq);

    template <typename Sequence>
    typename result_of::as_map<Sequence const>::type
    as_map(Sequence const& seq);

[heading Parameters]

[table
    [[Parameter]    [Requirement]               [Description]]
    [[`seq`]        [An instance of Sequence]   [The sequence to convert.]]
]

[heading Expression Semantics]

    as_map(seq);

[*Return type]: __result_of_as_map__`<Sequence>::type`

[*Semantics]: Convert a fusion sequence, `seq`, to a __map__.

[*Precondition]: For non-associative sequence, the elements are assumed to be
__fusion_pair__s. There may be no duplicate __fusion_pair__ key types.

[heading Header]

    #include <boost/fusion/container/map/convert.hpp>
    #include <boost/fusion/include/as_map.hpp>

[heading Example]

    // from sequence of __fusion_pair__
    as_map(__make_vector__(
        __fusion_make_pair__<int>('X')
      , __fusion_make_pair__<double>("Men")))

    // from associative sequence
    namespace ns
    {
        struct x_member;
        struct y_member;
    }
    BOOST_FUSION_DEFINE_ASSOC_STRUCT(
        (ns),
        point,
        (int, x, ns::x_member)
        (int, y, ns::y_member)
    )
    ...
    as_map(ns::point(123, 456))

[endsect]

[endsect]

[section Metafunctions]

[section as_list]

[heading Description]

Returns the result type of __as_list__.

[heading Synopsis]

    template <typename Sequence>
    struct as_list;

[heading Parameters]

[table
    [[Parameter]    [Requirement]               [Description]]
    [[`Sequence`]   [A fusion __sequence__]     [The sequence type to convert.]]
]

[heading Expression Semantics]

    result_of::as_list<Sequence>::type;

[*Return type]: A __list__ with same elements as the input sequence,
`Sequence`.

[*Semantics]: Convert a fusion sequence, `Sequence`, to a __list__.

[heading Header]

    #include <boost/fusion/container/list/convert.hpp>
    #include <boost/fusion/include/as_list.hpp>

[heading Example]

    result_of::as_list<__vector__<char, int> >::type

[endsect]

[section as_vector]

[heading Description]

Returns the result type of __as_vector__.

[heading Synopsis]

    template <typename Sequence>
    struct as_vector;

[heading Parameters]

[table
    [[Parameter]    [Requirement]               [Description]]
    [[`Sequence`]   [A fusion __sequence__]     [The sequence to convert.]]
]

[heading Expression Semantics]

    result_of::as_vector<Sequence>::type;

[*Return type]: A __vector__ with same elements as the input sequence,
`Sequence`.

[*Semantics]: Convert a fusion sequence, `Sequence`, to a __vector__.

[heading Header]

    #include <boost/fusion/container/vector/convert.hpp>
    #include <boost/fusion/include/as_vector.hpp>

[heading Example]

    result_of::as_vector<__list__<char, int> >::type

[endsect]

[section as_deque]

[heading Description]

Returns the result type of __as_deque__.

[heading Synopsis]

    template <typename Sequence>
    struct as_deque;

[heading Parameters]

[table
    [[Parameter]    [Requirement]               [Description]]
    [[`Sequence`]   [A fusion __sequence__]     [The sequence type to convert.]]
]

[heading Expression Semantics]

    result_of::as_deque<Sequence>::type;

[*Return type]: A __deque__ with same elements as the input sequence,
`Sequence`.

[*Semantics]: Convert a fusion sequence, `Sequence`, to a __deque__.

[heading Header]

    #include <boost/fusion/container/deque/convert.hpp>
    #include <boost/fusion/include/as_deque.hpp>

[heading Example]

    result_of::as_deque<__vector__<char, int> >::type

[endsect]

[section as_set]

[heading Description]

Returns the result type of __as_set__.

[heading Synopsis]

    template <typename Sequence>
    struct as_set;

[heading Parameters]

[table
    [[Parameter]    [Requirement]               [Description]]
    [[`Sequence`]   [A fusion __sequence__]     [The sequence to convert.]]
]

[heading Expression Semantics]

    result_of::as_set<Sequence>::type;

[*Return type]: A __set__ with same elements as the input sequence,
`Sequence`.

[*Semantics]: Convert a fusion sequence, `Sequence`, to a __set__.

[*Precondition]: There may be no duplicate key types.

[heading Header]

    #include <boost/fusion/container/set/convert.hpp>
    #include <boost/fusion/include/as_set.hpp>

[heading Example]

    result_of::as_set<__vector__<char, int> >::type

[endsect]

[section as_map]

[heading Description]

Returns the result type of __as_map__.

[heading Synopsis]

    template <typename Sequence>
    struct as_map;

[heading Parameters]

[table
    [[Parameter]    [Requirement]               [Description]]
    [[`Sequence`]   [A fusion __sequence__]     [The sequence to convert.]]
]

[heading Expression Semantics]

    result_of::as_map<Sequence>::type;

[*Return type]: A __map__ with same elements as the input sequence,
`Sequence`.

[*Semantics]: Convert a fusion sequence, `Sequence`, to a __map__.

[*Precondition]: For non-associative sequence, the elements are assumed to be
__fusion_pair__s. There may be no duplicate __fusion_pair__ key types.

[heading Header]

    #include <boost/fusion/container/map/convert.hpp>
    #include <boost/fusion/include/as_map.hpp>

[heading Example]

    // from sequence of __fusion_pair__
    result_of::as_map<__vector__<
        __fusion_pair__<int, char>
      , __fusion_pair__<double, std::string> > >::type

    // from associative sequence
    namespace ns
    {
        struct x_member;
        struct y_member;
    }
    BOOST_FUSION_DEFINE_ASSOC_STRUCT(
        (ns),
        point,
        (int, x, ns::x_member)
        (int, y, ns::y_member)
    )
    ...
    result_of::as_map<ns::point>::type // __map__<__fusion_pair__<ns::x_member, int>, __fusion_pair__<ns::y_member, int> >

[endsect]

[endsect]

[endsect]

[endsect]
