Update CMakeLists.txt

[skip ci] Add "cxxstd" json field

.travis.yml

@@ -0,0 +1,251 @@
+# 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:
+    - os: linux
+      dist: xenial
+      env: TOOLSET=gcc-4.4 CXXSTD=98,0x
+      addons:
+        apt:
+          packages:
+            - g++-4.4
+          sources:
+            - ubuntu-toolchain-r-test
+
+    #- os: linux
+    #  dist: xenial
+    #  env: TOOLSET=gcc-4.5 CXXSTD=03,0x
+    #  addons:
+    #    apt:
+    #      packages:
+    #        - g++-4.5
+    #      sources:
+    #        - ubuntu-toolchain-r-test
+
+    - os: linux
+      dist: xenial
+      env: TOOLSET=gcc-4.6 CXXSTD=03,0x
+      addons:
+        apt:
+          packages:
+            - g++-4.6
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      dist: xenial
+      env: TOOLSET=gcc-4.7 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - g++-4.7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      dist: xenial
+      env: TOOLSET=gcc-4.8 CXXSTD=03,11,1y
+      addons:
+        apt:
+          packages:
+            - g++-4.8
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      dist: xenial
+      env: TOOLSET=gcc-4.9 CXXSTD=03,11,14
+      addons:
+        apt:
+          packages:
+            - g++-4.9
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      dist: xenial
+      env: TOOLSET=gcc-5 CXXSTD=03,11,14,17
+      addons:
+        apt:
+          packages:
+            - g++-5
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      dist: xenial
+      env: TOOLSET=gcc-6 CXXSTD=03,11,14,17
+      addons:
+        apt:
+          packages:
+            - g++-6
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      dist: xenial
+      env: TOOLSET=gcc-7 CXXSTD=03,11,14,17
+      addons:
+        apt:
+          packages:
+            - g++-7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      dist: xenial
+      env: TOOLSET=gcc-8 CXXSTD=03,11,14,17,2a
+      addons:
+        apt:
+          packages:
+            - g++-8
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      dist: xenial
+      env: TOOLSET=clang-3.5 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-3.5
+
+    - os: linux
+      dist: xenial
+      env: TOOLSET=clang-3.6 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-3.6
+
+    - os: linux
+      dist: xenial
+      env: TOOLSET=clang-3.7 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-3.7
+
+    - os: linux
+      dist: xenial
+      env: TOOLSET=clang-3.8 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-3.8
+
+    - os: linux
+      dist: xenial
+      env: TOOLSET=clang-3.9 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-3.9
+
+    - os: linux
+      dist: xenial
+      env: TOOLSET=clang-4.0 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-4.0
+
+    - os: linux
+      dist: xenial
+      env: TOOLSET=clang-5.0 CXXSTD=03,11,14,17,2a
+      addons:
+        apt:
+          packages:
+            - clang-5.0
+          sources:
+            - llvm-toolchain-xenial-5.0
+
+    - os: linux
+      dist: xenial
+      env: TOOLSET=clang-6.0 CXXSTD=03,11,14,17,2a
+      addons:
+        apt:
+          packages:
+            - clang-6.0
+          sources:
+            - llvm-toolchain-xenial-6.0
+
+    - os: linux
+      dist: xenial
+      env: TOOLSET=clang-7.0 CXXSTD=03,11,14,17,2a
+      addons:
+        apt:
+          packages:
+            - clang-7
+          sources:
+            - llvm-toolchain-xenial-7
+
+    - 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 libs/headers tools/boost_install 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

CMakeLists.txt

@@ -0,0 +1,26 @@
+# Copyright 2018 Mike Dev
+# Distributed under the Boost Software License, Version 1.0.
+# See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
+
+cmake_minimum_required(VERSION 3.5...3.20)
+project(boost_fusion VERSION "${BOOST_SUPERPROJECT_VERSION}" LANGUAGES CXX)
+
+add_library(boost_fusion INTERFACE)
+add_library(Boost::fusion ALIAS boost_fusion)
+
+target_include_directories(boost_fusion INTERFACE include)
+
+target_link_libraries(boost_fusion
+    INTERFACE
+        Boost::config
+        Boost::container_hash
+        Boost::core
+        Boost::function_types
+        Boost::mpl
+        Boost::preprocessor
+        Boost::static_assert
+        Boost::tuple
+        Boost::type_traits
+        Boost::typeof
+        Boost::utility
+)

appveyor.yml

@@ -0,0 +1,91 @@
+# 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 2015
+      TOOLSET: msvc-9.0
+      CXXSTD: latest # fake
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      TOOLSET: msvc-10.0
+      CXXSTD: latest # fake
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      TOOLSET: msvc-11.0
+      CXXSTD: latest # fake
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      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
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      TOOLSET: clang-win
+      CXXSTD: 14
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      TOOLSET: clang-win
+      CXXSTD: 17
+
+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 libs/headers tools/boost_install 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%

doc/Jamfile

@@ -25,4 +25,8 @@ boostbook quickbook
         <format>pdf:<xsl:param>img.src.path=$(images_location)/
     ;
 
-
+###############################################################################
+alias boostdoc ;
+explicit boostdoc ;
+alias boostrelease : quickbook ;
+explicit boostrelease ;

doc/adapted.qbk

@@ -23,19 +23,6 @@ various data structures, non-intrusively, as full fledged Fusion sequences.
     #include <boost/fusion/adapted.hpp>
     #include <boost/fusion/include/adapted.hpp>
 
-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.
-
 [section:array Array]
 
 This module provides adapters for arrays. Including the module
@@ -89,6 +76,35 @@ __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
@@ -116,6 +132,21 @@ header makes all __mpl__ sequences fully conforming fusion sequences.
     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__
@@ -168,8 +199,8 @@ header makes `boost::tuple` a fully conforming __forward_sequence__.
 [heading Example]
 
     boost::tuple<int,std::string> example_tuple(101, "hello");
-    std::cout << *boost::fusion::begin(example_tuple) << '\n';
-    std::cout << *boost::fusion::next(boost::fusion::begin(example_tuple)) << '\n';
+    std::cout << *__begin__(example_tuple) << '\n';
+    std::cout << *__next__(__begin__(example_tuple)) << '\n';
 
 [heading See also]
 
@@ -198,7 +229,7 @@ __random_access_sequence__.
         struct_name,
         (member_type0, member_name0)
         (member_type1, member_name1)
-        (BOOST_FUSION_ADAPT_AUTO, member_name2)
+        (auto, member_name2)
         ...
         )
 
@@ -211,7 +242,7 @@ 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 BOOST_FUSION_ADAPT_AUTO, the type is
+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
@@ -241,8 +272,8 @@ namespace qualified name of the struct to be adapted.
     // Without BOOST_PP_VARIADICS support :
     BOOST_FUSION_ADAPT_STRUCT(
         demo::employee,
-        (BOOST_FUSION_ADAPT_AUTO, name)
-        (BOOST_FUSION_ADAPT_AUTO, age)
+        (auto, name)
+        (auto, age)
     )
 
 [endsect]
@@ -269,7 +300,7 @@ __random_access_sequence__.
         (struct_name) (specialization_param0)(specialization_param1)...,
         (member_type0, member_name0)
         (member_type1, member_name1)
-        (BOOST_FUSION_ADAPT_AUTO, member_name2),
+        (auto, member_name2),
         ...
         )
 
@@ -287,7 +318,7 @@ 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 BOOST_FUSION_ADAPT_AUTO, the type is
+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
@@ -316,7 +347,7 @@ namespace qualified name of the struct to be adapted.
         (demo::employee) (Name)(Age),
         (Name, name)
         (Age, age)
-        (BOOST_FUSION_ADAPT_AUTO, employment_timestamp))
+        (auto, employment_timestamp))
 
     // Or by infering type completely
     BOOST_FUSION_ADAPT_TPL_STRUCT(
@@ -361,7 +392,7 @@ adapted using the given name.
         struct_name, adapted_name,
         (member_type0, member_name0)
         (member_type1, member_name1)
-        (BOOST_FUSION_ADAPT_AUTO, member_name2),
+        (auto, member_name2),
         ...
         )
 
@@ -371,7 +402,7 @@ adapted using the given name.
         adapted_name,
         (member_type0, member_name0)
         (member_type1, member_name1)
-        (BOOST_FUSION_ADAPT_AUTO, member_name2),
+        (auto, member_name2),
         ...
         )
 
@@ -393,7 +424,7 @@ 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 BOOST_FUSION_ADAPT_AUTO, the type is
+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
@@ -424,8 +455,8 @@ namespace qualified name of the struct to be converted.
     // Without BOOST_PP_VARIADICS support :
     BOOST_FUSION_ADAPT_STRUCT_NAMED(
         demo::employee, adapted_employee,
-        (BOOST_FUSION_ADAPT_AUTO, name),
-        (BOOST_FUSION_ADAPT_AUTO, age))
+        (auto, name),
+        (auto, age))
 
 [endsect]
 
@@ -452,7 +483,7 @@ 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 BOOST_FUSION_ADAPT_AUTO, the type is
+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
@@ -490,8 +521,8 @@ namespace qualified name of the struct to be adapted.
     // Without BOOST_PP_VARIADICS support :
     BOOST_FUSION_ADAPT_ASSOC_STRUCT(
         demo::employee,
-        (BOOST_FUSION_ADAPT_AUTO, name, keys::name),
-        (BOOST_FUSION_ADAPT_AUTO, age, keys::name))
+        (auto, name, keys::name),
+        (auto, age, keys::name))
 
 [endsect]
 
@@ -525,7 +556,7 @@ 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 BOOST_FUSION_ADAPT_AUTO, the type is
+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
@@ -612,7 +643,7 @@ 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 BOOST_FUSION_ADAPT_AUTO, the type is
+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
@@ -649,8 +680,8 @@ namespace qualified name of the struct to be converted.
     // Without BOOST_PP_VARIADICS support :
     BOOST_FUSION_ADAPT_ASSOC_STRUCT_NAMED(
         demo::employee, adapted_employee,
-        (BOOST_FUSION_ADAPT_AUTO, name, keys::name)
-        (BOOST_FUSION_ADAPT_AUTO, age, keys::age))
+        (auto, name, keys::name)
+        (auto, age, keys::age))
 
 [endsect]
 
@@ -684,7 +715,7 @@ 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 BOOST_FUSION_ADAPT_AUTO can be used to avoid repeating the type.
+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
@@ -794,7 +825,7 @@ 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 BOOST_FUSION_ADAPT_AUTO can be used to avoid repeating the type.
+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
@@ -899,7 +930,7 @@ 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 BOOST_FUSION_ADAPT_AUTO can be used to avoid repeating the type.
+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
@@ -1015,7 +1046,7 @@ 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 BOOST_FUSION_ADAPT_AUTO can be used to avoid repeating the type.
+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

doc/algorithm.qbk

@@ -258,6 +258,22 @@ the first call) and [arg_desc] of `seq`.
     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]]
@@ -441,10 +457,10 @@ Linear, exactly `__result_of_size__<Sequence>::value` applications of `F`.
 [endsect]
 
 [section for_each]
