Merge pull request #207 from boostorg/develop

Update CI scripts on master
Merge pull request #206 from boostorg/update-ci
2025-07-13 04:26:30 +02:00 · 2019-01-10 17:19:50 +09:00 · 2019-01-10 08:45:02 +09:00 · 2019-01-09 18:59:05 +09:00 · 2019-01-09 18:58:40 +09:00 · 2019-01-09 18:33:23 +09:00
87 changed files with 489 additions and 1587 deletions
--- a/.travis.yml
+++ b/.travis.yml
@ -21,32 +21,48 @@ matrix:
    - env: BOGUS_JOB=true

  include:
-      # trusty default (gcc 4.8.4)
-    - os: linux
-      env: TOOLSET=gcc CXXSTD=03,11,1y
-
    - os: linux
+      dist: xenial
      env: TOOLSET=gcc-4.4 CXXSTD=98,0x
      addons:
        apt:
          packages:
            - g++-4.4
+          sources:
+            - ubuntu-toolchain-r-test
+
+    #- os: linux
+    #  dist: xenial
+    #  env: TOOLSET=gcc-4.5 CXXSTD=03,0x
+    #  addons:
+    #    apt:
+    #      packages:
+    #        - g++-4.5
+    #      sources:
+    #        - ubuntu-toolchain-r-test

    - os: linux
+      dist: xenial
      env: TOOLSET=gcc-4.6 CXXSTD=03,0x
      addons:
        apt:
          packages:
            - g++-4.6
+          sources:
+            - ubuntu-toolchain-r-test

    - os: linux
+      dist: xenial
      env: TOOLSET=gcc-4.7 CXXSTD=03,11
      addons:
        apt:
          packages:
            - g++-4.7
+          sources:
+            - ubuntu-toolchain-r-test

    - os: linux
+      dist: xenial
      env: TOOLSET=gcc-4.8 CXXSTD=03,11,1y
      addons:
        apt:
@ -56,7 +72,8 @@ matrix:
            - ubuntu-toolchain-r-test

    - os: linux
-      env: TOOLSET=gcc-4.9 CXXSTD=03,11,1y
+      dist: xenial
+      env: TOOLSET=gcc-4.9 CXXSTD=03,11,14
      addons:
        apt:
          packages:
@ -65,7 +82,8 @@ matrix:
            - ubuntu-toolchain-r-test

    - os: linux
-      env: TOOLSET=gcc-5 CXXSTD=03,11,14,1z
+      dist: xenial
+      env: TOOLSET=gcc-5 CXXSTD=03,11,14,17
      addons:
        apt:
          packages:
@ -74,7 +92,8 @@ matrix:
            - ubuntu-toolchain-r-test

    - os: linux
-      env: TOOLSET=gcc-6 CXXSTD=03,11,14,1z
+      dist: xenial
+      env: TOOLSET=gcc-6 CXXSTD=03,11,14,17
      addons:
        apt:
          packages:
@ -83,7 +102,8 @@ matrix:
            - ubuntu-toolchain-r-test

    - os: linux
-      env: TOOLSET=gcc-7 CXXSTD=03,11,14,1z
+      dist: xenial
+      env: TOOLSET=gcc-7 CXXSTD=03,11,14,17
      addons:
        apt:
          packages:
@ -91,87 +111,93 @@ matrix:
          sources:
            - ubuntu-toolchain-r-test

-      # trusty default (clang 3.9.0)
    - os: linux
-      env: TOOLSET=clang CXXSTD=03,11,14,1z
+      dist: xenial
+      env: TOOLSET=gcc-8 CXXSTD=03,11,14,17,2a
      addons:
        apt:
          packages:
-            - libstdc++-4.9-dev
+            - g++-8
          sources:
            - ubuntu-toolchain-r-test

    - os: linux
+      dist: xenial
      env: TOOLSET=clang-3.5 CXXSTD=03,11,14,1z
      addons:
        apt:
          packages:
            - clang-3.5
-            - 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
-            - libstdc++-4.9-dev
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-4.0

    - os: linux
-      env: TOOLSET=clang-5.0 CXXSTD=03,11,14,1z,2a
+      dist: xenial
+      env: TOOLSET=clang-5.0 CXXSTD=03,11,14,17,2a
      addons:
        apt:
          packages:
            - clang-5.0
-            - libstdc++-4.9-dev
          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-5.0
+            - llvm-toolchain-xenial-5.0
+
+    - os: linux
+      dist: xenial
+      env: TOOLSET=clang-6.0 CXXSTD=03,11,14,17,2a
+      addons:
+        apt:
+          packages:
+            - clang-6.0
+          sources:
+            - llvm-toolchain-xenial-6.0
+
+    - os: linux
+      dist: xenial
+      env: TOOLSET=clang-7.0 CXXSTD=03,11,14,17,2a
+      addons:
+        apt:
+          packages:
+            - clang-7
+          sources:
+            - llvm-toolchain-xenial-7

    - os: osx
      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z
@ -211,7 +237,7 @@ install:
  - git submodule init libs/typeof
  - git submodule init libs/utility

-  - git submodule init tools/build
+  - git submodule init libs/headers tools/boost_install tools/build
  - git submodule update

  - rm -rf libs/fusion
--- a/appveyor.yml
+++ b/appveyor.yml
@ -36,6 +36,12 @@ environment:
    - 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
@ -73,7 +79,7 @@ install:
  - git submodule init libs/typeof
  - git submodule init libs/utility

-  - git submodule init tools/build
+  - git submodule init libs/headers tools/boost_install tools/build
  - git submodule update
  - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\fusion
  - cmd /c bootstrap
--- a/doc/adapted.qbk
+++ b/doc/adapted.qbk
@ -23,19 +23,6 @@ various data structures, non-intrusively, as full fledged Fusion sequences.
    #include <boost/fusion/adapted.hpp>
    #include <boost/fusion/include/adapted.hpp>

-Fusion sequences may also be adapted as fully conforming __mpl__ sequences (see
-__intrinsics__). That way, we can have 2-way adaptation to and from __mpl__ and
-Fusion. To make Fusion sequences fully conforming __mpl__ sequences, include:
-
-    #include <boost/fusion/mpl.hpp>
-
-If you want bi-directional adaptation to and from __mpl__ and Fusion, simply
-include:
-
-    #include <boost/fusion/include/mpl.hpp>
-
-The header includes all the necessary headers.
-
 [section:array Array]

 This module provides adapters for arrays. Including the module
@ -145,6 +132,21 @@ header makes all __mpl__ sequences fully conforming fusion sequences.
    std::cout << __at_c__<0>(v) << std::endl;
    std::cout << __at_c__<1>(v) << std::endl;

+[heading Bi-directional adaptation]
+
+Fusion sequences may also be adapted as fully conforming __mpl__ sequences (see
+__intrinsics__). That way, we can have 2-way adaptation to and from __mpl__ and
+Fusion. To make Fusion sequences fully conforming __mpl__ sequences, include:
+
+    #include <boost/fusion/mpl.hpp>
+
+If you want bi-directional adaptation to and from __mpl__ and Fusion, simply
+include:
+
+    #include <boost/fusion/include/mpl.hpp>
+
+The header includes all the necessary headers.
+
 [heading See also]

 __mpl__
--- a/doc/sequence.qbk
+++ b/doc/sequence.qbk
@ -1522,6 +1522,16 @@ each element. Analogously, the global `operator>>` has been overloaded
 to extract __sequence__(s) from generic input streams by recursively
 calling `operator>>` for each element.

+Please note that, to display your adapted types via fusion IO system,
+corresponding overloaded operators should be introduced to same namespace
+of the type.
+
+    namespace your_awesome_library
+    {
+        using boost::fusion::operators::operator>>; // for input
+        using boost::fusion::operators::operator<<; // for output
+        ...
+
 The default delimiter between the elements is space, and the __sequence__
 is enclosed in parenthesis. For Example:

--- a/doc/view.qbk
+++ b/doc/view.qbk
@ -93,10 +93,9 @@ presents only those elements for which its predicate evaluates to
 [heading Template parameters]

 [table
-    [[Parameter]            [Description]               [Default]]
-    [[`Sequence`]           [A __forward_sequence__]    []]
-    [[`Pred`]               [Unary Metafunction
-                             returning an `mpl::bool_`] []]
+    [[Parameter]            [Description]                       [Default]]
+    [[`Sequence`]           [A __forward_sequence__]            []]
+    [[`Pred`]               [A unary __mpl_lambda_expression__] []]
 ]

 [heading Model of]
@ -271,7 +270,7 @@ defined in the implemented models.
 [heading Description]

 `zip_view` presents a view which iterates over a collection of __sequence__(s) in parallel. A `zip_view`
-is constructed from a __sequence__ of references to the component __sequence__s.
+is constructed from a __sequence__ of references to the component `__sequence__`s.

 [heading Header]

@ -287,7 +286,7 @@ is constructed from a __sequence__ of references to the component __sequence__s.

 [table
    [[Parameter]            [Description]                   [Default]]
-    [[`Sequences`]          [A __forward_sequence__ of references to other Fusion __sequence__s]        []]
+    [[`Sequences`]          [A __forward_sequence__ of references to other Fusion `__sequence__`s]        []]
 ]

 [heading Model of]
@ -309,7 +308,7 @@ defined in __forward_sequence__.

 [table
    [[Expression]           [Semantics]]
-    [[`ZV(s)`]              [Creates a `zip_view` given a sequence of references to the component __sequence__s.]]
+    [[`ZV(s)`]              [Creates a `zip_view` given a sequence of references to the component `__sequence__`s.]]
    [[`ZV(zv1)`]             [Copy constructs a `zip_view` from another `zip_view`, `zv`.]]
    [[`zv1 = zv2`]           [Assigns to a `zip_view`, `zv`, from another `zip_view`, `zv2`.]]
 ]
--- a/include/boost/fusion/adapted/adt/adapt_adt.hpp
+++ b/include/boost/fusion/adapted/adt/adapt_adt.hpp
@ -16,10 +16,6 @@
 #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>
--- a/include/boost/fusion/adapted/adt/adapt_assoc_adt.hpp
+++ b/include/boost/fusion/adapted/adt/adapt_assoc_adt.hpp
@ -15,9 +15,6 @@
 #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>
--- a/include/boost/fusion/adapted/adt/detail/adapt_base.hpp
+++ b/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,20 +83,8 @@
    typedef                                                                     \
        BOOST_PP_EXPR_IF(BOOST_FUSION_ADAPT_IS_TPL(TEMPLATE_PARAMS_SEQ),        \
                         typename)                                              \
-        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;
+        deduced_attr_type::type type;                                           \
+    typedef type const_type;

 #define BOOST_FUSION_ADT_ATTRIBUTE_GIVENTYPE(                                   \
    NAME_SEQ, ATTRIBUTE, ATTRIBUTE_TUPLE_SIZE, PREFIX, TEMPLATE_PARAMS_SEQ)     \
--- a/include/boost/fusion/adapted/struct/adapt_assoc_struct.hpp
+++ b/include/boost/fusion/adapted/struct/adapt_assoc_struct.hpp
@ -15,10 +15,6 @@
 #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>
--- a/include/boost/fusion/adapted/struct/adapt_struct.hpp
+++ b/include/boost/fusion/adapted/struct/adapt_struct.hpp
@ -18,10 +18,6 @@
 #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>
