Make fusion::pair trivially copyable if possible

.travis.yml

@@ -11,6 +11,11 @@ os:
   - linux
   - osx
 
+branches:
+  only:
+    - master
+    - develop
+
 env:
   matrix:
     - BOGUS_JOB=true
@@ -21,48 +26,18 @@ matrix:
     - env: BOGUS_JOB=true
 
   include:
+      # trusty default (gcc 4.8.4)
     - os: linux
-      dist: xenial
-      env: TOOLSET=gcc-4.4 CXXSTD=98,0x
-      addons:
-        apt:
-          packages:
-            - g++-4.4
-          sources:
-            - ubuntu-toolchain-r-test
-
-    #- os: linux
-    #  dist: xenial
-    #  env: TOOLSET=gcc-4.5 CXXSTD=03,0x
-    #  addons:
-    #    apt:
-    #      packages:
-    #        - g++-4.5
-    #      sources:
-    #        - ubuntu-toolchain-r-test
+      env: TOOLSET=gcc CXXSTD=03,11,1y
 
     - os: linux
-      dist: xenial
-      env: TOOLSET=gcc-4.6 CXXSTD=03,0x
-      addons:
-        apt:
-          packages:
-            - g++-4.6
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      dist: xenial
       env: TOOLSET=gcc-4.7 CXXSTD=03,11
       addons:
         apt:
           packages:
             - g++-4.7
-          sources:
-            - ubuntu-toolchain-r-test
 
     - os: linux
-      dist: xenial
       env: TOOLSET=gcc-4.8 CXXSTD=03,11,1y
       addons:
         apt:
@@ -72,8 +47,7 @@ matrix:
             - ubuntu-toolchain-r-test
 
     - os: linux
-      dist: xenial
-      env: TOOLSET=gcc-4.9 CXXSTD=03,11,14
+      env: TOOLSET=gcc-4.9 CXXSTD=03,11,1y
       addons:
         apt:
           packages:
@@ -82,8 +56,7 @@ matrix:
             - ubuntu-toolchain-r-test
 
     - os: linux
-      dist: xenial
-      env: TOOLSET=gcc-5 CXXSTD=03,11,14,17
+      env: TOOLSET=gcc-5 CXXSTD=03,11,14,1z
       addons:
         apt:
           packages:
@@ -92,8 +65,7 @@ matrix:
             - ubuntu-toolchain-r-test
 
     - os: linux
-      dist: xenial
-      env: TOOLSET=gcc-6 CXXSTD=03,11,14,17
+      env: TOOLSET=gcc-6 CXXSTD=03,11,14,1z
       addons:
         apt:
           packages:
@@ -102,8 +74,7 @@ matrix:
             - ubuntu-toolchain-r-test
 
     - os: linux
-      dist: xenial
-      env: TOOLSET=gcc-7 CXXSTD=03,11,14,17
+      env: TOOLSET=gcc-7 CXXSTD=03,11,14,1z
       addons:
         apt:
           packages:
@@ -111,93 +82,76 @@ matrix:
           sources:
             - ubuntu-toolchain-r-test
 
+      # trusty default (clang 3.9.0)
     - os: linux
-      dist: xenial
-      env: TOOLSET=gcc-8 CXXSTD=03,11,14,17,2a
+      env: TOOLSET=clang CXXSTD=03,11,14,1z
       addons:
         apt:
           packages:
-            - g++-8
+            - libstdc++-4.9-dev
           sources:
             - ubuntu-toolchain-r-test
 
     - os: linux
-      dist: xenial
       env: TOOLSET=clang-3.5 CXXSTD=03,11,14,1z
       addons:
         apt:
           packages:
             - clang-3.5
+            - libstdc++-4.9-dev
+          sources:
+            - ubuntu-toolchain-r-test
 
     - os: linux
-      dist: xenial
       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
-      dist: xenial
       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
-      dist: xenial
       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
-      dist: xenial
       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
-      dist: xenial
       env: TOOLSET=clang-4.0 CXXSTD=03,11,14,1z
       addons:
         apt:
           packages:
             - clang-4.0
-
-    - os: linux
-      dist: xenial
-      env: TOOLSET=clang-5.0 CXXSTD=03,11,14,17,2a
-      addons:
-        apt:
-          packages:
-            - clang-5.0
+            - libstdc++-4.9-dev
           sources:
-            - llvm-toolchain-xenial-5.0
-
-    - os: linux
-      dist: xenial
-      env: TOOLSET=clang-6.0 CXXSTD=03,11,14,17,2a
-      addons:
-        apt:
-          packages:
-            - clang-6.0
-          sources:
-            - llvm-toolchain-xenial-6.0
-
-    - os: linux
-      dist: xenial
-      env: TOOLSET=clang-7.0 CXXSTD=03,11,14,17,2a
-      addons:
-        apt:
-          packages:
-            - clang-7
-          sources:
-            - llvm-toolchain-xenial-7
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-4.0
 
     - os: osx
       env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z
@@ -237,7 +191,7 @@ install:
   - git submodule init libs/typeof
   - git submodule init libs/utility
 
-  - git submodule init libs/headers tools/boost_install tools/build
+  - git submodule init tools/build
   - git submodule update
 
   - rm -rf libs/fusion

appveyor.yml

@@ -7,41 +7,25 @@ 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
-      CXXSTD: latest # fake
     - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
       TOOLSET: msvc-10.0
-      CXXSTD: latest # fake
     - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
       TOOLSET: msvc-11.0
-      CXXSTD: latest # fake
     - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
       TOOLSET: msvc-12.0
-      CXXSTD: latest # fake
     - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
       TOOLSET: msvc-14.0
-      CXXSTD: 14
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      TOOLSET: msvc-14.0
-      CXXSTD: latest
     - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
       TOOLSET: msvc-14.1
-      CXXSTD: 14
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      TOOLSET: msvc-14.1
-      CXXSTD: 17
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      TOOLSET: msvc-14.1
-      CXXSTD: latest
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      TOOLSET: clang-win
-      CXXSTD: 14
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      TOOLSET: clang-win
-      CXXSTD: 17
 
 install:
   - set BOOST_BRANCH=develop
@@ -79,7 +63,7 @@ install:
   - git submodule init libs/typeof
   - git submodule init libs/utility
 
-  - git submodule init libs/headers tools/boost_install tools/build
+  - git submodule init tools/build
   - git submodule update
   - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\fusion
   - cmd /c bootstrap
@@ -88,4 +72,4 @@ install:
 build: off
 
 test_script:
-  - b2 -j%NUMBER_OF_PROCESSORS% --hash libs/fusion/test toolset=%TOOLSET% cxxstd=%CXXSTD%
+  - b2 -j%NUMBER_OF_PROCESSORS% --hash libs/fusion/test toolset=%TOOLSET%

doc/adapted.qbk

@@ -23,6 +23,19 @@ various data structures, non-intrusively, as full fledged Fusion sequences.
     #include <boost/fusion/adapted.hpp>
     #include <boost/fusion/include/adapted.hpp>
 
+Fusion sequences may also be adapted as fully conforming __mpl__ sequences (see
+__intrinsics__). That way, we can have 2-way adaptation to and from __mpl__ and
+Fusion. To make Fusion sequences fully conforming __mpl__ sequences, include:
+
+    #include <boost/fusion/mpl.hpp>
+
+If you want bi-directional adaptation to and from __mpl__ and Fusion, simply
+include:
+
+    #include <boost/fusion/include/mpl.hpp>
+
+The header includes all the necessary headers.
+
 [section:array Array]
 
 This module provides adapters for arrays. Including the module
@@ -132,21 +145,6 @@ header makes all __mpl__ sequences fully conforming fusion sequences.
     std::cout << __at_c__<0>(v) << std::endl;
     std::cout << __at_c__<1>(v) << std::endl;
 
-[heading Bi-directional adaptation]
-
-Fusion sequences may also be adapted as fully conforming __mpl__ sequences (see
-__intrinsics__). That way, we can have 2-way adaptation to and from __mpl__ and
-Fusion. To make Fusion sequences fully conforming __mpl__ sequences, include:
-
-    #include <boost/fusion/mpl.hpp>
-
-If you want bi-directional adaptation to and from __mpl__ and Fusion, simply
-include:
-
-    #include <boost/fusion/include/mpl.hpp>
-
-The header includes all the necessary headers.
-
 [heading See also]
 
 __mpl__

doc/sequence.qbk

@@ -1522,16 +1522,6 @@ each element. Analogously, the global `operator>>` has been overloaded
 to extract __sequence__(s) from generic input streams by recursively
 calling `operator>>` for each element.
 
-Please note that, to display your adapted types via fusion IO system,
-corresponding overloaded operators should be introduced to same namespace
-of the type.
-
-    namespace your_awesome_library
-    {
-        using boost::fusion::operators::operator>>; // for input
-        using boost::fusion::operators::operator<<; // for output
-        ...
-
 The default delimiter between the elements is space, and the __sequence__
 is enclosed in parenthesis. For Example:
 

doc/view.qbk

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

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

@@ -16,6 +16,10 @@
 #include <boost/preprocessor/empty.hpp>
 #include <boost/preprocessor/control/if.hpp>
 #include <boost/preprocessor/comparison/less.hpp>
+#include <boost/type_traits/add_reference.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/add_const.hpp>
+#include <boost/type_traits/remove_const.hpp>
 
 #include <boost/fusion/adapted/struct/detail/extension.hpp>
 #include <boost/fusion/adapted/struct/detail/adapt_base.hpp>

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

@@ -15,6 +15,9 @@
 #include <boost/preprocessor/cat.hpp>
 #include <boost/preprocessor/empty.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>
 
 #include <boost/fusion/adapted/struct/detail/extension.hpp>
 #include <boost/fusion/adapted/struct/detail/adapt_base.hpp>

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

@@ -21,8 +21,8 @@
 #include <boost/preprocessor/tuple/elem.hpp>
 #include <boost/mpl/if.hpp>
 #include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/add_const.hpp>
 #include <boost/type_traits/remove_const.hpp>
-#include <boost/type_traits/remove_reference.hpp>
 
 #include <boost/typeof/typeof.hpp>
 
@@ -83,8 +83,20 @@
     typedef                                                                     \
         BOOST_PP_EXPR_IF(BOOST_FUSION_ADAPT_IS_TPL(TEMPLATE_PARAMS_SEQ),        \
                          typename)                                              \
-        deduced_attr_type::type type;                                           \
-    typedef type const_type;
+        boost::remove_const<                                                    \
+          BOOST_PP_EXPR_IF(BOOST_FUSION_ADAPT_IS_TPL(TEMPLATE_PARAMS_SEQ),      \
+                           typename) \
+          deduced_attr_type::type                                               \
+        >::type type;                                                           \
+                                                                                \
+    typedef                                                                     \
+        BOOST_PP_EXPR_IF(BOOST_FUSION_ADAPT_IS_TPL(TEMPLATE_PARAMS_SEQ),        \
+                         typename)   \
+        boost::add_const<                                                       \
+          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_TUPLE_SIZE, PREFIX, TEMPLATE_PARAMS_SEQ)     \

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

@@ -15,6 +15,10 @@
 #include <boost/preprocessor/empty.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>
+#include <boost/type_traits/remove_const.hpp>
 
 #include <boost/fusion/adapted/struct/detail/extension.hpp>
 #include <boost/fusion/adapted/struct/detail/adapt_base.hpp>

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

@@ -18,6 +18,10 @@
 #include <boost/preprocessor/comparison/less.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>
+#include <boost/type_traits/remove_const.hpp>
 
 #include <boost/fusion/adapted/struct/detail/extension.hpp>
 #include <boost/fusion/adapted/struct/detail/adapt_base.hpp>

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

@@ -34,9 +34,7 @@
 #include <boost/mpl/tag.hpp>
 #include <boost/mpl/eval_if.hpp>
 #include <boost/mpl/identity.hpp>
-#include <boost/type_traits/is_const.hpp>
 #include <boost/type_traits/add_const.hpp>