-A metafunction returning the result type of applying __for_each__ to a sequence. The
-return type of __for_each__ is always `void`.
 
 [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<
@@ -724,8 +740,10 @@ or `__end__(seq)` if there is no such element.
 [heading Complexity]
 Linear. At most `__result_of_size__<Sequence>::value` comparisons.
 
-#include <boost/fusion/algorithm/query/find_if.hpp>
-#include <boost/fusion/include/find_if.hpp>
+[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);
@@ -1361,7 +1379,7 @@ Returns a new sequence, with all the elements of the original sequence, except t
         typename T,
         typename Sequence
         >
-    typename __result_of_remove__<Sequence const, T>::type replace(Sequence const& seq);
+    typename __result_of_remove__<Sequence const, T>::type remove(Sequence const& seq);
 
 [table Parameters
     [[Parameter][Requirement][Description]]
@@ -1720,7 +1738,7 @@ Takes 2 sequences and returns a sequence containing the elements of the first fo
     template<
         typename LhSequence,
         typename RhSequence>
-    typename __result_of_join__<LhSequence, RhSequence>::type join(LhSequence const& lhs, RhSequence const& rhs);
+    typename __result_of_join__<LhSequence const, RhSequence const>::type join(LhSequence const& lhs, RhSequence const& rhs);
 
 [table Parameters
     [[Parameter][Requirement][Description]]
@@ -1765,7 +1783,7 @@ Zips sequences together to form a single sequence, whose members are tuples of t
         ...
         typename SequenceN
         >
-    typename __result_of_zip__<Sequence1, Sequence2, ... SequenceN>::type
+    typename __result_of_zip__<Sequence1 const, Sequence2 const, ... SequenceN const>::type
     zip(Sequence1 const& seq1, Sequence2 const& seq2, ... SequenceN const& seqN);
 
 [table Parameters
@@ -1830,7 +1848,7 @@ Constant. Returns a view which is lazily evaluated.
     #include <boost/fusion/include/pop_back.hpp>
 
 [heading Example]
-    assert(___pop_back__(__make_vector__(1,2,3)) == __make_vector__(1,2));
+    assert(__pop_back__(__make_vector__(1,2,3)) == __make_vector__(1,2));
 
 [endsect]
 
@@ -1884,7 +1902,7 @@ Returns a new sequence with an element added at the end.
         typename Sequence,
         typename T
         >
-    typename __result_of_push_back__<Sequence, T>::type push_back(
+    typename __result_of_push_back__<Sequence const, T>::type push_back(
         Sequence const& seq, T const& t);
 
 [table Parameters
@@ -1925,7 +1943,7 @@ Returns a new sequence with an element added at the beginning.
         typename Sequence,
         typename T
         >
-    typename __result_of_push_front__<Sequence, T>::type push_front(
+    typename __result_of_push_front__<Sequence const, T>::type push_front(
         Sequence const& seq, T const& t);
 
 [table Parameters
@@ -2089,32 +2107,33 @@ Constant.
 [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`.
+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
         >
-    typename __result_of_transform__<Sequence const, F>::type transform(
-        Sequence const& seq, F f);
+    struct transform
+    {
+        typedef __unspecified__ type;
+    };
 
 [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]]
+    [[`Sequence`][A model of __forward_sequence__][Operation's argument]]
+    [[`F`][A model of unary __poly_func_obj__][Transformation metafunction]]
 ]
 
 [heading Expression Semantics]
-    __transform__(seq, f);
+    __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 new sequence, containing the return values of `f(e)` for each element `e` within `seq`.
+[*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<
@@ -2122,41 +2141,33 @@ with elements created by applying `f(e)` to each element of `e` of `seq`.
         typename Sequence2,
         typename F
         >
-    typename __result_of_transform__<Sequence1 const, Sequence2 const, F>::type transform(
-        Sequence1 const& seq1, Sequence2 const& seq2, F f);
+    struct transform
+    {
+          typedef __unspecified__ type;
+    };
 
 [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]]
+    [[`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 new sequence, containing the return values of `f(e1, e2)` for each pair of elements `e1` and `e2` within `seq1` and `seq2` respectively.
+[*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. Returns a view which is lazily evaluated.
+Constant.
 
 [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]
@@ -2200,7 +2211,7 @@ Constant.
 [section replace_if]
 
 [heading Description]
-Returns the result type of __replace_if__, given the types of the sequence, __poly_func_obj__ predicate and replacement object.
+Returns the result type of __replace_if__, given the types of the sequence, unary __mpl_lambda_expression__ predicate and replacement object.
 
 [heading Synopsis]
     template<
@@ -2215,7 +2226,7 @@ Returns the result type of __replace_if__, given the types of the sequence, __po
 [table Parameters
     [[Parameter][Requirement][Description]]
     [[`Sequence`][A model of __forward_sequence__][Operation's argument]]
-    [[`F`][A model of unary __poly_func_obj__][Replacement predicate]]
+    [[`F`][A model of unary __mpl_lambda_expression__][Replacement predicate]]
     [[`T`][Any type][The type of the replacement object]]
 ]
 
@@ -2265,7 +2276,7 @@ Returns the result type of __remove__, given the sequence and removal types.
 * 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_replace_if__<Sequence, boost::is_same<mpl::_, T> >::type`.
+[*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.

doc/container.qbk

@@ -66,6 +66,11 @@ cases the most efficient.
     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 <
@@ -81,9 +86,11 @@ The numbered form accepts the exact number of elements. Example:
 
     vector3<int, char, double>
 
-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:
+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>
 
@@ -191,7 +198,7 @@ defined in __forward_sequence__.
     [[`__at__<N>(l)`]           [The Nth element from the beginning of the sequence; see __at__.]]
 ]
 
-[blurb __note__ `__at__<N>(l)` is provided for convenience and compatibility
+[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
@@ -232,9 +239,11 @@ each element is peculiarly constant (see __recursive_inline__).
     >
     struct list;
 
-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:
+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>
 
@@ -276,7 +285,7 @@ defined in __forward_sequence__.
     [[`__at__<N>(l)`]           [The Nth element from the beginning of the sequence; see __at__.]]
 ]
 
-[blurb __note__ `__at__<n>(l)` is provided for convenience and compatibility
+[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
@@ -309,7 +318,7 @@ __front_extended_deque__ and __back_extended_deque__.
 
     #include <boost/fusion/container/deque.hpp>
     #include <boost/fusion/include/deque.hpp>
-    #include <boost/fusion/container/list/deque_fwd.hpp>
+    #include <boost/fusion/container/deque/deque_fwd.hpp>
     #include <boost/fusion/include/deque_fwd.hpp>
 
 [heading Synopsis]
@@ -363,7 +372,7 @@ defined in __bidirectional_sequence__.
     [[`__at__<N>(d)`]       [The Nth element from the beginning of the sequence; see __at__.]]
 ]
 
-[blurb __note__ `__at__<N>(d)` is provided for convenience, despite
+[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
@@ -406,7 +415,7 @@ the same properties as the __deque__.
     [[`T`]                  [Element type]              [ ]]
 ]
 
-[blurb __note__ `Deque` can be a __deque__, a __front_extended_deque__ or a
+[note `Deque` can be a __deque__, a __front_extended_deque__ or a
 __back_extended_deque__]
 
 [heading Model of]
@@ -430,7 +439,7 @@ not defined in __bidirectional_sequence__.
     [[`__at__<N>(d)`]       [The Nth element from the beginning of the sequence; see __at__.]]
 ]
 
-[blurb __note__ See __deque__ for further details.]
+[note See __deque__ for further details.]
 
 [heading Example]
 
@@ -467,7 +476,7 @@ the same properties as the __deque__.
     [[`T`]                  [Element type]              [ ]]
 ]
 
-[blurb __note__ `Deque` can be a __deque__, a __back_extended_deque__ or a
+[note `Deque` can be a __deque__, a __back_extended_deque__ or a
 __back_extended_deque__]
 
 [heading Model of]
@@ -491,7 +500,7 @@ not defined in __bidirectional_sequence__.
     [[`__at__<N>(d)`]       [The Nth element from the beginning of the sequence; see __at__.]]
 ]
 
-[blurb __note__ See __deque__ for further details.]
+[note See __deque__ for further details.]
 
 [heading Example]
 
@@ -532,9 +541,11 @@ complexity (see __overloaded_functions__).
     >
     struct set;
 
-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:
+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>
 
@@ -614,9 +625,11 @@ __overloaded_functions__).
     >
     struct map;
 
-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:
+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> >
 
@@ -697,10 +710,13 @@ Create a __list__ from one or more values.
     typename __result_of_make_list__<T0, T1,... TN>::type
     make_list(T0 const& x0, T1 const& x1... TN const& xN);
 
-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:
+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
 
@@ -730,7 +746,7 @@ before including any Fusion header to change the default. Example:
 
 [heading See also]
 
-__note_boost_ref__
+__note_ref_wrappers__
 
 [endsect]
 
@@ -778,7 +794,7 @@ __result_of_make_cons__`<Car>::type`
 
 [heading See also]
 
-__note_boost_ref__
+__note_ref_wrappers__
 
 [endsect]
 
@@ -794,11 +810,13 @@ Create a __vector__ from one or more values.
     typename __result_of_make_vector__<T0, T1,... TN>::type
     make_vector(T0 const& x0, T1 const& x1... TN const& xN);
 
-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:
+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
 
@@ -828,7 +846,7 @@ default. Example:
 
 [heading See also]
 
-__note_boost_ref__
+__note_ref_wrappers__
 
 [endsect]
 
@@ -880,7 +898,7 @@ Fusion header to change the default. Example:
 
 [heading See also]
 
-__note_boost_ref__
+__note_ref_wrappers__
 
 [endsect]
 
@@ -896,11 +914,13 @@ Create a __set__ from one or more values.
     typename __result_of_make_set__<T0, T1,... TN>::type
     make_set(T0 const& x0, T1 const& x1... TN const& xN);
 
-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:
+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
 
@@ -932,7 +952,7 @@ default. Example:
 
 [heading See also]
 
-__note_boost_ref__
+__note_ref_wrappers__
 
 [endsect]
 
@@ -990,7 +1010,7 @@ default. Example:
 
 [heading See also]
 
-__note_boost_ref__, __fusion_pair__
+__note_ref_wrappers__, __fusion_pair__
 
 [endsect]
 
@@ -1049,10 +1069,13 @@ Constructs a tie using a __list__ sequence.
     __list__<T0&, T1&,... TN&>
     list_tie(T0& x0, T1& x1... TN& xN);
 
-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:
+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
 
@@ -1096,11 +1119,13 @@ Constructs a tie using a __vector__ sequence.
     __vector__<T0&, T1&,... TN&>
     vector_tie(T0& x0, T1& x1... TN& xN);
 
-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:
+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
 
@@ -1144,11 +1169,14 @@ Constructs a tie using a __map__ sequence.
     __map__<__pair__<K0, D0&>, __pair__<K1, D1&>,... __pair__<KN, DN&> >
     map_tie(D0& d0, D1& d1... DN& dN);
 
-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:
+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
 
@@ -1249,10 +1277,13 @@ Returns the result type of __make_list__.
     template <typename T0, typename T1,... typename TN>
     struct make_list;
 
-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:
+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
 
@@ -1333,11 +1364,13 @@ Returns the result type of __make_vector__.
     template <typename T0, typename T1,... typename TN>
     struct make_vector;
 
-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:
+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
 
@@ -1427,11 +1460,13 @@ Returns the result type of __make_set__.
     template <typename T0, typename T1,... typename TN>
     struct make_set;
 
-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:
+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
 
@@ -1559,10 +1594,13 @@ Returns the result type of __list_tie__.
     template <typename T0, typename T1,... typename TN>
     struct list_tie;
 
-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:
+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
 
@@ -1603,11 +1641,13 @@ Returns the result type of __vector_tie__.
     template <typename T0, typename T1,... typename TN>
     struct vector_tie;
 
-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:
+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
 
@@ -1695,11 +1735,13 @@ Returns the result type of __map_tie__.
     template <typename K0, typename K1,... typename KN, typename D0, typename D1,... typename DN>
     struct map_tie;
 
-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:
+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
 
@@ -1949,7 +1991,7 @@ Convert a fusion sequence to a __map__.
 
 [*Semantics]: Convert a fusion sequence, `seq`, to a __map__.
 
-[*Precondition]: The elements of the sequence are assumed to be
+[*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]
@@ -1959,9 +2001,25 @@ __fusion_pair__s. There may be no duplicate __fusion_pair__ key types.
 
 [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]
 
@@ -2150,7 +2208,7 @@ Returns the result type of __as_map__.
 
 [*Semantics]: Convert a fusion sequence, `Sequence`, to a __map__.
 
-[*Precondition]: The elements of the sequence are assumed to be
+[*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]
@@ -2160,9 +2218,25 @@ __fusion_pair__s. There may be no duplicate __fusion_pair__ key types.
 
 [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]
 

doc/extension.qbk

@@ -323,7 +323,7 @@ For our __random_access_sequence__ we will also need to implement `size_impl`,
 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__,
-__value_at_key__ and __has_key__. We also need to enable 3 iterator lookup
+__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`
@@ -400,7 +400,7 @@ producing a conforming Fusion sequence.
 [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 the implement the key expressions required by their sequence type.
+The user must implement the key expressions required by their sequence type.
 
 [table Parameters
 [[Name][Description]]
@@ -447,7 +447,7 @@ producing a conforming Fusion iterator.
 [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 the implement the key expressions required by their iterator type.
+The user must implement the key expressions required by their iterator type.
 
 [table Parameters
 [[Name][Description]]

doc/functional.qbk

@@ -689,7 +689,7 @@ is not implemented).
     [[`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<R>`]]
+    [[`f`] [An instance of `fused_procedure<R>`]]
 ]
 
 [heading Expression Semantics]
@@ -931,11 +931,11 @@ reference. Const qualification is preserved and propagated appropriately
 the target function object is const - or, in case the target function object
 is held by value, the adapter is const).
 
-[blurb __note__ For Microsoft Visual C++ 7.1 (Visual Studio 2003) the detection
+[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. ]
 
-[blurb __tip__ If the type sequence passed to this template contains
+[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.]
 

doc/fusion.qbk

@@ -2,6 +2,7 @@
     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
@@ -20,43 +21,37 @@
     ]
 ]
 
-[def __note__                   [$images/note.png]]
-[def __alert__                  [$images/alert.png]]
-[def __tip__                    [$images/tip.png]]
-[def __caution__                [$images/caution.png]]
-
-[def __spirit__                 [@http://spirit.sourceforge.net Spirit]]
-[def __phoenix__                [@http://www.boost.org/libs/phoenix/index.html Phoenix]]
-[def __mpl__                    [@http://www.boost.org/libs/mpl/index.html MPL]]
+[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/doc/tuple_users_guide.html Boost.Tuple]]
+[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://lists.sourceforge.net/lists/listinfo/spirit-general Spirit Mailing List]]
-[def __spirit_general__         [@news://news.gmane.org/gmane.comp.spirit.general Spirit General NNTP news portal]]
-[def __gmane__                  [@http://www.gmane.org Gmane]]
-[def __mlist_archive__          [@http://news.gmane.org/gmane.comp.parsers.spirit.general]]
+[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/doc/html/any.html Boost.Any]]
+[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/doc/html/array.html Boost.Array Library]]
-[def __boost_variant_library__  [@http://www.boost.org/doc/html/variant.html Boost.Variant Library]]
-[def __boost_tuple_library__    [@http://www.boost.org/libs/tuple/doc/tuple_users_guide.html Boost.Tuple Library]]
-[def __boost_ref__              [@http://www.boost.org/doc/html/ref.html Boost.Ref]]
-[def __boost_ref_call__         [@http://www.boost.org/doc/html/ref.html `ref`]]
-[def __boost_result_of__        [@http://www.boost.org/libs/utility/utility.htm#result_of Boost.ResultOf]]
+[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/utility/enable_if.html Boost.EnableIf utility]]
-[def __boost_shared_ptr_call__  [@http://www.boost.org/libs/smart_ptr/shared_ptr.htm `boost::shared_ptr`]]
-[def __boost_func_forward__     [@http://www.boost.org/libs/functional/forward/doc/html/index.html Boost.Functional/Forward]]
-[def __boost_func_factory__     [@http://www.boost.org/libs/functional/factory/doc/html/index.html Boost.Functional/Factory]]
-[def __boost_func_hash__        [@http://www.boost.org/doc/html/hash.html Boost.Functional/Hash]]
-[def __std_pair_doc__           [@http://www.sgi.com/tech/stl/pair.html `std::pair`]]
-[def __std_plus_doc__           [@http://www.sgi.com/tech/stl/plus.html `std::plus`]]
-[def __std_minus_doc__          [@http://www.sgi.com/tech/stl/minus.html `std::minus`]]
+[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]]
@@ -83,6 +78,7 @@
 [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`]]
@@ -112,6 +108,7 @@
 [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`]]
@@ -321,17 +318,17 @@
 [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 `make_fused`]]
-[def __result_of_make_fused_procedure__       [link fusion.functional.generation.metafunctions.mk_fused_proc `make_fused_procedure`]]
-[def __result_of_make_fused_function_object__ [link fusion.functional.generation.metafunctions.mk_fused_fobj `make_fused_function_object`]]
-[def __result_of_make_unfused__       [link fusion.functional.generation.metafunctions.mk_unfused `make_unfused`]]
+[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_boost_ref__         [link fusion.notes.boost__ref `boost::ref`]]
+[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]]
@@ -341,6 +338,8 @@
 
 [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]

doc/html/index.html

@@ -69,6 +69,8 @@
         Access Iterator</a></span></dt>
 <dt><span class="section"><a href="fusion/iterator/concepts/associative_iterator.html">Associative
         Iterator</a></span></dt>
+<dt><span class="section"><a href="fusion/iterator/concepts/unbounded_iterator.html">Unbounded
+        Iterator</a></span></dt>
 </dl></dd>
 <dt><span class="section"><a href="fusion/iterator/functions.html">Functions</a></span></dt>
 <dd><dl>
@@ -116,6 +118,8 @@
         Access Sequence</a></span></dt>
 <dt><span class="section"><a href="fusion/sequence/concepts/associative_sequence.html">Associative
         Sequence</a></span></dt>
+<dt><span class="section"><a href="fusion/sequence/concepts/unbounded_sequence.html">Unbounded
+        Sequence</a></span></dt>
 </dl></dd>
 <dt><span class="section"><a href="fusion/sequence/intrinsic.html">Intrinsic</a></span></dt>
 <dd><dl>
@@ -167,6 +171,7 @@
 <dd><dl>
 <dt><span class="section"><a href="fusion/adapted/array.html">Array</a></span></dt>
 <dt><span class="section"><a href="fusion/adapted/std__pair.html">std::pair</a></span></dt>
+<dt><span class="section"><a href="fusion/adapted/std__tuple.html">std::tuple</a></span></dt>
 <dt><span class="section"><a href="fusion/adapted/mpl_sequence.html">mpl sequence</a></span></dt>
 <dt><span class="section"><a href="fusion/adapted/boost__array.html">boost::array</a></span></dt>
 <dt><span class="section"><a href="fusion/adapted/boost__tuple.html">boost::tuple</a></span></dt>
@@ -273,7 +278,7 @@
 </div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"><p><small>Last revised: May 10, 2013 at 05:54:18 GMT</small></p></td>
+<td align="left"><p><small>Last revised: June 25, 2015 at 13:41:27 GMT</small></p></td>
 <td align="right"><div class="copyright-footer"></div></td>
 </tr></table>
 <hr>

doc/iterator.qbk

@@ -67,8 +67,7 @@ the following expressions are valid:
 ]
 
 [heading Expression Semantics]
-[
-table
+[table
     [[Expression]              [Semantics]]
     [[`__next__(i)`]               [An iterator to the element following `i`]]
     [[`i == j`]                [Iterator equality comparison]]
@@ -258,6 +257,12 @@ expressions must be valid:
 
 [endsect]
 
+[section Unbounded Iterator]
+
+[warning In this release, __unbounded_iterator__ concept has no effect. It's reserved for future release.]
+
+[endsect]
+
 [endsect]
 
 [section Functions]
@@ -418,15 +423,15 @@ Moves an iterator by a specified distance.
 
 [heading Synopsis]
     template<
-        typename I,
-        typename M
+        typename M,
+        typename I
         >
     typename __result_of_advance__<I, M>::type advance(I const& i);
 
 [table Parameters
     [[Parameter]    [Requirement]   [Description]]
     [[`i`]          [Model of __forward_iterator__] [Iterator to move relative to]]
-    [[`N`]          [An __mpl_integral_constant__] [Number of positions to move]]
+    [[`M`]          [An __mpl_integral_constant__] [Number of positions to move]]
 ]
 
 [heading Expression Semantics]
@@ -455,8 +460,8 @@ Moves an iterator by a specified distance.
 
 [heading Synopsis]
     template<
-        typename I,
-        int N
+        int N,
+        typename I
         >
     typename __result_of_advance_c__<I, N>::type advance_c(I const& i);
 
@@ -537,7 +542,7 @@ Dereferences an iterator.
     template<
         typename I
         >
-    typename __result_of_deref__<I>::type operator*(__unspecified__<I> const& i);
+    typename __result_of_deref__<I>::type operator*(I const& i);
 
 [table Parameters
     [[Parameter]      [Requirement]    [Description]]

doc/notes.qbk

@@ -100,7 +100,7 @@ Array arguments are deduced to reference to const types. For example
 [footnote Note that the type of a string literal is an array of const
 characters, not `const char*`. To get __make_list__ to create a __list__
 with an element of a non-const array type one must use the `ref` wrapper
-(see __note_boost_ref__).]:
+(see __note_ref_wrappers__).]:
 
     __make_list__("Donald", "Daisy")
 
@@ -121,7 +121,7 @@ creates a __list__ of type
 
     __list__<void (*)(int)>
 
-[heading boost::ref]
+[heading Reference Wrappers]
 
 Fusion's generation functions (e.g. __make_list__) by default stores the
 element types as plain non-reference types. Example:
@@ -151,6 +151,8 @@ For example:
 
 See __boost_ref__ for details.
 
+Since C++11, the standard reference wrappers (`std::ref` and `std::cref`) work as well.
+
 [heading adt_attribute_proxy]
 
 To adapt arbitrary data types that do not allow direct access to their members,

doc/organization.qbk

@@ -36,20 +36,26 @@ link against.
 
 * tuple
 * algorithm
+    * auxiliary
     * iteration
     * query
     * transformation
 * adapted
+    * adt
     * array
-    * mpl
+    * boost::array
     * boost::tuple
+    * mpl
     * std_pair
+    * std_tuple
     * struct
-    * variant
 * view
     * filter_view
+    * flatten_view
     * iterator_range
     * joint_view
+    * nview
+    * repetitive_view
     * reverse_view
     * single_view
     * transform_view
@@ -63,6 +69,9 @@ link against.
     * generation
 * mpl
 * functional
+    * adapter
+    * generation
+    * invocation
 * sequence
     * comparison
     * intrinsic

doc/preface.qbk

@@ -49,16 +49,11 @@ and traversal routines. It was an instant /AHA!/ moment.
 Some icons are used to mark certain topics indicative of their relevance.
 These icons precede some text to indicate:
 
-[table Icons
-    [[Icon]         [Name]          [Meaning]]
-    [[__note__]     [Note]          [Information provided is auxiliary but will
-                                     give the reader a deeper insight into a specific
-                                     topic. May be skipped.]]
-    [[__alert__]    [Alert]         [Information provided is of utmost importance.]]
-    [[__caution__]  [Caution]       [A mild warning.]]
-    [[__tip__]      [Tip]           [A potentially useful and helpful piece of
-                                     information.]]
-]
+[note Information provided is auxiliary but will give the reader a deeper
+insight into a specific topic. May be skipped.]
+[important Information provided is of utmost importance.]
+[caution A mild warning.]
+[tip A potentially useful and helpful piece of information.]
 
 This documentation is automatically generated by Boost QuickBook documentation
 tool. QuickBook can be found in the __boost_tools__.
@@ -66,11 +61,8 @@ tool. QuickBook can be found in the __boost_tools__.
 [heading Support]
 
 Please direct all questions to Spirit's mailing list. You can subscribe to the
-__spirit_list__. The mailing list has a searchable archive. A search link to
-this archive is provided in __spirit__'s home page. You may also read and post
-messages to the mailing list through __spirit_general__ (thanks to __gmane__).
-The news group mirrors the mailing list. Here is a link to the archives:
-__mlist_archive__.
+__spirit_list__. The mailing list has a searchable archive. Here is a link to
+the archives: __list_archive__.
 
 [endsect]
 

doc/references.qbk

@@ -1,6 +1,7 @@
 [/==============================================================================
     Copyright (C) 2001-2011 Joel de Guzman
     Copyright (C) 2006 Dan Marsden
+    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
@@ -8,20 +9,20 @@
 ===============================================================================/]
 [section References]
 
-# [@http://boost.org/libs/iterator/doc/new-iter-concepts.html New Iterator Concepts],
+# [@http://www.boost.org/libs/iterator/doc/new-iter-concepts.html New Iterator Concepts],
   David Abrahams, Jeremy Siek, Thomas Witt, 2004-11-01.
-# [@http://boost.org/libs/tuple/doc/tuple_users_guide.html The Boost Tuple Library],
+# [@http://www.boost.org/libs/tuple The Boost Tuple Library],
   Jaakko Jarvi, 2001.
-# [@http://www.boost.org/libs/spirit/ Spirit Parser Library],
+# [@http://www.boost.org/libs/spirit Spirit Parser Library],
   Joel de Guzman, 2001-2006.
-# [@http://www.boost.org/libs/mpl/ The Boost MPL Library],
+# [@http://www.boost.org/libs/mpl The Boost MPL Library],
   Aleksey Gurtovoy and David Abrahams, 2002-2004.
-# [@http://www.boost.org/doc/html/array.html Boost Array],
+# [@http://www.boost.org/libs/array The Boost Array Library],
   Nicolai Josuttis, 2002-2004.
-# [@http://www.sgi.com/tech/stl/ Standard Template Library Programmer's Guide],
-  Hewlett-Packard Company, 1994.
-# [@http://www.boost.org/doc/html/ref.html Boost.Ref],
+# [@http://www.boost.org/libs/core/ref.html Boost.Core / Ref utility],
   Jaakko Jarvi, Peter Dimov, Douglas Gregor, Dave Abrahams, 1999-2002.
+# [@http://www.boost.org/libs/hana The Boost Hana Library],
+  Louis Dionne, 2017.
 
 [endsect]
 

doc/sequence.qbk

@@ -39,6 +39,11 @@ These concepts pertain to sequence traversal.
 The __associative_sequence__ concept is orthogonal to traversal. An Associative
 Sequence allows efficient retrieval of elements based on keys.
 
+[heading Boundary]
+
+The __unbounded_sequence__ concept is also orthogonal to traversal and associativity.
+A Unbounded Sequence allows out-of-bounds access.
+
 [section Forward Sequence]
 
 [heading Description]
@@ -249,15 +254,18 @@ any Random Access Sequence the following must be met:
     [[Expression]                           [Compile Time Complexity]]
     [[`__result_of_begin__<S>::type`]          [Amortized constant time]]
     [[`__result_of_end__<S>::type`]            [Amortized constant time]]
-    [[`__result_of_at__<S, N>::type`]          [Amortized constant time]]
-    [[`__result_of_value_at__<S, N>::type`]    [Amortized constant time]]
+    [[`__result_of_at__<S, M>::type`]          [Amortized constant time]]
+    [[`__result_of_at_c__<S, N>::type`]        [Amortized constant time]]
+    [[`__result_of_value_at__<S, M>::type`]    [Amortized constant time]]
+    [[`__result_of_value_at_c__<S, N>::type`]  [Amortized constant time]]
 ]
 
-[blurb __note__ `__result_of_at__<S, N>` returns the actual type returned by
-`__at__<N>(s)`. In most cases, this is a reference. Hence, there is no way to
-know the exact element type using `__result_of_at__<S, N>`.The element at `N`
+[note `__result_of_at__<S, M>` returns the actual type returned by
+`__at__<M>(s)`. In most cases, this is a reference. Hence, there is no way to
+know the exact element type using `__result_of_at__<S, M>`.The element at `M`
 may actually be a reference to begin with. For this purpose, you can use
-`__result_of_value_at__<S, N>`.]
+`__result_of_value_at__<S, M>` (Note that, `__result_of_value_at_c__<S, N>`
+is a counterpart of `__result_of_at_c__<S, N>` as well).]
 
 [heading Expression Semantics]
 
@@ -327,11 +335,11 @@ For any Associative Sequence the following expressions must be valid:
     [[`__result_of_value_at_key__<S, K>::type`]    [Amortized constant time]]
 ]
 
-[blurb __note__ `__result_of_at_key__<S, K>` returns the actual type returned
+[note `__result_of_at_key__<S, K>` returns the actual type returned
 by `__at_key__<K>(s)`. In most cases, this is a reference. Hence, there is no
 way to know the exact element type using `__result_of_at_key__<S, K>`.The
 element at `K` may actually be a reference to begin with. For this purpose,
-you can use `__result_of_value_at_key__<S, N>`.]
+you can use `__result_of_value_at_key__<S, K>`.]
 
 [heading Expression Semantics]
 
@@ -356,6 +364,55 @@ you can use `__result_of_value_at_key__<S, N>`.]
 
 [endsect]
 
+[section Unbounded Sequence]
+
+[heading Description]
+
+A Unbounded Sequence allows Out-of-Bounds access: it will achieve something like a __window_function__.
+Most of the sequences do not meet this concept, but some special usecases do.
+
+[important User extending sequences should handle any parameters or be SFINAE-friendly.]
+
+[variablelist Notation
+    [[`s`]       [An Fusion Sequence]]
+    [[`S`]       [An Fusion Sequence type]]
+    [[`M`]       [An __mpl__ integral constant]]
+    [[`N`]       [An integral constant]]
+    [[`K`]       [An arbitrary /key/ type]]
+    [[`o`]       [An arbitrary object]]
+    [[`e`]       [A Sequence element]]
+]
+
+[heading Valid Expressions]
+
+[table
+    [[Expression]               [Return type]   [Type Requirements]                         [Runtime Complexity]]
+    [[`__at_c__<N>(s)`]         [Any type]      []                                          [Depends on its traversability]]
+    [[`__at_c__<N>(s) = o`]     [Any type]      []                                          [Depends on its traversability]]
+    [[`__at__<M>(s)`]           [Any type]      []                                          [Depends on its traversability]]
+    [[`__at__<M>(s) = o`]       [Any type]      []                                          [Depends on its traversability]]
+    [[`__at_key__<K>(s)`]       [Any type]      [`S` should be __associative_sequence__]    [Depends on its traversability]]
+    [[`__at_key__<K>(s) = o`]   [Any type]      [`S` should be __associative_sequence__]    [Depends on its traversability]]
+]
+
+[heading Result Type Expressions]
+
+[table
+    [[Expression]                               [Compile Time Complexity]]
+    [[`__result_of_at__<S, M>::type`]           [Depends on its traversability]]
+    [[`__result_of_at_c__<S, N>::type`]         [Depends on its traversability]]
+    [[`__result_of_value_at__<S, M>::type`]     [Depends on its traversability]]
+    [[`__result_of_value_at_c__<S, N>::type`]   [Depends on its traversability]]
+    [[`__result_of_at_key__<S, K>::type`]       [Depends on its traversability]]
+    [[`__result_of_value_at_key__<S, K>::type`] [Depends on its traversability]]
+]
+
+[heading Models]
+
+* none.
+
+[endsect]
+
 [endsect]
 
 [section Intrinsic]
@@ -683,7 +740,7 @@ element from the beginning of the sequence, is a valid expression. Else,
 returns a type convertible to the M-th element from the beginning of the
 sequence.
 
-[*Precondition]: `0 <= M::value < __size__(s)`
+[*Precondition]: `0 <= M::value < __size__(seq)` (where `seq` is not __unbounded_sequence__)
 
 [*Semantics]: Equivalent to
 
@@ -736,7 +793,7 @@ element from the beginning of the sequence, is a valid expression. Else,
 returns a type convertible to the N-th element from the beginning of the
 sequence.
 
-[*Precondition]: `0 <= N < __size__(s)`
+[*Precondition]: `0 <= N < __size__(seq)` (where `seq` is not __unbounded_sequence__)
 
 [*Semantics]: Equivalent to
 
@@ -830,7 +887,7 @@ the sequence `seq` if `seq` is mutable and `e = o`, where `e` is the
 element associated with Key, is a valid expression. Else, returns a type
 convertible to the element associated with Key.
 
-[*Precondition]: `has_key<Key>(seq) == true`
+[*Precondition]: `has_key<Key>(seq) == true` (where `seq` is not __unbounded_sequence__)
 
 [*Semantics]: Returns the element associated with Key.
 
@@ -1146,6 +1203,8 @@ the actual element type, use __result_of_value_at__].
 
 [*Return type]: Any type.
 
+[*Precondition]: `0 <= M::value < __result_of_size__<Seq>::value` (where `Seq` is not __unbounded_sequence__)
+
 [*Semantics]: Returns the result type of using __at__ to access the `M`th element of `Seq`.
 
 [heading Header]
@@ -1188,6 +1247,8 @@ get the actual element type, use __result_of_value_at_c__].
 
 [*Return type]: Any type
 
+[*Precondition]: `0 <= N < __result_of_size__<Seq>::value` (where `Seq` is not __unbounded_sequence__)
+
 [*Semantics]: Returns the result type of using __at_c__ to access the `N`th element of `Seq`.
 
 [heading Header]
@@ -1323,7 +1384,7 @@ Returns the result type of __has_key__.
 [heading Description]
 
 Returns the result type of __at_key__[footnote __result_of_at_key__
-reflects the actual return type of the function __at_key__. __sequence__s
+reflects the actual return type of the function __at_key__. __sequence__(s)
 typically return references to its elements via the __at_key__ function. If
 you want to get the actual element type, use __result_of_value_at_key__].
 
@@ -1347,6 +1408,8 @@ you want to get the actual element type, use __result_of_value_at_key__].
 
 [*Return type]: Any type.
 
+[*Precondition]: `has_key<Seq, Key>::type::value == true` (where `Seq` is not __unbounded_sequence__)
+
 [*Semantics]: Returns the result of using __at_key__ to access the element with key type `Key` in `Seq`.
 
 [heading Header]
@@ -1385,6 +1448,8 @@ Returns the actual element type associated with a Key from the __sequence__.
 
 [*Return type]: Any type.
 
+[*Precondition]: `has_key<Seq, Key>::type::value == true` (where `Seq` is not __unbounded_sequence__)
+
 [*Semantics]: Returns the actual element type associated with key type
 `Key` in `Seq`.
 
@@ -1445,7 +1510,7 @@ operators for free.
 
 The I/O operators: `<<` and `>>` work generically on all Fusion
 sequences. The I/O operators are overloaded in namespace `boost::fusion`
-[footnote __sequences__ and __views__ residing in different namespaces
+[footnote __sequence__(s) and __views__ residing in different namespaces
 will have to either provide their own I/O operators (possibly forwarding
 to fusion's I/O operators) or hoist fusion's I/O operators (using
 declaration), in their own namespaces for proper argument dependent
@@ -1457,6 +1522,16 @@ each element. Analogously, the global `operator>>` has been overloaded
 to extract __sequence__(s) from generic input streams by recursively
 calling `operator>>` for each element.
 
+Please note that, to display your adapted types via fusion IO system,
+corresponding overloaded operators should be introduced to same namespace
+of the type.
+
+    namespace your_awesome_library
+    {
+        using boost::fusion::operators::operator>>; // for input
+        using boost::fusion::operators::operator<<; // for output
+        ...
+
 The default delimiter between the elements is space, and the __sequence__
 is enclosed in parenthesis. For Example:
 
@@ -1637,7 +1712,7 @@ compile time error.
 [*Semantics]:
 
 For each element, `e1`, in  sequence `a`, and for each element, `e2`, in
-sequence `b`, `e1 == e2` returns true. For any 2 zero length __sequence__s,
+sequence `b`, `e1 == e2` returns true. For any 2 zero length __sequence__(s),
 e and f, e == f  returns true.
 
 [heading Header]

doc/support.qbk

@@ -227,6 +227,8 @@ And optionally from:
         namespace boost { namespace fusion
         {
             struct associative_tag {};
+
+            struct unbounded_tag {};
         }}
 
 [*Semantics]: Establishes the conceptual classification of a particular
@@ -254,7 +256,8 @@ Metafunction to apply __element_conversion__ to the full argument type.
 
 It removes references to `const`, references to array types are kept, even
 if the array is `const`. Reference wrappers are removed (see
-__note_boost_ref__).
+__note_ref_wrappers__)[footnote Since C++11, the standard reference wrappers
+are also removed.].
 
 [heading Header]
 

doc/view.qbk

@@ -93,10 +93,9 @@ presents only those elements for which its predicate evaluates to
 [heading Template parameters]
 
 [table
-    [[Parameter]            [Description]               [Default]]
-    [[`Sequence`]           [A __forward_sequence__]    []]
-    [[`Pred`]               [Unary Metafunction
-                             returning an `mpl::bool_`] []]
+    [[Parameter]            [Description]                       [Default]]
+    [[`Sequence`]           [A __forward_sequence__]            []]
+    [[`Pred`]               [A unary __mpl_lambda_expression__] []]
 ]
 
 [heading Model of]
@@ -271,7 +270,7 @@ defined in the implemented models.
 [heading Description]
 
 `zip_view` presents a view which iterates over a collection of __sequence__(s) in parallel. A `zip_view`
-is constructed from a __sequence__ of references to the component __sequence__s.
+is constructed from a __sequence__ of references to the component `__sequence__`s.
 
 [heading Header]
 
@@ -287,7 +286,7 @@ is constructed from a __sequence__ of references to the component __sequence__s.
 
 [table
     [[Parameter]            [Description]                   [Default]]
-    [[`Sequences`]          [A __forward_sequence__ of references to other Fusion __sequence__s]        []]
+    [[`Sequences`]          [A __forward_sequence__ of references to other Fusion `__sequence__`s]        []]
 ]
 
 [heading Model of]
@@ -309,7 +308,7 @@ defined in __forward_sequence__.
 
 [table
     [[Expression]           [Semantics]]
-    [[`ZV(s)`]              [Creates a `zip_view` given a sequence of references to the component __sequence__s.]]
+    [[`ZV(s)`]              [Creates a `zip_view` given a sequence of references to the component `__sequence__`s.]]
     [[`ZV(zv1)`]             [Copy constructs a `zip_view` from another `zip_view`, `zv`.]]
     [[`zv1 = zv2`]           [Assigns to a `zip_view`, `zv`, from another `zip_view`, `zv2`.]]
 ]

include/boost/fusion/adapted/adt/adapt_adt.hpp

@@ -15,12 +15,7 @@
 #include <boost/preprocessor/cat.hpp>
 #include <boost/preprocessor/empty.hpp>
 #include <boost/preprocessor/control/if.hpp>
-#include <boost/preprocessor/comparison/equal.hpp>
 #include <boost/preprocessor/comparison/less.hpp>
-#include <boost/type_traits/add_reference.hpp>
-#include <boost/type_traits/is_const.hpp>
-#include <boost/type_traits/add_const.hpp>
-#include <boost/type_traits/remove_const.hpp>
 
 #include <boost/fusion/adapted/struct/detail/extension.hpp>
 #include <boost/fusion/adapted/struct/detail/adapt_base.hpp>
@@ -45,13 +40,11 @@
             TEMPLATE_PARAMS_SEQ,                                                \
             NAME_SEQ,                                                           \
             I,                                                                  \
-            BOOST_PP_IF(IS_VIEW, BOOST_FUSION_PROXY_PREFIX, BOOST_PP_EMPTY),    \
+            BOOST_PP_IIF(IS_VIEW, BOOST_FUSION_PROXY_PREFIX, BOOST_PP_EMPTY),   \
             BOOST_FUSION_ADAPT_ADT_WRAPPEDATTR(ATTRIBUTE),                      \
             BOOST_FUSION_ADAPT_ADT_WRAPPEDATTR_SIZE(ATTRIBUTE),                 \
-            BOOST_PP_IF(                                                        \
-                BOOST_PP_LESS(                                                  \
-                    BOOST_FUSION_ADAPT_ADT_WRAPPEDATTR_SIZE(ATTRIBUTE), 4)      \
-                , 1, 0))    
+            BOOST_PP_LESS(                                                      \
+                BOOST_FUSION_ADAPT_ADT_WRAPPEDATTR_SIZE(ATTRIBUTE), 4))         \
 
 #define BOOST_FUSION_ADAPT_TPL_ADT(TEMPLATE_PARAMS_SEQ, NAME_SEQ , ATTRIBUTES)  \
     BOOST_FUSION_ADAPT_STRUCT_BASE(                                             \

include/boost/fusion/adapted/adt/adapt_assoc_adt.hpp

@@ -14,10 +14,7 @@
 #include <boost/fusion/support/config.hpp>
 #include <boost/preprocessor/cat.hpp>
 #include <boost/preprocessor/empty.hpp>
-#include <boost/preprocessor/tuple/elem.hpp>
-#include <boost/type_traits/add_reference.hpp>
-#include <boost/type_traits/is_const.hpp>
-#include <boost/type_traits/remove_const.hpp>
+#include <boost/preprocessor/control/if.hpp>
 
 #include <boost/fusion/adapted/struct/detail/extension.hpp>
 #include <boost/fusion/adapted/struct/detail/adapt_base.hpp>
@@ -46,13 +43,11 @@
             TEMPLATE_PARAMS_SEQ,                                                \
             NAME_SEQ,                                                           \
             I,                                                                  \
-            BOOST_PP_IF(IS_VIEW, BOOST_FUSION_PROXY_PREFIX, BOOST_PP_EMPTY),    \
+            BOOST_PP_IIF(IS_VIEW, BOOST_FUSION_PROXY_PREFIX, BOOST_PP_EMPTY),   \
             BOOST_FUSION_ADAPT_ADT_WRAPPEDATTR(ATTRIBUTE),                      \
             BOOST_FUSION_ADAPT_ADT_WRAPPEDATTR_SIZE(ATTRIBUTE),                 \
-            BOOST_PP_IF(                                                        \
-                BOOST_PP_LESS(                                                  \
-                    BOOST_FUSION_ADAPT_ADT_WRAPPEDATTR_SIZE(ATTRIBUTE), 5)      \
-                , 1, 0))                                                        \
+            BOOST_PP_LESS(                                                      \
+                BOOST_FUSION_ADAPT_ADT_WRAPPEDATTR_SIZE(ATTRIBUTE), 5))         \
                                                                                 \
     template<                                                                   \
         BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS(TEMPLATE_PARAMS_SEQ)   \

include/boost/fusion/adapted/adt/detail/adapt_base.hpp

@@ -15,12 +15,14 @@
 #include <boost/fusion/adapted/struct/detail/adapt_is_tpl.hpp>
 
 #include <boost/preprocessor/control/if.hpp>
+#include <boost/preprocessor/control/expr_if.hpp>
 #include <boost/preprocessor/seq/seq.hpp>
 #include <boost/preprocessor/seq/elem.hpp>
+#include <boost/preprocessor/tuple/elem.hpp>
 #include <boost/mpl/if.hpp>
 #include <boost/type_traits/is_const.hpp>
-#include <boost/type_traits/add_const.hpp>
 #include <boost/type_traits/remove_const.hpp>
+#include <boost/type_traits/remove_reference.hpp>
 
 #include <boost/typeof/typeof.hpp>
 
@@ -36,18 +38,18 @@
     boost::remove_const<boost::remove_reference<lvalue>::type>::type
 
 #define BOOST_FUSION_ADAPT_ADT_ATTRIBUTE_GETEXPR(ATTRIBUTE,                     \
-    ATTRIBUTE_TUPEL_SIZE, DEDUCE_TYPE)                                          \
-    BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPEL_SIZE,                                   \
+    ATTRIBUTE_TUPLE_SIZE, DEDUCE_TYPE)                                          \
+    BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPLE_SIZE,                                   \
         BOOST_PP_IF(DEDUCE_TYPE, 0, 2), ATTRIBUTE)
 
 #define BOOST_FUSION_ADAPT_ADT_ATTRIBUTE_SETEXPR(ATTRIBUTE,                     \
-    ATTRIBUTE_TUPEL_SIZE, DEDUCE_TYPE)                                          \
-    BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPEL_SIZE,                                   \
+    ATTRIBUTE_TUPLE_SIZE, DEDUCE_TYPE)                                          \
+    BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPLE_SIZE,                                   \
         BOOST_PP_IF(DEDUCE_TYPE, 1, 3), ATTRIBUTE)
 
 #ifdef BOOST_MSVC
 #   define BOOST_FUSION_DEDUCED_ATTR_TYPE(NAME_SEQ, ATTRIBUTE,                  \
-        ATTRIBUTE_TUPEL_SIZE, PREFIX, TEMPLATE_PARAMS_SEQ)                      \
+        ATTRIBUTE_TUPLE_SIZE, PREFIX, TEMPLATE_PARAMS_SEQ)                      \
                                                                                 \
     BOOST_FUSION_ADAPT_STRUCT_MSVC_REDEFINE_TEMPLATE_PARAMS(                    \
         TEMPLATE_PARAMS_SEQ)                                                    \
@@ -55,52 +57,45 @@
     struct deduced_attr_type {                                                  \
       static const BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)& obj;        \
       typedef                                                                   \
-          BOOST_PP_IF(BOOST_FUSION_ADAPT_IS_TPL(TEMPLATE_PARAMS_SEQ),typename,) \
+          BOOST_PP_EXPR_IF(BOOST_FUSION_ADAPT_IS_TPL(TEMPLATE_PARAMS_SEQ),      \
+                           typename)                                            \
           BOOST_TYPEOF( PREFIX() BOOST_FUSION_ADAPT_ADT_ATTRIBUTE_GETEXPR(      \
-              ATTRIBUTE, ATTRIBUTE_TUPEL_SIZE, 1)) type;                        \
+              ATTRIBUTE, ATTRIBUTE_TUPLE_SIZE, 1)) type;                        \
     };
 
 #else
 #   define BOOST_FUSION_DEDUCED_ATTR_TYPE(NAME_SEQ, ATTRIBUTE,                  \
-        ATTRIBUTE_TUPEL_SIZE, PREFIX, TEMPLATE_PARAMS_SEQ)                      \
+        ATTRIBUTE_TUPLE_SIZE, PREFIX, TEMPLATE_PARAMS_SEQ)                      \
     struct deduced_attr_type {                                                  \
       static const BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)& obj;        \
       typedef BOOST_TYPEOF( PREFIX() BOOST_FUSION_ADAPT_ADT_ATTRIBUTE_GETEXPR(  \
-                      ATTRIBUTE, ATTRIBUTE_TUPEL_SIZE, 1)) type;                \
+                      ATTRIBUTE, ATTRIBUTE_TUPLE_SIZE, 1)) type;                \
     };
 
 #endif
 
 #define BOOST_FUSION_ADT_ATTRIBUTE_TYPEOF(                                      \
-    NAME_SEQ, ATTRIBUTE, ATTRIBUTE_TUPEL_SIZE, PREFIX, TEMPLATE_PARAMS_SEQ)     \
+    NAME_SEQ, ATTRIBUTE, ATTRIBUTE_TUPLE_SIZE, PREFIX, TEMPLATE_PARAMS_SEQ)     \
                                                                                 \
     BOOST_FUSION_DEDUCED_ATTR_TYPE(                                             \
-        NAME_SEQ, ATTRIBUTE, ATTRIBUTE_TUPEL_SIZE, PREFIX, TEMPLATE_PARAMS_SEQ) \
+        NAME_SEQ, ATTRIBUTE, ATTRIBUTE_TUPLE_SIZE, PREFIX, TEMPLATE_PARAMS_SEQ) \
                                                                                 \
     typedef                                                                     \
-        BOOST_PP_IF(BOOST_FUSION_ADAPT_IS_TPL(TEMPLATE_PARAMS_SEQ),typename,)   \
-        boost::remove_const<                                                    \
-          BOOST_PP_IF(BOOST_FUSION_ADAPT_IS_TPL(TEMPLATE_PARAMS_SEQ),typename,) \
-          deduced_attr_type::type                                               \
-        >::type type;                                                           \
-                                                                                \
-    typedef                                                                     \
-        BOOST_PP_IF(BOOST_FUSION_ADAPT_IS_TPL(TEMPLATE_PARAMS_SEQ),typename,)   \
-        boost::add_const<                                                       \
-          BOOST_PP_IF(BOOST_FUSION_ADAPT_IS_TPL(TEMPLATE_PARAMS_SEQ),typename,) \
-          deduced_attr_type::type                                               \
-    >::type const_type;
+        BOOST_PP_EXPR_IF(BOOST_FUSION_ADAPT_IS_TPL(TEMPLATE_PARAMS_SEQ),        \
+                         typename)                                              \
+        deduced_attr_type::type type;                                           \
+    typedef type const_type;
 
 #define BOOST_FUSION_ADT_ATTRIBUTE_GIVENTYPE(                                   \
-    NAME_SEQ, ATTRIBUTE, ATTRIBUTE_TUPEL_SIZE, PREFIX, TEMPLATE_PARAMS_SEQ)     \
+    NAME_SEQ, ATTRIBUTE, ATTRIBUTE_TUPLE_SIZE, PREFIX, TEMPLATE_PARAMS_SEQ)     \
                                                                                 \
-    typedef BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPEL_SIZE, 0, ATTRIBUTE) type;       \
-    typedef BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPEL_SIZE, 1, ATTRIBUTE) const_type;
+    typedef BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPLE_SIZE, 0, ATTRIBUTE) type;       \
+    typedef BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPLE_SIZE, 1, ATTRIBUTE) const_type;
 
 
 #define BOOST_FUSION_ADAPT_ADT_C_BASE(                                          \
     TEMPLATE_PARAMS_SEQ,NAME_SEQ,I,PREFIX,                                      \
-    ATTRIBUTE,ATTRIBUTE_TUPEL_SIZE, DEDUCE_TYPE)                                \
+    ATTRIBUTE,ATTRIBUTE_TUPLE_SIZE, DEDUCE_TYPE)                                \
                                                                                 \
     template<                                                                   \
         BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS(TEMPLATE_PARAMS_SEQ)   \
@@ -116,19 +111,19 @@
             BOOST_FUSION_ADT_ATTRIBUTE_GIVENTYPE)(                              \
                 NAME_SEQ,                                                       \
                 ATTRIBUTE,                                                      \
-                ATTRIBUTE_TUPEL_SIZE,                                           \
+                ATTRIBUTE_TUPLE_SIZE,                                           \
                 PREFIX,                                                         \
                 TEMPLATE_PARAMS_SEQ)                                            \
                                                                                 \
         template<class Val>                                                     \
-        BOOST_FUSION_GPU_ENABLED                                                \
+        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED                          \
         static void                                                             \
         boost_fusion_adapt_adt_impl_set(                                        \
             BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)& obj,               \
             Val const& val)                                                     \
         {                                                                       \
            PREFIX() BOOST_FUSION_ADAPT_ADT_ATTRIBUTE_SETEXPR(ATTRIBUTE,         \
-                ATTRIBUTE_TUPEL_SIZE, DEDUCE_TYPE);                             \
+                ATTRIBUTE_TUPLE_SIZE, DEDUCE_TYPE);                             \
         }                                                                       \
                                                                                 \
         BOOST_FUSION_GPU_ENABLED                                                \
@@ -137,7 +132,7 @@
             BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)& obj)               \
         {                                                                       \
             return PREFIX() BOOST_FUSION_ADAPT_ADT_ATTRIBUTE_GETEXPR(ATTRIBUTE, \
-                ATTRIBUTE_TUPEL_SIZE, DEDUCE_TYPE);                             \
+                ATTRIBUTE_TUPLE_SIZE, DEDUCE_TYPE);                             \
         }                                                                       \
                                                                                 \
         BOOST_FUSION_GPU_ENABLED                                                \
@@ -146,7 +141,7 @@
             BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ) const& obj)         \
         {                                                                       \
             return PREFIX() BOOST_FUSION_ADAPT_ADT_ATTRIBUTE_GETEXPR(ATTRIBUTE, \
-                ATTRIBUTE_TUPEL_SIZE, DEDUCE_TYPE);                             \
+                ATTRIBUTE_TUPLE_SIZE, DEDUCE_TYPE);                             \
         }                                                                       \
     };                                                                          \
                                                                                 \
@@ -160,13 +155,13 @@
     >                                                                           \
     {                                                                           \
         typedef                                                                 \
-            BOOST_PP_IF(BOOST_PP_SEQ_HEAD(TEMPLATE_PARAMS_SEQ), typename, )     \
+            BOOST_PP_EXPR_IF(BOOST_PP_SEQ_HEAD(TEMPLATE_PARAMS_SEQ), typename)  \
             access::adt_attribute_access<                                       \
                 BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)                 \
               , I                                                               \
             >::const_type type;                                                 \
                                                                                 \
-        BOOST_FUSION_GPU_ENABLED                                                \
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED                                \
         explicit                                                                \
         adt_attribute_proxy(                                                    \
             BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ) const& o)           \