--- a/include/boost/fusion/adapted/struct/detail/adapt_base.hpp
+++ b/include/boost/fusion/adapted/struct/detail/adapt_base.hpp
@ -34,7 +34,9 @@
 #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>

--- a/include/boost/fusion/algorithm/iteration/detail/for_each.hpp
+++ b/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 const& f, mpl::false_)
+    for_each_linear(First const& first, Last const& last, F& f, mpl::false_)
    {
        f(*first);
        detail::for_each_linear(fusion::next(first), last, f, 
@ -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 const& f, Tag)
+    for_each_dispatch(Sequence& seq, F& 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 const& f)
+        static void call(I0 const& i0, F& 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 const& f)
+        static void call(I0 const& i0, F& 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 const& f)
+        static void call(I0 const& i0, F& 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 const& f)
+        static void call(I0 const& i0, F& 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 const& f, random_access_traversal_tag)
+    for_each_dispatch(Sequence& seq, F& f, random_access_traversal_tag)
    {
        typedef typename result_of::begin<Sequence>::type begin;
        typedef typename result_of::end<Sequence>::type end;
@ -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 const& f, mpl::false_) // unsegmented implementation
+    for_each(Sequence& seq, F& f, mpl::false_) // unsegmented implementation
    {
        detail::for_each_dispatch(seq, f, typename traits::category_of<Sequence>::type());
    }
--- a/include/boost/fusion/algorithm/iteration/detail/segmented_for_each.hpp
+++ b/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 const& f)
+        explicit segmented_for_each_fun(Fun& f)
          : fun(f)
        {}

-        Fun const& fun;
+        Fun& 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 const& f, mpl::true_) // segmented implementation
+    for_each(Sequence& seq, F& f, mpl::true_) // segmented implementation
    {
        fusion::segmented_fold_until(seq, void_(), segmented_for_each_fun<F>(f));
    }
--- a/include/boost/fusion/algorithm/iteration/for_each.hpp
+++ b/include/boost/fusion/algorithm/iteration/for_each.hpp
@ -1,6 +1,7 @@
 /*=============================================================================
    Copyright (c) 2001-2007 Joel de Guzman
    Copyright (c) 2007 Dan Marsden
+    Copyright (c) 2018 Kohei Takahashi

    Distributed under the Boost Software License, Version 1.0. (See accompanying 
    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@ -13,7 +14,7 @@
 #include <boost/fusion/algorithm/iteration/detail/segmented_for_each.hpp>
 #include <boost/fusion/support/is_segmented.hpp>
 #include <boost/fusion/support/is_sequence.hpp>
-#include <boost/utility/enable_if.hpp>
+#include <boost/core/enable_if.hpp>

 namespace boost { namespace fusion
 {
@ -28,24 +29,16 @@ namespace boost { namespace fusion

    template <typename Sequence, typename F>
    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-    inline typename
-        enable_if<
-            traits::is_sequence<Sequence>
-          , void
-        >::type
-    for_each(Sequence& seq, F const& f)
+    inline typename enable_if<traits::is_sequence<Sequence> >::type
+    for_each(Sequence& seq, F f)
    {
        detail::for_each(seq, f, typename traits::is_segmented<Sequence>::type());
    }

    template <typename Sequence, typename F>
    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-    inline typename
-        enable_if<
-            traits::is_sequence<Sequence>
-          , void
-        >::type
-    for_each(Sequence const& seq, F const& f)
+    inline typename enable_if<traits::is_sequence<Sequence> >::type
+    for_each(Sequence const& seq, F f)
    {
        detail::for_each(seq, f, typename traits::is_segmented<Sequence>::type());
    }
--- a/include/boost/fusion/algorithm/iteration/for_each_fwd.hpp
+++ b/include/boost/fusion/algorithm/iteration/for_each_fwd.hpp
@ -1,5 +1,6 @@
 /*=============================================================================
    Copyright (c) 2011 Eric Niebler
+    Copyright (c) 2018 Kohei Takahashi

    Distributed under the Boost Software License, Version 1.0. (See accompanying 
    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@ -9,7 +10,7 @@

 #include <boost/fusion/support/config.hpp>
 #include <boost/fusion/support/is_sequence.hpp>
-#include <boost/utility/enable_if.hpp>
+#include <boost/core/enable_if.hpp>

 namespace boost { namespace fusion
 {
@ -21,21 +22,13 @@ namespace boost { namespace fusion

    template <typename Sequence, typename F>
    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-    inline typename
-        enable_if<
-            traits::is_sequence<Sequence>
-          , void
-        >::type
-    for_each(Sequence& seq, F const& f);
+    inline typename enable_if<traits::is_sequence<Sequence> >::type
+    for_each(Sequence& seq, F f);

    template <typename Sequence, typename F>
    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-    inline typename
-        enable_if<
-            traits::is_sequence<Sequence>
-          , void
-        >::type
-    for_each(Sequence const& seq, F const& f);
+    inline typename enable_if<traits::is_sequence<Sequence> >::type
+    for_each(Sequence const& seq, F f);
 }}

 #endif
--- a/include/boost/fusion/algorithm/query/detail/find_if.hpp
+++ b/include/boost/fusion/algorithm/query/detail/find_if.hpp
@ -2,6 +2,7 @@
    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)
@ -13,7 +14,6 @@
 #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,10 +22,9 @@
 #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 { 
-    struct random_access_traversal_tag;
-namespace detail
+namespace boost { namespace fusion { namespace detail
 {
    template <typename Iterator, typename Pred>
    struct apply_filter
@ -178,8 +177,8 @@ namespace detail
            choose_find_if<
                First
              , Last
-              , typename mpl::lambda<Pred>::type
-              , is_base_of<random_access_traversal_tag, typename traits::category_of<First>::type>::value
+              , Pred
+              , traits::is_random_access<First>::value
            >::type
        type;

@ -208,31 +207,23 @@ namespace detail
            return recursive_call(iter, found());
        }

-        template <typename Iterator, typename Tag>
+        template <typename Iterator>
        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-        static type
-        choose_call(Iterator const& iter, Tag)
+        static typename boost::disable_if<traits::is_random_access<Iterator>, type>::type
+        iter_call(Iterator const& iter)
        {
            return recursive_call(iter);
        }

        template <typename Iterator>
        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-        static type
-        choose_call(Iterator const& iter, random_access_traversal_tag)
+        static typename boost::enable_if<traits::is_random_access<Iterator>, type>::type
+        iter_call(Iterator const& iter)
        {
            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
--- a/include/boost/fusion/algorithm/transformation/remove_if.hpp
+++ b/include/boost/fusion/algorithm/transformation/remove_if.hpp
@ -1,7 +1,8 @@
 /*=============================================================================
    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)
@ -10,7 +11,6 @@
 #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
 {
--- a/include/boost/fusion/container/map/detail/value_at_key_impl.hpp
+++ b/include/boost/fusion/container/map/detail/value_at_key_impl.hpp
@ -24,12 +24,10 @@ namespace boost { namespace fusion
        struct value_at_key_impl<map_tag>
        {
            template <typename Sequence, typename Key>
-            struct apply
-            {
-                typedef typename BOOST_FUSION_IDENTIFIED_TYPE((
+            struct apply : BOOST_FUSION_DECLTYPE_N3031((
                    boost::declval<Sequence>().get_val(mpl::identity<Key>())
-                )) type;
-            };
+                ))
+            {};
        };
    }
 }}
--- a/include/boost/fusion/container/map/map_fwd.hpp
+++ b/include/boost/fusion/container/map/map_fwd.hpp
@ -36,8 +36,6 @@
 # include <boost/fusion/container/map/detail/cpp03/map_fwd.hpp>
 #else

-#include <boost/fusion/container/map/detail/map_impl.hpp>
-
 ///////////////////////////////////////////////////////////////////////////////
 // C++11 interface
 ///////////////////////////////////////////////////////////////////////////////
--- a/include/boost/fusion/container/vector/detail/value_at_impl.hpp
+++ b/include/boost/fusion/container/vector/detail/value_at_impl.hpp
@ -47,12 +47,10 @@ namespace boost { namespace fusion
        struct value_at_impl<vector_tag>
        {
            template <typename Sequence, typename N>
-            struct apply
-            {
-                typedef typename BOOST_FUSION_IDENTIFIED_TYPE((
+            struct apply : BOOST_FUSION_DECLTYPE_N3031((
                    vector_detail::value_at_impl<N::value>(boost::declval<Sequence*>())
-                )) type;
-            };
+                ))
+            {};
        };
    }
 }}
--- a/include/boost/fusion/container/vector/vector.hpp
+++ b/include/boost/fusion/container/vector/vector.hpp
@ -26,7 +26,6 @@
 #include <boost/fusion/support/is_sequence.hpp>
 #include <boost/fusion/support/detail/and.hpp>
 #include <boost/fusion/support/detail/index_sequence.hpp>
-#include <boost/fusion/support/detail/propagate_trivialness.hpp>
 #include <boost/fusion/container/vector/detail/at_impl.hpp>
 #include <boost/fusion/container/vector/detail/value_at_impl.hpp>
 #include <boost/fusion/container/vector/detail/begin_impl.hpp>
@ -51,6 +50,8 @@ namespace boost { namespace fusion

    namespace vector_detail
    {
+        struct each_elem {};
+
        template <
            typename This, typename T, typename T_, std::size_t Size, bool IsSeq
        >
@ -130,6 +131,32 @@ namespace boost { namespace fusion
                : elem() // value-initialized explicitly
            {}

+            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+            store(store const& rhs)
+                : elem(rhs.elem)
+            {}
+
+            BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+            store&
+            operator=(store const& rhs)
+            {
+                elem = rhs.elem;
+                return *this;
+            }
+
+            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+            store(store&& rhs)
+                : elem(static_cast<T&&>(rhs.elem))
+            {}
+
+            BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+            store&
+            operator=(store&& rhs)
+            {
+                elem = static_cast<T&&>(rhs.elem);
+                return *this;
+            }
+
            template <
                typename U
              , typename = typename boost::disable_if<
@ -141,9 +168,15 @@ 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;

@ -151,7 +184,6 @@ namespace boost { namespace fusion
        struct vector_data<detail::index_sequence<I...>, T...>
            : store<I, T>...
            , sequence_base<vector_data<detail::index_sequence<I...>, T...> >
-            , private detail::propagate_trivialness<T...>
        {
            typedef vector_tag                  fusion_tag;
            typedef fusion_sequence_tag         tag; // this gets picked up by MPL
@ -172,14 +204,14 @@ namespace boost { namespace fusion
            >
            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
            explicit
-            vector_data(Sequence&& rhs)
+            vector_data(each_elem, Sequence&& rhs)
                : store<I, T>(forward_at_c<I>(std::forward<Sequence>(rhs)))...
            {}

            template <typename ...U>
            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
            explicit
-            vector_data(U&&... var)
+            vector_data(each_elem, U&&... var)
                : store<I, T>(std::forward<U>(var))...
            {}

@ -205,32 +237,23 @@ namespace boost { namespace fusion
                assign(std::forward<Sequence>(seq), detail::index_sequence<M...>());
            }

-            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;
-            }
+        private:
+            template <std::size_t J>
+            using store_at = decltype(store_at_impl<J>(static_cast<vector_data*>(nullptr)));

+        public:
            template <typename J>
            BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            auto at_impl(J) -> decltype(at_detail<J::value>(&std::declval<vector_data&>()))
+            typename store_at<J::value>::elem_type& at_impl(J)
            {
-                return at_detail<J::value>(this);
+                return store_at<J::value>::elem;
            }

            template <typename J>
            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            auto at_impl(J) const -> decltype(at_detail<J::value>(&std::declval<vector_data const&>()))
+            typename store_at<J::value>::elem_type const& at_impl(J) const
            {
-                return at_detail<J::value>(this);
+                return store_at<J::value>::elem;
            }
        };
    } // namespace boost::fusion::vector_detail
@ -264,7 +287,7 @@ namespace boost { namespace fusion
        //      In the (near) future release, should be fixed.
        /* BOOST_CONSTEXPR */ BOOST_FUSION_GPU_ENABLED
        explicit vector(U&&... u)
