[/==============================================================================
    Copyright (C) 2001-2011 Joel de Guzman
    Copyright (C) 2006 Dan Marsden
    Copyright (C) 2010 Christopher Schmidt
    Copyright (C) 2018 Kohei Takahashi

    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)
===============================================================================/]
[library Fusion
    [quickbook 1.3]
    [version 2.2]
    [authors [de Guzman, Joel], [Marsden, Dan], [Schwinger, Tobias]]
    [copyright 2001 2002 2003 2004 2005 2006 2011 2012 Joel de Guzman, Dan Marsden, Tobias Schwinger]
    [purpose Statically Typed Heterogeneous Data Structures and Algorithms]
    [license
        Distributed under 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])
    ]
]

[def __spirit__                 [@http://boost-spirit.com/home/ Spirit]]
[def __phoenix__                [@http://www.boost.org/libs/phoenix Phoenix]]
[def __mpl__                    [@http://www.boost.org/libs/mpl MPL]]
[def __stl__                    [@http://en.wikipedia.org/wiki/Standard_Template_Library STL]]
[def __tuple__                  [@http://www.boost.org/libs/tuple Boost.Tuple]]
[def __tr1__tuple__             [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2002/n1403.pdf TR1 Tuple]]
[def __boost_tools__            [@http://www.boost.org/tools/index.html Boost Tools]]
[def __spirit_list__            [@https://sourceforge.net/projects/spirit/lists/spirit-general Spirit Mailing List]]
[def __list_archive__           [@https://sourceforge.net/p/spirit/mailman/spirit-general/ archive]]
[def __jaakko_jarvi__           [@http://www.boost.org/people/jaakko_jarvi.htm Jaakko Jarvi]]
[def __david_abrahams__         [@http://www.boost.org/people/dave_abrahams.htm David Abrahams]]
[def __the_forwarding_problem__ [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2002/n1385.htm The Forwarding Problem]]

[def __boost_any__              [@http://www.boost.org/libs/any Boost.Any Library]]
[def __new_iterator_concepts__  [@http://www.boost.org/libs/iterator/doc/new-iter-concepts.html New Iterator Concepts]]
[def __boost_array_library__    [@http://www.boost.org/libs/array Boost.Array Library]]
[def __boost_variant_library__  [@http://www.boost.org/libs/variant Boost.Variant Library]]
[def __boost_tuple_library__    [@http://www.boost.org/libs/tuple Boost.Tuple Library]]
[def __boost_ref__              [@http://www.boost.org/libs/core/ref.html Ref utility]]
[def __boost_ref_call__         [@http://www.boost.org/libs/core/ref.html `ref`]]
[def __boost_result_of__        [@http://www.boost.org/libs/utility/utility.htm#result_of ResultOf utility]]
[def __boost_result_of_call__   [@http://www.boost.org/libs/utility/utility.htm#result_of `boost::result_of`]]
[def __boost_enable_if__        [@http://www.boost.org/libs/core/doc/html/core/enable_if.html EnableIf utility]]
[def __boost_shared_ptr_call__  [@http://www.boost.org/libs/smart_ptr#shared_ptr `boost::shared_ptr`]]
[def __boost_func_forward__     [@http://www.boost.org/libs/functional/forward Boost.Functional/Forward Library]]
[def __boost_func_factory__     [@http://www.boost.org/libs/functional/factory Boost.Functional/Factory Library]]
[def __boost_func_hash__        [@http://www.boost.org/doc/html/hash.html Boost.ContainerHash Library]]
[def __std_pair_doc__           [@http://en.cppreference.com/w/cpp/utility/pair `std::pair`]]
[def __std_tuple_doc__          [@http://en.cppreference.com/w/cpp/utility/tuple `std::tuple`]]
[def __std_plus_doc__           [@http://en.cppreference.com/w/cpp/utility/functional/plus `std::plus`]]
[def __std_minus_doc__          [@http://en.cppreference.com/w/cpp/utility/functional/minus `std::minus`]]

[def __mpl_integral_constant__  [@http://www.boost.org/libs/mpl/doc/refmanual/integral-constant.html MPL Integral Constant]]
[def __mpl_boolean_constant__   [@http://www.boost.org/libs/mpl/doc/refmanual/integral-constant.html MPL Boolean Constant]]
[def __mpl_metafunction_class__ [@http://www.boost.org/libs/mpl/doc/refmanual/metafunction-class.html MPL Metafunction Class]]
[def __mpl_lambda_expression__  [@http://www.boost.org/libs/mpl/doc/refmanual/lambda-expression.html MPL Lambda Expression]]

[def __lvalue__                 LValue]
[def __unspecified__            /unspecified/]

[def __support__                [link fusion.support Support]]
[def __is_sequence__            [link fusion.support.is_sequence `is_sequence`]]
[def __is_view__                [link fusion.support.is_view `is_view`]]
[def __tag_of__                 [link fusion.support.tag_of `tag_of`]]
[def __category_of__            [link fusion.support.category_of `category_of`]]
[def __deduce__                 [link fusion.support.deduce `deduce`]]
[def __deduce_sequence__        [link fusion.support.deduce_sequence `deduce_sequence`]]
[def __fusion_pair__            [link fusion.support.pair `fusion::pair`]]
[def __pair__                   [link fusion.support.pair `pair`]]
[def __fusion_make_pair__       [link fusion.support.pair `make_pair`]]

[def __iterator__               [link fusion.iterator Iterator]]
[def __iterator_concepts__      [link fusion.iterator.concepts Iterator Concepts]]
[def __forward_iterator__       [link fusion.iterator.concepts.forward_iterator Forward Iterator]]
[def __bidirectional_iterator__ [link fusion.iterator.concepts.bidirectional_iterator Bidirectional Iterator]]
[def __random_access_iterator__ [link fusion.iterator.concepts.random_access_iterator Random Access Iterator]]
[def __associative_iterator__   [link fusion.iterator.concepts.associative_iterator Associative Iterator]]
[def __unbounded_iterator__     [link fusion.iterator.concepts.unbounded_iterator Unbounded Iterator]]

[def __next__                   [link fusion.iterator.functions.next `next`]]
[def __prior__                  [link fusion.iterator.functions.prior `prior`]]
[def __advance__                [link fusion.iterator.functions.advance `advance`]]
[def __advance_c__              [link fusion.iterator.functions.advance_c `advance_c`]]
[def __distance__               [link fusion.iterator.functions.distance `distance`]]
[def __deref__                  [link fusion.iterator.functions.deref `deref`]]
[def __deref_data__             [link fusion.iterator.functions.deref_data `deref_data`]]

[def __result_of_next__         [link fusion.iterator.metafunctions.next `result_of::next`]]
[def __result_of_prior__        [link fusion.iterator.metafunctions.prior `result_of::prior`]]
[def __result_of_equal_to__     [link fusion.iterator.metafunctions.equal_to `result_of::equal_to`]]
[def __result_of_advance__      [link fusion.iterator.metafunctions.advance `result_of::advance`]]
[def __result_of_advance_c__    [link fusion.iterator.metafunctions.advance_c `result_of::advance_c`]]
[def __result_of_distance__     [link fusion.iterator.metafunctions.distance `result_of::distance`]]
[def __result_of_deref__        [link fusion.iterator.metafunctions.deref `result_of::deref`]]
[def __result_of_value_of__     [link fusion.iterator.metafunctions.value_of `result_of::value_of`]]
[def __result_of_key_of__       [link fusion.iterator.metafunctions.key_of `result_of::key_of`]]
[def __result_of_value_of_data__ [link fusion.iterator.metafunctions.value_of_data `result_of::value_of_data`]]
[def __result_of_deref_data__   [link fusion.iterator.metafunctions.deref_data `result_of::deref_data`]]

[def __sequence__               [link fusion.sequence Sequence]]
[def __sequence_concepts__      [link fusion.sequence.concepts Sequence Concepts]]
[def __traversal_concept__      [link fusion.sequence.concepts.traversal Sequence Traversal Concept]]
[def __associativity_concept__  [link fusion.sequence.concepts.associativity Sequence Associativity Concept]]
[def __forward_sequence__       [link fusion.sequence.concepts.forward_sequence Forward Sequence]]
[def __bidirectional_sequence__ [link fusion.sequence.concepts.bidirectional_sequence Bidirectional Sequence]]
[def __random_access_sequence__ [link fusion.sequence.concepts.random_access_sequence Random Access Sequence]]
[def __associative_sequence__   [link fusion.sequence.concepts.associative_sequence Associative Sequence]]
[def __unbounded_sequence__     [link fusion.sequence.concepts.unbounded_sequence Unbounded Sequence]]

[def __containers__             [link fusion.container Container]]
[def __vector__                 [link fusion.container.vector `vector`]]
[def __cons__                   [link fusion.container.cons `cons`]]
[def __list__                   [link fusion.container.list `list`]]
[def __deque__                  [link fusion.container.deque `deque`]]
[def __front_extended_deque__   [link fusion.container.front_extended_deque `front_extended_deque`]]
[def __back_extended_deque__    [link fusion.container.back_extended_deque `back_extended_deque`]]
[def __set__                    [link fusion.container.set `set`]]
[def __map__                    [link fusion.container.map `map`]]

[def __view__                   [link fusion.view View]]
[def __views__                  [link fusion.view Views]]
[def __single_view__            [link fusion.view.single_view `single_view`]]
[def __filter_view__            [link fusion.view.filter_view `filter_view`]]
[def __iterator_range__         [link fusion.view.iterator_range `iterator_range`]]
[def __joint_view__             [link fusion.view.joint_view `joint_view`]]
[def __transform_view__         [link fusion.view.transform_view `transform_view`]]
[def __reverse_view__           [link fusion.view.reverse_view `reverse_view`]]
[def __zip_view__               [link fusion.view.zip_view `zip_view`]]
[def __flatten_view__           [link fusion.view.flatten_view `flatten_view`]]

[def __array__                  [link fusion.adapted.array array]]
[def __std_pair__               [link fusion.adapted.std__pair `std::pair`]]
[def __boost_array__            [link fusion.adapted.boost__array `boost::array`]]
[def __mpl_sequence__           [link fusion.adapted.mpl_sequence mpl sequence]]
[def __adapt_tpl_struct__       [link fusion.adapted.adapt_tpl_struct `BOOST_FUSION_ADAPT_TPL_STRUCT`]]
[def __adapt_struct_named__     [link fusion.adapted.adapt_struct_named `BOOST_FUSION_ADAPT_STRUCT_NAMED`]]
[def __adapt_struct_named_ns__  [link fusion.adapted.adapt_struct_named `BOOST_FUSION_ADAPT_STRUCT_NAMED_NS`]]
[def __adapt_assoc_tpl_struct__ [link fusion.adapted.adapt_assoc_tpl_struct `BOOST_FUSION_ADAPT_ASSOC_TPL_STRUCT`]]
[def __adapt_assoc_struct_named__ [link fusion.adapted.adapt_assoc_struct_named `BOOST_FUSION_ADAPT_ASSOC_STRUCT_NAMED`]]
[def __adapt_assoc_struct_named_ns__ [link fusion.adapted.adapt_assoc_struct_named `BOOST_FUSION_ADAPT_ASSOC_STRUCT_NAMED_NS`]]
[def __adapt_adt__              [link fusion.adapted.adapt_adt `BOOST_FUSION_ADAPT_ADT`]]
[def __adapt_tpl_adt__          [link fusion.adapted.adapt_tpl_adt `BOOST_FUSION_ADAPT_TPL_ADT`]]
[def __adapt_assoc_adt__        [link fusion.adapted.adapt_assoc_adt `BOOST_FUSION_ADAPT_ASSOC_ADT`]]
[def __adapt_assoc_tpl_adt__    [link fusion.adapted.adapt_assoc_tpl_adt `BOOST_FUSION_ADAPT_ASSOC_TPL_ADT`]]
[def __define_struct__          [link fusion.adapted.define_struct `BOOST_FUSION_DEFINE_STRUCT`]]
[def __define_tpl_struct__      [link fusion.adapted.define_tpl_struct `BOOST_FUSION_DEFINE_TPL_STRUCT`]]
[def __define_assoc_struct__    [link fusion.adapted.define_assoc_struct `BOOST_FUSION_DEFINE_ASSOC_STRUCT`]]
[def __define_assoc_tpl_struct__ [link fusion.adapted.define_assoc_tpl_struct `BOOST_FUSION_DEFINE_ASSOC_TPL_STRUCT`]]

[def __intrinsic__              [link fusion.sequence.intrinsic Intrinsic]]
[def __intrinsics__             [link fusion.sequence.intrinsic Intrinsics]]
[def __begin__                  [link fusion.sequence.intrinsic.functions.begin `begin`]]
[def __result_of_begin__        [link fusion.sequence.intrinsic.metafunctions.begin `result_of::begin`]]
[def __end__                    [link fusion.sequence.intrinsic.functions.end `end`]]
[def __result_of_end__          [link fusion.sequence.intrinsic.metafunctions.end `result_of::end`]]
[def __size__                   [link fusion.sequence.intrinsic.functions.size `size`]]
[def __result_of_size__         [link fusion.sequence.intrinsic.metafunctions.size `result_of::size`]]
[def __empty__                  [link fusion.sequence.intrinsic.functions.empty `empty`]]
[def __result_of_empty__        [link fusion.sequence.intrinsic.metafunctions.empty `result_of::empty`]]
[def __front__                  [link fusion.sequence.intrinsic.functions.front `front`]]
[def __result_of_front__        [link fusion.sequence.intrinsic.metafunctions.front `result_of::front`]]
[def __back__                   [link fusion.sequence.intrinsic.functions.back `back`]]
[def __result_of_back__         [link fusion.sequence.intrinsic.metafunctions.back `result_of::back`]]
[def __at__                     [link fusion.sequence.intrinsic.functions.at `at`]]
[def __result_of_at__           [link fusion.sequence.intrinsic.metafunctions.at `result_of::at`]]
[def __at_c__                   [link fusion.sequence.intrinsic.functions.at_c `at_c`]]
[def __result_of_at_c__         [link fusion.sequence.intrinsic.metafunctions.at_c `result_of::at_c`]]
[def __at_key__                 [link fusion.sequence.intrinsic.functions.at_key `at_key`]]
[def __result_of_at_key__       [link fusion.sequence.intrinsic.metafunctions.at_key `result_of::at_key`]]
[def __has_key__                [link fusion.sequence.intrinsic.functions.has_key `has_key`]]
[def __result_of_has_key__      [link fusion.sequence.intrinsic.metafunctions.has_key `result_of::has_key`]]
[def __result_of_value_at__     [link fusion.sequence.intrinsic.metafunctions.value_at `result_of::value_at`]]
[def __result_of_value_at_c__   [link fusion.sequence.intrinsic.metafunctions.value_at_c `result_of::value_at_c`]]
[def __result_of_value_at_key__ [link fusion.sequence.intrinsic.metafunctions.value_at_key `result_of::value_at_key`]]
[def __swap__                   [link fusion.sequence.intrinsic.functions.swap `swap`]]
[def __result_of_swap__         [link fusion.sequence.intrinsic.metafunctions.swap `result_of::swap`]]

[def __conversion__             [link fusion.container.conversion.functions Conversion]]
[def __result_of_conversion__   [link fusion.container.conversion.metafunctions Conversion Metafunctions]]
[def __as_vector__              [link fusion.container.conversion.functions.as_vector `as_vector`]]
[def __result_of_as_vector__    [link fusion.container.conversion.metafunctions.as_vector `result_of::as_vector`]]
[def __as_list__                [link fusion.container.conversion.functions.as_list `as_list`]]
[def __result_of_as_list__      [link fusion.container.conversion.metafunctions.as_list `result_of::as_list`]]
[def __as_set__                 [link fusion.container.conversion.functions.as_set `as_set`]]
[def __result_of_as_set__       [link fusion.container.conversion.metafunctions.as_set `result_of::as_set`]]
[def __as_map__                 [link fusion.container.conversion.functions.as_map `as_map`]]
[def __result_of_as_map__       [link fusion.container.conversion.metafunctions.as_map `result_of::as_map`]]

[def __generation__             [link fusion.container.generation.functions Generation]]
[def __result_of_generation__   [link fusion.container.generation.metafunctions Generation Metafunctions]]
[def __make_vector__            [link fusion.container.generation.functions.make_vector `make_vector`]]
[def __result_of_make_vector__  [link fusion.container.generation.metafunctions.make_vector `result_of::make_vector`]]
[def __vector_tie__             [link fusion.container.generation.functions.vector_tie `vector_tie`]]
[def __map_tie__                [link fusion.container.generation.functions.vector_tie `map_tie`]]
[def __result_of_vector_tie__   [link fusion.container.generation.metafunctions.vector_tie `result_of::vector_tie`]]
[def __make_vector__            [link fusion.container.generation.functions.make_vector `make_vector`]]
[def __result_of_make_vector__  [link fusion.container.generation.metafunctions.make_vector `result_of::make_vector`]]
[def __make_cons__              [link fusion.container.generation.functions.make_cons `make_cons`]]
[def __result_of_make_cons__    [link fusion.container.generation.metafunctions.make_cons `result_of::make_cons`]]
[def __make_list__              [link fusion.container.generation.functions.make_list `make_list`]]
[def __result_of_make_list__    [link fusion.container.generation.metafunctions.make_list `result_of::make_list`]]
[def __make_deque__             [link fusion.container.generation.functions.make_deque `make_deque`]]
[def __result_of_make_deque__   [link fusion.container.generation.metafunctions.make_deque `result_of::make_deque`]]
[def __make_set__               [link fusion.container.generation.functions.make_set `make_set`]]
[def __result_of_make_set__     [link fusion.container.generation.metafunctions.make_set `result_of::make_set`]]
[def __make_map__               [link fusion.container.generation.functions.make_map `make_map`]]
[def __result_of_make_map__     [link fusion.container.generation.metafunctions.make_map `result_of::make_map`]]
[def __list_tie__               [link fusion.container.generation.functions.list_tie `list_tie`]]
[def __result_of_list_tie__     [link fusion.container.generation.metafunctions.list_tie `result_of::list_tie`]]
[def __deque_tie__              [link fusion.container.generation.functions.deque_tie `deque_tie`]]
[def __result_of_deque_tie__    [link fusion.container.generation.metafunctions.deque_tie `result_of::deque_tie`]]

[def __out__                    [link fusion.sequence.operator.i_o.out out]]
[def __in__                     [link fusion.sequence.operator.i_o.in in]]
[def __eq__                     [link fusion.sequence.operator.comparison.equal equal]]
[def __neq__                    [link fusion.sequence.operator.comparison.not_equal not equal]]
[def __lt__                     [link fusion.sequence.operator.comparison.less_than less than]]
[def __lte__                    [link fusion.sequence.operator.comparison.less_than_equal less than equal]]
[def __gt__                     [link fusion.sequence.operator.comparison.greater_than greater than]]
[def __gte__                    [link fusion.sequence.operator.comparison.greater_than_equal greater than equal]]

[def __algorithm__              [link fusion.algorithm Algorithm]]
[def __algorithms__             [link fusion.algorithm Algorithms]]
[def __copy__                   [link fusion.algorithm.auxiliary.functions.copy `copy`]]
[def __result_of_copy__         [link fusion.algorithm.auxiliary.metafunctions.copy `result_of::copy`]]
[def __move__                   [link fusion.algorithm.auxiliary.functions.move `move`]]
[def __result_of_move__         [link fusion.algorithm.auxiliary.metafunctions.move `result_of::move`]]
[def __fold__                   [link fusion.algorithm.iteration.functions.fold `fold`]]
[def __result_of_fold__         [link fusion.algorithm.iteration.metafunctions.fold `result_of::fold`]]
[def __reverse_fold__           [link fusion.algorithm.iteration.functions.reverse_fold `reverse_fold`]]
[def __result_of_reverse_fold__ [link fusion.algorithm.iteration.metafunctions.reverse_fold `result_of::reverse_fold`]]
[def __iter_fold__              [link fusion.algorithm.iteration.functions.iter_fold `iter_fold`]]
[def __result_of_iter_fold__    [link fusion.algorithm.iteration.metafunctions.iter_fold `result_of::iter_fold`]]
[def __reverse_iter_fold__      [link fusion.algorithm.iteration.functions.reverse_iter_fold `reverse_iter_fold`]]
[def __result_of_reverse_iter_fold__ [link fusion.algorithm.iteration.metafunctions.reverse_iter_fold `result_of::reverse_iter_fold`]]
[def __accumulate__             [link fusion.algorithm.iteration.functions.accumulate `accumulate`]]
[def __result_of_accumulate__   [link fusion.algorithm.iteration.metafunctions.accumulate `result_of::accumulate`]]
[def __for_each__               [link fusion.algorithm.iteration.functions.for_each `for_each`]]
[def __result_of_for_each__     [link fusion.algorithm.iteration.metafunctions.for_each `result_of::for_each`]]
[def __any__                    [link fusion.algorithm.query.functions.any `any`]]
[def __result_of_any__          [link fusion.algorithm.query.metafunctions.any `result_of::any`]]
[def __all__                    [link fusion.algorithm.query.functions.all `all`]]
[def __result_of_all__          [link fusion.algorithm.query.metafunctions.all `result_of::all`]]
[def __none__                   [link fusion.algorithm.query.functions.none `none`]]
[def __result_of_none__         [link fusion.algorithm.query.metafunctions.none `result_of::none`]]
[def __find__                   [link fusion.algorithm.query.functions.find `find`]]
[def __result_of_find__         [link fusion.algorithm.query.metafunctions.find `result_of::find`]]
[def __find_if__                [link fusion.algorithm.query.functions.find_if `find_if`]]
[def __result_of_find_if__      [link fusion.algorithm.query.metafunctions.find_if `result_of::find_if`]]
[def __count__                  [link fusion.algorithm.query.functions.count `count`]]
[def __result_of_count__        [link fusion.algorithm.query.metafunctions.count `result_of::count`]]
[def __count_if__               [link fusion.algorithm.query.functions.count_if `count_if`]]
[def __result_of_count_if__     [link fusion.algorithm.query.metafunctions.count_if `result_of::count_if`]]
[def __filter__                 [link fusion.algorithm.transformation.functions.filter `filter`]]
[def __result_of_filter__       [link fusion.algorithm.transformation.metafunctions.filter `result_of::filter`]]
[def __filter_if__              [link fusion.algorithm.transformation.functions.filter_if `filter_if`]]
[def __result_of_filter_if__    [link fusion.algorithm.transformation.metafunctions.filter_if `result_of::filter_if`]]
[def __transform__              [link fusion.algorithm.transformation.functions.transform `transform`]]
[def __result_of_transform__    [link fusion.algorithm.transformation.metafunctions.transform `result_of::transform`]]
[def __replace__                [link fusion.algorithm.transformation.functions.replace `replace`]]
[def __result_of_replace__      [link fusion.algorithm.transformation.metafunctions.replace `result_of::replace`]]
[def __replace_if__             [link fusion.algorithm.transformation.functions.replace_if `replace_if`]]
[def __result_of_replace_if__   [link fusion.algorithm.transformation.metafunctions.replace_if `result_of::replace_if`]]
[def __remove__                 [link fusion.algorithm.transformation.functions.remove `remove`]]
[def __result_of_remove__       [link fusion.algorithm.transformation.metafunctions.remove `result_of::remove`]]
[def __remove_if__              [link fusion.algorithm.transformation.functions.remove_if `remove_if`]]
[def __result_of_remove_if__    [link fusion.algorithm.transformation.metafunctions.remove_if `result_of::remove_if`]]
[def __reverse__                [link fusion.algorithm.transformation.functions.reverse `reverse`]]
[def __result_of_reverse__      [link fusion.algorithm.transformation.metafunctions.reverse `result_of::reverse`]]
[def __clear__                  [link fusion.algorithm.transformation.functions.clear `clear`]]
[def __result_of_clear__        [link fusion.algorithm.transformation.metafunctions.clear `result_of::clear`]]
[def __erase__                  [link fusion.algorithm.transformation.functions.erase `erase`]]
[def __result_of_erase__        [link fusion.algorithm.transformation.metafunctions.erase `result_of::erase`]]
[def __erase_key__              [link fusion.algorithm.transformation.functions.erase_key `erase_key`]]
[def __result_of_erase_key__    [link fusion.algorithm.transformation.metafunctions.erase_key `result_of::erase_key`]]
[def __insert__                 [link fusion.algorithm.transformation.functions.insert `insert`]]
[def __result_of_insert__       [link fusion.algorithm.transformation.metafunctions.insert `result_of::insert`]]
[def __insert_range__           [link fusion.algorithm.transformation.functions.insert_range `insert_range`]]
[def __result_of_insert_range__ [link fusion.algorithm.transformation.metafunctions.insert_range `result_of::insert_range`]]
[def __join__                   [link fusion.algorithm.transformation.functions.join `join`]]
[def __result_of_join__         [link fusion.algorithm.transformation.metafunctions.join `result_of::join`]]
[def __zip__                    [link fusion.algorithm.transformation.functions.zip `zip`]]
[def __result_of_zip__          [link fusion.algorithm.transformation.metafunctions.zip `result_of::zip`]]
[def __pop_back__               [link fusion.algorithm.transformation.functions.pop_back `pop_back`]]
[def __result_of_pop_back__     [link fusion.algorithm.transformation.metafunctions.pop_back `result_of::pop_back`]]
[def __pop_front__              [link fusion.algorithm.transformation.functions.pop_front `pop_front`]]
[def __result_of_pop_front__    [link fusion.algorithm.transformation.metafunctions.pop_front `result_of::pop_front`]]
[def __push_back__              [link fusion.algorithm.transformation.functions.push_back `push_back`]]
[def __result_of_push_back__    [link fusion.algorithm.transformation.metafunctions.push_back `result_of::push_back`]]
[def __push_front__             [link fusion.algorithm.transformation.functions.push_front `push_front`]]
[def __result_of_push_front__   [link fusion.algorithm.transformation.metafunctions.push_front `result_of::push_front`]]
[def __flatten__                [link fusion.algorithm.transformation.functions.flatten `flatten`]]
[def __result_of_flatten__      [link fusion.algorithm.transformation.metafunctions.flatten `result_of::flatten`]]

[def __tr1_tuple_pair__         [link fusion.tuple.pairs `TR1 and std::pair`]]
[def __tuple_get__              [link fusion.tuple.class_template_tuple.element_access `get`]]

[def __callable_obj__           [link fusion.functional.concepts.callable Callable Object]]
[def __def_callable_obj__       [link fusion.functional.concepts.def_callable Deferred Callable Object]]
[def __reg_callable_obj__       [link fusion.functional.concepts.reg_callable Regular Callable Object]]
[def __poly_func_obj__          [link fusion.functional.concepts.poly Polymorphic Function Object]]
[def __functional_adapters__    [link fusion.functional.adapters functional adapters]]
[def __fused__                  [link fusion.functional.adapters.fused `fused`]]
[def __fused_procedure__        [link fusion.functional.adapters.fused_procedure `fused_procedure`]]
[def __fused_function_object__  [link fusion.functional.adapters.fused_function_object `fused_function_object`]]
[def __unfused__                [link fusion.functional.adapters.unfused `unfused`]]
[def __unfused_typed__          [link fusion.functional.adapters.unfused_typed `unfused_typed`]]
[def __invoke__                 [link fusion.functional.invocation.functions.invoke `invoke`]]
[def __invoke_procedure__       [link fusion.functional.invocation.functions.invoke_proc `invoke_procedure`]]
[def __invoke_function_object__ [link fusion.functional.invocation.functions.invoke_fobj `invoke_function_object`]]
[def __make_fused__                 [link fusion.functional.generation.functions.mk_fused `make_fused`]]
[def __make_fused_procedure__       [link fusion.functional.generation.functions.mk_fused_proc `make_fused_procedure`]]
[def __make_fused_function_object__ [link fusion.functional.generation.functions.mk_fused_fobj `make_fused_function_object`]]
[def __make_unfused__               [link fusion.functional.generation.functions.mk_unfused `make_unfused`]]
[def __result_of_invoke__                     [link fusion.functional.invocation.metafunctions.invoke `result_of::invoke`]]
[def __result_of_invoke_procedure__           [link fusion.functional.invocation.metafunctions.invoke_proc `result_of::invoke_procedure`]]
[def __result_of_invoke_function_object__     [link fusion.functional.invocation.metafunctions.invoke_fobj `result_of::invoke_function_object`]]
[def __result_of_make_fused__                 [link fusion.functional.generation.metafunctions.mk_fused `result_of::make_fused`]]
[def __result_of_make_fused_procedure__       [link fusion.functional.generation.metafunctions.mk_fused_proc `result_of::make_fused_procedure`]]
[def __result_of_make_fused_function_object__ [link fusion.functional.generation.metafunctions.mk_fused_fobj `result_of::make_fused_function_object`]]
[def __result_of_make_unfused__               [link fusion.functional.generation.metafunctions.mk_unfused `result_of::make_unfused`]]

[def __recursive_inline__       [link fusion.notes.recursive_inlined_functions Recursive Inlined Functions]]
[def __overloaded_functions__   [link fusion.notes.overloaded_functions Overloaded Functions]]
[def __tag_dispatching__        [link fusion.notes.tag_dispatching /tag dispatching/]]
[def __element_conversion__     [link fusion.notes.element_conversion /element conversion/]]
[def __see_element_conversion__ [link fusion.notes.element_conversion /see element conversion/]]
[def __note_ref_wrappers__      [link fusion.notes.reference_wrappers `Reference Wrappers`]]

[def __quick_start__            [link fusion.quick_start Quick Start]]
[def __organization__           [link fusion.organization Organization]]
[def __extension__              [link fusion.extension Extension]]
[def __sequence_facade__        [link fusion.extension.sequence_facade `sequence_facade`]]
[def __iterator_facade__        [link fusion.extension.iterator_facade `iterator_facade`]]

[def __adt_attribute_proxy__    [link fusion.notes.adt_attribute_proxy `adt_attribute_proxy`]]

[def __window_function__        [@http://en.wikipedia.org/wiki/Window_function Window Function]]

[include preface.qbk]
[include introduction.qbk]
[include quick_start.qbk]
[include organization.qbk]
[include support.qbk]
[include iterator.qbk]
[include sequence.qbk]
[include container.qbk]
[include view.qbk]
[include adapted.qbk]
[include algorithm.qbk]
[include tuple.qbk]
[include extension.qbk]
[include functional.qbk]
[include notes.qbk]
[include changelog.qbk]
[include acknowledgements.qbk]
[include references.qbk]