@@ -201,13 +196,13 @@
     >                                                                           \
     {                                                                           \
         typedef                                                                 \
-            BOOST_PP_IF(BOOST_PP_SEQ_HEAD(TEMPLATE_PARAMS_SEQ), typename, )     \
+            BOOST_PP_EXPR_IF(BOOST_PP_SEQ_HEAD(TEMPLATE_PARAMS_SEQ), typename)  \
             access::adt_attribute_access<                                       \
                 BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)                 \
               , I                                                               \
             >::type type;                                                       \
                                                                                 \
-        BOOST_FUSION_GPU_ENABLED                                                \
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED                                \
         explicit                                                                \
         adt_attribute_proxy(                                                    \
             BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)& o)                 \
@@ -215,7 +210,7 @@
         {}                                                                      \
                                                                                 \
         template<class Val>                                                     \
-        BOOST_FUSION_GPU_ENABLED                                                \
+        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED                          \
         adt_attribute_proxy&                                                    \
         operator=(Val const& val)                                               \
         {                                                                       \
@@ -252,7 +247,8 @@
       , I                                                                       \
     >                                                                           \
     {                                                                           \
-        typedef BOOST_PP_IF(BOOST_PP_SEQ_HEAD(TEMPLATE_PARAMS_SEQ), typename, ) \
+        typedef BOOST_PP_EXPR_IF(BOOST_PP_SEQ_HEAD(TEMPLATE_PARAMS_SEQ),        \
+                                 typename)                                      \
             adt_attribute_proxy<                                                \
                           BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)       \
                         , I                                                     \
@@ -281,7 +277,7 @@
                 >                                                               \
             type;                                                               \
                                                                                 \
-            BOOST_FUSION_GPU_ENABLED                                            \
+            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED                            \
             static type                                                         \
             call(Seq& obj)                                                      \
             {                                                                   \

include/boost/fusion/adapted/adt/detail/adapt_base_assoc_attr_filler.hpp

@@ -10,12 +10,15 @@
 
 #include <boost/config.hpp>
 
+#include <boost/fusion/adapted/struct/detail/adapt_auto.hpp>
 #include <boost/fusion/adapted/adt/detail/adapt_base_attr_filler.hpp>
 
-#include <boost/preprocessor/control/if.hpp>
+#include <boost/mpl/aux_/preprocessor/token_equal.hpp>
+
+#include <boost/preprocessor/config/config.hpp>
+#include <boost/preprocessor/control/iif.hpp>
 #include <boost/preprocessor/variadic/size.hpp>
-#include <boost/preprocessor/empty.hpp>
-#include <boost/preprocessor/facilities/is_empty.hpp>
+#include <boost/preprocessor/arithmetic/dec.hpp>
 
 #if BOOST_PP_VARIADICS
 
@@ -41,7 +44,7 @@
     BOOST_FUSION_ADAPT_ASSOC_ADT_FILLER_0
 
 #define BOOST_FUSION_ADAPT_ASSOC_ADT_WRAP_ATTR(A, B, C, D, E)                   \
-    BOOST_PP_IF(BOOST_PP_IS_EMPTY(A),                                           \
+    BOOST_PP_IIF(BOOST_MPL_PP_TOKEN_EQUAL(auto, A),                             \
         ((3, (C,D,E))),                                                         \
         ((5, (A,B,C,D,E)))                                                      \
     )
@@ -55,7 +58,7 @@
 #define BOOST_FUSION_ADAPT_ASSOC_ADT_WRAPPEDATTR_GET_KEY(ATTRIBUTE)             \
     BOOST_PP_TUPLE_ELEM(                                                        \
         BOOST_FUSION_ADAPT_ADT_WRAPPEDATTR_SIZE(ATTRIBUTE),                     \
-        BOOST_PP_SUB(BOOST_FUSION_ADAPT_ADT_WRAPPEDATTR_SIZE(ATTRIBUTE), 1),    \
+        BOOST_PP_DEC(BOOST_FUSION_ADAPT_ADT_WRAPPEDATTR_SIZE(ATTRIBUTE)),       \
         BOOST_FUSION_ADAPT_ADT_WRAPPEDATTR(ATTRIBUTE))
 
 #endif

include/boost/fusion/adapted/adt/detail/adapt_base_attr_filler.hpp

@@ -9,23 +9,21 @@
 #define BOOST_FUSION_ADAPTED_ADT_DETAIL_ADAPT_BASE_ATTR_FILLER_HPP
 
 #include <boost/config.hpp>
+
+#include <boost/fusion/adapted/struct/detail/adapt_auto.hpp>
 #include <boost/fusion/adapted/struct/detail/preprocessor/is_seq.hpp>
 
-#include <boost/preprocessor/arithmetic/sub.hpp>
-#include <boost/preprocessor/control/if.hpp>
-#include <boost/preprocessor/logical/or.hpp>
-#include <boost/preprocessor/empty.hpp>
-#include <boost/preprocessor/tuple/size.hpp>
-#include <boost/preprocessor/tuple/elem.hpp>
-#include <boost/preprocessor/facilities/is_empty.hpp>
-#include <boost/preprocessor/variadic/to_seq.hpp>
-#include <boost/preprocessor/variadic/to_tuple.hpp>
-#include <boost/preprocessor/variadic/elem.hpp>
-#include <boost/preprocessor/seq/for_each.hpp>
-#include <boost/preprocessor/seq/push_front.hpp>
-#include <boost/preprocessor/seq/rest_n.hpp>
+#include <boost/mpl/aux_/preprocessor/token_equal.hpp>
 
-#include <boost/preprocessor/tuple/reverse.hpp>
+#include <boost/preprocessor/arithmetic/dec.hpp>
+#include <boost/preprocessor/control/iif.hpp>
+#include <boost/preprocessor/logical/or.hpp>
+#include <boost/preprocessor/tuple/elem.hpp>
+#include <boost/preprocessor/variadic/to_seq.hpp>
+#include <boost/preprocessor/variadic/size.hpp>
+#include <boost/preprocessor/variadic/elem.hpp>
+#include <boost/preprocessor/seq/seq.hpp>
+#include <boost/preprocessor/seq/rest_n.hpp>
 
 
 #define BOOST_FUSION_ADAPT_ADT_WRAPPEDATTR_SIZE(ATTRIBUTE)                      \
@@ -47,11 +45,15 @@
 #  define BOOST_FUSION_ADAPT_ADT_FILLER_0_END
 #  define BOOST_FUSION_ADAPT_ADT_FILLER_1_END
 
+// MSVC don't compile when using BOOST_PP_BITOR instead of BOOST_PP_OR.
 #  define BOOST_FUSION_ADAPT_ADT_FILLER(...)                                    \
-      BOOST_PP_IF(                                                              \
+      BOOST_PP_IIF(                                                             \
           BOOST_PP_OR(                                                          \
-              BOOST_PP_IS_EMPTY(BOOST_PP_VARIADIC_ELEM(0, __VA_ARGS__)),        \
-              BOOST_PP_IS_EMPTY(BOOST_PP_VARIADIC_ELEM(1, __VA_ARGS__))),       \
+              BOOST_MPL_PP_TOKEN_EQUAL(auto,                                    \
+                  BOOST_PP_VARIADIC_ELEM(0, __VA_ARGS__)),                      \
+              BOOST_MPL_PP_TOKEN_EQUAL(auto,                                    \
+                  BOOST_PP_VARIADIC_ELEM(1, __VA_ARGS__))),                     \
+                                                                                \
           BOOST_FUSION_ADAPT_ADT_WRAP_ATTR(                                     \
               BOOST_PP_VARIADIC_ELEM(2, __VA_ARGS__),                           \
               BOOST_FUSION_WORKAROUND_VARIADIC_EMPTINESS_LAST_ELEM(__VA_ARGS__) \
@@ -63,7 +65,7 @@
 
 #  define BOOST_FUSION_WORKAROUND_VARIADIC_EMPTINESS_LAST_ELEM(...)             \
   BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_REST_N(                                        \
-            BOOST_PP_SUB(BOOST_PP_VARIADIC_SIZE(__VA_ARGS__), 1),               \
+            BOOST_PP_DEC(BOOST_PP_VARIADIC_SIZE(__VA_ARGS__)),                  \
         BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__)))
 
 #else // BOOST_PP_VARIADICS
@@ -80,7 +82,7 @@
 #  define BOOST_FUSION_ADAPT_ADT_FILLER_1_END
 
 #  define BOOST_FUSION_ADAPT_ADT_WRAP_ATTR(A, B, C, D)                          \
-      BOOST_PP_IF(BOOST_PP_IS_EMPTY(A),                                         \
+      BOOST_PP_IIF(BOOST_MPL_PP_TOKEN_EQUAL(auto, A),                           \
         ((2, (C,D))),                                                           \
         ((4, (A,B,C,D)))                                                        \
       )

include/boost/fusion/adapted/adt/detail/extension.hpp

@@ -17,7 +17,7 @@
 #include <boost/fusion/adapted/struct/detail/extension.hpp>
 
 namespace boost { namespace fusion
-{ 
+{
     namespace detail
     {
         template <typename T, typename Dummy>
@@ -25,12 +25,12 @@ namespace boost { namespace fusion
           : remove_const<typename remove_reference<T>::type>
         {};
     }
-    
+
     namespace extension
     {
         // Overload as_const() to unwrap adt_attribute_proxy.
         template <typename T, int N, bool Const>
-        BOOST_FUSION_GPU_ENABLED
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
         typename adt_attribute_proxy<T, N, Const>::type as_const(const adt_attribute_proxy<T, N, Const>& proxy)
         {
             return proxy.get();

include/boost/fusion/adapted/array/at_impl.hpp

@@ -27,7 +27,7 @@ namespace boost { namespace fusion { namespace extension
                 add_reference<typename remove_extent<Seq>::type>::type
             type;
 
-            BOOST_FUSION_GPU_ENABLED
+            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
             static type
             call(Seq& seq)
             {

include/boost/fusion/adapted/array/begin_impl.hpp

@@ -31,7 +31,7 @@ namespace boost { namespace fusion { namespace extension
                 >
             type;
 
-            BOOST_FUSION_GPU_ENABLED
+            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
             static type
             call(Seq& seq)
             {

include/boost/fusion/adapted/array/deref_impl.hpp

@@ -29,7 +29,7 @@ namespace boost { namespace fusion { namespace extension
                 >::type
             type;
 
-            BOOST_FUSION_GPU_ENABLED
+            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
             static type
             call(It const& it)
             {

include/boost/fusion/adapted/array/end_impl.hpp

@@ -33,7 +33,7 @@ namespace boost { namespace fusion { namespace extension
                 >
             type;
 
-            BOOST_FUSION_GPU_ENABLED
+            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
             static type
             call(Seq& seq)
             {

include/boost/fusion/adapted/boost_array/array_iterator.hpp

@@ -32,7 +32,7 @@ namespace boost { namespace fusion
         typedef mpl::int_<Pos> index;
         typedef Array array_type;
 
-        BOOST_FUSION_GPU_ENABLED
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
         array_iterator(Array& a)
             : array(a) {}
 
@@ -57,7 +57,7 @@ namespace boost { namespace fusion
                 >::type 
             type;
 
-            BOOST_FUSION_GPU_ENABLED
+            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
             static type
             call(Iterator const & it)
             {
@@ -72,7 +72,7 @@ namespace boost { namespace fusion
             typedef typename Iterator::array_type array_type;
             typedef array_iterator<array_type, index::value + N::value> type;
 
-            BOOST_FUSION_GPU_ENABLED
+            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
             static type
             call(Iterator const& i)
             {
@@ -95,7 +95,7 @@ namespace boost { namespace fusion
                 >::type 
             type;
 
-            BOOST_FUSION_GPU_ENABLED
+            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
             static type
             call(I1 const&, I2 const&)
             {
@@ -103,10 +103,17 @@ namespace boost { namespace fusion
             }
         };
 
-    private:
-
-        array_iterator<Array, Pos>& operator=(array_iterator<Array, Pos> const&);
+        BOOST_DELETED_FUNCTION(array_iterator& operator=(array_iterator const&))
     };
 }}
 
+#ifdef BOOST_FUSION_WORKAROUND_FOR_LWG_2408
+namespace std
+{
+    template <typename Array, int Pos>
+    struct iterator_traits< ::boost::fusion::array_iterator<Array, Pos> >
+    { };
+}
+#endif
+
 #endif

include/boost/fusion/adapted/boost_array/detail/at_impl.hpp

@@ -14,7 +14,7 @@
 #include <boost/mpl/if.hpp>
 
 namespace boost { namespace fusion {
-    
+
     struct boost_array_tag;
 
     namespace extension
@@ -33,7 +33,7 @@ namespace boost { namespace fusion {
                     typename Sequence::const_reference, 
                     typename Sequence::reference>::type type;
 
-                BOOST_FUSION_GPU_ENABLED
+                BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
                 static type
                 call(Sequence& seq)
                 {

include/boost/fusion/adapted/boost_array/detail/begin_impl.hpp

@@ -24,11 +24,11 @@ namespace boost { namespace fusion {
         struct begin_impl<boost_array_tag>
         {
             template <typename Sequence>
-            struct apply 
+            struct apply
             {
                 typedef array_iterator<Sequence, 0> type;
-    
-                BOOST_FUSION_GPU_ENABLED
+
+                BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
                 static type
                 call(Sequence& v)
                 {

include/boost/fusion/adapted/boost_array/detail/end_impl.hpp

@@ -24,11 +24,11 @@ namespace boost { namespace fusion {
         struct end_impl<boost_array_tag>
         {
             template <typename Sequence>
-            struct apply 
+            struct apply
             {
                 typedef array_iterator<Sequence, Sequence::static_size> type;
-    
-                BOOST_FUSION_GPU_ENABLED
+
+                BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
                 static type
                 call(Sequence& v)
                 {

include/boost/fusion/adapted/boost_tuple/boost_tuple_iterator.hpp

@@ -144,9 +144,8 @@ namespace boost { namespace fusion
             : is_same<typename I1::identity, typename I2::identity>
         {};
 
-    private:
         // silence MSVC warning C4512: assignment operator could not be generated
-        boost_tuple_iterator& operator= (boost_tuple_iterator const&);
+        BOOST_DELETED_FUNCTION(boost_tuple_iterator& operator= (boost_tuple_iterator const&))
     };
 
     template <typename Null>
@@ -207,6 +206,15 @@ namespace boost { namespace fusion
     };
 }}
 
+#ifdef BOOST_FUSION_WORKAROUND_FOR_LWG_2408
+namespace std
+{
+    template <typename Cons>
+    struct iterator_traits< ::boost::fusion::boost_tuple_iterator<Cons> >
+    { };
+}
+#endif
+
 #endif
 
 

include/boost/fusion/adapted/mpl/mpl_iterator.hpp

@@ -114,6 +114,15 @@ namespace boost { namespace fusion
     };
 }}
 
+#ifdef BOOST_FUSION_WORKAROUND_FOR_LWG_2408
+namespace std
+{
+    template <typename Iterator>
+    struct iterator_traits< ::boost::fusion::mpl_iterator<Iterator> >
+    { };
+}
+#endif
+
 #endif
 
 

include/boost/fusion/adapted/std_array.hpp

@@ -0,0 +1,23 @@
+/*=============================================================================
+    Copyright (c) 2013 Mateusz Loskot
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2005-2006 Dan Marsden
+
+    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)
+==============================================================================*/
+#if !defined(BOOST_FUSION_STD_ARRAY__01062013_1700)
+#define BOOST_FUSION_STD_ARRAY__01062013_1700
+
+#include <boost/fusion/adapted/std_array/std_array_iterator.hpp>
+#include <boost/fusion/adapted/std_array/tag_of.hpp>
+#include <boost/fusion/adapted/std_array/detail/is_view_impl.hpp>
+#include <boost/fusion/adapted/std_array/detail/is_sequence_impl.hpp>
+#include <boost/fusion/adapted/std_array/detail/category_of_impl.hpp>
+#include <boost/fusion/adapted/std_array/detail/begin_impl.hpp>
+#include <boost/fusion/adapted/std_array/detail/end_impl.hpp>
+#include <boost/fusion/adapted/std_array/detail/size_impl.hpp>
+#include <boost/fusion/adapted/std_array/detail/at_impl.hpp>
+#include <boost/fusion/adapted/std_array/detail/value_at_impl.hpp>
+
+#endif

include/boost/fusion/adapted/std_array/detail/array_size.hpp

@@ -0,0 +1,25 @@
+/*=============================================================================
+    Copyright (c) 2013 Mateusz Loskot
+
+    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)
+==============================================================================*/
+#if !defined(BOOST_FUSION_STD_ARRAY_ARRAY_SIZE_01062013_1700)
+#define BOOST_FUSION_STD_ARRAY_ARRAY_SIZE_01062013_1700
+
+#include <cstddef>
+#include <boost/type_traits/integral_constant.hpp>
+
+namespace boost { namespace fusion
+{
+    namespace extension
+    {
+        template<class T>
+        struct std_array_size;
+
+        template<template<typename, std::size_t> class Array, typename T, std::size_t N>
+        struct std_array_size<Array<T, N> > : boost::integral_constant<std::size_t, N> {};
+    }
+}}
+
+#endif

include/boost/fusion/adapted/std_array/detail/at_impl.hpp

@@ -0,0 +1,45 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2005-2006 Dan Marsden
+
+    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)
+==============================================================================*/
+#if !defined(BOOST_FUSION_STD_ARRAY_AT_IMPL_01062013_1700)
+#define BOOST_FUSION_STD_ARRAY_AT_IMPL_01062013_1700
+
+#include <boost/type_traits/is_const.hpp>
+
+#include <boost/mpl/if.hpp>
+
+namespace boost { namespace fusion {
+    
+    struct std_array_tag;
+
+    namespace extension
+    {
+        template<typename T>
+        struct at_impl;
+
+        template<>
+        struct at_impl<std_array_tag>
+        {
+            template<typename Sequence, typename N>
+            struct apply
+            {
+                typedef typename mpl::if_<
+                    is_const<Sequence>, 
+                    typename Sequence::const_reference, 
+                    typename Sequence::reference>::type type;
+
+                static type
+                call(Sequence& seq)
+                {
+                    return seq[N::value];
+                }
+            };
+        };
+    }
+}}
+
+#endif

include/boost/fusion/adapted/std_array/detail/begin_impl.hpp

@@ -0,0 +1,41 @@
+/*=============================================================================
+    Copyright (c) 2013 Mateusz Loskot
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2005-2006 Dan Marsden
+
+    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)
+==============================================================================*/
+#if !defined(BOOST_FUSION_STD_ARRAY_BEGIN_OF_IMPL_01062013_1700)
+#define BOOST_FUSION_STD_ARRAY_BEGIN_OF_IMPL_01062013_1700
+
+#include <boost/fusion/adapted/std_array/std_array_iterator.hpp>
+
+namespace boost { namespace fusion {
+
+    struct std_array_tag;
+
+    namespace extension
+    {
+        template<typename T>
+        struct begin_impl;
+
+        template <>
+        struct begin_impl<std_array_tag>
+        {
+            template <typename Sequence>
+            struct apply 
+            {
+                typedef std_array_iterator<Sequence, 0> type;
+           
+                static type
+                call(Sequence& v)
+                {
+                    return type(v);
+                }
+            };
+        };
+    }
+}}
+
+#endif

include/boost/fusion/adapted/std_array/detail/category_of_impl.hpp

@@ -0,0 +1,35 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2005-2006 Dan Marsden
+
+    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)
+==============================================================================*/
+#if !defined(BOOST_FUSION_STD_ARRAY_CATEGORY_OF_IMPL_01062013_1700)
+#define BOOST_FUSION_STD_ARRAY_CATEGORY_OF_IMPL_01062013_1700
+
+#include <boost/config/no_tr1/utility.hpp>
+
+namespace boost { namespace fusion { 
+
+    struct std_array_tag;
+    struct random_access_traversal_tag;
+
+    namespace extension
+    {
+        template<typename T>
+        struct category_of_impl;
+
+        template<>
+        struct category_of_impl<std_array_tag>
+        {
+            template<typename T>
+            struct apply
+            {
+                typedef random_access_traversal_tag type;
+            };
+        };
+    }
+}}
+
+#endif

include/boost/fusion/adapted/std_array/detail/end_impl.hpp

@@ -0,0 +1,45 @@
+/*=============================================================================
+    Copyright (c) 2013 Mateusz Loskot
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2005-2006 Dan Marsden
+
+    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)
+==============================================================================*/
+#if !defined(BOOST_FUSION_STD_ARRAY_END_OF_IMPL_01062013_1700)
+#define BOOST_FUSION_STD_ARRAY_END_OF_IMPL_01062013_1700
+
+#include <boost/fusion/adapted/std_array/std_array_iterator.hpp>
+#include <boost/fusion/adapted/std_array/detail/array_size.hpp>
+#include <boost/type_traits/remove_const.hpp>
+
+namespace boost { namespace fusion {
+
+    struct std_array_tag;
+
+    namespace extension
+    {
+        template <typename Tag>
+        struct end_impl;
+
+        template <>
+        struct end_impl<std_array_tag>
+        {
+            template <typename Sequence>
+            struct apply 
+            {
+                typedef typename remove_const<Sequence>::type seq_type;
+                static int const size = std_array_size<seq_type>::value;
+                typedef std_array_iterator<Sequence, size> type;
+
+                static type
+                call(Sequence& v)
+                {
+                    return type(v);
+                }
+            };
+        };
+    }
+}}
+
+#endif

include/boost/fusion/adapted/std_array/detail/is_sequence_impl.hpp

@@ -0,0 +1,32 @@
+/*=============================================================================
+    Copyright (c) 2013 Mateusz Loskot
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2005-2006 Dan Marsden
+
+    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)
+==============================================================================*/
+#if !defined(BOOST_FUSION_STD_ARRAY_IS_SEQUENCE_IMPL_01062013_1700)
+#define BOOST_FUSION_STD_ARRAY_IS_SEQUENCE_IMPL_01062013_1700
+
+#include <boost/mpl/bool.hpp>
+
+namespace boost { namespace fusion {
+
+    struct std_array_tag;
+
+    namespace extension
+    {
+        template<typename Tag>
+        struct is_sequence_impl;
+
+        template<>
+        struct is_sequence_impl<std_array_tag>
+        {
+            template<typename Sequence>
+            struct apply : mpl::true_ {};
+        };
+    }
+}}
+
+#endif

include/boost/fusion/adapted/std_array/detail/is_view_impl.hpp

@@ -0,0 +1,33 @@
+/*=============================================================================
+    Copyright (c) 2013 Mateusz Loskot
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2005-2006 Dan Marsden
+
+    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)
+==============================================================================*/
+#if !defined(BOOST_FUSION_STD_ARRAY_IS_VIEW_IMPL_01062013_1700)
+#define BOOST_FUSION_STD_ARRAY_IS_VIEW_IMPL_01062013_1700
+
+#include <boost/mpl/bool.hpp>
+
+namespace boost { namespace fusion 
+{
+    struct std_array_tag;
+
+    namespace extension
+    {
+        template<typename Tag>
+        struct is_view_impl;
+
+        template<>
+        struct is_view_impl<std_array_tag>
+        {
+            template<typename T>
+            struct apply : mpl::false_
+            {};
+        };
+    }
+}}
+
+#endif

include/boost/fusion/adapted/std_array/detail/size_impl.hpp

@@ -0,0 +1,41 @@
+/*=============================================================================
+    Copyright (c) 2013 Mateusz Loskot
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2005-2006 Dan Marsden
+
+    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)
+==============================================================================*/
+#if !defined(BOOST_FUSION_STD_ARRAY_SIZE_IMPL_01062013_1700)
+#define BOOST_FUSION_STD_ARRAY_SIZE_IMPL_01062013_1700
+
+#include <boost/fusion/adapted/std_array/detail/array_size.hpp>
+#include <boost/type_traits/remove_const.hpp>
+
+namespace boost { namespace fusion {
+
+    struct std_array_tag;
+
+    namespace extension
+    {
+        template<typename T>
+        struct size_impl;
+
+        template<>
+        struct size_impl<std_array_tag>
+        {
+            template<typename Sequence>
+            struct apply
+                : mpl::int_
+                    <
+                        std_array_size
+                        <
+                            typename remove_const<Sequence>::type
+                        >::value
+                    >
+            {};
+        };
+    }
+}}
+
+#endif

include/boost/fusion/adapted/std_array/detail/value_at_impl.hpp

@@ -0,0 +1,32 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2005-2006 Dan Marsden
+
+    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)
+==============================================================================*/
+#if !defined(BOOST_FUSION_STD_ARRAY_VALUE_AT_IMPL_01062013_1700)
+#define BOOST_FUSION_STD_ARRAY_VALUE_AT_IMPL_01062013_1700
+
+namespace boost { namespace fusion {
+    
+    struct std_array_tag;
+
+    namespace extension
+    {
+        template<typename T>
+        struct value_at_impl;
+
+        template <>
+        struct value_at_impl<std_array_tag>
+        {
+            template <typename Sequence, typename N>
+            struct apply 
+            {
+                typedef typename Sequence::value_type type;
+            };
+        };
+    }
+}}
+
+#endif

include/boost/fusion/adapted/std_array/std_array_iterator.hpp

@@ -0,0 +1,107 @@
+/*=============================================================================
+    Copyright (c) 2013 Mateusz Loskot
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2005-2006 Dan Marsden
+
+    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)
+==============================================================================*/
+#if !defined(BOOST_FUSION_STD_ARRAY_ARRAY_ITERATOR_01062013_1700)
+#define BOOST_FUSION_STD_ARRAY_ARRAY_ITERATOR_01062013_1700
+
+#include <cstddef>
+#include <boost/config.hpp>
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/minus.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/fusion/iterator/iterator_facade.hpp>
+#include <boost/fusion/adapted/std_array/detail/array_size.hpp>
+
+namespace boost { namespace fusion
+{
+    struct random_access_traversal_tag;
+
+    template <typename Array, int Pos>
+    struct std_array_iterator
+        : iterator_facade<std_array_iterator<Array, Pos>, random_access_traversal_tag>
+    {
+        BOOST_MPL_ASSERT_RELATION(Pos, >=, 0);
+        BOOST_MPL_ASSERT_RELATION(Pos, <=, std::tuple_size<Array>::value);
+
+        typedef mpl::int_<Pos> index;
+        typedef Array array_type;
+
+        std_array_iterator(Array& a)
+            : array(a) {}
+
+        Array& array;
+
+        template <typename Iterator>
+        struct value_of
+        {
+            typedef typename Iterator::array_type array_type;
+            typedef typename array_type::value_type type;
+        };
+
+        template <typename Iterator>
+        struct deref
+        {
+            typedef typename Iterator::array_type array_type;
+            typedef typename 
+                mpl::if_<
+                    is_const<array_type>
+                  , typename array_type::const_reference
+                  , typename array_type::reference
+                >::type 
+            type;
+
+            static type
+            call(Iterator const & it)
+            {
+                return it.array[Iterator::index::value];
+            }
+        };
+
+        template <typename Iterator, typename N>
+        struct advance
+        {
+            typedef typename Iterator::index index;
+            typedef typename Iterator::array_type array_type;
+            typedef std_array_iterator<array_type, index::value + N::value> type;
+
+            static type
+            call(Iterator const& i)
+            {
+                return type(i.array);
+            }
+        };
+
+        template <typename Iterator>
+        struct next : advance<Iterator, mpl::int_<1> > {};
+
+        template <typename Iterator>
+        struct prior : advance<Iterator, mpl::int_<-1> > {};
+
+        template <typename I1, typename I2>
+        struct distance : mpl::minus<typename I2::index, typename I1::index>
+        {
+            typedef typename
+                mpl::minus<
+                    typename I2::index, typename I1::index
+                >::type 
+            type;
+
+            static type
+            call(I1 const&, I2 const&)
+            {
+                return type();
+            }
+        };
+
+        BOOST_DELETED_FUNCTION(std_array_iterator& operator=(std_array_iterator const&))
+    };
+}}
+
+#endif

include/boost/fusion/adapted/std_array/tag_of.hpp

@@ -0,0 +1,52 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2005-2006 Dan Marsden
+
+    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)
+==============================================================================*/
+#if !defined(BOOST_FUSION_STD_ARRAY_TAG_OF_01062013_1700)
+#define BOOST_FUSION_STD_ARRAY_TAG_OF_01062013_1700
+
+#include <boost/fusion/support/tag_of_fwd.hpp>
+#include <array>
+#include <cstddef>
+
+namespace boost { namespace fusion
+{
+    struct std_array_tag;
+    struct fusion_sequence_tag;
+
+    namespace traits
+    {
+        template<typename T, std::size_t N>
+#if defined(BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS)
+        struct tag_of<std::array<T,N>, void >
+#else
+        struct tag_of<std::array<T,N> >
+#endif
+        {
+            typedef std_array_tag type;
+        };
+    }
+}}
+
+namespace boost { namespace mpl
+{
+    template<typename>
+    struct sequence_tag;
+
+    template<typename T, std::size_t N>
+    struct sequence_tag<std::array<T,N> >
+    {
+        typedef fusion::fusion_sequence_tag type;
+    };
+
+    template<typename T, std::size_t N>
+    struct sequence_tag<std::array<T,N> const>
+    {
+        typedef fusion::fusion_sequence_tag type;
+    };
+}}
+
+#endif

include/boost/fusion/adapted/std_tuple/detail/at_impl.hpp

@@ -40,7 +40,7 @@ namespace boost { namespace fusion
                     >::type
                 type;
 
-                BOOST_FUSION_GPU_ENABLED
+                BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
                 static type
                 call(Sequence& seq)
                 {

include/boost/fusion/adapted/std_tuple/detail/begin_impl.hpp

@@ -27,7 +27,7 @@ namespace boost { namespace fusion
             {
                 typedef std_tuple_iterator<Sequence, 0> type;
 
-                BOOST_FUSION_GPU_ENABLED
+                BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
                 static type
                 call(Sequence& v)
                 {

include/boost/fusion/adapted/std_tuple/detail/build_std_tuple.hpp

@@ -7,27 +7,27 @@
 #if !defined(BOOST_FUSION_BUILD_STD_TUPLE_05292014_0100)
 #define BOOST_FUSION_BUILD_STD_TUPLE_05292014_0100
 
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/identity.hpp>
 #include <boost/fusion/support/config.hpp>
+#include <boost/fusion/support/detail/index_sequence.hpp>
 #include <boost/fusion/iterator/equal_to.hpp>
 #include <boost/fusion/iterator/next.hpp>
 #include <boost/fusion/iterator/value_of.hpp>
 #include <boost/fusion/iterator/deref.hpp>
 #include <tuple>
+#include <cstddef>
 
 namespace boost { namespace fusion { namespace detail
 {
-    template <typename First, typename Last
-      , bool is_empty = result_of::equal_to<First, Last>::value
-    >
+    template <typename First, typename Last,
+              bool is_empty = result_of::equal_to<First, Last>::value>
     struct build_std_tuple;
 
     template <typename First, typename Last>
     struct build_std_tuple<First, Last, true>
     {
         typedef std::tuple<> type;
-        BOOST_FUSION_GPU_ENABLED
+
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
         static type
         call(First const&, Last const&)
         {
@@ -35,44 +35,27 @@ namespace boost { namespace fusion { namespace detail
         }
     };
 
-    template <int ...> struct indexed_tuple { };
-
-    template <int, typename = indexed_tuple<>>
-    struct make_indexed_tuple;
-
-    template <int Head, int ...Tail>
-    struct make_indexed_tuple<Head, indexed_tuple<Tail...>>
-    {
-        typedef typename
-            boost::mpl::eval_if_c<
-                (Head == 0),
-                boost::mpl::identity<indexed_tuple<Tail...>>,
-                make_indexed_tuple<Head - 1, indexed_tuple<Head - 1, Tail...>>
-            >::type
-        type;
-    };
-
     template <typename T, typename Rest>
     struct push_front_std_tuple;
 
     template <typename T, typename ...Rest>
-    struct push_front_std_tuple<T, std::tuple<Rest...>>
+    struct push_front_std_tuple<T, std::tuple<Rest...> >
     {
         typedef std::tuple<T, Rest...> type;
 
-        template <int ...I>
-        BOOST_FUSION_GPU_ENABLED
+        template <std::size_t ...I>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
         static type
-        indexed_call(T const& first, std::tuple<Rest...> const& rest, indexed_tuple<I...>)
+        indexed_call(T const& first, std::tuple<Rest...> const& rest, index_sequence<I...>)
         {
             return type(first, std::get<I>(rest)...);
         }
 
-        BOOST_FUSION_GPU_ENABLED
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
         static type
         call(T const& first, std::tuple<Rest...> const& rest)
         {
-            typedef typename make_indexed_tuple<sizeof...(Rest)>::type gen;
+            typedef typename make_index_sequence<sizeof...(Rest)>::type gen;
             return indexed_call(first, rest, gen());
         }
     };
@@ -91,7 +74,7 @@ namespace boost { namespace fusion { namespace detail
 
         typedef typename push_front::type type;
 
-        BOOST_FUSION_GPU_ENABLED
+        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
         static type
         call(First const& f, Last const& l)
         {

include/boost/fusion/adapted/std_tuple/detail/convert_impl.hpp

@@ -34,7 +34,7 @@ namespace boost { namespace fusion
 
                 typedef typename gen::type type;
 
-                BOOST_FUSION_GPU_ENABLED
+                BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
                 static type
                 call(Sequence& seq)
                 {

include/boost/fusion/adapted/std_tuple/detail/end_impl.hpp

@@ -31,7 +31,7 @@ namespace boost { namespace fusion
                 static int const size = std::tuple_size<seq_type>::value;
                 typedef std_tuple_iterator<Sequence, size> type;
 
-                BOOST_FUSION_GPU_ENABLED
+                BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
                 static type
                 call(Sequence& v)
                 {

include/boost/fusion/adapted/std_tuple/std_tuple_iterator.hpp

@@ -36,7 +36,8 @@ namespace boost { namespace fusion
             typename add_const<Tuple>::type, Index>
         identity;
 
-        BOOST_FUSION_GPU_ENABLED explicit std_tuple_iterator(Tuple& tuple)
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        explicit std_tuple_iterator(Tuple& tuple)
           : tuple(tuple) {}
 
         Tuple& tuple;
@@ -58,7 +59,7 @@ namespace boost { namespace fusion
                 >::type
             type;
 
-            BOOST_FUSION_GPU_ENABLED
+            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
             static type
             call(Iterator const& iter)
             {
@@ -73,7 +74,7 @@ namespace boost { namespace fusion
             typedef typename Iterator::tuple_type tuple_type;
             typedef std_tuple_iterator<tuple_type, index+N::value> type;
 
-            BOOST_FUSION_GPU_ENABLED
+            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
             static type
             call(Iterator const& i)
             {
@@ -96,7 +97,7 @@ namespace boost { namespace fusion
         {
             typedef mpl::int_<Last::index-First::index> type;
 
-            BOOST_FUSION_GPU_ENABLED
+            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
             static type
             call(First const&, Last const&)
             {
@@ -106,6 +107,15 @@ namespace boost { namespace fusion
     };
 }}
 
+#ifdef BOOST_FUSION_WORKAROUND_FOR_LWG_2408
+namespace std
+{
+    template <typename Tuple, int Index>
+    struct iterator_traits< ::boost::fusion::std_tuple_iterator<Tuple, Index> >
+    { };
+}
+#endif
+
 #endif
 
 

include/boost/fusion/adapted/struct/adapt_assoc_struct.hpp

@@ -13,11 +13,8 @@
 #include <boost/fusion/support/config.hpp>
 #include <boost/preprocessor/cat.hpp>
 #include <boost/preprocessor/empty.hpp>
-#include <boost/preprocessor/tuple/elem.hpp>
-#include <boost/type_traits/add_reference.hpp>
-#include <boost/type_traits/is_const.hpp>
-#include <boost/type_traits/add_const.hpp>
-#include <boost/type_traits/remove_const.hpp>
+#include <boost/preprocessor/control/iif.hpp>
+#include <boost/preprocessor/comparison/less.hpp>
 
 #include <boost/fusion/adapted/struct/detail/extension.hpp>
 #include <boost/fusion/adapted/struct/detail/adapt_base.hpp>
@@ -44,11 +41,11 @@
         NAME_SEQ,                                                               \
         IS_VIEW,                                                                \
         I,                                                                      \
-        PREFIX,                                                                 \
+        BOOST_PP_IIF(IS_VIEW, BOOST_FUSION_PROXY_PREFIX, BOOST_PP_EMPTY),       \
         BOOST_FUSION_ADAPT_STRUCT_WRAPPEDATTR(ATTRIBUTE),                       \
         BOOST_FUSION_ADAPT_STRUCT_WRAPPEDATTR_SIZE(ATTRIBUTE),                  \
-        BOOST_PP_IF(BOOST_PP_LESS(                                              \
-            BOOST_FUSION_ADAPT_STRUCT_WRAPPEDATTR_SIZE(ATTRIBUTE),3), 1, 0))    \
+        BOOST_PP_LESS(                                                          \
+            BOOST_FUSION_ADAPT_STRUCT_WRAPPEDATTR_SIZE(ATTRIBUTE),3))           \
                                                                                 \
     template<                                                                   \
         BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS(TEMPLATE_PARAMS_SEQ)   \

include/boost/fusion/adapted/struct/adapt_assoc_struct_named.hpp

@@ -12,13 +12,6 @@
 #include <boost/fusion/adapted/struct/adapt_assoc_struct.hpp>
 #include <boost/fusion/adapted/struct/detail/proxy_type.hpp>
 
-#define BOOST_FUSION_ADAPT_ASSOC_STRUCT_NAMED_FILLER_0(X, Y, Z)                 \
-    (X, obj.Y, Z) BOOST_FUSION_ADAPT_ASSOC_STRUCT_NAMED_FILLER_1
-#define BOOST_FUSION_ADAPT_ASSOC_STRUCT_NAMED_FILLER_1(X, Y, Z)                 \
-    (X, obj.Y, Z) BOOST_FUSION_ADAPT_ASSOC_STRUCT_NAMED_FILLER_0
-#define BOOST_FUSION_ADAPT_ASSOC_STRUCT_NAMED_FILLER_0_END
-#define BOOST_FUSION_ADAPT_ASSOC_STRUCT_NAMED_FILLER_1_END
-
 #define BOOST_FUSION_ADAPT_ASSOC_STRUCT_NAMED_NS(                               \
     WRAPPED_TYPE, NAMESPACE_SEQ, NAME, ATTRIBUTES)                              \
                                                                                 \
@@ -27,9 +20,7 @@
                                                                                 \
     BOOST_FUSION_ADAPT_ASSOC_STRUCT_AS_VIEW(                                    \
         BOOST_FUSION_ADAPT_STRUCT_NAMESPACE_DECLARATION((0)NAMESPACE_SEQ)NAME,  \
-        BOOST_PP_CAT(                                                           \
-            BOOST_FUSION_ADAPT_ASSOC_STRUCT_NAMED_FILLER_0 ATTRIBUTES,          \
-            _END))
+        ATTRIBUTES)
 
 #define BOOST_FUSION_ADAPT_ASSOC_STRUCT_NAMED(WRAPPED_TYPE, NAME, ATTRIBUTES)   \
     BOOST_FUSION_ADAPT_ASSOC_STRUCT_NAMED_NS(                                   \

include/boost/fusion/adapted/struct/adapt_struct.hpp

@@ -14,13 +14,10 @@
 #include <boost/preprocessor/config/config.hpp>
 #include <boost/preprocessor/cat.hpp>
 #include <boost/preprocessor/empty.hpp>
-#include <boost/preprocessor/control/if.hpp>
+#include <boost/preprocessor/control/iif.hpp>
 #include <boost/preprocessor/comparison/less.hpp>
-#include <boost/preprocessor/comparison/equal.hpp>
-#include <boost/type_traits/add_reference.hpp>
-#include <boost/type_traits/is_const.hpp>
-#include <boost/type_traits/add_const.hpp>
-#include <boost/type_traits/remove_const.hpp>
+#include <boost/preprocessor/seq/seq.hpp>
+#include <boost/preprocessor/variadic/to_seq.hpp>
 
 #include <boost/fusion/adapted/struct/detail/extension.hpp>
 #include <boost/fusion/adapted/struct/detail/adapt_base.hpp>
@@ -43,13 +40,11 @@
             NAME_SEQ,                                                           \
             IS_VIEW,                                                            \
             I,                                                                  \
-            BOOST_PP_IF(IS_VIEW, BOOST_FUSION_PROXY_PREFIX, BOOST_PP_EMPTY),    \
+            BOOST_PP_IIF(IS_VIEW, BOOST_FUSION_PROXY_PREFIX, BOOST_PP_EMPTY),   \
             BOOST_FUSION_ADAPT_STRUCT_WRAPPEDATTR(ATTRIBUTE),                   \
             BOOST_FUSION_ADAPT_STRUCT_WRAPPEDATTR_SIZE(ATTRIBUTE),              \
-            BOOST_PP_IF(                                                        \
-                BOOST_PP_LESS(                                                  \
-                    BOOST_FUSION_ADAPT_STRUCT_WRAPPEDATTR_SIZE(ATTRIBUTE), 2)   \
-                , 1, 0))
+            BOOST_PP_LESS(                                                      \
+                BOOST_FUSION_ADAPT_STRUCT_WRAPPEDATTR_SIZE(ATTRIBUTE), 2))
 
 
 
@@ -61,27 +56,30 @@
             (1)NAME_SEQ,                                                        \
             struct_tag,                                                         \
             0,                                                                  \
-            BOOST_FUSION_ADAPT_STRUCT_ATTRIBUTES_FILLER(__VA_ARGS__),           \
+            BOOST_FUSION_ADAPT_STRUCT_ATTRIBUTES_FILLER(                        \
+                BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__)),                         \
             BOOST_FUSION_ADAPT_STRUCT_C)
 
-#   define BOOST_FUSION_ADAPT_STRUCT(NAME, ...)                                 \
+#   define BOOST_FUSION_ADAPT_STRUCT(...)                                       \
         BOOST_FUSION_ADAPT_STRUCT_BASE(                                         \
             (0),                                                                \
-            (0)(NAME),                                                          \
+            (0)(BOOST_PP_SEQ_HEAD(BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__))),      \
             struct_tag,                                                         \
             0,                                                                  \
-            BOOST_FUSION_ADAPT_STRUCT_ATTRIBUTES_FILLER(__VA_ARGS__),           \
+            BOOST_FUSION_ADAPT_STRUCT_ATTRIBUTES_FILLER(                        \
+              BOOST_PP_SEQ_TAIL(BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__))),        \
             BOOST_FUSION_ADAPT_STRUCT_C)
 
-#   define BOOST_FUSION_ADAPT_STRUCT_AS_VIEW(NAME, ...)                         \
+#   define BOOST_FUSION_ADAPT_STRUCT_AS_VIEW(...)                               \
         BOOST_FUSION_ADAPT_STRUCT_BASE(                                         \
             (0),                                                                \
-            (0)(NAME),                                                          \
+            (0)(BOOST_PP_SEQ_HEAD(BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__))),      \
             struct_tag,                                                         \
             1,                                                                  \
-            BOOST_FUSION_ADAPT_STRUCT_ATTRIBUTES_FILLER(__VA_ARGS__),           \
+            BOOST_FUSION_ADAPT_STRUCT_ATTRIBUTES_FILLER(                        \
+              BOOST_PP_SEQ_TAIL(BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__))),        \
             BOOST_FUSION_ADAPT_STRUCT_C)
-        
+
 #else // BOOST_PP_VARIADICS
 
 #   define BOOST_FUSION_ADAPT_TPL_STRUCT(                                       \

include/boost/fusion/adapted/struct/adapt_struct_named.hpp

@@ -13,7 +13,7 @@
 #include <boost/fusion/support/config.hpp>
 #include <boost/fusion/adapted/struct/adapt_struct.hpp>
 #include <boost/fusion/adapted/struct/detail/proxy_type.hpp>
-#include <boost/preprocessor/empty.hpp>
+#include <boost/preprocessor/config/config.hpp>
 
 #ifdef BOOST_PP_VARIADICS
 

include/boost/fusion/adapted/struct/define_assoc_struct.hpp

@@ -11,6 +11,7 @@
 #include <boost/fusion/support/config.hpp>
 #include <boost/fusion/adapted/struct/adapt_assoc_struct.hpp>
 #include <boost/fusion/adapted/struct/detail/define_struct.hpp>
+#include <boost/preprocessor/cat.hpp>
 
 #define BOOST_FUSION_DEFINE_ASSOC_STRUCT_FILLER_0(X, Y, Z)                      \
     ((X, Y, Z)) BOOST_FUSION_DEFINE_ASSOC_STRUCT_FILLER_1

include/boost/fusion/adapted/struct/define_struct.hpp

@@ -11,6 +11,7 @@
 #include <boost/fusion/support/config.hpp>
 #include <boost/fusion/adapted/struct/adapt_struct.hpp>
 #include <boost/fusion/adapted/struct/detail/define_struct.hpp>
+#include <boost/preprocessor/cat.hpp>
 
 #define BOOST_FUSION_DEFINE_TPL_STRUCT(                                         \
     TEMPLATE_PARAMS_SEQ, NAMESPACE_SEQ, NAME, ATTRIBUTES)                       \

include/boost/fusion/adapted/struct/detail/adapt_auto.hpp

@@ -8,8 +8,7 @@
 #ifndef BOOST_FUSION_ADAPTED_STRUCT_DETAIL_ADAPT_AUTO_HPP
 #define BOOST_FUSION_ADAPTED_STRUCT_DETAIL_ADAPT_AUTO_HPP
 
-#include <boost/preprocessor/empty.hpp>
-
-#define BOOST_FUSION_ADAPT_AUTO BOOST_PP_EMPTY()
+#define BOOST_FUSION_ADAPT_AUTO auto 
+#define BOOST_MPL_PP_TOKEN_EQUAL_auto(x) x
 
 #endif

include/boost/fusion/adapted/struct/detail/adapt_base.hpp

@@ -29,11 +29,14 @@
 #include <boost/preprocessor/tuple/elem.hpp>
 #include <boost/preprocessor/arithmetic/dec.hpp>
 #include <boost/preprocessor/comparison/less.hpp>
+#include <boost/preprocessor/logical/not.hpp>
 #include <boost/mpl/bool.hpp>
 #include <boost/mpl/tag.hpp>
 #include <boost/mpl/eval_if.hpp>
 #include <boost/mpl/identity.hpp>
+#include <boost/type_traits/is_const.hpp>
 #include <boost/type_traits/add_const.hpp>
+#include <boost/type_traits/add_reference.hpp>
 
 #include <boost/typeof/typeof.hpp>
 
@@ -64,7 +67,7 @@
 
 #ifdef BOOST_MSVC
 #   define BOOST_FUSION_ATTRIBUTE_TYPEOF(                                       \
-        NAME_SEQ, ATTRIBUTE, ATTRIBUTE_TUPEL_SIZE, PREFIX, TEMPLATE_PARAMS_SEQ) \
+        NAME_SEQ, ATTRIBUTE, ATTRIBUTE_TUPLE_SIZE, PREFIX, TEMPLATE_PARAMS_SEQ) \
                                                                                 \
     BOOST_FUSION_ADAPT_STRUCT_MSVC_REDEFINE_TEMPLATE_PARAMS(                    \
         TEMPLATE_PARAMS_SEQ)                                                    \
@@ -73,7 +76,7 @@
       static const BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)& obj;        \
       typedef                                                                   \
       BOOST_PP_IF(BOOST_FUSION_ADAPT_IS_TPL(TEMPLATE_PARAMS_SEQ), typename, )   \
-      BOOST_TYPEOF( PREFIX() obj.BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPEL_SIZE,      \
+      BOOST_TYPEOF( PREFIX() obj.BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPLE_SIZE,      \
             0, ATTRIBUTE))                                                      \
       type;                                                                     \
     };                                                                          \
@@ -84,12 +87,12 @@
 
 #else 
 #   define BOOST_FUSION_ATTRIBUTE_TYPEOF(                                       \
-        NAME_SEQ, ATTRIBUTE, ATTRIBUTE_TUPEL_SIZE, PREFIX, TEMPLATE_PARAMS_SEQ) \
+        NAME_SEQ, ATTRIBUTE, ATTRIBUTE_TUPLE_SIZE, PREFIX, TEMPLATE_PARAMS_SEQ) \
                                                                                 \
     struct deduced_attr_type {                                                  \
       static const BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)& obj;        \
       typedef BOOST_TYPEOF(                                                     \
-          PREFIX() obj.BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPEL_SIZE, 0, ATTRIBUTE)) \
+          PREFIX() obj.BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPLE_SIZE, 0, ATTRIBUTE)) \
       type;                                                                     \
     };                                                                          \
                                                                                 \
@@ -100,9 +103,9 @@
 #endif
 
 #define BOOST_FUSION_ATTRIBUTE_GIVENTYPE(                                       \
-    NAME_SEQ, ATTRIBUTE, ATTRIBUTE_TUPEL_SIZE, PREFIX, TEMPLATE_PARAMS_SEQ)     \
+    NAME_SEQ, ATTRIBUTE, ATTRIBUTE_TUPLE_SIZE, PREFIX, TEMPLATE_PARAMS_SEQ)     \
     typedef                                                                     \
-        BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPEL_SIZE, 0, ATTRIBUTE) attribute_type;
+        BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPLE_SIZE, 0, ATTRIBUTE) attribute_type;
    
 
 #ifdef BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS
@@ -159,7 +162,7 @@
 
 #define BOOST_FUSION_ADAPT_STRUCT_C_BASE(                                       \
     TEMPLATE_PARAMS_SEQ,NAME_SEQ,IS_VIEW,                                       \
-    I,PREFIX,ATTRIBUTE,ATTRIBUTE_TUPEL_SIZE,                                    \
+    I,PREFIX,ATTRIBUTE,ATTRIBUTE_TUPLE_SIZE,                                    \
     DEDUCE_TYPE)                                                                \
                                                                                 \
     template<                                                                   \
@@ -174,7 +177,7 @@
             BOOST_FUSION_ATTRIBUTE_TYPEOF, BOOST_FUSION_ATTRIBUTE_GIVENTYPE)(   \
                 NAME_SEQ,                                                       \
                 ATTRIBUTE,                                                      \
-                ATTRIBUTE_TUPEL_SIZE,                                           \
+                ATTRIBUTE_TUPLE_SIZE,                                           \
                 PREFIX,                                                         \
                 TEMPLATE_PARAMS_SEQ)                                            \
                                                                                 \
@@ -196,13 +199,13 @@
                 >::type                                                         \
             type;                                                               \
                                                                                 \
-            BOOST_FUSION_GPU_ENABLED                                            \
+            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED                            \
             static type                                                         \
             call(Seq& seq)                                                      \
             {                                                                   \
                 return seq.PREFIX()                                             \
-                    BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPEL_SIZE,                   \
-                        BOOST_PP_IF(DEDUCE_TYPE, 0, 1), ATTRIBUTE);             \
+                    BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPLE_SIZE,                   \
+                        BOOST_PP_NOT(DEDUCE_TYPE), ATTRIBUTE);                  \
             }                                                                   \
         };                                                                      \
     };                                                                          \
@@ -217,14 +220,13 @@
     {                                                                           \
         typedef char const* type;                                               \
                                                                                 \
-        BOOST_FUSION_GPU_ENABLED                                                \
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED                                \
         static type                                                             \
         call()                                                                  \
         {                                                                       \
             return BOOST_PP_STRINGIZE(                                          \
-               BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPEL_SIZE,                        \
-                        BOOST_PP_IF(DEDUCE_TYPE, 0, 1),                         \
-                          ATTRIBUTE));                                          \
+               BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPLE_SIZE,                        \
+                   BOOST_PP_NOT(DEDUCE_TYPE), ATTRIBUTE));                      \
         }                                                                       \
     };
 
@@ -274,7 +276,7 @@ namespace boost
             struct struct_is_view<                                              \
                 BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)                 \
             >                                                                   \
-              : mpl::BOOST_PP_IF(IS_VIEW,true_,false_)                          \
+              : mpl::BOOST_PP_IIF(IS_VIEW,true_,false_)                         \
             {};                                                                 \
         }                                                                       \
     }                                                                           \

include/boost/fusion/adapted/struct/detail/adapt_base_assoc_attr_filler.hpp

@@ -10,13 +10,16 @@
 
 #include <boost/config.hpp>
 
+#include <boost/fusion/adapted/struct/detail/adapt_auto.hpp>
 #include <boost/fusion/adapted/struct/detail/adapt_base_attr_filler.hpp>
 
-#include <boost/preprocessor/control/if.hpp>
-#include <boost/preprocessor/arithmetic/sub.hpp>
+#include <boost/mpl/aux_/preprocessor/token_equal.hpp>
+
+#include <boost/preprocessor/config/config.hpp>
+#include <boost/preprocessor/control/iif.hpp>
+#include <boost/preprocessor/arithmetic/dec.hpp>
 #include <boost/preprocessor/variadic/size.hpp>
-#include <boost/preprocessor/empty.hpp>
-#include <boost/preprocessor/facilities/is_empty.hpp>
+#include <boost/preprocessor/variadic/elem.hpp>
 
 #if BOOST_PP_VARIADICS
 
@@ -29,7 +32,14 @@
     BOOST_FUSION_ADAPT_ASSOC_STRUCT_FILLER_0
 
 #define BOOST_FUSION_ADAPT_ASSOC_STRUCT_WRAP_ATTR(...)                          \
-      ((BOOST_PP_VARIADIC_SIZE(__VA_ARGS__), (__VA_ARGS__)))
+  BOOST_PP_IIF(                                                                 \
+      BOOST_MPL_PP_TOKEN_EQUAL(auto, BOOST_PP_VARIADIC_ELEM(0, __VA_ARGS__)),   \
+      ((2,                                                                      \
+          (BOOST_PP_VARIADIC_ELEM(1, __VA_ARGS__),                              \
+           BOOST_PP_VARIADIC_ELEM(2, __VA_ARGS__)))),                           \
+      ((BOOST_PP_VARIADIC_SIZE(__VA_ARGS__),                                    \
+          (__VA_ARGS__)))                                                       \
+    )
 
 #else // BOOST_PP_VARIADICS
 
@@ -43,7 +53,7 @@
     BOOST_FUSION_ADAPT_ASSOC_STRUCT_FILLER_0
 
 #define BOOST_FUSION_ADAPT_ASSOC_STRUCT_WRAP_ATTR(X, Y, Z)                      \
-    BOOST_PP_IF(BOOST_PP_IS_EMPTY(X),                                           \
+    BOOST_PP_IIF(BOOST_MPL_PP_TOKEN_EQUAL(auto, X),                             \
       ((2, (Y,Z))),                                                             \
       ((3, (X,Y,Z)))                                                            \
     )
@@ -57,7 +67,7 @@
 #define BOOST_FUSION_ADAPT_ASSOC_STRUCT_WRAPPEDATTR_GET_KEY(ATTRIBUTE)          \
     BOOST_PP_TUPLE_ELEM(                                                        \
         BOOST_FUSION_ADAPT_STRUCT_WRAPPEDATTR_SIZE(ATTRIBUTE),                  \
-        BOOST_PP_SUB(BOOST_FUSION_ADAPT_STRUCT_WRAPPEDATTR_SIZE(ATTRIBUTE), 1), \
+        BOOST_PP_DEC(BOOST_FUSION_ADAPT_STRUCT_WRAPPEDATTR_SIZE(ATTRIBUTE)),    \
         BOOST_FUSION_ADAPT_STRUCT_WRAPPEDATTR(ATTRIBUTE))
 
 #endif

include/boost/fusion/adapted/struct/detail/adapt_base_attr_filler.hpp

@@ -9,15 +9,21 @@
 #define BOOST_FUSION_ADAPTED_STRUCT_DETAIL_ADAPT_BASE_ATTR_FILLER_HPP
 
 #include <boost/config.hpp>
+
+#include <boost/fusion/adapted/struct/detail/adapt_auto.hpp>
 #include <boost/fusion/adapted/struct/detail/preprocessor/is_seq.hpp>
 
-#include <boost/preprocessor/empty.hpp>
-#include <boost/preprocessor/tuple/size.hpp>
+#include <boost/mpl/aux_/preprocessor/token_equal.hpp>
+
+#include <boost/preprocessor/config/config.hpp>
+#include <boost/preprocessor/control/iif.hpp>
+#include <boost/preprocessor/control/expr_iif.hpp>
+#include <boost/preprocessor/logical/compl.hpp>
 #include <boost/preprocessor/tuple/elem.hpp>
-#include <boost/preprocessor/facilities/is_empty.hpp>
-#include <boost/preprocessor/variadic/to_seq.hpp>
 #include <boost/preprocessor/seq/for_each.hpp>
 #include <boost/preprocessor/seq/push_front.hpp>
+#include <boost/preprocessor/facilities/expand.hpp>
+#include <boost/preprocessor/facilities/is_empty.hpp>
 
 
 #define BOOST_FUSION_ADAPT_STRUCT_FILLER_0(X, Y)                                \
@@ -32,7 +38,7 @@
 #define BOOST_FUSION_ADAPT_STRUCT_FILLER_1_END
 
 #define BOOST_FUSION_ADAPT_STRUCT_WRAP_ATTR(X, Y)                               \
-    BOOST_PP_IF(BOOST_PP_IS_EMPTY(X),                                           \
+    BOOST_PP_IIF(BOOST_MPL_PP_TOKEN_EQUAL(auto, BOOST_PP_EXPAND(X)),            \
       ((1, (Y))),                                                               \
       ((2, (X,Y)))                                                              \
     )
@@ -47,16 +53,16 @@
 #if BOOST_PP_VARIADICS
 
 #   define BOOST_FUSION_ADAPT_STRUCT_ATTRIBUTES_FILLER_OP(r, unused, elem)      \
-        BOOST_PP_IF(BOOST_FUSION_PP_IS_SEQ(elem),                               \
-            BOOST_PP_CAT( BOOST_FUSION_ADAPT_STRUCT_FILLER_0 elem ,_END),       \
-            BOOST_FUSION_ADAPT_STRUCT_WRAP_ATTR(BOOST_FUSION_ADAPT_AUTO,        \
-                elem))
+        BOOST_PP_IIF(BOOST_FUSION_PP_IS_SEQ(elem),                              \
+            BOOST_PP_CAT(BOOST_FUSION_ADAPT_STRUCT_FILLER_0 elem ,_END),        \
+            BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_PP_IS_EMPTY(elem)),          \
+                BOOST_FUSION_ADAPT_STRUCT_WRAP_ATTR(auto, elem)))
 
-#   define BOOST_FUSION_ADAPT_STRUCT_ATTRIBUTES_FILLER(...)                     \
+#   define BOOST_FUSION_ADAPT_STRUCT_ATTRIBUTES_FILLER(VA_ARGS_SEQ)             \
         BOOST_PP_SEQ_PUSH_FRONT(                                                \
             BOOST_PP_SEQ_FOR_EACH(                                              \
                 BOOST_FUSION_ADAPT_STRUCT_ATTRIBUTES_FILLER_OP,                 \
-                unused, BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__)),                 \
+                unused, VA_ARGS_SEQ),                                           \
             (0,0))
 
 #endif // BOOST_PP_VARIADICS

include/boost/fusion/adapted/struct/detail/adapt_is_tpl.hpp

@@ -8,6 +8,8 @@
 #ifndef BOOST_FUSION_ADAPTED_STRUCT_DETAIL_ADAPT_IS_TPL_HPP
 #define BOOST_FUSION_ADAPTED_STRUCT_DETAIL_ADAPT_IS_TPL_HPP
 
+#include <boost/preprocessor/seq/seq.hpp>
+
 #define BOOST_FUSION_ADAPT_IS_TPL(TEMPLATE_PARAMS_SEQ)                          \
     BOOST_PP_SEQ_HEAD(TEMPLATE_PARAMS_SEQ)
 

include/boost/fusion/adapted/struct/detail/begin_impl.hpp

@@ -33,7 +33,7 @@ namespace boost { namespace fusion { namespace extension
                 >
             type;
 
-            BOOST_FUSION_GPU_ENABLED
+            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
             static type
             call(Seq& seq)
             {
@@ -57,7 +57,7 @@ namespace boost { namespace fusion { namespace extension
                 >
             type;
 
-            BOOST_FUSION_GPU_ENABLED
+            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
             static type
             call(Seq& seq)
             {

include/boost/fusion/adapted/struct/detail/define_struct.hpp

@@ -10,19 +10,18 @@
 
 #include <boost/fusion/support/config.hpp>
 #include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
 #include <boost/fusion/sequence/intrinsic/begin.hpp>
 #include <boost/fusion/iterator/deref.hpp>
 #include <boost/fusion/iterator/next.hpp>
 #include <boost/fusion/iterator/advance.hpp>
 #include <boost/fusion/adapted/struct/detail/adapt_base.hpp>
 #include <boost/fusion/adapted/struct/detail/namespace.hpp>
-#include <boost/preprocessor/inc.hpp>
 #include <boost/preprocessor/if.hpp>
 #include <boost/preprocessor/expr_if.hpp>
 #include <boost/preprocessor/dec.hpp>
 #include <boost/preprocessor/logical/not.hpp>
 #include <boost/preprocessor/punctuation/comma_if.hpp>
-#include <boost/preprocessor/comparison/equal.hpp>
 #include <boost/preprocessor/seq/seq.hpp>
 #include <boost/preprocessor/seq/for_each.hpp>
 #include <boost/preprocessor/seq/for_each_i.hpp>
@@ -41,15 +40,65 @@
 #define BOOST_FUSION_DEFINE_STRUCT_FILLER_0_END
 #define BOOST_FUSION_DEFINE_STRUCT_FILLER_1_END
 
+#ifdef BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
+
 #define BOOST_FUSION_DEFINE_STRUCT_COPY_CTOR_FILLER_I(                          \
-    R, ATTRIBUTE_TUPEL_SIZE, I, ATTRIBUTE)                                      \
+    R, ATTRIBUTE_TUPLE_SIZE, I, ATTRIBUTE)                                      \
                                                                                 \
     BOOST_PP_COMMA_IF(I)                                                        \
-    BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPEL_SIZE,1,ATTRIBUTE)(                      \
-        other_self.BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPEL_SIZE,1,ATTRIBUTE))
+    BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPLE_SIZE,1,ATTRIBUTE)(                      \
+        other_self.BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPLE_SIZE,1,ATTRIBUTE))
+
+#define BOOST_FUSION_DEFINE_STRUCT_COPY_CTOR(                                   \
+    NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE)                                 \
+                                                                                \
+    BOOST_FUSION_GPU_ENABLED                                                    \
+    NAME(self_type const& other_self)                                           \
+      : BOOST_PP_SEQ_FOR_EACH_I_R(                                              \
+            1,                                                                  \
+            BOOST_FUSION_DEFINE_STRUCT_COPY_CTOR_FILLER_I,                      \
+            ATTRIBUTE_TUPLE_SIZE,                                               \
+            ATTRIBUTES_SEQ)                                                     \
+    {}
+
+// Use templated version instead.
+#define BOOST_FUSION_DEFINE_STRUCT_COPY_ASSIGN_FILLER_I(                        \
+    R, ATTRIBUTE_TUPLE_SIZE, I_, ATTRIBUTE)                                     \
+                                                                                \
+    BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPLE_SIZE,1,ATTRIBUTE)=                      \
+        other.BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPLE_SIZE,1,ATTRIBUTE);
+
+#define BOOST_FUSION_DEFINE_STRUCT_COPY_ASSIGN_OP(                              \
+    ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE)                                       \
+                                                                                \
+    BOOST_FUSION_GPU_ENABLED                                                    \
+    self_type& operator=(self_type const& other)                                \
+    {                                                                           \
+        BOOST_PP_SEQ_FOR_EACH_I_R(                                              \
+            1,                                                                  \
+            BOOST_FUSION_DEFINE_STRUCT_COPY_ASSIGN_FILLER_I,                    \
+            ATTRIBUTE_TUPLE_SIZE,                                               \
+            ATTRIBUTES_SEQ)                                                     \
+                                                                                \
+        return *this;                                                           \
+    }
+
+#else // BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
+
+#define BOOST_FUSION_DEFINE_STRUCT_COPY_CTOR(                                   \
+    NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE)                                 \
+                                                                                \
+    BOOST_FUSION_GPU_ENABLED NAME(self_type const&) = default;
+
+#define BOOST_FUSION_DEFINE_STRUCT_COPY_ASSIGN_OP(                              \
+    ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE)                                       \
+                                                                                \
+    BOOST_FUSION_GPU_ENABLED self_type& operator=(self_type const&) = default;
+
+#endif // BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
 
 #define BOOST_FUSION_DEFINE_STRUCT_ASSIGN_FILLER_I(                             \
-    R, ATTRIBUTE_TUPEL_SIZE, I_, ATTRIBUTE)                                     \
+    R, ATTRIBUTE_TUPLE_SIZE, I_, ATTRIBUTE)                                     \
                                                                                 \
     BOOST_PP_EXPR_IF(                                                           \
         I_,                                                                     \
@@ -62,11 +111,11 @@
                 boost::fusion::next(BOOST_PP_CAT(i,BOOST_PP_DEC(I_)));          \
     )                                                                           \
                                                                                 \
-    BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPEL_SIZE,1,ATTRIBUTE)=                      \
+    BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPLE_SIZE,1,ATTRIBUTE)=                      \
         boost::fusion::deref(BOOST_PP_CAT(i,I_));
 
 #define BOOST_FUSION_DEFINE_STRUCT_ASSIGN_OP(                                   \
-    ATTRIBUTES_SEQ, ATTRIBUTE_TUPEL_SIZE)                                       \
+    ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE)                                       \
                                                                                 \
     template<typename Seq>                                                      \
     BOOST_FUSION_GPU_ENABLED                                                    \
@@ -81,51 +130,126 @@
         BOOST_PP_SEQ_FOR_EACH_I_R(                                              \
             1,                                                                  \
             BOOST_FUSION_DEFINE_STRUCT_ASSIGN_FILLER_I,                         \
-            ATTRIBUTE_TUPEL_SIZE,                                               \
+            ATTRIBUTE_TUPLE_SIZE,                                               \
             ATTRIBUTES_SEQ)                                                     \
                                                                                 \
         return *this;                                                           \
     }
 
-#define BOOST_FUSION_DEFINE_STRUCT_ATTR_I(R, ATTRIBUTE_TUPEL_SIZE, ATTRIBUTE)   \
-                                                                                \
-    BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPEL_SIZE,0,ATTRIBUTE)                       \
-        BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPEL_SIZE,1,ATTRIBUTE);
+#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
 
