Merge pull request #162 from boostorg/develop

Post beta merge

.travis.yml

@@ -0,0 +1,204 @@
+# Copyright 2016, 2017 Peter Dimov
+# Copyright 2017 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
+
+branches:
+  only:
+    - master
+    - develop
+
+env:
+  matrix:
+    - BOGUS_JOB=true
+
+matrix:
+
+  exclude:
+    - env: BOGUS_JOB=true
+
+  include:
+      # trusty default (gcc 4.8.4)
+    - os: linux
+      env: TOOLSET=gcc CXXSTD=03,11,1y
+
+    - os: linux
+      env: TOOLSET=gcc-4.7 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - g++-4.7
+
+    - os: linux
+      env: TOOLSET=gcc-4.8 CXXSTD=03,11,1y
+      addons:
+        apt:
+          packages:
+            - g++-4.8
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      env: TOOLSET=gcc-4.9 CXXSTD=03,11,1y
+      addons:
+        apt:
+          packages:
+            - g++-4.9
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      env: TOOLSET=gcc-5 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - g++-5
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      env: TOOLSET=gcc-6 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - g++-6
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      env: TOOLSET=gcc-7 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - g++-7
+          sources:
+            - ubuntu-toolchain-r-test
+
+      # trusty default (clang 3.9.0)
+    - os: linux
+      env: TOOLSET=clang CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - libstdc++-4.9-dev
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      env: TOOLSET=clang-3.5 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-3.5
+            - libstdc++-4.9-dev
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      env: TOOLSET=clang-3.6 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-3.6
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.6
+
+    - os: linux
+      env: TOOLSET=clang-3.7 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-3.7
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.7
+
+    - os: linux
+      env: TOOLSET=clang-3.8 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-3.8
+            - libstdc++-4.9-dev
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      env: TOOLSET=clang-3.9 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-3.9
+            - libstdc++-4.9-dev
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      env: TOOLSET=clang-4.0 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-4.0
+            - libstdc++-4.9-dev
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-4.0
+
+    - os: 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/conversion
+  - git submodule init libs/core
+  - git submodule init libs/detail
+  - git submodule init libs/function
+  - git submodule init libs/function_types
+  - git submodule init libs/functional
+  - git submodule init libs/integer
+  - git submodule init libs/iterator
+  - git submodule init libs/lambda
+  - git submodule init libs/move
+  - git submodule init libs/mpl
+  - git submodule init libs/optional
+  - git submodule init libs/predef
+  - git submodule init libs/preprocessor
+  - git submodule init libs/smart_ptr
+  - git submodule init libs/static_assert
+  - git submodule init libs/throw_exception
+  - git submodule init libs/tuple
+  - git submodule init libs/type_index
+  - git submodule init libs/type_traits
+  - git submodule init libs/typeof
+  - git submodule init libs/utility
+
+  - git submodule init tools/build
+  - git submodule update
+
+  - rm -rf libs/fusion
+  - mv $TRAVIS_BUILD_DIR libs/fusion
+  - ln -s $(pwd)/libs/fusion $TRAVIS_BUILD_DIR
+
+  - ./bootstrap.sh
+  - ./b2 headers
+
+script:
+  - ./b2 libs/fusion/test toolset=$TOOLSET cxxstd=$CXXSTD define=RUNNING_ON_TRAVIS=1

appveyor.yml

@@ -0,0 +1,74 @@
+# Copyright 2016, 2017 Peter Dimov
+# Copyright 2017 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
+
+branches:
+  only:
+    - master
+    - develop
+
+environment:
+  matrix:
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+      TOOLSET: msvc-9.0
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+      TOOLSET: msvc-10.0
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+      TOOLSET: msvc-11.0
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+      TOOLSET: msvc-12.0
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      TOOLSET: msvc-14.0
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      TOOLSET: msvc-14.1
+
+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/conversion
+  - git submodule init libs/core
+  - git submodule init libs/detail
+  - git submodule init libs/function
+  - git submodule init libs/function_types
+  - git submodule init libs/functional
+  - git submodule init libs/integer
+  - git submodule init libs/iterator
+  - git submodule init libs/lambda
+  - git submodule init libs/move
+  - git submodule init libs/mpl
+  - git submodule init libs/optional
+  - git submodule init libs/predef
+  - git submodule init libs/preprocessor
+  - git submodule init libs/smart_ptr
+  - git submodule init libs/static_assert
+  - git submodule init libs/throw_exception
+  - git submodule init libs/tuple
+  - git submodule init libs/type_index
+  - git submodule init libs/type_traits
+  - git submodule init libs/typeof
+  - git submodule init libs/utility
+
+  - git submodule init tools/build
+  - git submodule update
+  - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\fusion
+  - cmd /c bootstrap
+  - b2 headers
+
+build: off
+
+test_script:
+  - b2 libs/fusion/test toolset=%TOOLSET% define=RUNNING_ON_APPVEYOR=1

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

@@ -227,7 +227,7 @@ __random_access_sequence__.
         struct_name,
         (member_type0, member_name0)
         (member_type1, member_name1)
-        (BOOST_FUSION_ADAPT_AUTO, member_name2)
+        (auto, member_name2)
         ...
         )
 
@@ -240,7 +240,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
@@ -270,8 +270,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]
@@ -298,7 +298,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),
         ...
         )
 
@@ -316,7 +316,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
@@ -345,7 +345,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(
@@ -390,7 +390,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),
         ...
         )
 
@@ -400,7 +400,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),
         ...
         )
 
@@ -422,7 +422,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
@@ -453,8 +453,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]
 
@@ -481,7 +481,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
@@ -519,8 +519,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]
 
@@ -554,7 +554,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
@@ -641,7 +641,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
@@ -678,8 +678,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]
 
@@ -713,7 +713,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
@@ -823,7 +823,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
@@ -928,7 +928,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
@@ -1044,7 +1044,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]]
@@ -1722,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]]
@@ -1767,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
@@ -1886,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
@@ -1927,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

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>
 
@@ -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>
 
@@ -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
 
@@ -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
 
@@ -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
 
@@ -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
 

doc/extension.qbk

@@ -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]

doc/fusion.qbk

@@ -79,6 +79,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`]]
@@ -108,6 +109,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`]]
@@ -337,6 +339,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>
@@ -274,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

@@ -257,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]

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]
@@ -359,6 +364,55 @@ you can use `__result_of_value_at_key__<S, K>`.]
 
 [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]
@@ -686,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
 
@@ -739,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
 
@@ -833,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.
 