-#include <boost/type_traits/add_reference.hpp>
 
 #include <boost/typeof/typeof.hpp>
 

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

@@ -30,7 +30,7 @@ namespace detail
     template <typename First, typename Last, typename F>
     BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
     inline void
-    for_each_linear(First const& first, Last const& last, F& f, mpl::false_)
+    for_each_linear(First const& first, Last const& last, F const& f, mpl::false_)
     {
         f(*first);
         detail::for_each_linear(fusion::next(first), last, f, 
@@ -41,7 +41,7 @@ namespace detail
     template <typename Sequence, typename F, typename Tag>
     BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
     inline void
-    for_each_dispatch(Sequence& seq, F& f, Tag)
+    for_each_dispatch(Sequence& seq, F const& f, Tag)
     {
         detail::for_each_linear(
                                 fusion::begin(seq)
@@ -57,7 +57,7 @@ namespace detail
     {
         template<typename I0, typename F>
         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-        static void call(I0 const& i0, F& f)
+        static void call(I0 const& i0, F const& f)
         {
             f(*i0);
             typedef typename result_of::next<I0>::type I1;
@@ -78,7 +78,7 @@ namespace detail
     {
         template<typename I0, typename F>
         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-        static void call(I0 const& i0, F& f)
+        static void call(I0 const& i0, F const& f)
         {
             f(*i0);
             typedef typename result_of::next<I0>::type I1;
@@ -95,7 +95,7 @@ namespace detail
     {
         template<typename I0, typename F>
         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-        static void call(I0 const& i0, F& f)
+        static void call(I0 const& i0, F const& f)
         {
             f(*i0);
             typedef typename result_of::next<I0>::type I1;
@@ -109,7 +109,7 @@ namespace detail
     {
         template<typename I0, typename F>
         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-        static void call(I0 const& i0, F& f)
+        static void call(I0 const& i0, F const& f)
         {
             f(*i0);
         }
@@ -128,7 +128,7 @@ namespace detail
     template <typename Sequence, typename F>
     BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
     inline void
-    for_each_dispatch(Sequence& seq, F& f, random_access_traversal_tag)
+    for_each_dispatch(Sequence& seq, F const& f, random_access_traversal_tag)
     {
         typedef typename result_of::begin<Sequence>::type begin;
         typedef typename result_of::end<Sequence>::type end;
@@ -138,7 +138,7 @@ namespace detail
     template <typename Sequence, typename F>
     BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
     inline void
-    for_each(Sequence& seq, F& f, mpl::false_) // unsegmented implementation
+    for_each(Sequence& seq, F const& f, mpl::false_) // unsegmented implementation
     {
         detail::for_each_dispatch(seq, f, typename traits::category_of<Sequence>::type());
     }

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

@@ -19,11 +19,11 @@ namespace boost { namespace fusion { namespace detail
     struct segmented_for_each_fun
     {
         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-        explicit segmented_for_each_fun(Fun& f)
+        explicit segmented_for_each_fun(Fun const& f)
           : fun(f)
         {}
 
-        Fun& fun;
+        Fun const& fun;
 
         template <typename Sequence, typename State, typename Context>
         struct apply
@@ -43,7 +43,7 @@ namespace boost { namespace fusion { namespace detail
     template <typename Sequence, typename F>
     BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
     inline void
-    for_each(Sequence& seq, F& f, mpl::true_) // segmented implementation
+    for_each(Sequence& seq, F const& f, mpl::true_) // segmented implementation
     {
         fusion::segmented_fold_until(seq, void_(), segmented_for_each_fun<F>(f));
     }

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

@@ -1,7 +1,6 @@
 /*=============================================================================
     Copyright (c) 2001-2007 Joel de Guzman
     Copyright (c) 2007 Dan Marsden
-    Copyright (c) 2018 Kohei Takahashi
 
     Distributed under the Boost Software License, Version 1.0. (See accompanying 
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -14,7 +13,7 @@
 #include <boost/fusion/algorithm/iteration/detail/segmented_for_each.hpp>
 #include <boost/fusion/support/is_segmented.hpp>
 #include <boost/fusion/support/is_sequence.hpp>
-#include <boost/core/enable_if.hpp>
+#include <boost/utility/enable_if.hpp>
 
 namespace boost { namespace fusion
 {
@@ -29,16 +28,24 @@ namespace boost { namespace fusion
 
     template <typename Sequence, typename F>
     BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-    inline typename enable_if<traits::is_sequence<Sequence> >::type
-    for_each(Sequence& seq, F f)
+    inline typename
+        enable_if<
+            traits::is_sequence<Sequence>
+          , void
+        >::type
+    for_each(Sequence& seq, F const& f)
     {
         detail::for_each(seq, f, typename traits::is_segmented<Sequence>::type());
     }
 
     template <typename Sequence, typename F>
     BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-    inline typename enable_if<traits::is_sequence<Sequence> >::type
-    for_each(Sequence const& seq, F f)
+    inline typename
+        enable_if<
+            traits::is_sequence<Sequence>
+          , void
+        >::type
+    for_each(Sequence const& seq, F const& f)
     {
         detail::for_each(seq, f, typename traits::is_segmented<Sequence>::type());
     }

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

@@ -1,6 +1,5 @@
 /*=============================================================================
     Copyright (c) 2011 Eric Niebler
-    Copyright (c) 2018 Kohei Takahashi
 
     Distributed under the Boost Software License, Version 1.0. (See accompanying 
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -10,7 +9,7 @@
 
 #include <boost/fusion/support/config.hpp>
 #include <boost/fusion/support/is_sequence.hpp>
-#include <boost/core/enable_if.hpp>
+#include <boost/utility/enable_if.hpp>
 
 namespace boost { namespace fusion
 {
@@ -22,13 +21,21 @@ namespace boost { namespace fusion
 
     template <typename Sequence, typename F>
     BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-    inline typename enable_if<traits::is_sequence<Sequence> >::type
-    for_each(Sequence& seq, F f);
+    inline typename
+        enable_if<
+            traits::is_sequence<Sequence>
+          , void
+        >::type
+    for_each(Sequence& seq, F const& f);
 
     template <typename Sequence, typename F>
     BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-    inline typename enable_if<traits::is_sequence<Sequence> >::type
-    for_each(Sequence const& seq, F f);
+    inline typename
+        enable_if<
+            traits::is_sequence<Sequence>
+          , void
+        >::type
+    for_each(Sequence const& seq, F const& f);
 }}
 
 #endif

include/boost/fusion/algorithm/query/detail/find_if.hpp

@@ -2,7 +2,6 @@
     Copyright (c) 2001-2011 Joel de Guzman
     Copyright (c) 2007 Dan Marsden
     Copyright (c) 2009 Christopher Schmidt
-    Copyright (c) 2018 Kohei Takahashi
 
     Distributed under the Boost Software License, Version 1.0. (See accompanying 
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -14,6 +13,7 @@
 #include <boost/mpl/apply.hpp>
 #include <boost/mpl/eval_if.hpp>
 #include <boost/mpl/identity.hpp>
+#include <boost/mpl/lambda.hpp>
 #include <boost/mpl/or.hpp>
 #include <boost/fusion/iterator/advance.hpp>
 #include <boost/fusion/iterator/distance.hpp>
@@ -22,9 +22,10 @@
 #include <boost/fusion/sequence/intrinsic/begin.hpp>
 #include <boost/fusion/sequence/intrinsic/end.hpp>
 #include <boost/fusion/support/category_of.hpp>
-#include <boost/core/enable_if.hpp>
 
-namespace boost { namespace fusion { namespace detail
+namespace boost { namespace fusion { 
+    struct random_access_traversal_tag;
+namespace detail
 {
     template <typename Iterator, typename Pred>
     struct apply_filter
@@ -177,8 +178,8 @@ namespace boost { namespace fusion { namespace detail
             choose_find_if<
                 First
               , Last
-              , Pred
-              , traits::is_random_access<First>::value
+              , typename mpl::lambda<Pred>::type
+              , is_base_of<random_access_traversal_tag, typename traits::category_of<First>::type>::value
             >::type
         type;
 
@@ -207,23 +208,31 @@ namespace boost { namespace fusion { namespace detail
             return recursive_call(iter, found());
         }
 
-        template <typename Iterator>
+        template <typename Iterator, typename Tag>
         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-        static typename boost::disable_if<traits::is_random_access<Iterator>, type>::type
-        iter_call(Iterator const& iter)
+        static type
+        choose_call(Iterator const& iter, Tag)
         {
             return recursive_call(iter);
         }
 
         template <typename Iterator>
         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-        static typename boost::enable_if<traits::is_random_access<Iterator>, type>::type
-        iter_call(Iterator const& iter)
+        static type
+        choose_call(Iterator const& iter, random_access_traversal_tag)
         {
             typedef typename result_of::distance<Iterator, type>::type N;
             return fusion::advance<N>(iter);
         }
 
+        template <typename Iterator>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static type
+        iter_call(Iterator const& iter)
+        {
+            return choose_call(iter, typename traits::category_of<Iterator>::type());
+        }
+
         template <typename Sequence>
         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
         static type

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

@@ -1,8 +1,7 @@
 /*=============================================================================
     Copyright (c) 2001-2011 Joel de Guzman
-    Copyright (c) 2018 Kohei Takahashi
 
-    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    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_REMOVE_IF_07162005_0818)
@@ -11,6 +10,7 @@
 #include <boost/fusion/support/config.hpp>
 #include <boost/fusion/view/filter_view/filter_view.hpp>
 #include <boost/mpl/not.hpp>
+#include <boost/type_traits/is_same.hpp>
 
 namespace boost { namespace fusion
 {

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

@@ -13,11 +13,6 @@
 #include <boost/fusion/iterator/deref.hpp>
 #include <boost/fusion/iterator/next.hpp>
 
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && BOOST_WORKAROUND(BOOST_GCC, / 100 == 404)
-#include <boost/core/enable_if.hpp>
-#include <boost/type_traits/is_same.hpp>
-#endif
-
 namespace boost { namespace fusion
 {
     struct fusion_sequence_tag;
@@ -119,13 +114,8 @@ namespace boost { namespace fusion { namespace detail
         {}
 
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-#if BOOST_WORKAROUND(BOOST_GCC, / 100 == 404)
-        template <typename Value_, typename = typename enable_if<is_same<Value_, Value> >::type>
-#else
-        typedef Value Value_;
-#endif
         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-        keyed_element(Value_&& value, Rest&& rest)
+        keyed_element(Value&& value, Rest&& rest)
             : Rest(std::move(rest))
             , value_(BOOST_FUSION_FWD_ELEM(Value, value))
         {}

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

@@ -70,10 +70,6 @@ namespace boost { namespace fusion
         cons(cons<Car2, Cdr2> const& rhs)
             : car(rhs.car), cdr(rhs.cdr) {}
 
-#if BOOST_WORKAROUND(BOOST_GCC, / 100 == 406) && !defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS)
-        // Workaround for `array used as initializer` compile error on gcc 4.6 w/ c++0x.
-        template <typename = void>
-#endif
         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
         cons(cons const& rhs)
             : car(rhs.car), cdr(rhs.cdr) {}

include/boost/fusion/container/map/detail/map_impl.hpp

@@ -125,7 +125,11 @@ namespace boost { namespace fusion { namespace detail
         }
 
         BOOST_FUSION_GPU_ENABLED
-        mpl::identity<value_type> get_val(mpl::identity<key_type>) const;
+        value_type get_val(mpl::identity<key_type>);
+        BOOST_FUSION_GPU_ENABLED
+        pair_type get_val(mpl::int_<index>);
+        BOOST_FUSION_GPU_ENABLED
+        value_type get_val(mpl::identity<key_type>) const;
         BOOST_FUSION_GPU_ENABLED
         pair_type get_val(mpl::int_<index>) const;
 

include/boost/fusion/container/map/detail/value_at_key_impl.hpp

@@ -1,6 +1,5 @@
 /*=============================================================================
     Copyright (c) 2001-2013 Joel de Guzman
-    Copyright (c) 2018 Kohei Takahashi
 
     Distributed under the Boost Software License, Version 1.0. (See accompanying
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -9,6 +8,10 @@
 #define BOOST_FUSION_MAP_DETAIL_VALUE_AT_KEY_IMPL_02042013_0821
 
 #include <boost/fusion/support/config.hpp>
+#include <boost/fusion/support/detail/access.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/mpl/at.hpp>
+#include <boost/mpl/identity.hpp>
 #include <boost/utility/declval.hpp>
 
 namespace boost { namespace fusion
@@ -24,10 +27,12 @@ namespace boost { namespace fusion
         struct value_at_key_impl<map_tag>
         {
             template <typename Sequence, typename Key>
-            struct apply : BOOST_FUSION_DECLTYPE_N3031((
-                    boost::declval<Sequence>().get_val(mpl::identity<Key>())
-                ))
-            {};
+            struct apply
+            {
+                typedef
+                    decltype(boost::declval<Sequence>().get_val(mpl::identity<Key>()))
+                type;
+            };
         };
     }
 }}

include/boost/fusion/container/map/map_fwd.hpp

@@ -36,6 +36,8 @@
 # include <boost/fusion/container/map/detail/cpp03/map_fwd.hpp>
 #else
 
+#include <boost/fusion/container/map/detail/map_impl.hpp>
+
 ///////////////////////////////////////////////////////////////////////////////
 // C++11 interface
 ///////////////////////////////////////////////////////////////////////////////

include/boost/fusion/container/vector/detail/value_at_impl.hpp

@@ -1,5 +1,5 @@
 /*=============================================================================
-    Copyright (c) 2014,2018 Kohei Takahashi
+    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)
@@ -7,6 +7,7 @@
 #ifndef FUSION_VALUE_AT_IMPL_16122014_1641
 #define FUSION_VALUE_AT_IMPL_16122014_1641
 
+#include <boost/config.hpp>
 #include <boost/fusion/support/config.hpp>
 #include <boost/fusion/container/vector/detail/config.hpp>
 
@@ -22,7 +23,6 @@
 ///////////////////////////////////////////////////////////////////////////////
 #include <boost/fusion/container/vector/vector_fwd.hpp>
 #include <boost/type_traits/declval.hpp>
-#include <boost/mpl/identity.hpp>
 
 namespace boost { namespace fusion
 {
@@ -35,7 +35,7 @@ namespace boost { namespace fusion
 
         template <std::size_t N, typename U>
         static inline BOOST_FUSION_GPU_ENABLED
-        mpl::identity<U> value_at_impl(store<N, U> const volatile*);
+        U value_at_impl(store<N, U> const volatile*);
     }
 
     namespace extension
@@ -47,10 +47,12 @@ namespace boost { namespace fusion
         struct value_at_impl<vector_tag>
         {
             template <typename Sequence, typename N>
-            struct apply : BOOST_FUSION_DECLTYPE_N3031((
-                    vector_detail::value_at_impl<N::value>(boost::declval<Sequence*>())
-                ))
-            {};
+            struct apply
+            {
+                typedef
+                    decltype(vector_detail::value_at_impl<N::value>(boost::declval<Sequence*>()))
+                type;
+            };
         };
     }
 }}

include/boost/fusion/container/vector/vector.hpp

@@ -168,15 +168,9 @@ namespace boost { namespace fusion
                 : elem(std::forward<U>(rhs))
             {}
 
-            using elem_type = T;
             T elem;
         };
 
-        // placed outside of vector_data due to GCC < 6 bug
-        template <std::size_t J, typename U>
-        static inline BOOST_FUSION_GPU_ENABLED
-        store<J, U> store_at_impl(store<J, U>*);
-
         template <typename I, typename ...T>
         struct vector_data;
 
@@ -237,23 +231,32 @@ namespace boost { namespace fusion
                 assign(std::forward<Sequence>(seq), detail::index_sequence<M...>());
             }
 
-        private:
-            template <std::size_t J>
-            using store_at = decltype(store_at_impl<J>(static_cast<vector_data*>(nullptr)));
+            template <std::size_t N, typename U>
+            static BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+            U& at_detail(store<N, U>* this_)
+            {
+                return this_->elem;
+            }
+
+            template <std::size_t N, typename U>
+            static BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+            U const& at_detail(store<N, U> const* this_)
+            {
+                return this_->elem;
+            }
 
-        public:
             template <typename J>
             BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            typename store_at<J::value>::elem_type& at_impl(J)
+            auto at_impl(J) -> decltype(at_detail<J::value>(&std::declval<vector_data&>()))
             {
-                return store_at<J::value>::elem;
+                return at_detail<J::value>(this);
             }
 
             template <typename J>
             BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            typename store_at<J::value>::elem_type const& at_impl(J) const
+            auto at_impl(J) const -> decltype(at_detail<J::value>(&std::declval<vector_data const&>()))
             {
-                return store_at<J::value>::elem;
+                return at_detail<J::value>(this);
             }
         };
     } // namespace boost::fusion::vector_detail

include/boost/fusion/support/config.hpp

@@ -1,6 +1,6 @@
 /*=============================================================================
     Copyright (c) 2014 Eric Niebler
-    Copyright (c) 2014,2015,2018 Kohei Takahashi
+    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)
@@ -96,35 +96,4 @@ namespace std
 #define BOOST_FUSION_CONSTEXPR_THIS BOOST_CONSTEXPR
 #endif
 
-
-// Workaround for compilers not implementing N3031 (DR743 and DR950).
-#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1913)) || \
-    BOOST_WORKAROUND(BOOST_GCC, < 40700) || \
-    defined(BOOST_CLANG) && (__clang_major__ == 3 && __clang_minor__ == 0)
-# if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
-namespace boost { namespace fusion { namespace detail
-{
-    template <typename T>
-    using type_alias_t = T;
-}}}
-#   define BOOST_FUSION_DECLTYPE_N3031(parenthesized_expr) \
-        boost::fusion::detail::type_alias_t<decltype parenthesized_expr>
-# else
-#   include <boost/mpl/identity.hpp>
-#   define BOOST_FUSION_DECLTYPE_N3031(parenthesized_expr) \
-        boost::mpl::identity<decltype parenthesized_expr>::type
-# endif
-#else
-#   define BOOST_FUSION_DECLTYPE_N3031(parenthesized_expr) \
-        decltype parenthesized_expr
-#endif
-
-
-// Workaround for GCC 4.6 that rejects defaulted function with noexcept.
-#if BOOST_WORKAROUND(BOOST_GCC, / 100 == 406)
-#   define BOOST_FUSION_NOEXCEPT_ON_DEFAULTED
-#else
-#   define BOOST_FUSION_NOEXCEPT_ON_DEFAULTED BOOST_NOEXCEPT
-#endif
-
 #endif

include/boost/fusion/support/detail/and.hpp

@@ -1,6 +1,5 @@
 /*=============================================================================
     Copyright (c) 2016 Lee Clagett
-    Copyright (c) 2018 Kohei Takahashi
 
     Distributed under the Boost Software License, Version 1.0. (See accompanying
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -9,7 +8,6 @@
 #define FUSION_AND_07152016_1625
 
 #include <boost/config.hpp>
-#include <boost/config/workaround.hpp>
 #include <boost/type_traits/integral_constant.hpp>
 
 #if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
@@ -17,8 +15,7 @@
 #endif
 
 namespace boost { namespace fusion { namespace detail {
-#if defined(BOOST_NO_CXX17_FOLD_EXPRESSIONS) \
- || BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1913))
+#if defined(BOOST_NO_CXX17_FOLD_EXPRESSIONS)
     template<typename ...Cond>
     struct and_impl : false_type {};
 

include/boost/fusion/support/detail/is_same_size.hpp

@@ -9,19 +9,20 @@
 
 #include <boost/fusion/support/is_sequence.hpp>
 #include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/core/enable_if.hpp>
 #include <boost/mpl/bool.hpp>
+#include <boost/mpl/equal_to.hpp>
 
 namespace boost { namespace fusion { namespace detail
 {
-    template <typename Sequence1, typename Sequence2, bool
-            = traits::is_sequence<Sequence1>::value &&
-              traits::is_sequence<Sequence2>::value>
+    template <typename Sequence1, typename Sequence2, typename = void, typename = void>
     struct is_same_size : mpl::false_ {};
 
     template <typename Sequence1, typename Sequence2>
-    struct is_same_size<Sequence1, Sequence2, true>
-        : mpl::bool_<result_of::size<Sequence1>::value == 
-                     result_of::size<Sequence2>::value>
+    struct is_same_size<Sequence1, Sequence2,
+                        typename enable_if<traits::is_sequence<Sequence1> >::type,
+                        typename enable_if<traits::is_sequence<Sequence2> >::type>
+        : mpl::equal_to<result_of::size<Sequence1>, result_of::size<Sequence2> >
     {};
 }}}
 

include/boost/fusion/support/is_view.hpp

@@ -14,7 +14,6 @@
 namespace boost { namespace fusion
 {
     // Special tags:
-    struct non_fusion_tag;
     struct sequence_facade_tag;
     struct boost_tuple_tag; // boost::tuples::tuple tag
     struct boost_array_tag; // boost::array tag
@@ -33,13 +32,6 @@ namespace boost { namespace fusion
             };
         };
 
-        template <>
-        struct is_view_impl<non_fusion_tag>
-        {
-            template <typename T>
-            struct apply : mpl::false_ {};
-        };
-
         template <>
         struct is_view_impl<sequence_facade_tag>
         {

include/boost/fusion/support/pair.hpp

@@ -8,15 +8,16 @@
 #if !defined(FUSION_PAIR_07222005_1203)
 #define FUSION_PAIR_07222005_1203
 
-#include <boost/fusion/support/config.hpp>
 #include <iosfwd>
-
+#include <utility>
+#include <boost/fusion/support/config.hpp>
 #include <boost/fusion/support/detail/access.hpp>
 #include <boost/fusion/support/detail/as_fusion_element.hpp>
-#include <boost/config.hpp>
-#include <boost/utility/enable_if.hpp>
+#include <boost/fusion/support/detail/enabler.hpp>
+#include <boost/core/enable_if.hpp>
+#include <boost/type_traits/is_same.hpp>
 #include <boost/type_traits/is_convertible.hpp>
-#include <boost/type_traits/is_lvalue_reference.hpp>
+#include <boost/type_traits/remove_cv_ref.hpp>
 
 #if defined (BOOST_MSVC)
 #  pragma warning(push)
@@ -33,54 +34,46 @@ namespace boost { namespace fusion
         pair()
             : second() {}
 
-        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-        pair(pair const& rhs)
-            : second(rhs.second) {}
-
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-        pair(pair&& rhs)
-            : second(BOOST_FUSION_FWD_ELEM(Second, rhs.second)) {}
-#endif
-
         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
         pair(typename detail::call_param<Second>::type val)
             : second(val) {}
 
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-        template <typename Second2>
         BOOST_FUSION_GPU_ENABLED
-        pair(Second2&& val
-          , typename boost::disable_if<is_lvalue_reference<Second2> >::type* /* dummy */ = 0
-          , typename boost::enable_if<is_convertible<Second2, Second> >::type* /*dummy*/ = 0
-        ) : second(BOOST_FUSION_FWD_ELEM(Second, val)) {}
+        pair(typename remove_cv_ref<Second>::type&& val)
+            : second(BOOST_FUSION_FWD_ELEM(Second, val)) {}
 #endif
 
         template <typename Second2>
         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-        pair(pair<First, Second2> const& rhs)
+        pair(pair<First, Second2> const& rhs,
+             typename disable_if<is_same<Second, Second2>, detail::enabler_>::type = detail::enabler,
+             typename enable_if<is_convertible<Second2, Second>, detail::enabler_>::type = detail::enabler)
             : second(rhs.second) {}
 
         template <typename Second2>
         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-        pair& operator=(pair<First, Second2> const& rhs)
-        {
-            second = rhs.second;
-            return *this;
-        }
-
-        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-        pair& operator=(pair const& rhs)
+        typename disable_if<is_same<Second, Second2>, pair&>::type
+        operator=(pair<First, Second2> const& rhs)
         {
             second = rhs.second;
             return *this;
         }
 
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+        template <typename Second2>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        pair(pair<First, Second2>&& rhs,
+             typename disable_if<is_same<Second, Second2>, detail::enabler_>::type = detail::enabler,
+             typename enable_if<is_convertible<Second2, Second>, detail::enabler_>::type = detail::enabler)
+            : second(std::move(rhs.second)) {}
+
+        template <typename Second2>
         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-        pair& operator=(pair&& rhs)
+        typename disable_if<is_same<Second, Second2>, pair&>::type
+        operator=(pair<First, Second2>&& rhs)
         {
-            second = BOOST_FUSION_FWD_ELEM(Second, rhs.second);
+            second = std::move(rhs.second);
             return *this;
         }
 #endif

include/boost/fusion/support/unused.hpp

@@ -1,6 +1,5 @@
 /*=============================================================================
     Copyright (c) 2001-2011 Joel de Guzman
-    Copyright (c) 2018 Kohei Takahashi
 
     Distributed under the Boost Software License, Version 1.0. (See accompanying
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -11,6 +10,7 @@
 #include <boost/fusion/support/config.hpp>
 #include <iosfwd>
 
+#include <boost/config.hpp>
 #if defined(BOOST_MSVC)
 # pragma warning(push)
 # pragma warning(disable: 4522) // multiple assignment operators specified warning
@@ -23,16 +23,9 @@ namespace boost { namespace fusion
     struct unused_type
     {
         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-        BOOST_DEFAULTED_FUNCTION(
-        unused_type() BOOST_FUSION_NOEXCEPT_ON_DEFAULTED,
+        unused_type() BOOST_NOEXCEPT
         {
-        })
-
-        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-        BOOST_DEFAULTED_FUNCTION(
-        unused_type(unused_type const&) BOOST_FUSION_NOEXCEPT_ON_DEFAULTED,
-        {
-        })
+        }
 
         template <typename T>
         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
@@ -40,12 +33,35 @@ namespace boost { namespace fusion
         {
         }
 
+        template <typename T>
+        BOOST_FUSION_CONSTEXPR_THIS BOOST_FUSION_GPU_ENABLED
+        unused_type const&
+        operator=(T const&) const BOOST_NOEXCEPT
+        {
+            return *this;
+        }
+
+        template <typename T>
+        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        unused_type&
+        operator=(T const&) BOOST_NOEXCEPT
+        {
+            return *this;
+        }
+
         BOOST_FUSION_CONSTEXPR_THIS BOOST_FUSION_GPU_ENABLED
         unused_type const&
         operator=(unused_type const&) const BOOST_NOEXCEPT
         {
             return *this;
         }
+
+        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        unused_type&
+        operator=(unused_type const&) BOOST_NOEXCEPT
+        {
+            return *this;
+        }
     };
 
     BOOST_CONSTEXPR_OR_CONST unused_type unused = unused_type();

include/boost/fusion/view/filter_view/detail/next_impl.hpp

@@ -1,6 +1,5 @@
 /*=============================================================================
     Copyright (c) 2001-2011 Joel de Guzman
-    Copyright (c) 2018 Kohei Takahashi
 
     Distributed under the Boost Software License, Version 1.0. (See accompanying 
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -9,10 +8,14 @@
 #define FUSION_NEXT_IMPL_06052005_0900
 
 #include <boost/fusion/support/config.hpp>
-#include <boost/fusion/iterator/next.hpp>
-#include <boost/fusion/iterator/equal_to.hpp>
+#include <boost/fusion/algorithm/query/detail/find_if.hpp>
+#include <boost/fusion/iterator/value_of.hpp>
 #include <boost/mpl/eval_if.hpp>
 #include <boost/mpl/identity.hpp>
+#include <boost/mpl/lambda.hpp>
+#include <boost/mpl/quote.hpp>
+#include <boost/mpl/bind.hpp>
+#include <boost/mpl/placeholders.hpp>
 
 namespace boost { namespace fusion
 {
@@ -45,13 +48,26 @@ namespace boost { namespace fusion
                     >::type
                 next_type;
 
-                typedef filter_iterator<category, next_type, last_type, pred_type> type;
+                typedef typename
+                    detail::static_find_if<
+                        next_type
+                      , last_type
+                      , mpl::bind1<
+                            typename mpl::lambda<pred_type>::type
+                          , mpl::bind1<mpl::quote1<result_of::value_of>,mpl::_1>
+                        >
+                    >
+                filter;
+
+                typedef filter_iterator<
+                    category, typename filter::type, last_type, pred_type>
+                type;
 
                 BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
                 static type
                 call(Iterator const& i)
                 {
-                    return type(fusion::next(i.first));
+                    return type(filter::iter_call(i.first));
                 }
             };
         };

include/boost/fusion/view/filter_view/filter_view_iterator.hpp

@@ -1,6 +1,5 @@
 /*=============================================================================
     Copyright (c) 2001-2011 Joel de Guzman
-    Copyright (c) 2018 Kohei Takahashi
 
     Distributed under the Boost Software License, Version 1.0. (See accompanying
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -10,6 +9,7 @@
 
 #include <boost/fusion/support/config.hpp>
 #include <boost/fusion/iterator/mpl/convert_iterator.hpp>
+#include <boost/fusion/adapted/mpl/mpl_iterator.hpp>
 #include <boost/fusion/iterator/value_of.hpp>
 #include <boost/fusion/support/iterator_base.hpp>
 #include <boost/fusion/algorithm/query/detail/find_if.hpp>

include/boost/fusion/view/transform_view/detail/apply_transform_result.hpp

@@ -0,0 +1,38 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2007 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_APPLY_TRANSFORM_RESULT_02092006_1936)
+#define BOOST_FUSION_APPLY_TRANSFORM_RESULT_02092006_1936
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/utility/result_of.hpp>
+
+namespace boost { namespace fusion
+{
+    struct void_;
+    
+    namespace detail
+    {
+        template <typename F>
+        struct apply_transform_result
+        {
+            template <typename T0, typename T1 = void_>
+            struct apply
+                : boost::result_of<F(T0, T1)>
+            {};
+
+            template <typename T0>
+            struct apply<T0, void_>
+                : boost::result_of<F(T0)>
+            {};
+        };
+    }
+}}
+
+#endif
+
+

include/boost/fusion/view/transform_view/detail/at_impl.hpp

@@ -1,7 +1,6 @@
 /*=============================================================================
     Copyright (c) 2001-2011 Joel de Guzman
     Copyright (c) 2005-2006 Dan Marsden
-    Copyright (c) 2018 Kohei Takahashi
 
     Distributed under the Boost Software License, Version 1.0. (See accompanying 
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -10,8 +9,9 @@
 #define BOOST_FUSION_AT_IMPL_20061029_1946
 
 #include <boost/fusion/support/config.hpp>
+#include <boost/mpl/apply.hpp>
+#include <boost/fusion/view/transform_view/detail/apply_transform_result.hpp>
 #include <boost/fusion/sequence/intrinsic/at.hpp>
-#include <boost/utility/result_of.hpp>
 
 namespace boost { namespace fusion {
     struct transform_view_tag;
@@ -29,8 +29,9 @@ namespace boost { namespace fusion {
             struct apply
             {
                 typedef typename Seq::transform_type F;
-                typedef typename result_of::at<typename Seq::sequence_type, N>::type value_type;
-                typedef typename boost::result_of<F(value_type)>::type type;
+                typedef detail::apply_transform_result<F> transform_type;
+                typedef typename boost::fusion::result_of::at<typename Seq::sequence_type, N>::type value_type;
+                typedef typename mpl::apply<transform_type, value_type>::type type;
 
                 BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
                 static type call(Seq& seq)
@@ -47,9 +48,10 @@ namespace boost { namespace fusion {
             struct apply
             {
                 typedef typename Seq::transform_type F;
-                typedef typename result_of::at<typename Seq::sequence1_type, N>::type value1_type;
-                typedef typename result_of::at<typename Seq::sequence2_type, N>::type value2_type;
-                typedef typename boost::result_of<F(value1_type, value2_type)>::type type;
+                typedef detail::apply_transform_result<F> transform_type;
+                typedef typename boost::fusion::result_of::at<typename Seq::sequence1_type, N>::type value1_type;
+                typedef typename boost::fusion::result_of::at<typename Seq::sequence2_type, N>::type value2_type;
+                typedef typename mpl::apply<transform_type, value1_type, value2_type>::type type;
 
                 BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
                 static type call(Seq& seq)

include/boost/fusion/view/transform_view/detail/deref_impl.hpp

@@ -1,6 +1,5 @@
 /*=============================================================================
     Copyright (c) 2001-2011 Joel de Guzman
-    Copyright (c) 2018 Kohei Takahashi
 
     Distributed under the Boost Software License, Version 1.0. (See accompanying 
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -9,8 +8,10 @@
 #define FUSION_DEREF_IMPL_07162005_1026
 
 #include <boost/fusion/support/config.hpp>
+#include <boost/mpl/apply.hpp>
 #include <boost/fusion/iterator/deref.hpp>
-#include <boost/utility/result_of.hpp>
+#include <boost/fusion/iterator/value_of.hpp>
+#include <boost/fusion/view/transform_view/detail/apply_transform_result.hpp>
 
 namespace boost { namespace fusion
 {
@@ -33,8 +34,8 @@ namespace boost { namespace fusion
                     result_of::deref<typename Iterator::first_type>::type
                 value_type;
 
-                typedef typename Iterator::transform_type F;
-                typedef typename boost::result_of<F(value_type)>::type type;
+                typedef detail::apply_transform_result<typename Iterator::transform_type> transform_type;
+                typedef typename mpl::apply<transform_type, value_type>::type type;
 
                 BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
                 static type
@@ -59,8 +60,8 @@ namespace boost { namespace fusion
                     result_of::deref<typename Iterator::first2_type>::type
                 value2_type;
 
-                typedef typename Iterator::transform_type F;
-                typedef typename boost::result_of<F(value1_type, value2_type)>::type type;
+                typedef detail::apply_transform_result<typename Iterator::transform_type> transform_type;
+                typedef typename mpl::apply<transform_type, value1_type, value2_type>::type type;
 
                 BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
                 static type
@@ -69,7 +70,7 @@ namespace boost { namespace fusion
                     return i.f(*i.first1, *i.first2);
                 }
             };
-        };
+        };    
     }
 }}
 

include/boost/fusion/view/transform_view/detail/value_at_impl.hpp

@@ -1,7 +1,6 @@
 /*=============================================================================
     Copyright (c) 2001-2011 Joel de Guzman
     Copyright (c) 2005-2006 Dan Marsden
-    Copyright (c) 2018 Kohei Takahashi
 
     Distributed under the Boost Software License, Version 1.0. (See accompanying
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -10,8 +9,9 @@
 #define BOOST_FUSION_VALUE_AT_IMPL_20061101_0745
 
 #include <boost/fusion/support/config.hpp>
+#include <boost/mpl/apply.hpp>
+#include <boost/fusion/view/transform_view/detail/apply_transform_result.hpp>
 #include <boost/fusion/sequence/intrinsic/value_at.hpp>
-#include <boost/utility/result_of.hpp>
 
 namespace boost { namespace fusion {
     struct transform_view_tag;
@@ -29,8 +29,9 @@ namespace boost { namespace fusion {
             struct apply
             {
                 typedef typename Seq::transform_type F;
-                typedef typename result_of::value_at<typename Seq::sequence_type, N>::type value_type;
-                typedef typename boost::result_of<F(value_type)>::type type;
+                typedef detail::apply_transform_result<F> transform_type;
+                typedef typename boost::fusion::result_of::value_at<typename Seq::sequence_type, N>::type value_type;
+                typedef typename mpl::apply<transform_type, value_type>::type type;
             };
         };
 
@@ -41,9 +42,10 @@ namespace boost { namespace fusion {
             struct apply
             {
                 typedef typename Seq::transform_type F;
-                typedef typename result_of::value_at<typename Seq::sequence1_type, N>::type value1_type;
-                typedef typename result_of::value_at<typename Seq::sequence2_type, N>::type value2_type;
-                typedef typename boost::result_of<F(value1_type, value2_type)>::type type;
+                typedef detail::apply_transform_result<F> transform_type;
+                typedef typename boost::fusion::result_of::value_at<typename Seq::sequence1_type, N>::type value1_type;
+                typedef typename boost::fusion::result_of::value_at<typename Seq::sequence2_type, N>::type value2_type;
+                typedef typename mpl::apply<transform_type, value1_type, value2_type>::type type;
             };
         };
     }

include/boost/fusion/view/transform_view/detail/value_of_impl.hpp

@@ -1,6 +1,5 @@
 /*=============================================================================
     Copyright (c) 2001-2011 Joel de Guzman
-    Copyright (c) 2018 Kohei Takahashi
 
     Distributed under the Boost Software License, Version 1.0. (See accompanying 
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -9,8 +8,9 @@
 #define FUSION_VALUE_OF_IMPL_07162005_1030
 
 #include <boost/fusion/support/config.hpp>
+#include <boost/mpl/apply.hpp>
 #include <boost/fusion/iterator/value_of.hpp>
-#include <boost/utility/result_of.hpp>
+#include <boost/fusion/view/transform_view/detail/apply_transform_result.hpp>
 
 namespace boost { namespace fusion
 {
@@ -33,8 +33,8 @@ namespace boost { namespace fusion
                     result_of::value_of<typename Iterator::first_type>::type
                 value_type;
 
-                typedef typename Iterator::transform_type F;
-                typedef typename boost::result_of<F(value_type)>::type type;
+                typedef detail::apply_transform_result<typename Iterator::transform_type> transform_type;
+                typedef typename mpl::apply<transform_type, value_type>::type type;
             };
         };
 
@@ -52,8 +52,8 @@ namespace boost { namespace fusion
                     result_of::value_of<typename Iterator::first2_type>::type
                 value2_type;
 
-                typedef typename Iterator::transform_type F;
-                typedef typename boost::result_of<F(value1_type, value2_type)>::type type;
+                typedef detail::apply_transform_result<typename Iterator::transform_type> transform_type;
+                typedef typename mpl::apply<transform_type, value1_type, value2_type>::type type;
             };
         };
     }

meta/explicit-failures-markup.xml

@@ -9,8 +9,8 @@
             <toolset name="msvc-11.0"/>
             <toolset name="msvc-12.0"/>
             <toolset name="qcc-4.4.2_x86"/>
-            <toolset name="gcc-4.4~c++0x*"/>
-            <toolset name="gcc-4.4~gnu0x*"/>
+            <toolset name="gcc-gnu-4.4~c++0x*"/>
+            <toolset name="gcc-gnu-4.4~gnu0x*"/>
             <note author="Kohei Takahashi">
                 The compiler doesn't generate defaulted move ctor/assgin thus
                 perform copy construction/assginment. Even though such case,

test/Jamfile

@@ -66,7 +66,6 @@ project
     [ run algorithm/zip2.cpp ]
     [ run algorithm/zip_ignore.cpp ]
     [ run algorithm/flatten.cpp ]
-    [ compile algorithm/ticket-5490.cpp ]
 
     [ run sequence/as_deque.cpp ]
     [ run sequence/as_list.cpp ]
@@ -238,7 +237,6 @@ project
     [ run sequence/ref_vector.cpp ]
     [ run sequence/flatten_view.cpp ]
     [ compile sequence/github-159.cpp ]
-    [ run sequence/github-176.cpp ]
 
     [ compile sequence/size.cpp ]
 
@@ -257,7 +255,7 @@ project
     [ run sequence/swap.cpp ]
 
     [ compile support/is_sequence.cpp ]
-    [ compile support/is_view.cpp ]
+    [ compile support/pair_conversion.cpp ]
     [ compile support/pair_deque.cpp ]
     [ compile support/pair_list.cpp ]
     [ compile support/pair_map.cpp ]
@@ -269,7 +267,8 @@ project
     [ compile support/and.cpp
         : [ requires cxx11_variadic_templates ] ]
     [ compile support/tag_of.cpp ]
-    [ compile support/unused.cpp ]
+    [ compile support/pair_trivially_copyable.cpp
+        : [ requires cxx11_hdr_type_traits ] ]
 
 #   [ compile-fail xxx.cpp  ]
 

test/algorithm/for_each.cpp

@@ -1,15 +1,13 @@
 /*=============================================================================
     Copyright (c) 2001-2011 Joel de Guzman
-    Copyright (c) 2018 Kohei Takahashi
 
     Distributed under the Boost Software License, Version 1.0. (See accompanying 
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 ==============================================================================*/
-#include <boost/core/lightweight_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 #include <boost/fusion/container/vector/vector.hpp>
 #include <boost/fusion/adapted/mpl.hpp>
 #include <boost/fusion/sequence/io/out.hpp>
-#include <boost/fusion/sequence/comparison/equal_to.hpp>
 #include <boost/fusion/algorithm/iteration/for_each.hpp>
 #include <boost/mpl/vector_c.hpp>
 
@@ -31,15 +29,6 @@ struct increment
     }
 };
 
-struct mutable_increment : increment
-{
-    template <typename T>
-    void operator()(T& v)
-    {
-        return increment::operator()(v);
-    }
-};
-
 int
 main()
 {
@@ -55,20 +44,9 @@ main()
     }
 
     {
-        char const ruby[] = "Ruby";
         typedef vector<int, char, double, char const*> vector_type;
-        vector_type v(1, 'x', 3.3, ruby);
+        vector_type v(1, 'x', 3.3, "Ruby");
         for_each(v, increment());
-        BOOST_TEST_EQ(v, vector_type(2, 'y', 4.3, ruby + 1));
-        std::cout << v << std::endl;
-    }
-
-    {
-        char const ruby[] = "Ruby";
-        typedef vector<int, char, double, char const*> vector_type;
-        vector_type v(1, 'x', 3.3, ruby);
-        for_each(v, mutable_increment());
-        BOOST_TEST_EQ(v, vector_type(2, 'y', 4.3, ruby + 1));
         std::cout << v << std::endl;
     }
 

test/algorithm/segmented_for_each.cpp

@@ -1,17 +1,14 @@
 /*=============================================================================
     Copyright (c) 2001-2011 Joel de Guzman
     Copyright (c) 2011 Eric Niebler
-    Copyright (c) 2018 Kohei Takahashi
 
     Distributed under the Boost Software License, Version 1.0. (See accompanying 
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 ==============================================================================*/
-#include <boost/core/lightweight_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 #include <boost/fusion/container/vector/vector.hpp>
-#include <boost/fusion/container/generation/make_vector.hpp>
 #include <boost/fusion/algorithm/iteration/for_each.hpp>
-#include <boost/fusion/sequence/comparison/equal_to.hpp>
-#include <boost/fusion/sequence/io/out.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
 #include "../sequence/tree.hpp"
 
 struct print
@@ -23,31 +20,6 @@ struct print
     }
 };
 
-struct increment
-{
-    template <typename T>
-    void operator()(T& v) const
-    {
-        ++v;
-    }
-};
-
-struct mutable_increment : increment
-{
-    template <typename T>
-    void operator()(T& v)
-    {
-        return increment::operator()(v);
-    }
-};
-
-template <typename F, typename Tree>
-void test(Tree tree, Tree const& expected)
-{
-    boost::fusion::for_each(tree, F());
-    BOOST_TEST_EQ(tree, expected);
-}
-
 int
 main()
 {
@@ -70,69 +42,6 @@ main()
             )
           , print()
         );
-        std::cout << std::endl;
-    }
-
-    {
-        test<increment>(
-            make_tree(
-                make_vector(double(0),'B')
-              , make_tree(
-                    make_vector(1,2,long(3))
-                  , make_tree(make_vector('a','b','c'))
-                  , make_tree(make_vector(short('d'),'e','f'))
-                )
-              , make_tree(
-                    make_vector(4,5,6)
-                  , make_tree(make_vector(float(1),'h','i'))
-                  , make_tree(make_vector('j','k','l'))
-                )
-            )
-          , make_tree(
-                make_vector(double(1),'C')
-              , make_tree(
-                    make_vector(2,3,long(4))
-                  , make_tree(make_vector('b','c','d'))
-                  , make_tree(make_vector(short('e'),'f','g'))
-                )
-              , make_tree(
-                    make_vector(5,6,7)
-                  , make_tree(make_vector(float(2),'i','j'))
-                  , make_tree(make_vector('k','l','m'))
-                )
-            )
-        );
-    }
-
-    {
-        test<mutable_increment>(
-            make_tree(
-                make_vector(double(0),'B')
-              , make_tree(
-                    make_vector(1,2,long(3))
-                  , make_tree(make_vector('a','b','c'))
-                  , make_tree(make_vector(short('d'),'e','f'))
-                )
-              , make_tree(
-                    make_vector(4,5,6)
-                  , make_tree(make_vector(float(1),'h','i'))
-                  , make_tree(make_vector('j','k','l'))
-                )
-            )
-          , make_tree(
-                make_vector(double(1),'C')
-              , make_tree(
-                    make_vector(2,3,long(4))
-                  , make_tree(make_vector('b','c','d'))
-                  , make_tree(make_vector(short('e'),'f','g'))
-                )
-              , make_tree(
-                    make_vector(5,6,7)
-                  , make_tree(make_vector(float(2),'i','j'))
-                  , make_tree(make_vector('k','l','m'))
-                )
-            )
-        );
     }
 
     return boost::report_errors();

test/algorithm/ticket-5490.cpp

@@ -1,41 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2018 Kohei Takahashi
-
-    Distributed under the Boost Software License, Version 1.0. (See accompanying 
-    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-==============================================================================*/
-#include <boost/fusion/include/vector.hpp>
-#include <boost/fusion/include/transform.hpp>
-#include <boost/mpl/quote.hpp>
-#include <boost/mpl/placeholders.hpp>
-#include <boost/core/ignore_unused.hpp>
-
-using namespace boost::fusion;
-
-template <typename>
-struct predicate {};
-
-struct unique {};
-
-template <typename>
-struct meta_func
-{
-    typedef unique result_type;
-
-    template <typename T>
-    unique operator()(const T&) const;
-};
-
-int main()
-{
-    vector<int> v;
-
-    typedef predicate<boost::mpl::_1> lambda_t;
-    typedef boost::mpl::quote1<predicate> quote_t;
-
-    vector<unique> l = transform(v, meta_func<lambda_t>());
-
-    vector<unique> q = transform(v, meta_func<quote_t>());
-
-    boost::ignore_unused(l, q);
-}

test/sequence/adapt_adt.cpp

@@ -165,7 +165,6 @@ main()
 
     {
         BOOST_MPL_ASSERT_NOT((traits::is_view<ns::point>));
-        BOOST_STATIC_ASSERT(!traits::is_view<ns::point>::value);
         ns::point p(123, 456, 789);
 
         std::cout << at_c<0>(p) << std::endl;
@@ -238,7 +237,6 @@ main()
 #if !BOOST_WORKAROUND(__GNUC__,<4)
     {
         BOOST_MPL_ASSERT_NOT((traits::is_view<ns::point_with_private_members>));
-        BOOST_STATIC_ASSERT(!traits::is_view<ns::point_with_private_members>::value);
         ns::point_with_private_members p(123, 456, 789);
 
         std::cout << at_c<0>(p) << std::endl;
@@ -302,7 +300,7 @@ main()
         BOOST_MPL_ASSERT((
             boost::is_same<
                 boost::fusion::result_of::back<ns::point const>::type::type,
-                int
+                const int
             >));
     }
 

test/sequence/adapt_adt_empty.cpp

@@ -42,7 +42,6 @@ main()
 
     {
         BOOST_MPL_ASSERT_NOT((traits::is_view<empty_adt>));
-        BOOST_STATIC_ASSERT(!traits::is_view<empty_adt>::value);
         empty_adt e;
 
         std::cout << e << std::endl;

test/sequence/adapt_adt_named.cpp

@@ -93,7 +93,6 @@ main()
 
     {
         BOOST_MPL_ASSERT((traits::is_view<adapted::point>));
-        BOOST_STATIC_ASSERT(traits::is_view<adapted::point>::value);
         ns::point basep(123, 456, 789);
         adapted::point p(basep);
 

test/sequence/adapt_adt_named_empty.cpp

@@ -43,7 +43,6 @@ main()
     empty_adt empty;
     {
         BOOST_MPL_ASSERT((traits::is_view<adapted::empty_adt>));
-        BOOST_STATIC_ASSERT(traits::is_view<adapted::empty_adt>::value);
         adapted::empty_adt e(empty);
 
         std::cout << e << std::endl;

test/sequence/adapt_assoc_adt.cpp

@@ -84,7 +84,6 @@ main()
 
     {
         BOOST_MPL_ASSERT_NOT((traits::is_view<ns::point>));
-        BOOST_STATIC_ASSERT(!traits::is_view<ns::point>::value);
         ns::point p(123, 456, 789);
 
         std::cout << at_c<0>(p) << std::endl;

test/sequence/adapt_assoc_adt_empty.cpp

@@ -42,7 +42,6 @@ main()
 
     {
         BOOST_MPL_ASSERT_NOT((traits::is_view<empty_adt>));
-        BOOST_STATIC_ASSERT(!traits::is_view<empty_adt>::value);
         empty_adt e;
 
         std::cout << e << std::endl;

test/sequence/adapt_assoc_adt_named.cpp

@@ -80,7 +80,6 @@ main()
 
     {
         BOOST_MPL_ASSERT((traits::is_view<adapted::point>));
-        BOOST_STATIC_ASSERT(traits::is_view<adapted::point>::value);
         ns::point basep(123, 456);
         adapted::point p(basep);
 

test/sequence/adapt_assoc_adt_named_empty.cpp

@@ -43,7 +43,6 @@ main()
     empty_adt empty;
     {
         BOOST_MPL_ASSERT((traits::is_view<adapted::empty_adt>));
-        BOOST_STATIC_ASSERT(traits::is_view<adapted::empty_adt>::value);
         adapted::empty_adt e(empty);
 
         std::cout << e << std::endl;

test/sequence/adapt_assoc_struct.cpp

@@ -72,7 +72,7 @@ namespace ns
 #endif
 
 struct empty_struct {};
-BOOST_FUSION_ADAPT_ASSOC_STRUCT(empty_struct,)
+BOOST_FUSION_ADAPT_ASSOC_STRUCT(empty_struct,); 
 
 int
 main()
@@ -86,7 +86,6 @@ main()
 
     {
         BOOST_MPL_ASSERT_NOT((traits::is_view<ns::point>));
-        BOOST_STATIC_ASSERT(!traits::is_view<ns::point>::value);
         ns::point p = {123, 456, 789};
 
         std::cout << at_c<0>(p) << std::endl;

test/sequence/adapt_assoc_struct_empty.cpp

@@ -42,7 +42,6 @@ main()
 
     {
         BOOST_MPL_ASSERT_NOT((traits::is_view<empty_struct>));
-        BOOST_STATIC_ASSERT(!traits::is_view<empty_struct>::value);
         empty_struct e;
 
         std::cout << e << std::endl;

test/sequence/adapt_assoc_struct_named.cpp

@@ -53,7 +53,7 @@ namespace ns
 #endif
 
 struct empty_struct {};
-BOOST_FUSION_ADAPT_ASSOC_STRUCT_NAMED(empty_struct, renamed_empty_struct,)
+BOOST_FUSION_ADAPT_ASSOC_STRUCT_NAMED(empty_struct, renamed_empty_struct,); 
 
 int
 main()
@@ -66,7 +66,6 @@ main()
 
     {
         BOOST_MPL_ASSERT((traits::is_view<adapted::point>));
-        BOOST_STATIC_ASSERT(traits::is_view<adapted::point>::value);
         ns::point basep = {123, 456};
         adapted::point p(basep);
 

test/sequence/adapt_assoc_struct_named_empty.cpp

@@ -43,7 +43,6 @@ main()
     empty_struct empty;
     {
         BOOST_MPL_ASSERT((traits::is_view<adapted::empty_struct>));
-        BOOST_STATIC_ASSERT(traits::is_view<adapted::empty_struct>::value);
         adapted::empty_struct e(empty);
 
         std::cout << e << std::endl;

test/sequence/adapt_assoc_tpl_adt.cpp

@@ -98,7 +98,6 @@ main()
 
     {
         BOOST_MPL_ASSERT_NOT((traits::is_view<point>));
-        BOOST_STATIC_ASSERT(!traits::is_view<point>::value);
         point p(123, 456, 789);
 
         std::cout << at_c<0>(p) << std::endl;

test/sequence/adapt_assoc_tpl_struct.cpp

@@ -96,7 +96,6 @@ main()
 
     {
         BOOST_MPL_ASSERT_NOT((traits::is_view<point>));
-        BOOST_STATIC_ASSERT(!traits::is_view<point>::value);
         point p = {123, 456, 789.43f};
 
         std::cout << at_c<0>(p) << std::endl;

test/sequence/adapt_struct.cpp

@@ -170,7 +170,6 @@ main()
 
     {
         BOOST_MPL_ASSERT_NOT((traits::is_view<point>));
-        BOOST_STATIC_ASSERT(!traits::is_view<point>::value);
         point p = {123, 456, 789};
 
         std::cout << at_c<0>(p) << std::endl;

test/sequence/adapt_struct_empty.cpp

@@ -42,7 +42,6 @@ main()
 
     {
         BOOST_MPL_ASSERT_NOT((traits::is_view<empty_struct>));
-        BOOST_STATIC_ASSERT(!traits::is_view<empty_struct>::value);
         empty_struct e;
 
         std::cout << e << std::endl;

test/sequence/adapt_struct_named.cpp

@@ -87,7 +87,6 @@ main()
 
     {
         BOOST_MPL_ASSERT((traits::is_view<adapted::point>));
-        BOOST_STATIC_ASSERT(traits::is_view<adapted::point>::value);
         ns::point basep = {123, 456, 789};
         adapted::point p(basep);
 

test/sequence/adapt_struct_named_empty.cpp

@@ -43,7 +43,6 @@ main()
     empty_struct empty;
     {
         BOOST_MPL_ASSERT((traits::is_view<adapted::empty_struct>));
-        BOOST_STATIC_ASSERT(traits::is_view<adapted::empty_struct>::value);
         adapted::empty_struct e(empty);
 
         std::cout << e << std::endl;

test/sequence/adapt_tpl_adt.cpp

@@ -107,7 +107,6 @@ main()
 
     {
         BOOST_MPL_ASSERT_NOT((traits::is_view<point>));
-        BOOST_STATIC_ASSERT(!traits::is_view<point>::value);
         point p(123, 456, 789);
 
         std::cout << at_c<0>(p) << std::endl;

test/sequence/adapt_tpl_struct.cpp

@@ -96,7 +96,6 @@ main()
 
     {
         BOOST_MPL_ASSERT_NOT((traits::is_view<point>));
-        BOOST_STATIC_ASSERT(!traits::is_view<point>::value);
         point p = {123, 456, 789};
 
         std::cout << at_c<0>(p) << std::endl;

test/sequence/adt_attribute_proxy.cpp

@@ -5,7 +5,7 @@
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 ==============================================================================*/
 
-#include <boost/core/lightweight_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 #include <boost/fusion/adapted/adt/adapt_assoc_adt.hpp>
 #include <boost/fusion/sequence.hpp>
 #include <boost/mpl/assert.hpp>
@@ -185,5 +185,4 @@ int main()
         BOOST_TEST(fusion::front(ec).get()=="marshall mathers");
         BOOST_TEST(fusion::back(ec).get()==37);
     }
-    return boost::report_errors();
 }

test/sequence/array.cpp

@@ -22,8 +22,6 @@ int main()
 
     BOOST_MPL_ASSERT((traits::is_sequence<array_type>));
     BOOST_MPL_ASSERT_NOT((traits::is_view<array_type>));
-    BOOST_STATIC_ASSERT(traits::is_sequence<array_type>::value);
-    BOOST_STATIC_ASSERT(!traits::is_view<array_type>::value);
 
     array_type arr = {1,2,3};
 

test/sequence/boost_array.cpp

@@ -26,8 +26,6 @@ int main()
 
     BOOST_MPL_ASSERT((traits::is_sequence<array_type>));
     BOOST_MPL_ASSERT_NOT((traits::is_view<array_type>));
-    BOOST_STATIC_ASSERT(traits::is_sequence<array_type>::value);
-    BOOST_STATIC_ASSERT(!traits::is_view<array_type>::value);
 
     array_type arr = {{1,2,3}};
 

test/sequence/boost_tuple.cpp

@@ -46,7 +46,6 @@ main()
     {
         typedef boost::tuple<int, std::string> tuple_type;
         BOOST_MPL_ASSERT_NOT((traits::is_view<tuple_type>));
-        BOOST_STATIC_ASSERT(!traits::is_view<tuple_type>::value);
         tuple_type t(123, "Hola!!!");
 
         std::cout << at_c<0>(t) << std::endl;

test/sequence/construction.hpp

@@ -54,14 +54,11 @@ test()
     using namespace test_detail;
 
     nil empty;
-    (void)empty;
 
     FUSION_SEQUENCE<> empty0;
-    (void)empty0;
 
 #ifndef NO_CONSTRUCT_FROM_NIL
     FUSION_SEQUENCE<> empty1(empty);
-    (void)empty1;
 #endif
 
     FUSION_SEQUENCE<int> t1;

test/sequence/define_assoc_struct.cpp

@@ -42,7 +42,6 @@ main()
 
     {
         BOOST_MPL_ASSERT_NOT((traits::is_view<ns::point>));
-        BOOST_STATIC_ASSERT(!traits::is_view<ns::point>::value);
         ns::point p(123, 456);
 
         std::cout << at_c<0>(p) << std::endl;

test/sequence/define_assoc_struct_empty.cpp

@@ -30,7 +30,6 @@ main()
 
     {
         BOOST_MPL_ASSERT_NOT((traits::is_view<empty_struct>));
-        BOOST_STATIC_ASSERT(!traits::is_view<empty_struct>::value);
         empty_struct e;
 
         std::cout << e << std::endl;

test/sequence/define_assoc_tpl_struct.cpp

@@ -46,7 +46,6 @@ main()
 
     {
         BOOST_MPL_ASSERT_NOT((traits::is_view<point>));
-        BOOST_STATIC_ASSERT(!traits::is_view<point>::value);
         point p(123, 456);
 
         std::cout << at_c<0>(p) << std::endl;

test/sequence/define_assoc_tpl_struct_empty.cpp

@@ -30,7 +30,6 @@ main()
 
     {
         BOOST_MPL_ASSERT_NOT((traits::is_view<empty_struct<void> >));
-        BOOST_STATIC_ASSERT(!traits::is_view<empty_struct<void> >::value);
         empty_struct<void> e;
 
         std::cout << e << std::endl;

test/sequence/define_struct.cpp

@@ -54,7 +54,6 @@ main()
 
     {
         BOOST_MPL_ASSERT_NOT((traits::is_view<ns::point>));
-        BOOST_STATIC_ASSERT(!traits::is_view<ns::point>::value);
         ns::point p(123, 456);
 
         std::cout << at_c<0>(p) << std::endl;

test/sequence/define_struct_empty.cpp

@@ -30,7 +30,6 @@ main()
 
     {
         BOOST_MPL_ASSERT_NOT((traits::is_view<empty_struct>));
-        BOOST_STATIC_ASSERT(!traits::is_view<empty_struct>::value);
         empty_struct e;
 
         std::cout << e << std::endl;

test/sequence/define_struct_inline.cpp

@@ -66,7 +66,6 @@ void run_test()
     
     {
         BOOST_MPL_ASSERT_NOT((traits::is_view<Point>));
-        BOOST_STATIC_ASSERT(!traits::is_view<Point>::value);
         Point p(123, 456);
 
         std::cout << at_c<0>(p) << std::endl;

test/sequence/define_struct_inline_empty.cpp

@@ -30,7 +30,6 @@ main()
 
     {
         BOOST_MPL_ASSERT_NOT((traits::is_view<empty_struct>));
-        BOOST_STATIC_ASSERT(!traits::is_view<empty_struct>::value);
         empty_struct e;
 
         std::cout << e << std::endl;

test/sequence/define_struct_inline_move.cpp

@@ -47,8 +47,8 @@ int main()
         BOOST_TEST(y.w.value == 42);
     }
 
-    // Older MSVCs and gcc 4.4 don't generate move ctor by default.
-#if !(defined(CI_SKIP_KNOWN_FAILURE) && (BOOST_WORKAROUND(BOOST_MSVC, < 1900) || BOOST_WORKAROUND(BOOST_GCC, / 100 == 404)))
+    // Older MSVCs don't generate move ctor by default.
+#if !(defined(CI_SKIP_KNOWN_FAILURE) && BOOST_WORKAROUND(BOOST_MSVC, < 1900))
     {
         ns::value x;
         ns::value y(std::move(x)); // move
@@ -66,7 +66,7 @@ int main()
         BOOST_TEST(x.w.value == 0);
         BOOST_TEST(y.w.value == 0);
     }
-#endif // !(ci && (msvc < 14.0 || gcc 4.4.x))
+#endif // !(ci && msvc < 14.0)
 
     return boost::report_errors();
 }

test/sequence/define_tpl_struct.cpp

@@ -42,7 +42,6 @@ main()
 
     {
         BOOST_MPL_ASSERT_NOT((traits::is_view<point>));
-        BOOST_STATIC_ASSERT(!traits::is_view<point>::value);
         point p(123, 456);
 
         std::cout << at_c<0>(p) << std::endl;

test/sequence/define_tpl_struct_inline.cpp

@@ -61,7 +61,6 @@ void run_test()
     
     {
         BOOST_MPL_ASSERT_NOT((traits::is_view<Point>));
-        BOOST_STATIC_ASSERT(!traits::is_view<Point>::value);
         Point p(123, 456);
 
         std::cout << at_c<0>(p) << std::endl;

test/sequence/define_tpl_struct_inline_move.cpp

@@ -47,8 +47,8 @@ int main()
         BOOST_TEST(y.w.value == 42);
     }
 
-    // Older MSVCs and gcc 4.4 don't generate move ctor by default.
-#if !(defined(CI_SKIP_KNOWN_FAILURE) && (BOOST_WORKAROUND(BOOST_MSVC, < 1900) || BOOST_WORKAROUND(BOOST_GCC, / 100 == 404)))
+    // Older MSVCs don't generate move ctor by default.
+#if !(defined(CI_SKIP_KNOWN_FAILURE) && BOOST_WORKAROUND(BOOST_MSVC, < 1900))
     {
         ns::value<wrapper> x;
         ns::value<wrapper> y(std::move(x)); // move
@@ -66,7 +66,7 @@ int main()
         BOOST_TEST(x.w.value == 0);
         BOOST_TEST(y.w.value == 0);
     }
-#endif // !(ci && (msvc < 14.0 || gcc 4.4.x))
+#endif // !(ci && msvc < 14.0)
 
     return boost::report_errors();
 }

test/sequence/github-176.cpp

@@ -1,90 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2018 Kohei Takahashi
-
-    Distributed under the Boost Software License, Version 1.0. (See accompanying
-    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-==============================================================================*/
-
-#include <boost/fusion/sequence/intrinsic/at.hpp>
-#include <boost/fusion/sequence/intrinsic/at_key.hpp>
-#include <boost/fusion/container/vector.hpp>
-#include <boost/fusion/container/list.hpp>
-#include <boost/fusion/container/deque.hpp>
-#include <boost/fusion/container/map.hpp>
-#include <boost/fusion/container/set.hpp>
-#include <boost/fusion/tuple/tuple.hpp>
-#include <boost/core/lightweight_test.hpp>
-
-template <typename Sequence>
-void test_at()
-{
-    Sequence seq;
-
-    // zero initialized
-    BOOST_TEST(boost::fusion::at_c<0>(seq)[0] == 0);
-    BOOST_TEST(boost::fusion::at_c<0>(seq)[1] == 0);
-    BOOST_TEST(boost::fusion::at_c<0>(seq)[2] == 0);
-
-    int (&arr)[3] = boost::fusion::deref(boost::fusion::begin(seq));
-
-    arr[0] = 2;
-    arr[1] = 4;
-    arr[2] = 6;
-
-    BOOST_TEST(boost::fusion::at_c<0>(seq)[0] == 2);
-    BOOST_TEST(boost::fusion::at_c<0>(seq)[1] == 4);
-    BOOST_TEST(boost::fusion::at_c<0>(seq)[2] == 6);
-
-    boost::fusion::at_c<0>(seq)[1] = 42;
-
-    BOOST_TEST(boost::fusion::at_c<0>(seq)[0] == 2);
-    BOOST_TEST(boost::fusion::at_c<0>(seq)[1] == 42);
-    BOOST_TEST(boost::fusion::at_c<0>(seq)[2] == 6);
-}
-
-template <typename T> inline T& value(T& v) { return v; }
-template <typename K, typename T> inline T& value(boost::fusion::pair<K, T>& v) { return v.second; }
-
-template <typename Sequence>
-void test_at_key()
-{
-    Sequence seq;
-
-    // zero initialized
-    BOOST_TEST(boost::fusion::at_key<int[3]>(seq)[0] == 0);
-    BOOST_TEST(boost::fusion::at_key<int[3]>(seq)[1] == 0);
-    BOOST_TEST(boost::fusion::at_key<int[3]>(seq)[2] == 0);
-
-    int (&arr)[3] = value(boost::fusion::deref(boost::fusion::begin(seq)));
-
-    arr[0] = 2;
-    arr[1] = 4;
-    arr[2] = 6;
-
-    BOOST_TEST(boost::fusion::at_key<int[3]>(seq)[0] == 2);
-    BOOST_TEST(boost::fusion::at_key<int[3]>(seq)[1] == 4);
-    BOOST_TEST(boost::fusion::at_key<int[3]>(seq)[2] == 6);
-
-    boost::fusion::at_key<int[3]>(seq)[1] = 42;
-
-    BOOST_TEST(boost::fusion::at_key<int[3]>(seq)[0] == 2);
-    BOOST_TEST(boost::fusion::at_key<int[3]>(seq)[1] == 42);
-    BOOST_TEST(boost::fusion::at_key<int[3]>(seq)[2] == 6);
-}
-
-int main()
-{
-    using namespace boost::fusion;
-
-    test_at<vector<int[3]> >();
-    test_at<deque<int[3]> >();
-    test_at<list<int[3]> >();
-    test_at<tuple<int[3]> >();
-
-#if !BOOST_WORKAROUND(BOOST_GCC, / 100 == 406) || defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS)
-    // FIXME: gcc 4.6 w/ c++0x doesn't like set with array...
-    test_at_key<set<int[3]> >();
-#endif
-    test_at_key<map<pair<int[3], int[3]> > >();
-    return boost::report_errors();
-}

test/sequence/hash.cpp

@@ -7,7 +7,7 @@
 
 #include <string>
 
-#include <boost/core/lightweight_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 #include <boost/fusion/include/adapt_struct.hpp>
 #include <boost/fusion/sequence/hash.hpp>
 
@@ -55,5 +55,4 @@ int main()
     BOOST_TEST(hash_value(c) != hash_value(d));
     BOOST_TEST(hash_value(c) != hash_value(e));
     BOOST_TEST(hash_value(d) != hash_value(e));
-    return boost::report_errors();
 }

test/sequence/hash.hpp

@@ -1,6 +1,5 @@
 /*=============================================================================
     Copyright (c) 2014 Christoph Weiss
-    Copyright (c) 2017 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,24 +11,24 @@
 #include <boost/fusion/sequence/hash.hpp>
 #include <boost/functional/hash.hpp>
 
-void hash_test()
+void
+hash_test()
 {
-    namespace fusion = boost::fusion;
-    using namespace fusion;
+    using namespace boost::fusion;
 
     const FUSION_SEQUENCE<int, char, bool, std::string> v0(42, 'x', false, "Aurea prima");
     const FUSION_SEQUENCE<int, char, bool, std::string> v1(42, 'x', false, "Aurea prima");
-    BOOST_TEST(fusion::hash_value(v0) == fusion::hash_value(v1));
-
+    BOOST_TEST(hash_value(v0) == hash_value(v1));
+    
     const FUSION_SEQUENCE<int, char, bool, std::string> w(41, 'x', false, "Aurea prima");
-    BOOST_TEST(fusion::hash_value(w) != fusion::hash_value(v0));
-
+    BOOST_TEST(hash_value(w) != hash_value(v0));
+    
     const FUSION_SEQUENCE<int, char, bool, std::string> x(42, 'y', false, "Aurea prima");
-    BOOST_TEST(fusion::hash_value(x) != fusion::hash_value(v0));
-
+    BOOST_TEST(hash_value(x) != hash_value(v0));
+    
     const FUSION_SEQUENCE<int, char, bool, std::string> y(42, 'x', true, "Aurea prima");
-    BOOST_TEST(fusion::hash_value(y) != fusion::hash_value(v0));
-
+    BOOST_TEST(hash_value(y) != hash_value(v0));
+    
     const FUSION_SEQUENCE<int, char, bool, std::string> z(42, 'x', false, "quae vindice nullo");
-    BOOST_TEST(fusion::hash_value(z) != fusion::hash_value(v0));
+    BOOST_TEST(hash_value(z) != hash_value(v0));
 }

test/sequence/map_construction.cpp

@@ -55,14 +55,11 @@ test()
     using namespace test_detail;
 
     nil empty;
-    (void)empty;
 
     map<> empty0;
-    (void)empty0;
 
 #ifndef NO_CONSTRUCT_FROM_NIL
     map<> empty1(empty);
-    (void)empty1;
 #endif
 
     map<pair<key1, int> > t1;

test/sequence/set.cpp

@@ -89,9 +89,6 @@ main()
         BOOST_MPL_ASSERT((traits::is_sequence<t1>));
         BOOST_MPL_ASSERT((traits::is_sequence<t2>));
         BOOST_MPL_ASSERT((traits::is_sequence<t3>));
-        BOOST_STATIC_ASSERT(traits::is_sequence<t1>::value);
-        BOOST_STATIC_ASSERT(traits::is_sequence<t2>::value);
-        BOOST_STATIC_ASSERT(traits::is_sequence<t3>::value);
     }
 
     {   // testing mpl::is_sequence

test/sequence/std_array.cpp

@@ -33,8 +33,6 @@ int main()
 
     BOOST_MPL_ASSERT((traits::is_sequence<array_type>));
     BOOST_MPL_ASSERT_NOT((traits::is_view<array_type>));
-    BOOST_STATIC_ASSERT(traits::is_sequence<array_type>::value);
-    BOOST_STATIC_ASSERT(!traits::is_view<array_type>::value);
 
     array_type arr = {{1,2,3}};
 

test/sequence/std_pair.cpp

@@ -44,7 +44,6 @@ main()
     {
         typedef std::pair<int, std::string> pair_type;
         BOOST_MPL_ASSERT_NOT((traits::is_view<pair_type>));
-        BOOST_STATIC_ASSERT(!traits::is_view<pair_type>::value);
         pair_type p(123, "Hola!!!");
 
         std::cout << at_c<0>(p) << std::endl;

test/sequence/traits.hpp

@@ -1,6 +1,5 @@
 /*=============================================================================
     Copyright (C) 2016 Lee Clagett
-    Copyright (C) 2018 Kohei Takahashi
 
     Distributed under the Boost Software License, Version 1.0. (See accompanying
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -39,7 +38,9 @@ bool is_convertible(bool has_conversion)
 }
 
 // is_constructible has a few requirements
-#ifdef BOOST_TT_IS_CONSTRUCTIBLE_CONFORMING
+#if !defined(BOOST_NO_CXX11_DECLTYPE) &&   \
+    !defined(BOOST_NO_CXX11_TEMPLATES) &&  \
+    !defined(BOOST_NO_SFINAE_EXPR)
 
 #define FUSION_TEST_HAS_CONSTRUCTIBLE
 
@@ -87,9 +88,7 @@ void test_constructible()
     BOOST_TEST((
         is_constructible<FUSION_SEQUENCE<convertible>, convertible>(true)
     ));
-
-    // boost::is_constructible always fail to test ctor which takes 2 or more arguments on GCC 4.7.
-#if !BOOST_WORKAROUND(BOOST_GCC, < 40700)
+        
     BOOST_TEST((
         is_constructible<FUSION_SEQUENCE<int, int>, int, int>(true)
     ));
@@ -132,7 +131,6 @@ void test_constructible()
             FUSION_SEQUENCE<convertible, convertible>, convertible, convertible
         >(true)
     ));
-#endif // !(gcc < 4.7)
 }
 
 #endif // is_constructible is available

test/sequence/tuple_traits.cpp

@@ -65,13 +65,10 @@ main()
     BOOST_TEST((is_constructible<tuple<int>, int, int>(false)));
 
     BOOST_TEST((is_constructible< tuple<int, int> >(true)));
-    // boost::is_constructible always fail to test ctor which takes 2 or more arguments on GCC 4.7.
-#if !BOOST_WORKAROUND(BOOST_GCC, < 40700)
     BOOST_TEST((is_constructible<tuple<int, int>, int, int>(true)));
     BOOST_TEST((
         is_constructible<tuple<convertible, convertible>, int, int>(true)
     ));
-#endif // !(gcc < 4.7)
     BOOST_TEST((is_constructible<tuple<int, not_convertible>, int, int>(false)));
     BOOST_TEST((is_constructible<tuple<not_convertible, int>, int, int>(false)));
     BOOST_TEST((

test/sequence/vector_n.cpp

@@ -94,7 +94,7 @@ main()
     }
 
     {
-        vector2<int, short> t1(123, 456);
+        vector2<int, int> t1(123, 456);
         vector2<double, float> t2(t1);
         (void)t2;
     }

test/support/is_view.cpp

@@ -1,15 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2018 Nikita Kniazev
-
-    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/fusion/support/is_view.hpp>
-#include <boost/static_assert.hpp>
-
-
-// Make sure fusion::is_view can be used with non fusion types.
-struct incomplete;
-BOOST_STATIC_ASSERT(!boost::fusion::traits::is_view<incomplete>::value);
-
-int main() { }

test/support/pair_conversion.cpp

@@ -0,0 +1,42 @@
+/*=============================================================================
+    Copyright (c) 2018 Kohei Takahashi
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+
+#include <utility>
+#include <boost/config.hpp>
+#include <boost/fusion/support/pair.hpp>
+
+using namespace boost::fusion;
+
+struct eat_int
+{
+    eat_int(int);
+};
+
+struct eat_pair
+{
+    template <typename K, typename V>
+    eat_pair(pair<K, V>);
+};
+
+int main()
+{
+    pair<void, int> p;
+
+    pair<void, eat_int> ci(p);
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+    pair<void, eat_int> mi(std::move(p));
+#endif
+
+    // eat_pair can't be converted from int, but can be pair.
+    // So pair(eat_pair) should be called rather than pair(pair<void, eat_pair>).
+    pair<void, eat_pair> cp(p);
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+    pair<void, eat_pair> mp(std::move(p));
+#endif
+}

test/support/pair_nest.cpp

@@ -1,5 +1,5 @@
 /*=============================================================================
-    Copyright (c) 2015 Kohei Takahashi
+    Copyright (c) 2015,2018 Kohei Takahashi
 
     Distributed under the Boost Software License, Version 1.0. (See accompanying
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -10,15 +10,20 @@
 using namespace boost::fusion;
 
 template <typename C>
-void copy()
+void copy(C value)
 {
-    pair<int, C> src;
+    pair<int, C> src(value);
     pair<int, C> dest = src;
     boost::ignore_unused(dest);
 }
 
 int main()
 {
-    copy<pair<void, float> >();
+    copy<pair<void, float> >(42.195f);
+    copy<pair<int, float> >(42.195f);
+
+    float f;
+    pair<void, float&> r(f);
+    copy<pair<void, float&> >(r);
 }
 

test/support/pair_trivially_copyable.cpp

@@ -0,0 +1,50 @@
+/*=============================================================================
+    Copyright (c) 2018 Kohei Takahashi
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+
+#include <type_traits>
+#include <boost/fusion/support/pair.hpp>
+#include <boost/mpl/assert.hpp>
+
+using namespace boost::fusion;
+
+struct non_trivially_copyable
+{
+    non_trivially_copyable(const non_trivially_copyable&);
+    non_trivially_copyable operator=(const non_trivially_copyable&);
+};
+
+struct pod { };
+
+BOOST_MPL_ASSERT_NOT((std::is_trivially_copyable<void>));
+BOOST_MPL_ASSERT((std::is_trivially_copyable<int>));
+BOOST_MPL_ASSERT_NOT((std::is_trivially_copyable<non_trivially_copyable>));
+BOOST_MPL_ASSERT((std::is_trivially_copyable<pod>));
+BOOST_MPL_ASSERT_NOT((std::is_trivially_copyable<int&>));
+BOOST_MPL_ASSERT((std::is_trivially_copyable<void*>));
+
+
+
+BOOST_MPL_ASSERT((std::is_trivially_copyable<pair<void, int> >));
+BOOST_MPL_ASSERT((std::is_trivially_copyable<pair<int, int> >));
+BOOST_MPL_ASSERT((std::is_trivially_copyable<pair<non_trivially_copyable, int> >));
+BOOST_MPL_ASSERT_NOT((std::is_trivially_copyable<pair<int, non_trivially_copyable> >));
+BOOST_MPL_ASSERT((std::is_trivially_copyable<pair<pod, int> >));
+BOOST_MPL_ASSERT((std::is_trivially_copyable<pair<int, pod> >));
+
+BOOST_MPL_ASSERT((std::is_trivially_copyable<pair<void, int&> >));
+BOOST_MPL_ASSERT((std::is_trivially_copyable<pair<int, int&> >));
+BOOST_MPL_ASSERT((std::is_trivially_copyable<pair<non_trivially_copyable, int&> >));
+BOOST_MPL_ASSERT((std::is_trivially_copyable<pair<int, non_trivially_copyable&> >));
+BOOST_MPL_ASSERT((std::is_trivially_copyable<pair<int, pod&> >));
+BOOST_MPL_ASSERT((std::is_trivially_copyable<pair<int, pod&> >));
+
+BOOST_MPL_ASSERT((std::is_trivially_copyable<pair<void, int*> >));
+BOOST_MPL_ASSERT((std::is_trivially_copyable<pair<int, int*> >));
+BOOST_MPL_ASSERT((std::is_trivially_copyable<pair<non_trivially_copyable, int*> >));
+BOOST_MPL_ASSERT((std::is_trivially_copyable<pair<int, non_trivially_copyable*> >));
+BOOST_MPL_ASSERT((std::is_trivially_copyable<pair<int, pod*> >));
+BOOST_MPL_ASSERT((std::is_trivially_copyable<pair<int, pod*> >));

test/support/unused.cpp

@@ -1,96 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2018 Kohei Takahashi
-
-    Distributed under the Boost Software License, Version 1.0. (See accompanying
-    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-==============================================================================*/
-
-#include <boost/config.hpp>
-#include <boost/fusion/support/unused.hpp>
-#include <boost/type_traits/detail/yes_no_type.hpp>
-#include <boost/static_assert.hpp>
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-#include <utility>
-#endif
-
-struct T { };
-
-void unused_construction()
-{
-    boost::fusion::unused_type dephault;
-
-    boost::fusion::unused_type BOOST_ATTRIBUTE_UNUSED parenthesis = boost::fusion::unused_type();
-#ifndef BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
-    boost::fusion::unused_type BOOST_ATTRIBUTE_UNUSED brace{};
-    boost::fusion::unused_type BOOST_ATTRIBUTE_UNUSED list_copy = {};
-#endif
-
-    boost::fusion::unused_type copy_copy BOOST_ATTRIBUTE_UNUSED = dephault;
-    boost::fusion::unused_type copy_direct BOOST_ATTRIBUTE_UNUSED (dephault);
-#ifndef BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
-    boost::fusion::unused_type copy_copy_brace_direct BOOST_ATTRIBUTE_UNUSED = {dephault};
-    boost::fusion::unused_type copy_direct_brace BOOST_ATTRIBUTE_UNUSED {dephault};
-#endif
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-    boost::fusion::unused_type move_copy BOOST_ATTRIBUTE_UNUSED = std::move(dephault);
-    boost::fusion::unused_type move_direct BOOST_ATTRIBUTE_UNUSED (std::move(dephault));
-#ifndef BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
-    boost::fusion::unused_type move_copy_brace_direct BOOST_ATTRIBUTE_UNUSED = {std::move(dephault)};
-    boost::fusion::unused_type move_direct_brace BOOST_ATTRIBUTE_UNUSED {std::move(dephault)};
-#endif
-#endif
-
-
-    T value;
-
-    boost::fusion::unused_type T_copy_copy BOOST_ATTRIBUTE_UNUSED = value;
-    boost::fusion::unused_type T_copy_direct BOOST_ATTRIBUTE_UNUSED (value);
-#ifndef BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
-    boost::fusion::unused_type T_copy_copy_brace_direct BOOST_ATTRIBUTE_UNUSED = {value};
-    boost::fusion::unused_type T_copy_direct_brace BOOST_ATTRIBUTE_UNUSED {value};
-#endif
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-    boost::fusion::unused_type T_move_copy BOOST_ATTRIBUTE_UNUSED = std::move(value);
-    boost::fusion::unused_type T_move_direct BOOST_ATTRIBUTE_UNUSED (std::move(value));
-#ifndef BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
-    boost::fusion::unused_type T_move_copy_brace_direct BOOST_ATTRIBUTE_UNUSED = {std::move(value)};
-    boost::fusion::unused_type T_move_direct_brace BOOST_ATTRIBUTE_UNUSED {std::move(value)};
-#endif
-#endif
-}
-
-void unused_assignment()
-{
-    boost::fusion::unused_type val1, val2;
-
-    val1 = val2;
-#ifndef BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
-    val1 = {};
-#endif
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-    val1 = std::move(val2);
-#endif
-
-
-    T value;
-
-    val1 = value;
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-    val1 = std::move(value);
-#endif
-}
-
-boost::type_traits::yes_type test_unused(boost::fusion::detail::unused_only const&);
-boost::type_traits::no_type  test_unused(...);
-
-void only_unused()
-{
-    BOOST_STATIC_ASSERT((sizeof(test_unused(boost::fusion::unused)) == sizeof(boost::type_traits::yes_type)));
-    BOOST_STATIC_ASSERT((sizeof(test_unused(0)) == sizeof(boost::type_traits::no_type)));
-
-    boost::fusion::unused_type my_unused;
-    (void)my_unused;
-    BOOST_STATIC_ASSERT((sizeof(test_unused(my_unused)) == sizeof(boost::type_traits::yes_type)));
-}