-#define BOOST_FUSION_DEFINE_STRUCT_SEQ_CTOR_FILLER_I(                           \
-    R, ATTRIBUTE_TUPEL_SIZE, I, ATTRIBUTE)                                      \
+#define BOOST_FUSION_DEFINE_STRUCT_MOVE_CTOR(NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE)
+#define BOOST_FUSION_DEFINE_STRUCT_MOVE_ASSIGN_OP(ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE)
+
+#else // BOOST_NO_CXX11_RVALUE_REFERENCES
+
+#if defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) \
+ || BOOST_WORKAROUND(BOOST_GCC, < 40500) \
+ || BOOST_WORKAROUND(BOOST_MSVC, == 1800)
+
+#define BOOST_FUSION_DEFINE_STRUCT_MOVE_CTOR_FILLER_I(                          \
+    R, ATTRIBUTE_TUPLE_SIZE, I, ATTRIBUTE)                                      \
                                                                                 \
     BOOST_PP_COMMA_IF(I)                                                        \
-    BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPEL_SIZE,1,ATTRIBUTE)(                      \
+    BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPLE_SIZE,1,ATTRIBUTE)(std::move(            \
+        other_self.BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPLE_SIZE,1,ATTRIBUTE)))
+
+#define BOOST_FUSION_DEFINE_STRUCT_MOVE_CTOR(                                   \
+    NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE)                                 \
+                                                                                \
+    BOOST_FUSION_GPU_ENABLED                                                    \
+    NAME(self_type&& other_self)                                                \
+      : BOOST_PP_SEQ_FOR_EACH_I_R(                                              \
+            1,                                                                  \
+            BOOST_FUSION_DEFINE_STRUCT_MOVE_CTOR_FILLER_I,                      \
+            ATTRIBUTE_TUPLE_SIZE,                                               \
+            ATTRIBUTES_SEQ)                                                     \
+    {}
+
+#else // BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
+
+#define BOOST_FUSION_DEFINE_STRUCT_MOVE_CTOR(                                   \
+    NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE)                                 \
+                                                                                \
+    BOOST_FUSION_GPU_ENABLED NAME(self_type&&) = default;
+
+#endif // BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
+
+#if defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) \
+ || BOOST_WORKAROUND(BOOST_GCC, < 40600) \
+ || BOOST_WORKAROUND(BOOST_MSVC, == 1800)
+
+#define BOOST_FUSION_DEFINE_STRUCT_MOVE_ASSIGN_FILLER_I(                        \
+    R, ATTRIBUTE_TUPLE_SIZE, I_, ATTRIBUTE)                                     \
+                                                                                \
+    BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPLE_SIZE,1,ATTRIBUTE)=std::move(            \
+        other.BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPLE_SIZE,1,ATTRIBUTE));
+
+#define BOOST_FUSION_DEFINE_STRUCT_MOVE_ASSIGN_OP(                              \
+    ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE)                                       \
+                                                                                \
+    BOOST_FUSION_GPU_ENABLED                                                    \
+    self_type& operator=(self_type&& other)                                     \
+    {                                                                           \
+        BOOST_PP_SEQ_FOR_EACH_I_R(                                              \
+            1,                                                                  \
+            BOOST_FUSION_DEFINE_STRUCT_MOVE_ASSIGN_FILLER_I,                    \
+            ATTRIBUTE_TUPLE_SIZE,                                               \
+            ATTRIBUTES_SEQ)                                                     \
+                                                                                \
+        return *this;                                                           \
+    }
+
+#else // BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
+
+#define BOOST_FUSION_DEFINE_STRUCT_MOVE_ASSIGN_OP(                              \
+    ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE)                                       \
+                                                                                \
+    BOOST_FUSION_GPU_ENABLED self_type& operator=(self_type&&) = default;
+
+#endif // BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
+
+#endif // BOOST_NO_CXX11_RVALUE_REFERENCES
+
+#define BOOST_FUSION_DEFINE_STRUCT_ATTR_I(R, ATTRIBUTE_TUPLE_SIZE, ATTRIBUTE)   \
+                                                                                \
+    BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPLE_SIZE,0,ATTRIBUTE)                       \
+        BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPLE_SIZE,1,ATTRIBUTE);
+
+#define BOOST_FUSION_DEFINE_STRUCT_SEQ_CTOR_FILLER_I(                           \
+    R, ATTRIBUTE_TUPLE_SIZE, I, ATTRIBUTE)                                      \
+                                                                                \
+    BOOST_PP_COMMA_IF(I)                                                        \
+    BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPLE_SIZE,1,ATTRIBUTE)(                      \
         boost::fusion::deref(boost::fusion::advance_c<I>(boost::fusion::begin(  \
             seq))))
 
 #define BOOST_FUSION_DEFINE_STRUCT_SEQ_CTOR_DISABLER(                           \