-            : base(std::forward<U>(u)...)
+            : base(vector_detail::each_elem(), std::forward<U>(u)...)
        {}

        template <
@ -277,7 +300,7 @@ namespace boost { namespace fusion
        >
        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
        vector(Sequence&& seq)
-            : base(std::forward<Sequence>(seq))
+            : base(vector_detail::each_elem(), std::forward<Sequence>(seq))
        {}

        template <typename Sequence>
--- a/include/boost/fusion/support/config.hpp
+++ b/include/boost/fusion/support/config.hpp
@ -97,15 +97,26 @@ namespace std
 #endif


-// Workaround for compiler which doesn't compile decltype(expr)::type.
-// It expects decltype(expr) deduced as mpl::identity<T>.
-#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1913)) || BOOST_WORKAROUND(BOOST_GCC, < 40700)
+// 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_IDENTIFIED_TYPE(parenthesized_expr) \
-        boost::mpl::identity<decltype parenthesized_expr>::type::type
+#   define BOOST_FUSION_DECLTYPE_N3031(parenthesized_expr) \
+        boost::mpl::identity<decltype parenthesized_expr>::type
+# endif
 #else
-#   define BOOST_FUSION_IDENTIFIED_TYPE(parenthesized_expr) \
-        decltype parenthesized_expr ::type
+#   define BOOST_FUSION_DECLTYPE_N3031(parenthesized_expr) \
+        decltype parenthesized_expr
 #endif


@ -116,11 +127,4 @@ namespace std
 #   define BOOST_FUSION_NOEXCEPT_ON_DEFAULTED BOOST_NOEXCEPT
 #endif

-
-#ifdef __has_extension
-#   define BOOST_FUSION_HAS_EXTENSION __has_extension
-#else
-#   define BOOST_FUSION_HAS_EXTENSION(_) 0
-#endif
-
 #endif
--- a/include/boost/fusion/support/detail/is_same_size.hpp
+++ b/include/boost/fusion/support/detail/is_same_size.hpp
@ -9,20 +9,19 @@

 #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, typename = void, typename = void>
+    template <typename Sequence1, typename Sequence2, bool
+            = traits::is_sequence<Sequence1>::value &&
+              traits::is_sequence<Sequence2>::value>
    struct is_same_size : mpl::false_ {};

    template <typename Sequence1, typename Sequence2>
-    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> >
+    struct is_same_size<Sequence1, Sequence2, true>
+        : mpl::bool_<result_of::size<Sequence1>::value == 
+                     result_of::size<Sequence2>::value>
    {};
 }}}

--- a/include/boost/fusion/support/detail/is_trivially_copyable.hpp
+++ b/include/boost/fusion/support/detail/is_trivially_copyable.hpp
@ -1,113 +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)
-==============================================================================*/
-#ifndef BOOST_FUSION_SUPPORT_DETAIL_IS_TRIVIALLY_COPYABLE
-#define BOOST_FUSION_SUPPORT_DETAIL_IS_TRIVIALLY_COPYABLE
-
-#include <boost/fusion/support/config.hpp>
-
-#if BOOST_WORKAROUND(BOOST_GCC, BOOST_TESTED_AT(90000))
-    // GCC treats volatile qualified scalar type as non trivially copyable,
-    // so to be fail safe, we also treat it as non trivially copyable type.
-    // http://wg21.link/cwg2094
-    // https://gcc.gnu.org/PR85679
-    //
-    // Some version of clang also tweats volatile qualified scalar type as
-    // non trivially copyable type, but all of known the versions what
-    // behaves as CWG 496 but not CWG 2094 implement builtin.
-    // So we don't have to emulate CWG 496 on clang.
-#   define BOOST_FUSION_DETAIL_VOLATILE_SCALAR_IS_NON_TRIVIALLY_COPYABLE
-#endif
-
-#if BOOST_FUSION_HAS_EXTENSION(is_trivially_copyable) || \
-    (50000 <= BOOST_GCC) || (1700 <= BOOST_MSVC)
-#   define BOOST_FUSION_IS_TRIVIALLY_COPYABLE __is_trivially_copyable
-#endif
-
-#if defined(BOOST_FUSION_IS_TRIVIALLY_COPYABLE)
-#   define BOOST_FUSION_DETAIL_IS_TRIVIALLY_COPYABLE_CONFORMING 2
-#   include <boost/mpl/bool.hpp>
-#elif !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
-#   define BOOST_FUSION_DETAIL_IS_TRIVIALLY_COPYABLE_CONFORMING 2
-#   include <type_traits>
-#else
-#   include <boost/config/workaround.hpp>
-#   include <boost/mpl/bool.hpp>
-#   include <boost/mpl/if.hpp>
-#   include <boost/type_traits/remove_cv.hpp>
-#   include <boost/type_traits/remove_all_extents.hpp>
-#   include <boost/type_traits/is_scalar.hpp>
-#   include <boost/type_traits/is_class.hpp>
-#   include <boost/type_traits/is_union.hpp>
-#   include <boost/type_traits/is_constructible.hpp>
-#   include <boost/type_traits/is_assignable.hpp>
-#   include <boost/type_traits/is_copy_constructible.hpp>
-#   include <boost/type_traits/is_copy_assignable.hpp>
-#   include <boost/type_traits/has_trivial_assign.hpp>
-#   include <boost/type_traits/has_trivial_copy.hpp>
-#   include <boost/type_traits/has_trivial_destructor.hpp>
-#   include <boost/type_traits/has_trivial_move_assign.hpp>
-#   include <boost/type_traits/has_trivial_move_constructor.hpp>
-#ifdef BOOST_FUSION_DETAIL_VOLATILE_SCALAR_IS_NON_TRIVIALLY_COPYABLE
-#   include <boost/mpl/not.hpp>
-#   include <boost/type_traits/is_volatile.hpp>
-#endif
-#endif // <type_traits>
-
-namespace boost { namespace fusion { namespace detail
-{
-
-#ifndef BOOST_FUSION_DETAIL_IS_TRIVIALLY_COPYABLE_CONFORMING
-#if defined(BOOST_SFINAE_EXPR) && !defined(BOOST_NO_CXX11_DECLTYPE) && \
-    defined(BOOST_IS_UNION) && defined(BOOST_TT_HAS_CONFORMING_IS_CLASS_IMPLEMENTATION) && \
-    defined(BOOST_HAS_TRIVIAL_ASSIGN) && defined(BOOST_HAS_TRIVIAL_COPY) && \
-    defined(BOOST_HAS_TRIVIAL_MOVE_ASSIGN) && defined(BOOST_HAS_TRIVIAL_MOVE_CONSTRUCTOR) && \
-    defined(BOOST_HAS_TRIVIAL_DESTRUCTOR) && defined(BOOST_TT_IS_CONSTRUCTIBLE_CONFORMING)
-#   define BOOST_FUSION_DETAIL_IS_TRIVIALLY_COPYABLE_CONFORMING 1
-#endif
-
-template <typename T>
-struct is_trivially_copyable_class
-  : mpl::bool_<
-        (has_trivial_copy<T>::value   || !is_copy_constructible<T>::value) &&
-        (has_trivial_assign<T>::value || !is_copy_assignable<T>::value) &&
-        (has_trivial_move_constructor<T>::value || !is_constructible<T, T>::value) &&
-        (has_trivial_move_assign<T>::value      || !is_assignable<T, T>::value) &&
-        (is_copy_constructible<T>::value || is_copy_assignable<T>::value ||
-         is_constructible<T, T>::value   || is_assignable<T, T>::value) &&
-        has_trivial_destructor<T>::value
-    > { };
-
-template <typename T>
-struct is_trivially_copyable_impl
-  : mpl::if_c<is_scalar<T>::value
-#ifdef BOOST_FUSION_DETAIL_VOLATILE_SCALAR_IS_NON_TRIVIALLY_COPYABLE
-    , mpl::not_<is_volatile<T> >
-#else
-    , mpl::true_
-#endif
-    , typename mpl::if_c<is_class<T>::value || is_union<T>::value
-      , is_trivially_copyable_class<typename remove_cv<T>::type>
-      , mpl::false_
-      >::type
-    >::type { };
-#endif // <type_traits>
-
-template <typename T>
-struct is_trivially_copyable
-#if defined(BOOST_FUSION_IS_TRIVIALLY_COPYABLE)
-  : mpl::bool_<BOOST_FUSION_IS_TRIVIALLY_COPYABLE(T)>
-#elif !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
-  : std::is_trivially_copyable<T>
-#else
-  : is_trivially_copyable_impl<typename remove_all_extents<T>::type>
-#endif // <type_traits>
-{ };
-
-}}} // namespace boost::fusion::detail
-
-#endif
-
--- a/include/boost/fusion/support/detail/propagate_trivialness.hpp
+++ b/include/boost/fusion/support/detail/propagate_trivialness.hpp
@ -1,40 +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)
-==============================================================================*/
-#ifndef BOOST_FUSION_SUPPORT_DETAIL_PROPAGATE_TRIVIALNESS
-#define BOOST_FUSION_SUPPORT_DETAIL_PROPAGATE_TRIVIALNESS
-
-#include <boost/fusion/support/config.hpp>
-#include <boost/fusion/support/detail/and.hpp>
-#include <boost/fusion/support/detail/is_trivially_copyable.hpp>
-#include <boost/mpl/if.hpp>
-
-namespace boost { namespace fusion { namespace detail
-{
-
-struct trivial_base { };
-
-struct non_trivial_base
-{
-    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-    BOOST_DEFAULTED_FUNCTION(non_trivial_base(), {})
-
-    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-    non_trivial_base(non_trivial_base const&) BOOST_NOEXCEPT { }
-};
-
-template <typename... T>
-struct propagate_trivialness
-  : mpl::if_c<and_<is_trivially_copyable<T>...>::value
-      , trivial_base
-      , non_trivial_base
-    >::type
-{ };
-
-}}} // namespace boost::fusion::detail
-
-#endif
-
--- a/include/boost/fusion/support/is_view.hpp
+++ b/include/boost/fusion/support/is_view.hpp
@ -14,6 +14,7 @@
 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
