Squashed 'third_party/boostorg/fusion/' content from commit c740a4d
Change-Id: I7edf009a9af708652675b581322ff44ce5d1559a
git-subtree-dir: third_party/boostorg/fusion
git-subtree-split: c740a4dbadb5daf836f2f8ab024e6ae5fa331dde
diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 0000000..3e84d7c
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1,96 @@
+* text=auto !eol svneol=native#text/plain
+*.gitattributes text svneol=native#text/plain
+
+# Scriptish formats
+*.bat text svneol=native#text/plain
+*.bsh text svneol=native#text/x-beanshell
+*.cgi text svneol=native#text/plain
+*.cmd text svneol=native#text/plain
+*.js text svneol=native#text/javascript
+*.php text svneol=native#text/x-php
+*.pl text svneol=native#text/x-perl
+*.pm text svneol=native#text/x-perl
+*.py text svneol=native#text/x-python
+*.sh eol=lf svneol=LF#text/x-sh
+configure eol=lf svneol=LF#text/x-sh
+
+# Image formats
+*.bmp binary svneol=unset#image/bmp
+*.gif binary svneol=unset#image/gif
+*.ico binary svneol=unset#image/ico
+*.jpeg binary svneol=unset#image/jpeg
+*.jpg binary svneol=unset#image/jpeg
+*.png binary svneol=unset#image/png
+*.tif binary svneol=unset#image/tiff
+*.tiff binary svneol=unset#image/tiff
+*.svg text svneol=native#image/svg%2Bxml
+
+# Data formats
+*.pdf binary svneol=unset#application/pdf
+*.avi binary svneol=unset#video/avi
+*.doc binary svneol=unset#application/msword
+*.dsp text svneol=crlf#text/plain
+*.dsw text svneol=crlf#text/plain
+*.eps binary svneol=unset#application/postscript
+*.gz binary svneol=unset#application/gzip
+*.mov binary svneol=unset#video/quicktime
+*.mp3 binary svneol=unset#audio/mpeg
+*.ppt binary svneol=unset#application/vnd.ms-powerpoint
+*.ps binary svneol=unset#application/postscript
+*.psd binary svneol=unset#application/photoshop
+*.rdf binary svneol=unset#text/rdf
+*.rss text svneol=unset#text/xml
+*.rtf binary svneol=unset#text/rtf
+*.sln text svneol=native#text/plain
+*.swf binary svneol=unset#application/x-shockwave-flash
+*.tgz binary svneol=unset#application/gzip
+*.vcproj text svneol=native#text/xml
+*.vcxproj text svneol=native#text/xml
+*.vsprops text svneol=native#text/xml
+*.wav binary svneol=unset#audio/wav
+*.xls binary svneol=unset#application/vnd.ms-excel
+*.zip binary svneol=unset#application/zip
+
+# Text formats
+.htaccess text svneol=native#text/plain
+*.bbk text svneol=native#text/xml
+*.cmake text svneol=native#text/plain
+*.css text svneol=native#text/css
+*.dtd text svneol=native#text/xml
+*.htm text svneol=native#text/html
+*.html text svneol=native#text/html
+*.ini text svneol=native#text/plain
+*.log text svneol=native#text/plain
+*.mak text svneol=native#text/plain
+*.qbk text svneol=native#text/plain
+*.rst text svneol=native#text/plain
+*.sql text svneol=native#text/x-sql
+*.txt text svneol=native#text/plain
+*.xhtml text svneol=native#text/xhtml%2Bxml
+*.xml text svneol=native#text/xml
+*.xsd text svneol=native#text/xml
+*.xsl text svneol=native#text/xml
+*.xslt text svneol=native#text/xml
+*.xul text svneol=native#text/xul
+*.yml text svneol=native#text/plain
+boost-no-inspect text svneol=native#text/plain
+CHANGES text svneol=native#text/plain
+COPYING text svneol=native#text/plain
+INSTALL text svneol=native#text/plain
+Jamfile text svneol=native#text/plain
+Jamroot text svneol=native#text/plain
+Jamfile.v2 text svneol=native#text/plain
+Jamrules text svneol=native#text/plain
+Makefile* text svneol=native#text/plain
+README text svneol=native#text/plain
+TODO text svneol=native#text/plain
+
+# Code formats
+*.c text svneol=native#text/plain
+*.cpp text svneol=native#text/plain
+*.h text svneol=native#text/plain
+*.hpp text svneol=native#text/plain
+*.ipp text svneol=native#text/plain
+*.tpp text svneol=native#text/plain
+*.jam text svneol=native#text/plain
+*.java text svneol=native#text/plain
diff --git a/.travis.yml b/.travis.yml
new file mode 100644
index 0000000..0528f49
--- /dev/null
+++ b/.travis.yml
@@ -0,0 +1,225 @@
+# Copyright 2016, 2017 Peter Dimov
+# Copyright 2017-2018 Kohei Takahashi
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
+
+language: cpp
+
+sudo: false
+
+os:
+ - linux
+ - osx
+
+env:
+ matrix:
+ - BOGUS_JOB=true
+
+matrix:
+
+ exclude:
+ - env: BOGUS_JOB=true
+
+ include:
+ # trusty default (gcc 4.8.4)
+ - os: linux
+ env: TOOLSET=gcc CXXSTD=03,11,1y
+
+ - os: linux
+ env: TOOLSET=gcc-4.4 CXXSTD=98,0x
+ addons:
+ apt:
+ packages:
+ - g++-4.4
+
+ - os: linux
+ env: TOOLSET=gcc-4.6 CXXSTD=03,0x
+ addons:
+ apt:
+ packages:
+ - g++-4.6
+
+ - os: linux
+ env: TOOLSET=gcc-4.7 CXXSTD=03,11
+ addons:
+ apt:
+ packages:
+ - g++-4.7
+
+ - os: linux
+ env: TOOLSET=gcc-4.8 CXXSTD=03,11,1y
+ addons:
+ apt:
+ packages:
+ - g++-4.8
+ sources:
+ - ubuntu-toolchain-r-test
+
+ - os: linux
+ env: TOOLSET=gcc-4.9 CXXSTD=03,11,1y
+ addons:
+ apt:
+ packages:
+ - g++-4.9
+ sources:
+ - ubuntu-toolchain-r-test
+
+ - os: linux
+ env: TOOLSET=gcc-5 CXXSTD=03,11,14,1z
+ addons:
+ apt:
+ packages:
+ - g++-5
+ sources:
+ - ubuntu-toolchain-r-test
+
+ - os: linux
+ env: TOOLSET=gcc-6 CXXSTD=03,11,14,1z
+ addons:
+ apt:
+ packages:
+ - g++-6
+ sources:
+ - ubuntu-toolchain-r-test
+
+ - os: linux
+ env: TOOLSET=gcc-7 CXXSTD=03,11,14,1z
+ addons:
+ apt:
+ packages:
+ - g++-7
+ sources:
+ - ubuntu-toolchain-r-test
+
+ # trusty default (clang 3.9.0)
+ - os: linux
+ env: TOOLSET=clang CXXSTD=03,11,14,1z
+ addons:
+ apt:
+ packages:
+ - libstdc++-4.9-dev
+ sources:
+ - ubuntu-toolchain-r-test
+
+ - os: linux
+ env: TOOLSET=clang-3.5 CXXSTD=03,11,14,1z
+ addons:
+ apt:
+ packages:
+ - clang-3.5
+ - libstdc++-4.9-dev
+ sources:
+ - ubuntu-toolchain-r-test
+
+ - os: linux
+ env: TOOLSET=clang-3.6 CXXSTD=03,11,14,1z
+ addons:
+ apt:
+ packages:
+ - clang-3.6
+ sources:
+ - ubuntu-toolchain-r-test
+ - llvm-toolchain-precise-3.6
+
+ - os: linux
+ env: TOOLSET=clang-3.7 CXXSTD=03,11,14,1z
+ addons:
+ apt:
+ packages:
+ - clang-3.7
+ sources:
+ - ubuntu-toolchain-r-test
+ - llvm-toolchain-precise-3.7
+
+ - os: linux
+ env: TOOLSET=clang-3.8 CXXSTD=03,11,14,1z
+ addons:
+ apt:
+ packages:
+ - clang-3.8
+ - libstdc++-4.9-dev
+ sources:
+ - ubuntu-toolchain-r-test
+
+ - os: linux
+ env: TOOLSET=clang-3.9 CXXSTD=03,11,14,1z
+ addons:
+ apt:
+ packages:
+ - clang-3.9
+ - libstdc++-4.9-dev
+ sources:
+ - ubuntu-toolchain-r-test
+
+ - os: linux
+ env: TOOLSET=clang-4.0 CXXSTD=03,11,14,1z
+ addons:
+ apt:
+ packages:
+ - clang-4.0
+ - libstdc++-4.9-dev
+ sources:
+ - ubuntu-toolchain-r-test
+ - llvm-toolchain-trusty-4.0
+
+ - os: linux
+ env: TOOLSET=clang-5.0 CXXSTD=03,11,14,1z,2a
+ addons:
+ apt:
+ packages:
+ - clang-5.0
+ - libstdc++-4.9-dev
+ sources:
+ - ubuntu-toolchain-r-test
+ - llvm-toolchain-trusty-5.0
+
+ - os: osx
+ env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z
+
+install:
+ - BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
+ - cd ..
+ - git clone --depth 1 -b $BOOST_BRANCH https://github.com/boostorg/boost.git boost-root
+ - cd boost-root
+
+ - git submodule init libs/array
+ - git submodule init libs/assert
+ - git submodule init libs/bind
+ - git submodule init libs/concept_check
+ - git submodule init libs/config
+ - git submodule init libs/container_hash
+ - git submodule init libs/conversion
+ - git submodule init libs/core
+ - git submodule init libs/detail
+ - git submodule init libs/function
+ - git submodule init libs/function_types
+ - git submodule init libs/functional
+ - git submodule init libs/integer
+ - git submodule init libs/iterator
+ - git submodule init libs/lambda
+ - git submodule init libs/move
+ - git submodule init libs/mpl
+ - git submodule init libs/optional
+ - git submodule init libs/predef
+ - git submodule init libs/preprocessor
+ - git submodule init libs/smart_ptr
+ - git submodule init libs/static_assert
+ - git submodule init libs/throw_exception
+ - git submodule init libs/tuple
+ - git submodule init libs/type_index
+ - git submodule init libs/type_traits
+ - git submodule init libs/typeof
+ - git submodule init libs/utility
+
+ - git submodule init tools/build
+ - git submodule update
+
+ - rm -rf libs/fusion
+ - mv $TRAVIS_BUILD_DIR libs/fusion
+ - ln -s $(pwd)/libs/fusion $TRAVIS_BUILD_DIR
+
+ - ./bootstrap.sh
+ - ./b2 headers
+
+script:
+ - ./b2 -j`(nproc || sysctl -n hw.ncpu) 2> /dev/null` libs/fusion/test toolset=$TOOLSET cxxstd=$CXXSTD
diff --git a/appveyor.yml b/appveyor.yml
new file mode 100644
index 0000000..4613ff6
--- /dev/null
+++ b/appveyor.yml
@@ -0,0 +1,85 @@
+# Copyright 2016, 2017 Peter Dimov
+# Copyright 2017-2018 Kohei Takahashi
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
+
+version: 1.0.{build}-{branch}
+
+shallow_clone: true
+
+environment:
+ matrix:
+ - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+ TOOLSET: msvc-9.0
+ CXXSTD: latest # fake
+ - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+ TOOLSET: msvc-10.0
+ CXXSTD: latest # fake
+ - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+ TOOLSET: msvc-11.0
+ CXXSTD: latest # fake
+ - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+ TOOLSET: msvc-12.0
+ CXXSTD: latest # fake
+ - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+ TOOLSET: msvc-14.0
+ CXXSTD: 14
+ - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+ TOOLSET: msvc-14.0
+ CXXSTD: latest
+ - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+ TOOLSET: msvc-14.1
+ CXXSTD: 14
+ - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+ TOOLSET: msvc-14.1
+ CXXSTD: 17
+ - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+ TOOLSET: msvc-14.1
+ CXXSTD: latest
+
+install:
+ - set BOOST_BRANCH=develop
+ - if "%APPVEYOR_REPO_BRANCH%" == "master" set BOOST_BRANCH=master
+ - cd ..
+ - git clone --depth 1 -b %BOOST_BRANCH% https://github.com/boostorg/boost.git boost-root
+ - cd boost-root
+
+ - git submodule init libs/array
+ - git submodule init libs/assert
+ - git submodule init libs/bind
+ - git submodule init libs/concept_check
+ - git submodule init libs/config
+ - git submodule init libs/container_hash
+ - git submodule init libs/conversion
+ - git submodule init libs/core
+ - git submodule init libs/detail
+ - git submodule init libs/function
+ - git submodule init libs/function_types
+ - git submodule init libs/functional
+ - git submodule init libs/integer
+ - git submodule init libs/iterator
+ - git submodule init libs/lambda
+ - git submodule init libs/move
+ - git submodule init libs/mpl
+ - git submodule init libs/optional
+ - git submodule init libs/predef
+ - git submodule init libs/preprocessor
+ - git submodule init libs/smart_ptr
+ - git submodule init libs/static_assert
+ - git submodule init libs/throw_exception
+ - git submodule init libs/tuple
+ - git submodule init libs/type_index
+ - git submodule init libs/type_traits
+ - git submodule init libs/typeof
+ - git submodule init libs/utility
+
+ - git submodule init tools/build
+ - git submodule update
+ - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\fusion
+ - cmd /c bootstrap
+ - b2 headers
+
+build: off
+
+test_script:
+ - b2 -j%NUMBER_OF_PROCESSORS% --hash libs/fusion/test toolset=%TOOLSET% cxxstd=%CXXSTD%
diff --git a/doc/Jamfile b/doc/Jamfile
new file mode 100644
index 0000000..04f9933
--- /dev/null
+++ b/doc/Jamfile
@@ -0,0 +1,32 @@
+#==============================================================================
+# Copyright (c) 2003-2011 Joel de Guzman
+#
+# 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)
+#==============================================================================
+project boost/libs/fusion/doc ;
+import boostbook : boostbook ;
+using quickbook ;
+
+path-constant images_location : html ;
+
+boostbook quickbook
+ :
+ fusion.qbk
+ :
+ <xsl:param>boost.root=../../../..
+ <xsl:param>chunk.section.depth=4
+ <xsl:param>chunk.first.sections=1
+ <xsl:param>toc.section.depth=3
+ <xsl:param>toc.max.depth=3
+ <xsl:param>generate.section.toc.level=4
+ <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/libs/fusion/doc/html
+ <format>pdf:<xsl:param>img.src.path=$(images_location)/
+ ;
+
+###############################################################################
+alias boostdoc ;
+explicit boostdoc ;
+alias boostrelease : quickbook ;
+explicit boostrelease ;
diff --git a/doc/acknowledgements.qbk b/doc/acknowledgements.qbk
new file mode 100644
index 0000000..da05995
--- /dev/null
+++ b/doc/acknowledgements.qbk
@@ -0,0 +1,24 @@
+[/==============================================================================
+ 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 Acknowledgements]
+
+Special thanks to David Abrahams, Douglas Gregor, Hartmut Kaiser, Aleksey
+Gurtovoy, Peder Holt, Daniel Wallin, Jaakko Jarvi, Jeremiah Willcock, Dan
+Marsden, Eric Niebler, Joao Abecasis and Andy Little. These people are
+instrumental in the design and development of Fusion.
+
+Special thanks to Ronald Garcia, the review manager and to all the people in the
+boost community who participated in the review: Andreas Pokorny, Andreas Huber,
+Jeff Flinn, David Abrahams, Pedro Lamarao, Larry Evans, Ryan Gallagher, Andy
+Little, Gennadiy Rozental, Tobias Schwinger, Joao Abecasis, Eric Niebler, Oleg
+Abrosimov, Gary Powell, Eric Friedman, Darren Cook, Martin Bonner and Douglas
+Gregor.
+
+[endsect]
+
diff --git a/doc/adapted.qbk b/doc/adapted.qbk
new file mode 100644
index 0000000..d140861
--- /dev/null
+++ b/doc/adapted.qbk
@@ -0,0 +1,1503 @@
+[/==============================================================================
+ Copyright (C) 2001-2011 Joel de Guzman
+ Copyright (C) 2006 Dan Marsden
+ Copyright (C) 2010 Christopher Schmidt
+
+ 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 Adapted]
+
+Fusion provides a couple of adapters for other sequences such as arrays,
+`std::pair`, __mpl__ sequences, and `boost::array`. These adapters are
+written using Fusion's non-intrusive __extension__ mechanism. If you wish
+to use these sequences with fusion, simply include the necessary files and
+they will be regarded as first-class, fully conforming fusion sequences.
+
+Fusion also provides various schemes to make it easy for the user to adapt
+various data structures, non-intrusively, as full fledged Fusion sequences.
+
+[heading Header]
+
+ #include <boost/fusion/adapted.hpp>
+ #include <boost/fusion/include/adapted.hpp>
+
+[section:array Array]
+
+This module provides adapters for arrays. Including the module
+header makes any array a fully conforming __random_access_sequence__.
+
+[heading Header]
+
+ #include <boost/fusion/adapted/array.hpp>
+ #include <boost/fusion/include/array.hpp>
+
+[heading Model of]
+
+* __random_access_sequence__
+
+[heading Example]
+
+ int arr[3] = {1,2,3};
+
+ std::cout << *__begin__(arr) << std::endl;
+ std::cout << *__next__(__begin__(arr)) << std::endl;
+ std::cout << *__advance_c__<2>(__begin__(arr)) << std::endl;
+ std::cout << *__prior__(__end__(arr)) << std::endl;
+ std::cout << __at_c__<2>(arr) << std::endl;
+
+[endsect]
+
+[section std::pair]
+
+This module provides adapters for `std::pair`. Including the module header
+makes `std::pair` a fully conforming __random_access_sequence__.
+
+[heading Header]
+
+ #include <boost/fusion/adapted/std_pair.hpp>
+ #include <boost/fusion/include/std_pair.hpp>
+
+[heading Model of]
+
+* __random_access_sequence__
+
+[heading Example]
+
+ std::pair<int, std::string> p(123, "Hola!!!");
+ std::cout << __at_c__<0>(p) << std::endl;
+ std::cout << __at_c__<1>(p) << std::endl;
+ std::cout << p << std::endl;
+
+[heading See also]
+
+__std_pair_doc__, __tr1_tuple_pair__
+
+[endsect]
+
+[section std::tuple]
+
+This module provides adapters for `std::tuple`. Including the module header
+makes `std::tuple` a fully conforming __random_access_sequence__.
+
+[important To be fully conforming, compiler should support C++11 Variadic Templates.]
+
+[heading Header]
+
+ #include <boost/fusion/adapted/std_tuple.hpp>
+ #include <boost/fusion/include/std_tuple.hpp>
+
+[heading Model of]
+
+* __random_access_sequence__
+
+[heading Example]
+
+ std::tuple<int, std::string, float> p(123, "Hola!!!", 456.f);
+ std::cout << __at_c__<0>(p) << std::endl;
+ std::cout << __at_c__<1>(p) << std::endl;
+ std::cout << p << std::endl;
+
+[heading See also]
+
+__std_tuple_doc__
+
+[endsect]
+
+[section mpl sequence]
+
+This module provides adapters for __mpl__ sequences. Including the module
+header makes all __mpl__ sequences fully conforming fusion sequences.
+
+[heading Header]
+
+ #include <boost/fusion/adapted/mpl.hpp>
+ #include <boost/fusion/include/mpl.hpp>
+
+[heading Model of]
+
+* __forward_sequence__ (If the __mpl__ sequence is a forward sequence.)
+* __bidirectional_sequence__ (If the __mpl__ sequence is a bidirectional sequence.)
+* __random_access_sequence__ (If the __mpl__ sequence is a random access sequence.)
+
+[heading Example]
+
+ mpl::vector_c<int, 123, 456> vec_c;
+ fusion::vector2<int, long> v(vec_c);
+ std::cout << __at_c__<0>(v) << std::endl;
+ std::cout << __at_c__<1>(v) << std::endl;
+
+ v = mpl::vector_c<int, 456, 789>();
+ std::cout << __at_c__<0>(v) << std::endl;
+ std::cout << __at_c__<1>(v) << std::endl;
+
+[heading Bi-directional adaptation]
+
+Fusion sequences may also be adapted as fully conforming __mpl__ sequences (see
+__intrinsics__). That way, we can have 2-way adaptation to and from __mpl__ and
+Fusion. To make Fusion sequences fully conforming __mpl__ sequences, include:
+
+ #include <boost/fusion/mpl.hpp>
+
+If you want bi-directional adaptation to and from __mpl__ and Fusion, simply
+include:
+
+ #include <boost/fusion/include/mpl.hpp>
+
+The header includes all the necessary headers.
+
+[heading See also]
+
+__mpl__
+
+[endsect]
+
+[section boost::array]
+
+This module provides adapters for `boost::array`. Including the module
+header makes `boost::array` a fully conforming __random_access_sequence__.
+
+[heading Header]
+
+ #include <boost/fusion/adapted/boost_array.hpp>
+ #include <boost/fusion/include/boost_array.hpp>
+
+[heading Model of]
+
+* __random_access_sequence__
+
+[heading Example]
+
+ boost::array<int,3> arr = {{1,2,3}};
+
+ std::cout << *__begin__(arr) << std::endl;
+ std::cout << *__next__(__begin__(arr)) << std::endl;
+ std::cout << *__advance_c__<2>(__begin__(arr)) << std::endl;
+ std::cout << *__prior__(__end__(arr)) << std::endl;
+ std::cout << __at_c__<2>(arr) << std::endl;
+
+[heading See also]
+
+__boost_array_library__
+
+[endsect]
+
+[section boost::tuple]
+This module provides adapters for `boost::tuple`. Including the module
+header makes `boost::tuple` a fully conforming __forward_sequence__.
+
+[heading Header]
+
+ #include <boost/fusion/adapted/boost_tuple.hpp>
+ #include <boost/fusion/include/boost_tuple.hpp>
+
+[heading Model of]
+
+* __forward_sequence__
+
+[heading Example]
+
+ boost::tuple<int,std::string> example_tuple(101, "hello");
+ std::cout << *__begin__(example_tuple) << '\n';
+ std::cout << *__next__(__begin__(example_tuple)) << '\n';
+
+[heading See also]
+
+__boost_tuple_library__
+
+[endsect]
+
+[section:adapt_struct BOOST_FUSION_ADAPT_STRUCT]
+
+[heading Description]
+BOOST_FUSION_ADAPT_STRUCT is a macro that can be used to generate all the
+necessary boilerplate to make an arbitrary struct a model of
+__random_access_sequence__.
+
+[heading Synopsis]
+ BOOST_FUSION_ADAPT_STRUCT(
+ struct_name,
+ member_name0,
+ member_name1,
+ member_name2,
+ ...
+ )
+
+ // Without BOOST_PP_VARIADICS support :
+ BOOST_FUSION_ADAPT_STRUCT(
+ struct_name,
+ (member_type0, member_name0)
+ (member_type1, member_name1)
+ (auto, member_name2)
+ ...
+ )
+
+[heading Semantics]
+
+The above macro generates the necessary code to adapt `struct_name`
+as a model of __random_access_sequence__.
+
+The sequence of `member_nameN,` arguments or `(member_typeN, member_nameN)`
+pairs declares the type and names of each of the struct members that are part of
+the sequence.
+
+When member_typeN is omitted or set to auto, the type is
+infered with Boost.TypeOf.
+
+The macro should be used at global scope, and `struct_name` should be the fully
+namespace qualified name of the struct to be adapted.
+
+[heading Header]
+
+ #include <boost/fusion/adapted/struct/adapt_struct.hpp>
+ #include <boost/fusion/include/adapt_struct.hpp>
+
+[heading Example: BOOST_FUSION_ADAPT_STRUCT ]
+ namespace demo
+ {
+ struct employee
+ {
+ std::string name;
+ int age;
+ };
+ }
+
+ // demo::employee is now a Fusion sequence
+ BOOST_FUSION_ADAPT_STRUCT(
+ demo::employee,
+ name,
+ age)
+
+ // Without BOOST_PP_VARIADICS support :
+ BOOST_FUSION_ADAPT_STRUCT(
+ demo::employee,
+ (auto, name)
+ (auto, age)
+ )
+
+[endsect]
+
+[section:adapt_tpl_struct BOOST_FUSION_ADAPT_TPL_STRUCT]
+
+[heading Description]
+BOOST_FUSION_ADAPT_TPL_STRUCT is a macro that can be used to generate all the
+necessary boilerplate to make an arbitrary template struct a model of
+__random_access_sequence__.
+
+[heading Synopsis]
+ BOOST_FUSION_ADAPT_TPL_STRUCT(
+ (template_param0)(template_param1)...,
+ (struct_name) (specialization_param0)(specialization_param1)...,
+ member_name0,
+ member_name1
+ ...
+ )
+
+ // Without BOOST_PP_VARIADICS support :
+ BOOST_FUSION_ADAPT_TPL_STRUCT(
+ (template_param0)(template_param1)...,
+ (struct_name) (specialization_param0)(specialization_param1)...,
+ (member_type0, member_name0)
+ (member_type1, member_name1)
+ (auto, member_name2),
+ ...
+ )
+
+[heading Semantics]
+
+The above macro generates the necessary code to adapt `struct_name` or an
+arbitrary specialization of `struct_name` as a model of
+__random_access_sequence__.
+The sequence `(template_param0)(template_param1)...` declares the names of
+the template type parameters used.
+The sequence `(specialization_param0)(specialization_param1)...`
+declares the template parameters of the actual specialization of `struct_name`
+that is adapted as a fusion sequence.
+The sequence of `member_nameN,` arguments or `(member_typeN, member_nameN)`
+pairs declares the type and names of each of the struct members that are part of
+the sequence.
+
+When member_typeN is omitted or set to auto, the type is
+infered with Boost.TypeOf.
+
+The macro should be used at global scope, and `struct_name` should be the fully
+namespace qualified name of the struct to be adapted.
+
+[heading Header]
+
+ #include <boost/fusion/adapted/struct/adapt_struct.hpp>
+ #include <boost/fusion/include/adapt_struct.hpp>
+
+[heading Example]
+ namespace demo
+ {
+ template<typename Name, typename Age>
+ struct employee
+ {
+ Name name;
+ Age age;
+ int employment_timestamp;
+ };
+ }
+
+ // Any instantiated demo::employee is now a Fusion sequence
+ BOOST_FUSION_ADAPT_TPL_STRUCT(
+ (Name)(Age),
+ (demo::employee) (Name)(Age),
+ (Name, name)
+ (Age, age)
+ (auto, employment_timestamp))
+
+ // Or by infering type completely
+ BOOST_FUSION_ADAPT_TPL_STRUCT(
+ (Name)(Age),
+ (demo::employee) (Name)(Age),
+ name,
+ age,
+ employment_timestamp)
+
+[endsect]
+
+[section:adapt_struct_named BOOST_FUSION_ADAPT_STRUCT_NAMED]
+
+[heading Description]
+BOOST_FUSION_ADAPT_STRUCT_NAMED and BOOST_FUSION_ADAPT_STRUCT_NAMED_NS are
+macros that can be used to generate all the necessary boilerplate to make an
+arbitrary struct a model of __random_access_sequence__. The given struct is
+adapted using the given name.
+
+[heading Synopsis]
+ BOOST_FUSION_ADAPT_STRUCT_NAMED(
+ struct_name, adapted_name,
+ member_name0,
+ member_name1,
+ member_name2,
+ ...
+ )
+
+ BOOST_FUSION_ADAPT_STRUCT_NAMED_NS(
+ struct_name,
+ (namespace0)(namespace1)...,
+ adapted_name,
+ member_name0,
+ member_name1,
+ member_name2,
+ ...
+ )
+
+ // Without BOOST_PP_VARIADICS support :
+
+ BOOST_FUSION_ADAPT_STRUCT_NAMED(
+ struct_name, adapted_name,
+ (member_type0, member_name0)
+ (member_type1, member_name1)
+ (auto, member_name2),
+ ...
+ )
+
+ BOOST_FUSION_ADAPT_STRUCT_NAMED_NS(
+ struct_name,
+ (namespace0)(namespace1)...,
+ adapted_name,
+ (member_type0, member_name0)
+ (member_type1, member_name1)
+ (auto, member_name2),
+ ...
+ )
+
+
+
+[heading Semantics]
+
+The above macros generate the necessary code to adapt `struct_name`
+as a model of __random_access_sequence__ while using `adapted_name` as the
+name of the adapted struct.
+The sequence `(namespace0)(namespace1)...` declares the namespace
+for `adapted_name`. It yields to a fully qualified name for `adapted_name` of
+`namespace0::namespace1::... adapted_name`.
+If an empty namespace sequence is given (that is a macro that expands to
+nothing), the adapted view is placed in the global namespace.
+If no namespace sequence is given (i.e. `BOOST_FUSION_ADAPT_STRUCT_NAMED`), the
+adapted view is placed in the namespace `boost::fusion::adapted`.
+The sequence of `member_nameN,` arguments or `(member_typeN, member_nameN)`
+pairs declares the type and names of each of the struct members that are part of
+the sequence.
+
+When member_typeN is omitted or set to auto, the type is
+infered with Boost.TypeOf.
+
+The macros should be used at global scope, and `struct_name` should be the fully
+namespace qualified name of the struct to be converted.
+
+[heading Header]
+
+ #include <boost/fusion/adapted/struct/adapt_struct_named.hpp>
+ #include <boost/fusion/include/adapt_struct_named.hpp>
+
+[heading Example]
+ namespace demo
+ {
+ struct employee
+ {
+ std::string name;
+ int age;
+ };
+ }
+
+ // boost::fusion::adapted::adapted_employee is now a Fusion sequence
+ // referring to demo::employee
+ BOOST_FUSION_ADAPT_STRUCT_NAMED(
+ demo::employee, adapted_employee,
+ name,
+ age)
+
+ // Without BOOST_PP_VARIADICS support :
+ BOOST_FUSION_ADAPT_STRUCT_NAMED(
+ demo::employee, adapted_employee,
+ (auto, name),
+ (auto, age))
+
+[endsect]
+
+[section:adapt_assoc BOOST_FUSION_ADAPT_ASSOC_STRUCT]
+
+[heading Description]
+BOOST_FUSION_ADAPT_ASSOC_STRUCT is a macro that can be used to generate all the
+necessary boilerplate to make an arbitrary struct a model of
+__random_access_sequence__ and __associative_sequence__.
+
+[heading Synopsis]
+ BOOST_FUSION_ADAPT_ASSOC_STRUCT(
+ struct_name,
+ ([member_type0,] member_name0, key_type0)
+ ([member_type1,] member_name1, key_type1)
+ ...
+ )
+
+[heading Semantics]
+
+The above macro generates the necessary code to adapt `struct_name`
+as a model of __random_access_sequence__ and __associative_sequence__.
+The sequence of `([member_typeN,] member_nameN, key_typeN)` tuples
+declares the type, name and key type of each of the struct members
+that are part of the sequence.
+
+When member_typeN is omitted or set to auto, the type is
+infered with Boost.TypeOf.
+
+The macro should be used at global scope, and `struct_name` should be the fully
+namespace qualified name of the struct to be adapted.
+
+[heading Header]
+
+ #include <boost/fusion/adapted/struct/adapt_assoc_struct.hpp>
+ #include <boost/fusion/include/adapt_assoc_struct.hpp>
+
+[heading Example]
+ namespace demo
+ {
+ struct employee
+ {
+ std::string name;
+ int age;
+ };
+ }
+
+ namespace keys
+ {
+ struct name;
+ struct age;
+ }
+
+ // demo::employee is now a Fusion sequence.
+ // It is also an associative sequence with
+ // keys keys::name and keys::age present.
+ BOOST_FUSION_ADAPT_ASSOC_STRUCT(
+ demo::employee,
+ (name, keys::name)
+ (age, keys::age))
+
+ // Without BOOST_PP_VARIADICS support :
+ BOOST_FUSION_ADAPT_ASSOC_STRUCT(
+ demo::employee,
+ (auto, name, keys::name),
+ (auto, age, keys::name))
+
+[endsect]
+
+[section:adapt_assoc_tpl_struct BOOST_FUSION_ADAPT_ASSOC_TPL_STRUCT]
+
+[heading Description]
+BOOST_FUSION_ADAPT_ASSOC_TPL_STRUCT is a macro that can be used to generate all the
+necessary boilerplate to make an arbitrary template struct a model of
+__random_access_sequence__ and __associative_sequence__.
+
+[heading Synopsis]
+ BOOST_FUSION_ADAPT_ASSOC_TPL_STRUCT(
+ (template_param0)(template_param1)...,
+ (struct_name) (specialization_param0)(specialization_param1)...,
+ ([member_type0,] member_name0, key_type0)
+ ([member_type1,] member_name1, key_type1)
+ ...
+ )
+
+[heading Semantics]
+
+The above macro generates the necessary code to adapt `struct_name` or an
+arbitrary specialization of `struct_name` as a model of
+__random_access_sequence__ and __associative_sequence__.
+The sequence `(template_param0)(template_param1)...` declares the names of
+the template type parameters used.
+The sequence `(specialization_param0)(specialization_param1)...`
+declares the template parameters of the actual specialization of `struct_name`
+that is adapted as a fusion sequence.
+The sequence of `([member_typeN,] member_nameN, key_typeN)`
+tuples declares the type, name and key type of each of the struct members
+that are part of the sequence.
+
+When member_typeN is omitted or set to auto, the type is
+infered with Boost.TypeOf.
+
+The macro should be used at global scope, and `struct_name` should be the fully
+namespace qualified name of the struct to be adapted.
+
+[heading Header]
+
+ #include <boost/fusion/adapted/struct/adapt_assoc_struct.hpp>
+ #include <boost/fusion/include/adapt_assoc_struct.hpp>
+
+[heading Example]
+ namespace demo
+ {
+ template<typename Name, typename Age>
+ struct employee
+ {
+ Name name;
+ Age age;
+ };
+ }
+
+ namespace keys
+ {
+ struct name;
+ struct age;
+ }
+
+ // Any instantiated demo::employee is now a Fusion sequence.
+ // It is also an associative sequence with
+ // keys keys::name and keys::age present.
+ BOOST_FUSION_ADAPT_ASSOC_TPL_STRUCT(
+ (Name)(Age),
+ (demo::employee) (Name)(Age),
+ (name, keys::name)
+ (age, keys::age))
+
+ // Without BOOST_PP_VARIADICS support :
+ BOOST_FUSION_ADAPT_ASSOC_TPL_STRUCT(
+ (Name)(Age),
+ (demo::employee) (Name)(Age),
+ (Name, name, keys::name)
+ (Age, age, keys::age))
+
+[endsect]
+
+[section:adapt_assoc_struct_named BOOST_FUSION_ADAPT_ASSOC_STRUCT_NAMED]
+
+[heading Description]
+BOOST_FUSION_ADAPT_ASSOC_STRUCT_NAMED and BOOST_FUSION_ADAPT_ASSOC_STRUCT_NAMED_NS are
+macros that can be used to generate all the necessary boilerplate to make an
+arbitrary struct a model of __random_access_sequence__ and
+__associative_sequence__. The given struct is adapted using the given name.
+
+[heading Synopsis]
+ BOOST_FUSION_ADAPT_ASSOC_STRUCT_NAMED(
+ struct_name, adapted_name,
+ ([member_type0,] member_name0, key_type0)
+ ([member_type1,] member_name1, key_type1)
+ ...
+ )
+
+ BOOST_FUSION_ADAPT_ASSOC_STRUCT_NAMED_NS(
+ struct_name,
+ (namespace0)(namespace1)...,
+ adapted_name,
+ ([member_type0,] member_name0, key_type0)
+ ([member_type1,] member_name1, key_type1)
+ ...
+ )
+
+[heading Semantics]
+
+The above macros generate the necessary code to adapt `struct_name`
+as a model of __random_access_sequence__ and __associative_sequence__ while
+using `adapted_name` as the name of the adapted struct.
+The sequence `(namespace0)(namespace1)...` declares the namespace
+for `adapted_name`. It yields to a fully qualified name for `adapted_name` of
+`namespace0::namespace1::... adapted_name`.
+If an empty namespace sequence is given (that is a macro that expands to
+nothing), the adapted view is placed in the global namespace.
+If no namespace sequence is given (i.e. `BOOST_FUSION_ADAPT_STRUCT_ASSOC_NAMED`), the
+adapted view is placed in the namespace `boost::fusion::adapted`.
+The sequence of `(member_typeN, member_nameN, key_typeN)`
+triples declares the type, name and key type of each of the struct members
+that are part of the sequence.
+
+When member_typeN is omitted or set to auto, the type is
+infered with Boost.TypeOf.
+
+The macros should be used at global scope, and `struct_name` should be the fully
+namespace qualified name of the struct to be converted.
+
+[heading Header]
+
+ #include <boost/fusion/adapted/struct/adapt_assoc_struct_named.hpp>
+ #include <boost/fusion/include/adapt_assoc_struct_named.hpp>
+
+[heading Example]
+ namespace demo
+ {
+ struct employee
+ {
+ std::string name;
+ int age;
+ };
+ }
+
+ namespace keys
+ {
+ struct name;
+ struct age;
+ }
+
+ // boost::fusion::adapted::adapted_employee is now a Fusion sequence
+ // referring to demo::employee
+ BOOST_FUSION_ADAPT_ASSOC_STRUCT_NAMED(
+ demo::employee, adapted_employee,
+ (name, keys::name)
+ (age, keys::age))
+
+ // Without BOOST_PP_VARIADICS support :
+ BOOST_FUSION_ADAPT_ASSOC_STRUCT_NAMED(
+ demo::employee, adapted_employee,
+ (auto, name, keys::name)
+ (auto, age, keys::age))
+
+[endsect]
+
+[section:adapt_adt BOOST_FUSION_ADAPT_ADT]
+
+BOOST_FUSION_ADAPT_ADT is a macro than can be used to generate all the
+necessary boilerplate to adapt an arbitrary class type as a model of
+__random_access_sequence__.
+
+[heading Synopsis]
+
+ BOOST_FUSION_ADAPT_ADT(
+ type_name,
+ ([attribute_type0, attribute_const_type0,] get_expr0, set_expr0)
+ ([attribute_type1, attribute_const_type1,] get_expr1, set_expr1)
+ ...
+ )
+
+[heading Expression Semantics]
+
+The above macro generates the necessary code to adapt `type_name`
+as a model of __random_access_sequence__.
+The sequence of
+[^([attribute_type['N], attribute_const_type['N],] get_expr['N], set_expr['N])]
+quadruples declares the types, const types, get-expressions and set-expressions
+of the elements that are part of the adapted fusion sequence.
+[^get_expr['N]] is the expression that is invoked to get the ['N]th element
+of an instance of `type_name`. This expression may access a variable named
+`obj` of type `type_name&` or `type_name const&` which represents the underlying
+instance of `type_name`.
+[^attribute_type['N]] and [^attribute_const_type['N]] may specify the types
+that [^get_expr['N]] denotes to, when omitted the type is deduced from
+[get_expr['N]] return type via BOOST_TYPEOF. On compiler missing support for
+variadic macros auto can be used to avoid repeating the type.
+[^set_expr['N]] is the expression that is invoked to set the ['N]th element
+of an instance of `type_name`. This expression may access 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 the right operand of the assignment
+expression.
+
+The actual return type of fusion's intrinsic sequence access (meta-)functions
+when in invoked with (an instance of) `type_name` is a proxy type.
+This type is implicitly convertible to the attribute type via [^get_expr['N]] and
+forwards assignment to the underlying element via [^set_expr['N]].
+The value type (that is the type returned by __result_of_value_of__,
+__result_of_value_at__ and __result_of_value_at_c__) of the ['N]th element
+is [^attribute_type['N]] with const-qualifier and reference removed.
+
+The macro should be used at global scope, and `type_name` should be the fully
+namespace qualified name of the class type to be adapted.
+
+[heading Header]
+
+ #include <boost/fusion/adapted/adt/adapt_adt.hpp>
+ #include <boost/fusion/include/adapt_adt.hpp>
+
+[heading Example]
+ namespace demo
+ {
+ struct employee
+ {
+ private:
+ std::string name;
+ int age;
+
+ public:
+ void set_name(std::string const& n)
+ {
+ name=n;
+ }
+
+ void set_age(int a)
+ {
+ age=a;
+ }
+
+ std::string const& get_name()const
+ {
+ return name;
+ }
+
+ int get_age()const
+ {
+ return age;
+ }
+ };
+ }
+
+ BOOST_FUSION_ADAPT_ADT(
+ demo::employee,
+ (obj.get_name(), obj.set_name(val))
+ (obj.get_age(), obj.set_age(val)))
+
+ demo::employee e;
+ front(e)="Edward Norton";
+ back(e)=41;
+ //Prints 'Edward Norton is 41 years old'
+ std::cout << e.get_name() << " is " << e.get_age() << " years old" << std::endl;
+
+[heading See also]
+
+__adt_attribute_proxy__
+
+[endsect]
+
+[section:adapt_tpl_adt BOOST_FUSION_ADAPT_TPL_ADT]
+
+BOOST_FUSION_ADAPT_TPL_ADT is a macro than can be used to generate all the
+necessary boilerplate to adapt an arbitrary template class type as a model of
+__random_access_sequence__.
+
+[heading Synopsis]
+
+ BOOST_FUSION_ADAPT_TPL_ADT(
+ (template_param0)(template_param1)...,
+ (type_name) (specialization_param0)(specialization_param1)...,
+ ([attribute_type0, attribute_const_type0,] get_expr0, set_expr0)
+ ([attribute_type1, attribute_const_type1,] get_expr1, set_expr1)
+ ...
+ )
+
+[heading Expression Semantics]
+
+The above macro generates the necessary code to adapt `type_name`
+or an arbitrary specialization of `type_name`
+as a model of __random_access_sequence__.
+The sequence `(template_param0)(template_param1)...` declares the names of
+the template type parameters used.
+The sequence `(specialization_param0)(specialization_param1)...`
+declares the template parameters of the actual specialization of `type_name`
+that is adapted as a fusion sequence.
+The sequence of
+[^(attribute_type['N], attribute_const_type['N], get_expr['N], set_expr['N])]
+quadruples declares the types, const types, get-expressions and set-expressions
+of the elements that are part of the adapted fusion sequence.
+[^get_expr['N]] is the expression that is invoked to get the ['N]th element
+of an instance of `type_name`. This expression may access a variable named
+`obj` of type `type_name&` or `type_name const&` which represents the underlying
+instance of `type_name`.
+[^attribute_type['N]] and [^attribute_const_type['N]] may specify the types
+that [^get_expr['N]] denotes to, when omitted the type is deduced from
+[get_expr['N]] return type via BOOST_TYPEOF. On compiler missing support for
+variadic macros auto can be used to avoid repeating the type.
+[^set_expr['N]] is the expression that is invoked to set the ['N]th element
+of an instance of `type_name`. This expression may access 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 the right operand of the assignment
+expression.
+
+The actual return type of fusion's intrinsic sequence access (meta-)functions
+when in invoked with (an instance of) `type_name` is a proxy type.
+This type is implicitly convertible to the attribute type via [^get_expr['N]] and
+forwards assignment to the underlying element via [^set_expr['N]].
+The value type (that is the type returned by __result_of_value_of__,
+__result_of_value_at__ and __result_of_value_at_c__) of the ['N]th element
+is [^attribute_type['N]] with const-qualifier and reference removed.
+
+The macro should be used at global scope, and `type_name` should be the fully
+namespace qualified name of the template class type to be adapted.
+
+[heading Header]
+
+ #include <boost/fusion/adapted/adt/adapt_adt.hpp>
+ #include <boost/fusion/include/adapt_adt.hpp>
+
+[heading Example]
+ namespace demo
+ {
+ template<typename Name, typename Age>
+ struct employee
+ {
+ private:
+ Name name;
+ Age age;
+
+ public:
+ void set_name(Name const& n)
+ {
+ name=n;
+ }
+
+ void set_age(Age const& a)
+ {
+ age=a;
+ }
+
+ Name const& get_name()const
+ {
+ return name;
+ }
+
+ Age const& get_age()const
+ {
+ return age;
+ }
+ };
+ }
+
+ BOOST_FUSION_ADAPT_TPL_ADT(
+ (Name)(Age),
+ (demo::employee) (Name)(Age),
+ (Name const&, Name const&, obj.get_name(), obj.set_name(val))
+ (Age const&, Age const&, obj.get_age(), obj.set_age(val)))
+
+ demo::employee<std::string, int> e;
+ boost::fusion::front(e)="Edward Norton";
+ boost::fusion::back(e)=41;
+ //Prints 'Edward Norton is 41 years old'
+ std::cout << e.get_name() << " is " << e.get_age() << " years old" << std::endl;
+
+[heading See also]
+
+__adt_attribute_proxy__
+
+[endsect]
+
+[section:adapt_assoc_adt BOOST_FUSION_ADAPT_ASSOC_ADT]
+
+BOOST_FUSION_ADAPT_ASSOC_ADT is a macro than can be used to generate all the
+necessary boilerplate to adapt an arbitrary class type as a model of
+__random_access_sequence__ and __associative_sequence__.
+
+[heading Synopsis]
+
+ BOOST_FUSION_ADAPT_ASSOC_ADT(
+ type_name,
+ ([attribute_type0, attribute_const_type0,] get_expr0, set_expr0, key_type0)
+ ([attribute_type1, attribute_const_type1,] get_expr1, set_expr1, key_type1)
+ ...
+ )
+
+[heading Expression Semantics]
+
+The above macro generates the necessary code to adapt `type_name`
+as a model of __random_access_sequence__ and __associative_sequence__.
+The sequence of
+[^(attribute_type['N], attribute_const_type['N], get_expr['N], set_expr['N], key_type['N])]
+5-tuples declares the types, const types, get-expressions, set-expressions and key types
+of the elements that are part of the adapted fusion sequence.
+[^get_expr['N]] is the expression that is invoked to get the ['N]th element
+of an instance of `type_name`. This expression may access a variable named
+`obj` of type `type_name&` or `type_name const&` which represents the underlying
+instance of `type_name`.
+[^attribute_type['N]] and [^attribute_const_type['N]] may specify the types
+that [^get_expr['N]] denotes to, when omitted the type is deduced from
+[get_expr['N]] return type via BOOST_TYPEOF. On compiler missing support for
+variadic macros auto can be used to avoid repeating the type.
+[^set_expr['N]] is the expression that is invoked to set the ['N]th element
+of an instance of `type_name`. This expression may access 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 the right operand of the assignment
+expression.
+
+The actual return type of fusion's intrinsic sequence access (meta-)functions
+when in invoked with (an instance of) `type_name` is a proxy type.
+This type is implicitly convertible to the attribute type via [^get_expr['N]] and
+forwards assignment to the underlying element via [^set_expr['N]].
+The value type (that is the type returned by __result_of_value_of__, __result_of_value_of_data__,
+__result_of_value_at__, __result_of_value_at_c__ and __result_of_value_at_key__) of the ['N]th element
+is [^attribute_type['N]] with const-qualifier and reference removed.
+
+The macro should be used at global scope, and `type_name` should be the fully
+namespace qualified name of the class type to be adapted.
+
+[heading Header]
+
+ #include <boost/fusion/adapted/adt/adapt_assoc_adt.hpp>
+ #include <boost/fusion/include/adapt_assoc_adt.hpp>
+
+[heading Example]
+ namespace demo
+ {
+ struct employee
+ {
+ private:
+ std::string name;
+ int age;
+
+ public:
+ void set_name(std::string const& n)
+ {
+ name=n;
+ }
+
+ void set_age(int a)
+ {
+ age=a;
+ }
+
+ std::string const& get_name()const
+ {
+ return name;
+ }
+
+ int get_age()const
+ {
+ return age;
+ }
+ };
+ }
+
+ namespace keys
+ {
+ struct name;
+ struct age;
+ }
+
+ BOOST_FUSION_ADAPT_ASSOC_ADT(
+ demo::employee,
+ (obj.get_name(), obj.set_name(val), keys::name)
+ (obj.get_age(), obj.set_age(val), keys::age))
+
+ demo::employee e;
+ at_key<keys::name>(e)="Edward Norton";
+ at_key<keys::age>(e)=41;
+ //Prints 'Edward Norton is 41 years old'
+ std::cout << e.get_name() << " is " << e.get_age() << " years old" << std::endl;
+
+[heading See also]
+
+__adt_attribute_proxy__
+
+[endsect]
+
+[section:adapt_assoc_tpl_adt BOOST_FUSION_ADAPT_ASSOC_TPL_ADT]
+
+BOOST_FUSION_ADAPT_ASSOC_TPL_ADT is a macro than can be used to generate all the
+necessary boilerplate to adapt an arbitrary template class type as a model of
+__random_access_sequence__ and __associative_sequence__.
+
+[heading Synopsis]
+
+ BOOST_FUSION_ADAPT_ASSOC_TPL_ADT(
+ (template_param0)(template_param1)...,
+ (type_name) (specialization_param0)(specialization_param1)...,
+ ([attribute_type0, attribute_const_type0,] get_expr0, set_expr0, key_type0)
+ ([attribute_type1, attribute_const_type1,] get_expr1, set_expr1, key_type1)
+ ...
+ )
+
+[heading Expression Semantics]
+
+The above macro generates the necessary code to adapt `type_name`
+or an arbitrary specialization of `type_name`
+as a model of __random_access_sequence__ and __associative_sequence__.
+The sequence `(template_param0)(template_param1)...` declares the names of
+the template type parameters used.
+The sequence `(specialization_param0)(specialization_param1)...`
+declares the template parameters of the actual specialization of `type_name`
+that is adapted as a fusion sequence.
+The sequence of
+[^([attribute_type['N], attribute_const_type['N],] get_expr['N], set_expr['N], key_type['N])]
+5-tuples declares the types, const types, get-expressions, set-expressions and key types
+of the elements that are part of the adapted fusion sequence.
+[^get_expr['N]] is the expression that is invoked to get the ['N]th element
+of an instance of `type_name`. This expression may access a variable named
+`obj` of type `type_name&` or `type_name const&` which represents the underlying
+instance of `type_name`.
+[^attribute_type['N]] and [^attribute_const_type['N]] may specify the types
+that [^get_expr['N]] denotes to, when omitted the type is deduced from
+[get_expr['N]] return type via BOOST_TYPEOF. On compiler missing support for
+variadic macros auto can be used to avoid repeating the type.
+[^set_expr['N]] is the expression that is invoked to set the ['N]th element
+of an instance of `type_name`. This expression may access 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 the right operand of the assignment
+expression.
+
+The actual return type of fusion's intrinsic sequence access (meta-)functions
+when in invoked with (an instance of) `type_name` is a proxy type.
+This type is implicitly convertible to the attribute type via [^get_expr['N]] and
+forwards assignment to the underlying element via [^set_expr['N]].
+The value type (that is the type returned by __result_of_value_of__, __result_of_value_of_data__,
+__result_of_value_at__, __result_of_value_at_c__ and __result_of_value_at_key__) of the ['N]th element
+is [^attribute_type['N]] with const-qualifier and reference removed.
+
+The macro should be used at global scope, and `type_name` should be the fully
+namespace qualified name of the template class type to be adapted.
+
+[heading Header]
+
+ #include <boost/fusion/adapted/adt/adapt_assoc_adt.hpp>
+ #include <boost/fusion/include/adapt_assoc_adt.hpp>
+
+[heading Example]
+ namespace demo
+ {
+ template<typename Name, typename Age>
+ struct employee
+ {
+ private:
+ Name name;
+ Age age;
+
+ public:
+ void set_name(Name const& n)
+ {
+ name=n;
+ }
+
+ void set_age(Age const& a)
+ {
+ age=a;
+ }
+
+ Name const& get_name()const
+ {
+ return name;
+ }
+
+ Age const& get_age()const
+ {
+ return age;
+ }
+ };
+ }
+
+ namespace keys
+ {
+ struct name;
+ struct age;
+ }
+
+ BOOST_FUSION_ADAPT_ASSOC_TPL_ADT(
+ (Name)(Age),
+ (demo::employee) (Name)(Age),
+ (Name const&, Name const&, obj.get_name(), obj.set_name(val), keys::name)
+ (Age const&, Age const&, obj.get_age(), obj.set_age(val), keys::age))
+
+ demo::employee<std::string, int> e;
+ at_key<keys::name>(e)="Edward Norton";
+ at_key<keys::age>(e)=41;
+ //Prints 'Edward Norton is 41 years old'
+ std::cout << e.get_name() << " is " << e.get_age() << " years old" << std::endl;
+
+[heading See also]
+
+__adt_attribute_proxy__
+
+[endsect]
+
+[section:define_struct BOOST_FUSION_DEFINE_STRUCT]
+
+BOOST_FUSION_DEFINE_STRUCT is a macro that can be used to generate all the
+necessary boilerplate to define and adapt an arbitrary struct as a model of
+__random_access_sequence__.
+
+[heading Synopsis]
+
+ BOOST_FUSION_DEFINE_STRUCT(
+ (namespace0)(namespace1)...,
+ struct_name,
+ (member_type0, member_name0)
+ (member_type1, member_name1)
+ ...
+ )
+
+[variablelist Notation
+ [[`str`] [An instance of `struct_name`]]
+ [[`e0`...`en`] [Heterogeneous values]]
+ [[`fs`] [A __forward_sequence__]]
+]
+
+[heading Expression Semantics]
+
+The above macro generates the necessary code that defines and adapts `struct_name`
+as a model of __random_access_sequence__.
+The sequence `(namespace0)(namespace1)...` declares the namespace
+for `struct_name`. It yields to a fully qualified name for `struct_name` of
+`namespace0::namespace1::... struct_name`.
+If an empty namespace sequence is given (that is a macro that expands to
+nothing), the struct is placed in the global namespace.
+The sequence of `(member_typeN, member_nameN)`
+pairs declares the type and names of each of the struct members that are
+part of the sequence.
+
+The macro should be used at global scope.
+Semantics of an expression is defined only where it differs from, or is not
+defined in __random_access_sequence__.
+
+[table
+ [[Expression] [Semantics]]
+ [[`struct_name()`] [Creates an instance of `struct_name` with default constructed elements.]]
+ [[`struct_name(e0, e1,... en)`] [Creates an instance of `struct_name` with elements `e0`...`en`.]]
+ [[`struct_name(fs)`] [Copy constructs an instance of `struct_name` from a __forward_sequence__ `fs`.]]
+ [[`str = fs`] [Assigns from a __forward_sequence__ `fs`.]]
+ [[`str.member_nameN`] [Access of struct member `member_nameN`]]
+]
+
+[heading Header]
+
+ #include <boost/fusion/adapted/struct/define_struct.hpp>
+ #include <boost/fusion/include/define_struct.hpp>
+
+[heading Example]
+
+ // demo::employee is a Fusion sequence
+ BOOST_FUSION_DEFINE_STRUCT(
+ (demo), employee,
+ (std::string, name)
+ (int, age))
+
+[endsect]
+
+[section:define_tpl_struct BOOST_FUSION_DEFINE_TPL_STRUCT]
+
+[heading Description]
+
+BOOST_FUSION_DEFINE_TPL_STRUCT is a macro that can be used to generate all the
+necessary boilerplate to define and adapt an arbitrary template struct as a
+model of __random_access_sequence__.
+
+[heading Synopsis]
+
+ BOOST_FUSION_DEFINE_TPL_STRUCT(
+ (template_param0)(template_param1)...,
+ (namespace0)(namespace1)...,
+ struct_name,
+ (member_type0, member_name0)
+ (member_type1, member_name1)
+ ...
+ )
+
+[variablelist Notation
+ [[`Str`] [An instantiated `struct_name`]]
+ [[`str`] [An instance of `Str`]]
+ [[`e0`...`en`] [Heterogeneous values]]
+ [[`fs`] [A __forward_sequence__]]
+]
+
+[heading Expression Semantics]
+
+The above macro generates the necessary code that defines and adapts `struct_name`
+as a model of __random_access_sequence__.
+The sequence `(template_param0)(template_param1)...` declares the names of
+the template type parameters used.
+The sequence `(namespace0)(namespace1)...` declares the namespace
+for `struct_name`. It yields to a fully qualified name for `struct_name` of
+`namespace0::namespace1::... struct_name`.
+If an empty namespace sequence is given (that is a macro that expands to
+nothing), the struct is placed in the global namespace.
+The sequence of `(member_typeN, member_nameN)`
+pairs declares the type and names of each of the struct members that are
+part of the sequence.
+
+The macro should be used at global scope.
+Semantics of an expression is defined only where it differs from, or is not
+defined in __random_access_sequence__.
+
+[table
+ [[Expression] [Semantics]]
+ [[`Str()`] [Creates an instance of `Str` with default constructed elements.]]
+ [[`Str(e0, e1,... en)`] [Creates an instance of `Str` with elements `e0`...`en`.]]
+ [[`Str(fs)`] [Copy constructs an instance of `Str` from a __forward_sequence__ `fs`.]]
+ [[`str = fs`] [Assigns from a __forward_sequence__ `fs`.]]
+ [[`str.member_nameN`] [Access of struct member `member_nameN`]]
+]
+
+[heading Header]
+
+ #include <boost/fusion/adapted/struct/define_struct.hpp>
+ #include <boost/fusion/include/define_struct.hpp>
+
+[heading Example]
+
+ // Any instantiated demo::employee is a Fusion sequence
+ BOOST_FUSION_DEFINE_TPL_STRUCT(
+ (Name)(Age), (demo), employee,
+ (Name, name)
+ (Age, age))
+
+[endsect]
+
+[section:define_struct_inline BOOST_FUSION_DEFINE_STRUCT_INLINE]
+
+[heading Description]
+
+BOOST_FUSION_DEFINE_STRUCT_INLINE is a macro that can be used to generate all
+the necessary boilerplate to define and adapt an arbitrary struct as a model of
+__random_access_sequence__. Unlike BOOST_FUSION_DEFINE_STRUCT, it can be used
+at class or namespace scope.
+
+[heading Synopsis]
+
+ BOOST_FUSION_DEFINE_STRUCT_INLINE(
+ struct_name,
+ (member_type0, member_name0)
+ (member_type1, member_name1)
+ ...
+ )
+
+[heading Expression Semantics]
+
+The semantics of BOOST_FUSION_DEFINE_STRUCT_INLINE are identical to those of
+BOOST_FUSION_DEFINE_STRUCT, with two differences:
+
+# BOOST_FUSION_DEFINE_STRUCT_INLINE can be used at class or namespace scope, and
+ thus does not take a namespace list parameter.
+# The structure generated by BOOST_FUSION_DEFINE_STRUCT_INLINE has a base class,
+ and is thus not POD in C++03.
+
+[heading Header]
+
+ #include <boost/fusion/adapted/struct/define_struct_inline.hpp>
+ #include <boost/fusion/include/define_struct_inline.hpp>
+
+[heading Example]
+
+ // enclosing::employee is a Fusion sequence
+ class enclosing
+ {
+ BOOST_FUSION_DEFINE_STRUCT_INLINE(
+ employee,
+ (std::string, name)
+ (int, age))
+ };
+
+
+[endsect]
+
+[section:define_tpl_struct_inline BOOST_FUSION_DEFINE_TPL_STRUCT_INLINE]
+
+[heading Description]
+
+BOOST_FUSION_DEFINE_TPL_STRUCT_INLINE is a macro that can be used to generate
+all the necessary boilerplate to define and adapt an arbitrary template struct
+as a model of __random_access_sequence__. Unlike BOOST_FUSION_DEFINE_TPL_STRUCT,
+it can be used at class or namespace scope.
+
+[heading Synopsis]
+
+ BOOST_FUSION_DEFINE_TPL_STRUCT_INLINE(
+ (template_param0)(template_param1)...,
+ struct_name,
+ (member_type0, member_name0)
+ (member_type1, member_name1)
+ ...
+ )
+
+[heading Expression Semantics]
+
+The semantics of BOOST_FUSION_DEFINE_TPL_STRUCT_INLINE are identical to those of
+BOOST_FUSION_DEFINE_TPL_STRUCT, with two differences:
+
+# BOOST_FUSION_DEFINE_TPL_STRUCT_INLINE can be used at class or namespace scope,
+ and thus does not take a namespace list parameter.
+# The structure generated by BOOST_FUSION_DEFINE_TPL_STRUCT_INLINE has a base
+ class, and is thus not POD in C++03.
+
+[heading Header]
+
+ #include <boost/fusion/adapted/struct/define_struct_inline.hpp>
+ #include <boost/fusion/include/define_struct_inline.hpp>
+
+[heading Example]
+
+ // Any instantiated enclosing::employee is a Fusion sequence
+ class enclosing
+ {
+ BOOST_FUSION_DEFINE_TPL_STRUCT(
+ (Name)(Age), employee,
+ (Name, name)
+ (Age, age))
+ };
+
+[endsect]
+
+[section:define_assoc_struct BOOST_FUSION_DEFINE_ASSOC_STRUCT]
+
+[heading Description]
+
+BOOST_FUSION_DEFINE_ASSOC_STRUCT is a macro that can be used to generate all the
+necessary boilerplate to define and adapt an arbitrary struct as a model of
+__random_access_sequence__ and __associative_sequence__.
+
+[heading Synopsis]
+
+ BOOST_FUSION_DEFINE_ASSOC_STRUCT(
+ (namespace0)(namespace1)...,
+ struct_name,
+ (member_type0, member_name0, key_type0)
+ (member_type1, member_name1, key_type1)
+ ...
+ )
+
+[variablelist Notation
+ [[`str`] [An instance of `struct_name`]]
+ [[`e0`...`en`] [Heterogeneous values]]
+ [[`fs`] [A __forward_sequence__]]
+]
+
+[heading Expression Semantics]
+
+The above macro generates the necessary code that defines and adapts `struct_name`
+as a model of __random_access_sequence__ and __associative_sequence__.
+The sequence `(namespace0)(namespace1)...` declares the namespace
+for `struct_name`. It yields to a fully qualified name for `struct_name` of
+`namespace0::namespace1::... struct_name`.
+If an empty namespace sequence is given (that is a macro that expands to
+nothing), the struct is placed in the global namespace.
+The sequence of `(member_typeN, member_nameN, key_typeN)`
+triples declares the type, name and key type of each of the struct members
+that are part of the sequence.
+
+The macro should be used at global scope.
+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]]
+ [[`struct_name()`] [Creates an instance of `struct_name` with default constructed elements.]]
+ [[`struct_name(e0, e1,... en)`] [Creates an instance of `struct_name` with elements `e0`...`en`.]]
+ [[`struct_name(fs)`] [Copy constructs an instance of `struct_name` from a __forward_sequence__ `fs`.]]
+ [[`str = fs`] [Assigns from a __forward_sequence__ `fs`.]]
+ [[`str.member_nameN`] [Access of struct member `member_nameN`]]
+]
+
+[heading Header]
+
+ #include <boost/fusion/adapted/struct/define_assoc_struct.hpp>
+ #include <boost/fusion/include/define_assoc_struct.hpp>
+
+[heading Example]
+
+ namespace keys
+ {
+ struct name;
+ struct age;
+ }
+
+ // demo::employee is a Fusion sequence
+ BOOST_FUSION_DEFINE_ASSOC_STRUCT(
+ (demo), employee,
+ (std::string, name, keys::name)
+ (int, age, keys::age))
+
+[endsect]
+
+[section:define_assoc_tpl_struct BOOST_FUSION_DEFINE_ASSOC_TPL_STRUCT]
+
+[heading Description]
+
+BOOST_FUSION_DEFINE_ASSOC_TPL_STRUCT is a macro that can be used to generate all
+the necessary boilerplate to define and adapt an arbitrary template struct as a
+model of __random_access_sequence__ and __associative_sequence__.
+
+[heading Synopsis]
+
+ BOOST_FUSION_DEFINE_ASSOC_TPL_STRUCT(
+ (template_param0)(template_param1)...,
+ (namespace0)(namespace1)...,
+ struct_name,
+ (member_type0, member_name0, key_type0)
+ (member_type1, member_name1, key_type1)
+ ...
+ )
+
+[variablelist Notation
+ [[`Str`] [An instantiated `struct_name`]]
+ [[`str`] [An instance of `Str`]]
+ [[`e0`...`en`] [Heterogeneous values]]
+ [[`fs`] [A __forward_sequence__]]
+]
+
+[heading Expression Semantics]
+
+The above macro generates the necessary code that defines and adapts
+`struct_name` as a model of __random_access_sequence__ and
+__associative_sequence__.
+The sequence `(template_param0)(template_param1)...` declares the names of
+the template type parameters used.
+The sequence `(namespace0)(namespace1)...` declares the namespace
+for `struct_name`. It yields to a fully qualified name for `struct_name` of
+`namespace0::namespace1::... struct_name`.
+If an empty namespace sequence is given (that is a macro that expands to
+nothing), the struct is placed in the global namespace.
+The sequence of `(member_typeN, member_nameN, key_typeN)`
+triples declares the type, name and key type of each of the struct members
+that are part of the sequence.
+
+The macro should be used at global scope.
+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]]
+ [[`Str()`] [Creates an instance of `Str` with default constructed elements.]]
+ [[`Str(e0, e1,... en)`] [Creates an instance of `Str` with elements `e0`...`en`.]]
+ [[`Str(fs)`] [Copy constructs an instance of `Str` from a __forward_sequence__ `fs`.]]
+ [[`str = fs`] [Assigns from a __forward_sequence__ `fs`.]]
+ [[`str.member_nameN`] [Access of struct member `member_nameN`]]
+]
+
+[heading Header]
+
+ #include <boost/fusion/adapted/struct/define_assoc_struct.hpp>
+ #include <boost/fusion/include/define_assoc_struct.hpp>
+
+[heading Example]
+
+ namespace keys
+ {
+ struct name;
+ struct age;
+ }
+
+ // Any instantiated demo::employee is a Fusion sequence
+ BOOST_FUSION_DEFINE_ASSOC_TPL_STRUCT(
+ (Name)(Age), (demo), employee,
+ (Name, name, keys::name)
+ (Age, age, keys::age))
+
+[endsect]
+
+[endsect]
diff --git a/doc/algorithm.qbk b/doc/algorithm.qbk
new file mode 100644
index 0000000..3bda204
--- /dev/null
+++ b/doc/algorithm.qbk
@@ -0,0 +1,2848 @@
+[/==============================================================================
+ Copyright (C) 2001-2011 Joel de Guzman
+ Copyright (C) 2006 Dan Marsden
+ Copyright (C) 2010 Christopher Schmidt
+
+ 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 Algorithm]
+
+[heading Lazy Evaluation]
+
+Unlike __mpl__, Fusion algorithms are lazy[footnote Except for some
+special cases such as __for_each__ and __copy__ which are inherently
+imperative algorithms.] and non sequence-type preserving [footnote What
+does that mean? It means that when you operate on a sequence through a
+Fusion algorithm that returns a sequence, the sequence returned may not
+be of the same class as the original]. This is by design. Runtime
+efficiency is given a high priority. Like __mpl__, and unlike __stl__,
+fusion algorithms are mostly functional in nature such that algorithms
+are non mutating (no side effects). However, due to the high cost of
+returning full sequences such as vectors and lists, /Views/ are returned
+from Fusion algorithms instead. For example, the __transform__ algorithm
+does not actually return a transformed version of the original sequence.
+__transform__ returns a __transform_view__. This view holds a reference
+to the original sequence plus the transform function. Iteration over the
+__transform_view__ will apply the transform function over the sequence
+elements on demand. This /lazy/ evaluation scheme allows us to chain as
+many algorithms as we want without incurring a high runtime penalty.
+
+[heading Sequence Extension]
+
+The /lazy/ evaluation scheme where __algorithms__ return __views__ also
+allows operations such as __push_back__ to be totally generic. In Fusion,
+__push_back__ is actually a generic algorithm that works on all sequences.
+Given an input sequence `s` and a value `x`, Fusion's __push_back__
+algorithm simply returns a __joint_view__: a view that holds a reference to
+the original sequence `s` and the value `x`. Functions that were once
+sequence specific and need to be implemented N times over N different
+sequences are now implemented only once. That is to say that Fusion
+sequences are cheaply extensible.
+
+To regain the original sequence, __conversion__ functions are provided. You
+may use one of the __conversion__ functions to convert back to the original
+sequence type.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm.hpp>
+ #include <boost/fusion/include/algorithm.hpp>
+
+[section Auxiliary]
+
+The auxiliary algorithms provide the utility algorithms for sequences.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/auxiliary.hpp>
+ #include <boost/fusion/include/auxiliary.hpp>
+
+[section Functions]
+
+[section copy]
+
+[heading Description]
+Copy a sequence `src` to a sequence `dest`.
+It is also used to convert sequence into other.
+
+[heading Synopsis]
+ template <typename Seq1, typename Seq2>
+ typename __result_of_copy__<Seq1, Seq2>::type copy(Seq1 const& src, Seq2& dest);
+
+[table Parameters
+ [[Parameter][Requirement][Description]]
+ [[`src`][A model of __forward_sequence__, all elements contained in the `src` sequence should be convertible into the element contained in the `dest` sequence.][Operation's argument]]
+ [[`dest`][A model of __forward_sequence__, `e2 = e1` is valid expression for each pair of elements `e1` of `src` and `e2` of `dest`.][Operation's argument]]
+]
+
+[heading Expression Semantics]
+ __copy__(src, dest);
+
+[*Return type]: `void`
+
+[*Semantics]: `e2 = e1` for each element `e1` in `src` and `e2` in `dest`.
+
+[heading Complexity]
+Linear, exactly `__result_of_size__<Sequence>::value`.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/auxiliary/copy.hpp>
+ #include <boost/fusion/include/copy.hpp>
+
+[heading Example]
+ __vector__<int,int> vec(1,2);
+ __list__<int,int> ls;
+ __copy__(vec, ls);
+ assert(ls == __make_list__(1,2));
+
+[endsect]
+
+[section move]
+
+[heading Description]
+move a sequence `src` to a sequence `dest`.
+It is also used to convert sequence into other.
+
+[heading Synopsis]
+ template <typename Seq1, typename Seq2>
+ typename __result_of_move__<Seq1, Seq2>::type move(Seq1&& src, Seq2& dest);
+
+[table Parameters
+ [[Parameter][Requirement][Description]]
+ [[`src`][A model of __forward_sequence__, all elements contained in the `src` sequence should be convertible into the element contained in the `dest` sequence.][Operation's argument]]
+ [[`dest`][A model of __forward_sequence__, `e2 = std::move(e1)` is valid expression for each pair of elements `e1` of `src` and `e2` of `dest`.][Operation's argument]]
+]
+
+[heading Expression Semantics]
+ __move__(src, dest);
+
+[*Return type]: `void`
+
+[*Semantics]: `e2 = std::move(e1)` for each element `e1` in `src` and `e2` in `dest`.
+
+[heading Complexity]
+Linear, exactly `__result_of_size__<Sequence>::value`.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/auxiliary/move.hpp>
+ #include <boost/fusion/include/move.hpp>
+
+[heading Example]
+ __vector__<int,int> vec(1,2);
+ __list__<int,int> ls;
+ __move__(std::move(vec), ls);
+ assert(ls == __make_list__(1,2));
+
+[endsect]
+
+[endsect]
+
+[section Metafunctions]
+
+[section copy]
+
+[heading Description]
+A metafunction returning the result type of applying __copy__, which is always `void`.
+
+[heading Synopsis]
+ template <typename Seq1, typename Seq2>
+ struct copy
+ {
+ typedef void type;
+ };
+
+[table Parameters
+ [[Parameter] [Requirement] [Description]]
+ [[`Seq1`] [A model of __forward_sequence__] [Operation's argument]]
+ [[`Seq2`] [A model of __forward_sequence__] [Operation's argument]]
+]
+
+[heading Expression Semantics]
+ result_of::copy<Seq1, Seq2>::type
+
+[*Return type]: `void` iff both of `Seq1` and `Seq2` are sequence.
+Otherwise, none.
+
+[*Semantics]: Returns the return type of __copy__ for 2 sequences of types `Seq1` and `Seq2`.
+
+[heading Complexity]
+Constant.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/auxiliary/copy.hpp>
+ #include <boost/fusion/include/copy.hpp>
+
+[endsect]
+
+[section move]
+
+[heading Description]
+A metafunction returning the result type of applying __move__, which is always `void`.
+
+[heading Synopsis]
+ template <typename Seq1, typename Seq2>
+ struct move
+ {
+ typedef void type;
+ };
+
+[table Parameters
+ [[Parameter] [Requirement] [Description]]
+ [[`Seq1`] [A model of __forward_sequence__] [Operation's argument]]
+ [[`Seq2`] [A model of __forward_sequence__] [Operation's argument]]
+]
+
+[heading Expression Semantics]
+ result_of::move<Seq1, Seq2>::type
+
+[*Return type]: `void` iff both of `Seq1` and `Seq2` are sequence.
+Otherwise, none.
+
+[*Semantics]: Returns the return type of __move__ for 2 sequences of types `Seq1` and `Seq2`.
+
+[heading Complexity]
+Constant.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/auxiliary/move.hpp>
+ #include <boost/fusion/include/move.hpp>
+
+[endsect]
+
+[endsect]
+
+[endsect]
+
+
+[section Iteration]
+
+The iteration algorithms provide the fundamental algorithms for traversing
+a sequence repeatedly applying an operation to its elements.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/iteration.hpp>
+ #include <boost/fusion/include/iteration.hpp>
+
+[section Functions]
+
+[template fold_desc[name result_of_name arg_desc seq_concept arg_id arg_type_id invoke_desc semantics_elements_desc example_arg_transform example_result I0 I1 IN]
+[heading Description]
+For a sequence `seq`, initial state `initial_state`, and binary function object
+or function pointer `f`, [^[name]] returns the result of the repeated application of
+binary `f` to the result of the previous `f` invocation (`inital_state` if it is
+the first call) and [arg_desc] of `seq`.
+
+[def name_macro [name]]
+[def result_of_name_macro [result_of_name]]
+[heading Synopsis]
+ template<
+ typename Sequence,
+ typename State,
+ typename F
+ >
+ typename result_of_name_macro<Sequence, State const, F>::type name_macro(
+ Sequence& seq, State const& initial_state, F f);
+
+ template<
+ typename Sequence,
+ typename State,
+ typename F
+ >
+ typename result_of_name_macro<Sequence const, State const, F>::type name_macro(
+ Sequence const& seq, State const& initial_state, F f);
+
+ template<
+ typename Sequence,
+ typename State,
+ typename F
+ >
+ typename result_of_name_macro<Sequence, State, F>::type name_macro(
+ Sequence& seq, State& initial_state, F f);
+
+ template<
+ typename Sequence,
+ typename State,
+ typename F
+ >
+ typename result_of_name_macro<Sequence const, State, F>::type name_macro(
+ Sequence const& seq, State& initial_state, F f);
+
+[def seq_concept_macro [seq_concept]]
+[def arg_type_id_macro [arg_type_id]]
+[def arg_id_macro [arg_id]]
+[def invoke_desc_macro [invoke_desc]]
+[table Parameters
+ [[Parameter][Requirement][Description]]
+ [[`seq`][A model of seq_concept_macro][Operation's argument]]
+ [[`initial_state`][Any type][Initial state]]
+ [[`f`][`f(s,arg_id_macro)` with return type `__boost_result_of_call__<F(S,arg_type_id_macro)>::type` for current state `s` of type `S`, and for each invoke_desc_macro][Operation's argument]]
+]
+
+[heading Expression Semantics]
+ name_macro(seq, initial_state, f);
+
+[*Return type]: Any type
+
+[*Semantics]: Equivalent to [^f(... f(f(initial_state,[arg_id][I0]),[arg_id][I1]) ...[arg_id][IN])] where [^[arg_id]1 ...[arg_id]N] are [semantics_elements_desc].
+
+[heading Complexity]
+Linear, exactly `__result_of_size__<Sequence>::value` applications of `f`.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/iteration/name_macro.hpp>
+ #include <boost/fusion/include/name_macro.hpp>
+
+[def example_result_macro [example_result]]
+[def example_arg_transform_macro [example_arg_transform]]
+[heading Example]
+ struct make_string
+ {
+ typedef std::string result_type;
+
+ template<typename T>
+ std::string operator()(const std::string& str, const T& t) const
+ {
+ return str + boost::lexical_cast<std::string>(example_arg_transform_macro);
+ }
+ };
+ ...
+ const __vector__<int,int> vec(1,2);
+ assert(name_macro(vec,std::string(""), make_string()) == example_result_macro);
+]
+
+[section fold]
+[fold_desc fold..__result_of_fold__..each element..__forward_sequence__..e..E..element `e` of type `E` in `seq`..the consecutive elements of `seq`..t.."12"..1..2..N]
+[endsect]
+
+[section reverse_fold]
+[fold_desc reverse_fold..__result_of_reverse_fold__..each element..__bidirectional_sequence__..e..E..element `e` of type `E` in `seq`..the consecutive elements of `seq`..t.."21"..N..N-1..1]
+[endsect]
+
+[section iter_fold]
+[fold_desc iter_fold..__result_of_iter_fold__..iterators on each element..__forward_sequence__..it..It..iterator `it` of type `It` on an element of `seq`..consecutive iterators on the elements of `seq`..__deref__(t).."12"..1..2..N]
+[endsect]
+
+[section reverse_iter_fold]
+[fold_desc reverse_iter_fold..__result_of_reverse_iter_fold__..iterators on each element..__bidirectional_sequence__..it..It..iterator `it` of type `It` on an element of `seq`..consecutive iterators on the elements of `seq`..__deref__(t).."21"..N..N-1..1]
+[endsect]
+
+[section accumulate]
+[fold_desc accumulate..__result_of_accumulate__..each element..__forward_sequence__..e..E..element `e` of type `E` in `seq`..the consecutive elements of `seq`..t.."12"..1..2..N]
+[endsect]
+
+[section for_each]
+
+[heading Description]
+Applies a unary function object to each element of a sequence.
+
+[heading Synopsis]
+ template<
+ typename Sequence,
+ typename F
+ >
+ typename __result_of_for_each__<Sequence, F>::type for_each(
+ Sequence& seq, F f);
+
+[table Parameters
+ [[Parameter][Requirement][Description]]
+ [[`seq`][A model of __forward_sequence__, `f(e)` must be a valid expression for each element `e` in `seq`][Operation's argument]]
+ [[`f`][A unary __reg_callable_obj__][Operation's argument]]
+]
+
+[heading Expression Semantics]
+ __for_each__(seq, f);
+
+[*Return type]: `void`
+
+[*Semantics]: Calls `f(e)` for each element `e` in `seq`.
+
+[heading Complexity]
+Linear, exactly `__result_of_size__<Sequence>::value` applications of `f`.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/iteration/for_each.hpp>
+ #include <boost/fusion/include/for_each.hpp>
+
+[heading Example]
+ struct increment
+ {
+ template<typename T>
+ void operator()(T& t) const
+ {
+ ++t;
+ }
+ };
+ ...
+ __vector__<int,int> vec(1,2);
+ __for_each__(vec, increment());
+ assert(vec == __make_vector__(2,3));
+
+[endsect]
+
+[endsect]
+
+[section Metafunctions]
+
+[template meta_fold_desc[name name_func seq_concept arg_id arg_type_id invoke_meta_desc]
+[heading Description]
+Returns the result type of [name_func].
+
+[def name_macro [name]]
+[heading Synopsis]
+ template<
+ typename Sequence,
+ typename State,
+ typename F>
+ struct name_macro
+ {
+ typedef __unspecified__ type;
+ };
+
+[def seq_concept_macro [seq_concept]]
+[def arg_type_id_macro [arg_type_id]]
+[def arg_id_macro [arg_id]]
+[def invoke_meta_desc_macro [invoke_meta_desc]]
+[table Parameters
+ [[Parameter] [Requirement] [Description]]
+ [[`Sequence`] [A model of seq_concept_macro] [The sequence to iterate]]
+ [[`State`] [Any type] [The initial state for the first application of `F`]]
+ [[`F`] [`__boost_result_of_call__<F(S,arg_type_id_macro)>::type` is the return type of `f(s,arg_id_macro)` with current state `s` of type `S`, and an invoke_meta_desc_macro][The operation to be applied on traversal]]
+]
+
+[heading Expression Semantics]
+ name_macro<Sequence, State, F>::type
+
+[*Return type]: Any type
+
+[*Semantics]: Returns the result of applying [name_func] to a sequence of type
+`Sequence`, with an initial state of type `State` and binary function object or
+function pointer of type `F`.
+
+[heading Complexity]
+Linear, exactly `__result_of_size__<Sequence>::value` applications of `F`.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/iteration/name_macro.hpp>
+ #include <boost/fusion/include/name_macro.hpp>
+]
+
+[section fold]
+[meta_fold_desc fold..__fold__..__forward_sequence__..e..E..element `e` of type `E` in `seq`]
+[endsect]
+
+[section reverse_fold]
+[meta_fold_desc reverse_fold..__reverse_fold__..__bidirectional_sequence__..e..E..element `e` of type `E` in `seq`]
+[endsect]
+
+[section iter_fold]
+[meta_fold_desc iter_fold..__iter_fold__..__forward_sequence__..it..It..iterator `it` of type `It` on an element of `seq`]
+[endsect]
+
+[section reverse_iter_fold]
+[meta_fold_desc reverse_iter_fold..__reverse_iter_fold__..__bidirectional_sequence__..it..It..iterator `it` of type `It` on an element of `seq`]
+[endsect]
+
+[section accumulate]
+[meta_fold_desc accumulate..__accumulate__..__forward_sequence__..e..E..element `e` of type `E` in `seq`]
+[endsect]
+
+[section for_each]
+
+[heading Description]
+A metafunction returning the result type of applying __for_each__ to a sequence. The
+return type of __for_each__ is always `void`.
+
+[heading Synopsis]
+ template<
+ typename Sequence,
+ typename F
+ >
+ struct for_each
+ {
+ typedef void type;
+ };
+
+[table Parameters
+ [[Parameter] [Requirement] [Description]]
+ [[`Sequence`] [A model of __forward_sequence__] [Operation's argument]]
+ [[`F`] [Any type] [Operation's argument]]
+]
+
+[heading Expression Semantics]
+ __result_of_for_each__<Sequence, F>::type
+
+[*Return type]: `void`.
+
+[*Semantics]: Returns the return type of __for_each__ for a sequence of type `Sequence` and a unary function object `F`.
+The return type is always `void`.
+
+[heading Complexity]
+Constant.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/iteration/for_each.hpp>
+ #include <boost/fusion/include/for_each.hpp>
+
+[endsect]
+
+[endsect]
+
+[endsect]
+
+[section Query]
+The query algorithms provide support for searching and analyzing sequences.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/query.hpp>
+ #include <boost/fusion/include/query.hpp>
+
+[section Functions]
+
+[section any]
+
+[heading Description]
+For a sequence `seq` and unary function object `f`, `any` returns true if `f` returns true for at least one element of `seq`.
+
+[heading Synopsis]
+ template<
+ typename Sequence,
+ typename F
+ >
+ typename __result_of_any__<Sequence,F>::type any(
+ Sequence const& seq, F f);
+
+[table Parameters
+ [[Parameter][Requirement][Description]]
+ [[`seq`][A model of __forward_sequence__, `f(e)` must be a valid expression, convertible to `bool`, for each element `e` in `seq`][The sequence to search]]
+ [[`f`][A unary function object][The search predicate]]
+]
+
+[heading Expression semantics]
+ __any__(seq, f);
+
+[*Return type]: `bool`
+
+[*Semantics]: Returns true if and only if `f(e)` evaluates to `true` for some element `e` in `seq`.
+
+[heading Complexity]
+Linear. At most `__result_of_size__<Sequence>::value` comparisons.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/query/any.hpp>
+ #include <boost/fusion/include/any.hpp>
+
+[heading Example]
+ struct odd
+ {
+ template<typename T>
+ bool operator()(T t) const
+ {
+ return t % 2;
+ }
+ };
+ ...
+ assert(__any__(__make_vector__(1,2), odd()));
+ assert(!__any__(__make_vector__(2,4), odd()));
+
+[endsect]
+
+[section all]
+
+[heading Description]
+For a sequence `seq` and unary function object `f`, `all` returns true if `f` returns true for every element of `seq`.
+
+[heading Synopsis]
+ template<
+ typename Sequence,
+ typename F
+ >
+ typename __result_of_all__<Sequence,F>::type all(
+ Sequence const& seq, F f);
+
+[table Parameters
+ [[Parameter][Requirement][Description]]
+ [[`seq`][A model of __forward_sequence__, `f(e)` is a valid expression, convertible to `bool`, for every element `e` in `seq`][The sequence to search]]
+ [[`f`][A unary function object][The search predicate]]
+]
+
+[heading Expression Semantics]
+ __all__(seq, f);
+
+[*Return type]: `bool`
+
+[*Semantics]: Returns true if and only if `f(e)` evaluates to `true` for every element `e` in `seq`.
+
+[heading Complexity]
+Linear. At most `__result_of_size__<Sequence>::value` comparisons.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/query/all.hpp>
+ #include <boost/fusion/include/all.hpp>
+
+[heading Example]
+ struct odd
+ {
+ template<typename T>
+ bool operator()(T t) const
+ {
+ return t % 2;
+ }
+ };
+ ...
+ assert(__all__(__make_vector__(1,3), odd()));
+ assert(!__all__(__make_vector__(1,2), odd()));
+
+[endsect]
+
+[section none]
+
+[heading Description]
+For a sequence `seq` and unary function object `f`, `none` returns true if `f` returns false for every element of `seq`.
+
+[heading Synopsis]
+ template<
+ typename Sequence,
+ typename F
+ >
+ typename __result_of_none__<Sequence,F>::type none(
+ Sequence const& seq, F f);
+
+[table Parameters
+ [[Parameter][Requirement][Description]]
+ [[`seq`][A model of __forward_sequence__, `f(e)` is a valid expression, convertible to `bool`, for every element `e` in `seq`][The sequence to search]]
+ [[`f`][A unary function object][The search predicate]]
+]
+
+[heading Expression Semantics]
+ __none__(seq, f);
+
+[*Return type]: `bool`
+
+[*Semantics]: Returns true if and only if `f(e)` evaluates to `false` for every element `e` in `seq`. Result equivalent to `!any(seq, f)`.
+
+[heading Complexity]
+Linear. At most `__result_of_size__<Sequence>::value` comparisons.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/query/none.hpp>
+ #include <boost/fusion/include/none.hpp>
+
+[heading Example]
+ struct odd
+ {
+ template<typename T>
+ bool operator()(T t) const
+ {
+ return t % 2;
+ }
+ };
+ ...
+ assert(__none__(__make_vector__(2,4), odd()));
+ assert(!__none__(__make_vector__(1,2), odd()));
+
+[endsect]
+
+[section find]
+
+[heading Description]
+Finds the first element of a given type within a sequence.
+
+[heading Synopsis]
+ template<
+ typename T,
+ typename Sequence
+ >
+ typename __result_of_find__<Sequence const, T>::type find(Sequence const& seq);
+
+ template<
+ typename T,
+ typename Sequence
+ >
+ typename __result_of_find__<Sequence, T>::type find(Sequence& seq);
+
+[table Parameters
+ [[Parameter][Requirement][Description]]
+ [[`seq`][A model of __forward_sequence__][The sequence to search]]
+ [[`T`][Any type][The type to search for]]
+]
+
+[heading Expression Semantics]
+ __find__<T>(seq)
+
+[*Return type]: A model of the same iterator category as the iterators of `seq`.
+
+[*Semantics]: Returns an iterator to the first element of `seq` of type `T`, or `__end__(seq)` if there is no such element.
+Equivalent to `__find_if__<boost::is_same<_, T> >(seq)`
+
+[heading Complexity]
+Linear. At most `__result_of_size__<Sequence>::value` comparisons.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/query/find.hpp>
+ #include <boost/fusion/include/find.hpp>
+
+[heading Example]
+ const __vector__<char,int> vec('a','0');
+ assert(*__find__<int>(vec) == '0');
+ assert(__find__<double>(vec) == __end__(vec));
+
+[endsect]
+
+[section find_if]
+
+[heading Description]
+Finds the first element within a sequence with a type for which a given __mpl_lambda_expression__ evaluates to
+`boost::mpl::true_`.
+
+[heading Synopsis]
+ template<
+ typename F,
+ typename Sequence
+ >
+ typename __result_of_find_if__<Sequence const, F>::type find_if(Sequence const& seq);
+
+ template<
+ typename F,
+ typename Sequence
+ >
+ typename __result_of_find_if__<Sequence, F>::type find_if(Sequence& seq);
+
+[table Parameters
+ [[Parameter][Requirement][Description]]
+ [[`seq`][A model of __forward_sequence__][The sequence to search]]
+ [[`F`][A unary __mpl_lambda_expression__][The search predicate]]
+]
+
+[heading Expression Semantics]
+ __find_if__<F>(seq)
+
+[*Return type]: An iterator of the same iterator category as the iterators of `seq`.
+
+[*Semantics]: Returns the first element of `seq` for which __mpl_lambda_expression__ `F` evaluates to `boost::mpl::true_`,
+or `__end__(seq)` if there is no such element.
+
+[heading Complexity]
+Linear. At most `__result_of_size__<Sequence>::value` comparisons.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/query/find_if.hpp>
+ #include <boost/fusion/include/find_if.hpp>
+
+[heading Example]
+ const __vector__<double,int> vec(1.0,2);
+ assert(*__find_if__<is_integral<mpl::_> >(vec) == 2);
+ assert(__find_if__<is_class<mpl::_> >(vec) == __end__(vec));
+
+[endsect]
+
+[section count]
+
+[heading Description]
+Returns the number of elements of a given type within a sequence.
+
+[heading Synopsis]
+ template<
+ typename Sequence,
+ typename T
+ >
+ typename __result_of_count__<Sequence, T>::type count(
+ Sequence const& seq, T const& t);
+
+[table Parameters
+ [[Parameter][Requirement][Description]]
+ [[`seq`][A model of __forward_sequence__, `e == t` must be a valid expression, convertible to `bool`, for each element `e` in `seq`][The sequence to search]]
+ [[`T`][Any type][The type to count]]
+]
+
+[heading Expression Semantics]
+ __count__(seq, t);
+
+[*Return type]: `int`
+
+[*Semantics]: Returns the number of elements of type `T` and equal to `t` in `seq`.
+
+[heading Complexity]
+Linear. At most `__result_of_size__<Sequence>::value` comparisons.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/query/count.hpp>
+ #include <boost/fusion/include/count.hpp>
+
+[heading Example]
+ const __vector__<double,int,int> vec(1.0,2,3);
+ assert(__count__(vec,2) == 1);
+
+[endsect]
+
+[section count_if]
+
+[heading Description]
+Returns the number of elements within a sequence with a type for which a given unary function object evaluates to
+`true`.
+
+[heading Synopsis]
+ template<
+ typename Sequence,
+ typename F
+ >
+ typename __result_of_count_if__<Sequence, F>::type count_if(
+ Sequence const& seq, F f);
+
+[table Parameters
+ [[Parameter][Requirement][Description]]
+ [[`seq`][A model of __forward_sequence__, `f(e)` is a valid expression, convertible to `bool`, for each element `e` in `seq`][The sequence to search]]
+ [[`f`][A unary function object][The search predicate]]
+]
+
+[heading Expression Semantics]
+ __count_if__(seq, f)
+
+[*Return type]: `int`
+
+[*Semantics]: Returns the number of elements in `seq` where `f` evaluates to `true`.
+
+[heading Complexity]
+Linear. At most `__result_of_size__<Sequence>::value` comparisons.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/query/count_if.hpp>
+ #include <boost/fusion/include/count_if.hpp>
+
+[heading Example]
+ const __vector__<int,int,int> vec(1,2,3);
+ assert(__count_if__(vec,odd()) == 2);
+
+[endsect]
+
+[endsect]
+
+[section Metafunctions]
+
+[section any]
+
+[heading Description]
+A metafunction returning the result type of __any__.
+
+[heading Synopsis]
+ template<
+ typename Sequence,
+ typename F
+ >
+ struct any
+ {
+ typedef bool type;
+ };
+
+[table Parameters
+ [[Parameter] [Requirement] [Description]]
+ [[`Sequence`] [A model of __forward_sequence__] [Operation's argument]]
+ [[`F`] [A model of unary __poly_func_obj__] [Operation's argument]]
+]
+
+[heading Expression Semantics]
+ __result_of_any__<Sequence, F>::type
+
+[*Return type]: `bool`.
+
+[*Semantics]: Returns the return type of __any__ given a sequence of type `Sequence` and a unary __poly_func_obj__ of type `F`. The return type is always `bool`.
+
+[heading Complexity]
+Constant.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/query/any.hpp>
+ #include <boost/fusion/include/any.hpp>
+
+[endsect]
+
+[section all]
+
+[heading Description]
+A metafunction returning the result type of __all__.
+
+[heading Synopsis]
+ template<
+ typename Sequence,
+ typename F
+ >
+ struct all
+ {
+ typedef bool type;
+ };
+
+[table Parameters
+ [[Parameter] [Requirement] [Description]]
+ [[`Sequence`] [A model of __forward_sequence__] [Operation's argument]]
+ [[`F`] [A model of unary __poly_func_obj__] [Operation's argument]]
+]
+
+[heading Expression Semantics]
+ __result_of_all__<Sequence, F>::type
+
+[*Return type]: `bool`.
+
+[*Semantics]: Returns the return type of __all__ given a sequence of type `Sequence` and a unary __poly_func_obj__ of type `F`. The return type is always `bool`.
+
+[heading Complexity]
+Constant.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/query/all.hpp>
+ #include <boost/fusion/include/all.hpp>
+
+[endsect]
+
+[section none]
+
+[heading Description]
+A metafunction returning the result type of __none__.
+
+[heading Synopsis]
+ template<
+ typename Sequence,
+ typename F
+ >
+ struct none
+ {
+ typedef bool type;
+ };
+
+[table Parameters
+ [[Parameter] [Requirement] [Description]]
+ [[`Sequence`] [A model of __forward_sequence__] [Operation's argument]]
+ [[`F`] [A model of unary __poly_func_obj__] [Operation's argument]]
+]
+
+[heading Expression Semantics]
+ __result_of_none__<Sequence, F>::type
+
+[*Return type]: `bool`.
+
+[*Semantics]: Returns the return type of __none__ given a sequence of type `Sequence` and a unary __poly_func_obj__ of type `F`. The return type is always `bool`.
+
+[heading Complexity]
+Constant.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/query/none.hpp>
+ #include <boost/fusion/include/none.hpp>
+
+[endsect]
+
+[section find]
+
+[heading Description]
+Returns the result type of __find__, given the sequence and search types.
+
+[heading Synopsis]
+ template<
+ typename Sequence,
+ typename T
+ >
+ struct find
+ {
+ typedef __unspecified__ type;
+ };
+
+[table Parameters
+ [[Parameter] [Requirement] [Description]]
+ [[`Sequence`] [Model of __forward_sequence__] [Operation's argument]]
+ [[`T`] [Any type] [Operation's argument]]
+]
+
+[heading Expression Semantics]
+ __result_of_find__<Sequence, T>::type
+
+[*Return type]: A model of the same iterator category as the iterators of `Sequence`.
+
+[*Semantics]: Returns an iterator to the first element of type `T` in `Sequence`, or `__result_of_end__<Sequence>::type` if there is no such element.
+
+[heading Complexity]
+Linear, at most `__result_of_size__<Sequence>::value` comparisons.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/query/find.hpp>
+ #include <boost/fusion/include/find.hpp>
+
+[endsect]
+
+[section find_if]
+
+[heading Description]
+Returns the result type of __find_if__ given the sequence and predicate types.
+
+[heading Synopsis]
+ template<
+ typename Sequence,
+ typename Pred
+ >
+ struct find_if
+ {
+ typedef __unspecified__ type;
+ };
+
+[table Parameters
+ [[Parameter] [Requirement] [Description]]
+ [[`Sequence`] [A model of __forward_sequence__] [Operation's argument]]
+ [[`Pred`] [A model of __mpl_lambda_expression__] [Operation's arguments]]
+]
+
+[heading Expression Semantics]
+ __result_of_find_if__<Sequence, Pred>::type
+
+[*Return type]: A model of the same iterator category as the iterators of `Sequence`.
+
+[*Semantics]: Returns an iterator to the first element in `Sequence` for which `Pred` evaluates to true. Returns `__result_of_end__<Sequence>::type` if there is no such element.
+
+[heading Complexity]
+Linear. At most `__result_of_size__<Sequence>::value` comparisons.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/query/find_if.hpp>
+ #include <boost/fusion/include/find_if.hpp>
+
+[endsect]
+
+[section count]
+
+[heading Description]
+A metafunction that returns the result type of `count` given the sequence and search types.
+
+[heading Synopsis]
+ template<
+ typename Sequence,
+ typename T
+ >
+ struct count
+ {
+ typedef int type;
+ };
+
+[table Parameters
+ [[Parameter] [Requirement] [heading Description]]
+ [[`Sequence`] [A model of __forward_sequence__] [Operation's argument]]
+ [[`T`] [Any type] [Operation's argument]]
+]
+
+[heading Expression Semantics]
+ __result_of_count__<T>::type
+
+[*Return type]: `int`.
+
+[*Semantics]: Returns the return type of __count__. The return type is always `int`.
+
+[heading Complexity]
+Constant.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/query/count.hpp>
+ #include <boost/fusion/include/count.hpp>
+
+[endsect]
+
+[section count_if]
+
+[heading Description]
+A metafunction that returns the result type of `count_if` given the sequence and predicate types.
+
+[heading Synopsis]
+ template<
+ typename Sequence,
+ typename Pred
+ >
+ struct count_if
+ {
+ typedef int type;
+ };
+
+[table Parameters
+ [[Parameter] [Requirement] [Description]]
+ [[`Sequence`] [A model of __forward_sequence__] [Operation's argument]]
+ [[`Pred`] [A unary function object] [Operation's argument]]
+]
+
+[heading Expression Semantics]
+ __result_of_count_if__<Sequence, Pred>::type
+
+[*Return type]: `int`.
+
+[*Semantics]: Returns the return type of __count_if__. The return type is always `int`.
+
+[heading Complexity]
+Constant.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/query/count_if.hpp>
+ #include <boost/fusion/include/count_if.hpp>
+
+[endsect]
+
+[endsect]
+
+[endsect]
+
+[section Transformation]
+The transformation algorithms create new sequences out of existing sequences by performing some sort of transformation. In reality the new sequences are views onto the data in the original sequences.
+
+[note As the transformation algorithms return views onto their input arguments,
+it is important that the lifetime of the input arguments is greater than the
+period during which you wish to use the results.]
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/transformation.hpp>
+ #include <boost/fusion/include/transformation.hpp>
+
+[section Functions]
+
+[section filter]
+
+[heading Description]
+For a given sequence, filter returns a new sequences containing only the elements of a specified type.
+
+[heading Synopsis]
+ template<
+ typename T,
+ typename Sequence
+ >
+ typename __result_of_filter__<Sequence const, T>::type filter(Sequence const& seq);
+
+[table Parameters
+ [[Parameter][Requirement][Description]]
+ [[`seq`][A model of __forward_sequence__][Operation's argument]]
+ [[`T`][Any type][The type to retain]]
+]
+
+[heading Expression Semantics]
+ __filter__<T>(seq);
+
+[*Return type]:
+
+* A model of __forward_sequence__.
+* A model of __associative_sequence__ if `seq` implements the __associative_sequence__ model.
+
+[*Semantics]: Returns a sequence containing all the elements of `seq` of type `T`.
+Equivalent to `__filter_if__<boost::same_type<_, T> >(seq)`.
+
+[heading Complexity]
+Constant. Returns a view which is lazily evaluated.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/transformation/filter.hpp>
+ #include <boost/fusion/include/filter.hpp>
+
+[heading Example]
+ const __vector__<int,int,long,long> vec(1,2,3,4);
+ assert(__filter__<int>(vec) == __make_vector__(1,2));
+
+[endsect]
+
+[section filter_if]
+
+[heading Description]
+For a given sequence, __filter_if__ returns a new sequences containing
+only the elements with types for which a given __mpl_lambda_expression__ evaluates to `boost::mpl::true_`.
+
+[heading Synopsis]
+ template<
+ typename Pred,
+ typename Sequence
+ >
+ typename __result_of_filter_if__<Sequence const, Pred>::type filter_if(Sequence const& seq);
+
+[table Parameters
+ [[Parameter][Requirement][Description]]
+ [[`seq`][A model of __forward_sequence__][Operation's argument]]
+ [[`Pred`][A unary __mpl_lambda_expression__][The predicate to filter by]]
+]
+
+[heading Expression Semantics]
+ __filter_if__<Pred>(seq);
+
+[*Return type]:
+
+* A model of __forward_sequence__.
+* A model of __associative_sequence__ if `seq` implements the __associative_sequence__ model.
+
+[*Semantics]: Returns a sequence containing all the elements of `seq` with types for which `Pred` evaluates
+to `boost::mpl::true_`. The order of the retained elements is the same as in the original sequence.
+
+[heading Complexity]
+Constant. Returns a view which is lazily evaluated.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/transformation/filter_if.hpp>
+ #include <boost/fusion/include/filter_if.hpp>
+
+[heading Example]
+ const __vector__<int,int,double,double> vec(1,2,3.0,4.0);
+ assert(__filter_if__<is_integral<mpl::_> >(vec) == __make_vector__(1,2));
+
+[endsect]
+
+[section transform]
+
+[heading Description]
+For a sequence `seq` and function object or function pointer `f`, `transform` returns a new sequence
+with elements created by applying `f(e)` to each element of `e` of `seq`.
+
+[heading Unary version synopsis]
+ template<
+ typename Sequence,
+ typename F
+ >
+ typename __result_of_transform__<Sequence const, F>::type transform(
+ Sequence const& seq, F f);
+
+[table Parameters
+ [[Parameter][Requirement][Description]]
+ [[`seq`][A model of __forward_sequence__][Operation's argument]]
+ [[`f`][`f(e)` is a valid expression for each element `e` of `seq`. `__boost_result_of_call__<F(E)>::type` is the return type of `f` when called with a value of each element type `E`.][Transformation function]]
+]
+
+[heading Expression Semantics]
+ __transform__(seq, f);
+
+[*Return type]: A model of __forward_sequence__
+
+[*Semantics]: Returns a new sequence, containing the return values of `f(e)` for each element `e` within `seq`.
+
+[heading Binary version synopsis]
+ template<
+ typename Sequence1,
+ typename Sequence2,
+ typename F
+ >
+ typename __result_of_transform__<Sequence1 const, Sequence2 const, F>::type transform(
+ Sequence1 const& seq1, Sequence2 const& seq2, F f);
+
+[table Parameters
+ [[Parameter][Requirement][Description]]
+ [[`seq1`][A model of __forward_sequence__][Operation's argument]]
+ [[`seq2`][A model of __forward_sequence__][Operation's argument]]
+ [[`f`][`f(e1,e2)` is a valid expression for each pair of elements `e1` of `seq1` and `e2` of `seq2`. `__boost_result_of_call__<F(E1,E2)>::type` is the return type of `f` when called with elements of type `E1` and `E2`][Transformation function]]
+]
+
+[*Return type]: A model of __forward_sequence__.
+
+[*Semantics]: Returns a new sequence, containing the return values of `f(e1, e2)` for each pair of elements `e1` and `e2` within `seq1` and `seq2` respectively.
+
+[heading Complexity]
+Constant. Returns a view which is lazily evaluated.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/transformation/transform.hpp>
+ #include <boost/fusion/include/transform.hpp>
+
+[heading Example]
+ struct triple
+ {
+ typedef int result_type;
+
+ int operator()(int t) const
+ {
+ return t * 3;
+ };
+ };
+ ...
+ assert(__transform__(__make_vector__(1,2,3), triple()) == __make_vector__(3,6,9));
+
+[endsect]
+
+[section replace]
+
+[heading Description]
+Replaces each value within a sequence of a given type and value with a new value.
+
+[heading Synopsis]
+ template<
+ typename Sequence,
+ typename T
+ >
+ typename __result_of_replace__<Sequence const, T>::type replace(
+ Sequence const& seq, T const& old_value, T const& new_value);
+
+[table Parameters
+ [[Parameter][Requirement][Description]]
+ [[`seq`][A model of __forward_sequence__, `e == old_value` is a valid expression, convertible to `bool`, for each element `e` in `seq` with type convertible to `T`][Operation's argument]]
+ [[`old_value`][Any type][Value to replace]]
+ [[`new_value`][Any type][Replacement value]]
+]
+
+[heading Expression Semantics]
+ __replace__(seq, old_value, new_value);
+
+[*Return type]: A model of __forward_sequence__.
+
+[*Semantics]: Returns a new sequence with all the values of `seq` with `new_value` assigned to elements with the same type and equal to `old_value`.
+
+[heading Complexity]
+Constant. Returns a view which is lazily evaluated.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/transformation/replace.hpp>
+ #include <boost/fusion/include/replace.hpp>
+
+[heading Example]
+ assert(__replace__(__make_vector__(1,2), 2, 3) == __make_vector__(1,3));
+
+[endsect]
+
+[section replace_if]
+
+[heading Description]
+Replaces each element of a given sequence for which an unary function object evaluates to `true` replaced with
+a new value.
+
+[heading Synopsis]
+ template<
+ typename Sequence,
+ typename F,
+ typename T>
+ typename __result_of_replace_if__<Sequence const, F, T>::type replace_if(
+ Sequence const& seq, F f, T const& new_value);
+
+[table Parameters
+ [[Parameter][Requirement][Description]]
+ [[`seq`][A model of __forward_sequence__][Operation's argument]]
+ [[`f`][A function object for which `f(e)` is a valid expression, convertible to `bool`, for each element `e` in `seq`][Operation's argument]]
+ [[`new_value`][Any type][Replacement value]]
+]
+
+[heading Expression Semantics]
+ __replace_if__(seq, f, new_value);
+
+[*Return type]: A model of __forward_sequence__.
+
+[*Semantics]: Returns a new sequence with all the elements of `seq`,
+with `new_value` assigned to each element for which `f` evaluates to `true`.
+
+[heading Complexity]
+Constant. Returns a view which is lazily evaluated.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/transformation/replace_if.hpp>
+ #include <boost/fusion/include/replace_if.hpp>
+
+[heading Example]
+ struct odd
+ {
+ template<typename T>
+ bool operator()(T t) const
+ {
+ return t % 2;
+ }
+ };
+ ...
+ assert(__replace_if__(__make_vector__(1,2), odd(), 3) == __make_vector__(3,2));
+
+[endsect]
+
+[section remove]
+
+[heading Description]
+Returns a new sequence, with all the elements of the original sequence, except those of a given type.
+
+[heading Synopsis]
+ template<
+ typename T,
+ typename Sequence
+ >
+ typename __result_of_remove__<Sequence const, T>::type remove(Sequence const& seq);
+
+[table Parameters
+ [[Parameter][Requirement][Description]]
+ [[`seq`][A model of __forward_sequence__][Operation's argument]]
+ [[`T`][Any type][Type to remove]]
+]
+
+[heading Expression Semantics]
+ __remove__<T>(seq);
+
+[*Return type]:
+
+* A model of __forward_sequence__.
+* A model of __associative_sequence__ if `Sequence` implements the __associative_sequence__ model.
+
+[*Semantics]: Returns a new sequence, containing all the elements of `seq`, in their original order, except
+those of type `T`. Equivalent to `__remove_if__<boost::is_same<_,T> >(seq)`.
+
+[heading Complexity]
+Constant. Returns a view which is lazily evaluated.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/transformation/remove.hpp>
+ #include <boost/fusion/include/remove.hpp>
+
+[heading Example]
+ const __vector__<int,double> vec(1,2.0);
+ assert(__remove__<double>(vec) == __make_vector__(1));
+
+[endsect]
+
+[section remove_if]
+
+[heading Description]
+Returns a new sequence, containing all the elements of the original except those where a given unary
+function object evaluates to `true`.
+
+[heading Synopsis]
+ template<
+ typename Pred,
+ typename Sequence
+ >
+ typename __result_of_remove_if__<Sequence const, Pred>::type remove_if(Sequence const& seq);
+
+[table Parameters
+ [[Parameter][Requirement][Description]]
+ [[`seq`][A model of __forward_sequence__][Operation's argument]]
+ [[`Pred`][A model of unary __mpl_lambda_expression__][Removal predicate]]
+]
+
+[heading Expression Semantics]
+ __remove_if__<Pred>(seq);
+
+[*Return type]:
+
+* A model of __forward_sequence__.
+* A model of __associative_sequence__ if `seq` implements the __associative_sequence__ model.
+
+[*Semantics]: Returns a new sequence, containing all the elements of `seq`, in their original order, except
+those elements with types for which `Pred` evaluates to `boost::mpl::true_`.
+Equivalent to `__filter__<boost::mpl::not_<Pred> >(seq)`.
+
+[heading Complexity]
+Constant. Returns a view which is lazily evaluated.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/transformation/remove_if.hpp>
+ #include <boost/fusion/include/remove_if.hpp>
+
+[heading Example]
+ const __vector__<int,double> vec(1,2.0);
+ assert(__remove_if__<is_floating_point<mpl::_> >(vec) == __make_vector__(1));
+
+[endsect]
+
+[section reverse]
+
+[heading Description]
+Returns a new sequence with the elements of the original in reverse order.
+
+[heading Synopsis]
+ template<
+ typename Sequence
+ >
+ typename __result_of_reverse__<Sequence const>::type reverse(Sequence const& seq);
+
+[table Parameters
+ [[Parameter][Requirement][Description]]
+ [[`seq`][A model of __bidirectional_sequence__][Operation's argument]]
+]
+
+[heading Expression Semantics]
+ __reverse__(seq);
+
+[*Return type]:
+
+* A model of __bidirectional_sequence__ if `seq` is a __bidirectional_sequence__
+else, __random_access_sequence__ if `seq` is a __random_access_sequence__.
+* A model of __associative_sequence__ if `seq` implements the __associative_sequence__ model.
+
+[*Semantics]: Returns a new sequence containing all the elements of `seq` in reverse order.
+
+[heading Complexity]
+Constant. Returns a view which is lazily evaluated.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/transformation/reverse.hpp>
+ #include <boost/fusion/include/reverse.hpp>
+
+[heading Example]
+ assert(__reverse__(__make_vector__(1,2,3)) == __make_vector__(3,2,1));
+
+[endsect]
+
+[section clear]
+
+[heading Description]
+__clear__ returns an empty sequence.
+
+[heading Synopsis]
+ template<
+ typename Sequence
+ >
+ typename __result_of_clear__<Sequence const>::type clear(Sequence const& seq);
+
+[table Parameters
+ [[Parameter][Requirement][Description]]
+ [[`seq`][A model of __forward_sequence__][Operation's argument]]
+]
+
+[heading Expression Semantics]
+ __clear__(seq);
+
+[*Return type]: A model of __forward_sequence__.
+
+[*Expression Semantics]: Returns a sequence with no elements.
+
+[heading Complexity]
+Constant.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/transformation/clear.hpp>
+ #include <boost/fusion/include/clear.hpp>
+
+[heading Example]
+ assert(__clear__(__make_vector__(1,2,3)) == __make_vector__());
+
+[endsect]
+
+[section erase]
+
+[heading Description]
+Returns a new sequence, containing all the elements of the original except those at a specified iterator, or
+between two iterators.
+
+[heading Synopsis]
+ template<
+ typename Sequence,
+ typename First
+ >
+ typename __result_of_erase__<Sequence const, First>::type erase(
+ Sequence const& seq, First const& it1);
+
+ template<
+ typename Sequence,
+ typename First,
+ typename Last
+ >
+ typename __result_of_erase__<Sequence const, First, Last>::type erase(
+ Sequence const& seq, First const& it1, Last const& it2);
+
+[table Parameters
+ [[Parameters][Requirement][Description]]
+ [[`seq`][A model of __forward_sequence__][Operation's argument]]
+ [[`it1`][A model of __forward_iterator__][Iterator into `seq`]]
+ [[`it2`][A model of __forward_iterator__][Iterator into `seq` after `it1`]]
+]
+
+[heading Expression Semantics]
+ __erase__(seq, pos);
+
+[*Return type]:
+
+* A model of __forward_sequence__.
+* A model of __associative_sequence__ if `seq` implements the __associative_sequence__ model.
+
+[*Semantics]: Returns a new sequence, containing all the elements of `seq` except the element at `pos`.
+
+ __erase__(seq, first, last);
+
+[*Return type]:
+
+* A model of __forward_sequence__.
+* A model of __associative_sequence__ if `seq` implements the __associative_sequence__ model.
+
+[*Semantics]: Returns a new sequence, with all the elements of `seq`, in their original order, except those
+in the range [`first`,`last`).
+
+[heading Complexity]
+Constant. Returns a view which is lazily evaluated.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/transformation/erase.hpp>
+ #include <boost/fusion/include/erase.hpp>
+
+[heading Example]
+ const __vector__<int, double, char> vec(1, 2.0, 'c');
+ assert(__erase__(vec, __next__(__begin__(vec))) == __make_vector__(1, 'c'));
+ assert(__erase__(vec, __next__(__begin__(vec)), __end__(vec)) == __make_vector__(1));
+
+[endsect]
+
+[section erase_key]
+
+[heading Description]
+For an [link fusion.sequence.concepts.associative_sequence associative] __forward_sequence__ `seq`,
+returns a [link fusion.sequence.concepts.associative_sequence associative] __forward_sequence__ containing
+all the elements of the original except those with a given key.
+
+[heading Synopsis]
+ template<
+ typename Key,
+ typename Sequence
+ >
+ typename __result_of_erase_key__<Sequence const, Key>::type erase_key(Sequence const& seq);
+
+[table Parameters
+ [[Parameter][Requirement][Description]]
+ [[`seq`][A model of __forward_sequence__ and __associative_sequence__][Operation's argument]]
+ [[`Key`][Any type][Key to erase]]
+]
+
+[heading Expression Semantics]
+ __erase_key__<Key>(seq);
+
+[*Return type]: A model of __forward_sequence__ and __associative_sequence__.
+
+[*Semantics]: Returns a new sequence, containing all the elements of `seq`, except those with key `Key`.
+
+[heading Complexity]
+Constant. Returns a view which is lazily evaluated.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/transformation/erase_key.hpp>
+ #include <boost/fusion/include/erase_key.hpp>
+
+[heading Example]
+ assert(__erase_key__<int>(__make_map__<int, long>('a', 'b')) == __make_map__<long>('b'));
+
+[endsect]
+
+[section insert]
+
+[heading Description]
+Returns a new sequence with all the elements of the original, an a new element inserted the
+position described by a given iterator.
+
+[heading Synopsis]
+ template<
+ typename Sequence,
+ typename Pos,
+ typename T
+ >
+ typename __result_of_insert__<Sequence const, Pos, T>::type insert(
+ Sequence const& seq, Pos const& pos, T const& t);
+
+[table Parameters
+ [[Parameter][Requirement][Description]]
+ [[`seq`][A model of __forward_sequence__][Operation's argument]]
+ [[`pos`][A model of __forward_iterator__][The position to insert at]]
+ [[`t`][Any type][The value to insert]]
+]
+
+[heading Expression Semantics]
+ __insert__(seq, pos, t);
+
+[*Return type]:
+
+* A model of __forward_sequence__.
+
+[*Semantics]: Returns a new sequence, containing all the elements of `seq`, in their original order, and a new element with the
+type and value of `t` inserted at iterator `pos`.
+
+[heading Complexity]
+Constant. Returns a view which is lazily evaluated.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/transformation/insert.hpp>
+ #include <boost/fusion/include/insert.hpp>
+
+[heading Example]
+ const __vector__<int,int> vec(1,2);
+ assert(__insert__(vec, __next__(__begin__(vec)), 3) == __make_vector__(1,3,2));
+
+[endsect]
+
+[section insert_range]
+
+[heading Description]
+Returns a new sequence with another sequence inserted at a specified iterator.
+
+[heading Synopsis]
+ template<
+ typename Sequence,
+ typename Pos,
+ typename Range
+ >
+ typename __result_of_insert_range__<Sequence const, Pos, Range>::type insert_range(
+ Sequence const& seq, Pos const& pos, Range const& range);
+
+[table Parameters
+ [[Parameter][Requirement][Description]]
+ [[`seq`][A model of __forward_sequence__][Operation's argument]]
+ [[`pos`][A model of __forward_iterator__][The position to insert at]]
+ [[`range`][A model of __forward_sequence__][Range to insert]]
+]
+
+[heading Expression Semantics]
+ __insert_range__(seq, pos, range);
+
+[*Return type]:
+
+* A model of __forward_sequence__.
+* A model of __associative_sequence__ if `seq` implements the __associative_sequence__ model.
+
+[*Semantics]: Returns a new sequence, containing all the elements of `seq`, and the elements of
+`range` inserted at iterator `pos`. All elements retaining their ordering from the original sequences.
+
+[heading Complexity]
+Constant. Returns a view which is lazily evaluated.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/transformation/insert_range.hpp>
+ #include <boost/fusion/include/insert_range.hpp>
+
+[heading Example]
+ const __vector__<int,int> vec(1,2);
+ assert(__insert_range__(vec, __next__(__begin__(vec)), __make_vector__(3,4)) == __make_vector__(1,3,4,2));
+
+[endsect]
+
+[section join]
+
+[heading Description]
+Takes 2 sequences and returns a sequence containing the elements of the first followed by the elements of the second.
+
+[heading Synopsis]
+ template<
+ typename LhSequence,
+ typename RhSequence>
+ typename __result_of_join__<LhSequence const, RhSequence const>::type join(LhSequence const& lhs, RhSequence const& rhs);
+
+[table Parameters
+ [[Parameter][Requirement][Description]]
+ [[`lhs`][A model of __forward_sequence__][Operation's argument]]
+ [[`rhs`][A model of __forward_sequence__][Operation's argument]]
+]
+
+[heading Expression Semantics]
+ __join__(lhs, rhs);
+
+[*Return type]:
+
+* A model of __forward_sequence__.
+* A model of __associative_sequence__ if `lhs` and `rhs` implement the __associative_sequence__ model.
+
+[*Semantics]: Returns a sequence containing all the elements of `lhs` followed by all the elements of `rhs`. The order of the elements is preserved.
+
+[heading Complexity]
+Constant. Returns a view which is lazily evaluated.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/transformation/join.hpp>
+ #include <boost/fusion/include/join.hpp>
+
+[heading Example]
+ __vector__<int,char> v1(1, 'a');
+ __vector__<int,char> v2(2, 'b');
+ assert(__join__(v1, v2) == __make_vector__(1,'a',2,'b'));
+
+[endsect]
+
+[section zip]
+
+[heading Description]
+Zips sequences together to form a single sequence, whose members are tuples of the members of the component sequences.
+
+[heading Synopsis]
+ template<
+ typename Sequence1,
+ typename Sequence2,
+ ...
+ typename SequenceN
+ >
+ typename __result_of_zip__<Sequence1 const, Sequence2 const, ... SequenceN const>::type
+ zip(Sequence1 const& seq1, Sequence2 const& seq2, ... SequenceN const& seqN);
+
+[table Parameters
+ [[Parameter][Requirement][Description]]
+ [[`seq1` to `seqN`][Each sequence is a model of __forward_sequence__.][Operation's argument]]
+]
+
+[heading Expression Semantics]
+ __zip__(seq1, seq2, ... seqN);
+
+[*Return type]: A model of __forward_sequence__.
+
+[*Semantics]: Returns a sequence containing tuples of elements from sequences `seq1` to `seqN`. For example, applying zip to tuples `(1, 2, 3)` and `('a', 'b', 'c')` would return `((1, 'a'),(2, 'b'),(3, 'c'))`
+
+[heading Complexity]
+Constant. Returns a view which is lazily evaluated.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/transformation/zip.hpp>
+ #include <boost/fusion/include/zip.hpp>
+
+[heading Example]
+ __vector__<int,char> v1(1, 'a');
+ __vector__<int,char> v2(2, 'b');
+ assert(__zip__(v1, v2) == __make_vector__(__make_vector__(1, 2),__make_vector__('a', 'b'));
+
+[endsect]
+
+[section pop_back]
+
+[heading Description]
+Returns a new sequence, with the last element of the original removed.
+
+[heading Synopsis]
+ template<
+ typename Sequence
+ >
+ typename __result_of_pop_back__<Sequence const>::type pop_back(Sequence const& seq);
+
+[table Parameters
+ [[Parameter][Requirement][Description]]
+ [[`seq`][A model of __forward_sequence__][Operation's argument]]
+]
+
+[heading Expression Semantics]
+ __pop_back__(seq);
+
+[*Return type]:
+
+* A model of __forward_sequence__.
+* A model of __associative_sequence__ if `seq` implements the __associative_sequence__ model.
+
+[*Semantics]: Returns a new sequence containing all the elements of `seq`, except the last element. The elements in the new sequence are in the same order as they were in `seq`.
+
+[heading Complexity]
+Constant. Returns a view which is lazily evaluated.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/transformation/pop_back.hpp>
+ #include <boost/fusion/include/pop_back.hpp>
+
+[heading Example]
+ assert(__pop_back__(__make_vector__(1,2,3)) == __make_vector__(1,2));
+
+[endsect]
+
+[section pop_front]
+
+[heading Description]
+Returns a new sequence, with the first element of the original removed.
+
+[heading Synopsis]
+ template<
+ typename Sequence
+ >
+ typename __result_of_pop_front__<Sequence const>::type pop_front(Sequence const& seq);
+
+
+[table Parameters
+ [[Parameter][Requirement][Description]]
+ [[`seq`][A model of __forward_sequence__][Operation's argument]]
+]
+
+[heading Expression Semantics]
+ __pop_front__(seq);
+
+[*Return type]:
+
+* A model of __forward_sequence__.
+* A model of __associative_sequence__ if `seq` implements the __associative_sequence__ model.
+
+[*Semantics]: Returns a new sequence containing all the elements of `seq`, except the first element. The elements in the new sequence are in the same order as they were in `seq`.
+
+[heading Complexity]
+Constant. Returns a view which is lazily evaluated.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/transformation/pop_front.hpp>
+ #include <boost/fusion/include/pop_front.hpp>
+
+[heading Example]
+ assert(__pop_front__(__make_vector__(1,2,3)) == __make_vector__(2,3));
+
+[endsect]
+
+[section push_back]
+
+[heading Description]
+Returns a new sequence with an element added at the end.
+
+[heading Synopsis]
+ template<
+ typename Sequence,
+ typename T
+ >
+ typename __result_of_push_back__<Sequence const, T>::type push_back(
+ Sequence const& seq, T const& t);
+
+[table Parameters
+ [[Parameter][Requirement][Description]]
+ [[`seq`][A model of __forward_sequence__][Operation's argument]]
+ [[`t`][Any type][The value to add to the end]]
+]
+
+[heading Expression Semantics]
+ __push_back__(seq, t);
+
+[*Return type]:
+
+* A model of __forward_sequence__.
+
+[*Semantics]: Returns a new sequence, containing all the elements of `seq`, and new element `t` appended to the end. The elements are in the same order as they were in `seq`.
+
+[heading Complexity]
+Constant. Returns a view which is lazily evaluated.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/transformation/push_back.hpp>
+ #include <boost/fusion/include/push_back.hpp>
+
+[heading Example]
+ assert(__push_back__(__make_vector__(1,2,3),4) == __make_vector__(1,2,3,4));
+
+[endsect]
+
+[section push_front]
+
+[heading Description]
+Returns a new sequence with an element added at the beginning.
+
+[heading Synopsis]
+ template<
+ typename Sequence,
+ typename T
+ >
+ typename __result_of_push_front__<Sequence const, T>::type push_front(
+ Sequence const& seq, T const& t);
+
+[table Parameters
+ [[Parameter][Requirement][Description]]
+ [[`seq`][A model of __forward_sequence__][Operation's argument]]
+ [[`t`][Any type][The value to add to the beginning]]
+]
+
+[heading Expression Semantics]
+ __push_back__(seq, t);
+
+[*Return type]:
+
+* A model of __forward_sequence__.
+
+[*Semantics]: Returns a new sequence, containing all the elements of `seq`, and new element `t` appended to the beginning. The elements are in the same order as they were in `seq`.
+
+[heading Complexity]
+Constant. Returns a view which is lazily evaluated.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/transformation/push_front.hpp>
+ #include <boost/fusion/include/push_front.hpp>
+
+[heading Example]
+ assert(__push_front__(__make_vector__(1,2,3),0) == __make_vector__(0,1,2,3));
+
+[endsect]
+
+[section flatten]
+
+[heading Description]
+Returns a new sequence without nested sequences.
+
+[heading Synopsis]
+ template<
+ typename Sequence
+ >
+ typename __result_of_flatten__<Sequence>::type flatten(Sequence& seq);
+
+ template<
+ typename Sequence
+ >
+ typename __result_of_flatten__<Sequence const>::type flatten(Sequence const& seq);
+
+[table Parameters
+ [[Parameter][Requirement][Description]]
+ [[`seq`][A model of __forward_sequence__][Operation's argument]]
+]
+
+[heading Expression Semantics]
+ __flatten__(seq);
+
+[*Return type]:
+
+* A model of __forward_sequence__.
+
+[*Semantics]: Returns a new sequence containing all the leaf elements of `seq`.
+
+[heading Complexity]
+Constant. Returns a view which is lazily evaluated.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/transformation/flatten.hpp>
+ #include <boost/fusion/include/flatten.hpp>
+
+[heading Example]
+ const __vector__<int, int, __vector__<int, int>, int> vec(1, 2, __make_vector__(3, 4), 5);
+ assert(__flatten__(vec) == __make_vector__(1, 2, 3, 4, 5)));
+
+[endsect]
+
+[endsect]
+
+[section Metafunctions]
+
+[section filter]
+
+[heading Description]
+Returns the result type of __filter__ given the sequence type and type to retain.
+
+[heading Synopsis]
+ template<
+ typename Sequence,
+ typename T
+ >
+ struct filter
+ {
+ typedef __unspecified__ type;
+ };
+
+[table Parameter
+ [[Parameter] [Requirement] [Description]]
+ [[`Sequence`][A model of __forward_sequence__] [Operation's argument]]
+ [[`T`][Any type][Type to retain]]
+]
+
+[heading Expression Semantics]
+ __result_of_filter__<Sequence, T>::type
+
+[*Return type]:
+
+* A model of __forward_sequence__.
+* A model of __associative_sequence__ if `Sequence` implements the __associative_sequence__ model.
+
+[*Semantics]: Returns a sequence containing the elements of `Sequence` that are of type `T`. Equivalent to `__result_of_filter_if__<Sequence, boost::is_same<mpl::_, T> >::type`.
+
+[heading Complexity]
+Constant.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/transformation/filter.hpp>
+ #include <boost/fusion/include/filter.hpp>
+
+[endsect]
+
+[section filter_if]
+
+[heading Description]
+Returns the result type of __filter_if__ given the sequence and unary __mpl_lambda_expression__ predicate type.
+
+[heading Synopsis]
+ template<
+ typename Sequence,
+ typename Pred
+ >
+ struct filter_if
+ {
+ typedef __unspecified__ type;
+ };
+
+[table Parameter
+ [[Parameter] [Requirement] [Description]]
+ [[`Sequence`][A model of __forward_sequence__] [Operation's argument]]
+ [[`Pred`][A unary __mpl_lambda_expression__][Type to retain]]
+]
+
+[heading Expression Semantics]
+ __result_of_filter_if__<Sequence, Pred>::type
+
+[*Return type]:
+
+* A model of __forward_sequence__.
+* A model of __associative_sequence__ if `Sequence` implements the __associative_sequence__ model.
+
+[*Semantics]: Returns a sequence containing the elements of `Sequence` for which `Pred` evaluates to `boost::mpl::true_`.
+
+[heading Complexity]
+Constant.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/transformation/filter_if.hpp>
+ #include <boost/fusion/include/filter_if.hpp>
+
+[endsect]
+
+[section transform]
+
+[heading Description]
+Returns the result type of __transform__, given the types of the input sequence and unary __poly_func_obj__.
+
+[heading Unary version synopsis]
+ template<
+ typename Sequence,
+ typename F
+ >
+ struct transform
+ {
+ typedef __unspecified__ type;
+ };
+
+[table Parameters
+ [[Parameter][Requirement][Description]]
+ [[`Sequence`][A model of __forward_sequence__][Operation's argument]]
+ [[`F`][A model of unary __poly_func_obj__][Transformation metafunction]]
+]
+
+[heading Expression Semantics]
+ __result_of_transform__<Sequence, F>::type
+
+[*Return type]:
+
+* A model of __forward_sequence__
+* A model of __associative_sequence__ if `Sequence` implements the __associative_sequence__ model.
+
+[*Semantics]: Returns a sequence that contains the types of `__result_of__<F(E)>::type` for each element `E` within `Sequence`.
+
+[heading Binary version synopsis]
+ template<
+ typename Sequence1,
+ typename Sequence2,
+ typename F
+ >
+ struct transform
+ {
+ typedef __unspecified__ type;
+ };
+
+[table Parameters
+ [[Parameter][Requirement][Description]]
+ [[`Sequence1`][A model of __forward_sequence__][Operation's argument]]
+ [[`Sequence2`][A model of __forward_sequence__][Operation's argument]]
+ [[`F`][A model of binary __poly_func_obj__][Transformation metafunction]]
+]
+
+[heading Expression Semantics]
+ __result_of_transform__<Sequence1, Sequence2, F>::type
+
+[*Return type]: A model of __forward_sequence__.
+
+[*Semantics]: Returns a sequence, that contains the types of `__result_of__<F(E1, E2)>::type` for each pair of elements `E1` and `E2` within `Sequence1` and `Sequence2` respectively.
+
+[heading Complexity]
+Constant.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/transformation/transform.hpp>
+ #include <boost/fusion/include/transform.hpp>
+
+[endsect]
+
+[section replace]
+
+[heading Description]
+Returns the result type of __replace__, given the types of the input sequence and element to replace.
+
+[heading Synopsis]
+ template<
+ typename Sequence,
+ typename T
+ >
+ struct replace
+ {
+ typedef __unspecified__ type;
+ };
+
+[table Parameters
+ [[Parameter][Requirement][Description]]
+ [[`Sequence`][A model of __forward_sequence__][Operation's argument]]
+ [[`T`][Any type][The type of the search and replacement objects]]
+]
+
+[heading Expression Semantics]
+ __result_of_replace__<Sequence,T>::type
+
+[*Return type]: A model of __forward_sequence__.
+
+[*Semantics]: Returns the return type of __replace__.
+
+[heading Complexity]
+Constant.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/transformation/replace.hpp>
+ #include <boost/fusion/include/replace.hpp>
+
+[endsect]
+
+[section replace_if]
+
+[heading Description]
+Returns the result type of __replace_if__, given the types of the sequence, unary __mpl_lambda_expression__ predicate and replacement object.
+
+[heading Synopsis]
+ template<
+ typename Sequence,
+ typename F,
+ typename T>
+ struct replace_if
+ {
+ typedef __unspecified__ type;
+ };
+
+[table Parameters
+ [[Parameter][Requirement][Description]]
+ [[`Sequence`][A model of __forward_sequence__][Operation's argument]]
+ [[`F`][A model of unary __mpl_lambda_expression__][Replacement predicate]]
+ [[`T`][Any type][The type of the replacement object]]
+]
+
+[heading Expression Semantics]
+ __result_of_replace_if__<Sequence,F,T>::type
+
+[*Return type]: A model of __forward_sequence__.
+
+[*Semantics]: Returns the return type of __replace_if__.
+
+[heading Complexity]
+Constant.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/transformation/replace_if.hpp>
+ #include <boost/fusion/include/replace_if.hpp>
+
+[endsect]
+
+[section remove]
+
+[heading Description]
+Returns the result type of __remove__, given the sequence and removal types.
+
+[heading Synopsis]
+ template<
+ typename Sequence,
+ typename T
+ >
+ struct remove
+ {
+ typedef __unspecified__ type;
+ };
+
+[table Parameters
+ [[Parameter][Requirement][Description]]
+ [[`Sequence`][A model of __forward_sequence__][Operation's argument]]
+ [[`T`][Any type][Remove elements of this type]]
+]
+
+[heading Expression Semantics]
+ __result_of_remove__<Sequence, T>::type
+
+[*Return type]:
+
+* A model of __forward_sequence__.
+* A model of __associative_sequence__ if `Sequence` implements the __associative_sequence__ model.
+
+[*Semantics]: Returns a sequence containing the elements of `Sequence` not of type `T`. Equivalent to `__result_of_remove_if__<Sequence, boost::is_same<mpl::_, T> >::type`.
+
+[heading Complexity]
+Constant.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/transformation/remove.hpp>
+ #include <boost/fusion/include/remove.hpp>
+
+[endsect]
+
+[section remove_if]
+
+[heading Description]
+Returns the result type of __remove_if__, given the input sequence and unary __mpl_lambda_expression__ predicate types.
+
+[heading Synopsis]
+ template<
+ typename Sequence,
+ typename Pred
+ >
+ struct remove_if
+ {
+ typedef __unspecified__ type;
+ };
+
+[table Parameters
+ [[Parameter][Requirement][Description]]
+ [[`Sequence`][A model of __forward_sequence__][Operation's argument]]
+ [[`Pred`][A model of unary __mpl_lambda_expression__][Remove elements which evaluate to `boost::mpl::true_`]]
+]
+
+[heading Expression Semantics]
+ __result_of_remove_if__<Sequence, Pred>::type
+
+[*Return type]:
+
+* A model of __forward_sequence__.
+* A model of __associative_sequence__ if `Sequence` implements the __associative_sequence__ model.
+
+[*Semantics]: Returns a sequence containing the elements of `Sequence` for which `Pred` evaluates to `boost::mpl::false_`.
+
+[heading Complexity]
+Constant.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/transformation/remove_if.hpp>
+ #include <boost/fusion/include/remove_if.hpp>
+
+[endsect]
+
+[section reverse]
+
+[heading Description]
+Returns the result type of __reverse__, given the input sequence type.
+
+[heading Synopsis]
+ template<
+ typename Sequence
+ >
+ struct reverse
+ {
+ typedef __unspecified__ type;
+ };
+
+[table Parameters
+ [[Parameter][Requirement][Description]]
+ [[`Sequence`][A model of __bidirectional_sequence__][Operation's argument]]
+]
+
+[heading Expression Semantics]
+ __result_of_reverse__<Sequence>::type
+
+[*Return type]:
+
+* A model of __bidirectional_sequence__ if `Sequence` is a __bidirectional_sequence__
+else, __random_access_sequence__ if `Sequence` is a __random_access_sequence__.
+* A model of __associative_sequence__ if `Sequence` implements the __associative_sequence__ model.
+
+[*Semantics]: Returns a sequence with the elements in the reverse order to `Sequence`.
+
+[heading Complexity]
+Constant.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/transformation/reverse.hpp>
+ #include <boost/fusion/include/reverse.hpp>
+
+[endsect]
+
+[section clear]
+
+[heading Description]
+Returns the result type of __clear__, given the input sequence type.
+
+[heading Synopsis]
+ template<
+ typename Sequence
+ >
+ struct clear
+ {
+ typedef __unspecified__ type;
+ };
+
+[table Parameters
+ [[Parameter][Requirement][Description]]
+ [[`Sequence`][Any type][Operation's argument]]
+]
+
+[heading Expression Semantics]
+ __result_of_clear__<Sequence>::type
+
+[*Return type]: A model of __forward_sequence__.
+
+[*Semantics]: Returns an empty sequence.
+
+[heading Complexity]
+Constant.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/transformation/clear.hpp>
+ #include <boost/fusion/include/clear.hpp>
+
+[endsect]
+
+[section erase]
+Returns the result type of __erase__, given the input sequence and range delimiting iterator types.
+
+[heading Description]
+
+[heading Synopsis]
+ template<
+ typename Sequence,
+ typename It1,
+ typename It2 = __unspecified__>
+ struct erase
+ {
+ typedef __unspecified__ type;
+ };
+
+[table Parameters
+ [[Parameter][Requirement][Description]]
+ [[`Sequence`][A model of __forward_sequence__][Operation's argument]]
+ [[`It1`][A model of __forward_iterator__][Operation's argument]]
+ [[`It2`][A model of __forward_iterator__][Operation's argument]]
+]
+
+[heading Expression Semantics]
+ __result_of_erase__<Sequence, It1>::type
+
+[*Return type]:
+
+* A model of __forward_sequence__.
+* A model of __associative_sequence__ if `Sequence` implements the __associative_sequence__ model.
+
+[*Semantics]: Returns a new sequence with the element at `It1` removed.
+
+ __result_of_erase__<Sequence, It1, It2>::type
+
+[*Return type]: A model of __forward_sequence__.
+
+[*Semantics]: Returns a new sequence with the elements between `It1` and `It2` removed.
+
+[heading Complexity]
+Constant.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/transformation/erase.hpp>
+ #include <boost/fusion/include/erase.hpp>
+
+[endsect]
+
+[section erase_key]
+
+[heading Description]
+Returns the result type of __erase_key__, given the sequence and key types.
+
+[heading Synopsis]
+ template<
+ typename Sequence,
+ typename Key
+ >
+ struct erase_key
+ {
+ typedef __unspecified__ type;
+ };
+
+[table Parameters
+ [[Parameter][Requirement][Description]]
+ [[`Sequence`][A model of __forward_sequence__ and __associative_sequence__][Operation's argument]]
+ [[`Key`][Any type][Key type]]
+]
+
+[heading Expression Semantics]
+ __result_of_erase_key__<Sequence, Key>::type
+
+[*Return type]: A model of __forward_sequence__ and __associative_sequence__.
+
+[*Semantics]: Returns a sequence with the elements of `Sequence`, except those with key `Key`.
+
+[heading Complexity]
+Constant.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/transformation/erase_key.hpp>
+ #include <boost/fusion/include/erase_key.hpp>
+
+[endsect]
+
+[section insert]
+
+[heading Description]
+Returns the result type of __insert__, given the sequence, position iterator and insertion types.
+
+[heading Synopsis]
+ template<
+ typename Sequence,
+ typename Position,
+ typename T
+ >
+ struct insert
+ {
+ typedef __unspecified__ type;
+ };
+
+[table Parameters
+ [[Parameter][Requirement][Description]]
+ [[`Sequence`][A model of __forward_sequence__][Operation's argument]]
+ [[`Position`][A model of __forward_iterator__][Operation's argument]]
+ [[`T`][Any type][Operation's argument]]
+]
+
+[heading Expression Semantics]
+ __result_of_insert__<Sequence, Position, T>::type
+
+[*Return type]:
+
+* A model of __forward_sequence__.
+
+[*Semantics]: Returns a sequence with an element of type `T` inserted at position `Position` in `Sequence`.
+
+[heading Complexity]
+Constant.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/transformation/insert.hpp>
+ #include <boost/fusion/include/insert.hpp>
+
+[endsect]
+
+[section insert_range]
+
+[heading Description]
+Returns the result type of __insert_range__, given the input sequence, position iterator and insertion range types.
+
+[heading Synopsis]
+ template<
+ typename Sequence,
+ typename Position,
+ typename Range
+ >
+ struct insert_range
+ {
+ typedef __unspecified__ type;
+ };
+
+[table Parameters
+ [[Parameter][Requirement][Description]]
+ [[`Sequence`][A model of __forward_sequence__][Operation's argument]]
+ [[`Position`][A model of __forward_iterator__][Operation's argument]]
+ [[`Range`][A model of __forward_sequence__][Operation's argument]]
+]
+
+[heading Expression Semantics]
+ __result_of_insert_range__<Sequence, Position, Range>::type
+
+[*Return type]:
+
+* A model of __forward_sequence__.
+* A model of __associative_sequence__ if `Sequence` implements the __associative_sequence__ model.
+
+[*Semantics]: Returns a sequence with the elements of `Range` inserted at position `Position` into `Sequence`.
+
+[heading Complexity]
+Constant.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/transformation/insert_range.hpp>
+ #include <boost/fusion/include/insert_range.hpp>
+
+[endsect]
+
+[section join]
+
+[heading Description]
+Returns the result of joining 2 sequences, given the sequence types.
+
+[heading Synopsis]
+ template<
+ typename LhSequence,
+ typename RhSequence
+ >
+ struct join
+ {
+ typedef __unspecified__ type;
+ };
+
+[heading Expression Semantics]
+ __result_of_join__<LhSequence, RhSequence>::type
+
+[*Return type]:
+
+* A model of __forward_sequence__.
+* A model of __associative_sequence__ if `LhSequence` and `RhSequence` implement the __associative_sequence__ model.
+
+[*Semantics]: Returns a sequence containing the elements of `LhSequence` followed by the elements of `RhSequence`. The order of the elements in the 2 sequences is preserved.
+
+[heading Complexity]
+Constant.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/transformation/join.hpp>
+ #include <boost/fusion/include/join.hpp>
+
+[endsect]
+
+[section zip]
+
+[heading Description]
+Zips sequences together to form a single sequence, whose members are tuples of the members of the component sequences.
+
+[heading Synopsis]
+ template<
+ typename Sequence1,
+ typename Sequence2,
+ ...
+ typename SequenceN
+ >
+ struct zip
+ {
+ typedef __unspecified__ type;
+ };
+
+[heading Expression Semantics]
+ __result_of_zip__<Sequence1, Sequence2, ... SequenceN>::type
+
+[*Return type]: A model of the most restrictive traversal category of sequences `Sequence1` to `SequenceN`.
+
+[*Semantics]: Return a sequence containing tuples of elements from each sequence. For example, applying zip to tuples `(1, 2, 3)` and `('a', 'b', 'c')` would return `((1, 'a'),(2, 'b'),(3, 'c'))`
+
+[heading Complexity]
+Constant.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/transformation/zip.hpp>
+ #include <boost/fusion/include/zip.hpp>
+
+[endsect]
+
+[section pop_back]
+
+[heading Description]
+Returns the result type of __pop_back__, given the input sequence type.
+
+[heading Synopsis]
+ template<
+ typename Sequence
+ >
+ struct pop_back
+ {
+ typedef __unspecified__ type;
+ };
+
+[table Parameters
+ [[Parameter][Requirement][Description]]
+ [[`Sequence`][A model of __forward_sequence__][Operation's argument]]
+]
+
+[heading Expression Semantics]
+ __result_of_pop_back__<Sequence>::type
+
+[*Return type]:
+
+* A model of __forward_sequence__.
+* A model of __associative_sequence__ if `Sequence` implements the __associative_sequence__ model.
+
+[*Semantics]: Returns a sequence with all the elements of `Sequence` except the last element.
+
+[heading Complexity]
+Constant.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/transformation/pop_back.hpp>
+ #include <boost/fusion/include/pop_back.hpp>
+
+[endsect]
+
+[section pop_front]
+
+[heading Description]
+Returns the result type of __pop_front__, given the input sequence type.
+
+[heading Synopsis]
+ template<
+ typename Sequence
+ >
+ struct pop_front
+ {
+ typedef __unspecified__ type;
+ };
+
+[table Parameters
+ [[Parameter][Requirement][Description]]
+ [[`Sequence`][A model of __forward_sequence__][Operation's argument]]
+]
+
+[heading Expression Semantics]
+ __result_of_pop_front__<Sequence>::type
+
+[*Return type]:
+
+* A model of __forward_sequence__.
+* A model of __associative_sequence__ if `Sequence` implements the __associative_sequence__ model.
+
+[*Semantics]: Returns a sequence with all the elements of `Sequence` except the first element.
+
+[heading Complexity]
+Constant.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/transformation/pop_front.hpp>
+ #include <boost/fusion/include/pop_front.hpp>
+
+[endsect]
+
+[section push_back]
+
+[heading Description]
+Returns the result type of __push_back__, given the types of the input sequence and element to push.
+
+[heading Synopsis]
+ template<
+ typename Sequence,
+ typename T
+ >
+ struct push_back
+ {
+ typedef __unspecified__ type;
+ };
+
+[table Parameters
+ [[Parameter][Requirement][Description]]
+ [[`Sequence`][A model of __forward_sequence__][Operation's argument]]
+ [[`T`][Any type][Operation's argument]]
+]
+
+[heading Expression Semantics]
+ __result_of_push_back__<Sequence, T>::type
+
+[*Return type]:
+
+* A model of __forward_sequence__.
+
+[*Semantics]: Returns a sequence with the elements of `Sequence` and an element of type `T` added to the end.
+
+[heading Complexity]
+Constant.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/transformation/push_back.hpp>
+ #include <boost/fusion/include/push_back.hpp>
+
+[endsect]
+
+[section push_front]
+
+[heading Description]
+Returns the result type of __push_front__, given the types of the input sequence and element to push.
+
+[heading Synopsis]
+ template<
+ typename Sequence,
+ typename T
+ >
+ struct push_front
+ {
+ typedef __unspecified__ type;
+ };
+
+[table Parameters
+ [[Parameter][Requirement][Description]]
+ [[`Sequence`][A model of __forward_sequence__][Operation's argument]]
+ [[`T`][Any type][Operation's argument]]
+]
+
+[heading Expression Semantics]
+ __result_of_push_front__<Sequence, T>::type
+
+[*Return type]:
+
+* A model of __forward_sequence__.
+
+[*Semantics]: Returns a sequence with the elements of `Sequence` and an element of type `T` added to the beginning.
+
+[heading Complexity]
+Constant.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/transformation/push_front.hpp>
+ #include <boost/fusion/include/push_front.hpp>
+
+[endsect]
+
+[section flatten]
+
+[heading Description]
+Returns the result type of __flatten__, given the input sequence type.
+
+[heading Synopsis]
+ template<
+ typename Sequence
+ >
+ struct flatten
+ {
+ typedef __unspecified__ type;
+ };
+
+[table Parameters
+ [[Parameter][Requirement][Description]]
+ [[`Sequence`][A model of __forward_sequence__][Operation's argument]]
+]
+
+[heading Expression Semantics]
+ __result_of_flatten__<Sequence>::type
+
+[*Return type]:
+
+* A model of __forward_sequence__.
+
+[*Semantics]: Returns a sequence with all the leaf elements of `Sequence`.
+
+[heading Complexity]
+Constant.
+
+[heading Header]
+
+ #include <boost/fusion/algorithm/transformation/flatten.hpp>
+ #include <boost/fusion/include/flatten.hpp>
+
+[endsect]
+
+[endsect]
+
+[endsect]
+
+[endsect]
diff --git a/doc/changelog.qbk b/doc/changelog.qbk
new file mode 100644
index 0000000..e9ee256
--- /dev/null
+++ b/doc/changelog.qbk
@@ -0,0 +1,52 @@
+[/==============================================================================
+ Copyright (C) 2001-2011 Joel de Guzman
+ Copyright (C) 2006 Dan Marsden
+ Copyright (C) 2006 Tobias Schwinger
+ Copyright (C) 2010 Christopher Schmidt
+
+ 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 Change log]
+
+This section summarizes significant changes to the Fusion library.
+
+* Sep 27, 2006: Added `boost::tuple` support. (Joel de Guzman)
+* Nov 17, 2006: Added `boost::variant` support. (Joel de Guzman)
+* Feb 15, 2007: Added functional module. (Tobias Schwinger)
+* April 2, 2007: Added struct adapter. (Joel de Guzman)
+* May 8, 2007: Added associative struct adapter. (Dan Marsden)
+* Dec 20, 2007: Removed `boost::variant` support. After thorough
+ investigation, I think now that the move to make variant a
+ fusion sequence is rather quirky. A variant will always
+ have a size==1 regardless of the number of types it can contain
+ and there's no way to know at compile time what it contains.
+ Iterating over its types is simply wrong. All these imply that
+ the variant is *not* a fusion sequence. (Joel de Guzman)
+* Oct 12, 2009: The accumulator is the first argument to the functor of
+ __fold__ and __accumulate__. (Christopher Schmidt)
+* Oct 30, 2009: Added support for associative iterators and views. (Christopher
+ Schmidt)
+* March 1, 2010: Added __adapt_struct_named__ and __adapt_struct_named_ns__
+ (Hartmut Kaiser)
+* April 4, 2010: Added __array__ support, __adapt_tpl_struct__,
+ __adapt_assoc_tpl_struct__, __adapt_assoc_struct_named__ and
+ __adapt_assoc_struct_named_ns__ (Christopher Schmidt)
+* April 5, 2010: Added __define_struct__, __define_tpl_struct__,
+ __define_assoc_struct__ and __define_assoc_tpl_struct__ (Christopher Schmidt)
+* June 18, 2010: Added __reverse_fold__, __iter_fold__ and __reverse_iter_fold__
+ (Christopher Schmidt)
+* October 7, 2010: Added __adapt_adt__, __adapt_tpl_adt__,
+ __adapt_assoc_adt__ and __adapt_assoc_tpl_adt__ (Joel de Guzman,
+ Hartmut Kaiser and Christopher Schmidt)
+* August 29, 2011: Added support for segmented sequences and iterators (Eric Niebler)
+* September 16, 2011: Added preprocessed files (using wave) to speed up
+ compilation (Joel de Guzman)
+* October 8, 2011: Added adaptor for std::tuple (Joel de Guzman)
+* October 10, 2011: Made map random access (Brandon Kohn)
+* April 7, 2012: Added C++11 version of deque
+* May 19, 2012: Added BOOST_FUSION_DEFINE_STRUCT_INLINE by Nathan Ridge
+* September 1, 2012: Added move support for deque and vector
+
+[endsect]
diff --git a/doc/container.qbk b/doc/container.qbk
new file mode 100644
index 0000000..fccd210
--- /dev/null
+++ b/doc/container.qbk
@@ -0,0 +1,2247 @@
+[/==============================================================================
+ 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 non-const 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]
diff --git a/doc/extension.qbk b/doc/extension.qbk
new file mode 100644
index 0000000..21ebd84
--- /dev/null
+++ b/doc/extension.qbk
@@ -0,0 +1,490 @@
+[/==============================================================================
+ 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 Extension]
+
+[section:ext_full The Full Extension Mechanism]
+
+The Fusion library is designed to be extensible, new sequences types can easily
+be added. In fact, the library support for `std::pair`, `boost::array` and __mpl__
+sequences is entirely provided using the extension mechanism.
+
+The process for adding a new sequence type to Fusion is:
+
+# Enable the __tag_dispatching__ mechanism used by Fusion for your sequence type
+# Design an iterator type for the sequence
+# Provide specialized behaviour for the intrinsic operations of the new Fusion sequence
+
+[heading Our example]
+
+In order to illustrate enabling a new sequence type for use with Fusion, we
+are going to use the type:
+
+ namespace example
+ {
+ struct example_struct
+ {
+ std::string name;
+ int age;
+ example_struct(
+ const std::string& n,
+ int a)
+ : name(n), age(a)
+ {}
+ };
+ }
+
+We are going to pretend that this type has been provided by a 3rd party
+library, and therefore cannot be modified. We shall work through all the
+necessary steps to enable `example_struct` to serve as an __associative_sequence__
+as described in the __quick_start__ guide.
+
+[heading Enabling Tag Dispatching]
+
+The Fusion extensibility mechanism uses __tag_dispatching__ to call the
+correct code for a given sequence type. In order to exploit the tag
+dispatching mechanism we must first declare a new tag type for the
+mechanism to use. For example:
+
+ namespace example {
+ struct example_sequence_tag; // Only definition needed
+ }
+
+Next we need to enable the `traits::tag_of` metafunction to return our newly chosen
+tag type for operations involving our sequence. This is done by specializing
+`traits::tag_of` for our sequence type.
+
+ #include <boost/fusion/support/tag_of_fwd.hpp>
+ #include <boost/fusion/include/tag_of_fwd.hpp>
+
+ namespace boost { namespace fusion { namespace traits {
+ template<>
+ struct tag_of<example_struct>
+ {
+ typedef example::example_sequence_tag type;
+ };
+ }}}
+
+`traits::tag_of` also has a second template argument,
+that can be used in conjunction with `boost::enable_if` to provide tag
+support for groups of related types. This feature is not necessary
+for our sequence, but for an example see the code in:
+
+ #include <boost/fusion/adapted/array/tag_of.hpp>
+ #include <boost/fusion/include/tag_of.hpp>
+
+[heading Designing a suitable iterator]
+
+We need an iterator to describe positions, and provide access to
+the data within our sequence. As it is straightforward to do,
+we are going to provide a random access iterator in our example.
+
+We will use a simple design, in which the 2 members of
+`example_struct` are given numbered indices, 0 for `name` and
+1 for `age` respectively.
+
+ template<typename Struct, int Pos>
+ struct example_struct_iterator
+ : boost::fusion::iterator_base<example_struct_iterator<Struct, Pos> >
+ {
+ BOOST_STATIC_ASSERT(Pos >=0 && Pos < 3);
+ typedef Struct struct_type;
+ typedef boost::mpl::int_<Pos> index;
+ typedef boost::fusion::random_access_traversal_tag category;
+
+ example_struct_iterator(Struct& str)
+ : struct_(str) {}
+
+ Struct& struct_;
+ };
+
+A quick summary of the details of our iterator:
+
+# The iterator is parameterized by the type it is iterating over, and the index of the current element.
+# The typedefs `struct_type` and `index` provide convenient access to information we will need later in
+ the implementation.
+# The typedef `category` allows the `traits::__category_of__` metafunction to establish
+ the traversal category of the iterator.
+# The constructor stores a reference to the `example_struct` being iterated over.
+
+We also need to enable __tag_dispatching__ for our iterator type, with another specialization of
+`traits::tag_of`.
+
+In isolation, the iterator implementation is pretty dry. Things should become clearer as we
+add features to our implementation.
+
+[heading A first couple of instructive features]
+
+To start with, we will get the __result_of_value_of__ metafunction working. To
+do this, we provide a specialization of the `boost::fusion::extension::value_of_impl` template for
+our iterator's tag type.
+
+ template<>
+ struct value_of_impl<example::example_struct_iterator_tag>
+ {
+ template<typename Iterator>
+ struct apply;
+
+ template<typename Struct>
+ struct apply<example::example_struct_iterator<Struct, 0> >
+ {
+ typedef std::string type;
+ };
+
+ template<typename Struct>
+ struct apply<example::example_struct_iterator<Struct, 1> >
+ {
+ typedef int type;
+ };
+ };
+
+The implementation itself is pretty simple, it just uses 2 partial specializations to
+provide the type of the 2 different members of `example_struct`, based on the index of the iterator.
+
+To understand how `value_of_impl` is used by the library we will look at the implementation of __result_of_value_of__:
+
+ template <typename Iterator>
+ struct value_of
+ : extension::value_of_impl<typename detail::tag_of<Iterator>::type>::
+ template apply<Iterator>
+ {};
+
+So __result_of_value_of__ uses __tag_dispatching__ to select an __mpl_metafunction_class__
+to provide its functionality. You will notice this pattern throughout the
+implementation of Fusion.
+
+Ok, lets enable dereferencing of our iterator. In this case we must provide a suitable
+specialization of `deref_impl`.
+
+ template<>
+ struct deref_impl<example::example_struct_iterator_tag>
+ {
+ template<typename Iterator>
+ struct apply;
+
+ template<typename Struct>
+ struct apply<example::example_struct_iterator<Struct, 0> >
+ {
+ typedef typename mpl::if_<
+ is_const<Struct>, std::string const&, std::string&>::type type;
+
+ static type
+ call(example::example_struct_iterator<Struct, 0> const& it)
+ {
+ return it.struct_.name;
+ }
+ };
+
+ template<typename Struct>
+ struct apply<example::example_struct_iterator<Struct, 1> >
+ {
+ typedef typename mpl::if_<
+ is_const<Struct>, int const&, int&>::type type;
+
+ static type
+ call(example::example_struct_iterator<Struct, 1> const& it)
+ {
+ return it.struct_.age;
+ }
+ };
+ };
+ }
+
+The use of `deref_impl` is very similar to that of `value_of_impl`, but it also
+provides some runtime functionality this time via the `call` static member function.
+To see how `deref_impl` is used, lets have a look at the implementation of __deref__:
+
+ namespace result_of
+ {
+ template <typename Iterator>
+ struct __deref__
+ : extension::deref_impl<typename detail::tag_of<Iterator>::type>::
+ template apply<Iterator>
+ {};
+ }
+
+ template <typename Iterator>
+ typename result_of::deref<Iterator>::type
+ __deref__(Iterator const& i)
+ {
+ typedef result_of::deref<Iterator> deref_meta;
+ return deref_meta::call(i);
+ }
+
+So again __result_of_deref__ uses __tag_dispatching__ in exactly the
+same way as the __result_of_value_of__ implementation. The runtime functionality used
+by __deref__ is provided by the `call` static function of the selected
+__mpl_metafunction_class__.
+
+The actual implementation of `deref_impl` is slightly more complex than that of `value_of_impl`.
+We also need to implement the `call` function, which returns a reference
+to the appropriate member of the underlying sequence. We also require a little
+bit of metaprogramming to return `const` references if the underlying sequence
+is const.
+
+[note Although there is a fair amount of left to do to produce a fully fledged
+Fusion sequence, __result_of_value_of__ and __deref__ illustrate all the significant concepts
+required. The remainder of the process is very repetitive, simply requiring
+implementation of a suitable `xxxx_impl` for each feature `xxxx`.
+]
+
+[heading Implementing the remaining iterator functionality]
+
+Ok, now we have seen the way __result_of_value_of__ and __deref__ work, everything else will work
+ in pretty much the same way. Lets start with forward iteration,
+by providing a `next_impl`:
+
+ template<>
+ struct next_impl<example::example_struct_iterator_tag>
+ {
+ template<typename Iterator>
+ struct apply
+ {
+ typedef typename Iterator::struct_type struct_type;
+ typedef typename Iterator::index index;
+ typedef example::example_struct_iterator<struct_type, index::value + 1> type;
+
+ static type
+ call(Iterator const& i)
+ {
+ return type(i.struct_);
+ }
+ };
+ };
+
+This should be very familiar from our `deref_impl` implementation, we will be
+using this approach again and again now. Our design is simply to increment
+the `index` counter to move on to the next element. The various other iterator
+manipulations we need to perform will all just involve simple calculations
+with the `index` variables.
+
+We also need to provide a suitable `equal_to_impl` so that iterators can be
+correctly compared. A __bidirectional_iterator__ will also need an implementation of `prior_impl`. For a
+__random_access_iterator__ `distance_impl` and `advance_impl` also need to be provided
+in order to satisfy the necessary complexity guarantees. As our iterator is
+a __random_access_iterator__ we will have to implement all of these functions.
+
+Full implementations of `prior_impl`, `advance_impl`, `distance_impl` and `equal_to_impl` are
+provided in the example code.
+
+[heading Implementing the intrinsic functions of the sequence]
+
+In order that Fusion can correctly identify our sequence as a Fusion sequence, we
+need to enable `is_sequence` for our sequence type. As usual we just create
+an `impl` type specialized for our sequence tag:
+
+ template<>
+ struct is_sequence_impl<example::example_sequence_tag>
+ {
+ template<typename T>
+ struct apply : mpl::true_ {};
+ };
+
+We've some similar formalities to complete, providing `category_of_impl` so Fusion
+can correctly identify our sequence type, and `is_view_impl` so Fusion can correctly
+identify our sequence as not being a __view__ type. Implementations are
+provide in the example code.
+
+Now we've completed some formalities, on to more interesting features. Lets get
+__begin__ working so that we can get an iterator to start accessing the data in
+our sequence.
+
+ template<>
+ struct begin_impl<example::example_sequence_tag>
+ {
+ template<typename Sequence>
+ struct apply
+ {
+ typedef example::example_struct_iterator<Sequence, 0> type;
+
+ static type
+ call(Sequence& seq)
+ {
+ return type(seq);
+ }
+ };
+ };
+
+The implementation uses the same ideas we have applied throughout, in this case
+we are just creating one of the iterators we developed earlier, pointing to the
+first element in the sequence. The implementation of __end__ is very similar, and
+is provided in the example code.
+
+For our __random_access_sequence__ we will also need to implement `size_impl`,
+`value_at_impl` and `at_impl`.
+
+[heading Enabling our type as an associative sequence]
+
+In order for `example_struct` to serve as an associative forward sequence,
+we need to adapt the traversal category of our sequence and our iterator
+accordingly and enable 3 intrinsic sequence lookup features, __at_key__,
+__result_of_value_at_key__ and __has_key__. We also need to enable 3 iterator lookup
+features, __result_of_key_of__, __result_of_value_of_data__ and __deref_data__.
+
+To implement `at_key_impl` we need to associate the `fields::name` and `fields::age`
+types described in the __quick_start__ guide with the appropriate members of `example_struct`.
+Our implementation is as follows:
+
+ template<>
+ struct at_key_impl<example::example_sequence_tag>
+ {
+ template<typename Sequence, typename Key>
+ struct apply;
+
+ template<typename Sequence>
+ struct apply<Sequence, fields::name>
+ {
+ typedef typename mpl::if_<
+ is_const<Sequence>,
+ std::string const&,
+ std::string&>::type type;
+
+ static type
+ call(Sequence& seq)
+ {
+ return seq.name;
+ };
+ };
+
+ template<typename Sequence>
+ struct apply<Sequence, fields::age>
+ {
+ typedef typename mpl::if_<
+ is_const<Sequence>,
+ int const&,
+ int&>::type type;
+
+ static type
+ call(Sequence& seq)
+ {
+ return seq.age;
+ };
+ };
+ };
+
+Its all very similar to the implementations we've seen previously,
+such as `deref_impl` and `value_of_impl`. Instead of identifying
+the members by index or position, we are now selecting them using
+the types `fields::name` and `fields::age`. The implementations of
+the other functions are equally straightforward, and are provided in
+the example code.
+
+[heading Summary]
+
+We've now worked through the entire process for adding a new random
+access sequence and we've also enabled our type to serve as an associative
+sequence. The implementation was slightly long-winded, but followed
+a simple repeating pattern.
+
+The support for `std::pair`, __mpl__ sequences, and `boost::array` all
+use the same approach, and provide additional examples of the approach
+for a variety of types.
+
+[endsect]
+
+[section Sequence Facade]
+
+[heading Description]
+The __sequence_facade__ template provides an intrusive mechanism for
+producing a conforming Fusion sequence.
+
+[heading Synopsis]
+ template<typename Derived, typename TravesalTag, typename IsView = mpl::false_>
+ struct sequence_facade;
+
+[heading Usage]
+The user of __sequence_facade__ derives his sequence type from a specialization of __sequence_facade__ and passes the derived sequence type as the first template parameter. The second template parameter should be the traversal category of the sequence being implemented. The 3rd parameter should be set to `mpl::true_` if the sequence is a view.
+
+The user must implement the key expressions required by their sequence type.
+
+[table Parameters
+[[Name][Description]]
+[[`sequence`, `Seq`][A type derived from __sequence_facade__]]
+[[`N`][An __mpl_integral_constant__]]
+]
+
+[table Key Expressions
+[[Expression][Result]]
+[[`sequence::template begin<Seq>::type`][The type of an iterator to the beginning of a sequence of type `Seq`]]
+[[`sequence::template begin<Seq>::call(seq)`][An iterator to the beginning of sequence `seq`]]
+[[`sequence::template end<Seq>::type`][The type of an iterator to the end of a sequence of type `Seq`]]
+[[`sequence::template end<Seq>::call(seq)`][An iterator to the end of sequence `seq`]]
+[[`sequence::template size<Seq>::type`][The size of a sequence of type `Seq` as an __mpl_integral_constant__]]
+[[`sequence::template size<Seq>::call(seq)`][The size of sequence `seq`]]
+[[`sequence::template empty<Seq>::type`][Returns `mpl::true_` if `Seq` has zero elements, `mpl::false_` otherwise.]]
+[[`sequence::template empty<Seq>::call`][Returns a type convertible to `bool` that evaluates to true if the sequence is empty, else, evaluates to false. ]]
+[[`sequence::template at<Seq, N>::type`][The type of element `N` in a sequence of type `Seq`]]
+[[`sequence::template at<Seq, N>::call(seq)`][Element `N` in sequence `seq`]]
+[[`sequence::template value_at<Sequence, N>::type`][The type of the `N`th element in a sequence of type `Seq`]]
+]
+
+[heading Include]
+
+ #include <boost/fusion/sequence/sequence_facade.hpp>
+ #include <boost/fusion/include/sequence_facade.hpp>
+
+[heading Example]
+A full working example using __sequence_facade__ is provided in triple.cpp in the extension examples.
+
+[endsect]
+
+[section Iterator Facade]
+
+[heading Description]
+The __iterator_facade__ template provides an intrusive mechanism for
+producing a conforming Fusion iterator.
+
+[heading Synopsis]
+
+ template<typename Derived, typename TravesalTag>
+ struct iterator_facade;
+
+[heading Usage]
+The user of iterator_facade derives his iterator type from a specialization of iterator_facade and passes the derived iterator type as the first template parameter. The second template parameter should be the traversal category of the iterator being implemented.
+
+The user must implement the key expressions required by their iterator type.
+
+[table Parameters
+[[Name][Description]]
+[[`iterator`, `It`, `It1`, `It2`][A type derived from __iterator_facade__]]
+[[`N`][An __mpl_integral_constant__]]
+]
+
+[table Key Expressions
+[[Expression][Result][Default]]
+[[`iterator::template value_of<It>::type`][The element stored at iterator position `It`][None]]
+[[`iterator::template deref<It>::type`][The type returned when dereferencing an iterator of type `It`][None]]
+[[`iterator::template deref<It>::call(it)`][Dereferences iterator `it`][None]]
+[[`iterator::template next<It>::type`][The type of the next element from `It`][None]]
+[[`iterator::template next<It>::call(it)`][The next iterator after `it`][None]]
+[[`iterator::template prior<It>::type`][The type of the next element from `It`][None]]
+[[`iterator::template prior<It>::call(it)`][The next iterator after `it`][None]]
+[[`iterator::template advance<It, N>::type`][The type of an iterator advanced `N` elements from `It`][Implemented in terms of `next` and `prior`]]
+[[`iterator::template advance<It, N>::call(it)`][An iterator advanced `N` elements from `it`][Implemented in terms of `next` and `prior`]]
+[[`iterator::template distance<It1, It2>::type`][The distance between iterators of type `It1` and `It2` as an __mpl_integral_constant__][None]]
+[[`iterator::template distance<It1, It2>::call(it1, it2)`][The distance between iterator `it1` and `it2`][None]]
+[[`iterator::template equal_to<It1, It2>::type`][Returns `mpl::true_` if `It1` is equal to `It2`, `mpl::false_` otherwise.][`boost::same_type<It1, It2>::type`]]
+[[`iterator::template equal_to<It1, It2>::call(it1, it2)`][Returns a type convertible to `bool` that evaluates to `true` if `It1` is equal to `It2`, `false` otherwise.][`boost::same_type<It1, It2>::type()`]]
+[[`iterator::template key_of<It>::type`][The key type associated with the element from `It`][None]]
+[[`iterator::template value_of_data<It>::type`][The type of the data property associated with the element from `It`][None]]
+[[`iterator::template deref_data<It>::type`][The type that will be returned by dereferencing the data property of the element from `It`][None]]
+[[`iterator::template deref_data<It>::call(it)`][Deferences the data property associated with the element referenced by `it`][None]]
+]
+
+[heading Header]
+
+ #include <boost/fusion/iterator/iterator_facade.hpp>
+ #include <boost/fusion/include/iterator_facade.hpp>
+
+[heading Example]
+A full working example using __iterator_facade__ is provided in triple.cpp in the extension examples.
+
+[endsect]
+
+[endsect]
+
diff --git a/doc/functional.qbk b/doc/functional.qbk
new file mode 100644
index 0000000..7205a0b
--- /dev/null
+++ b/doc/functional.qbk
@@ -0,0 +1,1402 @@
+[/==============================================================================
+ Copyright (C) 2006 Tobias Schwinger
+
+ 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 Functional]
+
+Components to call functions and function objects and to make Fusion code
+callable through a function object interface.
+
+[heading Header]
+
+ #include <boost/fusion/functional.hpp>
+
+[heading Fused and unfused forms]
+
+What is a function call?
+
+ f (a,b,c)
+
+It is a name and a tuple written next to each other, left-to-right.
+
+Although the C++ syntax does not allow to replace [^(a,b,c)] with some Fusion
+__sequence__, introducing yet another function provides a solution:
+
+ invoke(f,my_sequence)
+
+Alternatively it is possible to apply a simple transformation to [^f] in order
+to achieve the same effect:
+
+ f tuple <=> ``f'`` (tuple)
+
+Now, [^f'] is an unary function that takes the arguments to `f` as a tuple;
+[^f'] is the /fused/ form of `f`.
+Reading the above equivalence right-to-left to get the inverse transformation,
+`f` is the /unfused/ form of [^f'].
+
+[heading Calling functions and function objects]
+
+Having generic C++ code call back arbitrary functions provided by the client
+used to be a heavily repetitive task, as different functions can differ in
+arity, invocation syntax and other properties that might be part of the type.
+Transporting arguments as Fusion sequences and factoring out the invocation
+makes Fusion algorithms applicable to function arguments and also reduces
+the problem to one invocation syntax and a fixed arity (instead of an arbitrary
+number of arbitrary arguments times several syntactic variants times additional
+properties).
+
+Transforming an unfused function into its fused counterpart allows n-ary
+calls from an algorithm that invokes an unary __poly_func_obj__ with
+__sequence__ arguments.
+
+The library provides several function templates to invoke different kinds of
+functions and adapters to transform them into fused form, respectively.
+Every variant has a corresponding generator function template that returns
+an adapter instance for the given argument.
+
+Constructors can be called applying __boost_func_factory__.
+
+[heading Making Fusion code callable through a function object interface]
+
+Transforming a fused function into its unfused counterpart allows to create
+function objects to accept arbitrary calls. In other words, an unary function
+object can be implemented instead of (maybe heavily overloaded) function
+templates or function call operators.
+
+The library provides both a strictly typed and a generic variant for this
+transformation. The latter should be used in combination with
+__boost_func_forward__ to attack __the_forwarding_problem__.
+
+Both variants have a corresponding generator function template that returns an
+adapter instance for the given argument.
+
+[/ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ]
+
+[section Concepts]
+
+
+[section:callable Callable Object]
+
+[heading Description]
+
+A pointer to a function, a pointer to member function, a pointer to member
+data, or a class type whose objects can appear immediately to the left of a
+function call operator.
+
+[heading Models]
+* function pointer types
+* member (function or data) pointer types
+* all kinds of function objects
+
+[heading Examples]
+
+ & a_free_function
+ & a_class::a_static_member_function
+ & a_class::a_nonstatic_data_member
+ & a_class::a_nonstatic_member_function
+ std::less<int>()
+ // using namespace boost;
+ bind(std::less<int>(), _1, 5)
+ lambda::_1 += lambda::_2;
+ fusion::__make_fused_function_object__(std::less<int>())
+
+
+[endsect]
+
+
+[section:reg_callable Regular Callable Object]
+
+[heading Description]
+
+A non-member-pointer __callable_obj__ type: A pointer to a function or a class
+type whose objects can appear immediately to the left of a function call operator.
+
+[heading Refinement of]
+* __callable_obj__
+
+[variablelist Notation
+ [[`F`][A possibly const qualified Deferred Callable Object type]]
+ [[`f`][An object or reference to an object of type F]]
+ [[`A1 ...AN`][Argument types]]
+ [[`a1 ...aN`][Objects or references to objects with types `A1 ...AN`]]
+]
+
+[heading Expression requirements]
+
+[table
+ [[Expression][Return Type][Runtime Complexity]]
+ [[`f(a1, ...aN)`][Unspecified][Unspecified]]
+]
+
+[heading Models]
+* function pointer types
+* all kinds of function objects
+
+[heading Examples]
+
+ & a_free_function
+ & a_class::a_static_member_function
+ std::less<int>()
+ // using namespace boost;
+ bind(std::less<int>(), _1, 5)
+ lambda::_1 += lambda::_2;
+ fusion::__make_fused_function_object__(std::less<int>())
+
+[endsect]
+
+
+[section:def_callable Deferred Callable Object]
+
+[heading Description]
+
+__callable_obj__ types that work with __boost_result_of__ to determine the
+result of a call.
+
+[heading Refinement of]
+* __callable_obj__
+
+[blurb note Once C++ supports the [^decltype] keyword, all models of
+__callable_obj__ will also be models of __def_callable_obj__, because
+function objects won't need client-side support for `result_of`.
+]
+
+[variablelist Notation
+ [[`F`][A possibly const qualified Deferred Callable Object type]]
+ [[`A1 ...AN`][Argument types]]
+ [[`a1 ...aN`][Objects or references to objects with types `A1 ...AN`]]
+ [[`T1 ...TN`][`T`i is `A`i `&` if `a`i is an __lvalue__, same as `A`i, otherwise]]
+]
+
+[heading Expression requirements]
+
+[table
+ [[Expression][Type]]
+ [[__boost_result_of_call__`< F(T1 ...TN) >::type`][Result of a call with `A1 ...AN`-typed arguments]]
+]
+
+[heading Models]
+* __poly_func_obj__ types
+* member (function or data) pointer types
+
+[heading Examples]
+
+ & a_free_function
+ & a_class::a_static_member_function
+ & a_class::a_nonstatic_data_member
+ & a_class::a_nonstatic_member_function
+ std::less<int>()
+ // using namespace boost;
+ bind(std::less<int>(), _1, 5)
+ // Note: Boost.Lambda expressions don't work with __boost_result_of__
+ fusion::__make_fused_function_object__(std::less<int>())
+
+[endsect]
+
+
+[section:poly Polymorphic Function Object]
+
+[heading Description]
+
+A non-member-pointer __def_callable_obj__ type.
+
+[heading Refinement of]
+* __reg_callable_obj__
+* __def_callable_obj__
+
+[variablelist Notation
+ [[`F`][A possibly const-qualified Polymorphic Function Object type]]
+ [[`f`][An object or reference to an object of type F]]
+ [[`A1 ...AN`][Argument types]]
+ [[`a1 ...aN`][Objects or references to objects with types `A1 ...AN`]]
+ [[`T1 ...TN`][`T`i is `A`i `&` if `a`i is an __lvalue__, same as `A`i, otherwise]]
+]
+
+[heading Expression requirements]
+
+[table
+ [[Expression][Return Type][Runtime Complexity]]
+ [[`f(a1, ...aN)`][`result_of< F(T1, ...TN) >::type`][Unspecified]]
+]
+
+[heading Models]
+* function pointers
+* function objects of the Standard Library
+* all Fusion __functional_adapters__
+
+[heading Examples]
+
+ & a_free_function
+ & a_class::a_static_member_function
+ std::less<int>()
+ // using namespace boost;
+ bind(std::less<int>(), _1, 5)
+ // Note: Boost.Lambda expressions don't work with __boost_result_of__
+ fusion::__make_fused_function_object__(std::less<int>())
+
+[endsect]
+
+
+[endsect]
+
+[/ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ]
+
+[section Invocation]
+
+[section Functions]
+
+[section invoke]
+
+[heading Description]
+
+Calls a __def_callable_obj__ with the arguments from a __sequence__.
+
+The first template parameter can be specialized explicitly to avoid copying
+and/or to control the const qualification of a function object.
+
+If the target function is a pointer to a class members, the corresponding
+object can be specified as a reference, pointer, or smart pointer.
+In case of the latter, a freestanding [^get_pointer] function must be
+defined (Boost provides this function for [^std::auto_ptr] and
+__boost_shared_ptr_call__).
+
+Constructors can be called applying __boost_func_factory__.
+
+[heading Synopsis]
+ template<
+ typename Function,
+ class Sequence
+ >
+ typename __result_of_invoke__<Function, Sequence>::type
+ invoke(Function f, Sequence & s);
+
+ template<
+ typename Function,
+ class Sequence
+ >
+ typename __result_of_invoke__<Function, Sequence const>::type
+ invoke(Function f, Sequence const & s);
+
+[heading Parameters]
+[table
+ [[Parameter] [Requirement] [Description]]
+ [[`f`] [A __def_callable_obj__] [The function to call.]]
+ [[`s`] [A __forward_sequence__] [The arguments.]]
+]
+
+[heading Expression Semantics]
+
+ invoke(f,s);
+
+[*Return type]: Return type of `f` when invoked with the elements in `s` as its
+arguments.
+
+[*Semantics]: Invokes `f` with the elements in `s` as arguments and returns
+the result of the call expression.
+
+[heading Header]
+
+ #include <boost/fusion/functional/invocation/invoke.hpp>
+
+[heading Example]
+ __std_plus_doc__<int> add;
+ assert(invoke(add,__make_vector__(1,1)) == 2);
+
+[heading See also]
+* __invoke_procedure__
+* __invoke_function_object__
+* __result_of_invoke__
+* __fused__
+* __make_fused__
+
+[endsect]
+
+[section:invoke_proc invoke_procedure]
+
+[heading Description]
+
+Calls a __callable_obj__ with the arguments from a __sequence__. The result
+of the call is ignored.
+
+The first template parameter can be specialized explicitly to avoid copying
+and/or to control the const qualification of a function object.
+
+For pointers to class members corresponding object can be specified as
+a reference, pointer, or smart pointer. In case of the latter, a freestanding
+[^get_pointer] function must be defined (Boost provides this function for
+[^std::auto_ptr] and __boost_shared_ptr_call__).
+
+The target function must not be a pointer to a member object (dereferencing
+such a pointer without returning anything does not make sense, so it isn't
+implemented).
+
+[heading Synopsis]
+ template<
+ typename Function,
+ class Sequence
+ >
+ typename __result_of_invoke_procedure__<Function, Sequence>::type
+ invoke_procedure(Function f, Sequence & s);
+
+ template<
+ typename Function,
+ class Sequence
+ >
+ typename __result_of_invoke_procedure__<Function, Sequence const>::type
+ invoke_procedure(Function f, Sequence const & s);
+
+[heading Parameters]
+[table
+ [[Parameter] [Requirement] [Description]]
+ [[`f`] [Model of __callable_obj__] [The function to call.]]
+ [[`s`] [Model of __forward_sequence__] [The arguments.]]
+]
+
+[heading Expression Semantics]
+
+ invoke_procedure(f,s);
+
+[*Return type]: `void`
+
+[*Semantics]: Invokes `f` with the elements in `s` as arguments.
+
+[heading Header]
+
+ #include <boost/fusion/functional/invocation/invoke_procedure.hpp>
+
+[heading Example]
+ __vector__<int,int> v(1,2);
+ using namespace boost::lambda;
+ invoke_procedure(_1 += _2, v);
+ assert(__front__(v) == 3);
+
+[heading See also]
+* __invoke__
+* __invoke_function_object__
+* __result_of_invoke_procedure__
+* __fused_procedure__
+* __make_fused_procedure__
+
+[endsect]
+
+[section:invoke_fobj invoke_function_object]
+
+[heading Description]
+
+Calls a __poly_func_obj__ with the arguments from a __sequence__.
+
+The first template parameter can be specialized explicitly to avoid copying
+and/or to control the const qualification of a function object.
+
+Constructors can be called applying __boost_func_factory__.
+
+[heading Synopsis]
+ template<
+ typename Function,
+ class Sequence
+ >
+ typename __result_of_invoke_function_object__<Function, Sequence>::type
+ invoke_function_object(Function f, Sequence & s);
+
+ template<
+ typename Function,
+ class Sequence
+ >
+ typename __result_of_invoke_function_object__<Function, Sequence const>::type
+ invoke_function_object(Function f, Sequence const & s);
+
+[heading Parameters]
+[table
+ [[Parameter] [Requirement] [Description]]
+ [[`f`] [Model of __poly_func_obj__] [The function object to call.]]
+ [[`s`] [Model of __forward_sequence__] [The arguments.]]
+]
+
+[heading Expression Semantics]
+
+ invoke_function_object(f,s);
+
+[*Return type]: Return type of `f` when invoked with the elements in `s` as its
+arguments.
+
+[*Semantics]: Invokes `f` with the elements in `s` as arguments and returns the
+result of the call expression.
+
+[heading Header]
+
+ #include <boost/fusion/functional/invocation/invoke_function_object.hpp>
+
+[heading Example]
+ struct sub
+ {
+ template <typename Sig>
+ struct result;
+
+ template <class Self, typename T>
+ struct result< Self(T,T) >
+ { typedef typename remove_reference<T>::type type; };
+
+ template<typename T>
+ T operator()(T lhs, T rhs) const
+ {
+ return lhs - rhs;
+ }
+ };
+
+ void try_it()
+ {
+ sub f;
+ assert(f(2,1) == invoke_function_object(f,__make_vector__(2,1)));
+ }
+
+[heading See also]
+* __invoke__
+* __invoke_procedure__
+* __result_of_invoke_function_object__
+* __fused_function_object__
+* __make_fused_function_object__
+
+[endsect]
+
+[endsect] [/ Functions]
+
+[section Metafunctions]
+
+[section invoke]
+
+[heading Description]
+Returns the result type of __invoke__.
+
+[heading Synopsis]
+ namespace result_of
+ {
+ template<
+ typename Function,
+ class Sequence
+ >
+ struct invoke
+ {
+ typedef __unspecified__ type;
+ };
+ }
+
+[heading See also]
+* __invoke__
+* __fused__
+
+[endsect]
+
+[section:invoke_proc invoke_procedure]
+
+[heading Description]
+Returns the result type of __invoke_procedure__.
+
+[heading Synopsis]
+ namespace result_of
+ {
+ template<
+ typename Function,
+ class Sequence
+ >
+ struct invoke_procedure
+ {
+ typedef __unspecified__ type;
+ };
+ }
+
+[heading See also]
+* __invoke_procedure__
+* __fused_procedure__
+
+[endsect]
+
+[section:invoke_fobj invoke_function_object]
+
+[heading Description]
+Returns the result type of __invoke_function_object__.
+
+[heading Synopsis]
+ namespace result_of
+ {
+ template<
+ class Function,
+ class Sequence
+ >
+ struct invoke_function_object
+ {
+ typedef __unspecified__ type;
+ };
+ }
+
+[heading See also]
+* __invoke_function_object__
+* __fused_function_object__
+
+[endsect]
+
+[endsect] [/ Metafunctions ]
+
+[section Limits]
+
+[heading Header]
+
+ #include <boost/fusion/functional/invocation/limits.hpp>
+
+[heading Macros]
+
+The following macros can be defined to change the maximum arity.
+The default is 6.
+
+* BOOST_FUSION_INVOKE_MAX_ARITY
+* BOOST_FUSION_INVOKE_PROCEDURE_MAX_ARITY
+* BOOST_FUSION_INVOKE_FUNCTION_OBJECT_MAX_ARITY
+
+[endsect]
+
+[endsect] [/ Invocation ]
+
+[/ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ]
+
+[section:adapters Adapters]
+
+Function object templates to transform a particular target function.
+
+[section fused]
+
+[heading Description]
+
+An unary __poly_func_obj__ adapter template for __def_callable_obj__ target
+functions. It takes a __forward_sequence__ that contains the arguments for the
+target function.
+
+The type of the target function is allowed to be const qualified or a
+reference. Const qualification is preserved and propagated appropriately
+(in other words, only const versions of [^operator()] can be used for a
+target function object that is const or, if the target function object
+is held by value, the adapter is const - these semantics have nothing to
+do with the const qualification of a member function, which is referring
+to the type of object pointed to by [^this] which is specified with the
+first element in the sequence passed to the adapter).
+
+If the target function is a pointer to a class members, the corresponding
+object can be specified as a reference, pointer, or smart pointer.
+In case of the latter, a freestanding [^get_pointer] function must be
+defined (Boost provides this function for [^std::auto_ptr] and
+__boost_shared_ptr_call__).
+
+[heading Header]
+
+ #include <boost/fusion/functional/adapter/fused.hpp>
+
+[heading Synopsis]
+ template <typename Function>
+ class fused;
+
+[heading Template parameters]
+
+[table
+ [[Parameter] [Description] [Default]]
+ [[`Function`] [A __def_callable_obj__] []]
+]
+
+[heading Model of]
+
+* __poly_func_obj__
+* __def_callable_obj__
+
+[variablelist Notation
+ [[`R`] [A possibly const qualified __def_callable_obj__ type or reference type thereof]]
+ [[`r`] [An object convertible to `R`]]
+ [[`s`] [A __sequence__ of arguments that are accepted by `r`]]
+ [[`f`] [An instance of `fused<R>`]]
+]
+
+[heading Expression Semantics]
+
+[table
+ [[Expression] [Semantics]]
+ [[`fused<R>(r)`] [Creates a fused function as described above, initializes the target function with `r`.]]
+ [[`fused<R>()`] [Creates a fused function as described above, attempts to use `R`'s default constructor.]]
+ [[`f(s)`] [Calls `r` with the elements in `s` as its arguments.]]
+]
+
+[heading Example]
+ fused< __std_plus_doc__<long> > f;
+ assert(f(__make_vector__(1,2l)) == 3l);
+
+[heading See also]
+
+* __fused_procedure__
+* __fused_function_object__
+* __invoke__
+* __make_fused__
+* __deduce__
+
+[endsect]
+
+[section fused_procedure]
+
+[heading Description]
+
+An unary __poly_func_obj__ adapter template for __callable_obj__ target
+functions. It takes a __forward_sequence__ that contains the arguments for
+the target function.
+
+The result is discarded and the adapter's return type is `void`.
+
+The type of the target function is allowed to be const qualified or a
+reference. Const qualification is preserved and propagated appropriately
+(in other words, only const versions of [^operator()] can be used for a
+target function object that is const or, if the target function object
+is held by value, the adapter is const - these semantics have nothing to
+do with the const qualification of a member function, which is referring
+to the type of object pointed to by [^this] which is specified with the
+first element in the sequence passed to the adapter).
+
+If the target function is a pointer to a members function, the corresponding
+object can be specified as a reference, pointer, or smart pointer.
+In case of the latter, a freestanding [^get_pointer] function must be
+defined (Boost provides this function for [^std::auto_ptr] and
+__boost_shared_ptr_call__).
+
+The target function must not be a pointer to a member object (dereferencing
+such a pointer without returning anything does not make sense, so this case
+is not implemented).
+
+[heading Header]
+
+ #include <boost/fusion/functional/adapter/fused_procedure.hpp>
+
+[heading Synopsis]
+ template <typename Function>
+ class fused_procedure;
+
+[heading Template parameters]
+
+[table
+ [[Parameter] [Description] [Default]]
+ [[`Function`] [__callable_obj__ type] []]
+]
+
+[heading Model of]
+
+* __poly_func_obj__
+* __def_callable_obj__
+
+[variablelist Notation
+ [[`R`] [A possibly const qualified __callable_obj__ type or reference type thereof]]
+ [[`r`] [An object convertible to `R`]]
+ [[`s`] [A __sequence__ of arguments that are accepted by `r`]]
+ [[`f`] [An instance of `fused_procedure<R>`]]
+]
+
+[heading Expression Semantics]
+
+[table
+ [[Expression] [Semantics]]
+ [[`fused_procedure<R>(r)`] [Creates a fused function as described above, initializes the target function with `r`.]]
+ [[`fused_procedure<R>()`] [Creates a fused function as described above, attempts to use `R`'s default constructor.]]
+ [[`f(s)`] [Calls `r` with the elements in `s` as its arguments.]]
+]
+
+[heading Example]
+ template<class SequenceOfSequences, class Func>
+ void n_ary_for_each(SequenceOfSequences const & s, Func const & f)
+ {
+ __for_each__(__zip_view__<SequenceOfSequences>(s),
+ fused_procedure<Func const &>(f));
+ }
+
+ void try_it()
+ {
+ __vector__<int,float> a(2,2.0f);
+ __vector__<int,float> b(1,1.5f);
+ using namespace boost::lambda;
+ n_ary_for_each(__vector_tie__(a,b), _1 -= _2);
+ assert(a == __make_vector__(1,0.5f));
+ }
+
+[heading See also]
+
+* __fused__
+* __fused_function_object__
+* __invoke_procedure__
+* __make_fused_procedure__
+
+[endsect]
+
+[section fused_function_object]
+
+[heading Description]
+
+An unary __poly_func_obj__ adapter template for a __poly_func_obj__ target
+function. It takes a __forward_sequence__ that contains the arguments for the
+target function.
+
+The type of the target function is allowed to be const qualified or a
+reference. Const qualification is preserved and propagated appropriately
+(in other words, only const versions of [^operator()] can be used for an
+target function object that is const or, if the target function object
+is held by value, the adapter is const).
+
+[heading Header]
+
+ #include <boost/fusion/functional/adapter/fused_function_object.hpp>
+
+[heading Synopsis]
+ template <class Function>
+ class fused_function_object;
+
+[heading Template parameters]
+
+[table
+ [[Parameter] [Description] [Default]]
+ [[`Function`] [__poly_func_obj__ type] []]
+]
+
+[heading Model of]
+
+* __poly_func_obj__
+* __def_callable_obj__
+
+[variablelist Notation
+ [[`R`] [A possibly const qualified __poly_func_obj__ type or reference type thereof]]
+ [[`r`] [An object convertible to `R`]]
+ [[`s`] [A __sequence__ of arguments that are accepted by `r`]]
+ [[`f`] [An instance of `fused<R>`]]
+]
+
+[heading Expression Semantics]
+
+[table
+ [[Expression] [Semantics]]
+ [[`fused_function_object<R>(r)`] [Creates a fused function as described above, initializes the target function with `r`.]]
+ [[`fused_function_object<R>()`] [Creates a fused function as described above, attempts to use `R`'s default constructor.]]
+ [[`f(s)`] [Calls `r` with the elements in `s` as its arguments.]]
+]
+
+[heading Example]
+ template<class SeqOfSeqs, class Func>
+ typename __result_of_transform__< zip_view<SeqOfSeqs> const,
+ fused_function_object<Func const &> >::type
+ n_ary_transform(SeqOfSeqs const & s, Func const & f)
+ {
+ return __transform__(zip_view<SeqOfSeqs>(s),
+ fused_function_object<Func const &>(f));
+ }
+
+ struct sub
+ {
+ template <typename Sig>
+ struct result;
+
+ template <class Self, typename T>
+ struct result< Self(T,T) >
+ { typedef typename remove_reference<T>::type type; };
+
+ template<typename T>
+ T operator()(T lhs, T rhs) const
+ {
+ return lhs - rhs;
+ }
+ };
+
+ void try_it()
+ {
+ __vector__<int,float> a(2,2.0f);
+ __vector__<int,float> b(1,1.5f);
+ __vector__<int,float> c(1,0.5f);
+ assert(c == n_ary_transform(__vector_tie__(a,b), sub()));
+ }
+
+[heading See also]
+
+* __fused__
+* __fused_procedure__
+* __invoke_function_object__
+* __make_fused_function_object__
+* __deduce__
+
+[endsect]
+
+
+[section unfused]
+
+[heading Description]
+
+An n-ary __poly_func_obj__ adapter template for an unary __poly_func_obj__
+target function. When called, its arguments are bundled to a
+__random_access_sequence__ of references that is passed to the target function
+object.
+
+The nullary overload of the call operator can be removed by setting the
+second template parameter to `false`, which is very useful if the result type
+computation would result in a compile error, otherwise (nullary call
+operator's prototypes can't be templates and thus are instantiated as early
+as the class template).
+
+Only __lvalue__ arguments are accepted. To overcome this limitation, apply
+__boost_func_forward__.
+
+The type of the target function is allowed to be const qualified or a
+reference. Const qualification is preserved and propagated appropriately.
+In other words, only const versions of [^operator()] can be used if
+the target function object is const - or, in case the target function
+object is held by value, the adapter is const.
+
+[heading Header]
+
+ #include <boost/fusion/functional/adapter/unfused.hpp>
+
+[heading Synopsis]
+ template <class Function, bool AllowNullary = true>
+ class unfused;
+
+[heading Template parameters]
+
+[table
+ [[Parameter] [Description] [Default]]
+ [[`Function`] [A unary __poly_func_obj__] []]
+ [[`AllowNullary`] [Boolean constant] [true]]
+]
+
+[heading Model of]
+
+* __poly_func_obj__
+* __def_callable_obj__
+
+[variablelist Notation
+ [[`F`] [A possibly const qualified, unary __poly_func_obj__ type or reference type thereof]]
+ [[`f`] [An object convertible to `F`]]
+ [[`UL`] [The type `unfused<F>`]]
+ [[`ul`] [An instance of `UL`, initialized with `f`]]
+ [[`a0`...`aN`] [Arguments to `ul`]]
+]
+
+[heading Expression Semantics]
+
+[table
+ [[Expression] [Semantics]]
+ [[`UL(f)`] [Creates a fused function as described above, initializes the target function with `f`.]]
+ [[`UL()`] [Creates a fused function as described above, attempts to use `F`'s default constructor.]]
+ [[`ul(a0`...`aN)`] [Calls `f` with a __sequence__ that contains references to the arguments `a0`...`aN`.]]
+]
+
+[heading Example]
+ struct fused_incrementer
+ {
+ template <class Seq>
+ struct result
+ {
+ typedef void type;
+ };
+
+ template <class Seq>
+ void operator()(Seq const & s) const
+ {
+ __for_each__(s,++boost::lambda::_1);
+ }
+ };
+
+ void try_it()
+ {
+ unfused<fused_incrementer> increment;
+ int a = 2; char b = 'X';
+ increment(a,b);
+ assert(a == 3 && b == 'Y');
+ }
+
+[heading See also]
+* __unfused_typed__
+* __make_unfused__
+
+[endsect]
+
+[section unfused_typed]
+
+[heading Description]
+
+An n-ary __poly_func_obj__ adapter template for an unary __poly_func_obj__
+target function. When called, its arguments are bundled to a
+__random_access_sequence__ that is passed to the target function object.
+
+The call operators of resulting function objects are strictly typed
+(in other words, non-templatized) with the types from a __sequence__.
+
+The type of the target function is allowed to be const qualified or a
+reference. Const qualification is preserved and propagated appropriately
+(in other words, only const versions of [^operator()] can be used if
+the target function object is const - or, in case the target function object
+is held by value, the adapter is const).
+
+[note For Microsoft Visual C++ 7.1 (Visual Studio 2003) the detection
+of the Function Object's const qualification easily causes an internal error.
+Therefore the adapter is always treated as if it was const. ]
+
+[tip If the type sequence passed to this template contains
+non-reference elements, the element is copied only once - the call operator's
+signature is optimized automatically to avoid by-value parameters.]
+
+[heading Header]
+
+ #include <boost/fusion/functional/adapter/unfused_typed.hpp>
+
+[heading Synopsis]
+ template <class Function, class Sequence>
+ class unfused_typed;
+
+[heading Template parameters]
+
+[table
+ [[Parameter] [Description] [Default]]
+ [[`Function`] [A unary __poly_func_obj__] []]
+ [[`Sequence`] [A __sequence__] []]
+]
+
+[heading Model of]
+
+* __poly_func_obj__
+* __def_callable_obj__
+
+[variablelist Notation
+ [[`F`] [A possibly const qualified, unary __poly_func_obj__ type or reference type thereof]]
+ [[`f`] [An object convertible to `F`]]
+ [[`S`] [A __sequence__ of parameter types]]
+ [[`UT`] [The type `unfused_typed<F,S>`]]
+ [[`ut`] [An instance of `UT`, initialized with `f`]]
+ [[`a0`...`aN`] [Arguments to `ut`, convertible to the types in `S`]]
+]
+
+[heading Expression Semantics]
+
+[table
+ [[Expression] [Semantics]]
+ [[`UT(f)`] [Creates a fused function as described above, initializes the target function with `f`.]]
+ [[`UT()`] [Creates a fused function as described above, attempts to use `F`'s default constructor.]]
+ [[`ut(a0`...`aN)`] [Calls `f` with an instance of `S` (or a subsequence of `S` starting at the first element,
+ if fewer arguments are given and the overload hasn't been disabled) initialized with
+ `a0`...`aN`.]]
+]
+
+[heading Example]
+ struct add_assign // applies operator+=
+ {
+ typedef void result_type; // for simplicity
+
+ template <typename T>
+ void operator()(T & lhs, T const & rhs) const
+ {
+ lhs += rhs;
+ }
+ };
+
+ template <class Tie>
+ class fused_parallel_adder
+ {
+ Tie tie_dest;
+ public:
+ explicit fused_parallel_adder(Tie const & dest)
+ : tie_dest(dest)
+ { }
+
+ typedef void result_type;
+
+ template <class Seq>
+ void operator()(Seq const & s) const
+ {
+ for_each( zip(tie_dest,s), fused<add_assign>() );
+ }
+ };
+
+ // accepts a tie and creates a typed function object from it
+ struct fused_parallel_adder_maker
+ {
+ template <typename Sig>
+ struct result;
+
+ template <class Self, class Seq>
+ struct result< Self(Seq) >
+ {
+ typedef typename remove_reference<Seq>::type seq;
+
+ typedef unfused_typed< fused_parallel_adder<seq>,
+ typename mpl::transform<seq, remove_reference<_> >::type > type;
+ };
+
+ template <class Seq>
+ typename result< void(Seq) >::type operator()(Seq const & tie)
+ {
+ return typename result< void(Seq) >::type(
+ fused_parallel_adder<Seq>(tie) );
+ }
+ };
+ unfused<fused_parallel_adder_maker> parallel_add;
+
+ void try_it()
+ {
+ int a = 2; char b = 'X';
+ // the second call is strictly typed with the types deduced from the
+ // first call
+ parallel_add(a,b)(3,2);
+ parallel_add(a,b)(3);
+ parallel_add(a,b)();
+ assert(a == 8 && b == 'Z');
+ }
+
+[heading See also]
+* __unfused__
+* __deduce__
+* __deduce_sequence__
+
+[endsect]
+
+[section Limits]
+
+[heading Header]
+
+ #include <boost/fusion/functional/adapter/limits.hpp>
+
+[heading Macros]
+
+The following macros can be defined to change the maximum arity.
+The value used for these macros must not exceed `FUSION_MAX_VECTOR_SIZE`.
+The default is 6.
+
+* BOOST_FUSION_UNFUSED_MAX_ARITY
+* BOOST_FUSION_UNFUSED_TYPE_MAX_ARITY
+
+[endsect]
+
+[endsect] [/ Adapters]
+
+[/ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ]
+
+[section Generation]
+
+[section Functions]
+
+[section:mk_fused make_fused]
+
+[heading Description]
+Creates a __fused__ adapter for a given __def_callable_obj__. The usual
+__element_conversion__ is applied to the target function.
+
+[heading Synopsis]
+ template <typename F>
+ inline typename __result_of_make_fused__<F>::type
+ make_fused(F const & f);
+
+[heading Parameters]
+[table
+ [[Parameter] [Requirement] [Description]]
+ [[`f`] [Model of __def_callable_obj__] [The function to transform.]]
+]
+
+[heading Expression Semantics]
+
+ make_fused(f);
+
+[*Return type]: A specialization of __fused__.
+
+[*Semantics]: Returns a __fused__ adapter for `f`.
+
+[heading Header]
+
+ #include <boost/fusion/functional/generation/make_fused.hpp>
+ #include <boost/fusion/include/make_fused.hpp>
+
+[heading Example]
+ float sub(float a, float b) { return a - b; }
+
+ void try_it()
+ {
+ __vector__<int,float> a(2,2.0f);
+ __vector__<int,float> b(1,1.5f);
+ __vector__<float,float> c(1.0f,0.5f);
+ assert(c == __transform__(__zip__(a,b), make_fused(& sub)));
+ assert(c == __transform__(__zip__(a,b), make_fused(__std_minus_doc__<float>())));
+ }
+
+[heading See also]
+* __fused__
+* __deduce__
+* __result_of_make_fused__
+
+[endsect]
+
+[section:mk_fused_proc make_fused_procedure]
+
+[heading Description]
+Creates a __fused_procedure__ adapter for a given __def_callable_obj__.
+The usual __element_conversion__ applied to the target function.
+
+[heading Synopsis]
+ template <typename F>
+ inline typename __result_of_make_fused_procedure__<F>::type
+ make_fused_procedure(F const & f);
+
+[heading Parameters]
+[table
+ [[Parameter] [Requirement] [Description]]
+ [[`f`] [Model of __callable_obj__] [The function to transform.]]
+]
+
+[heading Expression Semantics]
+
+ make_fused_procedure(f);
+
+[*Return type]: A specialization of __fused_procedure__.
+
+[*Semantics]: Returns a __fused_procedure__ adapter for `f`.
+
+[heading Header]
+
+ #include <boost/fusion/functional/generation/make_fused_procedure.hpp>
+ #include <boost/fusion/include/make_fused_procedure.hpp>
+
+[heading Example]
+ __vector__<int,int,int> v(1,2,3);
+ using namespace boost::lambda;
+ make_fused_procedure(_1 += _2 - _3)(v);
+ assert(__front__(v) == 0);
+
+[heading See also]
+* __fused_procedure__
+* __deduce__
+* __result_of_make_fused_procedure__
+
+[endsect]
+
+[section:mk_fused_fobj make_fused_function_object]
+
+[heading Description]
+Creates a __fused_function_object__ adapter for a given __def_callable_obj__.
+The usual __element_conversion__ is applied to the target function.
+
+[heading Synopsis]
+ template <typename F>
+ inline typename __result_of_make_fused_function_object__<F>::type
+ make_fused_function_object(F const & f);
+
+[heading Parameters]
+[table
+ [[Parameter] [Requirement] [Description]]
+ [[`f`] [Model of __poly_func_obj__] [The function to transform.]]
+]
+
+[heading Expression Semantics]
+
+ make_fused_function_object(f);
+
+[*Return type]: A specialization of __fused_function_object__.
+
+[*Semantics]: Returns a __fused_function_object__ adapter for `f`.
+
+[heading Header]
+
+ #include <boost/fusion/functional/generation/make_fused_function_object.hpp>
+ #include <boost/fusion/include/make_fused_function_object.hpp>
+
+[heading Example]
+ struct sub
+ {
+ template <typename Sig>
+ struct result;
+
+ template <class Self, typename T>
+ struct result< Self(T,T) >
+ { typedef typename remove_reference<T>::type type; };
+
+ template<typename T>
+ T operator()(T lhs, T rhs) const
+ {
+ return lhs - rhs;
+ }
+ };
+
+ void try_it()
+ {
+ __vector__<int,float> a(2,2.0f);
+ __vector__<int,float> b(1,1.5f);
+ __vector__<int,float> c(1,0.5f);
+ assert(c == __transform__(__zip__(a,b), make_fused_function_object(sub())));
+ }
+
+[heading See also]
+* __fused_function_object__
+* __deduce__
+* __result_of_make_fused_function_object__
+
+[endsect]
+
+[section:mk_unfused make_unfused]
+
+[heading Description]
+Creates a __unfused__ adapter for a given, unary __poly_func_obj__.
+The usual __element_conversion__ is applied to the target function.
+
+[heading Synopsis]
+ template <typename F>
+ inline typename __result_of_make_unfused__<F>::type
+ make_unfused(F const & f);
+
+[heading Parameters]
+[table
+ [[Parameter] [Requirement] [Description]]
+ [[`f`] [Model of __poly_func_obj__] [The function to transform.]]
+]
+
+[heading Expression Semantics]
+
+ make_unfused(f);
+
+[*Return type]: A specialization of __unfused__.
+
+[*Semantics]: Returns a __unfused__ adapter for `f`.
+
+[heading Header]
+
+ #include <boost/fusion/functional/generation/make_unfused.hpp>
+ #include <boost/fusion/include/make_unfused.hpp>
+
+[heading Example]
+ struct fused_incrementer
+ {
+ template <class Seq>
+ struct result
+ {
+ typedef void type;
+ };
+
+ template <class Seq>
+ void operator()(Seq const & s) const
+ {
+ __for_each__(s,++boost::lambda::_1);
+ }
+ };
+
+ void try_it()
+ {
+ int a = 2; char b = 'X';
+ make_unfused(fused_incrementer())(a,b);
+ assert(a == 3 && b == 'Y');
+ }
+
+[heading See also]
+* __unfused__
+* __deduce__
+* __result_of_make_unfused__
+
+[endsect]
+
+[endsect] [/ Functions]
+
+[section Metafunctions]
+
+[section:mk_fused make_fused]
+
+[heading Description]
+Returns the result type of __make_fused__.
+
+[heading Header]
+
+ #include <boost/fusion/functional/generation/make_fused.hpp>
+ #include <boost/fusion/include/make_fused.hpp>
+
+[heading Synopsis]
+ namespace result_of
+ {
+ template<typename Function>
+ struct make_fused
+ {
+ typedef __unspecified__ type;
+ };
+ }
+
+[heading See also]
+* __make_fused__
+
+[endsect]
+
+[section:mk_fused_proc make_fused_procedure]
+
+[heading Description]
+Returns the result type of __make_fused_procedure__.
+
+[heading Header]
+
+ #include <boost/fusion/functional/generation/make_fused_procedure.hpp>
+ #include <boost/fusion/include/make_fused_procedure.hpp>
+
+[heading Synopsis]
+ namespace result_of
+ {
+ template<typename Function>
+ struct make_fused_procedure
+ {
+ typedef __unspecified__ type;
+ };
+ }
+
+[heading See also]
+* __make_fused_procedure__
+
+[endsect]
+
+[section:mk_fused_fobj make_fused_function_object]
+
+[heading Description]
+Returns the result type of __make_fused_function_object__.
+
+[heading Header]
+
+ #include <boost/fusion/functional/generation/make_fused_function_object.hpp>
+ #include <boost/fusion/include/make_fused_function_object.hpp>
+
+[heading Synopsis]
+ namespace result_of
+ {
+ template<typename Function>
+ struct make_fused_function_object
+ {
+ typedef __unspecified__ type;
+ };
+ }
+
+[heading See also]
+* __make_fused_function_object__
+
+[endsect]
+
+[section:mk_unfused make_unfused]
+
+[heading Description]
+Returns the result type of __make_unfused__.
+
+[heading Header]
+
+ #include <boost/fusion/functional/generation/make_unfused.hpp>
+ #include <boost/fusion/include/make_unfused.hpp>
+
+[heading Synopsis]
+ namespace result_of
+ {
+ template<typename Function>
+ struct make_unfused
+ {
+ typedef __unspecified__ type;
+ };
+ }
+
+[heading See also]
+* __make_unfused__
+
+[endsect]
+
+[endsect] [/ Metafunctions]
+
+[endsect] [/ Generation]
+
+[endsect] [/ Functional ]
diff --git a/doc/fusion.qbk b/doc/fusion.qbk
new file mode 100644
index 0000000..6d6987d
--- /dev/null
+++ b/doc/fusion.qbk
@@ -0,0 +1,361 @@
+[/==============================================================================
+ 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]
+