-    ATTRIBUTES_SEQ, ATTRIBUTE_TUPEL_SIZE)                                       \
+    ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE)                                       \
                                                                                 \
     , typename boost::disable_if<                                               \
         boost::is_convertible<                                                  \
             Seq const&                                                          \
           , BOOST_PP_TUPLE_ELEM(                                                \
-                ATTRIBUTE_TUPEL_SIZE,                                           \
+                ATTRIBUTE_TUPLE_SIZE,                                           \
                 0,                                                              \
                 BOOST_PP_SEQ_HEAD(ATTRIBUTES_SEQ))                              \
         >                                                                       \
     >::type* =0
 
 #define BOOST_FUSION_DEFINE_STRUCT_SEQ_DEFAULT_CTOR_FILLER_I(                   \
-    R, ATTRIBUTE_TUPEL_SIZE, I, ATTRIBUTE)                                      \
+    R, ATTRIBUTE_TUPLE_SIZE, I, ATTRIBUTE)                                      \
                                                                                 \
     BOOST_PP_COMMA_IF(I)                                                        \
-    BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPEL_SIZE,1,ATTRIBUTE)()
+    BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPLE_SIZE,1,ATTRIBUTE)()
 
 #define BOOST_FUSION_DEFINE_STRUCT_IMPL_IMPL(                                   \
-    NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPEL_SIZE)                                 \
+    NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE)                                 \
                                                                                 \
     BOOST_PP_SEQ_FOR_EACH_R(                                                    \
         1,                                                                      \
         BOOST_FUSION_DEFINE_STRUCT_ATTR_I,                                      \
-        ATTRIBUTE_TUPEL_SIZE,                                                   \
+        ATTRIBUTE_TUPLE_SIZE,                                                   \
         ATTRIBUTES_SEQ)                                                         \
                                                                                 \
     BOOST_FUSION_GPU_ENABLED                                                    \
@@ -133,18 +257,14 @@
       : BOOST_PP_SEQ_FOR_EACH_I_R(                                              \
             1,                                                                  \
             BOOST_FUSION_DEFINE_STRUCT_SEQ_DEFAULT_CTOR_FILLER_I,               \
-            ATTRIBUTE_TUPEL_SIZE,                                               \
+            ATTRIBUTE_TUPLE_SIZE,                                               \
             ATTRIBUTES_SEQ)                                                     \
     {}                                                                          \
                                                                                 \
-    BOOST_FUSION_GPU_ENABLED                                                    \
-    NAME(self_type const& other_self)                                           \
-      : BOOST_PP_SEQ_FOR_EACH_I_R(                                              \
-            1,                                                                  \
-            BOOST_FUSION_DEFINE_STRUCT_COPY_CTOR_FILLER_I,                      \
-            ATTRIBUTE_TUPEL_SIZE,                                               \
-            ATTRIBUTES_SEQ)                                                     \
-    {}                                                                          \
+    BOOST_FUSION_DEFINE_STRUCT_COPY_CTOR(                                       \
+        NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE)  \
+    BOOST_FUSION_DEFINE_STRUCT_MOVE_CTOR(                                       \
+        NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE)  \
                                                                                 \
     template<typename Seq>                                                      \
     BOOST_FUSION_GPU_ENABLED                                                    \
@@ -153,53 +273,57 @@
             BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(ATTRIBUTES_SEQ)),                    \
             BOOST_PP_TUPLE_EAT(2),                                              \
             BOOST_FUSION_DEFINE_STRUCT_SEQ_CTOR_DISABLER)(                      \
-                ATTRIBUTES_SEQ, ATTRIBUTE_TUPEL_SIZE)                           \
+                ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE)                           \
         )                                                                       \
       : BOOST_PP_SEQ_FOR_EACH_I_R(                                              \
             1,                                                                  \
             BOOST_FUSION_DEFINE_STRUCT_SEQ_CTOR_FILLER_I,                       \
-            ATTRIBUTE_TUPEL_SIZE,                                               \
+            ATTRIBUTE_TUPLE_SIZE,                                               \
             ATTRIBUTES_SEQ)                                                     \
     {}                                                                          \
                                                                                 \
-    BOOST_FUSION_DEFINE_STRUCT_ASSIGN_OP(ATTRIBUTES_SEQ, ATTRIBUTE_TUPEL_SIZE)
+    BOOST_FUSION_DEFINE_STRUCT_COPY_ASSIGN_OP(                                  \
+        ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE)                                   \
+    BOOST_FUSION_DEFINE_STRUCT_MOVE_ASSIGN_OP(                                  \
+        ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE)                                   \
+    BOOST_FUSION_DEFINE_STRUCT_ASSIGN_OP(ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE)
 
 #define BOOST_FUSION_DEFINE_STRUCT_CTOR_1(                                      \
-        NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPEL_SIZE)                             \
+        NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE)                             \
                                                                                 \
         BOOST_FUSION_GPU_ENABLED                                                \
         explicit                                                                \
         NAME(boost::call_traits<                                                \
                 BOOST_PP_TUPLE_ELEM(                                            \
-                    ATTRIBUTE_TUPEL_SIZE,0,BOOST_PP_SEQ_HEAD(ATTRIBUTES_SEQ))   \
+                    ATTRIBUTE_TUPLE_SIZE,0,BOOST_PP_SEQ_HEAD(ATTRIBUTES_SEQ))   \
             >::param_type arg)                                                  \
           : BOOST_PP_TUPLE_ELEM(                                                \
-                ATTRIBUTE_TUPEL_SIZE,1,BOOST_PP_SEQ_HEAD(ATTRIBUTES_SEQ))(arg)  \
+                ATTRIBUTE_TUPLE_SIZE,1,BOOST_PP_SEQ_HEAD(ATTRIBUTES_SEQ))(arg)  \
         {}
 
 #define BOOST_FUSION_DEFINE_TPL_STRUCT_CTOR_1(                                  \
-        TEMPLATE_PARAMS_SEQ, NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPEL_SIZE)        \
+        TEMPLATE_PARAMS_SEQ, NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE)        \
                                                                                 \
         BOOST_FUSION_GPU_ENABLED                                                \
         explicit                                                                \
         NAME(typename boost::call_traits<                                       \
                 typename boost::fusion::detail::get_first_arg<                  \
                     BOOST_PP_TUPLE_ELEM(                                        \
-                        ATTRIBUTE_TUPEL_SIZE,                                   \
+                        ATTRIBUTE_TUPLE_SIZE,                                   \
                         0,                                                      \
                         BOOST_PP_SEQ_HEAD(ATTRIBUTES_SEQ))                      \
                   , BOOST_PP_SEQ_HEAD(TEMPLATE_PARAMS_SEQ)                      \
                 >::type                                                         \
             >::param_type arg)                                                  \
           : BOOST_PP_TUPLE_ELEM(                                                \
-                ATTRIBUTE_TUPEL_SIZE,1,BOOST_PP_SEQ_HEAD(ATTRIBUTES_SEQ))(arg)  \
+                ATTRIBUTE_TUPLE_SIZE,1,BOOST_PP_SEQ_HEAD(ATTRIBUTES_SEQ))(arg)  \
         {}
 
 #define BOOST_FUSION_DEFINE_STRUCT_CTOR_FILLER_I(                               \
-    R, ATTRIBUTE_TUPEL_SIZE, I, ATTRIBUTE)                                      \
+    R, ATTRIBUTE_TUPLE_SIZE, I, ATTRIBUTE)                                      \
                                                                                 \
     BOOST_PP_COMMA_IF(I)                                                        \
-    BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPEL_SIZE,1,ATTRIBUTE)(BOOST_PP_CAT(_,I))
+    BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPLE_SIZE,1,ATTRIBUTE)(BOOST_PP_CAT(_,I))
 
 #define BOOST_FUSION_DEFINE_TPL_STRUCT_CTOR_ARG_I(R, DATA, I, ATTRIBUTE)        \
                                                                                 \
@@ -215,14 +339,14 @@
         >::param_type BOOST_PP_CAT(_,I)
 
 #define BOOST_FUSION_DEFINE_TPL_STRUCT_CTOR_N(                                  \
-    TEMPLATE_PARAMS_SEQ, NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPEL_SIZE)            \
+    TEMPLATE_PARAMS_SEQ, NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE)            \
                                                                                 \
         BOOST_FUSION_GPU_ENABLED                                                \
         NAME(BOOST_PP_SEQ_FOR_EACH_I_R(                                         \
                 1,                                                              \
                 BOOST_FUSION_DEFINE_TPL_STRUCT_CTOR_ARG_I,                      \
                 (                                                               \
-                    ATTRIBUTE_TUPEL_SIZE,                                       \
+                    ATTRIBUTE_TUPLE_SIZE,                                       \
                     BOOST_PP_SEQ_SIZE(ATTRIBUTES_SEQ),                          \
                     BOOST_PP_SEQ_HEAD(TEMPLATE_PARAMS_SEQ)                      \
                 ),                                                              \
@@ -230,77 +354,64 @@
           : BOOST_PP_SEQ_FOR_EACH_I_R(                                          \
                 1,                                                              \
                 BOOST_FUSION_DEFINE_STRUCT_CTOR_FILLER_I,                       \
-                ATTRIBUTE_TUPEL_SIZE,                                           \
+                ATTRIBUTE_TUPLE_SIZE,                                           \
                 ATTRIBUTES_SEQ)                                                 \
         {}
 
 #define BOOST_FUSION_DEFINE_STRUCT_CTOR_ARG_I(                                  \
-        R, ATTRIBUTE_TUPEL_SIZE, I, ATTRIBUTE)                                  \
+        R, ATTRIBUTE_TUPLE_SIZE, I, ATTRIBUTE)                                  \
                                                                                 \
         BOOST_PP_COMMA_IF(I)                                                    \
         boost::call_traits<                                                     \
-            BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPEL_SIZE,0,ATTRIBUTE)               \
+            BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPLE_SIZE,0,ATTRIBUTE)               \
         >::param_type BOOST_PP_CAT(_,I)
 
 #define BOOST_FUSION_DEFINE_STRUCT_CTOR_N(                                      \
-    NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPEL_SIZE)                                 \
+    NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE)                                 \
                                                                                 \
-        BOOST_FUSION_GPU_ENABLED                                                \
+        BOOST_FUSION_GPU_ENABLED                                \
         NAME(BOOST_PP_SEQ_FOR_EACH_I_R(                                         \
                 1,                                                              \
                 BOOST_FUSION_DEFINE_STRUCT_CTOR_ARG_I,                          \
-                ATTRIBUTE_TUPEL_SIZE,                                           \
+                ATTRIBUTE_TUPLE_SIZE,                                           \
                 ATTRIBUTES_SEQ))                                                \
           : BOOST_PP_SEQ_FOR_EACH_I_R(                                          \
                 1,                                                              \
                 BOOST_FUSION_DEFINE_STRUCT_CTOR_FILLER_I,                       \
-                ATTRIBUTE_TUPEL_SIZE,                                           \
+                ATTRIBUTE_TUPLE_SIZE,                                           \
                 ATTRIBUTES_SEQ)                                                 \
         {}
 
 #define BOOST_FUSION_DEFINE_STRUCT_CTOR(                                        \
-    NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPEL_SIZE)                                 \
+    NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE)                                 \
                                                                                 \
     BOOST_PP_IF(BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(ATTRIBUTES_SEQ)),                \
         BOOST_FUSION_DEFINE_STRUCT_CTOR_N,                                      \
         BOOST_FUSION_DEFINE_STRUCT_CTOR_1)(                                     \
-            NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPEL_SIZE)
+            NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE)
 
 #define BOOST_FUSION_DEFINE_TPL_STRUCT_CTOR(                                    \
-    TEMPLATE_PARAMS_SEQ, NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPEL_SIZE)            \
+    TEMPLATE_PARAMS_SEQ, NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE)            \
                                                                                 \
     BOOST_PP_IF(BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(ATTRIBUTES_SEQ)),                \
         BOOST_FUSION_DEFINE_TPL_STRUCT_CTOR_N,                                  \
         BOOST_FUSION_DEFINE_TPL_STRUCT_CTOR_1)(                                 \
-            TEMPLATE_PARAMS_SEQ, NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPEL_SIZE)
+            TEMPLATE_PARAMS_SEQ, NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE)
 
 #define BOOST_FUSION_DEFINE_NONEMPTY_STRUCT_IMPL(                               \
-    NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPEL_SIZE)                                 \
+    NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE)                                 \
                                                                                 \
         BOOST_FUSION_DEFINE_STRUCT_IMPL_IMPL(                                   \
-            NAME, BOOST_PP_SEQ_TAIL(ATTRIBUTES_SEQ), ATTRIBUTE_TUPEL_SIZE)      \
+            NAME, BOOST_PP_SEQ_TAIL(ATTRIBUTES_SEQ), ATTRIBUTE_TUPLE_SIZE)      \
                                                                                 \
         BOOST_FUSION_DEFINE_STRUCT_CTOR(                                        \
-            NAME, BOOST_PP_SEQ_TAIL(ATTRIBUTES_SEQ), ATTRIBUTE_TUPEL_SIZE)
+            NAME, BOOST_PP_SEQ_TAIL(ATTRIBUTES_SEQ), ATTRIBUTE_TUPLE_SIZE)
 
 #define BOOST_FUSION_DEFINE_EMPTY_STRUCT_IMPL(                                  \
-    NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPEL_SIZE)                                 \
-                                                                                \
-        template<typename Seq>                                                  \
-        BOOST_FUSION_GPU_ENABLED                                                \
-        NAME(Seq const&)                                                        \
-        {}                                                                      \
-                                                                                \
-        template<typename Seq>                                                  \
-        BOOST_FUSION_GPU_ENABLED                                                \
-        self_type&                                                              \
-        operator=(Seq const& seq)                                               \
-        {                                                                       \
-            return *this;                                                       \
-        }
+    NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE)
 
 #define BOOST_FUSION_DEFINE_STRUCT_IMPL(                                        \
-    NAMESPACE_SEQ, NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPEL_SIZE)                  \
+    NAMESPACE_SEQ, NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE)                  \
                                                                                 \
     BOOST_FUSION_ADAPT_STRUCT_NAMESPACE_DEFINITION_BEGIN(NAMESPACE_SEQ)         \
                                                                                 \
@@ -311,35 +422,32 @@
         BOOST_PP_IF(BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(ATTRIBUTES_SEQ)),            \
             BOOST_FUSION_DEFINE_NONEMPTY_STRUCT_IMPL,                           \
             BOOST_FUSION_DEFINE_EMPTY_STRUCT_IMPL)(                             \
-                NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPEL_SIZE)                     \
+                NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE)                     \
     };                                                                          \
                                                                                 \
     BOOST_FUSION_ADAPT_STRUCT_NAMESPACE_DEFINITION_END(NAMESPACE_SEQ)
 
 #define BOOST_FUSION_DEFINE_NONEMPTY_TPL_STRUCT_IMPL(                           \
-    TEMPLATE_PARAMS_SEQ, NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPEL_SIZE)            \
+    TEMPLATE_PARAMS_SEQ, NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE)            \
                                                                                 \
         BOOST_FUSION_DEFINE_STRUCT_IMPL_IMPL(                                   \
-            NAME, BOOST_PP_SEQ_TAIL(ATTRIBUTES_SEQ), ATTRIBUTE_TUPEL_SIZE)      \
+            NAME, BOOST_PP_SEQ_TAIL(ATTRIBUTES_SEQ), ATTRIBUTE_TUPLE_SIZE)      \
                                                                                 \
         BOOST_FUSION_DEFINE_TPL_STRUCT_CTOR(                                    \
             TEMPLATE_PARAMS_SEQ,                                                \
             NAME,                                                               \
             BOOST_PP_SEQ_TAIL(ATTRIBUTES_SEQ),                                  \
-            ATTRIBUTE_TUPEL_SIZE)
+            ATTRIBUTE_TUPLE_SIZE)
 
 #define BOOST_FUSION_DEFINE_EMPTY_TPL_STRUCT_IMPL(                              \
-    TEMPLATE_PARAMS_SEQ, NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPEL_SIZE)            \
-                                                                                \
-        BOOST_FUSION_DEFINE_EMPTY_STRUCT_IMPL(                                  \
-            NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPEL_SIZE)
+    TEMPLATE_PARAMS_SEQ, NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE)
 
 #define BOOST_FUSION_DEFINE_TPL_STRUCT_IMPL(                                    \
     TEMPLATE_PARAMS_SEQ,                                                        \
     NAMESPACE_SEQ,                                                              \
     NAME,                                                                       \
     ATTRIBUTES_SEQ,                                                             \
-    ATTRIBUTE_TUPEL_SIZE)                                                       \
+    ATTRIBUTE_TUPLE_SIZE)                                                       \
                                                                                 \
     BOOST_FUSION_ADAPT_STRUCT_NAMESPACE_DEFINITION_BEGIN(NAMESPACE_SEQ)         \
                                                                                 \
@@ -354,7 +462,7 @@
         BOOST_PP_IF(BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(ATTRIBUTES_SEQ)),            \
             BOOST_FUSION_DEFINE_NONEMPTY_TPL_STRUCT_IMPL,                       \
             BOOST_FUSION_DEFINE_EMPTY_TPL_STRUCT_IMPL)(                         \
-                TEMPLATE_PARAMS_SEQ, NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPEL_SIZE)\
+                TEMPLATE_PARAMS_SEQ, NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE)\
     };                                                                          \
                                                                                 \
     BOOST_FUSION_ADAPT_STRUCT_NAMESPACE_DEFINITION_END(NAMESPACE_SEQ)

include/boost/fusion/adapted/struct/detail/define_struct_inline.hpp

@@ -22,7 +22,7 @@
 #include <boost/mpl/if.hpp>
 #include <boost/type_traits/is_const.hpp>
 #include <boost/preprocessor/comma_if.hpp>
-#include <boost/preprocessor/facilities/is_empty.hpp>
+#include <boost/preprocessor/facilities/empty.hpp>
 #include <boost/preprocessor/repeat.hpp>
 #include <boost/preprocessor/seq/for_each_i.hpp>
 #include <boost/preprocessor/seq/size.hpp>
@@ -62,10 +62,10 @@
               ~,                                                                \
               ATTRIBUTES_SEQ)                                                   \
 
-#define BOOST_FUSION_IGNORE_1(ARG1)
 #define BOOST_FUSION_IGNORE_2(ARG1, ARG2)
 
 #define BOOST_FUSION_MAKE_COPY_CONSTRUCTOR(NAME, ATTRIBUTES_SEQ)                \