@ -32,6 +33,13 @@ 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>
        {
--- a/include/boost/fusion/tuple/tuple.hpp
+++ b/include/boost/fusion/tuple/tuple.hpp
@ -56,7 +56,7 @@ namespace boost { namespace fusion
        >
        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
        tuple(tuple<U...> const& other)
-            : base(other) {}
+            : base(vector_detail::each_elem(), other) {}

        template <
            typename ...U
@ -66,7 +66,7 @@ namespace boost { namespace fusion
        >
        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
        tuple(tuple<U...>&& other)
-            : base(std::move(other)) {}
+            : base(vector_detail::each_elem(), std::move(other)) {}

        template <
            typename ...U
@ -78,17 +78,17 @@ namespace boost { namespace fusion
        /*BOOST_CONSTEXPR*/ BOOST_FUSION_GPU_ENABLED
        explicit
        tuple(U&&... args)
-            : base(std::forward<U>(args)...) {}
+            : base(vector_detail::each_elem(), std::forward<U>(args)...) {}

        template<typename U1, typename U2>
        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
        tuple(std::pair<U1, U2> const& other)
-            : base(other.first, other.second) {}
+            : base(vector_detail::each_elem(), other.first, other.second) {}

        template<typename U1, typename U2>
        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
        tuple(std::pair<U1, U2>&& other)
-            : base(std::move(other.first), std::move(other.second)) {}
+            : base(vector_detail::each_elem(), std::move(other.first), std::move(other.second)) {}

        template<typename U>
        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
--- a/include/boost/fusion/view/filter_view/detail/next_impl.hpp
+++ b/include/boost/fusion/view/filter_view/detail/next_impl.hpp
@ -1,5 +1,6 @@
 /*=============================================================================
    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)
@ -8,14 +9,10 @@
 #define FUSION_NEXT_IMPL_06052005_0900

 #include <boost/fusion/support/config.hpp>
-#include <boost/fusion/algorithm/query/detail/find_if.hpp>
-#include <boost/fusion/iterator/value_of.hpp>
+#include <boost/fusion/iterator/next.hpp>
+#include <boost/fusion/iterator/equal_to.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
 {
@ -48,26 +45,13 @@ namespace boost { namespace fusion
                    >::type
                next_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;
+                typedef filter_iterator<category, next_type, last_type, pred_type> type;

                BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
                static type
                call(Iterator const& i)
                {
-                    return type(filter::iter_call(i.first));
+                    return type(fusion::next(i.first));
                }
            };
        };
--- a/include/boost/fusion/view/filter_view/filter_view_iterator.hpp
+++ b/include/boost/fusion/view/filter_view/filter_view_iterator.hpp
@ -1,5 +1,6 @@
 /*=============================================================================
    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,7 +10,6 @@

 #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>
--- a/include/boost/fusion/view/transform_view/detail/apply_transform_result.hpp
+++ b/include/boost/fusion/view/transform_view/detail/apply_transform_result.hpp
@ -1,38 +0,0 @@
-/*=============================================================================
-    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
-
-
--- a/include/boost/fusion/view/transform_view/detail/at_impl.hpp
+++ b/include/boost/fusion/view/transform_view/detail/at_impl.hpp
@ -1,6 +1,7 @@
 /*=============================================================================
    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)
@ -9,9 +10,8 @@
 #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,9 +29,8 @@ namespace boost { namespace fusion {
            struct apply
            {
                typedef typename Seq::transform_type F;
-                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;
+                typedef typename result_of::at<typename Seq::sequence_type, N>::type value_type;
+                typedef typename boost::result_of<F(value_type)>::type type;

                BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
                static type call(Seq& seq)
@ -48,10 +47,9 @@ namespace boost { namespace fusion {
            struct apply
            {
                typedef typename Seq::transform_type F;
-                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;
+                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;

                BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
                static type call(Seq& seq)
--- a/include/boost/fusion/view/transform_view/detail/deref_impl.hpp
+++ b/include/boost/fusion/view/transform_view/detail/deref_impl.hpp
@ -1,5 +1,6 @@
 /*=============================================================================
    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)
@ -8,10 +9,8 @@
 #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/fusion/iterator/value_of.hpp>
-#include <boost/fusion/view/transform_view/detail/apply_transform_result.hpp>
+#include <boost/utility/result_of.hpp>

 namespace boost { namespace fusion
 {
@ -34,8 +33,8 @@ namespace boost { namespace fusion
                    result_of::deref<typename Iterator::first_type>::type
                value_type;

-                typedef detail::apply_transform_result<typename Iterator::transform_type> transform_type;
-                typedef typename mpl::apply<transform_type, value_type>::type type;
+                typedef typename Iterator::transform_type F;
+                typedef typename boost::result_of<F(value_type)>::type type;

                BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
                static type
@ -60,8 +59,8 @@ namespace boost { namespace fusion
                    result_of::deref<typename Iterator::first2_type>::type
                value2_type;

-                typedef detail::apply_transform_result<typename Iterator::transform_type> transform_type;
-                typedef typename mpl::apply<transform_type, value1_type, value2_type>::type type;
+                typedef typename Iterator::transform_type F;
+                typedef typename boost::result_of<F(value1_type, value2_type)>::type type;

                BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
                static type
@ -70,7 +69,7 @@ namespace boost { namespace fusion
                    return i.f(*i.first1, *i.first2);
                }
            };
-        };    
+        };
    }
 }}

--- a/include/boost/fusion/view/transform_view/detail/value_at_impl.hpp
+++ b/include/boost/fusion/view/transform_view/detail/value_at_impl.hpp
@ -1,6 +1,7 @@
 /*=============================================================================
    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)
@ -9,9 +10,8 @@
 #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,9 +29,8 @@ namespace boost { namespace fusion {
            struct apply
            {
                typedef typename Seq::transform_type F;
-                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;
+                typedef typename result_of::value_at<typename Seq::sequence_type, N>::type value_type;
+                typedef typename boost::result_of<F(value_type)>::type type;
            };
        };

@ -42,10 +41,9 @@ namespace boost { namespace fusion {
            struct apply
            {
                typedef typename Seq::transform_type F;
-                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;
+                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;
            };
        };
    }
--- a/include/boost/fusion/view/transform_view/detail/value_of_impl.hpp
+++ b/include/boost/fusion/view/transform_view/detail/value_of_impl.hpp
@ -1,5 +1,6 @@
 /*=============================================================================
    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)
@ -8,9 +9,8 @@
 #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/fusion/view/transform_view/detail/apply_transform_result.hpp>
+#include <boost/utility/result_of.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 detail::apply_transform_result<typename Iterator::transform_type> transform_type;
-                typedef typename mpl::apply<transform_type, value_type>::type type;
+                typedef typename Iterator::transform_type F;
+                typedef typename boost::result_of<F(value_type)>::type type;
            };
        };

@ -52,8 +52,8 @@ namespace boost { namespace fusion
                    result_of::value_of<typename Iterator::first2_type>::type
                value2_type;

-                typedef detail::apply_transform_result<typename Iterator::transform_type> transform_type;
-                typedef typename mpl::apply<transform_type, value1_type, value2_type>::type type;
+                typedef typename Iterator::transform_type F;
+                typedef typename boost::result_of<F(value1_type, value2_type)>::type type;
            };
        };
    }
--- a/test/Jamfile
+++ b/test/Jamfile
@ -66,6 +66,7 @@ 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 ]
@ -154,8 +155,6 @@ project
    [ run sequence/tuple_traits.cpp : :
        : <define>BOOST_FUSION_DISABLE_VARIADIC_VECTOR
        : tuple_traits__no_variadic ]
-    [ run sequence/tuple_trivially_copyable.cpp : :
-        : [ requires cxx11_variadic_templates ] ]
    [ run sequence/transform_view.cpp ]
    [ run sequence/vector_comparison.cpp ]
    [ run sequence/vector_construction.cpp ]
@ -177,8 +176,6 @@ project
    [ run sequence/vector_traits.cpp : :
        : <define>BOOST_FUSION_DISABLE_VARIADIC_VECTOR
        : vector_traits__no_variadic ]
-    [ run sequence/vector_trivially_copyable.cpp : :
-        : [ requires cxx11_variadic_templates ] ]
    [ run sequence/vector_value_at.cpp ]
    [ run sequence/zip_view.cpp ]
    [ run sequence/zip_view2.cpp ]
@ -260,6 +257,7 @@ project
    [ run sequence/swap.cpp ]

    [ compile support/is_sequence.cpp ]
+    [ compile support/is_view.cpp ]
    [ compile support/pair_deque.cpp ]
    [ compile support/pair_list.cpp ]
    [ compile support/pair_map.cpp ]
@ -272,9 +270,6 @@ project
        : [ requires cxx11_variadic_templates ] ]
    [ compile support/tag_of.cpp ]
    [ compile support/unused.cpp ]
-    [ compile support/is_trivially_copyable.cpp ]
-    [ compile support/propagate_trivialness.cpp
-        : [ requires cxx11_variadic_templates ] ]

 #   [ compile-fail xxx.cpp  ]

--- a/test/algorithm/for_each.cpp
+++ b/test/algorithm/for_each.cpp
@ -1,13 +1,15 @@
 /*=============================================================================
    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/detail/lightweight_test.hpp>
+#include <boost/core/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>

@ -29,6 +31,15 @@ struct increment
    }
 };

+struct mutable_increment : increment
+{
+    template <typename T>
+    void operator()(T& v)
+    {
+        return increment::operator()(v);
+    }
+};
+
 int
 main()
 {
@ -44,9 +55,20 @@ 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;
    }

--- a/test/algorithm/segmented_for_each.cpp
+++ b/test/algorithm/segmented_for_each.cpp
@ -1,14 +1,17 @@
 /*=============================================================================
    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/detail/lightweight_test.hpp>
+#include <boost/core/lightweight_test.hpp>
 #include <boost/fusion/container/vector/vector.hpp>
-#include <boost/fusion/algorithm/iteration/for_each.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 "../sequence/tree.hpp"

 struct print
@ -20,6 +23,31 @@ 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()
 {
@ -42,6 +70,69 @@ 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();
--- a/test/algorithm/ticket-5490.cpp
+++ b/test/algorithm/ticket-5490.cpp
@ -0,0 +1,41 @@
+/*=============================================================================
+    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);
+}
--- a/test/sequence/adapt_adt.cpp
+++ b/test/sequence/adapt_adt.cpp
@ -165,6 +165,7 @@ 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;
@ -237,6 +238,7 @@ 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;
@ -300,7 +302,7 @@ main()
        BOOST_MPL_ASSERT((
            boost::is_same<
                boost::fusion::result_of::back<ns::point const>::type::type,
-                const int
+                int
            >));
    }

--- a/test/sequence/adapt_adt_empty.cpp
+++ b/test/sequence/adapt_adt_empty.cpp
@ -42,6 +42,7 @@ 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;
--- a/test/sequence/adapt_adt_named.cpp
+++ b/test/sequence/adapt_adt_named.cpp
@ -93,6 +93,7 @@ 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);

--- a/test/sequence/adapt_adt_named_empty.cpp
+++ b/test/sequence/adapt_adt_named_empty.cpp
@ -43,6 +43,7 @@ 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;
--- a/test/sequence/adapt_assoc_adt.cpp
+++ b/test/sequence/adapt_assoc_adt.cpp
@ -84,6 +84,7 @@ 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;
--- a/test/sequence/adapt_assoc_adt_empty.cpp
+++ b/test/sequence/adapt_assoc_adt_empty.cpp
@ -42,6 +42,7 @@ 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;
--- a/test/sequence/adapt_assoc_adt_named.cpp
+++ b/test/sequence/adapt_assoc_adt_named.cpp
@ -80,6 +80,7 @@ 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);

--- a/test/sequence/adapt_assoc_adt_named_empty.cpp
+++ b/test/sequence/adapt_assoc_adt_named_empty.cpp
@ -43,6 +43,7 @@ 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;
--- a/test/sequence/adapt_assoc_struct.cpp
+++ b/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,6 +86,7 @@ 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;
--- a/test/sequence/adapt_assoc_struct_empty.cpp
+++ b/test/sequence/adapt_assoc_struct_empty.cpp
@ -42,6 +42,7 @@ 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;
--- a/test/sequence/adapt_assoc_struct_named.cpp
+++ b/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,6 +66,7 @@ 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);

--- a/test/sequence/adapt_assoc_struct_named_empty.cpp
+++ b/test/sequence/adapt_assoc_struct_named_empty.cpp
@ -43,6 +43,7 @@ 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;
--- a/test/sequence/adapt_assoc_tpl_adt.cpp
+++ b/test/sequence/adapt_assoc_tpl_adt.cpp
@ -98,6 +98,7 @@ 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;
--- a/test/sequence/adapt_assoc_tpl_struct.cpp
+++ b/test/sequence/adapt_assoc_tpl_struct.cpp
@ -96,6 +96,7 @@ 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;
--- a/test/sequence/adapt_struct.cpp
+++ b/test/sequence/adapt_struct.cpp
@ -170,6 +170,7 @@ 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;
--- a/test/sequence/adapt_struct_empty.cpp
+++ b/test/sequence/adapt_struct_empty.cpp
@ -42,6 +42,7 @@ 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;
--- a/test/sequence/adapt_struct_named.cpp
+++ b/test/sequence/adapt_struct_named.cpp
@ -87,6 +87,7 @@ 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);

--- a/test/sequence/adapt_struct_named_empty.cpp
+++ b/test/sequence/adapt_struct_named_empty.cpp
@ -43,6 +43,7 @@ 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;
--- a/test/sequence/adapt_tpl_adt.cpp
+++ b/test/sequence/adapt_tpl_adt.cpp
@ -107,6 +107,7 @@ 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;
--- a/test/sequence/adapt_tpl_struct.cpp
+++ b/test/sequence/adapt_tpl_struct.cpp
@ -96,6 +96,7 @@ 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;
--- a/test/sequence/adt_attribute_proxy.cpp
+++ b/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/detail/lightweight_test.hpp>
+#include <boost/core/lightweight_test.hpp>
 #include <boost/fusion/adapted/adt/adapt_assoc_adt.hpp>
 #include <boost/fusion/sequence.hpp>
 #include <boost/mpl/assert.hpp>
@ -185,4 +185,5 @@ int main()
        BOOST_TEST(fusion::front(ec).get()=="marshall mathers");
        BOOST_TEST(fusion::back(ec).get()==37);
    }
+    return boost::report_errors();
 }
--- a/test/sequence/array.cpp
+++ b/test/sequence/array.cpp
@ -22,6 +22,8 @@ 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};

--- a/test/sequence/boost_array.cpp
+++ b/test/sequence/boost_array.cpp
@ -26,6 +26,8 @@ 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}};

--- a/test/sequence/boost_tuple.cpp
+++ b/test/sequence/boost_tuple.cpp
@ -46,6 +46,7 @@ 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;
--- a/test/sequence/construction.hpp
+++ b/test/sequence/construction.hpp
@ -54,11 +54,14 @@ 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;
--- a/test/sequence/define_assoc_struct.cpp
+++ b/test/sequence/define_assoc_struct.cpp
@ -42,6 +42,7 @@ 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;
--- a/test/sequence/define_assoc_struct_empty.cpp
+++ b/test/sequence/define_assoc_struct_empty.cpp
@ -30,6 +30,7 @@ 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;
--- a/test/sequence/define_assoc_tpl_struct.cpp
+++ b/test/sequence/define_assoc_tpl_struct.cpp
@ -46,6 +46,7 @@ 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;
--- a/test/sequence/define_assoc_tpl_struct_empty.cpp
+++ b/test/sequence/define_assoc_tpl_struct_empty.cpp
@ -30,6 +30,7 @@ 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;
--- a/test/sequence/define_struct.cpp
+++ b/test/sequence/define_struct.cpp
@ -54,6 +54,7 @@ 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;
--- a/test/sequence/define_struct_empty.cpp
+++ b/test/sequence/define_struct_empty.cpp
@ -30,6 +30,7 @@ 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;
--- a/test/sequence/define_struct_inline.cpp
+++ b/test/sequence/define_struct_inline.cpp
@ -66,6 +66,7 @@ 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;
--- a/test/sequence/define_struct_inline_empty.cpp
+++ b/test/sequence/define_struct_inline_empty.cpp
@ -30,6 +30,7 @@ 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;
--- a/test/sequence/define_tpl_struct.cpp
+++ b/test/sequence/define_tpl_struct.cpp
@ -42,6 +42,7 @@ 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;
--- a/test/sequence/define_tpl_struct_inline.cpp
+++ b/test/sequence/define_tpl_struct_inline.cpp
@ -61,6 +61,7 @@ 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;
--- a/test/sequence/github-176.cpp
+++ b/test/sequence/github-176.cpp
@ -86,4 +86,5 @@ int main()
    test_at_key<set<int[3]> >();
 #endif
    test_at_key<map<pair<int[3], int[3]> > >();
+    return boost::report_errors();
 }
--- a/test/sequence/hash.cpp
+++ b/test/sequence/hash.cpp
@ -7,7 +7,7 @@

 #include <string>

-#include <boost/detail/lightweight_test.hpp>
+#include <boost/core/lightweight_test.hpp>
 #include <boost/fusion/include/adapt_struct.hpp>
 #include <boost/fusion/sequence/hash.hpp>

@ -55,4 +55,5 @@ 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();
 }
--- a/test/sequence/map_construction.cpp
+++ b/test/sequence/map_construction.cpp
@ -55,11 +55,14 @@ 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;
--- a/test/sequence/set.cpp
+++ b/test/sequence/set.cpp
@ -89,6 +89,9 @@ 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
--- a/test/sequence/std_array.cpp
+++ b/test/sequence/std_array.cpp
@ -33,6 +33,8 @@ 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}};

--- a/test/sequence/std_pair.cpp
+++ b/test/sequence/std_pair.cpp
@ -44,6 +44,7 @@ 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;
--- a/test/sequence/trivially_copyable.hpp
+++ b/test/sequence/trivially_copyable.hpp
@ -1,76 +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)
-==============================================================================*/
-#ifndef TRIVIALLY_COPYABLE_HPP
-#define TRIVIALLY_COPYABLE_HPP
-
-#include <boost/fusion/support/detail/is_trivially_copyable.hpp>
-
-#include <boost/mpl/assert.hpp>
-#include "../support/trivial.hpp"
-
-using namespace boost::fusion;
-
-BOOST_FUSION_ASSERT_CWG496((detail::is_trivially_copyable<FUSION_SEQUENCE<> >));
-BOOST_FUSION_ASSERT_CWG496((detail::is_trivially_copyable<FUSION_SEQUENCE<int> >));
-BOOST_FUSION_ASSERT_CWG496((detail::is_trivially_copyable<FUSION_SEQUENCE<int, int> >));
-BOOST_FUSION_ASSERT_CWG496((detail::is_trivially_copyable<FUSION_SEQUENCE<int, int, int> >));
-BOOST_MPL_ASSERT_NOT((detail::is_trivially_copyable<FUSION_SEQUENCE<int&> >));
-BOOST_MPL_ASSERT_NOT((detail::is_trivially_copyable<FUSION_SEQUENCE<int, int&> >));
-BOOST_MPL_ASSERT_NOT((detail::is_trivially_copyable<FUSION_SEQUENCE<int, int, int&> >));
-
-BOOST_FUSION_ASSERT_CWG496((detail::is_trivially_copyable<FUSION_SEQUENCE<FUSION_SEQUENCE<> > >));
-BOOST_FUSION_ASSERT_CWG496((detail::is_trivially_copyable<FUSION_SEQUENCE<FUSION_SEQUENCE<int> > >));
-BOOST_FUSION_ASSERT_CWG496((detail::is_trivially_copyable<FUSION_SEQUENCE<FUSION_SEQUENCE<int>, FUSION_SEQUENCE<int, int> > >));
-BOOST_FUSION_ASSERT_CWG496((detail::is_trivially_copyable<FUSION_SEQUENCE<FUSION_SEQUENCE<int>, FUSION_SEQUENCE<int, int>, FUSION_SEQUENCE<int, int, int> > >));
-
-BOOST_FUSION_ASSERT_CWG496((detail::is_trivially_copyable<FUSION_SEQUENCE<int, trivial> >));
-BOOST_MPL_ASSERT_NOT((detail::is_trivially_copyable<FUSION_SEQUENCE<int, user_provided_copy> >));
-BOOST_MPL_ASSERT_NOT((detail::is_trivially_copyable<FUSION_SEQUENCE<int, user_provided_move> >));
-BOOST_MPL_ASSERT_NOT((detail::is_trivially_copyable<FUSION_SEQUENCE<int, user_provided_dtor> >));
-
-#ifdef BOOST_FUSION_DETAIL_IS_TRIVIALLY_COPYABLE_CONFORMING
-#include <boost/core/lightweight_test.hpp>
-#include <boost/core/addressof.hpp>
-#include <boost/fusion/sequence/intrinsic/at_c.hpp>
-#include <boost/fusion/sequence/comparison/equal_to.hpp>
-#include <cstring>
-
-int main()
-{
-    typedef FUSION_SEQUENCE<char, double, const int*> seq_t;
-    BOOST_MPL_ASSERT((detail::is_trivially_copyable<seq_t>));
-
-    char* storage = new char[sizeof(seq_t)];
-
-    int i = 42;
-
-    const seq_t* src = new seq_t('\t', 3.14159265359, &i);
-    std::memcpy(static_cast<void*>(storage), src, sizeof(seq_t));
-
-    seq_t* dst = new seq_t;
-    std::memcpy(dst, static_cast<void const*>(storage), sizeof(seq_t));
-
-    BOOST_TEST((*src) == (*dst));
-    BOOST_TEST(boost::fusion::at_c<0>(*src) == '\t');
-    BOOST_TEST(boost::fusion::at_c<1>(*src) == 3.14159265359);
-    BOOST_TEST(boost::fusion::at_c<2>(*src) == &i);
-    BOOST_TEST(*boost::fusion::at_c<2>(*src) == 42);
-    BOOST_TEST(boost::fusion::at_c<0>(*dst) == '\t');
-    BOOST_TEST(boost::fusion::at_c<1>(*dst) == 3.14159265359);
-    BOOST_TEST(boost::fusion::at_c<2>(*dst) == &i);
-    BOOST_TEST(*boost::fusion::at_c<2>(*dst) == 42);
-
-    delete dst;
-    delete src;
-    delete [] storage;
-
-    return boost::report_errors();
-}
-#else
-int main() { }
-#endif
-#endif
--- a/test/sequence/vector_n.cpp
+++ b/test/sequence/vector_n.cpp
@ -94,7 +94,7 @@ main()
    }

    {
-        vector2<int, int> t1(123, 456);
+        vector2<int, short> t1(123, 456);
        vector2<double, float> t2(t1);
        (void)t2;
    }
--- a/test/sequence/vector_trivially_copyable.cpp
+++ b/test/sequence/vector_trivially_copyable.cpp
@ -1,17 +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/container/vector/detail/config.hpp>
-
-#ifndef BOOST_FUSION_HAS_VARIADIC_VECTOR
-int main() { }
-#else
-
-#include <boost/fusion/container/vector/vector.hpp>
-#define FUSION_SEQUENCE boost::fusion::vector
-#include "trivially_copyable.hpp"
-#endif
-
--- a/test/support/is_trivially_copyable.cpp
+++ b/test/support/is_trivially_copyable.cpp
@ -1,766 +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/detail/is_trivially_copyable.hpp>
-#include <boost/mpl/assert.hpp>
-#include "trivial.hpp"
-
-using namespace boost;
-using namespace boost::fusion::detail;
-
-// disable cv-qialifer on function type warning
-#if defined(BOOST_CLANG)
-#   pragma clang diagnostic ignored "-Wignored-qualifiers"
-#elif defined(BOOST_MSVC)
-#   pragma warning(disable: 4180)
-#endif
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<void>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<void const>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<void volatile>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<void const volatile>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<int>));
-BOOST_MPL_ASSERT((is_trivially_copyable<int const>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<int volatile>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<int const volatile>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<int*>));
-BOOST_MPL_ASSERT((is_trivially_copyable<int const*>));
-BOOST_MPL_ASSERT((is_trivially_copyable<int volatile*>));
-BOOST_MPL_ASSERT((is_trivially_copyable<int const volatile*>));
-BOOST_MPL_ASSERT((is_trivially_copyable<int* const>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<int* volatile>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<int* const volatile>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int const&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int volatile&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int const volatile&>));
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int&&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int const&&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int volatile&&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int const volatile&&>));
-#endif
-
-BOOST_MPL_ASSERT((is_trivially_copyable<int[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<int const[]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<int volatile[]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<int const volatile[]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<int[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<int const[3]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<int volatile[3]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<int const volatile[3]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<int[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<int const[][3][4][5]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<int volatile[][3][4][5]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<int const volatile[][3][4][5]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<int(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<int const(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<int volatile(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<int const volatile(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<int(*const)[]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<int(*volatile)[]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<int(*const volatile)[]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<int(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<int const(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<int volatile(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<int const volatile(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<int(*const)[3]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<int(*volatile)[3]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<int(*const volatile)[3]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<int(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<int const(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<int volatile(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<int const volatile(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<int(*const)[][3][4][5]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<int(*volatile)[][3][4][5]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<int(*const volatile)[][3][4][5]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int(&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int const(&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int volatile(&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int const volatile(&)[]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int(&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int const(&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int volatile(&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int const volatile(&)[3]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int(&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int const(&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int volatile(&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int const volatile(&)[][3][4][5]>));
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int(&&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int const(&&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int volatile(&&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int const volatile(&&)[]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int(&&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int const(&&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int volatile(&&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int const volatile(&&)[3]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int(&&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int const(&&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int volatile(&&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int const volatile(&&)[][3][4][5]>));
-#endif
-
-typedef int function_type();
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type const>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type volatile>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type const volatile>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type*>));
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type const*>));
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type volatile*>));
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type const volatile*>));
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type* const>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<function_type* volatile>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<function_type* const volatile>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type const&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type volatile&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type const volatile&>));
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type&&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type const&&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type volatile&&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type const volatile&&>));
-#endif
-
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type*[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type const*[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type volatile*[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type const volatile*[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type* const[]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<function_type* volatile[]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<function_type* const volatile[]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type*[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type const*[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type volatile*[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type const volatile*[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type* const[3]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<function_type* volatile[3]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<function_type* const volatile[3]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type*[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type const*[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type volatile*[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type const volatile*[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type* const[][3][4][5]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<function_type* volatile[][3][4][5]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<function_type* const volatile[][3][4][5]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type*(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type const*(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type volatile*(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type const volatile*(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type*(*const)[]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<function_type*(*volatile)[]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<function_type*(*const volatile)[]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type*(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type const*(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type volatile*(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type const volatile*(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type*(*const)[3]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<function_type*(*volatile)[3]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<function_type*(*const volatile)[3]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type*(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type const*(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type volatile*(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type const volatile*(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type*(*const)[][3][4][5]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<function_type*(*volatile)[][3][4][5]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<function_type*(*const volatile)[][3][4][5]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type*(&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type const*(&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type volatile*(&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type const volatile*(&)[]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type*(&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type const*(&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type volatile*(&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type const volatile*(&)[3]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type*(&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type const*(&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type volatile*(&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type const volatile*(&)[][3][4][5]>));
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type*(&&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type const*(&&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type volatile*(&&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type const volatile*(&&)[]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type*(&&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type const*(&&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type volatile*(&&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type const volatile*(&&)[3]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type*(&&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type const*(&&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type volatile*(&&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type const volatile*(&&)[][3][4][5]>));
-#endif
-
-BOOST_MPL_ASSERT((is_trivially_copyable<member_type>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_type const>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_type volatile>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_type const volatile>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<member_type[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_type const[]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_type volatile[]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_type const volatile[]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<member_type[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_type const[3]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_type volatile[3]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_type const volatile[3]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<member_type[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_type const[][3][4][5]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_type volatile[][3][4][5]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_type const volatile[][3][4][5]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<member_type(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_type const(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_type volatile(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_type const volatile(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_type(*const)[]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_type(*volatile)[]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_type(*const volatile)[]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<member_type(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_type const(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_type volatile(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_type const volatile(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_type(*const)[3]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_type(*volatile)[3]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_type(*const volatile)[3]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<member_type(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_type const(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_type volatile(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_type const volatile(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_type(*const)[][3][4][5]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_type(*volatile)[][3][4][5]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_type(*const volatile)[][3][4][5]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type(&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type const(&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type volatile(&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type const volatile(&)[]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type(&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type const(&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type volatile(&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type const volatile(&)[3]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type(&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type const(&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type volatile(&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type const volatile(&)[][3][4][5]>));
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type(&&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type const(&&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type volatile(&&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type const volatile(&&)[]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type(&&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type const(&&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type volatile(&&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type const volatile(&&)[3]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type(&&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type const(&&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type volatile(&&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type const volatile(&&)[][3][4][5]>));
-#endif
-
-BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type const>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_function_type volatile>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_function_type const volatile>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type const[]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_function_type volatile[]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_function_type const volatile[]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type const[3]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_function_type volatile[3]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_function_type const volatile[3]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type const[][3][4][5]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_function_type volatile[][3][4][5]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_function_type const volatile[][3][4][5]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type const(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type volatile(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type const volatile(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type(*const)[]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_function_type(*volatile)[]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_function_type(*const volatile)[]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type const(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type volatile(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type const volatile(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type(*const)[3]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_function_type(*volatile)[3]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_function_type(*const volatile)[3]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type const(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type volatile(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type const volatile(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type(*const)[][3][4][5]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_function_type(*volatile)[][3][4][5]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_function_type(*const volatile)[][3][4][5]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type(&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type const(&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type volatile(&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type const volatile(&)[]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type(&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type const(&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type volatile(&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type const volatile(&)[3]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type(&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type const(&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type volatile(&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type const volatile(&)[][3][4][5]>));
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type(&&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type const(&&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type volatile(&&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type const volatile(&&)[]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type(&&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type const(&&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type volatile(&&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type const volatile(&&)[3]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type(&&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type const(&&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type volatile(&&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type const volatile(&&)[][3][4][5]>));
-#endif
-
-
-BOOST_FUSION_ASSERT_CWG496((is_trivially_copyable<trivial>));
-BOOST_FUSION_ASSERT_CWG496((is_trivially_copyable<trivial const>));
-BOOST_FUSION_ASSERT_CWG2094((is_trivially_copyable<trivial volatile>));
-BOOST_FUSION_ASSERT_CWG2094((is_trivially_copyable<trivial const volatile>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<trivial*>));
-BOOST_MPL_ASSERT((is_trivially_copyable<trivial const*>));
-BOOST_MPL_ASSERT((is_trivially_copyable<trivial volatile*>));
-BOOST_MPL_ASSERT((is_trivially_copyable<trivial const volatile*>));
-BOOST_MPL_ASSERT((is_trivially_copyable<trivial* const>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<trivial* volatile>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<trivial* const volatile>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial const&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial volatile&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial const volatile&>));
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial&&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial const&&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial volatile&&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial const volatile&&>));
-#endif
-
-BOOST_FUSION_ASSERT_CWG496((is_trivially_copyable<trivial[]>));
-BOOST_FUSION_ASSERT_CWG496((is_trivially_copyable<trivial const[]>));
-BOOST_FUSION_ASSERT_CWG2094((is_trivially_copyable<trivial volatile[]>));
-BOOST_FUSION_ASSERT_CWG2094((is_trivially_copyable<trivial const volatile[]>));
-
-BOOST_FUSION_ASSERT_CWG496((is_trivially_copyable<trivial[3]>));
-BOOST_FUSION_ASSERT_CWG496((is_trivially_copyable<trivial const[3]>));
-BOOST_FUSION_ASSERT_CWG2094((is_trivially_copyable<trivial volatile[3]>));
-BOOST_FUSION_ASSERT_CWG2094((is_trivially_copyable<trivial const volatile[3]>));
-
-BOOST_FUSION_ASSERT_CWG496((is_trivially_copyable<trivial[][3][4][5]>));
-BOOST_FUSION_ASSERT_CWG496((is_trivially_copyable<trivial const[][3][4][5]>));
-BOOST_FUSION_ASSERT_CWG2094((is_trivially_copyable<trivial volatile[][3][4][5]>));
-BOOST_FUSION_ASSERT_CWG2094((is_trivially_copyable<trivial const volatile[][3][4][5]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<trivial(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<trivial const(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<trivial volatile(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<trivial const volatile(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<trivial(*const)[]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<trivial(*volatile)[]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<trivial(*const volatile)[]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<trivial(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<trivial const(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<trivial volatile(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<trivial const volatile(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<trivial(*const)[3]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<trivial(*volatile)[3]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<trivial(*const volatile)[3]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<trivial(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<trivial const(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<trivial volatile(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<trivial const volatile(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<trivial(*const)[][3][4][5]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<trivial(*volatile)[][3][4][5]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<trivial(*const volatile)[][3][4][5]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial(&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial const(&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial volatile(&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial const volatile(&)[]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial(&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial const(&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial volatile(&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial const volatile(&)[3]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial(&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial const(&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial volatile(&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial const volatile(&)[][3][4][5]>));
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial(&&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial const(&&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial volatile(&&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial const volatile(&&)[]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial(&&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial const(&&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial volatile(&&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial const volatile(&&)[3]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial(&&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial const(&&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial volatile(&&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial const volatile(&&)[][3][4][5]>));
-#endif
-
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy volatile>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const volatile>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy*>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy const*>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy volatile*>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy const volatile*>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy* const>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_copy* volatile>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_copy* const volatile>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy volatile&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const volatile&>));
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy&&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const&&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy volatile&&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const volatile&&>));
-#endif
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy volatile[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const volatile[]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy volatile[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const volatile[3]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy volatile[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const volatile[][3][4][5]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy const(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy volatile(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy const volatile(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy(*const)[]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_copy(*volatile)[]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_copy(*const volatile)[]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy const(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy volatile(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy const volatile(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy(*const)[3]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_copy(*volatile)[3]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_copy(*const volatile)[3]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy const(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy volatile(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy const volatile(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy(*const)[][3][4][5]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_copy(*volatile)[][3][4][5]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_copy(*const volatile)[][3][4][5]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy(&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const(&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy volatile(&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const volatile(&)[]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy(&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const(&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy volatile(&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const volatile(&)[3]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy(&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const(&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy volatile(&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const volatile(&)[][3][4][5]>));
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy(&&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const(&&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy volatile(&&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const volatile(&&)[]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy(&&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const(&&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy volatile(&&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const volatile(&&)[3]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy(&&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const(&&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy volatile(&&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const volatile(&&)[][3][4][5]>));
-#endif
-
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move volatile>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const volatile>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move*>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move const*>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move volatile*>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move const volatile*>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move* const>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_move* volatile>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_move* const volatile>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move volatile&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const volatile&>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move&&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const&&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move volatile&&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const volatile&&>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move volatile[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const volatile[]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move volatile[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const volatile[3]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move volatile[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const volatile[][3][4][5]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move const(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move volatile(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move const volatile(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move(*const)[]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_move(*volatile)[]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_move(*const volatile)[]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move const(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move volatile(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move const volatile(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move(*const)[3]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_move(*volatile)[3]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_move(*const volatile)[3]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move const(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move volatile(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move const volatile(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move(*const)[][3][4][5]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_move(*volatile)[][3][4][5]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_move(*const volatile)[][3][4][5]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move(&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const(&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move volatile(&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const volatile(&)[]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move(&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const(&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move volatile(&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const volatile(&)[3]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move(&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const(&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move volatile(&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const volatile(&)[][3][4][5]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move(&&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const(&&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move volatile(&&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const volatile(&&)[]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move(&&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const(&&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move volatile(&&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const volatile(&&)[3]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move(&&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const(&&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move volatile(&&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const volatile(&&)[][3][4][5]>));
-#endif
-
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor volatile>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const volatile>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor*>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor const*>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor volatile*>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor const volatile*>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor* const>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_dtor* volatile>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_dtor* const volatile>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor volatile&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const volatile&>));
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor&&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const&&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor volatile&&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const volatile&&>));
-#endif
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor volatile[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const volatile[]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor volatile[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const volatile[3]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor volatile[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const volatile[][3][4][5]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor const(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor volatile(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor const volatile(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor(*const)[]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_dtor(*volatile)[]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_dtor(*const volatile)[]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor const(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor volatile(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor const volatile(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor(*const)[3]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_dtor(*volatile)[3]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_dtor(*const volatile)[3]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor const(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor volatile(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor const volatile(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor(*const)[][3][4][5]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_dtor(*volatile)[][3][4][5]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_dtor(*const volatile)[][3][4][5]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor(&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const(&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor volatile(&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const volatile(&)[]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor(&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const(&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor volatile(&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const volatile(&)[3]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor(&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const(&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor volatile(&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const volatile(&)[][3][4][5]>));
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor(&&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const(&&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor volatile(&&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const volatile(&&)[]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor(&&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const(&&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor volatile(&&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const volatile(&&)[3]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor(&&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const(&&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor volatile(&&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const volatile(&&)[][3][4][5]>));
-#endif
--- a/test/sequence/tuple_trivially_copyable.cpp
+++ b/test/sequence/tuple_trivially_copyable.cpp
@ -1,17 +1,15 @@
 /*=============================================================================
-    Copyright (c) 2018 Kohei Takahashi
+    Copyright (c) 2018 Nikita Kniazev

-    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)
 ==============================================================================*/
-#include <boost/fusion/tuple/tuple_fwd.hpp>
+#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);

-#ifndef BOOST_FUSION_HAS_VARIADIC_TUPLE
 int main() { }
-#else
-
-#include <boost/fusion/tuple/tuple.hpp>
-#define FUSION_SEQUENCE boost::fusion::tuple
-#include "trivially_copyable.hpp"
-#endif
-
--- a/test/support/propagate_trivialness.cpp
+++ b/test/support/propagate_trivialness.cpp
@ -1,183 +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/detail/propagate_trivialness.hpp>
-#include <boost/fusion/support/detail/is_trivially_copyable.hpp>
-#include <boost/mpl/assert.hpp>
-#include <boost/type_traits/is_convertible.hpp>
-#include <boost/type_traits/is_base_of.hpp>
-#include <boost/type_traits/is_default_constructible.hpp>
-#include "trivial.hpp"
-
-using namespace boost;
-using namespace boost::fusion::detail;
-
-
-BOOST_MPL_ASSERT((is_default_constructible<trivial_base>));
-BOOST_MPL_ASSERT((is_default_constructible<non_trivial_base>));
-
-BOOST_FUSION_ASSERT_CWG496((is_trivially_copyable<trivial_base>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<non_trivial_base>));
-
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<> >));
-
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<int> >));
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<int const> >));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_base_of<trivial_base, propagate_trivialness<int volatile> >));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_base_of<trivial_base, propagate_trivialness<int const volatile> >));
-
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<int*> >));
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<int const*> >));
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<int volatile*> >));
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<int const volatile*> >));
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<int* const> >));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_base_of<trivial_base, propagate_trivialness<int* volatile> >));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_base_of<trivial_base, propagate_trivialness<int* const volatile> >));
-
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<int&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<int const&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<int volatile&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<int const volatile&> >));
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<int&&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<int const&&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<int volatile&&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<int const volatile&&> >));
-#endif
-
-
-BOOST_FUSION_ASSERT_CWG496((is_base_of<trivial_base, propagate_trivialness<trivial> >));
-BOOST_FUSION_ASSERT_CWG496((is_base_of<trivial_base, propagate_trivialness<trivial const> >));
-BOOST_FUSION_ASSERT_CWG2094((is_base_of<trivial_base, propagate_trivialness<trivial volatile> >));
-BOOST_FUSION_ASSERT_CWG2094((is_base_of<trivial_base, propagate_trivialness<trivial const volatile> >));
-
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<trivial*> >));
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<trivial const*> >));
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<trivial volatile*> >));
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<trivial const volatile*> >));
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<trivial* const> >));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_base_of<trivial_base, propagate_trivialness<trivial* volatile> >));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_base_of<trivial_base, propagate_trivialness<trivial* const volatile> >));
-
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<trivial&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<trivial const&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<trivial volatile&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<trivial const volatile&> >));
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<trivial&&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<trivial const&&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<trivial volatile&&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<trivial const volatile&&> >));
-#endif
-
-
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_copy> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_copy const> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_copy volatile> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_copy const volatile> >));
-
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<user_provided_copy*> >));
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<user_provided_copy const*> >));
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<user_provided_copy volatile*> >));
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<user_provided_copy const volatile*> >));
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<user_provided_copy* const> >));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_base_of<trivial_base, propagate_trivialness<user_provided_copy* volatile> >));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_base_of<trivial_base, propagate_trivialness<user_provided_copy* const volatile> >));
-
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_copy&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_copy const&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_copy volatile&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_copy const volatile&> >));
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_copy&&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_copy const&&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_copy volatile&&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_copy const volatile&&> >));
-#endif
-
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_move> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_move const> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_move volatile> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_move const volatile> >));
-
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<user_provided_move*> >));
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<user_provided_move const*> >));
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<user_provided_move volatile*> >));
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<user_provided_move const volatile*> >));
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<user_provided_move* const> >));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_base_of<trivial_base, propagate_trivialness<user_provided_move* volatile> >));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_base_of<trivial_base, propagate_trivialness<user_provided_move* const volatile> >));
-
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_move&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_move const&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_move volatile&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_move const volatile&> >));
-
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_move&&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_move const&&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_move volatile&&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_move const volatile&&> >));
-#endif
-
-
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_dtor> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_dtor const> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_dtor volatile> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_dtor const volatile> >));
-
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<user_provided_dtor*> >));
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<user_provided_dtor const*> >));
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<user_provided_dtor volatile*> >));
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<user_provided_dtor const volatile*> >));
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<user_provided_dtor* const> >));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_base_of<trivial_base, propagate_trivialness<user_provided_dtor* volatile> >));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_base_of<trivial_base, propagate_trivialness<user_provided_dtor* const volatile> >));
-
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_dtor&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_dtor const&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_dtor volatile&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_dtor const volatile&> >));
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_dtor&&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_dtor const&&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_dtor volatile&&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_dtor const volatile&&> >));
-#endif
-
-
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<int, float, void*> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<int, float&, void*> >));
-BOOST_FUSION_ASSERT_CWG496((is_base_of<trivial_base, propagate_trivialness<int, float, trivial> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<int, float, user_provided_copy> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<int, float, user_provided_move> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<int, float, user_provided_dtor> >));
-
-
-struct S1 : private propagate_trivialness<int, float, void*> { };
-BOOST_MPL_ASSERT((is_trivially_copyable<S1>));
-
-struct S2 : private propagate_trivialness<int, float&, void*> { };
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<S2>));
-
-struct S3 : private propagate_trivialness<int, float, trivial> { };
-BOOST_FUSION_ASSERT_CWG496((is_trivially_copyable<S3>));
-
-struct S4 : private propagate_trivialness<int, float, user_provided_copy> { };
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<S4>));
-
-struct S5 : private propagate_trivialness<int, float, user_provided_move> { };
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<S5>));
-
-struct S6 : private propagate_trivialness<int, float, user_provided_dtor> { };
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<S6>));
--- a/test/support/trivial.hpp
+++ b/test/support/trivial.hpp
@ -1,66 +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)
-==============================================================================*/
-#ifndef TRIVIAL_HPP
-#define TRIVIAL_HPP
-
-#include <boost/fusion/support/detail/is_trivially_copyable.hpp>
-#include <boost/mpl/assert.hpp>
-#include <boost/static_assert.hpp>
-
-#if defined(BOOST_FUSION_DETAIL_VOLATILE_SCALAR_IS_NON_TRIVIALLY_COPYABLE)
-#   define BOOST_FUSION_ASSERT_CWG496_SCALAR BOOST_MPL_ASSERT_NOT
-#elif defined(BOOST_FUSION_IS_TRIVIALLY_COPYABLE)
-#   define BOOST_FUSION_ASSERT_CWG496_SCALAR_I(...) BOOST_STATIC_ASSERT((__VA_ARGS__::value) == BOOST_FUSION_IS_TRIVIALLY_COPYABLE(int volatile))
-#   define BOOST_FUSION_ASSERT_CWG496_SCALAR(pred) BOOST_FUSION_ASSERT_CWG496_SCALAR_I pred
-#else
-#   define BOOST_FUSION_ASSERT_CWG496_SCALAR BOOST_MPL_ASSERT
-#endif
-
-#if defined(BOOST_FUSION_IS_TRIVIALLY_COPYABLE)
-#   define BOOST_FUSION_ASSERT_CWG496 BOOST_MPL_ASSERT
-#   define BOOST_FUSION_ASSERT_CWG2094_I(...) BOOST_STATIC_ASSERT((__VA_ARGS__::value) == BOOST_FUSION_IS_TRIVIALLY_COPYABLE(trivial volatile))
-#   define BOOST_FUSION_ASSERT_CWG2094(pred) BOOST_FUSION_ASSERT_CWG2094_I pred
-#elif defined(BOOST_FUSION_DETAIL_IS_TRIVIALLY_COPYABLE_CONFORMING)
-#   define BOOST_FUSION_ASSERT_CWG496 BOOST_MPL_ASSERT
-#   define BOOST_FUSION_ASSERT_CWG2094 BOOST_MPL_ASSERT
-#else
-#   define BOOST_FUSION_ASSERT_CWG496(pred) struct skip_assertion
-#   define BOOST_FUSION_ASSERT_CWG2094(pred) struct skip_assertion
-#endif
-
-
-struct S;
-typedef int (S::*member_type);
-typedef int (S::*member_function_type)();
-
-
-struct trivial { };
-
-
-struct user_provided_copy
-{
-    user_provided_copy(user_provided_copy const&);
-    user_provided_copy& operator=(user_provided_copy const&);
-};
-
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-struct user_provided_move
-{
-    user_provided_move(user_provided_move&&);
-    user_provided_move& operator=(user_provided_move&&);
-};
-#endif
-
-
-struct user_provided_dtor
-{
-    ~user_provided_dtor();
-};
-
-#endif
-
--- a/test/support/unused.cpp
+++ b/test/support/unused.cpp
@ -19,7 +19,7 @@ void unused_construction()
 {
    boost::fusion::unused_type dephault;

-    boost::fusion::unused_type BOOST_ATTRIBUTE_UNUSED parenthesis();
+    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 = {};
@ -91,5 +91,6 @@ void only_unused()
    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)));
 }
Author	SHA1	Message	Date
Kohei Takahashi	81a1c2c99a	Merge pull request #207 from boostorg/develop Update CI scripts on master	2019-01-10 17:19:50 +09:00
Kohei Takahashi	7b55860d78	Merge pull request #206 from boostorg/update-ci Update CI scripts	2019-01-10 08:45:02 +09:00
Kohei Takahashi	70837a30c5	CI: Added clang-win runner	2019-01-09 18:59:05 +09:00
Kohei Takahashi	2e91d0b78e	CI: Updated travis compiler matrix	2019-01-09 18:58:40 +09:00
Kohei Takahashi	e375a4541b	CI: Updated for the recent boost-install changes	2019-01-09 18:33:23 +09:00
Kohei Takahashi	62137c0ab7	Merge pull request #204 from boostorg/develop boost 1.69	2018-10-31 08:23:10 +09:00
Kohei Takahashi	753db26073	Merge pull request #198 from Kojoley/vector-simplify-at_impl vector: Simplify at_impl	2018-10-25 22:12:38 +09:00
Kohei Takahashi	309a2d623f	Merge pull request #201 from Kojoley/a-slightly-cleaner-n3031-workaround A slightly cleaner N3031 workaround	2018-10-18 08:17:24 +09:00
Nikita Kniazev	b5ba6cbd2b	N3031 workaround for compilers without alias templates	2018-10-14 02:49:25 +03:00
Nikita Kniazev	2160949150	A slightly cleaner N3031 workaround	2018-10-12 00:34:20 +03:00
Kohei Takahashi	6208b083fb	Merge pull request #199 from Kojoley/simplify-is_same_size Simplify is_same_size	2018-10-10 22:34:30 +09:00
Kohei Takahashi	95beeba19c	Merge pull request #197 from Kojoley/vector_n-test-fix-warning TST: vector_n: Fixed conversion warning	2018-10-10 22:31:53 +09:00
Nikita Kniazev	efe9065b8c	vector: Simplify at_impl	2018-10-10 04:19:10 +03:00
Nikita Kniazev	d1da8ee746	Simplify is_same_size	2018-10-07 23:17:40 +03:00
Nikita Kniazev	a26dcf59ce	TST: vector_n: Fixed conversion warning ``` boost\fusion\container\vector\vector.hpp(168): warning C4244: 'initializing': conversion from 'T' to 'T', possible loss of data 1> with 1> [ 1> T=int 1> ] 1> and 1> [ 1> T=float 1> ] ```	2018-10-05 15:54:35 +03:00
Kohei Takahashi	6b5c5be9be	Merge pull request #195 from Kojoley/patch-2 map_fwd: Do not include the implementation details	2018-09-27 09:35:05 +09:00
Kohei Takahashi	8c36079edb	Merge pull request #193 from Kojoley/patch-1 Update decltype(expr)::type WA for Clang 3.0	2018-09-27 09:34:43 +09:00
Glen Fernandes	9db262acf5	Fix unit tests that did not return report_errors()	2018-09-24 19:43:33 -04:00
Nikita Kniazev	a3abadb884	map_fwd: Do not include the implementation details	2018-09-25 02:21:05 +03:00
Glen Fernandes	3cfbd9826d	Fix unit tests that did not return report_errors()	2018-09-17 07:17:29 -04:00
Nikita Kniazev	c1fea895c2	Update decltype(expr)::type WA for Clang 3.0	2018-08-17 01:36:56 +03:00
Kohei Takahashi	6a3ddd1458	Merge pull request #191 from boostorg/adapt-adt/return-const adapt/adt: Don't add/remove const on return type of attributes	2018-08-09 08:21:49 +09:00
Kohei Takahashi	b1f20628bb	Merge pull request #192 from Kojoley/define-is_view-for-non-fusion Define traits::is_view for non fusion types	2018-08-03 09:46:42 +09:00
Nikita Kniazev	b0f0882229	Define traits::is_view for non fusion types	2018-08-03 00:24:10 +03:00
Kohei Takahashi	b8fafe04d9	Merge pull request #190 from boostorg/cleanup/filter_view Cleanup filter_view to improve performance	2018-08-02 12:53:08 +09:00
Kohei Takahashi	95b4500898	test: Suppress unused warning	2018-08-02 12:43:26 +09:00
Kohei Takahashi	b02cb70760	test: Suppress unused warning on MSVC	2018-08-02 09:37:32 +09:00
Kohei Takahashi	77ebd568e1	adapt/adt: Don't add/remove const on return type of attributes Boost.TypeOf always deduces the type as un-cv-qualified value type, thus const-ized value type is redundant and inhibiting compiler optimization.	2018-08-01 20:08:24 +09:00
Kohei Takahashi	e29b1a07f3	adapt: Cleanup includes	2018-07-28 14:49:50 +09:00
Kohei Takahashi	f03bb5ec2e	test: Removed unnecessary semi-colon	2018-07-28 14:40:51 +09:00
Kohei Takahashi	cc0c684a92	test: Suppress unused warning	2018-07-27 12:45:33 +09:00
Kohei Takahashi	c740a4dbad	Merge pull request #188 from boostorg/develop Post beta merge	2018-07-17 21:12:08 +09:00
Kohei Takahashi	48f8af3e73	filter_view: Removed redundant filter operation Iterator constructor always filters and determines right position.	2018-07-07 09:30:17 +09:00
Kohei Takahashi	cc3fbc4f5d	Removed unused headers	2018-07-07 09:30:17 +09:00
Kohei Takahashi	bd96a6bcfb	doc: Fixed filter_view parameter requirements	2018-07-07 09:24:55 +09:00
Kohei Takahashi	2a95fcc3e9	Merge pull request #186 from boostorg/bugfix/apply Fixed unintentional MPL substitution in transform_view	2018-07-07 08:11:15 +09:00
Kohei Takahashi	47ff2e6cb5	find_if: Improved tag usage The traversal tag is a bit complex than before.	2018-07-07 07:18:56 +09:00
Kohei Takahashi	9036c72a61	find_if: Removed unnecessary mpl::lambda mpl::apply can treat placeholder expression	2018-07-07 07:08:17 +09:00
Kohei Takahashi	06a2f0560f	doc: Fixed keyword links	2018-07-07 01:56:50 +09:00
Kohei Takahashi	c76cd3d6b2	test: Suppress unused warning	2018-07-07 01:27:20 +09:00
Kohei Takahashi	77959b1d33	test: Added test for ticket 5490	2018-07-07 01:23:11 +09:00
Kohei Takahashi	c6448b9e45	transform: Stopped use of mpl::apply it causes unintended MPL substitution	2018-07-07 01:06:05 +09:00
Kohei Takahashi	561890429b	doc: Moved paragraph `to mpl adaptation` to mpl section	2018-07-06 11:21:54 +09:00
Kohei Takahashi	23c54602c2	Merge pull request #185 from boostorg/docfix/io-for-adapted doc: Added note regarding IO for adapted type	2018-07-05 22:57:56 +09:00
Kohei Takahashi	30c044b03a	doc: Added note regarding IO for adapted type [skip ci] closes: track 6091	2018-07-05 22:15:33 +09:00
Kohei Takahashi	a71b9607e1	Merge pull request #184 from boostorg/develop pre boost 1.68.0 beta merge	2018-07-03 21:50:36 +09:00
Kohei Takahashi	102588ae46	Merge pull request #183 from boostorg/mutable_for_each Fixed for_each parameter type to accept mutable functor	2018-07-03 12:40:54 +09:00
Kohei Takahashi	0e4c5127f5	algo/for_each: Fixed parameter type to be able to call mutable object	2018-07-02 22:19:25 +09:00
Kohei Takahashi	afb8b150a9	Merge pull request #181 from boostorg/init-and-paren Fixed misused parenthesized initializer	2018-05-13 20:40:25 +09:00
Kohei Takahashi	d832387fdb	Fixed misused parenthesized initializer	2018-05-13 18:59:43 +09:00
Kohei Takahashi	0c138de7cb	Merge pull request #180 from boostorg/develop Merge develop	2018-05-10 00:59:45 +09:00
Kohei Takahashi	7899658d8e	Merge pull request #175 from boostorg/develop Post beta merge	2018-03-25 12:58:00 +09:00
Kohei Takahashi	03ac9086bc	Merge pull request #172 from boostorg/develop Pre 1.67.0 beta merge - agian	2018-03-06 15:09:50 +09:00
Kohei Takahashi	479bc3133b	Merge pull request #169 from boostorg/develop Pre 1.67.0 beta merge	2018-02-26 01:02:16 +09:00
Kohei Takahashi	71ad390cf0	Merge pull request #162 from boostorg/develop Post beta merge	2017-12-03 00:08:31 +09:00
Kohei Takahashi	e6b5879511	Merge pull request #157 from boostorg/develop Merge develop to master	2017-10-31 09:40:44 +09:00
Kohei Takahashi	84d8afbb31	Merge pull request #147 from boostorg/develop Develop to Master	2017-06-19 23:43:44 +09:00
Kohei Takahashi	715a7fb729	Merge pull request #141 from boostorg/develop Boost 1.63.0 beta release	2016-11-01 17:03:05 +09:00
Rene Rivera	3b96c3b70b	Add, and update, documentation build targets.	2016-10-10 11:39:49 -05:00
Joel de Guzman	904d3c2c01	Merge pull request #131 from boostorg/develop post 1.61.0 beta1	2016-04-02 12:44:16 +08:00
Joel de Guzman	0263c75cd8	Merge pull request #125 from boostorg/develop Release Candidate for 1.61.0.	2016-03-03 06:58:37 +08:00
Joel de Guzman	53ba3de15a	Merge pull request #119 from boostorg/develop Post 1.60.0 Beta bugfixes.	2015-12-11 15:06:59 +08:00
Joel de Guzman	d6c853f7ad	Merge pull request #111 from boostorg/develop 1.60.0 beta	2015-10-28 07:42:24 +08:00
Joel de Guzman	dc55e5e103	Merge pull request #98 from Flast/bugfix/issue-11517 Fix #11517 (for master)	2015-08-04 08:14:48 +08:00
Joel de Guzman	1646a7252b	Merge pull request #95 from Flast/preprocess Regenerate preprocessed files.	2015-07-28 08:03:50 +08:00
Joel de Guzman	dae9964b15	Merge pull request #93 from Flast/bugfix/issue-11140 Fix a issue with nested fusion::tuple.	2015-07-27 15:26:37 +08:00