@@ -1149,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]
@@ -1191,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]
@@ -1350,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]
@@ -1388,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`.
 

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

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

@@ -15,7 +15,6 @@
 #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>
@@ -45,13 +44,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,7 +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/preprocessor/control/if.hpp>
 #include <boost/type_traits/add_reference.hpp>
 #include <boost/type_traits/is_const.hpp>
 #include <boost/type_traits/remove_const.hpp>
@@ -46,13 +46,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,8 +15,10 @@
 #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>
@@ -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,57 @@
     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_PP_EXPR_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,) \
+          BOOST_PP_EXPR_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_PP_EXPR_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,) \
+          BOOST_PP_EXPR_IF(BOOST_FUSION_ADAPT_IS_TPL(TEMPLATE_PARAMS_SEQ),      \
+                           typename) \
           deduced_attr_type::type                                               \
     >::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,7 +123,7 @@
             BOOST_FUSION_ADT_ATTRIBUTE_GIVENTYPE)(                              \
                 NAME_SEQ,                                                       \
                 ATTRIBUTE,                                                      \
-                ATTRIBUTE_TUPEL_SIZE,                                           \
+                ATTRIBUTE_TUPLE_SIZE,                                           \
                 PREFIX,                                                         \
                 TEMPLATE_PARAMS_SEQ)                                            \
                                                                                 \
@@ -128,7 +135,7 @@
             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 +144,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 +153,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,7 +167,7 @@
     >                                                                           \
     {                                                                           \
         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                                                               \
@@ -201,7 +208,7 @@
     >                                                                           \
     {                                                                           \
         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                                                               \
@@ -252,7 +259,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                                                     \

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/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,109 @@
+/*=============================================================================
+    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();
+            }
+        };
+
+    private:
+
+        std_array_iterator<Array, Pos>& operator=(std_array_iterator<Array, Pos> 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/build_std_tuple.hpp

@@ -7,26 +7,26 @@
 #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_CONSTEXPR BOOST_FUSION_GPU_ENABLED
         static type
         call(First const&, Last const&)
@@ -35,35 +35,18 @@ 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>
+        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)...);
         }
@@ -72,7 +55,7 @@ namespace boost { namespace fusion { namespace detail
         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());
         }
     };

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

@@ -13,7 +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/preprocessor/control/iif.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>
@@ -44,11 +45,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,9 +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/preprocessor/seq/seq.hpp>
+#include <boost/preprocessor/variadic/to_seq.hpp>
 #include <boost/type_traits/add_reference.hpp>
 #include <boost/type_traits/is_const.hpp>
 #include <boost/type_traits/add_const.hpp>
@@ -43,13 +44,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 +60,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,6 +29,7 @@
 #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>
@@ -64,7 +65,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 +74,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 +85,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 +101,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 +160,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 +175,7 @@
             BOOST_FUSION_ATTRIBUTE_TYPEOF, BOOST_FUSION_ATTRIBUTE_GIVENTYPE)(   \
                 NAME_SEQ,                                                       \
                 ATTRIBUTE,                                                      \
-                ATTRIBUTE_TUPEL_SIZE,                                           \
+                ATTRIBUTE_TUPLE_SIZE,                                           \
                 PREFIX,                                                         \
                 TEMPLATE_PARAMS_SEQ)                                            \
                                                                                 \
@@ -201,8 +202,8 @@
             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);                  \
             }                                                                   \
         };                                                                      \
     };                                                                          \
@@ -222,9 +223,8 @@
         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 +274,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/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,14 +111,14 @@
                 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_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED                              \
+    BOOST_FUSION_GPU_ENABLED                                                    \
     self_type&                                                                  \
     operator=(Seq const& seq)                                                   \
     {                                                                           \
@@ -81,125 +130,200 @@
         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_CONSTEXPR BOOST_FUSION_GPU_ENABLED                                    \
+    BOOST_FUSION_GPU_ENABLED                                                    \
     NAME()                                                                      \
       : 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_CONSTEXPR 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_CONSTEXPR BOOST_FUSION_GPU_ENABLED                                    \
+    BOOST_FUSION_GPU_ENABLED                                                    \
     NAME(Seq const& seq                                                         \
         BOOST_PP_IF(                                                            \
             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_CONSTEXPR BOOST_FUSION_GPU_ENABLED                                \
+        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_CONSTEXPR BOOST_FUSION_GPU_ENABLED                                \
+        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_CONSTEXPR BOOST_FUSION_GPU_ENABLED                                \
+        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_CONSTEXPR 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_CONSTEXPR BOOST_FUSION_GPU_ENABLED                                \
-        NAME(Seq const&)                                                        \
-        {}                                                                      \
-                                                                                \
-        template<typename Seq>                                                  \
-        BOOST_CXX14_CONSTEXPR 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,11 +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_CONSTEXPR BOOST_FUSION_GPU_ENABLED                                    \
+    BOOST_FUSION_GPU_ENABLED                                                    \
     NAME(BOOST_PP_SEQ_FOR_EACH_I(                                               \
             BOOST_FUSION_MAKE_CONST_REF_PARAM,                                  \
             ~,                                                                  \
@@ -337,7 +336,7 @@
         typedef boost::mpl::int_<N> index;                                      \
         typedef boost_fusion_detail_Seq sequence_type;                          \
                                                                                 \
-        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED                                \
+        BOOST_FUSION_GPU_ENABLED                                                \
         BOOST_FUSION_ITERATOR_NAME(NAME)(boost_fusion_detail_Seq& seq)          \
             : seq_(seq)                                                         \
               BOOST_FUSION_DEFINE_ITERATOR_WKND_INIT_LIST_ENTRIES(              \
@@ -425,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)                                     \
     {                                                                           \
     }                                                                           \
                                                                                 \

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/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
 {
@@ -27,11 +26,7 @@ namespace boost { namespace fusion
 
     template <typename Sequence, typename State, typename F>
     BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-    inline typename
-        lazy_enable_if<
-            traits::is_sequence<Sequence>
-          , result_of::accumulate<Sequence, State const, F>
-        >::type
+    inline typename result_of::accumulate<Sequence, State const, F>::type
     accumulate(Sequence& seq, State const& state, F f)
     {
         return fusion::fold(seq, state, f);
@@ -39,11 +34,7 @@ namespace boost { namespace fusion
 
     template <typename Sequence, typename State, typename F>
     BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-    inline typename
-        lazy_enable_if<
-            traits::is_sequence<Sequence>
-          , result_of::accumulate<Sequence const, State const, F>
-        >::type
+    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
 {
@@ -21,20 +20,12 @@ namespace boost { namespace fusion
 
     template <typename Sequence, typename State, typename F>
     BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-    inline typename
-        lazy_enable_if<
-            traits::is_sequence<Sequence>
-          , result_of::accumulate<Sequence, State const, F>
-        >::type
+    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_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-    inline typename
-        lazy_enable_if<
-            traits::is_sequence<Sequence>
-          , result_of::accumulate<Sequence const, State const, F>
-        >::type
+    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/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,6 +10,7 @@
 #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
 {
@@ -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<
@@ -53,7 +54,7 @@ namespace boost { namespace fusion { namespace detail
         type;
 
         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-        static type call(State& state, Sequence& seq, Fun fun)
+        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/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

@@ -38,7 +38,7 @@ namespace boost { namespace fusion
     BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
     inline typename result_of::fold<
         Seq
-      , State const
+      , State
       , F
     >::type
     fold(Seq& seq, State& state, F f);
@@ -47,7 +47,7 @@ namespace boost { namespace fusion
     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);

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

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

@@ -38,7 +38,7 @@ namespace boost { namespace fusion
     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);
@@ -47,7 +47,7 @@ namespace boost { namespace fusion
     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);

include/boost/fusion/algorithm/iteration/reverse_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)
@@ -12,21 +13,15 @@
 #include <boost/fusion/support/config.hpp>
 #include <boost/fusion/algorithm/iteration/reverse_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>
 
 #define BOOST_FUSION_REVERSE_FOLD

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

@@ -38,7 +38,7 @@ namespace boost { namespace fusion
     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);
@@ -47,7 +47,7 @@ namespace boost { namespace fusion
     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);

include/boost/fusion/algorithm/iteration/reverse_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)
@@ -11,21 +12,15 @@
 #include <boost/fusion/support/config.hpp>
 #include <boost/fusion/algorithm/iteration/reverse_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/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>
 
 #define BOOST_FUSION_REVERSE_FOLD

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

@@ -38,7 +38,7 @@ namespace boost { namespace fusion
     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);
@@ -47,7 +47,7 @@ namespace boost { namespace fusion
     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);

include/boost/fusion/algorithm/transformation/erase.hpp

@@ -10,7 +10,6 @@
 #include <boost/fusion/support/config.hpp>
 #include <boost/fusion/iterator/equal_to.hpp>
 #include <boost/fusion/iterator/mpl/convert_iterator.hpp>
-#include <boost/fusion/container/vector/vector10.hpp>
 #include <boost/fusion/view/joint_view/joint_view.hpp>
 #include <boost/fusion/view/iterator_range/iterator_range.hpp>
 #include <boost/fusion/support/detail/as_fusion_element.hpp>

include/boost/fusion/algorithm/transformation/flatten.hpp

@@ -1,9 +1,9 @@
-/*//////////////////////////////////////////////////////////////////////////////
+/*==============================================================================
     Copyright (c) 2013 Jamboree
 
     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)
-//////////////////////////////////////////////////////////////////////////////*/
+==============================================================================*/
 #ifndef BOOST_FUSION_ALGORITHM_FLATTEN_HPP_INCLUDED
 #define BOOST_FUSION_ALGORITHM_FLATTEN_HPP_INCLUDED
 

include/boost/fusion/algorithm/transformation/insert.hpp

@@ -10,7 +10,6 @@
 #include <boost/fusion/support/config.hpp>
 #include <boost/fusion/support/detail/as_fusion_element.hpp>
 #include <boost/fusion/iterator/mpl/convert_iterator.hpp>
-#include <boost/fusion/container/vector/vector10.hpp>
 #include <boost/fusion/view/joint_view/joint_view.hpp>
 #include <boost/fusion/view/single_view/single_view.hpp>
 #include <boost/fusion/view/iterator_range/iterator_range.hpp>

include/boost/fusion/algorithm/transformation/insert_range.hpp

@@ -9,7 +9,6 @@
 
 #include <boost/fusion/support/config.hpp>
 #include <boost/fusion/iterator/mpl/convert_iterator.hpp>
-#include <boost/fusion/container/vector/vector10.hpp>
 #include <boost/fusion/view/joint_view/joint_view.hpp>
 #include <boost/fusion/view/iterator_range/iterator_range.hpp>
 #include <boost/fusion/support/detail/as_fusion_element.hpp>

include/boost/fusion/algorithm/transformation/zip.hpp

@@ -17,6 +17,7 @@
 #include <boost/type_traits/add_reference.hpp>
 #include <boost/preprocessor/repetition/enum.hpp>
 #include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
 #include <boost/preprocessor/repetition/enum_binary_params.hpp>
 #include <boost/preprocessor/repetition/repeat_from_to.hpp>
 #include <boost/preprocessor/arithmetic/inc.hpp>

include/boost/fusion/container/deque/deque.hpp

@@ -21,6 +21,8 @@
 // C++11 interface
 ///////////////////////////////////////////////////////////////////////////////
 #include <boost/fusion/support/sequence_base.hpp>
+#include <boost/fusion/support/void.hpp>
+#include <boost/fusion/support/detail/enabler.hpp>
 #include <boost/fusion/support/detail/access.hpp>
 #include <boost/fusion/support/is_sequence.hpp>
 #include <boost/fusion/container/deque/detail/keyed_element.hpp>
@@ -59,7 +61,7 @@ namespace boost { namespace fusion
             typename enable_if<
                 mpl::and_<
                     traits::is_sequence<Sequence>
-                  , result_of::empty<Sequence>>>::type* /*dummy*/ = 0) BOOST_NOEXCEPT
+                  , result_of::empty<Sequence>>, detail::enabler_>::type = detail::enabler) BOOST_NOEXCEPT
         {}
 
         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
@@ -149,7 +151,8 @@ namespace boost { namespace fusion
         template <typename Sequence>
         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
         explicit deque(Sequence const& seq
-          , typename disable_if<is_convertible<Sequence, Head> >::type* /*dummy*/ = 0)
+          , typename disable_if<is_convertible<Sequence, Head>, detail::enabler_>::type = detail::enabler
+          , typename enable_if<traits::is_sequence<Sequence>, detail::enabler_>::type = detail::enabler)
           : base(base::from_iterator(fusion::begin(seq)))
         {}
 

include/boost/fusion/container/deque/deque_fwd.hpp

@@ -23,8 +23,7 @@
 # endif
 #endif
 
-// MSVC variadics at this point in time is not ready yet (ICE!)
-#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1900))
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1910)
 # if defined(BOOST_FUSION_HAS_VARIADIC_DEQUE)
 #   undef BOOST_FUSION_HAS_VARIADIC_DEQUE
 # endif

include/boost/fusion/container/deque/detail/convert_impl.hpp

@@ -1,6 +1,7 @@
 /*=============================================================================
     Copyright (c) 2005-2012 Joel de Guzman
     Copyright (c) 2005-2006 Dan Marsden
+    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)
@@ -12,7 +13,7 @@
 #include <boost/fusion/container/deque/convert.hpp>
 #include <boost/fusion/container/deque/deque.hpp>
 #include <boost/fusion/sequence/intrinsic/begin.hpp>
-#include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
 
 namespace boost { namespace fusion
 {
@@ -41,7 +42,11 @@ namespace boost { namespace fusion
                 BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
                 static type call(Sequence& seq)
                 {
-                    return gen::call(seq);
+                    return gen::call(fusion::begin(seq)
+#if defined(BOOST_FUSION_HAS_VARIADIC_DEQUE)
+                        , fusion::end(seq)
+#endif
+                    );
                 }
             };
         };

include/boost/fusion/container/deque/detail/cpp03/build_deque.hpp

@@ -22,6 +22,7 @@ namespace boost { namespace fusion
     {
         template <typename Sequence>
         struct as_deque
+            : detail::as_deque<result_of::size<Sequence>::value>
         {
             typedef typename
                 detail::as_deque<result_of::size<Sequence>::value>

include/boost/fusion/container/deque/detail/cpp03/deque.hpp

@@ -24,6 +24,8 @@
 #include <boost/preprocessor/repetition/enum_binary_params.hpp>
 #include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
 #include <boost/type_traits/is_convertible.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_reference.hpp>
 
 #include <boost/fusion/container/deque/deque_fwd.hpp>
 #include <boost/fusion/container/deque/detail/value_at_impl.hpp>
@@ -35,6 +37,7 @@
 #include <boost/mpl/bool.hpp>
 
 #include <boost/fusion/support/void.hpp>
+#include <boost/fusion/support/detail/enabler.hpp>
 #include <boost/utility/enable_if.hpp>
 
 #if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES)
@@ -94,26 +97,19 @@ namespace boost { namespace fusion {
             {}
 
         template<BOOST_PP_ENUM_PARAMS(FUSION_MAX_DEQUE_SIZE, typename U)>
-        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        BOOST_FUSION_GPU_ENABLED
         deque(deque<BOOST_PP_ENUM_PARAMS(FUSION_MAX_DEQUE_SIZE, U)> const& seq)
             : base(seq)
             {}
 
         template<typename Sequence>
-        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-        deque(Sequence const& seq, typename disable_if<is_convertible<Sequence, T0> >::type* /*dummy*/ = 0)
+        BOOST_FUSION_GPU_ENABLED
+        deque(Sequence const& seq
+            , typename disable_if<is_convertible<Sequence, T0>, detail::enabler_>::type = detail::enabler
+            , typename enable_if<traits::is_sequence<Sequence>, detail::enabler_>::type = detail::enabler)
             : base(base::from_iterator(fusion::begin(seq)))
             {}
 
-        template <BOOST_PP_ENUM_PARAMS(FUSION_MAX_DEQUE_SIZE, typename U)>
-        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-        deque&
-        operator=(deque<BOOST_PP_ENUM_PARAMS(FUSION_MAX_DEQUE_SIZE, U)> const& rhs)
-        {
-            base::operator=(rhs);
-            return *this;
-        }
-
         template <typename T>
         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
         deque&
@@ -129,9 +125,13 @@ FUSION_HASH if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) || \
     (defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES))
         template <typename T0_>
-        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        BOOST_FUSION_GPU_ENABLED
         explicit deque(T0_&& t0
-          , typename enable_if<is_convertible<T0_, T0> >::type* /*dummy*/ = 0
+          , typename enable_if<is_convertible<T0_, T0>, detail::enabler_>::type = detail::enabler
+          , typename disable_if_c<
+                boost::is_same<deque const, typename boost::remove_reference<T0_>::type const>::value
+              , detail::enabler_
+            >::type = detail::enabler
          )
             : base(BOOST_FUSION_FWD_ELEM(T0_, t0), detail::nil_keyed_element())
             {}
@@ -140,11 +140,12 @@ FUSION_HASH if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
             : base(std::forward<deque>(rhs))
             {}
         template<BOOST_PP_ENUM_PARAMS(FUSION_MAX_DEQUE_SIZE, typename U)>
-        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        BOOST_FUSION_GPU_ENABLED
         deque(deque<BOOST_PP_ENUM_PARAMS(FUSION_MAX_DEQUE_SIZE, U)>&& seq
             , typename disable_if<
                   is_convertible<deque<BOOST_PP_ENUM_PARAMS(FUSION_MAX_DEQUE_SIZE, U)>, T0>
-              >::type* /*dummy*/ = 0)
+                , detail::enabler_
+              >::type = detail::enabler)
             : base(std::forward<deque<BOOST_PP_ENUM_PARAMS(FUSION_MAX_DEQUE_SIZE, U)>>(seq))
             {}
         template <typename T>
@@ -155,6 +156,14 @@ FUSION_HASH if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
             base::operator=(BOOST_FUSION_FWD_ELEM(T, rhs));
             return *this;
         }
+        // This copy op= is required because move ctor deletes copy op=.
+        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        deque&
+        operator=(deque const& rhs)
+        {
+            base::operator=(static_cast<base const&>(rhs));
+            return *this;
+        }
 #endif
 #if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
 FUSION_HASH endif
@@ -178,7 +187,7 @@ FUSION_HASH endif
             typename enable_if<
                 mpl::and_<
                     traits::is_sequence<Sequence>
-                  , result_of::empty<Sequence> > >::type* /*dummy*/ = 0) BOOST_NOEXCEPT
+                  , result_of::empty<Sequence> >, detail::enabler_>::type = detail::enabler) BOOST_NOEXCEPT
         {}
 
         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED

include/boost/fusion/container/deque/detail/cpp03/deque_keyed_values.hpp

@@ -24,7 +24,6 @@
 
 #include <boost/mpl/plus.hpp>
 #include <boost/mpl/int.hpp>
-#include <boost/mpl/print.hpp>
 
 #define FUSION_VOID(z, n, _) void_
 

include/boost/fusion/container/deque/detail/cpp03/limits.hpp

@@ -12,7 +12,7 @@
 #error "C++03 only! This file should not have been included"
 #endif
 
-#include <boost/fusion/container/vector/limits.hpp>
+#include <boost/fusion/container/vector/detail/cpp03/limits.hpp>
 
 #if !defined(FUSION_MAX_DEQUE_SIZE)
 # define FUSION_MAX_DEQUE_SIZE FUSION_MAX_VECTOR_SIZE

include/boost/fusion/container/deque/detail/cpp03/preprocessed/deque10.hpp

@@ -195,23 +195,17 @@ deque(T_0 && t0 , T_1 && t1 , T_2 && t2 , T_3 && t3 , T_4 && t4 , T_5 && t5 , T_
             : base(rhs)
             {}
         template<typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8 , typename U9>
-        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        BOOST_FUSION_GPU_ENABLED
         deque(deque<U0 , U1 , U2 , U3 , U4 , U5 , U6 , U7 , U8 , U9> const& seq)
             : base(seq)
             {}
         template<typename Sequence>
-        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-        deque(Sequence const& seq, typename disable_if<is_convertible<Sequence, T0> >::type* = 0)
+        BOOST_FUSION_GPU_ENABLED
+        deque(Sequence const& seq
+            , typename disable_if<is_convertible<Sequence, T0>, detail::enabler_>::type = detail::enabler
+            , typename enable_if<traits::is_sequence<Sequence>, detail::enabler_>::type = detail::enabler)
             : base(base::from_iterator(fusion::begin(seq)))
             {}
-        template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8 , typename U9>
-        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-        deque&
-        operator=(deque<U0 , U1 , U2 , U3 , U4 , U5 , U6 , U7 , U8 , U9> const& rhs)
-        {
-            base::operator=(rhs);
-            return *this;
-        }
         template <typename T>
         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
         deque&
@@ -222,9 +216,13 @@ deque(T_0 && t0 , T_1 && t1 , T_2 && t2 , T_3 && t3 , T_4 && t4 , T_5 && t5 , T_
         }
 # if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
         template <typename T0_>
-        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        BOOST_FUSION_GPU_ENABLED
         explicit deque(T0_&& t0
-          , typename enable_if<is_convertible<T0_, T0> >::type* = 0
+          , typename enable_if<is_convertible<T0_, T0>, detail::enabler_>::type = detail::enabler
+          , typename disable_if_c<
+                boost::is_same<deque const, typename boost::remove_reference<T0_>::type const>::value
+              , detail::enabler_
+            >::type = detail::enabler
          )
             : base(std::forward<T0_>( t0), detail::nil_keyed_element())
             {}
@@ -233,11 +231,12 @@ deque(T_0 && t0 , T_1 && t1 , T_2 && t2 , T_3 && t3 , T_4 && t4 , T_5 && t5 , T_
             : base(std::forward<deque>(rhs))
             {}
         template<typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8 , typename U9>
-        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        BOOST_FUSION_GPU_ENABLED
         deque(deque<U0 , U1 , U2 , U3 , U4 , U5 , U6 , U7 , U8 , U9>&& seq
             , typename disable_if<
                   is_convertible<deque<U0 , U1 , U2 , U3 , U4 , U5 , U6 , U7 , U8 , U9>, T0>
-              >::type* = 0)
+                , detail::enabler_
+              >::type = detail::enabler)
             : base(std::forward<deque<U0 , U1 , U2 , U3 , U4 , U5 , U6 , U7 , U8 , U9>>(seq))
             {}
         template <typename T>
@@ -248,6 +247,14 @@ deque(T_0 && t0 , T_1 && t1 , T_2 && t2 , T_3 && t3 , T_4 && t4 , T_5 && t5 , T_
             base::operator=(std::forward<T>( rhs));
             return *this;
         }
+        
+        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        deque&
+        operator=(deque const& rhs)
+        {
+            base::operator=(static_cast<base const&>(rhs));
+            return *this;
+        }
 # endif
     };
     template <>
@@ -265,7 +272,7 @@ deque(T_0 && t0 , T_1 && t1 , T_2 && t2 , T_3 && t3 , T_4 && t4 , T_5 && t5 , T_
             typename enable_if<
                 mpl::and_<
                     traits::is_sequence<Sequence>
-                  , result_of::empty<Sequence> > >::type* = 0) BOOST_NOEXCEPT
+                  , result_of::empty<Sequence> >, detail::enabler_>::type = detail::enabler) BOOST_NOEXCEPT
         {}
         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
         deque() BOOST_NOEXCEPT {}

include/boost/fusion/container/deque/detail/cpp03/preprocessed/deque20.hpp

@@ -375,23 +375,17 @@ deque(T_0 && t0 , T_1 && t1 , T_2 && t2 , T_3 && t3 , T_4 && t4 , T_5 && t5 , T_
             : base(rhs)
             {}
         template<typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8 , typename U9 , typename U10 , typename U11 , typename U12 , typename U13 , typename U14 , typename U15 , typename U16 , typename U17 , typename U18 , typename U19>
-        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        BOOST_FUSION_GPU_ENABLED
         deque(deque<U0 , U1 , U2 , U3 , U4 , U5 , U6 , U7 , U8 , U9 , U10 , U11 , U12 , U13 , U14 , U15 , U16 , U17 , U18 , U19> const& seq)
             : base(seq)
             {}
         template<typename Sequence>
-        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-        deque(Sequence const& seq, typename disable_if<is_convertible<Sequence, T0> >::type* = 0)
+        BOOST_FUSION_GPU_ENABLED
+        deque(Sequence const& seq
+            , typename disable_if<is_convertible<Sequence, T0>, detail::enabler_>::type = detail::enabler
+            , typename enable_if<traits::is_sequence<Sequence>, detail::enabler_>::type = detail::enabler)
             : base(base::from_iterator(fusion::begin(seq)))
             {}
-        template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8 , typename U9 , typename U10 , typename U11 , typename U12 , typename U13 , typename U14 , typename U15 , typename U16 , typename U17 , typename U18 , typename U19>
-        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-        deque&
-        operator=(deque<U0 , U1 , U2 , U3 , U4 , U5 , U6 , U7 , U8 , U9 , U10 , U11 , U12 , U13 , U14 , U15 , U16 , U17 , U18 , U19> const& rhs)
-        {
-            base::operator=(rhs);
-            return *this;
-        }
         template <typename T>
         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
         deque&
@@ -402,9 +396,13 @@ deque(T_0 && t0 , T_1 && t1 , T_2 && t2 , T_3 && t3 , T_4 && t4 , T_5 && t5 , T_
         }
 # if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
         template <typename T0_>
-        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        BOOST_FUSION_GPU_ENABLED
         explicit deque(T0_&& t0
-          , typename enable_if<is_convertible<T0_, T0> >::type* = 0
+          , typename enable_if<is_convertible<T0_, T0>, detail::enabler_>::type = detail::enabler
+          , typename disable_if_c<
+                boost::is_same<deque const, typename boost::remove_reference<T0_>::type const>::value
+              , detail::enabler_
+            >::type = detail::enabler
          )
             : base(std::forward<T0_>( t0), detail::nil_keyed_element())
             {}
@@ -413,11 +411,12 @@ deque(T_0 && t0 , T_1 && t1 , T_2 && t2 , T_3 && t3 , T_4 && t4 , T_5 && t5 , T_
             : base(std::forward<deque>(rhs))
             {}
         template<typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8 , typename U9 , typename U10 , typename U11 , typename U12 , typename U13 , typename U14 , typename U15 , typename U16 , typename U17 , typename U18 , typename U19>
-        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        BOOST_FUSION_GPU_ENABLED
         deque(deque<U0 , U1 , U2 , U3 , U4 , U5 , U6 , U7 , U8 , U9 , U10 , U11 , U12 , U13 , U14 , U15 , U16 , U17 , U18 , U19>&& seq
             , typename disable_if<
                   is_convertible<deque<U0 , U1 , U2 , U3 , U4 , U5 , U6 , U7 , U8 , U9 , U10 , U11 , U12 , U13 , U14 , U15 , U16 , U17 , U18 , U19>, T0>
-              >::type* = 0)
+                , detail::enabler_
+              >::type = detail::enabler)
             : base(std::forward<deque<U0 , U1 , U2 , U3 , U4 , U5 , U6 , U7 , U8 , U9 , U10 , U11 , U12 , U13 , U14 , U15 , U16 , U17 , U18 , U19>>(seq))
             {}
         template <typename T>
@@ -428,6 +427,14 @@ deque(T_0 && t0 , T_1 && t1 , T_2 && t2 , T_3 && t3 , T_4 && t4 , T_5 && t5 , T_
             base::operator=(std::forward<T>( rhs));
             return *this;
         }
+        
+        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        deque&
+        operator=(deque const& rhs)
+        {
+            base::operator=(static_cast<base const&>(rhs));
+            return *this;
+        }
 # endif
     };
     template <>
@@ -445,7 +452,7 @@ deque(T_0 && t0 , T_1 && t1 , T_2 && t2 , T_3 && t3 , T_4 && t4 , T_5 && t5 , T_
             typename enable_if<
                 mpl::and_<
                     traits::is_sequence<Sequence>
-                  , result_of::empty<Sequence> > >::type* = 0) BOOST_NOEXCEPT
+                  , result_of::empty<Sequence> >, detail::enabler_>::type = detail::enabler) BOOST_NOEXCEPT
         {}
         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
         deque() BOOST_NOEXCEPT {}

include/boost/fusion/container/deque/detail/cpp03/preprocessed/deque30.hpp

@@ -555,23 +555,17 @@ deque(T_0 && t0 , T_1 && t1 , T_2 && t2 , T_3 && t3 , T_4 && t4 , T_5 && t5 , T_
             : base(rhs)
             {}
         template<typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8 , typename U9 , typename U10 , typename U11 , typename U12 , typename U13 , typename U14 , typename U15 , typename U16 , typename U17 , typename U18 , typename U19 , typename U20 , typename U21 , typename U22 , typename U23 , typename U24 , typename U25 , typename U26 , typename U27 , typename U28 , typename U29>
-        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        BOOST_FUSION_GPU_ENABLED
         deque(deque<U0 , U1 , U2 , U3 , U4 , U5 , U6 , U7 , U8 , U9 , U10 , U11 , U12 , U13 , U14 , U15 , U16 , U17 , U18 , U19 , U20 , U21 , U22 , U23 , U24 , U25 , U26 , U27 , U28 , U29> const& seq)
             : base(seq)
             {}
         template<typename Sequence>
-        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-        deque(Sequence const& seq, typename disable_if<is_convertible<Sequence, T0> >::type* = 0)
+        BOOST_FUSION_GPU_ENABLED
+        deque(Sequence const& seq
+            , typename disable_if<is_convertible<Sequence, T0>, detail::enabler_>::type = detail::enabler
+            , typename enable_if<traits::is_sequence<Sequence>, detail::enabler_>::type = detail::enabler)
             : base(base::from_iterator(fusion::begin(seq)))
             {}
-        template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8 , typename U9 , typename U10 , typename U11 , typename U12 , typename U13 , typename U14 , typename U15 , typename U16 , typename U17 , typename U18 , typename U19 , typename U20 , typename U21 , typename U22 , typename U23 , typename U24 , typename U25 , typename U26 , typename U27 , typename U28 , typename U29>
-        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-        deque&
-        operator=(deque<U0 , U1 , U2 , U3 , U4 , U5 , U6 , U7 , U8 , U9 , U10 , U11 , U12 , U13 , U14 , U15 , U16 , U17 , U18 , U19 , U20 , U21 , U22 , U23 , U24 , U25 , U26 , U27 , U28 , U29> const& rhs)
-        {
-            base::operator=(rhs);
-            return *this;
-        }
         template <typename T>
         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
         deque&
@@ -582,9 +576,13 @@ deque(T_0 && t0 , T_1 && t1 , T_2 && t2 , T_3 && t3 , T_4 && t4 , T_5 && t5 , T_
         }
 # if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
         template <typename T0_>
-        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        BOOST_FUSION_GPU_ENABLED
         explicit deque(T0_&& t0
-          , typename enable_if<is_convertible<T0_, T0> >::type* = 0
+          , typename enable_if<is_convertible<T0_, T0>, detail::enabler_>::type = detail::enabler
+          , typename disable_if_c<
+                boost::is_same<deque const, typename boost::remove_reference<T0_>::type const>::value
+              , detail::enabler_
+            >::type = detail::enabler
          )
             : base(std::forward<T0_>( t0), detail::nil_keyed_element())
             {}
@@ -593,11 +591,12 @@ deque(T_0 && t0 , T_1 && t1 , T_2 && t2 , T_3 && t3 , T_4 && t4 , T_5 && t5 , T_
             : base(std::forward<deque>(rhs))
             {}
         template<typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8 , typename U9 , typename U10 , typename U11 , typename U12 , typename U13 , typename U14 , typename U15 , typename U16 , typename U17 , typename U18 , typename U19 , typename U20 , typename U21 , typename U22 , typename U23 , typename U24 , typename U25 , typename U26 , typename U27 , typename U28 , typename U29>
-        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        BOOST_FUSION_GPU_ENABLED
         deque(deque<U0 , U1 , U2 , U3 , U4 , U5 , U6 , U7 , U8 , U9 , U10 , U11 , U12 , U13 , U14 , U15 , U16 , U17 , U18 , U19 , U20 , U21 , U22 , U23 , U24 , U25 , U26 , U27 , U28 , U29>&& seq
             , typename disable_if<
                   is_convertible<deque<U0 , U1 , U2 , U3 , U4 , U5 , U6 , U7 , U8 , U9 , U10 , U11 , U12 , U13 , U14 , U15 , U16 , U17 , U18 , U19 , U20 , U21 , U22 , U23 , U24 , U25 , U26 , U27 , U28 , U29>, T0>
-              >::type* = 0)
+                , detail::enabler_
+              >::type = detail::enabler)
             : base(std::forward<deque<U0 , U1 , U2 , U3 , U4 , U5 , U6 , U7 , U8 , U9 , U10 , U11 , U12 , U13 , U14 , U15 , U16 , U17 , U18 , U19 , U20 , U21 , U22 , U23 , U24 , U25 , U26 , U27 , U28 , U29>>(seq))
             {}
         template <typename T>
@@ -608,6 +607,14 @@ deque(T_0 && t0 , T_1 && t1 , T_2 && t2 , T_3 && t3 , T_4 && t4 , T_5 && t5 , T_
             base::operator=(std::forward<T>( rhs));
             return *this;
         }
+        
+        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        deque&
+        operator=(deque const& rhs)
+        {
+            base::operator=(static_cast<base const&>(rhs));
+            return *this;
+        }
 # endif
     };
     template <>
@@ -625,7 +632,7 @@ deque(T_0 && t0 , T_1 && t1 , T_2 && t2 , T_3 && t3 , T_4 && t4 , T_5 && t5 , T_
             typename enable_if<
                 mpl::and_<
                     traits::is_sequence<Sequence>
-                  , result_of::empty<Sequence> > >::type* = 0) BOOST_NOEXCEPT
+                  , result_of::empty<Sequence> >, detail::enabler_>::type = detail::enabler) BOOST_NOEXCEPT
         {}
         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
         deque() BOOST_NOEXCEPT {}

include/boost/fusion/container/deque/detail/cpp03/preprocessed/deque40.hpp

@@ -735,23 +735,17 @@ deque(T_0 && t0 , T_1 && t1 , T_2 && t2 , T_3 && t3 , T_4 && t4 , T_5 && t5 , T_
             : base(rhs)
             {}
         template<typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8 , typename U9 , typename U10 , typename U11 , typename U12 , typename U13 , typename U14 , typename U15 , typename U16 , typename U17 , typename U18 , typename U19 , typename U20 , typename U21 , typename U22 , typename U23 , typename U24 , typename U25 , typename U26 , typename U27 , typename U28 , typename U29 , typename U30 , typename U31 , typename U32 , typename U33 , typename U34 , typename U35 , typename U36 , typename U37 , typename U38 , typename U39>
-        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        BOOST_FUSION_GPU_ENABLED
         deque(deque<U0 , U1 , U2 , U3 , U4 , U5 , U6 , U7 , U8 , U9 , U10 , U11 , U12 , U13 , U14 , U15 , U16 , U17 , U18 , U19 , U20 , U21 , U22 , U23 , U24 , U25 , U26 , U27 , U28 , U29 , U30 , U31 , U32 , U33 , U34 , U35 , U36 , U37 , U38 , U39> const& seq)
             : base(seq)
             {}
         template<typename Sequence>
-        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-        deque(Sequence const& seq, typename disable_if<is_convertible<Sequence, T0> >::type* = 0)
+        BOOST_FUSION_GPU_ENABLED
+        deque(Sequence const& seq
+            , typename disable_if<is_convertible<Sequence, T0>, detail::enabler_>::type = detail::enabler
+            , typename enable_if<traits::is_sequence<Sequence>, detail::enabler_>::type = detail::enabler)
             : base(base::from_iterator(fusion::begin(seq)))
             {}
-        template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8 , typename U9 , typename U10 , typename U11 , typename U12 , typename U13 , typename U14 , typename U15 , typename U16 , typename U17 , typename U18 , typename U19 , typename U20 , typename U21 , typename U22 , typename U23 , typename U24 , typename U25 , typename U26 , typename U27 , typename U28 , typename U29 , typename U30 , typename U31 , typename U32 , typename U33 , typename U34 , typename U35 , typename U36 , typename U37 , typename U38 , typename U39>
-        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-        deque&
-        operator=(deque<U0 , U1 , U2 , U3 , U4 , U5 , U6 , U7 , U8 , U9 , U10 , U11 , U12 , U13 , U14 , U15 , U16 , U17 , U18 , U19 , U20 , U21 , U22 , U23 , U24 , U25 , U26 , U27 , U28 , U29 , U30 , U31 , U32 , U33 , U34 , U35 , U36 , U37 , U38 , U39> const& rhs)
-        {
-            base::operator=(rhs);
-            return *this;
-        }
         template <typename T>
         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
         deque&
@@ -762,9 +756,13 @@ deque(T_0 && t0 , T_1 && t1 , T_2 && t2 , T_3 && t3 , T_4 && t4 , T_5 && t5 , T_
         }
 # if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
         template <typename T0_>
-        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        BOOST_FUSION_GPU_ENABLED
         explicit deque(T0_&& t0
-          , typename enable_if<is_convertible<T0_, T0> >::type* = 0
+          , typename enable_if<is_convertible<T0_, T0>, detail::enabler_>::type = detail::enabler
+          , typename disable_if_c<
+                boost::is_same<deque const, typename boost::remove_reference<T0_>::type const>::value
+              , detail::enabler_
+            >::type = detail::enabler
          )
             : base(std::forward<T0_>( t0), detail::nil_keyed_element())
             {}
@@ -773,11 +771,12 @@ deque(T_0 && t0 , T_1 && t1 , T_2 && t2 , T_3 && t3 , T_4 && t4 , T_5 && t5 , T_
             : base(std::forward<deque>(rhs))
             {}
         template<typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8 , typename U9 , typename U10 , typename U11 , typename U12 , typename U13 , typename U14 , typename U15 , typename U16 , typename U17 , typename U18 , typename U19 , typename U20 , typename U21 , typename U22 , typename U23 , typename U24 , typename U25 , typename U26 , typename U27 , typename U28 , typename U29 , typename U30 , typename U31 , typename U32 , typename U33 , typename U34 , typename U35 , typename U36 , typename U37 , typename U38 , typename U39>
-        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        BOOST_FUSION_GPU_ENABLED
         deque(deque<U0 , U1 , U2 , U3 , U4 , U5 , U6 , U7 , U8 , U9 , U10 , U11 , U12 , U13 , U14 , U15 , U16 , U17 , U18 , U19 , U20 , U21 , U22 , U23 , U24 , U25 , U26 , U27 , U28 , U29 , U30 , U31 , U32 , U33 , U34 , U35 , U36 , U37 , U38 , U39>&& seq
             , typename disable_if<
                   is_convertible<deque<U0 , U1 , U2 , U3 , U4 , U5 , U6 , U7 , U8 , U9 , U10 , U11 , U12 , U13 , U14 , U15 , U16 , U17 , U18 , U19 , U20 , U21 , U22 , U23 , U24 , U25 , U26 , U27 , U28 , U29 , U30 , U31 , U32 , U33 , U34 , U35 , U36 , U37 , U38 , U39>, T0>
-              >::type* = 0)
+                , detail::enabler_
+              >::type = detail::enabler)
             : base(std::forward<deque<U0 , U1 , U2 , U3 , U4 , U5 , U6 , U7 , U8 , U9 , U10 , U11 , U12 , U13 , U14 , U15 , U16 , U17 , U18 , U19 , U20 , U21 , U22 , U23 , U24 , U25 , U26 , U27 , U28 , U29 , U30 , U31 , U32 , U33 , U34 , U35 , U36 , U37 , U38 , U39>>(seq))
             {}
         template <typename T>
@@ -788,6 +787,14 @@ deque(T_0 && t0 , T_1 && t1 , T_2 && t2 , T_3 && t3 , T_4 && t4 , T_5 && t5 , T_
             base::operator=(std::forward<T>( rhs));
             return *this;
         }
+        
+        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        deque&
+        operator=(deque const& rhs)
+        {
+            base::operator=(static_cast<base const&>(rhs));
+            return *this;
+        }
 # endif
     };
     template <>
@@ -805,7 +812,7 @@ deque(T_0 && t0 , T_1 && t1 , T_2 && t2 , T_3 && t3 , T_4 && t4 , T_5 && t5 , T_
             typename enable_if<
                 mpl::and_<
                     traits::is_sequence<Sequence>
-                  , result_of::empty<Sequence> > >::type* = 0) BOOST_NOEXCEPT
+                  , result_of::empty<Sequence> >, detail::enabler_>::type = detail::enabler) BOOST_NOEXCEPT
         {}
         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
         deque() BOOST_NOEXCEPT {}

include/boost/fusion/container/deque/detail/cpp03/preprocessed/deque50.hpp

@@ -915,23 +915,17 @@ deque(T_0 && t0 , T_1 && t1 , T_2 && t2 , T_3 && t3 , T_4 && t4 , T_5 && t5 , T_
             : base(rhs)
             {}
         template<typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8 , typename U9 , typename U10 , typename U11 , typename U12 , typename U13 , typename U14 , typename U15 , typename U16 , typename U17 , typename U18 , typename U19 , typename U20 , typename U21 , typename U22 , typename U23 , typename U24 , typename U25 , typename U26 , typename U27 , typename U28 , typename U29 , typename U30 , typename U31 , typename U32 , typename U33 , typename U34 , typename U35 , typename U36 , typename U37 , typename U38 , typename U39 , typename U40 , typename U41 , typename U42 , typename U43 , typename U44 , typename U45 , typename U46 , typename U47 , typename U48 , typename U49>
-        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        BOOST_FUSION_GPU_ENABLED
         deque(deque<U0 , U1 , U2 , U3 , U4 , U5 , U6 , U7 , U8 , U9 , U10 , U11 , U12 , U13 , U14 , U15 , U16 , U17 , U18 , U19 , U20 , U21 , U22 , U23 , U24 , U25 , U26 , U27 , U28 , U29 , U30 , U31 , U32 , U33 , U34 , U35 , U36 , U37 , U38 , U39 , U40 , U41 , U42 , U43 , U44 , U45 , U46 , U47 , U48 , U49> const& seq)
             : base(seq)
             {}
         template<typename Sequence>
-        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-        deque(Sequence const& seq, typename disable_if<is_convertible<Sequence, T0> >::type* = 0)
+        BOOST_FUSION_GPU_ENABLED
+        deque(Sequence const& seq
+            , typename disable_if<is_convertible<Sequence, T0>, detail::enabler_>::type = detail::enabler
+            , typename enable_if<traits::is_sequence<Sequence>, detail::enabler_>::type = detail::enabler)
             : base(base::from_iterator(fusion::begin(seq)))
             {}
-        template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8 , typename U9 , typename U10 , typename U11 , typename U12 , typename U13 , typename U14 , typename U15 , typename U16 , typename U17 , typename U18 , typename U19 , typename U20 , typename U21 , typename U22 , typename U23 , typename U24 , typename U25 , typename U26 , typename U27 , typename U28 , typename U29 , typename U30 , typename U31 , typename U32 , typename U33 , typename U34 , typename U35 , typename U36 , typename U37 , typename U38 , typename U39 , typename U40 , typename U41 , typename U42 , typename U43 , typename U44 , typename U45 , typename U46 , typename U47 , typename U48 , typename U49>
-        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-        deque&
-        operator=(deque<U0 , U1 , U2 , U3 , U4 , U5 , U6 , U7 , U8 , U9 , U10 , U11 , U12 , U13 , U14 , U15 , U16 , U17 , U18 , U19 , U20 , U21 , U22 , U23 , U24 , U25 , U26 , U27 , U28 , U29 , U30 , U31 , U32 , U33 , U34 , U35 , U36 , U37 , U38 , U39 , U40 , U41 , U42 , U43 , U44 , U45 , U46 , U47 , U48 , U49> const& rhs)
-        {
-            base::operator=(rhs);
-            return *this;
-        }
         template <typename T>
         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
         deque&
@@ -942,9 +936,13 @@ deque(T_0 && t0 , T_1 && t1 , T_2 && t2 , T_3 && t3 , T_4 && t4 , T_5 && t5 , T_
         }
 # if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
         template <typename T0_>
-        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        BOOST_FUSION_GPU_ENABLED
         explicit deque(T0_&& t0
-          , typename enable_if<is_convertible<T0_, T0> >::type* = 0
+          , typename enable_if<is_convertible<T0_, T0>, detail::enabler_>::type = detail::enabler
+          , typename disable_if_c<
+                boost::is_same<deque const, typename boost::remove_reference<T0_>::type const>::value
+              , detail::enabler_
+            >::type = detail::enabler
          )
             : base(std::forward<T0_>( t0), detail::nil_keyed_element())
             {}
@@ -953,11 +951,12 @@ deque(T_0 && t0 , T_1 && t1 , T_2 && t2 , T_3 && t3 , T_4 && t4 , T_5 && t5 , T_
             : base(std::forward<deque>(rhs))
             {}
         template<typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8 , typename U9 , typename U10 , typename U11 , typename U12 , typename U13 , typename U14 , typename U15 , typename U16 , typename U17 , typename U18 , typename U19 , typename U20 , typename U21 , typename U22 , typename U23 , typename U24 , typename U25 , typename U26 , typename U27 , typename U28 , typename U29 , typename U30 , typename U31 , typename U32 , typename U33 , typename U34 , typename U35 , typename U36 , typename U37 , typename U38 , typename U39 , typename U40 , typename U41 , typename U42 , typename U43 , typename U44 , typename U45 , typename U46 , typename U47 , typename U48 , typename U49>
-        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        BOOST_FUSION_GPU_ENABLED
         deque(deque<U0 , U1 , U2 , U3 , U4 , U5 , U6 , U7 , U8 , U9 , U10 , U11 , U12 , U13 , U14 , U15 , U16 , U17 , U18 , U19 , U20 , U21 , U22 , U23 , U24 , U25 , U26 , U27 , U28 , U29 , U30 , U31 , U32 , U33 , U34 , U35 , U36 , U37 , U38 , U39 , U40 , U41 , U42 , U43 , U44 , U45 , U46 , U47 , U48 , U49>&& seq
             , typename disable_if<
                   is_convertible<deque<U0 , U1 , U2 , U3 , U4 , U5 , U6 , U7 , U8 , U9 , U10 , U11 , U12 , U13 , U14 , U15 , U16 , U17 , U18 , U19 , U20 , U21 , U22 , U23 , U24 , U25 , U26 , U27 , U28 , U29 , U30 , U31 , U32 , U33 , U34 , U35 , U36 , U37 , U38 , U39 , U40 , U41 , U42 , U43 , U44 , U45 , U46 , U47 , U48 , U49>, T0>
-              >::type* = 0)
+                , detail::enabler_
+              >::type = detail::enabler)
             : base(std::forward<deque<U0 , U1 , U2 , U3 , U4 , U5 , U6 , U7 , U8 , U9 , U10 , U11 , U12 , U13 , U14 , U15 , U16 , U17 , U18 , U19 , U20 , U21 , U22 , U23 , U24 , U25 , U26 , U27 , U28 , U29 , U30 , U31 , U32 , U33 , U34 , U35 , U36 , U37 , U38 , U39 , U40 , U41 , U42 , U43 , U44 , U45 , U46 , U47 , U48 , U49>>(seq))
             {}
         template <typename T>
@@ -968,6 +967,14 @@ deque(T_0 && t0 , T_1 && t1 , T_2 && t2 , T_3 && t3 , T_4 && t4 , T_5 && t5 , T_
             base::operator=(std::forward<T>( rhs));
             return *this;
         }
+        
+        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        deque&
+        operator=(deque const& rhs)
+        {
+            base::operator=(static_cast<base const&>(rhs));
+            return *this;
+        }
 # endif
     };
     template <>
@@ -985,7 +992,7 @@ deque(T_0 && t0 , T_1 && t1 , T_2 && t2 , T_3 && t3 , T_4 && t4 , T_5 && t5 , T_
             typename enable_if<
                 mpl::and_<
                     traits::is_sequence<Sequence>
-                  , result_of::empty<Sequence> > >::type* = 0) BOOST_NOEXCEPT
+                  , result_of::empty<Sequence> >, detail::enabler_>::type = detail::enabler) BOOST_NOEXCEPT
         {}
         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
         deque() BOOST_NOEXCEPT {}

include/boost/fusion/container/deque/detail/keyed_element.hpp

@@ -59,7 +59,7 @@ namespace boost { namespace fusion { namespace detail
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
         keyed_element(keyed_element&& rhs)
-          : Rest(BOOST_FUSION_FWD_ELEM(Rest, rhs.forward_base()))
+          : Rest(rhs.forward_base())
           , value_(BOOST_FUSION_FWD_ELEM(Value, rhs.value_))
         {}
 #endif
@@ -90,7 +90,7 @@ namespace boost { namespace fusion { namespace detail
         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
         Rest&& forward_base() BOOST_NOEXCEPT
         {
-            return BOOST_FUSION_FWD_ELEM(Rest, *static_cast<Rest*>(this));
+            return std::move(*static_cast<Rest*>(this));
         }
 #endif
 
@@ -116,7 +116,7 @@ namespace boost { namespace fusion { namespace detail
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
         keyed_element(Value&& value, Rest&& rest)
-            : Rest(BOOST_FUSION_FWD_ELEM(Rest, rest))
+            : Rest(std::move(rest))
             , value_(BOOST_FUSION_FWD_ELEM(Value, value))
         {}
 #endif
@@ -147,8 +147,8 @@ namespace boost { namespace fusion { namespace detail
         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
         keyed_element& operator=(keyed_element&& rhs)
         {
-            base::operator=(std::forward<keyed_element>(rhs));
-            value_ = BOOST_FUSION_FWD_ELEM(Value, rhs.value_);
+            base::operator=(rhs.forward_base());
+            value_ = std::move(rhs.value_);
             return *this;
         }
 #endif

include/boost/fusion/container/generation/detail/pp_list_tie.hpp

@@ -0,0 +1,102 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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)
+==============================================================================*/
+#ifndef BOOST_PP_IS_ITERATING
+#if !defined(FUSION_PP_LIST_TIE_07192005_0109)
+#define FUSION_PP_LIST_TIE_07192005_0109
+
+#include <boost/preprocessor/iterate.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
+#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
+#include <boost/preprocessor/repetition/repeat_from_to.hpp>
+#include <boost/fusion/container/list/list.hpp>
+
+#if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES)
+#include <boost/fusion/container/generation/detail/preprocessed/list_tie.hpp>
+#else
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+#pragma wave option(preserve: 2, line: 0, output: "preprocessed/list_tie" FUSION_MAX_LIST_SIZE_STR".hpp")
+#endif
+
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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)
+
+    This is an auto-generated file. Do not edit!
+==============================================================================*/
+
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+#pragma wave option(preserve: 1)
+#endif
+
+namespace boost { namespace fusion
+{
+    struct void_;
+
+    namespace result_of
+    {
+        template <
+            BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
+                FUSION_MAX_LIST_SIZE, typename T, void_)
+          , typename Extra = void_
+        >
+        struct list_tie;
+    }
+
+// $$$ shouldn't we remove_reference first to allow references? $$$
+#define BOOST_FUSION_REF(z, n, data) BOOST_PP_CAT(T, n)&
+
+#define BOOST_PP_FILENAME_1 <boost/fusion/container/generation/detail/pp_list_tie.hpp>
+#define BOOST_PP_ITERATION_LIMITS (1, FUSION_MAX_LIST_SIZE)
+#include BOOST_PP_ITERATE()
+
+#undef BOOST_FUSION_REF
+
+}}
+
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+#pragma wave option(output: null)
+#endif
+
+#endif // BOOST_FUSION_DONT_USE_PREPROCESSED_FILES
+
+#endif
+#else // defined(BOOST_PP_IS_ITERATING)
+///////////////////////////////////////////////////////////////////////////////
+//
+//  Preprocessor vertical repetition code
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#define N BOOST_PP_ITERATION()
+
+    namespace result_of
+    {
+        template <BOOST_PP_ENUM_PARAMS(N, typename T)>
+        #define TEXT(z, n, text) , text
+        struct list_tie< BOOST_PP_ENUM_PARAMS(N, T) BOOST_PP_REPEAT_FROM_TO(BOOST_PP_DEC(N), FUSION_MAX_LIST_SIZE, TEXT, void_) >
+        #undef TEXT
+        {
+            typedef list<BOOST_PP_ENUM(N, BOOST_FUSION_REF, _)> type;
+        };
+    }
+
+    template <BOOST_PP_ENUM_PARAMS(N, typename T)>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline list<BOOST_PP_ENUM(N, BOOST_FUSION_REF, _)>
+    list_tie(BOOST_PP_ENUM_BINARY_PARAMS(N, T, & arg))
+    {
+        return list<BOOST_PP_ENUM(N, BOOST_FUSION_REF, _)>(
+            BOOST_PP_ENUM_PARAMS(N, arg));
+    }
+
+#undef N
+#endif // defined(BOOST_PP_IS_ITERATING)
+

include/boost/fusion/container/generation/detail/pp_make_list.hpp

@@ -0,0 +1,115 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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)
+==============================================================================*/
+#ifndef BOOST_PP_IS_ITERATING
+#if !defined(FUSION_PP_MAKE_LIST_07192005_1239)
+#define FUSION_PP_MAKE_LIST_07192005_1239
+
+#include <boost/preprocessor/iterate.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
+#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
+#include <boost/preprocessor/repetition/repeat_from_to.hpp>
+#include <boost/fusion/container/list/list.hpp>
+#include <boost/fusion/support/detail/as_fusion_element.hpp>
+
+#if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES)
+#include <boost/fusion/container/generation/detail/preprocessed/make_list.hpp>
+#else
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+#pragma wave option(preserve: 2, line: 0, output: "preprocessed/make_list" FUSION_MAX_LIST_SIZE_STR".hpp")
+#endif
+
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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)
+
+    This is an auto-generated file. Do not edit!
+==============================================================================*/
+
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+#pragma wave option(preserve: 1)
+#endif
+
+namespace boost { namespace fusion
+{
+    struct void_;
+
+    namespace result_of
+    {
+        template <
+            BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
+                FUSION_MAX_LIST_SIZE, typename T, void_)
+          , typename Extra = void_
+        >
+        struct make_list;
+
+        template <>
+        struct make_list<>
+        {
+            typedef list<> type;
+        };
+    }
+
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline list<>
+    make_list()
+    {
+        return list<>();
+    }
+
+#define BOOST_FUSION_AS_FUSION_ELEMENT(z, n, data)                               \
+    typename detail::as_fusion_element<BOOST_PP_CAT(T, n)>::type
+
+#define BOOST_PP_FILENAME_1 <boost/fusion/container/generation/detail/pp_make_list.hpp>
+#define BOOST_PP_ITERATION_LIMITS (1, FUSION_MAX_LIST_SIZE)
+#include BOOST_PP_ITERATE()
+
+#undef BOOST_FUSION_AS_FUSION_ELEMENT
+
+}}
+
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+#pragma wave option(output: null)
+#endif
+
+#endif // BOOST_FUSION_DONT_USE_PREPROCESSED_FILES
+
+#endif
+#else // defined(BOOST_PP_IS_ITERATING)
+///////////////////////////////////////////////////////////////////////////////
+//
+//  Preprocessor vertical repetition code
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#define N BOOST_PP_ITERATION()
+
+    namespace result_of
+    {
+        template <BOOST_PP_ENUM_PARAMS(N, typename T)>
+        #define TEXT(z, n, text) , text
+        struct make_list< BOOST_PP_ENUM_PARAMS(N, T) BOOST_PP_REPEAT_FROM_TO(BOOST_PP_DEC(N), FUSION_MAX_LIST_SIZE, TEXT, void_) >
+        #undef TEXT
+        {
+            typedef list<BOOST_PP_ENUM(N, BOOST_FUSION_AS_FUSION_ELEMENT, _)> type;
+        };
+    }
+
+    template <BOOST_PP_ENUM_PARAMS(N, typename T)>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline list<BOOST_PP_ENUM(N, BOOST_FUSION_AS_FUSION_ELEMENT, _)>
+    make_list(BOOST_PP_ENUM_BINARY_PARAMS(N, T, const& arg))
+    {
+        return list<BOOST_PP_ENUM(N, BOOST_FUSION_AS_FUSION_ELEMENT, _)>(
+            BOOST_PP_ENUM_PARAMS(N, arg));
+    }
+
+#undef N
+#endif // defined(BOOST_PP_IS_ITERATING)
+

include/boost/fusion/container/generation/detail/pp_make_set.hpp

@@ -0,0 +1,134 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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)
+==============================================================================*/
+#ifndef BOOST_PP_IS_ITERATING
+#if !defined(FUSION_MAKE_SET_09162005_1125)
+#define FUSION_MAKE_SET_09162005_1125
+
+#include <boost/preprocessor/iterate.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
+#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
+#include <boost/preprocessor/repetition/repeat_from_to.hpp>
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/container/set/set.hpp>
+#include <boost/fusion/support/detail/as_fusion_element.hpp>
+#include <boost/fusion/support/pair.hpp>
+
+#if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES)
+#include <boost/fusion/container/generation/detail/preprocessed/make_set.hpp>
+#else
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+#pragma wave option(preserve: 2, line: 0, output: "preprocessed/make_set" FUSION_MAX_SET_SIZE_STR".hpp")
+#endif
+
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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)
+
+    This is an auto-generated file. Do not edit!
+==============================================================================*/
+
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+#pragma wave option(preserve: 1)
+#define FUSION_HASH #
+#endif
+
+namespace boost { namespace fusion
+{
+    struct void_;
+
+    namespace result_of
+    {
+        template <
+            BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
+                FUSION_MAX_VECTOR_SIZE, typename T, void_)
+          , typename Extra = void_
+        >
+        struct make_set;
+
+        template <>
+        struct make_set<>
+        {
+            typedef set<> type;
+        };
+    }
+
+    // XXX:
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+FUSION_HASH if defined(BOOST_CLANG)
+    BOOST_CXX14_CONSTEXPR
+FUSION_HASH else
+    BOOST_CONSTEXPR
+FUSION_HASH endif
+#else
+#if defined(BOOST_CLANG)
+    BOOST_CXX14_CONSTEXPR
+#else
+    BOOST_CONSTEXPR
+#endif
+#endif
+    BOOST_FUSION_GPU_ENABLED
+    inline set<>
+    make_set()
+    {
+        return set<>();
+    }
+
+#define BOOST_FUSION_AS_FUSION_ELEMENT(z, n, data)                               \
+    typename detail::as_fusion_element<BOOST_PP_CAT(T, n)>::type
+
+#define BOOST_PP_FILENAME_1 <boost/fusion/container/generation/detail/pp_make_set.hpp>
+#define BOOST_PP_ITERATION_LIMITS (1, FUSION_MAX_VECTOR_SIZE)
+#include BOOST_PP_ITERATE()
+
+#undef BOOST_FUSION_ELEMENT
+#undef BOOST_FUSION_AS_ELEMENT
+
+}}
+
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+#undef FUSION_HASH
+#pragma wave option(output: null)
+#endif
+
+#endif // BOOST_FUSION_DONT_USE_PREPROCESSED_FILES
+
+#endif
+#else // defined(BOOST_PP_IS_ITERATING)
+///////////////////////////////////////////////////////////////////////////////
+//
+//  Preprocessor vertical repetition code
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#define N BOOST_PP_ITERATION()
+
+    namespace result_of
+    {
+        template <BOOST_PP_ENUM_PARAMS(N, typename T)>
+        #define TEXT(z, n, text) , text
+        struct make_set< BOOST_PP_ENUM_PARAMS(N, T) BOOST_PP_REPEAT_FROM_TO(BOOST_PP_DEC(N), FUSION_MAX_SET_SIZE, TEXT, void_) >
+        #undef TEXT
+        {
+            typedef set<BOOST_PP_ENUM(N, BOOST_FUSION_AS_FUSION_ELEMENT, _)> type;
+        };
+    }
+
+    template <BOOST_PP_ENUM_PARAMS(N, typename T)>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline set<BOOST_PP_ENUM(N, BOOST_FUSION_AS_FUSION_ELEMENT, _)>
+    make_set(BOOST_PP_ENUM_BINARY_PARAMS(N, T, const& arg))
+    {
+        return set<BOOST_PP_ENUM(N, BOOST_FUSION_AS_FUSION_ELEMENT, _)>(
+            BOOST_PP_ENUM_PARAMS(N, arg));
+    }
+
+#undef N
+#endif // defined(BOOST_PP_IS_ITERATING)
+

include/boost/fusion/container/generation/detail/pp_make_vector.hpp

@@ -0,0 +1,115 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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)
+==============================================================================*/
+#ifndef BOOST_PP_IS_ITERATING
+#if !defined(FUSION_MAKE_VECTOR_07162005_0243)
+#define FUSION_MAKE_VECTOR_07162005_0243
+
+#include <boost/preprocessor/iterate.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
+#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
+#include <boost/preprocessor/repetition/repeat_from_to.hpp>
+#include <boost/fusion/container/vector/vector.hpp>
+#include <boost/fusion/support/detail/as_fusion_element.hpp>
+
+#if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES)
+#include <boost/fusion/container/generation/detail/preprocessed/make_vector.hpp>
+#else
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+#pragma wave option(preserve: 2, line: 0, output: "preprocessed/make_vector" FUSION_MAX_VECTOR_SIZE_STR".hpp")
+#endif
+
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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)
+
+    This is an auto-generated file. Do not edit!
+==============================================================================*/
+
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+#pragma wave option(preserve: 1)
+#endif
+
+namespace boost { namespace fusion
+{
+    struct void_;
+
+    namespace result_of
+    {
+        template <
+            BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
+                FUSION_MAX_VECTOR_SIZE, typename T, void_)
+          , typename Extra = void_
+        >
+        struct make_vector;
+
+        template <>
+        struct make_vector<>
+        {
+            typedef vector0<> type;
+        };
+    }
+
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline vector0<>
+    make_vector()
+    {
+        return vector0<>();
+    }
+
+#define BOOST_FUSION_AS_FUSION_ELEMENT(z, n, data)                               \
+    typename detail::as_fusion_element<BOOST_PP_CAT(T, n)>::type
+
+#define BOOST_PP_FILENAME_1 <boost/fusion/container/generation/detail/pp_make_vector.hpp>
+#define BOOST_PP_ITERATION_LIMITS (1, FUSION_MAX_VECTOR_SIZE)
+#include BOOST_PP_ITERATE()
+
+#undef BOOST_FUSION_AS_FUSION_ELEMENT
+
+}}
+
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+#pragma wave option(output: null)
+#endif
+
+#endif // BOOST_FUSION_DONT_USE_PREPROCESSED_FILES
+
+#endif
+#else // defined(BOOST_PP_IS_ITERATING)
+///////////////////////////////////////////////////////////////////////////////
+//
+//  Preprocessor vertical repetition code
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#define N BOOST_PP_ITERATION()
+
+    namespace result_of
+    {
+        template <BOOST_PP_ENUM_PARAMS(N, typename T)>
+        #define TEXT(z, n, text) , text
+        struct make_vector< BOOST_PP_ENUM_PARAMS(N, T) BOOST_PP_REPEAT_FROM_TO(BOOST_PP_DEC(N), FUSION_MAX_VECTOR_SIZE, TEXT, void_) >
+        #undef TEXT
+        {
+            typedef BOOST_PP_CAT(vector, N)<BOOST_PP_ENUM(N, BOOST_FUSION_AS_FUSION_ELEMENT, _)> type;
+        };
+    }
+
+    template <BOOST_PP_ENUM_PARAMS(N, typename T)>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline BOOST_PP_CAT(vector, N)<BOOST_PP_ENUM(N, BOOST_FUSION_AS_FUSION_ELEMENT, _)>
+    make_vector(BOOST_PP_ENUM_BINARY_PARAMS(N, T, const& arg))
+    {
+        return BOOST_PP_CAT(vector, N)<BOOST_PP_ENUM(N, BOOST_FUSION_AS_FUSION_ELEMENT, _)>(
+            BOOST_PP_ENUM_PARAMS(N, arg));
+    }
+
+#undef N
+#endif // defined(BOOST_PP_IS_ITERATING)
+

include/boost/fusion/container/generation/detail/pp_vector_tie.hpp

@@ -0,0 +1,100 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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)
+==============================================================================*/
+#ifndef BOOST_PP_IS_ITERATING
+#if !defined(FUSION_VECTOR_TIE_07192005_1242)
+#define FUSION_VECTOR_TIE_07192005_1242
+
+#include <boost/preprocessor/iterate.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
+#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
+#include <boost/preprocessor/repetition/repeat_from_to.hpp>
+#include <boost/fusion/container/vector/vector.hpp>
+
+#if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES)
+#include <boost/fusion/container/generation/detail/preprocessed/vector_tie.hpp>
+#else
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+#pragma wave option(preserve: 2, line: 0, output: "preprocessed/vector_tie" FUSION_MAX_VECTOR_SIZE_STR".hpp")
+#endif
+
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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)
+
+    This is an auto-generated file. Do not edit!
+==============================================================================*/
+
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+#pragma wave option(preserve: 1)
+#endif
+
+namespace boost { namespace fusion
+{
+    struct void_;
+
+    namespace result_of
+    {
+        template <
+            BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
+                FUSION_MAX_VECTOR_SIZE, typename T, void_)
+          , typename Extra = void_
+        >
+        struct vector_tie;
+    }
+
+#define BOOST_FUSION_REF(z, n, data) BOOST_PP_CAT(T, n)&
+
+#define BOOST_PP_FILENAME_1 <boost/fusion/container/generation/detail/pp_vector_tie.hpp>
+#define BOOST_PP_ITERATION_LIMITS (1, FUSION_MAX_VECTOR_SIZE)
+#include BOOST_PP_ITERATE()
+
+#undef BOOST_FUSION_REF
+}}
+
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+#pragma wave option(output: null)
+#endif
+
+#endif // BOOST_FUSION_DONT_USE_PREPROCESSED_FILES
+
+#endif
+#else // defined(BOOST_PP_IS_ITERATING)
+///////////////////////////////////////////////////////////////////////////////
+//
+//  Preprocessor vertical repetition code
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#define N BOOST_PP_ITERATION()
+
+    namespace result_of
+    {
+        template <BOOST_PP_ENUM_PARAMS(N, typename T)>
+        #define TEXT(z, n, text) , text
+        struct vector_tie< BOOST_PP_ENUM_PARAMS(N, T) BOOST_PP_REPEAT_FROM_TO(BOOST_PP_DEC(N), FUSION_MAX_VECTOR_SIZE, TEXT, void_) >
+        #undef TEXT
+        {
+            typedef vector<BOOST_PP_ENUM(N, BOOST_FUSION_REF, _)> type;
+        };
+    }
+
+    template <BOOST_PP_ENUM_PARAMS(N, typename T)>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline vector<BOOST_PP_ENUM(N, BOOST_FUSION_REF, _)>
+    vector_tie(BOOST_PP_ENUM_BINARY_PARAMS(N, T, & arg))
+    {
+        return vector<BOOST_PP_ENUM(N, BOOST_FUSION_REF, _)>(
+            BOOST_PP_ENUM_PARAMS(N, arg));
+    }
+
+#undef N
+#endif // defined(BOOST_PP_IS_ITERATING)
+

include/boost/fusion/container/generation/ignore.hpp

@@ -9,6 +9,8 @@
 #if !defined(FUSION_IGNORE_07192005_0329)
 #define FUSION_IGNORE_07192005_0329
 
+#include <boost/fusion/support/config.hpp>
+
 namespace boost { namespace fusion
 {
     //  Swallows any assignment (by Doug Gregor)
@@ -17,7 +19,7 @@ namespace boost { namespace fusion
         struct swallow_assign
         {
             template<typename T>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+            BOOST_FUSION_CONSTEXPR_THIS BOOST_FUSION_GPU_ENABLED
             swallow_assign const&
             operator=(const T&) const
             {
@@ -27,7 +29,7 @@ namespace boost { namespace fusion
     }
 
     //  "ignore" allows tuple positions to be ignored when using "tie".
-    BOOST_CONSTEXPR detail::swallow_assign const ignore = detail::swallow_assign();
+    BOOST_CONSTEXPR_OR_CONST detail::swallow_assign ignore = detail::swallow_assign();
 }}
 
 #endif

include/boost/fusion/container/generation/list_tie.hpp

@@ -1,102 +1,44 @@
 /*=============================================================================
-    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)
 ==============================================================================*/
-#ifndef BOOST_PP_IS_ITERATING
-#if !defined(FUSION_LIST_TIE_07192005_0109)
-#define FUSION_LIST_TIE_07192005_0109
+#ifndef FUSION_LIST_TIE_06182015_0825
+#define FUSION_LIST_TIE_06182015_0825
 
-#include <boost/preprocessor/iterate.hpp>
-#include <boost/preprocessor/cat.hpp>
-#include <boost/preprocessor/repetition/enum_params.hpp>
-#include <boost/preprocessor/repetition/enum_binary_params.hpp>
-#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
-#include <boost/preprocessor/repetition/repeat_from_to.hpp>
+#include <boost/fusion/support/config.hpp>
 #include <boost/fusion/container/list/list.hpp>
 
-#if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES)
-#include <boost/fusion/container/generation/detail/preprocessed/list_tie.hpp>
+#if !defined(BOOST_FUSION_HAS_VARIADIC_LIST)
+# include <boost/fusion/container/generation/detail/pp_list_tie.hpp>
 #else
-#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
-#pragma wave option(preserve: 2, line: 0, output: "detail/preprocessed/list_tie" FUSION_MAX_LIST_SIZE_STR".hpp")
-#endif
 
-/*=============================================================================
-    Copyright (c) 2001-2011 Joel de Guzman
-
-    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)
-
-    This is an auto-generated file. Do not edit!
-==============================================================================*/
-
-#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
-#pragma wave option(preserve: 1)
-#endif
+///////////////////////////////////////////////////////////////////////////////
+// C++11 variadic interface
+///////////////////////////////////////////////////////////////////////////////
 
 namespace boost { namespace fusion
 {
-    struct void_;
-
     namespace result_of
     {
-        template <
-            BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
-                FUSION_MAX_LIST_SIZE, typename T, void_)
-          , typename Extra = void_
-        >
-        struct list_tie;
-    }
-
-// $$$ shouldn't we remove_reference first to allow references? $$$
-#define BOOST_FUSION_REF(z, n, data) BOOST_PP_CAT(T, n)&
-
-#define BOOST_PP_FILENAME_1 <boost/fusion/container/generation/list_tie.hpp>
-#define BOOST_PP_ITERATION_LIMITS (1, FUSION_MAX_LIST_SIZE)
-#include BOOST_PP_ITERATE()
-
-#undef BOOST_FUSION_REF
-
-}}
-
-#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
-#pragma wave option(output: null)
-#endif
-
-#endif // BOOST_FUSION_DONT_USE_PREPROCESSED_FILES
-
-#endif
-#else // defined(BOOST_PP_IS_ITERATING)
-///////////////////////////////////////////////////////////////////////////////
-//
-//  Preprocessor vertical repetition code
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#define N BOOST_PP_ITERATION()
-
-    namespace result_of
-    {
-        template <BOOST_PP_ENUM_PARAMS(N, typename T)>
-        #define TEXT(z, n, text) , text
-        struct list_tie< BOOST_PP_ENUM_PARAMS(N, T) BOOST_PP_REPEAT_FROM_TO(BOOST_PP_DEC(N), FUSION_MAX_LIST_SIZE, TEXT, void_) >
-        #undef TEXT
+        template <typename ...T>
+        struct list_tie
         {
-            typedef list<BOOST_PP_ENUM(N, BOOST_FUSION_REF, _)> type;
+            typedef list<T&...> type;
         };
     }
 
-    template <BOOST_PP_ENUM_PARAMS(N, typename T)>
+    template <typename ...T>
     BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-    inline list<BOOST_PP_ENUM(N, BOOST_FUSION_REF, _)>
-    list_tie(BOOST_PP_ENUM_BINARY_PARAMS(N, T, & arg))
+    inline list<T&...>
+    list_tie(T&... arg)
     {
-        return list<BOOST_PP_ENUM(N, BOOST_FUSION_REF, _)>(
-            BOOST_PP_ENUM_PARAMS(N, arg));
+        return list<T&...>(arg...);
     }
+}}
 
-#undef N
-#endif // defined(BOOST_PP_IS_ITERATING)
+#endif
+
+#endif
 

include/boost/fusion/container/generation/make_list.hpp

@@ -1,115 +1,46 @@
 /*=============================================================================
-    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2014 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)
 ==============================================================================*/
-#ifndef BOOST_PP_IS_ITERATING
-#if !defined(FUSION_MAKE_LIST_07192005_1239)
-#define FUSION_MAKE_LIST_07192005_1239
+#ifndef FUSION_MAKE_LIST_10262014_0647
+#define FUSION_MAKE_LIST_10262014_0647
 
-#include <boost/preprocessor/iterate.hpp>
-#include <boost/preprocessor/repetition/enum_params.hpp>
-#include <boost/preprocessor/repetition/enum_binary_params.hpp>
-#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
-#include <boost/preprocessor/repetition/repeat_from_to.hpp>
+#include <boost/fusion/support/config.hpp>
 #include <boost/fusion/container/list/list.hpp>
-#include <boost/fusion/support/detail/as_fusion_element.hpp>
 
-#if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES)
-#include <boost/fusion/container/generation/detail/preprocessed/make_list.hpp>
+#if !defined(BOOST_FUSION_HAS_VARIADIC_LIST)
+# include <boost/fusion/container/generation/detail/pp_make_list.hpp>
 #else
-#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
-#pragma wave option(preserve: 2, line: 0, output: "detail/preprocessed/make_list" FUSION_MAX_LIST_SIZE_STR".hpp")
-#endif
 
-/*=============================================================================
-    Copyright (c) 2001-2011 Joel de Guzman
+///////////////////////////////////////////////////////////////////////////////
+// C++11 variadic interface
+///////////////////////////////////////////////////////////////////////////////
 
-    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)
-
-    This is an auto-generated file. Do not edit!
-==============================================================================*/
-
-#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
-#pragma wave option(preserve: 1)
-#endif
+#include <boost/fusion/support/detail/as_fusion_element.hpp>
 
 namespace boost { namespace fusion
 {
-    struct void_;
-
     namespace result_of
     {
-        template <
-            BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
-                FUSION_MAX_LIST_SIZE, typename T, void_)
-          , typename Extra = void_
-        >
-        struct make_list;
-
-        template <>
-        struct make_list<>
+        template <typename ...T>
+        struct make_list
         {
-            typedef list<> type;
+            typedef list<typename detail::as_fusion_element<T>::type...> type;
         };
     }
 
+    template <typename ...T>
     BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-    inline list<>
-    make_list()
+    inline typename result_of::make_list<T...>::type
+    make_list(T const&... arg)
     {
-        return list<>();
+        return typename result_of::make_list<T...>::type(arg...);
     }
+ }}
 
-#define BOOST_FUSION_AS_FUSION_ELEMENT(z, n, data)                               \
-    typename detail::as_fusion_element<BOOST_PP_CAT(T, n)>::type
-
-#define BOOST_PP_FILENAME_1 <boost/fusion/container/generation/make_list.hpp>
-#define BOOST_PP_ITERATION_LIMITS (1, FUSION_MAX_LIST_SIZE)
-#include BOOST_PP_ITERATE()
-
-#undef BOOST_FUSION_AS_FUSION_ELEMENT
-
-}}
-
-#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
-#pragma wave option(output: null)
-#endif
-
-#endif // BOOST_FUSION_DONT_USE_PREPROCESSED_FILES
 
 #endif
-#else // defined(BOOST_PP_IS_ITERATING)
-///////////////////////////////////////////////////////////////////////////////
-//
-//  Preprocessor vertical repetition code
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#define N BOOST_PP_ITERATION()
-
-    namespace result_of
-    {
-        template <BOOST_PP_ENUM_PARAMS(N, typename T)>
-        #define TEXT(z, n, text) , text
-        struct make_list< BOOST_PP_ENUM_PARAMS(N, T) BOOST_PP_REPEAT_FROM_TO(BOOST_PP_DEC(N), FUSION_MAX_LIST_SIZE, TEXT, void_) >
-        #undef TEXT
-        {
-            typedef list<BOOST_PP_ENUM(N, BOOST_FUSION_AS_FUSION_ELEMENT, _)> type;
-        };
-    }
-
-    template <BOOST_PP_ENUM_PARAMS(N, typename T)>
-    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-    inline list<BOOST_PP_ENUM(N, BOOST_FUSION_AS_FUSION_ELEMENT, _)>
-    make_list(BOOST_PP_ENUM_BINARY_PARAMS(N, T, const& arg))
-    {
-        return list<BOOST_PP_ENUM(N, BOOST_FUSION_AS_FUSION_ELEMENT, _)>(
-            BOOST_PP_ENUM_PARAMS(N, arg));
-    }
-
-#undef N
-#endif // defined(BOOST_PP_IS_ITERATING)
+#endif
 

include/boost/fusion/container/generation/make_set.hpp

@@ -1,134 +1,55 @@
 /*=============================================================================
-    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2014-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)
 ==============================================================================*/
-#ifndef BOOST_PP_IS_ITERATING
-#if !defined(FUSION_MAKE_SET_09162005_1125)
-#define FUSION_MAKE_SET_09162005_1125
+#ifndef FUSION_MAKE_SET_11112014_2255
+#define FUSION_MAKE_SET_11112014_2255
 
-#include <boost/preprocessor/iterate.hpp>
-#include <boost/preprocessor/repetition/enum_params.hpp>
-#include <boost/preprocessor/repetition/enum_binary_params.hpp>
-#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
-#include <boost/preprocessor/repetition/repeat_from_to.hpp>
 #include <boost/fusion/support/config.hpp>
 #include <boost/fusion/container/set/set.hpp>
-#include <boost/fusion/support/detail/as_fusion_element.hpp>
-#include <boost/fusion/support/pair.hpp>
 
-#if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES)
-#include <boost/fusion/container/generation/detail/preprocessed/make_set.hpp>
+#if !defined(BOOST_FUSION_HAS_VARIADIC_SET)
+# include <boost/fusion/container/generation/detail/pp_make_set.hpp>
 #else
-#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
-#pragma wave option(preserve: 2, line: 0, output: "detail/preprocessed/make_set" FUSION_MAX_SET_SIZE_STR".hpp")
-#endif
 
-/*=============================================================================
-    Copyright (c) 2001-2011 Joel de Guzman
+///////////////////////////////////////////////////////////////////////////////
+// C++11 variadic interface
+///////////////////////////////////////////////////////////////////////////////
 
-    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)
-
-    This is an auto-generated file. Do not edit!
-==============================================================================*/
-
-#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
-#pragma wave option(preserve: 1)
-#define FUSION_HASH #
-#endif
+#include <boost/fusion/support/detail/as_fusion_element.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <utility>
 
 namespace boost { namespace fusion
 {
-    struct void_;
-
     namespace result_of
     {
-        template <
-            BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
-                FUSION_MAX_VECTOR_SIZE, typename T, void_)
-          , typename Extra = void_
-        >
-        struct make_set;
-
-        template <>
-        struct make_set<>
+        template <typename ...T>
+        struct make_set
         {
-            typedef set<> type;
+            typedef set<
+                typename detail::as_fusion_element<
+                    typename remove_const<
+                        typename remove_reference<T>::type
+                    >::type
+                >::type...
+            > type;
         };
     }
 
-    // XXX:
-#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
-FUSION_HASH if defined(BOOST_CLANG)
-    BOOST_CXX14_CONSTEXPR
-FUSION_HASH else
-    BOOST_CONSTEXPR
-FUSION_HASH endif
-#else
-#if defined(BOOST_CLANG)
-    BOOST_CXX14_CONSTEXPR
-#else
-    BOOST_CONSTEXPR
-#endif
-#endif
-    BOOST_FUSION_GPU_ENABLED
-    inline set<>
-    make_set()
-    {
-        return set<>();
-    }
-
-#define BOOST_FUSION_AS_FUSION_ELEMENT(z, n, data)                               \
-    typename detail::as_fusion_element<BOOST_PP_CAT(T, n)>::type
-
-#define BOOST_PP_FILENAME_1 <boost/fusion/container/generation/make_set.hpp>
-#define BOOST_PP_ITERATION_LIMITS (1, FUSION_MAX_VECTOR_SIZE)
-#include BOOST_PP_ITERATE()
-
-#undef BOOST_FUSION_ELEMENT
-#undef BOOST_FUSION_AS_ELEMENT
-
-}}
-
-#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
-#undef FUSION_HASH
-#pragma wave option(output: null)
-#endif
-
-#endif // BOOST_FUSION_DONT_USE_PREPROCESSED_FILES
-
-#endif
-#else // defined(BOOST_PP_IS_ITERATING)
-///////////////////////////////////////////////////////////////////////////////
-//
-//  Preprocessor vertical repetition code
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#define N BOOST_PP_ITERATION()
-
-    namespace result_of
-    {
-        template <BOOST_PP_ENUM_PARAMS(N, typename T)>
-        #define TEXT(z, n, text) , text
-        struct make_set< BOOST_PP_ENUM_PARAMS(N, T) BOOST_PP_REPEAT_FROM_TO(BOOST_PP_DEC(N), FUSION_MAX_SET_SIZE, TEXT, void_) >
-        #undef TEXT
-        {
-            typedef set<BOOST_PP_ENUM(N, BOOST_FUSION_AS_FUSION_ELEMENT, _)> type;
-        };
-    }
-
-    template <BOOST_PP_ENUM_PARAMS(N, typename T)>
+    template <typename ...T>
     BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-    inline set<BOOST_PP_ENUM(N, BOOST_FUSION_AS_FUSION_ELEMENT, _)>
-    make_set(BOOST_PP_ENUM_BINARY_PARAMS(N, T, const& arg))
+    inline typename result_of::make_set<T...>::type
+    make_set(T&&... arg)
     {
-        return set<BOOST_PP_ENUM(N, BOOST_FUSION_AS_FUSION_ELEMENT, _)>(
-            BOOST_PP_ENUM_PARAMS(N, arg));
+        return typename result_of::make_set<T...>::type(std::forward<T>(arg)...);
     }
+ }}
 
-#undef N
-#endif // defined(BOOST_PP_IS_ITERATING)
+
+#endif
+#endif
 

include/boost/fusion/container/generation/make_vector.hpp

@@ -1,115 +1,55 @@
 /*=============================================================================
-    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2014-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)
 ==============================================================================*/
-#ifndef BOOST_PP_IS_ITERATING
-#if !defined(FUSION_MAKE_VECTOR_07162005_0243)
-#define FUSION_MAKE_VECTOR_07162005_0243
+#ifndef FUSION_MAKE_VECTOR_11112014_2252
+#define FUSION_MAKE_VECTOR_11112014_2252
 
-#include <boost/preprocessor/iterate.hpp>
-#include <boost/preprocessor/repetition/enum_params.hpp>
-#include <boost/preprocessor/repetition/enum_binary_params.hpp>
-#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
-#include <boost/preprocessor/repetition/repeat_from_to.hpp>
+#include <boost/fusion/support/config.hpp>
 #include <boost/fusion/container/vector/vector.hpp>
-#include <boost/fusion/support/detail/as_fusion_element.hpp>
 
-#if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES)
-#include <boost/fusion/container/generation/detail/preprocessed/make_vector.hpp>
+#if !defined(BOOST_FUSION_HAS_VARIADIC_VECTOR)
+# include <boost/fusion/container/generation/detail/pp_make_vector.hpp>
 #else
-#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
-#pragma wave option(preserve: 2, line: 0, output: "detail/preprocessed/make_vector" FUSION_MAX_VECTOR_SIZE_STR".hpp")
-#endif
 
-/*=============================================================================
-    Copyright (c) 2001-2011 Joel de Guzman
+///////////////////////////////////////////////////////////////////////////////
+// C++11 variadic interface
+///////////////////////////////////////////////////////////////////////////////
 
-    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)
-
-    This is an auto-generated file. Do not edit!
-==============================================================================*/
-
-#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
-#pragma wave option(preserve: 1)
-#endif
+#include <boost/fusion/support/detail/as_fusion_element.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <utility>
 
 namespace boost { namespace fusion
 {
-    struct void_;
-
     namespace result_of
     {
-        template <
-            BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
-                FUSION_MAX_VECTOR_SIZE, typename T, void_)
-          , typename Extra = void_
-        >
-        struct make_vector;
-
-        template <>
-        struct make_vector<>
+        template <typename ...T>
+        struct make_vector
         {
-            typedef vector0<> type;
+            typedef vector<
+                typename detail::as_fusion_element<
+                    typename remove_const<
+                        typename remove_reference<T>::type
+                    >::type
+                >::type...
+            > type;
         };
     }
 
+    template <typename ...T>
     BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-    inline vector0<>
-    make_vector()
+    inline typename result_of::make_vector<T...>::type
+    make_vector(T&&... arg)
     {
-        return vector0<>();
+        return typename result_of::make_vector<T...>::type(std::forward<T>(arg)...);
     }
+ }}
 
-#define BOOST_FUSION_AS_FUSION_ELEMENT(z, n, data)                               \
-    typename detail::as_fusion_element<BOOST_PP_CAT(T, n)>::type
-
-#define BOOST_PP_FILENAME_1 <boost/fusion/container/generation/make_vector.hpp>
-#define BOOST_PP_ITERATION_LIMITS (1, FUSION_MAX_VECTOR_SIZE)
-#include BOOST_PP_ITERATE()
-
-#undef BOOST_FUSION_AS_FUSION_ELEMENT
-
-}}
-
-#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
-#pragma wave option(output: null)
-#endif
-
-#endif // BOOST_FUSION_DONT_USE_PREPROCESSED_FILES
 
 #endif
-#else // defined(BOOST_PP_IS_ITERATING)
-///////////////////////////////////////////////////////////////////////////////
-//
-//  Preprocessor vertical repetition code
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#define N BOOST_PP_ITERATION()
-
-    namespace result_of
-    {
-        template <BOOST_PP_ENUM_PARAMS(N, typename T)>
-        #define TEXT(z, n, text) , text
-        struct make_vector< BOOST_PP_ENUM_PARAMS(N, T) BOOST_PP_REPEAT_FROM_TO(BOOST_PP_DEC(N), FUSION_MAX_VECTOR_SIZE, TEXT, void_) >
-        #undef TEXT
-        {
-            typedef BOOST_PP_CAT(vector, N)<BOOST_PP_ENUM(N, BOOST_FUSION_AS_FUSION_ELEMENT, _)> type;
-        };
-    }
-
-    template <BOOST_PP_ENUM_PARAMS(N, typename T)>
-    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-    inline BOOST_PP_CAT(vector, N)<BOOST_PP_ENUM(N, BOOST_FUSION_AS_FUSION_ELEMENT, _)>
-    make_vector(BOOST_PP_ENUM_BINARY_PARAMS(N, T, const& arg))
-    {
-        return BOOST_PP_CAT(vector, N)<BOOST_PP_ENUM(N, BOOST_FUSION_AS_FUSION_ELEMENT, _)>(
-            BOOST_PP_ENUM_PARAMS(N, arg));
-    }
-
-#undef N
-#endif // defined(BOOST_PP_IS_ITERATING)
+#endif
 

include/boost/fusion/container/generation/vector_tie.hpp

@@ -1,100 +1,44 @@
 /*=============================================================================
-    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2014 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)
 ==============================================================================*/
-#ifndef BOOST_PP_IS_ITERATING
-#if !defined(FUSION_VECTOR_TIE_07192005_1242)
-#define FUSION_VECTOR_TIE_07192005_1242
+#ifndef FUSION_VECTOR_TIE_11112014_2302
+#define FUSION_VECTOR_TIE_11112014_2302
 
-#include <boost/preprocessor/iterate.hpp>
-#include <boost/preprocessor/cat.hpp>
-#include <boost/preprocessor/repetition/enum_params.hpp>
-#include <boost/preprocessor/repetition/enum_binary_params.hpp>
-#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
-#include <boost/preprocessor/repetition/repeat_from_to.hpp>
-#include <boost/fusion/container/vector/vector.hpp>
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/container/vector/detail/config.hpp>
 
-#if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES)
-#include <boost/fusion/container/generation/detail/preprocessed/vector_tie.hpp>
+#if !defined(BOOST_FUSION_HAS_VARIADIC_VECTOR)
+# include <boost/fusion/container/generation/detail/pp_vector_tie.hpp>
 #else
-#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
-#pragma wave option(preserve: 2, line: 0, output: "detail/preprocessed/vector_tie" FUSION_MAX_VECTOR_SIZE_STR".hpp")
-#endif
 
-/*=============================================================================
-    Copyright (c) 2001-2011 Joel de Guzman
-
-    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)
-
-    This is an auto-generated file. Do not edit!
-==============================================================================*/
-
-#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
-#pragma wave option(preserve: 1)
-#endif
+///////////////////////////////////////////////////////////////////////////////
+// C++11 variadic interface
+///////////////////////////////////////////////////////////////////////////////
 
 namespace boost { namespace fusion
 {
-    struct void_;
-
     namespace result_of
     {
-        template <
-            BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
-                FUSION_MAX_VECTOR_SIZE, typename T, void_)
-          , typename Extra = void_
-        >
-        struct vector_tie;
-    }
-
-#define BOOST_FUSION_REF(z, n, data) BOOST_PP_CAT(T, n)&
-
-#define BOOST_PP_FILENAME_1 <boost/fusion/container/generation/vector_tie.hpp>
-#define BOOST_PP_ITERATION_LIMITS (1, FUSION_MAX_VECTOR_SIZE)
-#include BOOST_PP_ITERATE()
-
-#undef BOOST_FUSION_REF
-}}
-
-#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
-#pragma wave option(output: null)
-#endif
-
-#endif // BOOST_FUSION_DONT_USE_PREPROCESSED_FILES
-
-#endif
-#else // defined(BOOST_PP_IS_ITERATING)
-///////////////////////////////////////////////////////////////////////////////
-//
-//  Preprocessor vertical repetition code
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#define N BOOST_PP_ITERATION()
-
-    namespace result_of
-    {
-        template <BOOST_PP_ENUM_PARAMS(N, typename T)>
-        #define TEXT(z, n, text) , text
-        struct vector_tie< BOOST_PP_ENUM_PARAMS(N, T) BOOST_PP_REPEAT_FROM_TO(BOOST_PP_DEC(N), FUSION_MAX_VECTOR_SIZE, TEXT, void_) >
-        #undef TEXT
+        template <typename ...T>
+        struct vector_tie
         {
-            typedef vector<BOOST_PP_ENUM(N, BOOST_FUSION_REF, _)> type;
+            typedef vector<T&...> type;
         };
     }
 
-    template <BOOST_PP_ENUM_PARAMS(N, typename T)>
+    template <typename ...T>
     BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-    inline vector<BOOST_PP_ENUM(N, BOOST_FUSION_REF, _)>
-    vector_tie(BOOST_PP_ENUM_BINARY_PARAMS(N, T, & arg))
+    inline vector<T&...>
+    vector_tie(T&... arg)
     {
-        return vector<BOOST_PP_ENUM(N, BOOST_FUSION_REF, _)>(
-            BOOST_PP_ENUM_PARAMS(N, arg));
+        return vector<T&...>(arg...);
     }
+ }}
 
-#undef N
-#endif // defined(BOOST_PP_IS_ITERATING)
+
+#endif
+#endif
 

include/boost/fusion/container/list.hpp

@@ -10,7 +10,6 @@
 #include <boost/fusion/support/config.hpp>
 #include <boost/fusion/container/list/cons.hpp>
 #include <boost/fusion/container/list/cons_iterator.hpp>
-#include <boost/fusion/container/list/limits.hpp>
 #include <boost/fusion/container/list/list.hpp>
 #include <boost/fusion/container/list/list_fwd.hpp>
 #include <boost/fusion/container/list/convert.hpp>

include/boost/fusion/container/list/cons.hpp

@@ -9,6 +9,8 @@
 #define FUSION_CONS_07172005_0843
 
 #include <boost/fusion/support/config.hpp>
+#include <boost/fusion/support/void.hpp>
+#include <boost/fusion/support/detail/enabler.hpp>
 #include <boost/fusion/container/list/cons_fwd.hpp>
 #include <boost/fusion/support/detail/access.hpp>
 #include <boost/fusion/sequence/intrinsic/begin.hpp>
@@ -23,6 +25,7 @@
 #include <boost/fusion/container/list/detail/value_at_impl.hpp>
 #include <boost/fusion/container/list/detail/empty_impl.hpp>
 #include <boost/type_traits/is_convertible.hpp>
+#include <boost/type_traits/is_base_of.hpp>
 #include <boost/utility/enable_if.hpp>
 #include <boost/fusion/support/sequence_base.hpp>
 #include <boost/fusion/support/is_sequence.hpp>
@@ -33,7 +36,6 @@
 
 namespace boost { namespace fusion
 {
-    struct void_;
     struct cons_tag;
     struct forward_traversal_tag;
     struct fusion_sequence_tag;
@@ -73,14 +75,16 @@ namespace boost { namespace fusion
             : car(rhs.car), cdr(rhs.cdr) {}
 
         template <typename Sequence>
-        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        BOOST_FUSION_GPU_ENABLED
         cons(
             Sequence const& seq
           , typename boost::enable_if<
                 mpl::and_<
                     traits::is_sequence<Sequence>
+                  , mpl::not_<is_base_of<cons, Sequence> >
                   , mpl::not_<is_convertible<Sequence, Car> > > // use copy to car instead
-            >::type* /*dummy*/ = 0
+              , detail::enabler_
+            >::type = detail::enabler
         )
             : car(*fusion::begin(seq))
             , cdr(fusion::next(fusion::begin(seq)), mpl::true_()) {}

include/boost/fusion/container/list/detail/cpp03/list.hpp

@@ -0,0 +1,104 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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(FUSION_LIST_07172005_1153)
+#define FUSION_LIST_07172005_1153
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/support/void.hpp>
+#include <boost/fusion/support/detail/enabler.hpp>
+#include <boost/fusion/container/list/detail/cpp03/list_fwd.hpp>
+#include <boost/fusion/container/list/detail/cpp03/list_to_cons.hpp>
+#include <boost/fusion/support/is_sequence.hpp>
+#include <boost/core/enable_if.hpp>
+
+#if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES)
+#include <boost/fusion/container/list/detail/cpp03/preprocessed/list.hpp>
+#else
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+#pragma wave option(preserve: 2, line: 0, output: "preprocessed/list" FUSION_MAX_LIST_SIZE_STR ".hpp")
+#endif
+
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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)
+
+    This is an auto-generated file. Do not edit!
+==============================================================================*/
+
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+#pragma wave option(preserve: 1)
+#endif
+
+namespace boost { namespace fusion
+{
+    struct nil_;
+    struct void_;
+
+    template <BOOST_PP_ENUM_PARAMS(FUSION_MAX_LIST_SIZE, typename T)>
+    struct list
+        : detail::list_to_cons<BOOST_PP_ENUM_PARAMS(FUSION_MAX_LIST_SIZE, T)>::type
+    {
+    private:
+        typedef
+            detail::list_to_cons<BOOST_PP_ENUM_PARAMS(FUSION_MAX_LIST_SIZE, T)>
+        list_to_cons;
+        typedef typename list_to_cons::type inherited_type;
+
+    public:
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        list()
+            : inherited_type() {}
+
+        template <BOOST_PP_ENUM_PARAMS(FUSION_MAX_LIST_SIZE, typename U)>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        list(list<BOOST_PP_ENUM_PARAMS(FUSION_MAX_LIST_SIZE, U)> const& rhs)
+            : inherited_type(rhs) {}
+
+        template <typename Sequence>
+        BOOST_FUSION_GPU_ENABLED
+        list(Sequence const& rhs
+            , typename enable_if<traits::is_sequence<Sequence>, detail::enabler_>::type = detail::enabler)
+            : inherited_type(rhs) {}
+
+        //  Expand a couple of forwarding constructors for arguments
+        //  of type (T0), (T0, T1), (T0, T1, T2) etc. Exanple:
+        //
+        //  list(
+        //      typename detail::call_param<T0>::type arg0
+        //    , typename detail::call_param<T1>::type arg1)
+        //    : inherited_type(list_to_cons::call(arg0, arg1)) {}
+        #include <boost/fusion/container/list/detail/cpp03/list_forward_ctor.hpp>
+
+        template <BOOST_PP_ENUM_PARAMS(FUSION_MAX_LIST_SIZE, typename U)>
+        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        list&
+        operator=(list<BOOST_PP_ENUM_PARAMS(FUSION_MAX_LIST_SIZE, U)> const& rhs)
+        {
+            inherited_type::operator=(rhs);
+            return *this;
+        }
+
+        template <typename Sequence>
+        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        typename boost::enable_if<traits::is_sequence<Sequence>, list&>::type
+        operator=(Sequence const& rhs)
+        {
+            inherited_type::operator=(rhs);
+            return *this;
+        }
+    };
+}}
+
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+#pragma wave option(output: null)
+#endif
+
+#endif // BOOST_FUSION_DONT_USE_PREPROCESSED_FILES
+
+#endif

include/boost/fusion/container/list/detail/cpp03/list_forward_ctor.hpp

@@ -18,7 +18,7 @@
 #define FUSION_LIST_CL_PAREN(z, n, type) )
 
 #define BOOST_PP_FILENAME_1 \
-    <boost/fusion/container/list/detail/list_forward_ctor.hpp>
+    <boost/fusion/container/list/detail/cpp03/list_forward_ctor.hpp>
 #define BOOST_PP_ITERATION_LIMITS (1, FUSION_MAX_LIST_SIZE)
 #include BOOST_PP_ITERATE()
 

include/boost/fusion/container/list/detail/cpp03/list_fwd.hpp

@@ -0,0 +1,51 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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(FUSION_LIST_FORWARD_07172005_0224)
+#define FUSION_LIST_FORWARD_07172005_0224
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/container/list/detail/cpp03/limits.hpp>
+#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
+
+#if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES)
+#include <boost/fusion/container/list/detail/cpp03/preprocessed/list_fwd.hpp>
+#else
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+#pragma wave option(preserve: 2, line: 0, output: "preprocessed/list" FUSION_MAX_LIST_SIZE_STR "_fwd.hpp")
+#endif
+
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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)
+
+    This is an auto-generated file. Do not edit!
+==============================================================================*/
+
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+#pragma wave option(preserve: 1)
+#endif
+
+namespace boost { namespace fusion
+{
+    struct void_;
+
+    template <
+        BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
+            FUSION_MAX_LIST_SIZE, typename T, void_)
+    >
+    struct list;
+}}
+
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+#pragma wave option(output: null)
+#endif
+
+#endif // BOOST_FUSION_DONT_USE_PREPROCESSED_FILES
+
+#endif

include/boost/fusion/container/list/detail/cpp03/list_to_cons.hpp

@@ -0,0 +1,76 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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(FUSION_LIST_TO_CONS_07172005_1041)
+#define FUSION_LIST_TO_CONS_07172005_1041
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/container/list/cons.hpp>
+#include <boost/fusion/container/list/detail/cpp03/limits.hpp>
+#include <boost/preprocessor/repetition/enum.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/enum_shifted_params.hpp>
+#include <boost/preprocessor/arithmetic/dec.hpp>
+
+#define FUSION_VOID(z, n, _) void_
+
+namespace boost { namespace fusion
+{
+    struct nil_;
+    struct void_;
+}}
+
+#if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES)
+#include <boost/fusion/container/list/detail/cpp03/preprocessed/list_to_cons.hpp>
+#else
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+#pragma wave option(preserve: 2, line: 0, output: "preprocessed/list_to_cons" FUSION_MAX_LIST_SIZE_STR ".hpp")
+#endif
+
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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)
+
+    This is an auto-generated file. Do not edit!
+==============================================================================*/
+
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+#pragma wave option(preserve: 1)
+#endif
+
+namespace boost { namespace fusion { namespace detail
+{
+    template <BOOST_PP_ENUM_PARAMS(FUSION_MAX_LIST_SIZE, typename T)>
+    struct list_to_cons
+    {
+        typedef T0 head_type;
+        typedef list_to_cons<
+            BOOST_PP_ENUM_SHIFTED_PARAMS(FUSION_MAX_LIST_SIZE, T), void_>
+        tail_list_to_cons;
+        typedef typename tail_list_to_cons::type tail_type;
+
+        typedef cons<head_type, tail_type> type;
+
+        #include <boost/fusion/container/list/detail/cpp03/list_to_cons_call.hpp>
+    };
+
+    template <>
+    struct list_to_cons<BOOST_PP_ENUM(FUSION_MAX_LIST_SIZE, FUSION_VOID, _)>
+    {
+        typedef nil_ type;
+    };
+}}}
+
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+#pragma wave option(output: null)
+#endif
+
+#endif // BOOST_FUSION_DONT_USE_PREPROCESSED_FILES
+
+#undef FUSION_VOID
+#endif

include/boost/fusion/container/list/detail/cpp03/list_to_cons_call.hpp

@@ -13,7 +13,7 @@
 #include <boost/preprocessor/repetition/enum_binary_params.hpp>
 
 #define BOOST_PP_FILENAME_1 \
-    <boost/fusion/container/list/detail/list_to_cons_call.hpp>
+    <boost/fusion/container/list/detail/cpp03/list_to_cons_call.hpp>
 #define BOOST_PP_ITERATION_LIMITS (1, FUSION_MAX_LIST_SIZE)
 #include BOOST_PP_ITERATE()
 

include/boost/fusion/container/list/detail/cpp03/preprocessed/list.hpp

@@ -8,15 +8,15 @@
 ==============================================================================*/
 
 #if FUSION_MAX_LIST_SIZE <= 10
-#include <boost/fusion/container/list/detail/preprocessed/list10.hpp>
+#include <boost/fusion/container/list/detail/cpp03/preprocessed/list10.hpp>
 #elif FUSION_MAX_LIST_SIZE <= 20
-#include <boost/fusion/container/list/detail/preprocessed/list20.hpp>
+#include <boost/fusion/container/list/detail/cpp03/preprocessed/list20.hpp>
 #elif FUSION_MAX_LIST_SIZE <= 30
-#include <boost/fusion/container/list/detail/preprocessed/list30.hpp>
+#include <boost/fusion/container/list/detail/cpp03/preprocessed/list30.hpp>
 #elif FUSION_MAX_LIST_SIZE <= 40
-#include <boost/fusion/container/list/detail/preprocessed/list40.hpp>
+#include <boost/fusion/container/list/detail/cpp03/preprocessed/list40.hpp>
 #elif FUSION_MAX_LIST_SIZE <= 50
-#include <boost/fusion/container/list/detail/preprocessed/list50.hpp>
+#include <boost/fusion/container/list/detail/cpp03/preprocessed/list50.hpp>
 #else
 #error "FUSION_MAX_LIST_SIZE out of bounds for preprocessed headers"
 #endif

include/boost/fusion/container/list/detail/cpp03/preprocessed/list10.hpp

@@ -18,8 +18,8 @@ namespace boost { namespace fusion
         typedef
             detail::list_to_cons<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>
         list_to_cons;
-    public:
         typedef typename list_to_cons::type inherited_type;
+    public:
         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
         list()
             : inherited_type() {}
@@ -28,9 +28,9 @@ namespace boost { namespace fusion
         list(list<U0 , U1 , U2 , U3 , U4 , U5 , U6 , U7 , U8 , U9> const& rhs)
             : inherited_type(rhs) {}
         template <typename Sequence>
-        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        BOOST_FUSION_GPU_ENABLED
         list(Sequence const& rhs
-            , typename boost::enable_if<traits::is_sequence<Sequence> >::type* = 0)
+            , typename enable_if<traits::is_sequence<Sequence>, detail::enabler_>::type = detail::enabler)
             : inherited_type(rhs) {}