+    BOOST_FUSION_GPU_ENABLED                                                    \
     NAME(BOOST_PP_SEQ_FOR_EACH_I(                                               \
             BOOST_FUSION_MAKE_CONST_REF_PARAM,                                  \
             ~,                                                                  \
@@ -113,7 +113,7 @@
     struct deref<SPEC_TYPE, N> >                                                \
     {                                                                           \
         typedef typename boost_fusion_detail_Sq::t##N##_type TYPE_QUAL& type;   \
-        BOOST_FUSION_GPU_ENABLED                                                \
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED                                \
         static type call(CALL_ARG_TYPE, N> const& iter)                         \
         {                                                                       \
             return iter.seq_.BOOST_PP_TUPLE_ELEM(2, 1, ATTRIBUTE);              \
@@ -163,7 +163,7 @@
             typename boost_fusion_detail_Sq::t##N##_type&                       \
         >::type type;                                                           \
                                                                                 \
-        BOOST_FUSION_GPU_ENABLED                                                \
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED                                \
         static type call(boost_fusion_detail_Sq& sq)                            \
         {                                                                       \
             return sq. BOOST_PP_TUPLE_ELEM(2, 1, ATTRIBUTE);                    \
@@ -208,7 +208,7 @@
                 result_raw_type                                                 \
             >::type type;                                                       \
                                                                                 \
-            BOOST_FUSION_GPU_ENABLED                                            \
+            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED                            \
             static type call(iterator_raw_type const& iter)                     \
             {                                                                   \
                 return boost::fusion::at_c<index>(iter.ref_vec);                \
@@ -359,7 +359,7 @@
                 boost_fusion_detail_It::index::value + 1                        \
             > type;                                                             \
                                                                                 \
-            BOOST_FUSION_GPU_ENABLED                                            \
+            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED                            \
             static type call(boost_fusion_detail_It const& it)                  \
             {                                                                   \
                 return type(it.seq_);                                           \
@@ -374,7 +374,7 @@
                 boost_fusion_detail_It::index::value - 1                        \
             > type;                                                             \
                                                                                 \
-            BOOST_FUSION_GPU_ENABLED                                            \
+            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED                            \
             static type call(boost_fusion_detail_It const& it)                  \
             {                                                                   \
                 return type(it.seq_);                                           \
@@ -392,7 +392,7 @@
                 typename boost_fusion_detail_It1::index                         \
             >::type type;                                                       \
                                                                                 \
-            BOOST_FUSION_GPU_ENABLED                                            \
+            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED                            \
             static type call(boost_fusion_detail_It1 const& /* it1 */,          \
                              boost_fusion_detail_It2 const& /* it2 */)          \
             {                                                                   \
@@ -412,7 +412,7 @@
                     + boost_fusion_detail_M::value                              \
             > type;                                                             \
                                                                                 \
-            BOOST_FUSION_GPU_ENABLED                                            \
+            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED                            \
             static type call(boost_fusion_detail_It const& it)                  \
             {                                                                   \
                 return type(it.seq_);                                           \
@@ -424,17 +424,10 @@
 #define BOOST_FUSION_DEFINE_STRUCT_INLINE_MEMBERS_IMPL_IMPL(                    \
     NAME, ATTRIBUTES_SEQ, ATTRIBUTES_SEQ_SIZE)                                  \
                                                                                 \
-    /* Note: second BOOST_PP_IF is necessary to avoid MSVC warning when */      \
-    /*       calling BOOST_FUSION_IGNORE_1 with no arguments.           */      \
     NAME()                                                                      \
-        BOOST_PP_IF(                                                            \
-            ATTRIBUTES_SEQ_SIZE,                                                \
+        BOOST_PP_IF(ATTRIBUTES_SEQ_SIZE,                                        \
             BOOST_FUSION_MAKE_DEFAULT_INIT_LIST,                                \
-            BOOST_FUSION_IGNORE_1)                                              \
-                (BOOST_PP_IF(                                                   \
-                    ATTRIBUTES_SEQ_SIZE,                                        \
-                    ATTRIBUTES_SEQ,                                             \
-                    0))                                                         \
+            BOOST_PP_EMPTY)(ATTRIBUTES_SEQ)                                     \
     {                                                                           \
     }                                                                           \
                                                                                 \
@@ -445,14 +438,14 @@
             (NAME, ATTRIBUTES_SEQ)                                              \
                                                                                 \
     template <typename boost_fusion_detail_Seq>                                 \
-    BOOST_FUSION_GPU_ENABLED                                                    \
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED                              \
     NAME(const boost_fusion_detail_Seq& rhs)                                    \
     {                                                                           \
         boost::fusion::copy(rhs, *this);                                        \
     }                                                                           \
                                                                                 \
     template <typename boost_fusion_detail_Seq>                                 \
-    BOOST_FUSION_GPU_ENABLED                                                    \
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED                              \
     NAME& operator=(const boost_fusion_detail_Seq& rhs)                         \
     {                                                                           \
         boost::fusion::copy(rhs, *this);                                        \
@@ -465,7 +458,7 @@
         typedef BOOST_FUSION_ITERATOR_NAME(NAME)<boost_fusion_detail_Sq, 0>     \
              type;                                                              \
                                                                                 \
-        BOOST_FUSION_GPU_ENABLED                                                \
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED                                \
         static type call(boost_fusion_detail_Sq& sq)                            \
         {                                                                       \
             return type(sq);                                                    \
@@ -480,7 +473,7 @@
             ATTRIBUTES_SEQ_SIZE                                                 \
         > type;                                                                 \
                                                                                 \
-        BOOST_FUSION_GPU_ENABLED                                                \
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED                                \
         static type call(boost_fusion_detail_Sq& sq)                            \
         {                                                                       \
             return type(sq);                                                    \

include/boost/fusion/adapted/struct/detail/deref_impl.hpp

@@ -28,9 +28,8 @@ namespace boost { namespace fusion { namespace extension
 
            typedef typename impl::type type;
 
-           BOOST_FUSION_GPU_ENABLED
-           static
-           type
+           BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+           static type
            call(It const& it)
            {
                return impl::call(*it.seq);

include/boost/fusion/adapted/struct/detail/end_impl.hpp

@@ -33,7 +33,7 @@ namespace boost { namespace fusion { namespace extension
                 >
             type;
 
-            BOOST_FUSION_GPU_ENABLED
+            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
             static type
             call(Seq& seq)
             {
@@ -57,7 +57,7 @@ namespace boost { namespace fusion { namespace extension
                 >
             type;
 
-            BOOST_FUSION_GPU_ENABLED
+            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
             static type
             call(Seq& seq)
             {

include/boost/fusion/adapted/struct/detail/preprocessor/is_seq.hpp

@@ -13,8 +13,6 @@
 #ifndef BOOST_FUSION_ADAPTED_STRUCT_DETAIL_PREPROCESSOR_IS_SEQ_HPP
 #define BOOST_FUSION_ADAPTED_STRUCT_DETAIL_PREPROCESSOR_IS_SEQ_HPP
 
-#include <boost/preprocessor/seq/size.hpp>
-#include <boost/preprocessor/arithmetic/dec.hpp>
 #include <boost/preprocessor/punctuation/paren.hpp>
 #include <boost/preprocessor/cat.hpp>
 #include <boost/preprocessor/config/config.hpp>

include/boost/fusion/adapted/struct/detail/proxy_type.hpp

@@ -21,15 +21,14 @@
                                                                                 \
     struct NAME                                                                 \
     {                                                                           \
-        BOOST_FUSION_GPU_ENABLED                                                \
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED                                \
         NAME(WRAPPED_TYPE& in_obj)                                              \
           : obj(in_obj)                                                         \
         {}                                                                      \
                                                                                 \
         WRAPPED_TYPE& obj;                                                      \
                                                                                 \
-    private:                                                                    \
-        NAME& operator= (NAME const&);                                          \
+        BOOST_DELETED_FUNCTION(NAME& operator= (NAME const&))                   \
     };                                                                          \
                                                                                 \
     BOOST_FUSION_ADAPT_STRUCT_NAMESPACE_DEFINITION_END(NAMESPACE_SEQ)

include/boost/fusion/algorithm/auxiliary.hpp

@@ -9,5 +9,8 @@
 
 #include <boost/fusion/support/config.hpp>
 #include <boost/fusion/algorithm/auxiliary/copy.hpp>
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+#include <boost/fusion/algorithm/auxiliary/move.hpp>
+#endif
 
 #endif

include/boost/fusion/algorithm/auxiliary/copy.hpp

@@ -34,14 +34,14 @@ namespace boost { namespace fusion
             typedef typename result_of::end<Seq2>::type end2_type;
 
             template <typename I1, typename I2>
-            BOOST_FUSION_GPU_ENABLED
+            BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
             static void
             call(I1 const&, I2 const&, mpl::true_)
             {
             }
 
             template <typename I1, typename I2>
-            BOOST_FUSION_GPU_ENABLED
+            BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
             static void
             call(I1 const& src, I2 const& dest, mpl::false_)
             {
@@ -50,7 +50,7 @@ namespace boost { namespace fusion
             }
 
             template <typename I1, typename I2>
-            BOOST_FUSION_GPU_ENABLED
+            BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
             static void
             call(I1 const& src, I2 const& dest)
             {
@@ -71,7 +71,7 @@ namespace boost { namespace fusion
     }
 
     template <typename Seq1, typename Seq2>
-    BOOST_FUSION_GPU_ENABLED
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
     inline typename result_of::copy<Seq1 const, Seq2>::type
     copy(Seq1 const& src, Seq2& dest)
     {

include/boost/fusion/algorithm/auxiliary/move.hpp

@@ -18,6 +18,8 @@
 #include <boost/utility/enable_if.hpp>
 #include <boost/mpl/and.hpp>
 
+#include <utility> // for std::move
+
 #if defined (BOOST_MSVC)
 #  pragma warning(push)
 #  pragma warning (disable: 4100) // unreferenced formal parameter
@@ -34,14 +36,14 @@ namespace boost { namespace fusion
             typedef typename result_of::end<Seq2>::type end2_type;
 
             template <typename I1, typename I2>
-            BOOST_FUSION_GPU_ENABLED
+            BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
             static void
             call(I1 const&, I2 const&, mpl::true_)
             {
             }
 
             template <typename I1, typename I2>
-            BOOST_FUSION_GPU_ENABLED
+            BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
             static void
             call(I1 const& src, I2 const& dest, mpl::false_)
             {
@@ -50,7 +52,7 @@ namespace boost { namespace fusion
             }
 
             template <typename I1, typename I2>
-            BOOST_FUSION_GPU_ENABLED
+            BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
             static void
             call(I1 const& src, I2 const& dest)
             {
@@ -71,7 +73,7 @@ namespace boost { namespace fusion
     }
 
     template <typename Seq1, typename Seq2>
-    BOOST_FUSION_GPU_ENABLED
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
     inline typename result_of::move<Seq1, Seq2>::type
     move(Seq1&& src, Seq2& dest)
     {

include/boost/fusion/algorithm/iteration/accumulate.hpp

@@ -1,5 +1,6 @@
 /*=============================================================================
     Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2015 Kohei Takahashi
 
     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)
@@ -10,8 +11,6 @@
 #include <boost/fusion/support/config.hpp>
 #include <boost/fusion/algorithm/iteration/accumulate_fwd.hpp>
 #include <boost/fusion/algorithm/iteration/fold.hpp>
-#include <boost/fusion/support/is_sequence.hpp>
-#include <boost/utility/enable_if.hpp>
 
 namespace boost { namespace fusion
 {
@@ -26,26 +25,16 @@ namespace boost { namespace fusion
     }
 
     template <typename Sequence, typename State, typename F>
-    BOOST_FUSION_GPU_ENABLED
-    inline 
-    typename
-        lazy_enable_if<
-            traits::is_sequence<Sequence>
-          , result_of::accumulate<Sequence, State const, F>
-        >::type
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::accumulate<Sequence, State const, F>::type
     accumulate(Sequence& seq, State const& state, F f)
     {
         return fusion::fold(seq, state, f);
     }
 
     template <typename Sequence, typename State, typename F>
-    BOOST_FUSION_GPU_ENABLED
-    inline 
-    typename
-        lazy_enable_if<
-            traits::is_sequence<Sequence>
-          , result_of::accumulate<Sequence const, State const, F>
-        >::type
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::accumulate<Sequence const, State const, F>::type
     accumulate(Sequence const& seq, State const& state, F f)
     {
         return fusion::fold(seq, state, f);

include/boost/fusion/algorithm/iteration/accumulate_fwd.hpp

@@ -1,5 +1,6 @@
 /*=============================================================================
     Copyright (c) 2011 Eric Niebler
+    Copyright (c) 2015 Kohei Takahashi
 
     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)
@@ -8,8 +9,6 @@
 #define BOOST_FUSION_ACCUMULATE_FWD_HPP_INCLUDED
 
 #include <boost/fusion/support/config.hpp>
-#include <boost/fusion/support/is_sequence.hpp>
-#include <boost/utility/enable_if.hpp>
 
 namespace boost { namespace fusion
 {
@@ -20,21 +19,13 @@ namespace boost { namespace fusion
     }
 
     template <typename Sequence, typename State, typename F>
-    BOOST_FUSION_GPU_ENABLED
-    typename
-        lazy_enable_if<
-            traits::is_sequence<Sequence>
-          , result_of::accumulate<Sequence, State const, F>
-        >::type
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::accumulate<Sequence, State const, F>::type
     accumulate(Sequence& seq, State const& state, F f);
 
     template <typename Sequence, typename State, typename F>
-    BOOST_FUSION_GPU_ENABLED
-    typename
-        lazy_enable_if<
-            traits::is_sequence<Sequence>
-          , result_of::accumulate<Sequence const, State const, F>
-        >::type
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::accumulate<Sequence const, State const, F>::type
     accumulate(Sequence const& seq, State const& state, F f);
 }}
 

include/boost/fusion/algorithm/iteration/detail/fold.hpp

@@ -2,12 +2,15 @@
     Copyright (c) 2001-2011 Joel de Guzman
     Copyright (c) 2006 Dan Marsden
     Copyright (c) 2009-2010 Christopher Schmidt
+    Copyright (c) 2015 Kohei Takahashi
 
     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)
 ==============================================================================*/
 #include <boost/preprocessor/cat.hpp>
 
+#define FUSION_HASH #
+
 #ifdef BOOST_FUSION_REVERSE_FOLD
 #   ifdef BOOST_FUSION_ITER_FOLD
 #       define BOOST_FUSION_FOLD_NAME reverse_iter_fold
@@ -41,378 +44,193 @@
 #   define BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(IT) fusion::deref(IT)
 #endif
 
+#if (defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES))
+FUSION_HASH if BOOST_WORKAROUND BOOST_PREVENT_MACRO_SUBSTITUTION (BOOST_MSVC, < 1500)
+FUSION_HASH     define BOOST_FUSION_FOLD_IMPL_ENABLER(T) void
+FUSION_HASH else
+FUSION_HASH     define BOOST_FUSION_FOLD_IMPL_ENABLER(T) typename T::type
+FUSION_HASH endif
+#else
+#   if BOOST_WORKAROUND(BOOST_MSVC, < 1500)
+#       define BOOST_FUSION_FOLD_IMPL_ENABLER(T) void
+#   else
+#       define BOOST_FUSION_FOLD_IMPL_ENABLER(T) typename T::type
+#   endif
+#endif
+
 namespace boost { namespace fusion
 {
     namespace detail
     {
-        template<typename State, typename It, typename F>
-        struct BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)
-          : fusion::detail::result_of_with_decltype<
-                F(
-                typename add_reference<typename add_const<State>::type>::type,
-                BOOST_FUSION_FOLD_IMPL_INVOKE_IT_META_TRANSFORM(It))
-            >
+        template<int SeqSize, typename It, typename State, typename F, typename = void
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+FUSION_HASH if BOOST_WORKAROUND BOOST_PREVENT_MACRO_SUBSTITUTION (BOOST_MSVC, < 1500)
+#endif
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1500) || \
+    (defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES))
+          // Dirty hack: those compilers cannot choose exactly one partial specialization.
+          , bool = SeqSize == 0
+#endif
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+FUSION_HASH endif
+#endif
+        >
+        struct BOOST_PP_CAT(result_of_it_,BOOST_FUSION_FOLD_NAME)
         {};
 
-        template<typename Result,int N>
-        struct BOOST_PP_CAT(unrolled_,BOOST_FUSION_FOLD_NAME)
+        template<typename It, typename State, typename F>
+        struct BOOST_PP_CAT(result_of_it_,BOOST_FUSION_FOLD_NAME)<0,It,State,F
+          , typename boost::enable_if_has_type<BOOST_FUSION_FOLD_IMPL_ENABLER(State)>::type
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+FUSION_HASH if BOOST_WORKAROUND BOOST_PREVENT_MACRO_SUBSTITUTION (BOOST_MSVC, < 1500)
+#endif
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1500) || \
+    (defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES))
+          , true
+#endif
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+FUSION_HASH endif
+#endif
+          >
         {
-            template<typename State3, typename It3, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call_3(State3 const& state3,It3 const& it3,F& f)
-            {
-                return BOOST_PP_CAT(unrolled_,BOOST_FUSION_FOLD_NAME)<
-                    Result
-                  , N-4
-                >::call(
-                    f(state3,BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it3)),
-                    fusion::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION(it3),
-                    f);
-            }
-
-            template<typename State2, typename It2, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call_2(State2 const& state2,It2 const& it2,F& f)
-            {
-                return call_3(
-                    f(state2,BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it2)),
-                    fusion::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION(it2),
-                    f);
-            }
-
-            template<typename State1, typename It1, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call_1(State1 const& state1,It1 const& it1,F& f)
-            {
-                return call_2(
-                    f(state1,BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it1)),
-                    fusion::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION(it1),
-                    f);
-            }
-
-            template<typename State, typename It0, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call(State const& state,It0 const& it0,F f)
-            {
-                return call_1(
-                    f(state,BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it0)),
-                    fusion::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION(it0),
-                    f);
-            }
+            typedef typename State::type type;
         };
 
-        template<typename Result>
-        struct BOOST_PP_CAT(unrolled_,BOOST_FUSION_FOLD_NAME)<Result,3>
-        {
-            template<typename State2, typename It2, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call_2(State2 const& state2,It2 const& it2,F& f)
-            {
-                return f(state2,BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it2));
-            }
-
-            template<typename State1, typename It1, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call_1(State1 const& state1,It1 const& it1,F& f)
-            {
-                return call_2(
-                    f(state1,BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it1)),
-                    fusion::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION(it1),
-                    f);
-            }
-
-            template<typename State, typename It0, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call(State const& state,It0 const& it0,F f)
-            {
-                return call_1(
-                    f(state,BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it0)),
-                    fusion::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION(it0),
-                    f);
-            }
-        };
-
-        template<typename Result>
-        struct BOOST_PP_CAT(unrolled_,BOOST_FUSION_FOLD_NAME)<Result,2>
-        {
-            template<typename State1, typename It1, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call_1(State1 const& state1,It1 const& it1,F& f)
-            {
-                return f(state1,BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it1));
-            }
-
-            template<typename State, typename It0, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call(State const& state,It0 const& it0,F f)
-            {
-                return call_1(
-                    f(state,BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it0)),
-                    fusion::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION(it0),
-                    f);
-            }
-        };
-
-        template<typename Result>
-        struct BOOST_PP_CAT(unrolled_,BOOST_FUSION_FOLD_NAME)<Result,1>
-        {
-            template<typename State, typename It0, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call(State const& state,It0 const& it0,F f)
-            {
-                return f(state,
-                    BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it0));
-            }
-        };
-
-        template<typename Result>
-        struct BOOST_PP_CAT(unrolled_,BOOST_FUSION_FOLD_NAME)<Result,0>
-        {
-            template<typename State, typename It0, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call(State const& state,It0 const&, F)
-            {
-                return static_cast<Result>(state);
-            }
-        };
-
-        template<typename StateRef, typename It0, typename F, int N>
-        struct BOOST_PP_CAT(result_of_unrolled_,BOOST_FUSION_FOLD_NAME)
-        {
-            typedef typename
-                BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)<
-                    StateRef
-                  , It0 const
-                  , F
-                >::type
-            rest1;
-            typedef typename
-                result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION<
-                    It0 const
-                >::type
-            it1;
-            typedef typename
-                BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)<
-                    rest1
-                  , it1
-                  , F
-                >::type
-            rest2;
-            typedef typename
-                result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION<it1>::type
-            it2;
-            typedef typename
-                BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)<
-                    rest2
-                  , it2
-                  , F
-                >::type
-            rest3;
-            typedef typename
-                result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION<it2>::type
-            it3;
-
-            typedef typename
-                BOOST_PP_CAT(result_of_unrolled_,BOOST_FUSION_FOLD_NAME)<
-                    typename BOOST_PP_CAT(
-                        BOOST_FUSION_FOLD_NAME, _lvalue_state)<
-                        rest3
-                      , it3
-                      , F
-                    >::type
-                  , typename result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION<
-                        it3
-                    >::type
-                  , F
-                  , N-4
-                >::type
-            type;
-        };
-
-        template<typename StateRef, typename It0, typename F>
-        struct BOOST_PP_CAT(result_of_unrolled_,BOOST_FUSION_FOLD_NAME)<
-            StateRef
-          , It0
-          , F
-          , 3
-        >
-        {
-            typedef typename
-                BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)<
-                    StateRef
-                  , It0 const
-                  , F
-                >::type
-            rest1;
-            typedef typename
-                result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION<
-                    It0 const
-                >::type
-            it1;
-
-            typedef typename
-                BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)<
-                    typename BOOST_PP_CAT(
-                        BOOST_FUSION_FOLD_NAME, _lvalue_state)<
-                        rest1
-                      , it1
-                      , F
-                    >::type
-                  , typename result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION<
-                        it1 const
-                    >::type const
-                  , F
-                >::type
-            type;
-        };
-
-        template<typename StateRef, typename It0, typename F>
-        struct BOOST_PP_CAT(result_of_unrolled_,BOOST_FUSION_FOLD_NAME)<
-            StateRef
-          , It0
-          , F
-          , 2
-        >
-          : BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)<
-                typename BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)<
-                    StateRef
-                  , It0 const
-                  , F
-                >::type
-              , typename result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION<
-                    It0 const
-                >::type const
-              , F
-            >
-        {};
-
-        template<typename StateRef, typename It0, typename F>
-        struct BOOST_PP_CAT(result_of_unrolled_,BOOST_FUSION_FOLD_NAME)<
-            StateRef
-          , It0
-          , F
-          , 1
-        >
-          : BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)<
-                StateRef
-              , It0 const
-              , F
-            >
-        {};
-
-        template<typename StateRef, typename It0, typename F>
-        struct BOOST_PP_CAT(result_of_unrolled_,BOOST_FUSION_FOLD_NAME)<
-            StateRef
-          , It0
-          , F
-          , 0
-        >
-        {
-            typedef StateRef type;
-        };
-
-        template<typename StateRef, typename It0, typename F, int SeqSize>
-        struct BOOST_PP_CAT(result_of_first_unrolled,BOOST_FUSION_FOLD_NAME)
-        {
-            typedef typename
-                BOOST_PP_CAT(result_of_unrolled_,BOOST_FUSION_FOLD_NAME)<
-                    typename fusion::detail::result_of_with_decltype<
-                        F(
-                            StateRef,
-                            BOOST_FUSION_FOLD_IMPL_INVOKE_IT_META_TRANSFORM(
-                                It0 const)
-                        )
-                    >::type
-                  , typename result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION<
-                        It0 const
-                    >::type
-                  , F
-                  , SeqSize-1
-                >::type
-            type;
-        };
-
-        template<int SeqSize, typename StateRef, typename Seq, typename F>
-        struct BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME,_impl)
-        {
-            typedef typename
-                BOOST_PP_CAT(
-                    result_of_first_unrolled,BOOST_FUSION_FOLD_NAME)<
-                    StateRef
-                  , BOOST_FUSION_FOLD_IMPL_FIRST_IT_META_TRANSFORM(
-                        typename result_of::BOOST_FUSION_FOLD_IMPL_FIRST_IT_FUNCTION<Seq>::type
+        template<int SeqSize, typename It, typename State, typename F>
+        struct BOOST_PP_CAT(result_of_it_,BOOST_FUSION_FOLD_NAME)<SeqSize,It,State,F
+          , typename boost::enable_if_has_type<
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+FUSION_HASH if BOOST_WORKAROUND BOOST_PREVENT_MACRO_SUBSTITUTION (BOOST_MSVC, >= 1500)
+#endif
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1500) || \
+    (defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES))
+                // Following SFINAE enables to avoid MSVC 9's partial specialization
+                // ambiguous bug but MSVC 8 don't compile, and moreover MSVC 8 style
+                // workaround won't work with MSVC 9.
+                typename boost::disable_if_c<SeqSize == 0, State>::type::type
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+FUSION_HASH else
+                BOOST_FUSION_FOLD_IMPL_ENABLER(State)
+#endif
+#else
+                BOOST_FUSION_FOLD_IMPL_ENABLER(State)
+#endif
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+FUSION_HASH endif
+#endif
+            >::type
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+FUSION_HASH if BOOST_WORKAROUND BOOST_PREVENT_MACRO_SUBSTITUTION (BOOST_MSVC, < 1500)
+#endif
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1500) || \
+    (defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES))
+          , false
+#endif
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+FUSION_HASH endif
+#endif
+          >
+          : BOOST_PP_CAT(result_of_it_,BOOST_FUSION_FOLD_NAME)<
+                SeqSize-1
+              , typename result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION<It>::type
+              , boost::result_of<
+                    F(
+                        typename add_reference<typename State::type>::type,
+                        BOOST_FUSION_FOLD_IMPL_INVOKE_IT_META_TRANSFORM(It const)
                     )
-                  , F
-                  , SeqSize
-                >::type
-            type;
-
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static type
-            call(StateRef state, Seq& seq, F f)
-            {
-                typedef
-                    BOOST_PP_CAT(unrolled_,BOOST_FUSION_FOLD_NAME)<
-                        type
-                      , SeqSize
-                    >
-                unrolled_impl;
-
-                return unrolled_impl::call(
-                    state,
-                    BOOST_FUSION_FOLD_IMPL_FIRST_IT_TRANSFORM(
-                        fusion::BOOST_FUSION_FOLD_IMPL_FIRST_IT_FUNCTION(seq)),
-                    f);
-            }
-        };
-
-        template<typename StateRef, typename Seq, typename F>
-        struct BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME,_impl)<0,StateRef,Seq,F>
-        {
-            typedef StateRef type;
-
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static StateRef
-            call(StateRef state, Seq&, F)
-            {
-                return static_cast<StateRef>(state);
-            }
-        };
-
-        template<typename Seq, typename State, typename F, bool IsSegmented>
-        struct BOOST_PP_CAT(result_of_, BOOST_FUSION_FOLD_NAME)
-          : BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME,_impl)<
-                result_of::size<Seq>::value
-              , typename add_reference<
-                    typename add_const<State>::type
-                >::type
-              , Seq
+                >
               , F
             >
         {};
+
+        template<typename It, typename State, typename F>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        inline typename BOOST_PP_CAT(result_of_it_,BOOST_FUSION_FOLD_NAME)<
+            0
+          , It
+          , State
+          , F
+        >::type
+        BOOST_PP_CAT(it_,BOOST_FUSION_FOLD_NAME)(mpl::int_<0>, It const&, typename State::type state, F&)
+        {
+            return state;
+        }
+
+        template<typename It, typename State, typename F, int SeqSize>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        inline typename lazy_enable_if_c<
+            SeqSize != 0
+          , BOOST_PP_CAT(result_of_it_,BOOST_FUSION_FOLD_NAME)<
+                SeqSize
+              , It
+              , State
+              , F
+            >
+        >::type
+        BOOST_PP_CAT(it_,BOOST_FUSION_FOLD_NAME)(mpl::int_<SeqSize>, It const& it, typename State::type state, F& f)
+        {
+            return BOOST_PP_CAT(it_,BOOST_FUSION_FOLD_NAME)<
+                typename result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION<It>::type
+              , boost::result_of<
+                    F(
+                        typename add_reference<typename State::type>::type,
+                        BOOST_FUSION_FOLD_IMPL_INVOKE_IT_META_TRANSFORM(It const)
+                    )
+                >
+              , F
+            >(
+                mpl::int_<SeqSize-1>()
+              , fusion::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION(it)
+              , f(state, BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it))
+              , f
+            );
+        }
+
+        template<typename Seq, typename State, typename F
+          , bool = traits::is_sequence<Seq>::value
+          , bool = traits::is_segmented<Seq>::value>
+        struct BOOST_PP_CAT(result_of_,BOOST_FUSION_FOLD_NAME)
+        {};
+
+        template<typename Seq, typename State, typename F>
+        struct BOOST_PP_CAT(result_of_,BOOST_FUSION_FOLD_NAME)<Seq, State, F, true, false>
+          : BOOST_PP_CAT(result_of_it_,BOOST_FUSION_FOLD_NAME)<
+                result_of::size<Seq>::value
+              , BOOST_FUSION_FOLD_IMPL_FIRST_IT_META_TRANSFORM(
+                    typename result_of::BOOST_FUSION_FOLD_IMPL_FIRST_IT_FUNCTION<Seq>::type
+                )
+              , add_reference<State>
+              , F
+            >
+        {};
+
+        template<typename Seq, typename State, typename F>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        inline typename BOOST_PP_CAT(result_of_,BOOST_FUSION_FOLD_NAME)<Seq, State, F>::type
+        BOOST_FUSION_FOLD_NAME(Seq& seq, State& state, F& f)
+        {
+            return BOOST_PP_CAT(it_,BOOST_FUSION_FOLD_NAME)<
+                BOOST_FUSION_FOLD_IMPL_FIRST_IT_META_TRANSFORM(
+                    typename result_of::BOOST_FUSION_FOLD_IMPL_FIRST_IT_FUNCTION<Seq>::type
+                )
+              , add_reference<State>
+              , F
+            >(
+                typename result_of::size<Seq>::type()
+              , BOOST_FUSION_FOLD_IMPL_FIRST_IT_TRANSFORM(
+                    fusion::BOOST_FUSION_FOLD_IMPL_FIRST_IT_FUNCTION(seq)
+                )
+              , state
+              , f
+            );
+        }
     }
 
     namespace result_of
     {
         template<typename Seq, typename State, typename F>
         struct BOOST_FUSION_FOLD_NAME
-          : detail::BOOST_PP_CAT(result_of_, BOOST_FUSION_FOLD_NAME)<
-                Seq
-              , State
-              , F
-              , traits::is_segmented<Seq>::type::value
-            >
+          : detail::BOOST_PP_CAT(result_of_,BOOST_FUSION_FOLD_NAME)<Seq, State, F>
         {};
     }
 
@@ -425,10 +243,7 @@ namespace boost { namespace fusion
     >::type
     BOOST_FUSION_FOLD_NAME(Seq& seq, State const& state, F f)
     {
-        return result_of::BOOST_FUSION_FOLD_NAME<Seq,State const,F>::call(
-            state,
-            seq,
-            f);
+        return detail::BOOST_FUSION_FOLD_NAME<Seq, State const, F>(seq, state, f);
     }
 
     template<typename Seq, typename State, typename F>
@@ -440,47 +255,40 @@ namespace boost { namespace fusion
     >::type
     BOOST_FUSION_FOLD_NAME(Seq const& seq, State const& state, F f)
     {
-        return result_of::BOOST_FUSION_FOLD_NAME<Seq const,State const,F>::call(
-            state,
-            seq,
-            f);
+        return detail::BOOST_FUSION_FOLD_NAME<Seq const, State const, F>(seq, state, f);
     }
 
     template<typename Seq, typename State, typename F>
     BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
     inline typename result_of::BOOST_FUSION_FOLD_NAME<
         Seq
-      , State const
+      , State
       , F
     >::type
     BOOST_FUSION_FOLD_NAME(Seq& seq, State& state, F f)
     {
-        return result_of::BOOST_FUSION_FOLD_NAME<Seq,State,F>::call(
-            state,
-            seq,
-            f);
+        return detail::BOOST_FUSION_FOLD_NAME<Seq, State, F>(seq, state, f);
     }
 
     template<typename Seq, typename State, typename F>
     BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
     inline typename result_of::BOOST_FUSION_FOLD_NAME<
         Seq const
-      , State const
+      , State
       , F
     >::type
     BOOST_FUSION_FOLD_NAME(Seq const& seq, State& state, F f)
     {
-        return result_of::BOOST_FUSION_FOLD_NAME<Seq const,State,F>::call(
-            state,
-            seq,
-            f);
+        return detail::BOOST_FUSION_FOLD_NAME<Seq const, State, F>(seq, state, f);
     }
 }}
 
 #undef BOOST_FUSION_FOLD_NAME
+#undef BOOST_FUSION_FOLD_IMPL_ENABLER
 #undef BOOST_FUSION_FOLD_IMPL_FIRST_IT_FUNCTION
 #undef BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION
 #undef BOOST_FUSION_FOLD_IMPL_FIRST_IT_META_TRANSFORM
 #undef BOOST_FUSION_FOLD_IMPL_FIRST_IT_TRANSFORM
 #undef BOOST_FUSION_FOLD_IMPL_INVOKE_IT_META_TRANSFORM
 #undef BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM
+#undef FUSION_HASH

include/boost/fusion/algorithm/iteration/detail/for_each.hpp

@@ -21,16 +21,16 @@ namespace boost { namespace fusion {
 namespace detail
 {
     template <typename First, typename Last, typename F>
-    BOOST_FUSION_GPU_ENABLED
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
     inline void
     for_each_linear(First const&, Last const&, F const&, mpl::true_)
     {
     }
-        
+
     template <typename First, typename Last, typename F>
-    BOOST_FUSION_GPU_ENABLED
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
     inline void
-    for_each_linear(First const& first, Last const& last, F const& f, mpl::false_)
+    for_each_linear(First const& first, Last const& last, F& f, mpl::false_)
     {
         f(*first);
         detail::for_each_linear(fusion::next(first), last, f, 
@@ -39,9 +39,9 @@ namespace detail
 
 
     template <typename Sequence, typename F, typename Tag>
-    BOOST_FUSION_GPU_ENABLED
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
     inline void
-    for_each_dispatch(Sequence& seq, F const& f, Tag)
+    for_each_dispatch(Sequence& seq, F& f, Tag)
     {
         detail::for_each_linear(
                                 fusion::begin(seq)
@@ -56,8 +56,8 @@ namespace detail
     struct for_each_unrolled
     {
         template<typename I0, typename F>
-        BOOST_FUSION_GPU_ENABLED
-        static void call(I0 const& i0, F const& f)
+        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static void call(I0 const& i0, F& f)
         {
             f(*i0);
             typedef typename result_of::next<I0>::type I1;
@@ -77,8 +77,8 @@ namespace detail
     struct for_each_unrolled<3>
     {
         template<typename I0, typename F>
-        BOOST_FUSION_GPU_ENABLED
-        static void call(I0 const& i0, F const& f)
+        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static void call(I0 const& i0, F& f)
         {
             f(*i0);
             typedef typename result_of::next<I0>::type I1;
@@ -94,8 +94,8 @@ namespace detail
     struct for_each_unrolled<2>
     {
         template<typename I0, typename F>
-        BOOST_FUSION_GPU_ENABLED
-        static void call(I0 const& i0, F const& f)
+        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static void call(I0 const& i0, F& f)
         {
             f(*i0);
             typedef typename result_of::next<I0>::type I1;
@@ -108,8 +108,8 @@ namespace detail
     struct for_each_unrolled<1>
     {
         template<typename I0, typename F>
-        BOOST_FUSION_GPU_ENABLED
-        static void call(I0 const& i0, F const& f)
+        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static void call(I0 const& i0, F& f)
         {
             f(*i0);
         }
@@ -119,16 +119,16 @@ namespace detail
     struct for_each_unrolled<0>
     {
         template<typename It, typename F>
-        BOOST_FUSION_GPU_ENABLED
+        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
         static void call(It const&, F const&)
         {
         }
     };
 
     template <typename Sequence, typename F>
-    BOOST_FUSION_GPU_ENABLED
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
     inline void
-    for_each_dispatch(Sequence& seq, F const& f, random_access_traversal_tag)
+    for_each_dispatch(Sequence& seq, F& f, random_access_traversal_tag)
     {
         typedef typename result_of::begin<Sequence>::type begin;
         typedef typename result_of::end<Sequence>::type end;
@@ -136,9 +136,9 @@ namespace detail
     }
 
     template <typename Sequence, typename F>
-    BOOST_FUSION_GPU_ENABLED
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
     inline void
-    for_each(Sequence& seq, F const& f, mpl::false_) // unsegmented implementation
+    for_each(Sequence& seq, F& f, mpl::false_) // unsegmented implementation
     {
         detail::for_each_dispatch(seq, f, typename traits::category_of<Sequence>::type());
     }

include/boost/fusion/algorithm/iteration/detail/preprocessed/fold.hpp

@@ -8,345 +8,138 @@
 
     This is an auto-generated file. Do not edit!
 ==============================================================================*/
+# if BOOST_WORKAROUND (BOOST_MSVC, < 1500)
+# define BOOST_FUSION_FOLD_IMPL_ENABLER(T) void
+# else
+# define BOOST_FUSION_FOLD_IMPL_ENABLER(T) typename T::type
+# endif
 namespace boost { namespace fusion
 {
     namespace detail
     {
-        template<typename State, typename It, typename F>
-        struct fold_lvalue_state
-          : fusion::detail::result_of_with_decltype<
-                F(
-                typename add_reference<typename add_const<State>::type>::type,
-                typename fusion::result_of::deref<It>::type)
-            >
+        template<int SeqSize, typename It, typename State, typename F, typename = void
+# if BOOST_WORKAROUND (BOOST_MSVC, < 1500)
+          
+          , bool = SeqSize == 0
+# endif
+        >
+        struct result_of_it_fold
         {};
-        template<typename Result,int N>
-        struct unrolled_fold
+        template<typename It, typename State, typename F>
+        struct result_of_it_fold<0,It,State,F
+          , typename boost::enable_if_has_type<BOOST_FUSION_FOLD_IMPL_ENABLER(State)>::type
+# if BOOST_WORKAROUND (BOOST_MSVC, < 1500)
+          , true
+# endif
+          >
         {
-            template<typename State3, typename It3, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call_3(State3 const& state3,It3 const& it3,F& f)
-            {
-                return unrolled_fold<
-                    Result
-                  , N-4
-                >::call(
-                    f(state3,fusion::deref(it3)),
-                    fusion::next(it3),
-                    f);
-            }
-            template<typename State2, typename It2, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call_2(State2 const& state2,It2 const& it2,F& f)
-            {
-                return call_3(
-                    f(state2,fusion::deref(it2)),
-                    fusion::next(it2),
-                    f);
-            }
-            template<typename State1, typename It1, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call_1(State1 const& state1,It1 const& it1,F& f)
-            {
-                return call_2(
-                    f(state1,fusion::deref(it1)),
-                    fusion::next(it1),
-                    f);
-            }
-            template<typename State, typename It0, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call(State const& state,It0 const& it0,F f)
-            {
-                return call_1(
-                    f(state,fusion::deref(it0)),
-                    fusion::next(it0),
-                    f);
-            }
+            typedef typename State::type type;
         };
-        template<typename Result>
-        struct unrolled_fold<Result,3>
-        {
-            template<typename State2, typename It2, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call_2(State2 const& state2,It2 const& it2,F& f)
-            {
-                return f(state2,fusion::deref(it2));
-            }
-            template<typename State1, typename It1, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call_1(State1 const& state1,It1 const& it1,F& f)
-            {
-                return call_2(
-                    f(state1,fusion::deref(it1)),
-                    fusion::next(it1),
-                    f);
-            }
-            template<typename State, typename It0, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call(State const& state,It0 const& it0,F f)
-            {
-                return call_1(
-                    f(state,fusion::deref(it0)),
-                    fusion::next(it0),
-                    f);
-            }
-        };
-        template<typename Result>
-        struct unrolled_fold<Result,2>
-        {
-            template<typename State1, typename It1, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call_1(State1 const& state1,It1 const& it1,F& f)
-            {
-                return f(state1,fusion::deref(it1));
-            }
-            template<typename State, typename It0, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call(State const& state,It0 const& it0,F f)
-            {
-                return call_1(
-                    f(state,fusion::deref(it0)),
-                    fusion::next(it0),
-                    f);
-            }
-        };
-        template<typename Result>
-        struct unrolled_fold<Result,1>
-        {
-            template<typename State, typename It0, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call(State const& state,It0 const& it0,F f)
-            {
-                return f(state,
-                    fusion::deref(it0));
-            }
-        };
-        template<typename Result>
-        struct unrolled_fold<Result,0>
-        {
-            template<typename State, typename It0, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call(State const& state,It0 const&, F)
-            {
-                return static_cast<Result>(state);
-            }
-        };
-        template<typename StateRef, typename It0, typename F, int N>
-        struct result_of_unrolled_fold
-        {
-            typedef typename
-                fold_lvalue_state<
-                    StateRef
-                  , It0 const
-                  , F
-                >::type
-            rest1;
-            typedef typename
-                result_of::next<
-                    It0 const
-                >::type
-            it1;
-            typedef typename
-                fold_lvalue_state<
-                    rest1
-                  , it1
-                  , F
-                >::type
-            rest2;
-            typedef typename
-                result_of::next<it1>::type
-            it2;
-            typedef typename
-                fold_lvalue_state<
-                    rest2
-                  , it2
-                  , F
-                >::type
-            rest3;
-            typedef typename
-                result_of::next<it2>::type
-            it3;
-            typedef typename
-                result_of_unrolled_fold<
-                    typename fold_lvalue_state<
-                        rest3
-                      , it3
-                      , F
-                    >::type
-                  , typename result_of::next<
-                        it3
-                    >::type
-                  , F
-                  , N-4
-                >::type
-            type;
-        };
-        template<typename StateRef, typename It0, typename F>
-        struct result_of_unrolled_fold<
-            StateRef
-          , It0
-          , F
-          , 3
-        >
-        {
-            typedef typename
-                fold_lvalue_state<
-                    StateRef
-                  , It0 const
-                  , F
-                >::type
-            rest1;
-            typedef typename
-                result_of::next<
-                    It0 const
-                >::type
-            it1;
-            typedef typename
-                fold_lvalue_state<
-                    typename fold_lvalue_state<
-                        rest1
-                      , it1
-                      , F
-                    >::type
-                  , typename result_of::next<
-                        it1 const
-                    >::type const
-                  , F
-                >::type
-            type;
-        };
-        template<typename StateRef, typename It0, typename F>
-        struct result_of_unrolled_fold<
-            StateRef
-          , It0
-          , F
-          , 2
-        >
-          : fold_lvalue_state<
-                typename fold_lvalue_state<
-                    StateRef
-                  , It0 const
-                  , F
-                >::type
-              , typename result_of::next<
-                    It0 const
-                >::type const
+        template<int SeqSize, typename It, typename State, typename F>
+        struct result_of_it_fold<SeqSize,It,State,F
+          , typename boost::enable_if_has_type<
+# if BOOST_WORKAROUND (BOOST_MSVC, >= 1500)
+                
+                
+                
+                typename boost::disable_if_c<SeqSize == 0, State>::type::type
+# else
+                BOOST_FUSION_FOLD_IMPL_ENABLER(State)
+# endif
+            >::type
+# if BOOST_WORKAROUND (BOOST_MSVC, < 1500)
+          , false
+# endif
+          >
+          : result_of_it_fold<
+                SeqSize-1
+              , typename result_of::next<It>::type
+              , boost::result_of<
+                    F(
+                        typename add_reference<typename State::type>::type,
+                        typename fusion::result_of::deref<It const>::type
+                    )
+                >
               , F
             >
         {};
-        template<typename StateRef, typename It0, typename F>
-        struct result_of_unrolled_fold<
-            StateRef
-          , It0
+        template<typename It, typename State, typename F>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        inline typename result_of_it_fold<
+            0
+          , It
+          , State
           , F
-          , 1
-        >
-          : fold_lvalue_state<
-                StateRef
-              , It0 const
+        >::type
+        it_fold(mpl::int_<0>, It const&, typename State::type state, F&)
+        {
+            return state;
+        }
+        template<typename It, typename State, typename F, int SeqSize>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        inline typename lazy_enable_if_c<
+            SeqSize != 0
+          , result_of_it_fold<
+                SeqSize
+              , It
+              , State
               , F
             >
-        {};
-        template<typename StateRef, typename It0, typename F>
-        struct result_of_unrolled_fold<
-            StateRef
-          , It0
-          , F
-          , 0
-        >
+        >::type
+        it_fold(mpl::int_<SeqSize>, It const& it, typename State::type state, F& f)
         {
-            typedef StateRef type;
-        };
-        template<typename StateRef, typename It0, typename F, int SeqSize>
-        struct result_of_first_unrolledfold
-        {
-            typedef typename
-                result_of_unrolled_fold<
-                    typename fusion::detail::result_of_with_decltype<
-                        F(
-                            StateRef,
-                            typename fusion::result_of::deref< It0 const>::type
-                        )
-                    >::type
-                  , typename result_of::next<
-                        It0 const
-                    >::type
-                  , F
-                  , SeqSize-1
-                >::type
-            type;
-        };
-        template<int SeqSize, typename StateRef, typename Seq, typename F>
-        struct fold_impl
-        {
-            typedef typename
-                result_of_first_unrolledfold<
-                    StateRef
-                  , typename result_of::begin<Seq>::type
-                  , F
-                  , SeqSize
-                >::type
-            type;
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static type
-            call(StateRef state, Seq& seq, F f)
-            {
-                typedef
-                    unrolled_fold<
-                        type
-                      , SeqSize
-                    >
-                unrolled_impl;
-                return unrolled_impl::call(
-                    state,
-                    fusion::begin(seq),
-                    f);
-            }
-        };
-        template<typename StateRef, typename Seq, typename F>
-        struct fold_impl<0,StateRef,Seq,F>
-        {
-            typedef StateRef type;
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static StateRef
-            call(StateRef state, Seq&, F)
-            {
-                return static_cast<StateRef>(state);
-            }
-        };
-        template<typename Seq, typename State, typename F, bool IsSegmented>
+            return it_fold<
+                typename result_of::next<It>::type
+              , boost::result_of<
+                    F(
+                        typename add_reference<typename State::type>::type,
+                        typename fusion::result_of::deref<It const>::type
+                    )
+                >
+              , F
+            >(
+                mpl::int_<SeqSize-1>()
+              , fusion::next(it)
+              , f(state, fusion::deref(it))
+              , f
+            );
+        }
+        template<typename Seq, typename State, typename F
+          , bool = traits::is_sequence<Seq>::value
+          , bool = traits::is_segmented<Seq>::value>
         struct result_of_fold
-          : fold_impl<
+        {};
+        template<typename Seq, typename State, typename F>
+        struct result_of_fold<Seq, State, F, true, false>
+          : result_of_it_fold<
                 result_of::size<Seq>::value
-              , typename add_reference<
-                    typename add_const<State>::type
-                >::type
-              , Seq
+              , typename result_of::begin<Seq>::type
+              , add_reference<State>
               , F
             >
         {};
+        template<typename Seq, typename State, typename F>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        inline typename result_of_fold<Seq, State, F>::type
+        fold(Seq& seq, State& state, F& f)
+        {
+            return it_fold<
+                typename result_of::begin<Seq>::type
+              , add_reference<State>
+              , F
+            >(
+                typename result_of::size<Seq>::type()
+              , fusion::begin(seq)
+              , state
+              , f
+            );
+        }
     }
     namespace result_of
     {
         template<typename Seq, typename State, typename F>
         struct fold
-          : detail::result_of_fold<
-                Seq
-              , State
-              , F
-              , traits::is_segmented<Seq>::type::value
-            >
+          : detail::result_of_fold<Seq, State, F>
         {};
     }
     template<typename Seq, typename State, typename F>
@@ -358,10 +151,7 @@ namespace boost { namespace fusion
     >::type
     fold(Seq& seq, State const& state, F f)
     {
-        return result_of::fold<Seq,State const,F>::call(
-            state,
-            seq,
-            f);
+        return detail::fold<Seq, State const, F>(seq, state, f);
     }
     template<typename Seq, typename State, typename F>
     BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
@@ -372,37 +162,28 @@ namespace boost { namespace fusion
     >::type
     fold(Seq const& seq, State const& state, F f)
     {
-        return result_of::fold<Seq const,State const,F>::call(
-            state,
-            seq,
-            f);
+        return detail::fold<Seq const, State const, F>(seq, state, f);
     }
     template<typename Seq, typename State, typename F>
     BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
     inline typename result_of::fold<
         Seq
-      , State const
+      , State
       , F
     >::type
     fold(Seq& seq, State& state, F f)
     {
-        return result_of::fold<Seq,State,F>::call(
-            state,
-            seq,
-            f);
+        return detail::fold<Seq, State, F>(seq, state, f);
     }
     template<typename Seq, typename State, typename F>
     BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
     inline typename result_of::fold<
         Seq const
-      , State const
+      , State
       , F
     >::type
     fold(Seq const& seq, State& state, F f)
     {
-        return result_of::fold<Seq const,State,F>::call(
-            state,
-            seq,
-            f);
+        return detail::fold<Seq const, State, F>(seq, state, f);
     }
 }}

include/boost/fusion/algorithm/iteration/detail/preprocessed/iter_fold.hpp

@@ -7,345 +7,138 @@
 
     This is an auto-generated file. Do not edit!
 ==============================================================================*/
+# if BOOST_WORKAROUND (BOOST_MSVC, < 1500)
+# define BOOST_FUSION_FOLD_IMPL_ENABLER(T) void
+# else
+# define BOOST_FUSION_FOLD_IMPL_ENABLER(T) typename T::type
+# endif
 namespace boost { namespace fusion
 {
     namespace detail
     {
-        template<typename State, typename It, typename F>
-        struct iter_fold_lvalue_state
-          : fusion::detail::result_of_with_decltype<
-                F(
-                typename add_reference<typename add_const<State>::type>::type,
-                It&)
-            >
+        template<int SeqSize, typename It, typename State, typename F, typename = void
+# if BOOST_WORKAROUND (BOOST_MSVC, < 1500)
+          
+          , bool = SeqSize == 0
+# endif
+        >
+        struct result_of_it_iter_fold
         {};
-        template<typename Result,int N>
-        struct unrolled_iter_fold
+        template<typename It, typename State, typename F>
+        struct result_of_it_iter_fold<0,It,State,F
+          , typename boost::enable_if_has_type<BOOST_FUSION_FOLD_IMPL_ENABLER(State)>::type
+# if BOOST_WORKAROUND (BOOST_MSVC, < 1500)
+          , true
+# endif
+          >
         {
-            template<typename State3, typename It3, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call_3(State3 const& state3,It3 const& it3,F& f)
-            {
-                return unrolled_iter_fold<
-                    Result
-                  , N-4
-                >::call(
-                    f(state3,it3),
-                    fusion::next(it3),
-                    f);
-            }
-            template<typename State2, typename It2, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call_2(State2 const& state2,It2 const& it2,F& f)
-            {
-                return call_3(
-                    f(state2,it2),
-                    fusion::next(it2),
-                    f);
-            }
-            template<typename State1, typename It1, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call_1(State1 const& state1,It1 const& it1,F& f)
-            {
-                return call_2(
-                    f(state1,it1),
-                    fusion::next(it1),
-                    f);
-            }
-            template<typename State, typename It0, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call(State const& state,It0 const& it0,F f)
-            {
-                return call_1(
-                    f(state,it0),
-                    fusion::next(it0),
-                    f);
-            }
+            typedef typename State::type type;
         };
-        template<typename Result>
-        struct unrolled_iter_fold<Result,3>
-        {
-            template<typename State2, typename It2, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call_2(State2 const& state2,It2 const& it2,F& f)
-            {
-                return f(state2,it2);
-            }
-            template<typename State1, typename It1, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call_1(State1 const& state1,It1 const& it1,F& f)
-            {
-                return call_2(
-                    f(state1,it1),
-                    fusion::next(it1),
-                    f);
-            }
-            template<typename State, typename It0, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call(State const& state,It0 const& it0,F f)
-            {
-                return call_1(
-                    f(state,it0),
-                    fusion::next(it0),
-                    f);
-            }
-        };
-        template<typename Result>
-        struct unrolled_iter_fold<Result,2>
-        {
-            template<typename State1, typename It1, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call_1(State1 const& state1,It1 const& it1,F& f)
-            {
-                return f(state1,it1);
-            }
-            template<typename State, typename It0, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call(State const& state,It0 const& it0,F f)
-            {
-                return call_1(
-                    f(state,it0),
-                    fusion::next(it0),
-                    f);
-            }
-        };
-        template<typename Result>
-        struct unrolled_iter_fold<Result,1>
-        {
-            template<typename State, typename It0, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call(State const& state,It0 const& it0,F f)
-            {
-                return f(state,
-                    it0);
-            }
-        };
-        template<typename Result>
-        struct unrolled_iter_fold<Result,0>
-        {
-            template<typename State, typename It0, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call(State const& state,It0 const&, F)
-            {
-                return static_cast<Result>(state);
-            }
-        };
-        template<typename StateRef, typename It0, typename F, int N>
-        struct result_of_unrolled_iter_fold
-        {
-            typedef typename
-                iter_fold_lvalue_state<
-                    StateRef
-                  , It0 const
-                  , F
-                >::type
-            rest1;
-            typedef typename
-                result_of::next<
-                    It0 const
-                >::type
-            it1;
-            typedef typename
-                iter_fold_lvalue_state<
-                    rest1
-                  , it1
-                  , F
-                >::type
-            rest2;
-            typedef typename
-                result_of::next<it1>::type
-            it2;
-            typedef typename
-                iter_fold_lvalue_state<
-                    rest2
-                  , it2
-                  , F
-                >::type
-            rest3;
-            typedef typename
-                result_of::next<it2>::type
-            it3;
-            typedef typename
-                result_of_unrolled_iter_fold<
-                    typename iter_fold_lvalue_state<
-                        rest3
-                      , it3
-                      , F
-                    >::type
-                  , typename result_of::next<
-                        it3
-                    >::type
-                  , F
-                  , N-4
-                >::type
-            type;
-        };
-        template<typename StateRef, typename It0, typename F>
-        struct result_of_unrolled_iter_fold<
-            StateRef
-          , It0
-          , F
-          , 3
-        >
-        {
-            typedef typename
-                iter_fold_lvalue_state<
-                    StateRef
-                  , It0 const
-                  , F
-                >::type
-            rest1;
-            typedef typename
-                result_of::next<
-                    It0 const
-                >::type
-            it1;
-            typedef typename
-                iter_fold_lvalue_state<
-                    typename iter_fold_lvalue_state<
-                        rest1
-                      , it1
-                      , F
-                    >::type
-                  , typename result_of::next<
-                        it1 const
-                    >::type const
-                  , F
-                >::type
-            type;
-        };
-        template<typename StateRef, typename It0, typename F>
-        struct result_of_unrolled_iter_fold<
-            StateRef
-          , It0
-          , F
-          , 2
-        >
-          : iter_fold_lvalue_state<
-                typename iter_fold_lvalue_state<
-                    StateRef
-                  , It0 const
-                  , F
-                >::type
-              , typename result_of::next<
-                    It0 const
-                >::type const
+        template<int SeqSize, typename It, typename State, typename F>
+        struct result_of_it_iter_fold<SeqSize,It,State,F
+          , typename boost::enable_if_has_type<
+# if BOOST_WORKAROUND (BOOST_MSVC, >= 1500)
+                
+                
+                
+                typename boost::disable_if_c<SeqSize == 0, State>::type::type
+# else
+                BOOST_FUSION_FOLD_IMPL_ENABLER(State)
+# endif
+            >::type
+# if BOOST_WORKAROUND (BOOST_MSVC, < 1500)
+          , false
+# endif
+          >
+          : result_of_it_iter_fold<
+                SeqSize-1
+              , typename result_of::next<It>::type
+              , boost::result_of<
+                    F(
+                        typename add_reference<typename State::type>::type,
+                        It const&
+                    )
+                >
               , F
             >
         {};
-        template<typename StateRef, typename It0, typename F>
-        struct result_of_unrolled_iter_fold<
-            StateRef
-          , It0
+        template<typename It, typename State, typename F>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        inline typename result_of_it_iter_fold<
+            0
+          , It
+          , State
           , F
-          , 1
-        >
-          : iter_fold_lvalue_state<
-                StateRef
-              , It0 const
+        >::type
+        it_iter_fold(mpl::int_<0>, It const&, typename State::type state, F&)
+        {
+            return state;
+        }
+        template<typename It, typename State, typename F, int SeqSize>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        inline typename lazy_enable_if_c<
+            SeqSize != 0
+          , result_of_it_iter_fold<
+                SeqSize
+              , It
+              , State
               , F
             >
-        {};
-        template<typename StateRef, typename It0, typename F>
-        struct result_of_unrolled_iter_fold<
-            StateRef
-          , It0
-          , F
-          , 0
-        >
+        >::type
+        it_iter_fold(mpl::int_<SeqSize>, It const& it, typename State::type state, F& f)
         {
-            typedef StateRef type;
-        };
-        template<typename StateRef, typename It0, typename F, int SeqSize>
-        struct result_of_first_unrollediter_fold
-        {
-            typedef typename
-                result_of_unrolled_iter_fold<
-                    typename fusion::detail::result_of_with_decltype<
-                        F(
-                            StateRef,
-                            It0 const&
-                        )
-                    >::type
-                  , typename result_of::next<
-                        It0 const
-                    >::type
-                  , F
-                  , SeqSize-1
-                >::type
-            type;
-        };
-        template<int SeqSize, typename StateRef, typename Seq, typename F>
-        struct iter_fold_impl
-        {
-            typedef typename
-                result_of_first_unrollediter_fold<
-                    StateRef
-                  , typename result_of::begin<Seq>::type
-                  , F
-                  , SeqSize
-                >::type
-            type;
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static type
-            call(StateRef state, Seq& seq, F f)
-            {
-                typedef
-                    unrolled_iter_fold<
-                        type
-                      , SeqSize
-                    >
-                unrolled_impl;
-                return unrolled_impl::call(
-                    state,
-                    fusion::begin(seq),
-                    f);
-            }
-        };
-        template<typename StateRef, typename Seq, typename F>
-        struct iter_fold_impl<0,StateRef,Seq,F>
-        {
-            typedef StateRef type;
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static StateRef
-            call(StateRef state, Seq&, F)
-            {
-                return static_cast<StateRef>(state);
-            }
-        };
-        template<typename Seq, typename State, typename F, bool IsSegmented>
+            return it_iter_fold<
+                typename result_of::next<It>::type
+              , boost::result_of<
+                    F(
+                        typename add_reference<typename State::type>::type,
+                        It const&
+                    )
+                >
+              , F
+            >(
+                mpl::int_<SeqSize-1>()
+              , fusion::next(it)
+              , f(state, it)
+              , f
+            );
+        }
+        template<typename Seq, typename State, typename F
+          , bool = traits::is_sequence<Seq>::value
+          , bool = traits::is_segmented<Seq>::value>
         struct result_of_iter_fold
-          : iter_fold_impl<
+        {};
+        template<typename Seq, typename State, typename F>
+        struct result_of_iter_fold<Seq, State, F, true, false>
+          : result_of_it_iter_fold<
                 result_of::size<Seq>::value
-              , typename add_reference<
-                    typename add_const<State>::type
-                >::type
-              , Seq
+              , typename result_of::begin<Seq>::type
+              , add_reference<State>
               , F
             >
         {};
+        template<typename Seq, typename State, typename F>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        inline typename result_of_iter_fold<Seq, State, F>::type
+        iter_fold(Seq& seq, State& state, F& f)
+        {
+            return it_iter_fold<
+                typename result_of::begin<Seq>::type
+              , add_reference<State>
+              , F
+            >(
+                typename result_of::size<Seq>::type()
+              , fusion::begin(seq)
+              , state
+              , f
+            );
+        }
     }
     namespace result_of
     {
         template<typename Seq, typename State, typename F>
         struct iter_fold
-          : detail::result_of_iter_fold<
-                Seq
-              , State
-              , F
-              , traits::is_segmented<Seq>::type::value
-            >
+          : detail::result_of_iter_fold<Seq, State, F>
         {};
     }
     template<typename Seq, typename State, typename F>
@@ -357,10 +150,7 @@ namespace boost { namespace fusion
     >::type
     iter_fold(Seq& seq, State const& state, F f)
     {
-        return result_of::iter_fold<Seq,State const,F>::call(
-            state,
-            seq,
-            f);
+        return detail::iter_fold<Seq, State const, F>(seq, state, f);
     }
     template<typename Seq, typename State, typename F>
     BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
@@ -371,37 +161,28 @@ namespace boost { namespace fusion
     >::type
     iter_fold(Seq const& seq, State const& state, F f)
     {
-        return result_of::iter_fold<Seq const,State const,F>::call(
-            state,
-            seq,
-            f);
+        return detail::iter_fold<Seq const, State const, F>(seq, state, f);
     }
     template<typename Seq, typename State, typename F>
     BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
     inline typename result_of::iter_fold<
         Seq
-      , State const
+      , State
       , F
     >::type
     iter_fold(Seq& seq, State& state, F f)
     {
-        return result_of::iter_fold<Seq,State,F>::call(
-            state,
-            seq,
-            f);
+        return detail::iter_fold<Seq, State, F>(seq, state, f);
     }
     template<typename Seq, typename State, typename F>
     BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
     inline typename result_of::iter_fold<
         Seq const
-      , State const
+      , State
       , F
     >::type
     iter_fold(Seq const& seq, State& state, F f)
     {
-        return result_of::iter_fold<Seq const,State,F>::call(
-            state,
-            seq,
-            f);
+        return detail::iter_fold<Seq const, State, F>(seq, state, f);
     }
 }}

include/boost/fusion/algorithm/iteration/detail/preprocessed/reverse_fold.hpp

@@ -7,345 +7,138 @@
 
     This is an auto-generated file. Do not edit!
 ==============================================================================*/
+# if BOOST_WORKAROUND (BOOST_MSVC, < 1500)
+# define BOOST_FUSION_FOLD_IMPL_ENABLER(T) void
+# else
+# define BOOST_FUSION_FOLD_IMPL_ENABLER(T) typename T::type
+# endif
 namespace boost { namespace fusion
 {
     namespace detail
     {
-        template<typename State, typename It, typename F>
-        struct reverse_fold_lvalue_state
-          : fusion::detail::result_of_with_decltype<
-                F(
-                typename add_reference<typename add_const<State>::type>::type,
-                typename fusion::result_of::deref<It>::type)
-            >
+        template<int SeqSize, typename It, typename State, typename F, typename = void
+# if BOOST_WORKAROUND (BOOST_MSVC, < 1500)
+          
+          , bool = SeqSize == 0
+# endif
+        >
+        struct result_of_it_reverse_fold
         {};
-        template<typename Result,int N>
-        struct unrolled_reverse_fold
+        template<typename It, typename State, typename F>
+        struct result_of_it_reverse_fold<0,It,State,F
+          , typename boost::enable_if_has_type<BOOST_FUSION_FOLD_IMPL_ENABLER(State)>::type
+# if BOOST_WORKAROUND (BOOST_MSVC, < 1500)
+          , true
+# endif
+          >
         {
-            template<typename State3, typename It3, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call_3(State3 const& state3,It3 const& it3,F& f)
-            {
-                return unrolled_reverse_fold<
-                    Result
-                  , N-4
-                >::call(
-                    f(state3,fusion::deref(it3)),
-                    fusion::prior(it3),
-                    f);
-            }
-            template<typename State2, typename It2, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call_2(State2 const& state2,It2 const& it2,F& f)
-            {
-                return call_3(
-                    f(state2,fusion::deref(it2)),
-                    fusion::prior(it2),
-                    f);
-            }
-            template<typename State1, typename It1, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call_1(State1 const& state1,It1 const& it1,F& f)
-            {
-                return call_2(
-                    f(state1,fusion::deref(it1)),
-                    fusion::prior(it1),
-                    f);
-            }
-            template<typename State, typename It0, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call(State const& state,It0 const& it0,F f)
-            {
-                return call_1(
-                    f(state,fusion::deref(it0)),
-                    fusion::prior(it0),
-                    f);
-            }
+            typedef typename State::type type;
         };
-        template<typename Result>
-        struct unrolled_reverse_fold<Result,3>
-        {
-            template<typename State2, typename It2, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call_2(State2 const& state2,It2 const& it2,F& f)
-            {
-                return f(state2,fusion::deref(it2));
-            }
-            template<typename State1, typename It1, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call_1(State1 const& state1,It1 const& it1,F& f)
-            {
-                return call_2(
-                    f(state1,fusion::deref(it1)),
-                    fusion::prior(it1),
-                    f);
-            }
-            template<typename State, typename It0, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call(State const& state,It0 const& it0,F f)
-            {
-                return call_1(
-                    f(state,fusion::deref(it0)),
-                    fusion::prior(it0),
-                    f);
-            }
-        };
-        template<typename Result>
-        struct unrolled_reverse_fold<Result,2>
-        {
-            template<typename State1, typename It1, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call_1(State1 const& state1,It1 const& it1,F& f)
-            {
-                return f(state1,fusion::deref(it1));
-            }
-            template<typename State, typename It0, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call(State const& state,It0 const& it0,F f)
-            {
-                return call_1(
-                    f(state,fusion::deref(it0)),
-                    fusion::prior(it0),
-                    f);
-            }
-        };
-        template<typename Result>
-        struct unrolled_reverse_fold<Result,1>
-        {
-            template<typename State, typename It0, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call(State const& state,It0 const& it0,F f)
-            {
-                return f(state,
-                    fusion::deref(it0));
-            }
-        };
-        template<typename Result>
-        struct unrolled_reverse_fold<Result,0>
-        {
-            template<typename State, typename It0, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call(State const& state,It0 const&, F)
-            {
-                return static_cast<Result>(state);
-            }
-        };
-        template<typename StateRef, typename It0, typename F, int N>
-        struct result_of_unrolled_reverse_fold
-        {
-            typedef typename
-                reverse_fold_lvalue_state<
-                    StateRef
-                  , It0 const
-                  , F
-                >::type
-            rest1;
-            typedef typename
-                result_of::prior<
-                    It0 const
-                >::type
-            it1;
-            typedef typename
-                reverse_fold_lvalue_state<
-                    rest1
-                  , it1
-                  , F
-                >::type
-            rest2;
-            typedef typename
-                result_of::prior<it1>::type
-            it2;
-            typedef typename
-                reverse_fold_lvalue_state<
-                    rest2
-                  , it2
-                  , F
-                >::type
-            rest3;
-            typedef typename
-                result_of::prior<it2>::type
-            it3;
-            typedef typename
-                result_of_unrolled_reverse_fold<
-                    typename reverse_fold_lvalue_state<
-                        rest3
-                      , it3
-                      , F
-                    >::type
-                  , typename result_of::prior<
-                        it3
-                    >::type
-                  , F
-                  , N-4
-                >::type
-            type;
-        };
-        template<typename StateRef, typename It0, typename F>
-        struct result_of_unrolled_reverse_fold<
-            StateRef
-          , It0
-          , F
-          , 3
-        >
-        {
-            typedef typename
-                reverse_fold_lvalue_state<
-                    StateRef
-                  , It0 const
-                  , F
-                >::type
-            rest1;
-            typedef typename
-                result_of::prior<
-                    It0 const
-                >::type
-            it1;
-            typedef typename
-                reverse_fold_lvalue_state<
-                    typename reverse_fold_lvalue_state<
-                        rest1
-                      , it1
-                      , F
-                    >::type
-                  , typename result_of::prior<
-                        it1 const
-                    >::type const
-                  , F
-                >::type
-            type;
-        };
-        template<typename StateRef, typename It0, typename F>
-        struct result_of_unrolled_reverse_fold<
-            StateRef
-          , It0
-          , F
-          , 2
-        >
-          : reverse_fold_lvalue_state<
-                typename reverse_fold_lvalue_state<
-                    StateRef
-                  , It0 const
-                  , F
-                >::type
-              , typename result_of::prior<
-                    It0 const
-                >::type const
+        template<int SeqSize, typename It, typename State, typename F>
+        struct result_of_it_reverse_fold<SeqSize,It,State,F
+          , typename boost::enable_if_has_type<
+# if BOOST_WORKAROUND (BOOST_MSVC, >= 1500)
+                
+                
+                
+                typename boost::disable_if_c<SeqSize == 0, State>::type::type
+# else
+                BOOST_FUSION_FOLD_IMPL_ENABLER(State)
+# endif
+            >::type
+# if BOOST_WORKAROUND (BOOST_MSVC, < 1500)
+          , false
+# endif
+          >
+          : result_of_it_reverse_fold<
+                SeqSize-1
+              , typename result_of::prior<It>::type
+              , boost::result_of<
+                    F(
+                        typename add_reference<typename State::type>::type,
+                        typename fusion::result_of::deref<It const>::type
+                    )
+                >
               , F
             >
         {};
-        template<typename StateRef, typename It0, typename F>
-        struct result_of_unrolled_reverse_fold<
-            StateRef
-          , It0
+        template<typename It, typename State, typename F>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        inline typename result_of_it_reverse_fold<
+            0
+          , It
+          , State
           , F
-          , 1
-        >
-          : reverse_fold_lvalue_state<
-                StateRef
-              , It0 const
+        >::type
+        it_reverse_fold(mpl::int_<0>, It const&, typename State::type state, F&)
+        {
+            return state;
+        }
+        template<typename It, typename State, typename F, int SeqSize>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        inline typename lazy_enable_if_c<
+            SeqSize != 0
+          , result_of_it_reverse_fold<
+                SeqSize
+              , It
+              , State
               , F
             >
-        {};
-        template<typename StateRef, typename It0, typename F>
-        struct result_of_unrolled_reverse_fold<
-            StateRef
-          , It0
-          , F
-          , 0
-        >
+        >::type
+        it_reverse_fold(mpl::int_<SeqSize>, It const& it, typename State::type state, F& f)
         {
-            typedef StateRef type;
-        };
-        template<typename StateRef, typename It0, typename F, int SeqSize>
-        struct result_of_first_unrolledreverse_fold
-        {
-            typedef typename
-                result_of_unrolled_reverse_fold<
-                    typename fusion::detail::result_of_with_decltype<
-                        F(
-                            StateRef,
-                            typename fusion::result_of::deref< It0 const>::type
-                        )
-                    >::type
-                  , typename result_of::prior<
-                        It0 const
-                    >::type
-                  , F
-                  , SeqSize-1
-                >::type
-            type;
-        };
-        template<int SeqSize, typename StateRef, typename Seq, typename F>
-        struct reverse_fold_impl
-        {
-            typedef typename
-                result_of_first_unrolledreverse_fold<
-                    StateRef
-                  , typename fusion::result_of::prior< typename result_of::end<Seq>::type >::type
-                  , F
-                  , SeqSize
-                >::type
-            type;
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static type
-            call(StateRef state, Seq& seq, F f)
-            {
-                typedef
-                    unrolled_reverse_fold<
-                        type
-                      , SeqSize
-                    >
-                unrolled_impl;
-                return unrolled_impl::call(
-                    state,
-                    fusion::prior( fusion::end(seq)),
-                    f);
-            }
-        };
-        template<typename StateRef, typename Seq, typename F>
-        struct reverse_fold_impl<0,StateRef,Seq,F>
-        {
-            typedef StateRef type;
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static StateRef
-            call(StateRef state, Seq&, F)
-            {
-                return static_cast<StateRef>(state);
-            }
-        };
-        template<typename Seq, typename State, typename F, bool IsSegmented>
+            return it_reverse_fold<
+                typename result_of::prior<It>::type
+              , boost::result_of<
+                    F(
+                        typename add_reference<typename State::type>::type,
+                        typename fusion::result_of::deref<It const>::type
+                    )
+                >
+              , F
+            >(
+                mpl::int_<SeqSize-1>()
+              , fusion::prior(it)
+              , f(state, fusion::deref(it))
+              , f
+            );
+        }
+        template<typename Seq, typename State, typename F
+          , bool = traits::is_sequence<Seq>::value
+          , bool = traits::is_segmented<Seq>::value>
         struct result_of_reverse_fold
-          : reverse_fold_impl<
+        {};
+        template<typename Seq, typename State, typename F>
+        struct result_of_reverse_fold<Seq, State, F, true, false>
+          : result_of_it_reverse_fold<
                 result_of::size<Seq>::value
-              , typename add_reference<
-                    typename add_const<State>::type
-                >::type
-              , Seq
+              , typename fusion::result_of::prior< typename result_of::end<Seq>::type >::type
+              , add_reference<State>
               , F
             >
         {};
+        template<typename Seq, typename State, typename F>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        inline typename result_of_reverse_fold<Seq, State, F>::type
+        reverse_fold(Seq& seq, State& state, F& f)
+        {
+            return it_reverse_fold<
+                typename fusion::result_of::prior< typename result_of::end<Seq>::type >::type
+              , add_reference<State>
+              , F
+            >(
+                typename result_of::size<Seq>::type()
+              , fusion::prior( fusion::end(seq) )
+              , state
+              , f
+            );
+        }
     }
     namespace result_of
     {
         template<typename Seq, typename State, typename F>
         struct reverse_fold
-          : detail::result_of_reverse_fold<
-                Seq
-              , State
-              , F
-              , traits::is_segmented<Seq>::type::value
-            >
+          : detail::result_of_reverse_fold<Seq, State, F>
         {};
     }
     template<typename Seq, typename State, typename F>
@@ -357,10 +150,7 @@ namespace boost { namespace fusion
     >::type
     reverse_fold(Seq& seq, State const& state, F f)
     {
-        return result_of::reverse_fold<Seq,State const,F>::call(
-            state,
-            seq,
-            f);
+        return detail::reverse_fold<Seq, State const, F>(seq, state, f);
     }
     template<typename Seq, typename State, typename F>
     BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
@@ -371,37 +161,28 @@ namespace boost { namespace fusion
     >::type
     reverse_fold(Seq const& seq, State const& state, F f)
     {
-        return result_of::reverse_fold<Seq const,State const,F>::call(
-            state,
-            seq,
-            f);
+        return detail::reverse_fold<Seq const, State const, F>(seq, state, f);
     }
     template<typename Seq, typename State, typename F>
     BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
     inline typename result_of::reverse_fold<
         Seq
-      , State const
+      , State
       , F
     >::type
     reverse_fold(Seq& seq, State& state, F f)
     {
-        return result_of::reverse_fold<Seq,State,F>::call(
-            state,
-            seq,
-            f);
+        return detail::reverse_fold<Seq, State, F>(seq, state, f);
     }
     template<typename Seq, typename State, typename F>
     BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
     inline typename result_of::reverse_fold<
         Seq const
-      , State const
+      , State
       , F
     >::type
     reverse_fold(Seq const& seq, State& state, F f)
     {
-        return result_of::reverse_fold<Seq const,State,F>::call(
-            state,
-            seq,
-            f);
+        return detail::reverse_fold<Seq const, State, F>(seq, state, f);
     }
 }}

include/boost/fusion/algorithm/iteration/detail/preprocessed/reverse_iter_fold.hpp

@@ -7,345 +7,138 @@
 
     This is an auto-generated file. Do not edit!
 ==============================================================================*/
+# if BOOST_WORKAROUND (BOOST_MSVC, < 1500)
+# define BOOST_FUSION_FOLD_IMPL_ENABLER(T) void
+# else
+# define BOOST_FUSION_FOLD_IMPL_ENABLER(T) typename T::type
+# endif
 namespace boost { namespace fusion
 {
     namespace detail
     {
-        template<typename State, typename It, typename F>
-        struct reverse_iter_fold_lvalue_state
-          : fusion::detail::result_of_with_decltype<
-                F(
-                typename add_reference<typename add_const<State>::type>::type,
-                It&)
-            >
+        template<int SeqSize, typename It, typename State, typename F, typename = void
+# if BOOST_WORKAROUND (BOOST_MSVC, < 1500)
+          
+          , bool = SeqSize == 0
+# endif
+        >
+        struct result_of_it_reverse_iter_fold
         {};
-        template<typename Result,int N>
-        struct unrolled_reverse_iter_fold
+        template<typename It, typename State, typename F>
+        struct result_of_it_reverse_iter_fold<0,It,State,F
+          , typename boost::enable_if_has_type<BOOST_FUSION_FOLD_IMPL_ENABLER(State)>::type
+# if BOOST_WORKAROUND (BOOST_MSVC, < 1500)
+          , true
+# endif
+          >
         {
-            template<typename State3, typename It3, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call_3(State3 const& state3,It3 const& it3,F& f)
-            {
-                return unrolled_reverse_iter_fold<
-                    Result
-                  , N-4
-                >::call(
-                    f(state3,it3),
-                    fusion::prior(it3),
-                    f);
-            }
-            template<typename State2, typename It2, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call_2(State2 const& state2,It2 const& it2,F& f)
-            {
-                return call_3(
-                    f(state2,it2),
-                    fusion::prior(it2),
-                    f);
-            }
-            template<typename State1, typename It1, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call_1(State1 const& state1,It1 const& it1,F& f)
-            {
-                return call_2(
-                    f(state1,it1),
-                    fusion::prior(it1),
-                    f);
-            }
-            template<typename State, typename It0, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call(State const& state,It0 const& it0,F f)
-            {
-                return call_1(
-                    f(state,it0),
-                    fusion::prior(it0),
-                    f);
-            }
+            typedef typename State::type type;
         };
-        template<typename Result>
-        struct unrolled_reverse_iter_fold<Result,3>
-        {
-            template<typename State2, typename It2, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call_2(State2 const& state2,It2 const& it2,F& f)
-            {
-                return f(state2,it2);
-            }
-            template<typename State1, typename It1, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call_1(State1 const& state1,It1 const& it1,F& f)
-            {
-                return call_2(
-                    f(state1,it1),
-                    fusion::prior(it1),
-                    f);
-            }
-            template<typename State, typename It0, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call(State const& state,It0 const& it0,F f)
-            {
-                return call_1(
-                    f(state,it0),
-                    fusion::prior(it0),
-                    f);
-            }
-        };
-        template<typename Result>
-        struct unrolled_reverse_iter_fold<Result,2>
-        {
-            template<typename State1, typename It1, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call_1(State1 const& state1,It1 const& it1,F& f)
-            {
-                return f(state1,it1);
-            }
-            template<typename State, typename It0, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call(State const& state,It0 const& it0,F f)
-            {
-                return call_1(
-                    f(state,it0),
-                    fusion::prior(it0),
-                    f);
-            }
-        };
-        template<typename Result>
-        struct unrolled_reverse_iter_fold<Result,1>
-        {
-            template<typename State, typename It0, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call(State const& state,It0 const& it0,F f)
-            {
-                return f(state,
-                    it0);
-            }
-        };
-        template<typename Result>
-        struct unrolled_reverse_iter_fold<Result,0>
-        {
-            template<typename State, typename It0, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call(State const& state,It0 const&, F)
-            {
-                return static_cast<Result>(state);
-            }
-        };
-        template<typename StateRef, typename It0, typename F, int N>
-        struct result_of_unrolled_reverse_iter_fold
-        {
-            typedef typename
-                reverse_iter_fold_lvalue_state<
-                    StateRef
-                  , It0 const
-                  , F
-                >::type
-            rest1;
-            typedef typename
-                result_of::prior<
-                    It0 const
-                >::type
-            it1;
-            typedef typename
-                reverse_iter_fold_lvalue_state<
-                    rest1
-                  , it1
-                  , F
-                >::type
-            rest2;
-            typedef typename
-                result_of::prior<it1>::type
-            it2;
-            typedef typename
-                reverse_iter_fold_lvalue_state<
-                    rest2
-                  , it2
-                  , F
-                >::type
-            rest3;
-            typedef typename
-                result_of::prior<it2>::type
-            it3;
-            typedef typename
-                result_of_unrolled_reverse_iter_fold<
-                    typename reverse_iter_fold_lvalue_state<
-                        rest3
-                      , it3
-                      , F
-                    >::type
-                  , typename result_of::prior<
-                        it3
-                    >::type
-                  , F
-                  , N-4
-                >::type
-            type;
-        };
-        template<typename StateRef, typename It0, typename F>
-        struct result_of_unrolled_reverse_iter_fold<
-            StateRef
-          , It0
-          , F
-          , 3
-        >
-        {
-            typedef typename
-                reverse_iter_fold_lvalue_state<
-                    StateRef
-                  , It0 const
-                  , F
-                >::type
-            rest1;
-            typedef typename
-                result_of::prior<
-                    It0 const
-                >::type
-            it1;
-            typedef typename
-                reverse_iter_fold_lvalue_state<
-                    typename reverse_iter_fold_lvalue_state<
-                        rest1
-                      , it1
-                      , F
-                    >::type
-                  , typename result_of::prior<
-                        it1 const
-                    >::type const
-                  , F
-                >::type
-            type;
-        };
-        template<typename StateRef, typename It0, typename F>
-        struct result_of_unrolled_reverse_iter_fold<
-            StateRef
-          , It0
-          , F
-          , 2
-        >
-          : reverse_iter_fold_lvalue_state<
-                typename reverse_iter_fold_lvalue_state<
-                    StateRef
-                  , It0 const
-                  , F
-                >::type
-              , typename result_of::prior<
-                    It0 const
-                >::type const
+        template<int SeqSize, typename It, typename State, typename F>
+        struct result_of_it_reverse_iter_fold<SeqSize,It,State,F
+          , typename boost::enable_if_has_type<
+# if BOOST_WORKAROUND (BOOST_MSVC, >= 1500)
+                
+                
+                
+                typename boost::disable_if_c<SeqSize == 0, State>::type::type
+# else
+                BOOST_FUSION_FOLD_IMPL_ENABLER(State)
+# endif
+            >::type
+# if BOOST_WORKAROUND (BOOST_MSVC, < 1500)
+          , false
+# endif
+          >
+          : result_of_it_reverse_iter_fold<
+                SeqSize-1
+              , typename result_of::prior<It>::type
+              , boost::result_of<
+                    F(
+                        typename add_reference<typename State::type>::type,
+                        It const&
+                    )
+                >
               , F
             >
         {};
-        template<typename StateRef, typename It0, typename F>
-        struct result_of_unrolled_reverse_iter_fold<
-            StateRef
-          , It0
+        template<typename It, typename State, typename F>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        inline typename result_of_it_reverse_iter_fold<
+            0
+          , It
+          , State
           , F
-          , 1
-        >
-          : reverse_iter_fold_lvalue_state<
-                StateRef
-              , It0 const
+        >::type
+        it_reverse_iter_fold(mpl::int_<0>, It const&, typename State::type state, F&)
+        {
+            return state;
+        }
+        template<typename It, typename State, typename F, int SeqSize>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        inline typename lazy_enable_if_c<
+            SeqSize != 0
+          , result_of_it_reverse_iter_fold<
+                SeqSize
+              , It
+              , State
               , F
             >
-        {};
-        template<typename StateRef, typename It0, typename F>
-        struct result_of_unrolled_reverse_iter_fold<
-            StateRef
-          , It0
-          , F
-          , 0
-        >
+        >::type
+        it_reverse_iter_fold(mpl::int_<SeqSize>, It const& it, typename State::type state, F& f)
         {
-            typedef StateRef type;
-        };
-        template<typename StateRef, typename It0, typename F, int SeqSize>
-        struct result_of_first_unrolledreverse_iter_fold
-        {
-            typedef typename
-                result_of_unrolled_reverse_iter_fold<
-                    typename fusion::detail::result_of_with_decltype<
-                        F(
-                            StateRef,
-                            It0 const&
-                        )
-                    >::type
-                  , typename result_of::prior<
-                        It0 const
-                    >::type
-                  , F
-                  , SeqSize-1
-                >::type
-            type;
-        };
-        template<int SeqSize, typename StateRef, typename Seq, typename F>
-        struct reverse_iter_fold_impl
-        {
-            typedef typename
-                result_of_first_unrolledreverse_iter_fold<
-                    StateRef
-                  , typename fusion::result_of::prior< typename result_of::end<Seq>::type >::type
-                  , F
-                  , SeqSize
-                >::type
-            type;
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static type
-            call(StateRef state, Seq& seq, F f)
-            {
-                typedef
-                    unrolled_reverse_iter_fold<
-                        type
-                      , SeqSize
-                    >
-                unrolled_impl;
-                return unrolled_impl::call(
-                    state,
-                    fusion::prior( fusion::end(seq)),
-                    f);
-            }
-        };
-        template<typename StateRef, typename Seq, typename F>
-        struct reverse_iter_fold_impl<0,StateRef,Seq,F>
-        {
-            typedef StateRef type;
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static StateRef
-            call(StateRef state, Seq&, F)
-            {
-                return static_cast<StateRef>(state);
-            }
-        };
-        template<typename Seq, typename State, typename F, bool IsSegmented>
+            return it_reverse_iter_fold<
+                typename result_of::prior<It>::type
+              , boost::result_of<
+                    F(
+                        typename add_reference<typename State::type>::type,
+                        It const&
+                    )
+                >
+              , F
+            >(
+                mpl::int_<SeqSize-1>()
+              , fusion::prior(it)
+              , f(state, it)
+              , f
+            );
+        }
+        template<typename Seq, typename State, typename F
+          , bool = traits::is_sequence<Seq>::value
+          , bool = traits::is_segmented<Seq>::value>
         struct result_of_reverse_iter_fold
-          : reverse_iter_fold_impl<
+        {};
+        template<typename Seq, typename State, typename F>
+        struct result_of_reverse_iter_fold<Seq, State, F, true, false>
+          : result_of_it_reverse_iter_fold<
                 result_of::size<Seq>::value
-              , typename add_reference<
-                    typename add_const<State>::type
-                >::type
-              , Seq
+              , typename fusion::result_of::prior< typename result_of::end<Seq>::type >::type
+              , add_reference<State>
               , F
             >
         {};
+        template<typename Seq, typename State, typename F>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        inline typename result_of_reverse_iter_fold<Seq, State, F>::type
+        reverse_iter_fold(Seq& seq, State& state, F& f)
+        {
+            return it_reverse_iter_fold<
+                typename fusion::result_of::prior< typename result_of::end<Seq>::type >::type
+              , add_reference<State>
+              , F
+            >(
+                typename result_of::size<Seq>::type()
+              , fusion::prior( fusion::end(seq) )
+              , state
+              , f
+            );
+        }
     }
     namespace result_of
     {
         template<typename Seq, typename State, typename F>
         struct reverse_iter_fold
-          : detail::result_of_reverse_iter_fold<
-                Seq
-              , State
-              , F
-              , traits::is_segmented<Seq>::type::value
-            >
+          : detail::result_of_reverse_iter_fold<Seq, State, F>
         {};
     }
     template<typename Seq, typename State, typename F>
@@ -357,10 +150,7 @@ namespace boost { namespace fusion
     >::type
     reverse_iter_fold(Seq& seq, State const& state, F f)
     {
-        return result_of::reverse_iter_fold<Seq,State const,F>::call(
-            state,
-            seq,
-            f);
+        return detail::reverse_iter_fold<Seq, State const, F>(seq, state, f);
     }
     template<typename Seq, typename State, typename F>
     BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
@@ -371,37 +161,28 @@ namespace boost { namespace fusion
     >::type
     reverse_iter_fold(Seq const& seq, State const& state, F f)
     {
-        return result_of::reverse_iter_fold<Seq const,State const,F>::call(
-            state,
-            seq,
-            f);
+        return detail::reverse_iter_fold<Seq const, State const, F>(seq, state, f);
     }
     template<typename Seq, typename State, typename F>
     BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
     inline typename result_of::reverse_iter_fold<
         Seq
-      , State const
+      , State
       , F
     >::type
     reverse_iter_fold(Seq& seq, State& state, F f)
     {
-        return result_of::reverse_iter_fold<Seq,State,F>::call(
-            state,
-            seq,
-            f);
+        return detail::reverse_iter_fold<Seq, State, F>(seq, state, f);
     }
     template<typename Seq, typename State, typename F>
     BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
     inline typename result_of::reverse_iter_fold<
         Seq const
-      , State const
+      , State
       , F
     >::type
     reverse_iter_fold(Seq const& seq, State& state, F f)
     {
-        return result_of::reverse_iter_fold<Seq const,State,F>::call(
-            state,
-            seq,
-            f);
+        return detail::reverse_iter_fold<Seq const, State, F>(seq, state, f);
     }
 }}

include/boost/fusion/algorithm/iteration/detail/segmented_fold.hpp

@@ -10,13 +10,14 @@
 #include <boost/fusion/support/config.hpp>
 #include <boost/fusion/algorithm/iteration/fold_fwd.hpp>
 #include <boost/fusion/support/segmented_fold_until.hpp>
+#include <boost/mpl/bool.hpp>
 
 namespace boost { namespace fusion { namespace detail
 {
     template <typename Fun>
     struct segmented_fold_fun
     {
-        BOOST_FUSION_GPU_ENABLED
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
         explicit segmented_fold_fun(Fun const& f)
           : fun(f)
         {}
@@ -29,7 +30,7 @@ namespace boost { namespace fusion { namespace detail
             typedef typename result_of::fold<Sequence, State, Fun>::type type;
             typedef mpl::true_ continue_type;
 
-            BOOST_FUSION_GPU_ENABLED
+            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
             static type call(Sequence& seq, State const& state, Context const&, segmented_fold_fun const& fun)
             {
                 return fusion::fold(seq, state, fun.fun);
@@ -38,11 +39,11 @@ namespace boost { namespace fusion { namespace detail
     };
 
     // The default implementation of this lives in detail/fold.hpp
-    template <typename Sequence, typename State, typename Fun, bool IsSegmented>
+    template <typename Sequence, typename State, typename Fun, bool IsSequence, bool IsSegmented>
     struct result_of_fold;
 
     template <typename Sequence, typename State, typename Fun>
-    struct result_of_fold<Sequence, State, Fun, true>
+    struct result_of_fold<Sequence, State, Fun, true, true>
     {
         typedef
             typename result_of::segmented_fold_until<
@@ -52,8 +53,8 @@ namespace boost { namespace fusion { namespace detail
             >::type
         type;
 
-        BOOST_FUSION_GPU_ENABLED
-        static type call(State& state, Sequence& seq, Fun fun)
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static type call(Sequence& seq, State& state, Fun& fun)
         {
             return fusion::segmented_fold_until(seq, state, segmented_fold_fun<Fun>(fun));
         }

include/boost/fusion/algorithm/iteration/detail/segmented_for_each.hpp

@@ -18,12 +18,12 @@ namespace boost { namespace fusion { namespace detail
     template <typename Fun>
     struct segmented_for_each_fun
     {
-        BOOST_FUSION_GPU_ENABLED
-        explicit segmented_for_each_fun(Fun const& f)
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        explicit segmented_for_each_fun(Fun& f)
           : fun(f)
         {}
 
-        Fun const& fun;
+        Fun& fun;
 
         template <typename Sequence, typename State, typename Context>
         struct apply
@@ -31,7 +31,7 @@ namespace boost { namespace fusion { namespace detail
             typedef void_ type;
             typedef mpl::true_ continue_type;
 
-            BOOST_FUSION_GPU_ENABLED
+            BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
             static type call(Sequence& seq, State const&, Context const&, segmented_for_each_fun const& fun)
             {
                 fusion::for_each(seq, fun.fun);
@@ -41,9 +41,9 @@ namespace boost { namespace fusion { namespace detail
     };
 
     template <typename Sequence, typename F>
-    BOOST_FUSION_GPU_ENABLED
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
     inline void
-    for_each(Sequence& seq, F const& f, mpl::true_) // segmented implementation
+    for_each(Sequence& seq, F& f, mpl::true_) // segmented implementation
     {
         fusion::segmented_fold_until(seq, void_(), segmented_for_each_fun<F>(f));
     }

include/boost/fusion/algorithm/iteration/fold.hpp

@@ -2,6 +2,7 @@
     Copyright (c) 2001-2011 Joel de Guzman
     Copyright (c) 2007 Dan Marsden
     Copyright (c) 2009-2010 Christopher Schmidt
+    Copyright (c) 2015 Kohei Takahashi
 
     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)
@@ -10,24 +11,17 @@
 #define BOOST_FUSION_ALGORITHM_ITERATION_FOLD_HPP
 
 #include <boost/fusion/support/config.hpp>
-#include <boost/fusion/support/detail/result_of.hpp>
 #include <boost/fusion/algorithm/iteration/fold_fwd.hpp>
 #include <boost/config.hpp>
 #include <boost/fusion/sequence/intrinsic/begin.hpp>
-#include <boost/fusion/sequence/intrinsic/end.hpp>
-#include <boost/fusion/sequence/intrinsic/empty.hpp>
 #include <boost/fusion/sequence/intrinsic/size.hpp>
 #include <boost/fusion/support/is_segmented.hpp>
-#include <boost/fusion/iterator/equal_to.hpp>
+#include <boost/fusion/support/is_sequence.hpp>
 #include <boost/fusion/iterator/deref.hpp>
 #include <boost/fusion/iterator/value_of.hpp>
-#include <boost/fusion/iterator/prior.hpp>
 #include <boost/fusion/iterator/next.hpp>
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/mpl/bool.hpp>
 #include <boost/utility/result_of.hpp>
-#include <boost/type_traits/add_const.hpp>
+#include <boost/core/enable_if.hpp>
 #include <boost/type_traits/add_reference.hpp>
 
 #if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES)

include/boost/fusion/algorithm/iteration/fold_fwd.hpp

@@ -18,7 +18,7 @@ namespace boost { namespace fusion
 
     template<typename Seq, typename State, typename F>
     BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-    typename result_of::fold<
+    inline typename result_of::fold<
         Seq
       , State const
       , F
@@ -27,7 +27,7 @@ namespace boost { namespace fusion
 
     template<typename Seq, typename State, typename F>
     BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-    typename result_of::fold<
+    inline typename result_of::fold<
         Seq const
       , State const
       , F
@@ -36,18 +36,18 @@ namespace boost { namespace fusion
 
     template<typename Seq, typename State, typename F>
     BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-    typename result_of::fold<
+    inline typename result_of::fold<
         Seq
-      , State const
+      , State
       , F
     >::type
     fold(Seq& seq, State& state, F f);
 
     template<typename Seq, typename State, typename F>
     BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-    typename result_of::fold<
+    inline typename result_of::fold<
         Seq const
-      , State const
+      , State
       , F
     >::type
     fold(Seq const& seq, State& state, F f);

include/boost/fusion/algorithm/iteration/for_each.hpp

@@ -1,6 +1,7 @@
 /*=============================================================================
     Copyright (c) 2001-2007 Joel de Guzman
     Copyright (c) 2007 Dan Marsden
+    Copyright (c) 2018 Kohei Takahashi
 
     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)
@@ -13,7 +14,7 @@
 #include <boost/fusion/algorithm/iteration/detail/segmented_for_each.hpp>
 #include <boost/fusion/support/is_segmented.hpp>
 #include <boost/fusion/support/is_sequence.hpp>
-#include <boost/utility/enable_if.hpp>
+#include <boost/core/enable_if.hpp>
 
 namespace boost { namespace fusion
 {
@@ -27,27 +28,17 @@ namespace boost { namespace fusion
     }
 
     template <typename Sequence, typename F>
-    BOOST_FUSION_GPU_ENABLED
-    inline
-    typename
-        enable_if<
-            traits::is_sequence<Sequence>
-          , void
-        >::type
-    for_each(Sequence& seq, F const& f)
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename enable_if<traits::is_sequence<Sequence> >::type
+    for_each(Sequence& seq, F f)
     {
         detail::for_each(seq, f, typename traits::is_segmented<Sequence>::type());
     }
 
     template <typename Sequence, typename F>
-    BOOST_FUSION_GPU_ENABLED
-    inline
-    typename
-        enable_if<
-            traits::is_sequence<Sequence>
-          , void
-        >::type
-    for_each(Sequence const& seq, F const& f)
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename enable_if<traits::is_sequence<Sequence> >::type
+    for_each(Sequence const& seq, F f)
     {
         detail::for_each(seq, f, typename traits::is_segmented<Sequence>::type());
     }

include/boost/fusion/algorithm/iteration/for_each_fwd.hpp

@@ -1,5 +1,6 @@
 /*=============================================================================
     Copyright (c) 2011 Eric Niebler
+    Copyright (c) 2018 Kohei Takahashi
 
     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)
@@ -9,7 +10,7 @@
 
 #include <boost/fusion/support/config.hpp>
 #include <boost/fusion/support/is_sequence.hpp>
-#include <boost/utility/enable_if.hpp>
+#include <boost/core/enable_if.hpp>
 
 namespace boost { namespace fusion
 {
@@ -20,24 +21,14 @@ namespace boost { namespace fusion
     }
 
     template <typename Sequence, typename F>
-    BOOST_FUSION_GPU_ENABLED
-    inline
-    typename
-        enable_if<
-            traits::is_sequence<Sequence>
-          , void
-        >::type
-    for_each(Sequence& seq, F const& f);
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename enable_if<traits::is_sequence<Sequence> >::type
+    for_each(Sequence& seq, F f);
 
     template <typename Sequence, typename F>
-    BOOST_FUSION_GPU_ENABLED
-    inline
-    typename
-        enable_if<
-            traits::is_sequence<Sequence>
-          , void
-        >::type
-    for_each(Sequence const& seq, F const& f);
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename enable_if<traits::is_sequence<Sequence> >::type
+    for_each(Sequence const& seq, F f);
 }}
 
 #endif

include/boost/fusion/algorithm/iteration/iter_fold.hpp

@@ -1,6 +1,7 @@
 /*=============================================================================
     Copyright (c) 2010 Christopher Schmidt
     Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2015 Kohei Takahashi
 
     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)
@@ -13,20 +14,14 @@
 #include <boost/fusion/algorithm/iteration/iter_fold_fwd.hpp>
 #include <boost/config.hpp>
 #include <boost/fusion/sequence/intrinsic/begin.hpp>
-#include <boost/fusion/sequence/intrinsic/end.hpp>
-#include <boost/fusion/sequence/intrinsic/empty.hpp>
 #include <boost/fusion/sequence/intrinsic/size.hpp>
 #include <boost/fusion/support/is_segmented.hpp>
-#include <boost/fusion/support/detail/result_of.hpp>
-#include <boost/fusion/iterator/equal_to.hpp>
+#include <boost/fusion/support/is_sequence.hpp>
 #include <boost/fusion/iterator/deref.hpp>
 #include <boost/fusion/iterator/value_of.hpp>
-#include <boost/fusion/iterator/prior.hpp>
 #include <boost/fusion/iterator/next.hpp>
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/mpl/bool.hpp>
-#include <boost/type_traits/add_const.hpp>
+#include <boost/utility/result_of.hpp>
+#include <boost/core/enable_if.hpp>
 #include <boost/type_traits/add_reference.hpp>
 
 #define BOOST_FUSION_ITER_FOLD