diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
old mode 100755
new mode 100644
index 588a60839..e427b06b6
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -346,6 +346,7 @@ jobs:
           git submodule init libs/utility
           git submodule init libs/describe
           git submodule init libs/mp11
+          git submodule init libs/pfr
           git submodule init libs/headers tools/boost_install tools/build
           git submodule update
           rm -rf libs/fusion
@@ -456,6 +457,7 @@ jobs:
           git submodule init libs/utility
           git submodule init libs/describe
           git submodule init libs/mp11
+          git submodule init libs/pfr
           git submodule init libs/headers tools/boost_install tools/build
           git submodule update
           rm -rf libs/fusion
diff --git a/CMakeLists.txt b/CMakeLists.txt
old mode 100755
new mode 100644
index 89c55ff26..4e12e21e9
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -26,4 +26,5 @@ target_link_libraries(boost_fusion
         Boost::functional
         Boost::describe
         Boost::mp11
+        Boost::pfr
 )
diff --git a/appveyor.yml b/appveyor.yml
old mode 100755
new mode 100644
index 2722b6b6a..5c1ab8d8e
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -84,6 +84,7 @@ install:
   - git submodule init libs/utility
   - git submodule init libs/describe
   - git submodule init libs/mp11
+  - git submodule init libs/pfr
 
   - git submodule init libs/headers tools/boost_install tools/build
   - git submodule update
diff --git a/doc/adapted.qbk b/doc/adapted.qbk
index d14086196..11a879ed7 100644
--- a/doc/adapted.qbk
+++ b/doc/adapted.qbk
@@ -2,6 +2,7 @@
     Copyright (C) 2001-2011 Joel de Guzman
     Copyright (C) 2006 Dan Marsden
     Copyright (C) 2010 Christopher Schmidt
+    Copyright (c) 2023 Denis Mikhailov
 
     Use, modification and distribution is subject to the Boost Software
     License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
@@ -23,6 +24,20 @@ various data structures, non-intrusively, as full fledged Fusion sequences.
     #include <boost/fusion/adapted.hpp>
     #include <boost/fusion/include/adapted.hpp>
 
+[caution
+You may get compiler errors when your environment doesn't support __boost_pfr_library__ and this
+lack of support doesn't detect automatically. If this happens, define macro
+`BOOST_FUSION_PFR_ENABLED` as 0 to suppress the inclusion
+of __boost_pfr_implicit_adapter__ and __boost_pfr_explicit_adapter__ in this module.
+]
+
+[caution
+You may get compiler errors when your program utilizes __tag_of__, __is_sequence__ or 
+__is_view__ with an incomplete type. If this happens, define macro
+`BOOST_FUSION_PFR_ENABLE_IMPLICIT_REFLECTION` as 0 to suppress the inclusion
+of __boost_pfr_implicit_adapter__ in this module.
+]
+
 [section:array Array]
 
 This module provides adapters for arrays. Including the module
@@ -208,6 +223,84 @@ __boost_tuple_library__
 
 [endsect]
 
+[section:boost_pfr_implicit boost::pfr]
+
+[caution This module requires at least C++14! Pre C++14 compilers (C++11, C++03...) are not supported.]
+
+This module provides reflection from `boost::pfr` as fallback when another reflection not found for a passed type, 
+the module can be used when you want to pass an user defined structure into Fusion, the module more preferable to use than 
+__adapt_struct__ macro, because the module does not require boilerplate code from an user defined structure.
+Note that the module expects a passed type satisfies __simple_aggregate__.
+
+[heading Header]
+
+    #include <boost/fusion/adapted/boost_pfr.hpp>
+    #include <boost/fusion/include/boost_pfr.hpp>
+
+[heading Model of]
+
+* __random_access_sequence__
+
+[heading Example]
+
+    struct some_person {       // SimpleAggregate
+        std::string name;
+        unsigned birth_year = 0;
+    };
+
+    some_person val{"Edgar Allan Poe", 1809};
+    std::cout << *__begin__(val) << '\n';
+    std::cout << *__next__(__begin__(val)) << '\n';
+
+[note See __force_pfr_nonreflectable__ or __force_pfr_nonreflectable_tpl__ if your type falsely determines as "reflectable via PFR" and you need to workaround it.]
+[note Define macro `BOOST_FUSION_PFR_ENABLE_IMPLICIT_REFLECTION` as 0 if you hit by lots of non-effective choices made by implicit reflection(or if you even hit by compiler errors, when your program utilizes __tag_of__, __is_sequence__ or __is_view__ with an incomplete type) and you need to change for explicit reflection. See __boost_pfr_explicit__ for more details.]
+[note Define macro `BOOST_FUSION_PFR_ENABLED` as 0 if you get compiler errors when your program includes __adapted__ and you need to suppress the inclusion of __boost_pfr_implicit__ in __adapted__ module.]
+[note This module can't adapt a passed type as fully conforming __mpl__ sequences.]
+
+[heading See also]
+
+__boost_pfr_library__
+
+[endsect]
+
+[section:boost_pfr_explicit boost::pfr (explicit)]
+
+[caution This module requires at least C++14! Pre C++14 compilers (C++11, C++03...) are not supported.]
+
+This module provides reflection from `boost::pfr`. If you want to use the module, you should specify 
+all reflectable types manually using one of the macro below. The module can't decide to use PFR for a passed type 
+automatically, unlike __boost_pfr_implicit__.
+
+[heading Header]
+
+    #include <boost/fusion/adapted/boost_pfr_explicit.hpp>
+    #include <boost/fusion/include/boost_pfr_explicit.hpp>
+
+[heading Model of]
+
+* __random_access_sequence__
+
+[heading Example]
+
+    struct some_person {       // SimpleAggregate
+        std::string name;
+        unsigned birth_year = 0;
+    };
+    __force_pfr_reflectable__(some_person)
+
+    some_person val{"Edgar Allan Poe", 1809};
+    std::cout << *__begin__(val) << '\n';
+    std::cout << *__next__(__begin__(val)) << '\n';
+
+[note Define macro `BOOST_FUSION_PFR_ENABLED` as 0 if you get compiler errors when your program includes __adapted__ and you need to suppress the inclusion of __boost_pfr_explicit__ in __adapted__ module.]
+[note This module can't adapt a passed type as fully conforming __mpl__ sequences.]
+
+[heading See also]
+
+__boost_pfr_library__, __force_pfr_reflectable__, __force_pfr_nonreflectable__, __force_pfr_reflectable_tpl__, __force_pfr_nonreflectable_tpl__
+
+[endsect]
+
 [section:adapt_struct BOOST_FUSION_ADAPT_STRUCT]
 
 [heading Description]
@@ -276,6 +369,10 @@ namespace qualified name of the struct to be adapted.
         (auto, age)
     )
 
+[heading See also]
+
+__boost_pfr_implicit__ (might be a better alternative to using this macro)
+
 [endsect]
 
 [section:adapt_tpl_struct BOOST_FUSION_ADAPT_TPL_STRUCT]
@@ -357,6 +454,10 @@ namespace qualified name of the struct to be adapted.
         age,
         employment_timestamp) 
 
+[heading See also]
+
+__boost_pfr_implicit__ (might be a better alternative to using this macro)
+
 [endsect]
 
 [section:adapt_struct_named BOOST_FUSION_ADAPT_STRUCT_NAMED]
@@ -1500,4 +1601,186 @@ defined in __random_access_sequence__ and __associative_sequence__.
 
 [endsect]
 
+[section:force_pfr_reflectable BOOST_FUSION_FORCE_PFR_REFLECTABLE]
+
+[heading Description]
+BOOST_FUSION_FORCE_PFR_REFLECTABLE is a macro that can be used to specify an 
+arbitrary struct as a pfr-reflectable type for Fusion, and thus to make the struct
+possible to be a model of __random_access_sequence__.
+The macro intended to be used with __boost_pfr_explicit_adapter__, when you don't need __boost_pfr_implicit_adapter__.
+
+[heading Synopsis]
+    BOOST_FUSION_FORCE_PFR_REFLECTABLE(aggregate_name)
+
+[heading Semantics]
+
+The above macro specializes `boost::pfr::is_reflectable` for `aggregate_name` with `boost::pfr::boost_fusion_tag` as positive.
+
+The macro should be used at global scope, and `aggregate_name` should be the fully
+namespace qualified name of the struct satisfying __simple_aggregate__ to be specifyed.
+
+[heading Header]
+
+    #include <boost/fusion/adapted/boost_pfr/force.hpp>
+    #include <boost/fusion/include/boost_pfr_force.hpp>
+
+[heading Example: BOOST_FUSION_FORCE_PFR_REFLECTABLE ]
+    namespace demo
+    {
+        struct employee
+        {
+            std::string name;
+            int age;
+        };
+    }
+
+    // demo::employee is now a pfr-reflectable type for Fusion
+    BOOST_FUSION_FORCE_PFR_REFLECTABLE(demo::employee)
+
+[note This macro affects only Fusion, see PFR docs if you want to know how to specify type as pfr-reflectable everywhere.]
+
+[heading See also]
+
+__boost_pfr_library__
+
+[endsect]
+
+[section:force_pfr_nonreflectable BOOST_FUSION_FORCE_PFR_NONREFLECTABLE]
+
+[heading Description]
+BOOST_FUSION_FORCE_PFR_NONREFLECTABLE is a macro that can be used to declare a Fusion-side prohibition
+for an arbitrary struct to be pfr-reflectable, and thus to make the struct
+impossible to be a model of fusion sequence.
+The macro intended to be used with __boost_pfr_implicit_adapter__, when you need to workaround erroneous 
+decision that defines a type as pfr-reflectable.
+
+[heading Synopsis]
+    BOOST_FUSION_FORCE_PFR_NONREFLECTABLE(type_name)
+
+[heading Semantics]
+
+The above macro specializes `boost::pfr::is_reflectable` for `type_name` with `boost::pfr::boost_fusion_tag` as negative.
+
+The macro should be used at global scope, and `type_name` should be the fully
+namespace qualified name of any type that you wish to be specifyed.
+
+[heading Header]
+
+    #include <boost/fusion/adapted/boost_pfr/force.hpp>
+    #include <boost/fusion/include/boost_pfr_force.hpp>
+
+[heading Example: BOOST_FUSION_FORCE_PFR_NONREFLECTABLE ]
+    namespace demo
+    {
+        struct employee
+        {
+            std::string name;
+            int age;
+        };
+    }
+
+    // demo::employee is now forbidden to be a pfr-reflectable type for Fusion
+    BOOST_FUSION_FORCE_PFR_NONREFLECTABLE(demo::employee)
+
+[note This macro affects only Fusion, see PFR docs if you want to know how to forbid pfr-reflection for a type everywhere.]
+
+[heading See also]
+
+__boost_pfr_library__
+
+[endsect]
+
+[section:force_pfr_reflectable_tpl BOOST_FUSION_FORCE_PFR_REFLECTABLE_TPL]
+
+[heading Description]
+BOOST_FUSION_FORCE_PFR_REFLECTABLE_TPL is a macro that can be used to specify an 
+arbitrary template struct as a pfr-reflectable type for Fusion, and thus to make the struct
+possible to be a model of __random_access_sequence__.
+The macro intended to be used with __boost_pfr_explicit_adapter__, when you don't need __boost_pfr_implicit_adapter__.
+
+[heading Synopsis]
+    BOOST_FUSION_FORCE_PFR_REFLECTABLE_TPL(aggregate_name)
+
+[heading Semantics]
+
+The above macro specializes `boost::pfr::is_reflectable` for `aggregate_name` with `boost::pfr::boost_fusion_tag` as positive.
+
+The macro should be used at global scope, and `aggregate_name` should be the fully
+namespace qualified name of the template struct satisfying __simple_aggregate__ to be specifyed.
+
+[heading Header]
+
+    #include <boost/fusion/adapted/boost_pfr/force.hpp>
+    #include <boost/fusion/include/boost_pfr_force.hpp>
+
+[heading Example: BOOST_FUSION_FORCE_PFR_REFLECTABLE_TPL ]
+    namespace demo
+    {
+        template<typename Name, typename Age>
+        struct employee
+        {
+            Name name;
+            Age age;
+            int employment_timestamp;
+        };
+    }
+
+    // Any instantiated demo::employee is now a pfr-reflectable type for Fusion
+    BOOST_FUSION_FORCE_PFR_REFLECTABLE_TPL(demo::employee)
+
+[note This macro affects only Fusion, see PFR docs if you want to know how to specify type as pfr-reflectable everywhere.]
+
+[heading See also]
+
+__boost_pfr_library__
+
+[endsect]
+
+[section:force_pfr_nonreflectable_tpl BOOST_FUSION_FORCE_PFR_NONREFLECTABLE_TPL]
+
+[heading Description]
+BOOST_FUSION_FORCE_PFR_NONREFLECTABLE_TPL is a macro that can be used to declare a Fusion-side prohibition
+for an arbitrary template struct to be pfr-reflectable, and thus to make the struct
+impossible to be a model of fusion sequence.
+The macro intended to be used with __boost_pfr_implicit_adapter__, when you need to workaround erroneous 
+decision that defines a type as pfr-reflectable.
+
+[heading Synopsis]
+    BOOST_FUSION_FORCE_PFR_NONREFLECTABLE_TPL(type_name)
+
+[heading Semantics]
+
+The above macro specializes `boost::pfr::is_reflectable` for `type_name` with `boost::pfr::boost_fusion_tag` as negative.
+
+The macro should be used at global scope, and `type_name` should be the fully
+namespace qualified name of any type that you wish to be specifyed.
+
+[heading Header]
+
+    #include <boost/fusion/adapted/boost_pfr/force.hpp>
+    #include <boost/fusion/include/boost_pfr_force.hpp>
+
+[heading Example: BOOST_FUSION_FORCE_PFR_NONREFLECTABLE_TPL ]
+    namespace demo
+    {
+        template<typename Name, typename Age>
+        struct employee
+        {
+            Name name;
+            Age age;
+            int employment_timestamp;
+        };
+    }
+
+    // Any instantiated demo::employee is now forbidden to be a pfr-reflectable type for Fusion
+    BOOST_FUSION_FORCE_PFR_NONREFLECTABLE_TPL(demo::employee)
+
+[note This macro affects only Fusion, see PFR docs if you want to know how to forbid pfr-reflection for a type everywhere.]
+
+[heading See also]
+
+__boost_pfr_library__
+
+[endsect]
+
 [endsect]
diff --git a/doc/fusion.qbk b/doc/fusion.qbk
index f7a5bf766..e10829f3c 100644
--- a/doc/fusion.qbk
+++ b/doc/fusion.qbk
@@ -48,6 +48,8 @@
 [def __boost_func_forward__     [@http://www.boost.org/libs/functional/forward Boost.Functional/Forward Library]]
 [def __boost_func_factory__     [@http://www.boost.org/libs/functional/factory Boost.Functional/Factory Library]]
 [def __boost_func_hash__        [@http://www.boost.org/doc/html/hash.html Boost.ContainerHash Library]]
+[def __boost_pfr_library__      [@http://www.boost.org/doc/html/boost_pfr.html Boost.PFR Library]]
+[def __simple_aggregate__       [@http://www.boost.org/doc/html/boost_pfr/limitations_and_configuration.html SimpleAggregate]]
 [def __std_pair_doc__           [@http://en.cppreference.com/w/cpp/utility/pair `std::pair`]]
 [def __std_tuple_doc__          [@http://en.cppreference.com/w/cpp/utility/tuple `std::tuple`]]
 [def __std_plus_doc__           [@http://en.cppreference.com/w/cpp/utility/functional/plus `std::plus`]]
@@ -132,11 +134,17 @@
 [def __flatten_view__           [link fusion.view.flatten_view `flatten_view`]]
 [def __identity_view__          [link fusion.view.identity_view `identity_view`]]
 
+[def __adapted__                [link fusion.adapted Adapted]]
 [def __array__                  [link fusion.adapted.array array]]
 [def __std_pair__               [link fusion.adapted.std__pair `std::pair`]]
 [def __boost_array__            [link fusion.adapted.boost__array `boost::array`]]
+[def __boost_pfr_implicit__     [link fusion.adapted.boost_pfr_implicit `boost::pfr`]]
+[def __boost_pfr_explicit__     [link fusion.adapted.boost_pfr_explicit `boost::pfr` (explicit)]]
+[def __boost_pfr_implicit_adapter__ [link fusion.adapted.boost_pfr_implicit implicit adapter for `boost::pfr`]]
+[def __boost_pfr_explicit_adapter__ [link fusion.adapted.boost_pfr_explicit explicit adapter for `boost::pfr`]]
 [def __mpl_sequence__           [link fusion.adapted.mpl_sequence mpl sequence]]
 [def __adapt_tpl_struct__       [link fusion.adapted.adapt_tpl_struct `BOOST_FUSION_ADAPT_TPL_STRUCT`]]
+[def __adapt_struct__           [link fusion.adapted.adapt_struct `BOOST_FUSION_ADAPT_STRUCT`]]
 [def __adapt_struct_named__     [link fusion.adapted.adapt_struct_named `BOOST_FUSION_ADAPT_STRUCT_NAMED`]]
 [def __adapt_struct_named_ns__  [link fusion.adapted.adapt_struct_named `BOOST_FUSION_ADAPT_STRUCT_NAMED_NS`]]
 [def __adapt_assoc_tpl_struct__ [link fusion.adapted.adapt_assoc_tpl_struct `BOOST_FUSION_ADAPT_ASSOC_TPL_STRUCT`]]
@@ -150,6 +158,10 @@
 [def __define_tpl_struct__      [link fusion.adapted.define_tpl_struct `BOOST_FUSION_DEFINE_TPL_STRUCT`]]
 [def __define_assoc_struct__    [link fusion.adapted.define_assoc_struct `BOOST_FUSION_DEFINE_ASSOC_STRUCT`]]
 [def __define_assoc_tpl_struct__ [link fusion.adapted.define_assoc_tpl_struct `BOOST_FUSION_DEFINE_ASSOC_TPL_STRUCT`]]
+[def __force_pfr_reflectable__  [link fusion.adapted.force_pfr_reflectable `BOOST_FUSION_FORCE_PFR_REFLECTABLE`]]
+[def __force_pfr_nonreflectable__ [link fusion.adapted.force_pfr_nonreflectable `BOOST_FUSION_FORCE_PFR_NONREFLECTABLE`]]
+[def __force_pfr_reflectable_tpl__ [link fusion.adapted.force_pfr_reflectable_tpl `BOOST_FUSION_FORCE_PFR_REFLECTABLE_TPL`]]
+[def __force_pfr_nonreflectable_tpl__ [link fusion.adapted.force_pfr_nonreflectable_tpl `BOOST_FUSION_FORCE_PFR_NONREFLECTABLE_TPL`]]
 
 [def __intrinsic__              [link fusion.sequence.intrinsic Intrinsic]]
 [def __intrinsics__             [link fusion.sequence.intrinsic Intrinsics]]
diff --git a/doc/html/index.html b/doc/html/index.html
index 9f0f14da5..c97b20194 100644
--- a/doc/html/index.html
+++ b/doc/html/index.html
@@ -176,6 +176,8 @@
 <dt><span class="section"><a href="fusion/adapted/mpl_sequence.html">mpl sequence</a></span></dt>
 <dt><span class="section"><a href="fusion/adapted/boost__array.html">boost::array</a></span></dt>
 <dt><span class="section"><a href="fusion/adapted/boost__tuple.html">boost::tuple</a></span></dt>
+<dt><span class="section"><a href="fusion/adapted/boost_pfr_implicit.html">boost::pfr</a></span></dt>
+<dt><span class="section"><a href="fusion/adapted/boost_pfr_explicit.html">boost::pfr (explicit)</a></span></dt>
 <dt><span class="section"><a href="fusion/adapted/adapt_struct.html">BOOST_FUSION_ADAPT_STRUCT</a></span></dt>
 <dt><span class="section"><a href="fusion/adapted/adapt_tpl_struct.html">BOOST_FUSION_ADAPT_TPL_STRUCT</a></span></dt>
 <dt><span class="section"><a href="fusion/adapted/adapt_struct_named.html">BOOST_FUSION_ADAPT_STRUCT_NAMED</a></span></dt>
@@ -192,6 +194,10 @@
 <dt><span class="section"><a href="fusion/adapted/define_tpl_struct_inline.html">BOOST_FUSION_DEFINE_TPL_STRUCT_INLINE</a></span></dt>
 <dt><span class="section"><a href="fusion/adapted/define_assoc_struct.html">BOOST_FUSION_DEFINE_ASSOC_STRUCT</a></span></dt>
 <dt><span class="section"><a href="fusion/adapted/define_assoc_tpl_struct.html">BOOST_FUSION_DEFINE_ASSOC_TPL_STRUCT</a></span></dt>
+<dt><span class="section"><a href="fusion/adapted/force_pfr_reflectable.html">BOOST_FUSION_FORCE_PFR_REFLECTABLE</a></span></dt>
+<dt><span class="section"><a href="fusion/adapted/force_pfr_nonreflectable.html">BOOST_FUSION_FORCE_PFR_NONREFLECTABLE</a></span></dt>
+<dt><span class="section"><a href="fusion/adapted/force_pfr_reflectable_tpl.html">BOOST_FUSION_FORCE_PFR_REFLECTABLE_TPL</a></span></dt>
+<dt><span class="section"><a href="fusion/adapted/force_pfr_nonreflectable_tpl.html">BOOST_FUSION_FORCE_PFR_NONREFLECTABLE_TPL</a></span></dt>
 </dl></dd>
 <dt><span class="section"><a href="fusion/algorithm.html">Algorithm</a></span></dt>
 <dd><dl>
diff --git a/doc/organization.qbk b/doc/organization.qbk
index b062e6ed8..248b59d77 100644
--- a/doc/organization.qbk
+++ b/doc/organization.qbk
@@ -45,6 +45,7 @@ link against.
     * array
     * boost::array
     * boost::tuple
+    * boost::pfr
     * mpl
     * std_pair
     * std_tuple
diff --git a/doc/references.qbk b/doc/references.qbk
index a07815d49..c5b513f3e 100644
--- a/doc/references.qbk
+++ b/doc/references.qbk
@@ -23,6 +23,8 @@
   Jaakko Jarvi, Peter Dimov, Douglas Gregor, Dave Abrahams, 1999-2002.
 # [@http://www.boost.org/libs/hana The Boost Hana Library],
   Louis Dionne, 2017.
+# [@http://www.boost.org/libs/pfr The Boost PFR Library],
+  Antony Polukhin, 2016-2023.
 
 [endsect]
 
diff --git a/include/boost/fusion/adapted.hpp b/include/boost/fusion/adapted.hpp
index 5bc33899c..2d983a1c2 100644
--- a/include/boost/fusion/adapted.hpp
+++ b/include/boost/fusion/adapted.hpp
@@ -23,4 +23,17 @@
 #include <boost/fusion/adapted/std_tuple.hpp>
 #endif
 
+// The Boost PFR Library is a C++14 library, but this library also
+// may be not supported in some C++14 compilers.
+// Even if the library is supported in user's environment, that
+// still doesn't mean the environment supports implicit reflection
+// and that also doesn't mean the user wants implicit reflection.
+#if BOOST_FUSION_PFR_ENABLED
+#if BOOST_FUSION_PFR_ENABLE_IMPLICIT_REFLECTION
+#include <boost/fusion/adapted/boost_pfr.hpp>
 #endif
+#include <boost/fusion/adapted/boost_pfr_explicit.hpp>
+#endif
+
+#endif
+
diff --git a/include/boost/fusion/adapted/boost_pfr.hpp b/include/boost/fusion/adapted/boost_pfr.hpp
new file mode 100644
index 000000000..cf97d2ef6
--- /dev/null
+++ b/include/boost/fusion/adapted/boost_pfr.hpp
@@ -0,0 +1,24 @@
+/*=============================================================================
+    Copyright (c) 2021-2023 Denis Mikhailov
+    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_ADAPTED_BOOST_PFR_HPP
+#define BOOST_FUSION_ADAPTED_BOOST_PFR_HPP
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/adapted/boost_pfr/detail/at_impl.hpp>
+#include <boost/fusion/adapted/boost_pfr/detail/begin_impl.hpp>
+#include <boost/fusion/adapted/boost_pfr/detail/category_of_impl.hpp>
+#include <boost/fusion/adapted/boost_pfr/detail/end_impl.hpp>
+#include <boost/fusion/adapted/boost_pfr/detail/is_sequence_impl.hpp>
+#include <boost/fusion/adapted/boost_pfr/detail/is_view_impl.hpp>
+#include <boost/fusion/adapted/boost_pfr/detail/size_impl.hpp>
+#include <boost/fusion/adapted/boost_pfr/detail/value_at_impl.hpp>
+#include <boost/fusion/adapted/boost_pfr/boost_pfr_iterator.hpp>
+#include <boost/fusion/adapted/boost_pfr/tag_of_fallback.hpp>
+#include <boost/fusion/adapted/boost_pfr/force.hpp>
+
+#endif //BOOST_FUSION_ADAPTED_BOOST_PFR_HPP
+
diff --git a/include/boost/fusion/adapted/boost_pfr/boost_pfr_iterator.hpp b/include/boost/fusion/adapted/boost_pfr/boost_pfr_iterator.hpp
new file mode 100644
index 000000000..d827908d8
--- /dev/null
+++ b/include/boost/fusion/adapted/boost_pfr/boost_pfr_iterator.hpp
@@ -0,0 +1,108 @@
+/*=============================================================================
+    Copyright (c) 2021-2023 Denis Mikhailov
+    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_ADAPTED_BOOST_PFR_ITERATOR_HPP
+#define BOOST_FUSION_ADAPTED_BOOST_PFR_ITERATOR_HPP
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/iterator/iterator_facade.hpp>
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/pfr/core.hpp>
+#include <utility>
+#include <type_traits> // for std::add_const_t, std::remove_const_t, std::is_same
+
+namespace boost { namespace fusion
+{
+    struct random_access_traversal_tag;
+
+    template <typename Reflectable, int Index>
+    struct pfr_iterator_identity;
+
+    template <typename Reflectable, int Index>
+    struct boost_pfr_iterator
+            : iterator_facade<
+                      boost_pfr_iterator<Reflectable, Index>
+                    , random_access_traversal_tag>
+    {
+        static_assert(Index >=0 && Index <= boost::pfr::tuple_size_v<Reflectable>, "out of range");
+        using reflectable_type = Reflectable;
+        using identity = pfr_iterator_identity<std::add_const_t<Reflectable>, Index>;
+
+        static constexpr auto index = Index;
+
+        constexpr BOOST_FUSION_GPU_ENABLED
+        explicit boost_pfr_iterator(Reflectable& reflectable) noexcept
+        : reflectable(reflectable) {}
+
+        Reflectable& reflectable;
+
+        template <typename Iterator>
+        struct value_of
+            : boost::pfr::tuple_element<Iterator::index,
+                    std::remove_const_t<typename Iterator::reflectable_type>> {};
+
+        template <typename Iterator>
+        struct deref
+        {
+            using type = decltype(boost::pfr::get<Index>(
+                std::declval<Iterator const&>().reflectable));
+            static_assert(std::is_reference<type>::value, "internal error");
+
+            constexpr BOOST_FUSION_GPU_ENABLED
+            static decltype(auto)
+            call(Iterator const& iter) noexcept
+            {
+                return boost::pfr::get<Index>(iter.reflectable);
+            }
+        };
+
+        template <typename Iterator, typename N>
+        struct advance
+        {
+            static constexpr auto index = Iterator::index;
+            using reflectable_type = typename Iterator::reflectable_type;
+            using type = boost_pfr_iterator<reflectable_type, index+N::value>;
+
+            constexpr BOOST_FUSION_GPU_ENABLED
+            static auto
+            call(Iterator const& i) noexcept
+            {
+                return type(i.reflectable);
+            }
+        };
+
+        template <typename Iterator>
+        struct next : advance<Iterator, mpl::int_<1>> {};
+
+        template <typename Iterator>
+        struct prior : advance<Iterator, mpl::int_<-1>> {};
+
+        template <typename First, typename Last>
+        struct equal_to : mpl::bool_<std::is_same<typename First::identity,
+                                                  typename Last::identity
+                                                  >
+                                                ::value>
+        {
+        };
+
+        template <typename First, typename Last>
+        struct distance
+        {
+            using type = mpl::int_<Last::index-First::index>;
+
+            constexpr BOOST_FUSION_GPU_ENABLED
+            static auto
+            call(First const&, Last const&) noexcept
+            {
+                return type();
+            }
+        };
+    };
+}}
+
+#endif //BOOST_FUSION_ADAPTED_BOOST_PFR_ITERATOR_HPP
+
diff --git a/include/boost/fusion/adapted/boost_pfr/detail/at_impl.hpp b/include/boost/fusion/adapted/boost_pfr/detail/at_impl.hpp
new file mode 100644
index 000000000..ac9677463
--- /dev/null
+++ b/include/boost/fusion/adapted/boost_pfr/detail/at_impl.hpp
@@ -0,0 +1,47 @@
+/*=============================================================================
+    Copyright (c) 2021-2023 Denis Mikhailov
+    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_ADAPTED_BOOST_PFR_DETAIL_AT_IMPL_HPP
+#define BOOST_FUSION_ADAPTED_BOOST_PFR_DETAIL_AT_IMPL_HPP
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/pfr/core.hpp>
+#include <utility> // for std::declval
+#include <boost/fusion/sequence/intrinsic/at.hpp>
+#include <type_traits> // for std::is_reference
+
+namespace boost { namespace fusion
+{
+    struct boost_pfr_tag;
+
+    namespace extension
+    {
+        template<typename Tag>
+        struct at_impl;
+
+        template<>
+        struct at_impl<boost_pfr_tag>
+        {
+            template <typename Reflectable, typename N>
+            struct apply
+            {
+                using type = decltype(boost::pfr::get<N::value>(
+                    std::declval<Reflectable&>()));
+                static_assert(std::is_reference<type>::value, "internal error");
+
+                constexpr BOOST_FUSION_GPU_ENABLED
+                static decltype(auto)
+                call(Reflectable& seq) noexcept
+                {
+                    return boost::pfr::get<N::value>(seq);
+                }
+            };
+        };
+    }
+}}
+
+#endif //BOOST_FUSION_ADAPTED_BOOST_PFR_DETAIL_AT_IMPL_HPP
+
diff --git a/include/boost/fusion/adapted/boost_pfr/detail/begin_impl.hpp b/include/boost/fusion/adapted/boost_pfr/detail/begin_impl.hpp
new file mode 100644
index 000000000..d94d09fa5
--- /dev/null
+++ b/include/boost/fusion/adapted/boost_pfr/detail/begin_impl.hpp
@@ -0,0 +1,43 @@
+/*=============================================================================
+    Copyright (c) 2021-2023 Denis Mikhailov
+    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_ADAPTED_BOOST_PFR_DETAIL_BEGIN_IMPL_HPP
+#define BOOST_FUSION_ADAPTED_BOOST_PFR_DETAIL_BEGIN_IMPL_HPP
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/adapted/boost_pfr/boost_pfr_iterator.hpp>
+
+namespace boost { namespace fusion
+{
+    struct boost_pfr_tag;
+
+    namespace extension
+    {
+        template<typename Tag>
+        struct begin_impl;
+
+        template <>
+        struct begin_impl<boost_pfr_tag>
+        {
+            template <typename Reflectable>
+            struct apply
+            {
+                using type = boost_pfr_iterator<Reflectable, 0>;
+
+                constexpr BOOST_FUSION_GPU_ENABLED
+                static auto
+                call(Reflectable& v) noexcept
+                {
+                    return type(v);
+                }
+            };
+        };
+    }
+}}
+
+#endif //BOOST_FUSION_ADAPTED_BOOST_PFR_DETAIL_BEGIN_IMPL_HPP
+
diff --git a/include/boost/fusion/adapted/boost_pfr/detail/category_of_impl.hpp b/include/boost/fusion/adapted/boost_pfr/detail/category_of_impl.hpp
new file mode 100644
index 000000000..8bb02e632
--- /dev/null
+++ b/include/boost/fusion/adapted/boost_pfr/detail/category_of_impl.hpp
@@ -0,0 +1,33 @@
+/*=============================================================================
+    Copyright (c) 2021-2023 Denis Mikhailov
+    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_ADAPTED_BOOST_PFR_DETAIL_CATEGORY_OF_IMPL_HPP
+#define BOOST_FUSION_ADAPTED_BOOST_PFR_DETAIL_CATEGORY_OF_IMPL_HPP
+
+#include <boost/mpl/identity.hpp>
+
+namespace boost { namespace fusion
+{
+    struct boost_pfr_tag;
+    struct random_access_traversal_tag;
+
+    namespace extension
+    {
+        template<typename Tag>
+        struct category_of_impl;
+
+        template<>
+        struct category_of_impl<boost_pfr_tag>
+        {
+            template<typename Reflectable>
+            struct apply : mpl::identity<random_access_traversal_tag> {};
+        };
+    }
+}}
+
+#endif //BOOST_FUSION_ADAPTED_BOOST_PFR_DETAIL_CATEGORY_OF_IMPL_HPP
+
+
diff --git a/include/boost/fusion/adapted/boost_pfr/detail/end_impl.hpp b/include/boost/fusion/adapted/boost_pfr/detail/end_impl.hpp
new file mode 100644
index 000000000..f2c81a9cd
--- /dev/null
+++ b/include/boost/fusion/adapted/boost_pfr/detail/end_impl.hpp
@@ -0,0 +1,45 @@
+/*=============================================================================
+    Copyright (c) 2021-2023 Denis Mikhailov
+    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_ADAPTED_BOOST_PFR_DETAIL_END_IMPL_HPP
+#define BOOST_FUSION_ADAPTED_BOOST_PFR_DETAIL_END_IMPL_HPP
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/adapted/boost_pfr/boost_pfr_iterator.hpp>
+#include <boost/pfr/tuple_size.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
+
+namespace boost { namespace fusion
+{
+    struct boost_pfr_tag;
+
+    namespace extension
+    {
+        template<typename Tag>
+        struct end_impl;
+
+        template<>
+        struct end_impl<boost_pfr_tag>
+        {
+            template <typename Reflectable>
+            struct apply
+            {
+                static constexpr auto size = boost::pfr::tuple_size_v<Reflectable>;
+                using type = boost_pfr_iterator<Reflectable, size>;
+
+                constexpr BOOST_FUSION_GPU_ENABLED
+                static auto
+                call(Reflectable& v) noexcept
+                {
+                    return type(v);
+                }
+            };
+        };
+    }
+}}
+
+#endif //BOOST_FUSION_ADAPTED_BOOST_PFR_DETAIL_END_IMPL_HPP
+
diff --git a/include/boost/fusion/adapted/boost_pfr/detail/is_sequence_impl.hpp b/include/boost/fusion/adapted/boost_pfr/detail/is_sequence_impl.hpp
new file mode 100644
index 000000000..bf70f390e
--- /dev/null
+++ b/include/boost/fusion/adapted/boost_pfr/detail/is_sequence_impl.hpp
@@ -0,0 +1,32 @@
+/*=============================================================================
+    Copyright (c) 2021-2023 Denis Mikhailov
+    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_ADAPTED_BOOST_PFR_DETAIL_IS_SEQUENCE_IMPL_HPP
+#define BOOST_FUSION_ADAPTED_BOOST_PFR_DETAIL_IS_SEQUENCE_IMPL_HPP
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/mpl/bool.hpp>
+
+namespace boost { namespace fusion
+{
+    struct boost_pfr_tag;
+
+    namespace extension
+    {
+        template<typename Tag>
+        struct is_sequence_impl;
+
+        template<>
+        struct is_sequence_impl<boost_pfr_tag>
+        {
+            template<typename Reflectable>
+            struct apply : mpl::true_ {};
+        };
+    }
+}}
+
+#endif //BOOST_FUSION_ADAPTED_BOOST_PFR_DETAIL_IS_SEQUENCE_IMPL_HPP
+
diff --git a/include/boost/fusion/adapted/boost_pfr/detail/is_view_impl.hpp b/include/boost/fusion/adapted/boost_pfr/detail/is_view_impl.hpp
new file mode 100644
index 000000000..2d53e5685
--- /dev/null
+++ b/include/boost/fusion/adapted/boost_pfr/detail/is_view_impl.hpp
@@ -0,0 +1,41 @@
+/*=============================================================================
+    Copyright (c) 2021-2023 Denis Mikhailov
+    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_ADAPTED_BOOST_PFR_DETAIL_IS_VIEW_IMPL_HPP
+#define BOOST_FUSION_ADAPTED_BOOST_PFR_DETAIL_IS_VIEW_IMPL_HPP
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/pfr/traits.hpp>
+
+namespace boost { namespace fusion
+{
+    struct boost_pfr_tag;
+
+    namespace extension
+    {
+        template<typename Tag>
+        struct is_view_impl;
+
+        // FIXME replace like this after merging of https://github.com/boostorg/pfr/pull/112
+        // template<>
+        // struct is_view_impl<boost_pfr_tag>
+        // {
+        //     template<typename Reflectable>
+        //     struct apply : boost::pfr::is_view<Reflectable> {};
+        // };
+        
+        template<>
+        struct is_view_impl<boost_pfr_tag>
+        {
+            template<typename Reflectable>
+            struct apply : mpl::false_ {};
+        };
+    }
+}}
+
+#endif //BOOST_FUSION_ADAPTED_BOOST_PFR_DETAIL_IS_VIEW_IMPL_HPP
+
diff --git a/include/boost/fusion/adapted/boost_pfr/detail/size_impl.hpp b/include/boost/fusion/adapted/boost_pfr/detail/size_impl.hpp
new file mode 100644
index 000000000..6ba714c0d
--- /dev/null
+++ b/include/boost/fusion/adapted/boost_pfr/detail/size_impl.hpp
@@ -0,0 +1,36 @@
+/*=============================================================================
+    Copyright (c) 2021-2023 Denis Mikhailov
+    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_ADAPTED_BOOST_PFR_DETAIL_VIEW_IMPL_HPP
+#define BOOST_FUSION_ADAPTED_BOOST_PFR_DETAIL_VIEW_IMPL_HPP
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/pfr/tuple_size.hpp>
+#include <boost/mpl/int.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+
+namespace boost { namespace fusion
+{
+    struct boost_pfr_tag;
+
+    namespace extension
+    {
+        template<typename Tag>
+        struct size_impl;
+
+        template<>
+        struct size_impl<boost_pfr_tag>
+        {
+            template <typename Reflectable>
+            struct apply : mpl::int_<
+                boost::pfr::tuple_size_v<Reflectable>
+            > {};
+        };
+    }
+}}
+
+#endif //BOOST_FUSION_ADAPTED_BOOST_PFR_DETAIL_VIEW_IMPL_HPP
+
diff --git a/include/boost/fusion/adapted/boost_pfr/detail/value_at_impl.hpp b/include/boost/fusion/adapted/boost_pfr/detail/value_at_impl.hpp
new file mode 100644
index 000000000..2a47f2c24
--- /dev/null
+++ b/include/boost/fusion/adapted/boost_pfr/detail/value_at_impl.hpp
@@ -0,0 +1,34 @@
+/*=============================================================================
+    Copyright (c) 2021-2023 Denis Mikhailov
+    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_ADAPTED_BOOST_PFR_DETAIL_VALUE_AT_IMPL_HPP
+#define BOOST_FUSION_ADAPTED_BOOST_PFR_DETAIL_VALUE_AT_IMPL_HPP
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/pfr/core.hpp>
+#include <boost/fusion/sequence/intrinsic/value_at.hpp>
+#include <type_traits> // for std::remove_const_t
+
+namespace boost { namespace fusion
+{
+    struct boost_pfr_tag;
+
+    namespace extension
+    {
+        template<typename Tag>
+        struct value_at_impl;
+
+        template<>
+        struct value_at_impl<boost_pfr_tag>
+        {
+            template <typename Reflectable, typename N>
+            struct apply : boost::pfr::tuple_element<N::value,
+                std::remove_const_t<Reflectable>> {};
+        };
+    }
+}}
+
+#endif //BOOST_FUSION_ADAPTED_BOOST_PFR_DETAIL_VALUE_AT_IMPL_HPP
diff --git a/include/boost/fusion/adapted/boost_pfr/force.hpp b/include/boost/fusion/adapted/boost_pfr/force.hpp
new file mode 100644
index 000000000..36478cafa
--- /dev/null
+++ b/include/boost/fusion/adapted/boost_pfr/force.hpp
@@ -0,0 +1,73 @@
+/*=============================================================================
+    Copyright (c) 2021-2023 Denis Mikhailov
+    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_ADAPTED_BOOST_PFR_FORCE_HPP
+#define BOOST_FUSION_ADAPTED_BOOST_PFR_FORCE_HPP
+
+#include <boost/fusion/support/config.hpp>
+
+#if BOOST_FUSION_PFR_ENABLED
+#include <boost/fusion/adapted/boost_pfr/detail/at_impl.hpp>
+#include <boost/fusion/adapted/boost_pfr/detail/begin_impl.hpp>
+#include <boost/fusion/adapted/boost_pfr/detail/category_of_impl.hpp>
+#include <boost/fusion/adapted/boost_pfr/detail/end_impl.hpp>
+#include <boost/fusion/adapted/boost_pfr/detail/is_sequence_impl.hpp>
+#include <boost/fusion/adapted/boost_pfr/detail/is_view_impl.hpp>
+#include <boost/fusion/adapted/boost_pfr/detail/size_impl.hpp>
+#include <boost/fusion/adapted/boost_pfr/detail/value_at_impl.hpp>
+#include <boost/pfr/traits.hpp>
+
+namespace boost { namespace pfr {
+  struct boost_fusion_tag;
+}} // namespace boost::pfr
+
+#define BOOST_FUSION_FORCE_PFR_REFLECTABLE(NAME)                                               \
+    namespace boost { namespace pfr {                                                          \
+        template<>                                                                             \
+        struct is_reflectable<NAME, boost::pfr::boost_fusion_tag>                              \
+            : std::true_type                                                                   \
+        {                                                                                      \
+        };                                                                                     \
+    }}
+
+#define BOOST_FUSION_FORCE_PFR_NONREFLECTABLE(NAME)                                            \
+    namespace boost { namespace pfr {                                                          \
+        template<>                                                                             \
+        struct is_reflectable<NAME, boost::pfr::boost_fusion_tag>                              \
+            : std::false_type                                                                  \
+        {                                                                                      \
+        };                                                                                     \
+    }}
+
+#define BOOST_FUSION_FORCE_PFR_REFLECTABLE_TPL(NAME)                                           \
+    namespace boost { namespace pfr {                                                          \
+        template<typename... Args>                                                             \
+        struct is_reflectable<NAME<Args...>, boost::pfr::boost_fusion_tag>                     \
+            : std::true_type                                                                   \
+        {                                                                                      \
+        };                                                                                     \
+    }}
+
+#define BOOST_FUSION_FORCE_PFR_NONREFLECTABLE_TPL(NAME)                                        \
+    namespace boost { namespace pfr {                                                          \
+        template<typename... Args>                                                             \
+        struct is_reflectable<NAME<Args...>, boost::pfr::boost_fusion_tag>                     \
+            : std::false_type                                                                  \
+        {                                                                                      \
+        };                                                                                     \
+    }}
+
+#else
+
+#define BOOST_FUSION_FORCE_PFR_REFLECTABLE(NAME)
+#define BOOST_FUSION_FORCE_PFR_NONREFLECTABLE(NAME)
+#define BOOST_FUSION_FORCE_PFR_REFLECTABLE_TPL(NAME)
+#define BOOST_FUSION_FORCE_PFR_NONREFLECTABLE_TPL(NAME)
+
+#endif
+
+#endif //BOOST_FUSION_ADAPTED_BOOST_PFR_FORCE_HPP
+
diff --git a/include/boost/fusion/adapted/boost_pfr/tag_of.hpp b/include/boost/fusion/adapted/boost_pfr/tag_of.hpp
new file mode 100644
index 000000000..6529b75cb
--- /dev/null
+++ b/include/boost/fusion/adapted/boost_pfr/tag_of.hpp
@@ -0,0 +1,36 @@
+/*=============================================================================
+    Copyright (c) 2021-2023 Denis Mikhailov
+    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_ADAPTED_BOOST_PFR_TAG_OF_HPP
+#define BOOST_FUSION_ADAPTED_BOOST_PFR_TAG_OF_HPP
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/support/tag_of_fwd.hpp>
+#include <boost/pfr/traits.hpp>
+#include <type_traits>
+
+namespace boost { namespace pfr {
+  struct boost_fusion_tag;
+}} // namespace boost::pfr
+
+namespace boost { namespace fusion
+{
+    struct boost_pfr_tag;
+    struct fusion_sequence_tag;
+
+    namespace traits
+    {
+        template <typename T>
+        struct tag_of<T, std::enable_if_t<boost::pfr::is_reflectable<
+                             T, boost::pfr::boost_fusion_tag>::value>>
+        {
+            using type = boost_pfr_tag;
+        };
+    }
+}}
+
+#endif //BOOST_FUSION_ADAPTED_BOOST_PFR_TAG_OF_HPP
+
diff --git a/include/boost/fusion/adapted/boost_pfr/tag_of_fallback.hpp b/include/boost/fusion/adapted/boost_pfr/tag_of_fallback.hpp
new file mode 100644
index 000000000..a700d9057
--- /dev/null
+++ b/include/boost/fusion/adapted/boost_pfr/tag_of_fallback.hpp
@@ -0,0 +1,94 @@
+/*=============================================================================
+    Copyright (c) 2021-2023 Denis Mikhailov
+    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_ADAPTED_BOOST_PFR_TAG_OF_FALLBACK_HPP
+#define BOOST_FUSION_ADAPTED_BOOST_PFR_TAG_OF_FALLBACK_HPP
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/support/tag_of_fwd.hpp>
+#include <boost/type_index/ctti_type_index.hpp>
+#include <boost/type_traits/is_complete.hpp>
+#include <boost/pfr/traits.hpp>
+#include <type_traits>
+
+namespace boost { namespace pfr {
+  struct boost_fusion_tag;
+}} // namespace boost::pfr
+
+namespace boost { namespace fusion
+{
+    struct boost_pfr_tag;
+    struct non_fusion_tag;
+    struct fusion_sequence_tag;
+
+    namespace detail
+    {
+        // Helper function that returns true if `name` starts with `substr`
+        template <std::size_t N>
+        constexpr bool starts_with(const char* name, const char (&substr)[N]) noexcept {
+            static_assert(N > 0, "non a zero-terminated string passed");
+            for (std::size_t i = 0; i<N-1; ++i) {
+                if (name[i] != substr[i]) {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        // Function that returns true if `T` declared in namespace `ns`
+        // got from here: https://www.boost.org/doc/libs/1_81_0/doc/html/boost_typeindex/examples.html#boost_typeindex.examples.c_14_checking_namespace_at_compi
+        template <class T, std::size_t N>
+        constexpr bool in_namespace(const char (&ns)[N]) noexcept {
+            const char* name = boost::typeindex::ctti_type_index::type_id<T>().raw_name();
+
+            // Some compilers add `class ` or `struct ` before the namespace, so we need to skip those words first
+            if (detail::starts_with(name, "class ")) {
+                name += sizeof("class ") - 1;
+            } else if (detail::starts_with(name, "struct ")) {
+                name += sizeof("struct ") - 1;
+            }
+
+            return detail::starts_with(name, ns) && detail::starts_with(name + N - 1, "::");
+        }
+
+        template<typename T>
+        struct constexpr_in_namespace_check_possible {
+            template <bool = detail::in_namespace<T>("") >
+            static std::true_type test(long) noexcept;
+
+            static std::false_type test(...) noexcept;
+
+            static constexpr bool value = decltype(test(0)){};
+        };
+
+        template<typename T>
+        constexpr bool is_implicitly_reflectable_via_pfr() noexcept {
+            static_assert(detail::constexpr_in_namespace_check_possible<T>::value
+                        , "Unfortunately, Boost PFR with implicit reflection won't work in your compiler due to constexpr limitations. "
+                          "Please, try to use another compiler or disable implicit reflection by '-DBOOST_FUSION_PFR_ENABLE_IMPLICIT_REFLECTION=0'");
+            static_assert(boost::is_complete<T>::value
+                        , "Boost Fusion doesn't work with incomplete types if Boost PFR is used as implicit fallback. "
+                          "Please, don't pass incomplete types into Boost Fusion or just disable implicit reflection by '-DBOOST_FUSION_PFR_ENABLE_IMPLICIT_REFLECTION=0'");
+            const auto possible_pfr = boost::pfr::is_implicitly_reflectable<
+                T, boost::pfr::boost_fusion_tag>::value;
+            const auto value = !std::is_array<T>::value
+                          && !detail::in_namespace<T>("boost::fusion")
+                          && !detail::in_namespace<T>("boost::mpl")
+                          && !detail::in_namespace<T>("mpl_")
+                          && possible_pfr;
+            return value;
+        }
+
+        template <typename T>
+        struct tag_of_fallback<T, std::enable_if_t<detail::is_implicitly_reflectable_via_pfr<T>()>>
+        {
+            using type = boost_pfr_tag;
+        };
+    }
+}}
+
+#endif //BOOST_FUSION_ADAPTED_BOOST_PFR_TAG_OF_FALLBACK_HPP
+
diff --git a/include/boost/fusion/adapted/boost_pfr_explicit.hpp b/include/boost/fusion/adapted/boost_pfr_explicit.hpp
new file mode 100644
index 000000000..0e31d8065
--- /dev/null
+++ b/include/boost/fusion/adapted/boost_pfr_explicit.hpp
@@ -0,0 +1,24 @@
+/*=============================================================================
+    Copyright (c) 2021-2023 Denis Mikhailov
+    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_ADAPTED_BOOST_PFR_EXPLICIT_HPP
+#define BOOST_FUSION_ADAPTED_BOOST_PFR_EXPLICIT_HPP
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/adapted/boost_pfr/detail/at_impl.hpp>
+#include <boost/fusion/adapted/boost_pfr/detail/begin_impl.hpp>
+#include <boost/fusion/adapted/boost_pfr/detail/category_of_impl.hpp>
+#include <boost/fusion/adapted/boost_pfr/detail/end_impl.hpp>
+#include <boost/fusion/adapted/boost_pfr/detail/is_sequence_impl.hpp>
+#include <boost/fusion/adapted/boost_pfr/detail/is_view_impl.hpp>
+#include <boost/fusion/adapted/boost_pfr/detail/size_impl.hpp>
+#include <boost/fusion/adapted/boost_pfr/detail/value_at_impl.hpp>
+#include <boost/fusion/adapted/boost_pfr/boost_pfr_iterator.hpp>
+#include <boost/fusion/adapted/boost_pfr/tag_of.hpp>
+#include <boost/fusion/adapted/boost_pfr/force.hpp>
+
+#endif //BOOST_FUSION_ADAPTED_BOOST_PFR_EXPLICIT_HPP
+
diff --git a/include/boost/fusion/include/boost_pfr.hpp b/include/boost/fusion/include/boost_pfr.hpp
new file mode 100644
index 000000000..d70d91b0c
--- /dev/null
+++ b/include/boost/fusion/include/boost_pfr.hpp
@@ -0,0 +1,14 @@
+/*=============================================================================
+    Copyright (c) 2021-2023 Denis Mikhailov
+    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_INCLUDE_BOOST_PFR_HPP
+#define BOOST_FUSION_INCLUDE_BOOST_PFR_HPP
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/adapted/boost_pfr.hpp>
+
+#endif
+
diff --git a/include/boost/fusion/include/boost_pfr_explicit.hpp b/include/boost/fusion/include/boost_pfr_explicit.hpp
new file mode 100644
index 000000000..f06f95deb
--- /dev/null
+++ b/include/boost/fusion/include/boost_pfr_explicit.hpp
@@ -0,0 +1,14 @@
+/*=============================================================================
+    Copyright (c) 2021-2023 Denis Mikhailov
+    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_INCLUDE_BOOST_PFR_EXPLICIT_HPP
+#define BOOST_FUSION_INCLUDE_BOOST_PFR_EXPLICIT_HPP
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/adapted/boost_pfr_explicit.hpp>
+
+#endif
+
diff --git a/include/boost/fusion/include/boost_pfr_force.hpp b/include/boost/fusion/include/boost_pfr_force.hpp
new file mode 100644
index 000000000..a9ca0e530
--- /dev/null
+++ b/include/boost/fusion/include/boost_pfr_force.hpp
@@ -0,0 +1,14 @@
+/*=============================================================================
+    Copyright (c) 2023 Denis Mikhailov
+    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_INCLUDE_BOOST_PFR_FORCE_HPP
+#define BOOST_FUSION_INCLUDE_BOOST_PFR_FORCE_HPP
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/adapted/boost_pfr/force.hpp>
+
+#endif
+
diff --git a/include/boost/fusion/support/config.hpp b/include/boost/fusion/support/config.hpp
index 7c87adeb9..f3e5a7e03 100644
--- a/include/boost/fusion/support/config.hpp
+++ b/include/boost/fusion/support/config.hpp
@@ -10,6 +10,7 @@
 
 #include <boost/config.hpp>
 #include <boost/detail/workaround.hpp>
+#include <boost/pfr/config.hpp>
 #include <utility>
 
 #ifndef BOOST_FUSION_GPU_ENABLED
@@ -137,4 +138,27 @@ namespace boost { namespace fusion { namespace detail
 #   define BOOST_FUSION_DISABLE_MSVC_WARNING(num)
 #endif
 
+
+// Configure possible integration with PFR
+#ifndef BOOST_FUSION_PFR_ENABLED
+#   define BOOST_FUSION_PFR_ENABLED BOOST_PFR_ENABLED
+#endif
+
+#ifndef BOOST_FUSION_PFR_ENABLE_IMPLICIT_REFLECTION
+#   define BOOST_FUSION_PFR_ENABLE_IMPLICIT_REFLECTION BOOST_PFR_ENABLE_IMPLICIT_REFLECTION
+#endif
+
+// Verify configuration of possible integration with PFR
+#if BOOST_FUSION_PFR_ENABLED && !BOOST_PFR_ENABLED
+#error Can not force to integrate Boost PFR with Boost Fusion because Boost PFR unavailable in this environment.
+#endif
+
+#if BOOST_FUSION_PFR_ENABLE_IMPLICIT_REFLECTION && !BOOST_PFR_ENABLE_IMPLICIT_REFLECTION
+#error Can not force to integrate Boost PFR as implicit fallback for Boost Fusion because Boost PFR does not provide implicit reflection in this environment.
+#endif
+
+#if BOOST_FUSION_PFR_ENABLE_IMPLICIT_REFLECTION && !BOOST_FUSION_PFR_ENABLED
+#error Can not force to integrate Boost PFR as implicit fallback for Boost Fusion because Boost Fusion configured to not use whole Boost PFR.
+#endif
+
 #endif
diff --git a/include/boost/fusion/support/tag_of.hpp b/include/boost/fusion/support/tag_of.hpp
old mode 100755
new mode 100644
index f9e578569..7e353be05
--- a/include/boost/fusion/support/tag_of.hpp
+++ b/include/boost/fusion/support/tag_of.hpp
@@ -48,7 +48,7 @@ namespace boost { namespace fusion
     {
         BOOST_MPL_HAS_XXX_TRAIT_DEF(fusion_tag)
 
-        template<typename Sequence, typename Active=void>
+        template<typename Sequence, typename Active>
         struct tag_of_fallback
         {
             typedef non_fusion_tag type;
diff --git a/include/boost/fusion/support/tag_of_fwd.hpp b/include/boost/fusion/support/tag_of_fwd.hpp
index ba434d933..feb98a0f9 100644
--- a/include/boost/fusion/support/tag_of_fwd.hpp
+++ b/include/boost/fusion/support/tag_of_fwd.hpp
@@ -10,6 +10,12 @@
 
 namespace boost { namespace fusion
 {
+    namespace detail
+    {
+        // This metafunction mustn't have more than one specialization in the whole Fusion
+        template<typename T, typename Active = void>
+        struct tag_of_fallback;
+    }
     namespace traits
     {
         template<typename T, typename Active = void>
diff --git a/test/Jamfile b/test/Jamfile
old mode 100755
new mode 100644
index 21944f24e..48525a7c7
--- a/test/Jamfile
+++ b/test/Jamfile
@@ -2,6 +2,7 @@
 #    Copyright (c) 2003-2006 Joel de Guzman
 #    Copyright (c) 2013 Mateusz Loskot
 #    Copyright (c) 2014-2018 Kohei Takahashi
+#    Copyright (c) 2023 Denis Mikhailov
 #
 #   Use, modification and distribution is subject to the Boost Software
 #   License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
@@ -12,11 +13,113 @@ import testing ;
 import os ;
 import ../../config/checks/config : requires ;
 
+# import rules from the boost fusion test
+import ../util/test :
+    test-bfl-run_with_and_without_fallback
+    test-bfl-compile_with_and_without_fallback
+    test-bfl-compile_strictly_without_fallback
+;
+
 if [ os.environ CI ]
 {
     CI_DEFINES = <define>CI_SKIP_KNOWN_FAILURE=1 ;
 }
 
+########## BEGIN of helpers to detect constexpr ctti_type_index trick support
+
+actions mp_simple_run_action
+{
+      $(>) > $(<)
+}
+
+rule mp-run-simple ( sources + : args * : input-files * : requirements * : target-name )
+{
+   exe $(target-name)_exe : $(sources) : $(requirements) ;
+   explicit $(target-name)_exe ;
+   make $(target-name).output : $(target-name)_exe : @mp_simple_run_action ;
+   explicit $(target-name).output ;
+   alias $(target-name) : $(target-name).output ;
+}
+
+mp-run-simple constexpr_ctti_type_index_detection.cpp : : : : compiler_supports_constexpr_ctti_type_index ;
+explicit compiler_supports_constexpr_ctti_type_index ;
+
+########## END of helpers to detect constexpr ctti_type_index trick support
+
+local REQUIRE_CONSTEXPR_CTTI_TYPE_INDEX =
+    [ check-target-builds ../test//compiler_supports_constexpr_ctti_type_index : : <build>no ]
+  ;
+
+local REQUIRE_CONSTEXPR_CTTI_TYPE_INDEX_FAIL =
+    [ check-target-builds ../test//compiler_supports_constexpr_ctti_type_index : <build>no : ]
+  ;
+
+
+rule test-bfl-run_pfr_implicit ( sources + ) {
+    local tests ;
+    local target-name = $(sources[1]:B) ;
+    local VARIANTS = 
+        IMPLICIT_0
+        IMPLICIT_1
+        IMPLICIT_2
+      ;
+    for local variant in $(VARIANTS)
+    {
+        tests += [
+            run
+                $(sources) : :
+            :   <define>BOOST_FUSION_USE_PFR_$(variant)=1 <define>BOOST_PFR_ENABLE_IMPLICIT_REFLECTION=1 $(REQUIRE_CONSTEXPR_CTTI_TYPE_INDEX) [ requires cxx14_constexpr ]
+            :   $(target-name)__$(variant:L)
+        ] ;
+        tests += [
+            compile-fail
+                $(sources)
+            :   <define>BOOST_FUSION_USE_PFR_$(variant)=1 <define>BOOST_PFR_ENABLE_IMPLICIT_REFLECTION=1 $(REQUIRE_CONSTEXPR_CTTI_TYPE_INDEX_FAIL) [ requires cxx14_constexpr ]
+            :   $(target-name)__$(variant:L)_fail
+        ] ;
+    }
+    return $(tests) ;
+}
+
+rule test-bfl-run_pfr_explicit ( sources + ) {
+    local tests ;
+    local target-name = $(sources[1]:B) ;
+    local VARIANTS = 
+        EXPLICIT_0
+        EXPLICIT_1
+        EXPLICIT_2
+      ;
+    for local variant in $(VARIANTS)
+    {
+        tests += [
+            run
+                $(sources) : :
+            :   <define>BOOST_FUSION_USE_PFR_$(variant)=1 [ requires cxx14_constexpr ]
+            :   $(target-name)__$(variant:L)
+        ] ;
+    }
+    return $(tests) ;
+}
+
+rule test-bfl-run_pfr_only_force ( sources + ) {
+    local tests ;
+    local target-name = $(sources[1]:B) ;
+    local VARIANTS = 
+        ONLY_FORCE_0
+        ONLY_FORCE_1
+      ;
+    for local variant in $(VARIANTS)
+    {
+        tests += [
+            run
+                $(sources) : :
+            :   <define>BOOST_FUSION_USE_PFR_$(variant)=1
+            :   $(target-name)__$(variant:L)
+        ] ;
+    }
+    return $(tests) ;
+}
+
 project
     : requirements
         $(CI_DEFINES)
@@ -25,252 +128,276 @@ project
 {
     test-suite fusion :
 
-    [ run algorithm/all.cpp ]
-    [ run algorithm/any.cpp ]
-    [ run algorithm/clear.cpp ]
-    [ run algorithm/copy.cpp ]
-    [ run algorithm/count.cpp ]
-    [ run algorithm/count_if.cpp ]
-    [ run algorithm/erase.cpp ]
-    [ run algorithm/erase_key.cpp ]
-    [ run algorithm/filter.cpp ]
-    [ run algorithm/filter_if.cpp ]
-    [ run algorithm/find.cpp ]
-    [ run algorithm/find_if.cpp ]
-    [ run algorithm/fold.cpp ]
-    [ run algorithm/for_each.cpp ]
-    [ run algorithm/insert.cpp ]
-    [ run algorithm/insert_range.cpp ]
-    [ run algorithm/iter_fold.cpp ]
-    [ run algorithm/move.cpp : :
+    [ test-bfl-run_with_and_without_fallback algorithm/all.cpp ]
+    [ test-bfl-run_with_and_without_fallback algorithm/any.cpp ]
+    [ test-bfl-run_with_and_without_fallback algorithm/clear.cpp ]
+    [ test-bfl-run_with_and_without_fallback algorithm/copy.cpp ]
+    [ test-bfl-run_with_and_without_fallback algorithm/count.cpp ]
+    [ test-bfl-run_with_and_without_fallback algorithm/count_if.cpp ]
+    [ test-bfl-run_with_and_without_fallback algorithm/erase.cpp ]
+    [ test-bfl-run_with_and_without_fallback algorithm/erase_key.cpp ]
+    [ test-bfl-run_with_and_without_fallback algorithm/filter.cpp ]
+    [ test-bfl-run_with_and_without_fallback algorithm/filter_if.cpp ]
+    [ test-bfl-run_with_and_without_fallback algorithm/find.cpp ]
+    [ test-bfl-run_with_and_without_fallback algorithm/find_if.cpp ]
+    [ test-bfl-run_with_and_without_fallback algorithm/fold.cpp ]
+    [ test-bfl-run_with_and_without_fallback algorithm/for_each.cpp ]
+    [ test-bfl-run_with_and_without_fallback algorithm/insert.cpp ]
+    [ test-bfl-run_with_and_without_fallback algorithm/insert_range.cpp ]
+    [ test-bfl-run_with_and_without_fallback algorithm/iter_fold.cpp ]
+    [ test-bfl-run_with_and_without_fallback algorithm/move.cpp : :
         : [ requires cxx11_rvalue_references ] ]
-    [ run algorithm/none.cpp ]
-    [ run algorithm/pop_back.cpp ]
-    [ run algorithm/pop_front.cpp ]
-    [ run algorithm/push_back.cpp ]
-    [ run algorithm/push_front.cpp ]
-    [ run algorithm/remove.cpp ]
-    [ run algorithm/remove_if.cpp ]
-    [ run algorithm/replace.cpp ]
-    [ run algorithm/replace_if.cpp ]
-    [ run algorithm/reverse_fold.cpp ]
-    [ run algorithm/reverse_iter_fold.cpp ]
-    [ run algorithm/reverse.cpp ]
-    [ run algorithm/segmented_for_each.cpp ]
-    [ run algorithm/segmented_find.cpp ]
-    [ run algorithm/segmented_find_if.cpp ]
-    [ run algorithm/segmented_fold.cpp ]
-    [ run algorithm/transform.cpp ]
-    [ run algorithm/join.cpp ]
-    [ run algorithm/zip.cpp ]
-    [ run algorithm/zip2.cpp ]
-    [ run algorithm/zip_ignore.cpp ]
-    [ run algorithm/flatten.cpp ]
-    [ compile algorithm/ticket-5490.cpp ]
+    [ test-bfl-run_with_and_without_fallback algorithm/none.cpp ]
+    [ test-bfl-run_with_and_without_fallback algorithm/pop_back.cpp ]
+    [ test-bfl-run_with_and_without_fallback algorithm/pop_front.cpp ]
+    [ test-bfl-run_with_and_without_fallback algorithm/push_back.cpp ]
+    [ test-bfl-run_with_and_without_fallback algorithm/push_front.cpp ]
+    [ test-bfl-run_with_and_without_fallback algorithm/remove.cpp ]
+    [ test-bfl-run_with_and_without_fallback algorithm/remove_if.cpp ]
+    [ test-bfl-run_with_and_without_fallback algorithm/replace.cpp ]
+    [ test-bfl-run_with_and_without_fallback algorithm/replace_if.cpp ]
+    [ test-bfl-run_with_and_without_fallback algorithm/reverse_fold.cpp ]
+    [ test-bfl-run_with_and_without_fallback algorithm/reverse_iter_fold.cpp ]
+    [ test-bfl-run_with_and_without_fallback algorithm/reverse.cpp ]
+    [ test-bfl-run_with_and_without_fallback algorithm/segmented_for_each.cpp ]
+    [ test-bfl-run_with_and_without_fallback algorithm/segmented_find.cpp ]
+    [ test-bfl-run_with_and_without_fallback algorithm/segmented_find_if.cpp ]
+    [ test-bfl-run_with_and_without_fallback algorithm/segmented_fold.cpp ]
+    [ test-bfl-run_with_and_without_fallback algorithm/transform.cpp ]
+    [ test-bfl-run_with_and_without_fallback algorithm/join.cpp ]
+    [ test-bfl-run_with_and_without_fallback algorithm/zip.cpp ]
+    [ test-bfl-run_with_and_without_fallback algorithm/zip2.cpp ]
+    [ test-bfl-run_with_and_without_fallback algorithm/zip_ignore.cpp ]
+    [ test-bfl-run_with_and_without_fallback algorithm/flatten.cpp ]
+    [ test-bfl-compile_with_and_without_fallback algorithm/ticket-5490.cpp ]
+
+    [ run sequence/detail/boost_pfr_utils.cpp : :
+        : <define>BOOST_FUSION_EXPECT_CTTI_TYPE_INDEX_CONSTEXPR_WHEN_UTILS_TEST=1 <define>BOOST_PFR_ENABLE_IMPLICIT_REFLECTION=1 $(REQUIRE_CONSTEXPR_CTTI_TYPE_INDEX) [ requires cxx14_constexpr ]
+        : detail_boost_pfr_utils_expect_constexpr_ctti_type_index
+    ]
+    [ run sequence/detail/boost_pfr_utils.cpp : :
+        : <define>BOOST_FUSION_EXPECT_CTTI_TYPE_INDEX_NONCONSTEXPR_WHEN_UTILS_TEST=1 <define>BOOST_PFR_ENABLE_IMPLICIT_REFLECTION=1 $(REQUIRE_CONSTEXPR_CTTI_TYPE_INDEX_FAIL) [ requires cxx14_constexpr ]
+        : detail_boost_pfr_utils_expect_nonconstexpr_ctti_type_index
+    ]
 
-    [ run sequence/as_deque.cpp ]
-    [ run sequence/as_list.cpp ]
-    [ run sequence/as_map.cpp ]
-    [ run sequence/as_map_assoc.cpp ]
-    [ run sequence/as_set.cpp ]
-    [ run sequence/as_vector.cpp ]
-    [ run sequence/boost_tuple.cpp ]
-    [ run sequence/boost_tuple_iterator.cpp ]
-    [ run sequence/cons.cpp ]
-    [ run sequence/convert_boost_tuple.cpp ]
-    [ run sequence/convert_deque.cpp ]
-    [ run sequence/convert_list.cpp ]
-    [ run sequence/convert_std_pair.cpp ]
-    [ run sequence/convert_std_tuple.cpp : :
+    [ test-bfl-run_with_and_without_fallback sequence/as_deque.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/as_list.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/as_map.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/as_map_assoc.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/as_set.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/as_vector.cpp ]
+    [ test-bfl-run_pfr_implicit sequence/boost_pfr.cpp ]
+    [ test-bfl-run_pfr_implicit sequence/boost_pfr_empty.cpp ]
+    [ test-bfl-run_pfr_implicit sequence/boost_pfr_convert.cpp ]
+    [ test-bfl-run_pfr_explicit sequence/boost_pfr_iterator.cpp ]
+    [ test-bfl-run_pfr_explicit sequence/boost_pfr_force_macro.cpp ]
+    [ test-bfl-run_pfr_explicit sequence/boost_pfr_explicit.cpp ]
+    [ test-bfl-run_pfr_only_force sequence/boost_pfr_force_macro_only.cpp ]
+    # FIXME it doesn't work properly due to issue on PFR side
+    # [ test-bfl-run_pfr_implicit sequence/boost_pfr_reference.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/boost_tuple.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/boost_tuple_iterator.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/cons.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/convert_boost_tuple.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/convert_deque.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/convert_list.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/convert_std_pair.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/convert_std_tuple.cpp : :
         : [ requires cxx11_variadic_templates cxx11_hdr_tuple ] ]
-    [ run sequence/convert_vector.cpp ]
-    [ run sequence/filter_view.cpp ]
-    [ run sequence/hash.cpp ]
-    [ run sequence/io.cpp ]
-    [ run sequence/iterator_range.cpp ]
-    [ run sequence/joint_view.cpp ]
-    [ run sequence/list_comparison.cpp ]
-    [ run sequence/list_construction.cpp ]
-    [ run sequence/list_copy.cpp ]
-    [ run sequence/list_iterator.cpp ]
-    [ run sequence/list_hash.cpp ]
-    [ run sequence/list_make.cpp ]
-    [ run sequence/list_misc.cpp ]
-    [ run sequence/list_mutate.cpp ]
-    [ run sequence/list_nest.cpp ]
-    [ run sequence/list_tie.cpp ]
-    [ run sequence/list_value_at.cpp ]
-    [ run sequence/deque_comparison.cpp ]
-    [ run sequence/deque_construction.cpp ]
-    [ run sequence/deque_copy.cpp ]
-    [ run sequence/deque_iterator.cpp ]
-    [ run sequence/deque_hash.cpp ]
-    [ compile sequence/deque_is_constructible.cpp ]
-    [ run sequence/deque_make.cpp ]
-    [ run sequence/deque_misc.cpp ]
-    [ run sequence/deque_move.cpp : :
+    [ test-bfl-run_with_and_without_fallback sequence/convert_vector.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/filter_view.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/hash.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/io.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/iterator_range.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/joint_view.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/list_comparison.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/list_construction.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/list_copy.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/list_iterator.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/list_hash.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/list_make.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/list_misc.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/list_mutate.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/list_nest.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/list_tie.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/list_value_at.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/deque_comparison.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/deque_construction.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/deque_copy.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/deque_iterator.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/deque_hash.cpp ]
+    [ test-bfl-compile_with_and_without_fallback sequence/deque_is_constructible.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/deque_make.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/deque_misc.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/deque_move.cpp : :
         : [ requires cxx11_rvalue_references ] ]
-    [ run sequence/deque_mutate.cpp ]
-    [ run sequence/deque_nest.cpp ]
-    [ run sequence/deque_tie.cpp ]
-    [ run sequence/deque_value_at.cpp ]
-    [ run sequence/front_extended_deque.cpp ]
-    [ run sequence/back_extended_deque.cpp ]
-    [ run sequence/make_list.cpp ]
-    [ run sequence/make_vector.cpp ]
-    [ run sequence/map.cpp ]
-    [ run sequence/map_comparison.cpp ]
-    [ run sequence/map_construction.cpp ]
-    [ run sequence/map_copy.cpp ]
-    [ run sequence/map_misc.cpp ]
-    [ run sequence/map_move.cpp : :
+    [ test-bfl-run_with_and_without_fallback sequence/deque_mutate.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/deque_nest.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/deque_tie.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/deque_value_at.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/front_extended_deque.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/back_extended_deque.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/make_list.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/make_vector.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/map.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/map_comparison.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/map_construction.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/map_copy.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/map_misc.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/map_move.cpp : :
         : [ requires cxx11_rvalue_references ] ]
-    [ run sequence/map_mutate.cpp ]
-    [ run sequence/map_tie.cpp ]
-    [ run sequence/nil.cpp ]
-    [ run sequence/nview.cpp ]
-    [ run sequence/reverse_view.cpp ]
-    [ run sequence/segmented_iterator_range.cpp ]
-    [ run sequence/set.cpp ]
-    [ run sequence/single_view.cpp ]
-    [ run sequence/std_pair.cpp ]
-    [ run sequence/boost_array.cpp ]
-    [ run sequence/array.cpp ]
-    [ run sequence/std_array.cpp : :
+    [ test-bfl-run_with_and_without_fallback sequence/map_mutate.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/map_tie.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/nil.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/nview.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/reverse_view.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/segmented_iterator_range.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/set.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/single_view.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/std_pair.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/boost_array.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/array.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/std_array.cpp : :
         : [ requires cxx11_hdr_array ] ]
-    [ run sequence/tuple_comparison.cpp ]
-    [ run sequence/tuple_construction.cpp ]
-    [ run sequence/tuple_conversion.cpp ]
-    [ run sequence/tuple_copy.cpp ]
-    [ run sequence/tuple_element.cpp ]
-    [ run sequence/tuple_make.cpp ]
-    [ run sequence/tuple_misc.cpp ]
-    [ run sequence/tuple_mutate.cpp ]
-    [ run sequence/tuple_nest.cpp ]
-    [ run sequence/tuple_hash.cpp ]
-    [ run sequence/tuple_tie.cpp ]
-    [ run sequence/tuple_traits.cpp : :
+    [ test-bfl-run_with_and_without_fallback sequence/tuple_comparison.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/tuple_construction.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/tuple_conversion.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/tuple_copy.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/tuple_element.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/tuple_make.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/tuple_misc.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/tuple_mutate.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/tuple_nest.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/tuple_hash.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/tuple_tie.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/tuple_traits.cpp : :
         :
         : tuple_traits__maybe_variadic ]
-    [ run sequence/tuple_traits.cpp : :
+    [ test-bfl-run_with_and_without_fallback sequence/tuple_traits.cpp : :
         : <define>BOOST_FUSION_DISABLE_VARIADIC_VECTOR
         : tuple_traits__no_variadic ]
-    [ run sequence/transform_view.cpp ]
-    [ run sequence/identity_view.cpp ]
-    [ run sequence/vector_comparison.cpp ]
-    [ run sequence/vector_construction.cpp ]
-    [ run sequence/vector_conversion.cpp ]
-    [ run sequence/vector_copy.cpp ]
-    [ run sequence/vector_iterator.cpp ]
-    [ run sequence/vector_make.cpp ]
-    [ run sequence/vector_misc.cpp ]
-    [ run sequence/vector_move.cpp : :
+    [ test-bfl-run_with_and_without_fallback sequence/transform_view.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/identity_view.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/vector_comparison.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/vector_construction.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/vector_conversion.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/vector_copy.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/vector_iterator.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/vector_make.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/vector_misc.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/vector_move.cpp : :
         : [ requires cxx11_rvalue_references ] ]
-    [ run sequence/vector_mutate.cpp ]
-    [ run sequence/vector_n.cpp ]
-    [ run sequence/vector_nest.cpp ]
-    [ run sequence/vector_hash.cpp ]
-    [ run sequence/vector_tie.cpp ]
-    [ run sequence/vector_traits.cpp : :
+    [ test-bfl-run_with_and_without_fallback sequence/vector_mutate.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/vector_n.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/vector_nest.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/vector_hash.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/vector_tie.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/vector_traits.cpp : :
         :
         : vector_traits__maybe_variadic ]
-    [ run sequence/vector_traits.cpp : :
+    [ test-bfl-run_with_and_without_fallback sequence/vector_traits.cpp : :
         : <define>BOOST_FUSION_DISABLE_VARIADIC_VECTOR
         : vector_traits__no_variadic ]
-    [ run sequence/vector_value_at.cpp ]
-    [ run sequence/zip_view.cpp ]
-    [ run sequence/zip_view2.cpp ]
-    [ run sequence/zip_view_ignore.cpp ]
-    [ run sequence/repetitive_view.cpp ]
-    [ run sequence/deduce_sequence.cpp ]
-    [ run sequence/adapt_adt_named.cpp ]
-    [ run sequence/adapt_adt_named_empty.cpp ]
-    [ run sequence/adapt_adt.cpp ]
-    [ run sequence/adapt_adt_empty.cpp ]
-    [ run sequence/adapt_assoc_adt_named.cpp ]
-    [ run sequence/adapt_assoc_adt_named_empty.cpp ]
-    [ run sequence/adapt_assoc_adt.cpp ]
-    [ run sequence/adapt_assoc_adt_empty.cpp ]
-    [ run sequence/adapt_assoc_struct_named.cpp ]
-    [ run sequence/adapt_assoc_struct_named_empty.cpp ]
-    [ run sequence/adapt_assoc_struct.cpp ]
-    [ run sequence/adapt_assoc_struct_empty.cpp ]
-    [ run sequence/adapt_assoc_tpl_adt.cpp ]
-    [ run sequence/adapt_assoc_tpl_adt_empty.cpp ]
-    [ run sequence/adapt_assoc_tpl_struct.cpp ]
-    [ run sequence/adapt_assoc_tpl_struct_empty.cpp ]
-    [ run sequence/adapt_struct_named.cpp ]
-    [ run sequence/adapt_struct_named_empty.cpp ]
-    [ run sequence/adapt_struct.cpp ]
-    [ run sequence/adapt_struct_empty.cpp ]
-    [ run sequence/adapt_tpl_adt.cpp ]
-    [ run sequence/adapt_tpl_adt_empty.cpp ]
-    [ run sequence/adapt_tpl_struct.cpp ]
-    [ run sequence/adapt_tpl_struct_empty.cpp ]
-    [ run sequence/adt_attribute_proxy.cpp ]
-    [ run sequence/define_struct.cpp ]
-    [ run sequence/define_struct_empty.cpp ]
-    [ run sequence/define_struct_move.cpp : :
+    [ test-bfl-run_with_and_without_fallback sequence/vector_value_at.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/zip_view.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/zip_view2.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/zip_view_ignore.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/repetitive_view.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/deduce_sequence.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/adapt_adt_named.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/adapt_adt_named_empty.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/adapt_adt.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/adapt_adt_empty.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/adapt_assoc_adt_named.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/adapt_assoc_adt_named_empty.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/adapt_assoc_adt.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/adapt_assoc_adt_empty.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/adapt_assoc_struct_named.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/adapt_assoc_struct_named_empty.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/adapt_assoc_struct.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/adapt_assoc_struct_empty.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/adapt_assoc_tpl_adt.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/adapt_assoc_tpl_adt_empty.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/adapt_assoc_tpl_struct.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/adapt_assoc_tpl_struct_empty.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/adapt_struct_named.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/adapt_struct_named_empty.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/adapt_struct.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/adapt_struct_empty.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/adapt_tpl_adt.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/adapt_tpl_adt_empty.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/adapt_tpl_struct.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/adapt_tpl_struct_empty.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/adt_attribute_proxy.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/define_struct.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/define_struct_empty.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/define_struct_move.cpp : :
         : [ requires cxx11_rvalue_references ] ]
-    [ run sequence/define_struct_inline.cpp ]
-    [ run sequence/define_struct_inline_empty.cpp ]
-    [ run sequence/define_struct_inline_move.cpp : :
+    [ test-bfl-run_with_and_without_fallback sequence/define_struct_inline.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/define_struct_inline_empty.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/define_struct_inline_move.cpp : :
         : [ requires cxx11_rvalue_references ] ]
-    [ run sequence/define_assoc_struct.cpp ]
-    [ run sequence/define_assoc_struct_empty.cpp ]
-    [ run sequence/define_assoc_struct_move.cpp : :
+    [ test-bfl-run_with_and_without_fallback sequence/define_assoc_struct.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/define_assoc_struct_empty.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/define_assoc_struct_move.cpp : :
         : [ requires cxx11_rvalue_references ] ]
-    [ run sequence/define_tpl_struct.cpp ]
-    [ run sequence/define_tpl_struct_empty.cpp ]
-    [ run sequence/define_tpl_struct_move.cpp : :
+    [ test-bfl-run_with_and_without_fallback sequence/define_tpl_struct.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/define_tpl_struct_empty.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/define_tpl_struct_move.cpp : :
         : [ requires cxx11_rvalue_references ] ]
-    [ run sequence/define_tpl_struct_inline.cpp ]
-    [ run sequence/define_tpl_struct_inline_empty.cpp ]
-    [ run sequence/define_tpl_struct_inline_move.cpp : :
+    [ test-bfl-run_with_and_without_fallback sequence/define_tpl_struct_inline.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/define_tpl_struct_inline_empty.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/define_tpl_struct_inline_move.cpp : :
         : [ requires cxx11_rvalue_references ] ]
-    [ run sequence/define_assoc_tpl_struct.cpp ]
-    [ run sequence/define_assoc_tpl_struct_empty.cpp ]
-    [ run sequence/define_assoc_tpl_struct_move.cpp : :
+    [ test-bfl-run_with_and_without_fallback sequence/define_assoc_tpl_struct.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/define_assoc_tpl_struct_empty.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/define_assoc_tpl_struct_move.cpp : :
         : [ requires cxx11_rvalue_references ] ]
-    [ run sequence/std_tuple.cpp : :
+    [ test-bfl-run_with_and_without_fallback sequence/std_tuple.cpp : :
         : [ requires cxx11_variadic_templates cxx11_hdr_tuple ] ]
-    [ run sequence/std_tuple_iterator.cpp : :
+    [ test-bfl-run_with_and_without_fallback sequence/std_tuple_iterator.cpp : :
         : [ requires cxx11_variadic_templates cxx11_hdr_tuple ] ]
-    [ run sequence/ref_vector.cpp ]
-    [ run sequence/flatten_view.cpp ]
-    [ compile sequence/github-159.cpp ]
-    [ run sequence/github-176.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/ref_vector.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/flatten_view.cpp ]
+    [ test-bfl-compile_with_and_without_fallback sequence/github-159.cpp ]
+    [ test-bfl-run_with_and_without_fallback sequence/github-176.cpp ]
 
-    [ compile sequence/size.cpp ]
+    [ test-bfl-compile_with_and_without_fallback sequence/size.cpp ]
 
-    [ run functional/fused.cpp ]
-    [ run functional/fused_function_object.cpp ]
-    [ run functional/fused_procedure.cpp ]
-    [ run functional/unfused.cpp ]
-    [ run functional/unfused_typed.cpp ]
-    [ run functional/make_fused.cpp ]
-    [ run functional/make_fused_function_object.cpp ]
-    [ run functional/make_fused_procedure.cpp ]
-    [ run functional/make_unfused.cpp ]
-    [ run functional/invoke.cpp ]
-    [ run functional/invoke_function_object.cpp ]
-    [ run functional/invoke_procedure.cpp ]
-    [ run sequence/swap.cpp ]
+    [ test-bfl-run_with_and_without_fallback functional/fused.cpp ]
+    [ test-bfl-run_with_and_without_fallback functional/fused_function_object.cpp ]
+    [ test-bfl-run_with_and_without_fallback functional/fused_procedure.cpp ]
+    [ test-bfl-run_with_and_without_fallback functional/unfused.cpp ]
+    [ test-bfl-run_with_and_without_fallback functional/unfused_typed.cpp ]
+    [ test-bfl-run_with_and_without_fallback functional/make_fused.cpp ]
+    [ test-bfl-run_with_and_without_fallback functional/make_fused_function_object.cpp ]
+    [ test-bfl-run_with_and_without_fallback functional/make_fused_procedure.cpp ]
+    [ test-bfl-run_with_and_without_fallback functional/make_unfused.cpp ]
+    [ test-bfl-run_with_and_without_fallback functional/invoke.cpp ]
+    [ test-bfl-run_with_and_without_fallback functional/invoke_function_object.cpp ]
+    [ test-bfl-run_with_and_without_fallback functional/invoke_procedure.cpp ]
+    [ test-bfl-run_with_and_without_fallback 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 ]
-    [ compile support/pair_set.cpp ]
-    [ compile support/pair_vector.cpp ]
-    [ compile support/pair_nest.cpp ]
-    [ compile support/index_sequence.cpp
+    [ run support/config.cpp : : : <test-info>always_show_run_output ]
+    [ compile support/config_pfr_0.cpp ]
+    [ compile support/config_pfr_1.cpp ]
+    [ compile-fail support/config_pfr_fail_0.cpp ]
+    [ compile-fail support/config_pfr_fail_1.cpp ]
+    [ compile-fail support/config_pfr_fail_2.cpp ]
+    [ test-bfl-compile_strictly_without_fallback support/is_sequence.cpp ]
+    [ test-bfl-compile_strictly_without_fallback support/is_view.cpp ]
+    [ test-bfl-compile_with_and_without_fallback support/pair_deque.cpp ]
+    [ test-bfl-compile_with_and_without_fallback support/pair_list.cpp ]
+    [ test-bfl-compile_with_and_without_fallback support/pair_map.cpp ]
+    [ test-bfl-compile_with_and_without_fallback support/pair_set.cpp ]
+    [ test-bfl-compile_with_and_without_fallback support/pair_vector.cpp ]
+    [ test-bfl-compile_with_and_without_fallback support/pair_nest.cpp ]
+    [ test-bfl-compile_with_and_without_fallback support/index_sequence.cpp
         : [ requires cxx11_variadic_templates ] ]
-    [ compile support/and.cpp
+    [ test-bfl-compile_with_and_without_fallback support/and.cpp
         : [ requires cxx11_variadic_templates ] ]
-    [ compile support/tag_of.cpp ]
-    [ compile support/unused.cpp ]
+    [ test-bfl-compile_strictly_without_fallback support/tag_of.cpp ]
+    [ test-bfl-compile_with_and_without_fallback support/unused.cpp ]
     [ compile support/detail/tag_of_fallback.cpp ]
 
 #   [ compile-fail xxx.cpp  ]
diff --git a/test/algorithm/all.cpp b/test/algorithm/all.cpp
index 7b5550732..d69601fb4 100644
--- a/test/algorithm/all.cpp
+++ b/test/algorithm/all.cpp
@@ -12,6 +12,8 @@
 #include <boost/lambda/lambda.hpp>
 #include <boost/mpl/vector_c.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 namespace
 {
     struct search_for
diff --git a/test/algorithm/any.cpp b/test/algorithm/any.cpp
index da0aa7933..44a483168 100644
--- a/test/algorithm/any.cpp
+++ b/test/algorithm/any.cpp
@@ -13,6 +13,8 @@
 #include <boost/lambda/lambda.hpp>
 #include <boost/mpl/vector_c.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 namespace
 {
     struct search_for
diff --git a/test/algorithm/clear.cpp b/test/algorithm/clear.cpp
index f90f5c0a6..87e293c9e 100644
--- a/test/algorithm/clear.cpp
+++ b/test/algorithm/clear.cpp
@@ -12,6 +12,8 @@
 #include <boost/fusion/algorithm/transformation/clear.hpp>
 #include <boost/mpl/vector_c.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 int
 main()
 {
diff --git a/test/algorithm/copy.cpp b/test/algorithm/copy.cpp
index 330caca62..0484fc5fb 100644
--- a/test/algorithm/copy.cpp
+++ b/test/algorithm/copy.cpp
@@ -10,6 +10,8 @@
 #include <boost/fusion/sequence/comparison.hpp>
 #include <boost/fusion/algorithm/auxiliary/copy.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 int
 main()
 {
diff --git a/test/algorithm/count.cpp b/test/algorithm/count.cpp
index 13aaad1a6..5546ac1b2 100644
--- a/test/algorithm/count.cpp
+++ b/test/algorithm/count.cpp
@@ -12,6 +12,8 @@
 #include <boost/mpl/vector_c.hpp>
 #include <string>
 
+#include "../with_or_without_fallback.hpp"
+
 int
 main()
 {
diff --git a/test/algorithm/count_if.cpp b/test/algorithm/count_if.cpp
index 7555f6fcb..fdb9b2fd1 100644
--- a/test/algorithm/count_if.cpp
+++ b/test/algorithm/count_if.cpp
@@ -12,6 +12,8 @@
 #include <boost/mpl/vector_c.hpp>
 #include <functional>
 
+#include "../with_or_without_fallback.hpp"
+
 template <typename F> struct bind1st;
 template <template <typename> class F, typename T>
 struct bind1st<F<T> > : public F<T>
diff --git a/test/algorithm/erase.cpp b/test/algorithm/erase.cpp
index f376ba2a5..fd5a5b5e0 100644
--- a/test/algorithm/erase.cpp
+++ b/test/algorithm/erase.cpp
@@ -17,6 +17,8 @@
 #include <boost/mpl/advance.hpp>
 #include <boost/mpl/int.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 int
 main()
 {
diff --git a/test/algorithm/erase_key.cpp b/test/algorithm/erase_key.cpp
index 34f69248c..8b66f8c9d 100644
--- a/test/algorithm/erase_key.cpp
+++ b/test/algorithm/erase_key.cpp
@@ -24,6 +24,8 @@
 #include <iostream>
 #include <string>
 
+#include "../with_or_without_fallback.hpp"
+
 template <typename Set>
 void test_set(Set const& set)
 {
@@ -50,7 +52,7 @@ void test_map(Map const& map)
     BOOST_STATIC_ASSERT(boost::fusion::result_of::size<Map>::value == 3);
     BOOST_TEST(((*find<_1>(map)).second == 1));
     BOOST_TEST(((*find<_3>(map)).second == 1.5));
-    BOOST_TEST(((*find<_4>(map)).second == std::string("hello")));
+    BOOST_TEST(((*find<_4>(map)).second == "hello"));
 }
 
 int
@@ -67,7 +69,7 @@ main()
     std::cout << tuple_delimiter(", ");
 
     test_set(erase_key<char>(make_set(1, 'x', 1.5, std::string("hello"))));
-    test_map(erase_key<_2>(make_map<_1, _2, _3, _4>(1, 'x', 1.5, "hello")));
+    test_map(erase_key<_2>(make_map<_1, _2, _3, _4>(1, 'x', 1.5, std::string("hello"))));
 
     return boost::report_errors();
 }
diff --git a/test/algorithm/filter.cpp b/test/algorithm/filter.cpp
index e762e4322..ad2c4e989 100644
--- a/test/algorithm/filter.cpp
+++ b/test/algorithm/filter.cpp
@@ -14,6 +14,8 @@
 #include <boost/fusion/algorithm/transformation/filter.hpp>
 #include <boost/mpl/vector.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 int
 main()
 {
diff --git a/test/algorithm/filter_if.cpp b/test/algorithm/filter_if.cpp
index 830813de6..ab90b8829 100644
--- a/test/algorithm/filter_if.cpp
+++ b/test/algorithm/filter_if.cpp
@@ -16,6 +16,8 @@
 #include <boost/mpl/vector.hpp>
 #include <boost/mpl/not.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 struct X
 {
     operator char const*() const
diff --git a/test/algorithm/find.cpp b/test/algorithm/find.cpp
index 83a86f1d9..e90199f7d 100644
--- a/test/algorithm/find.cpp
+++ b/test/algorithm/find.cpp
@@ -14,6 +14,8 @@
 #include <boost/mpl/vector.hpp>
 #include <string>
 
+#include "../with_or_without_fallback.hpp"
+
 struct X
 {
     operator int() const
diff --git a/test/algorithm/find_if.cpp b/test/algorithm/find_if.cpp
index c4dfafa28..cc4ea455b 100644
--- a/test/algorithm/find_if.cpp
+++ b/test/algorithm/find_if.cpp
@@ -14,6 +14,8 @@
 #include <boost/mpl/less.hpp>
 #include <boost/type_traits/is_same.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 struct X
 {
     operator int() const
diff --git a/test/algorithm/flatten.cpp b/test/algorithm/flatten.cpp
index ddc71006f..f44f60cde 100644
--- a/test/algorithm/flatten.cpp
+++ b/test/algorithm/flatten.cpp
@@ -19,6 +19,7 @@
 #include <boost/fusion/algorithm/auxiliary/copy.hpp>
 #include <boost/fusion/algorithm/transformation/flatten.hpp>
 
+#include "../with_or_without_fallback.hpp"
 
 int main()
 {
diff --git a/test/algorithm/fold.cpp b/test/algorithm/fold.cpp
index c441ceaf0..f01c74489 100644
--- a/test/algorithm/fold.cpp
+++ b/test/algorithm/fold.cpp
@@ -25,6 +25,8 @@
 
 #include <string>
 
+#include "../with_or_without_fallback.hpp"
+
 using boost::mpl::if_;
 using boost::mpl::int_;
 using boost::is_same;
diff --git a/test/algorithm/for_each.cpp b/test/algorithm/for_each.cpp
index 982cb3a12..953d655c2 100644
--- a/test/algorithm/for_each.cpp
+++ b/test/algorithm/for_each.cpp
@@ -13,6 +13,8 @@
 #include <boost/fusion/algorithm/iteration/for_each.hpp>
 #include <boost/mpl/vector_c.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 struct print
 {
     template <typename T>
diff --git a/test/algorithm/insert.cpp b/test/algorithm/insert.cpp
index a4239a8de..dc32a568c 100644
--- a/test/algorithm/insert.cpp
+++ b/test/algorithm/insert.cpp
@@ -17,6 +17,8 @@
 #include <boost/mpl/int.hpp>
 #include <string>
 
+#include "../with_or_without_fallback.hpp"
+
 int
 main()
 {
diff --git a/test/algorithm/insert_range.cpp b/test/algorithm/insert_range.cpp
index 28a02219b..f35cae714 100644
--- a/test/algorithm/insert_range.cpp
+++ b/test/algorithm/insert_range.cpp
@@ -17,6 +17,8 @@
 #include <boost/mpl/int.hpp>
 #include <string>
 
+#include "../with_or_without_fallback.hpp"
+
 int
 main()
 {
diff --git a/test/algorithm/iter_fold.cpp b/test/algorithm/iter_fold.cpp
index b37f90db5..9e6dcc4f2 100644
--- a/test/algorithm/iter_fold.cpp
+++ b/test/algorithm/iter_fold.cpp
@@ -5,6 +5,8 @@
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 ==============================================================================*/
 
+#include "../with_or_without_fallback.hpp"
+
 #define BOOST_FUSION_TEST_ITER_FOLD
 #include "fold.hpp"
 #undef BOOST_FUSION_TEST_ITER_FOLD
diff --git a/test/algorithm/join.cpp b/test/algorithm/join.cpp
index c0de1896a..3198f4c2a 100644
--- a/test/algorithm/join.cpp
+++ b/test/algorithm/join.cpp
@@ -12,6 +12,8 @@
 #include <boost/fusion/adapted/mpl.hpp>
 #include <boost/mpl/vector/vector10_c.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 int main()
 {
     using namespace boost::fusion;
diff --git a/test/algorithm/move.cpp b/test/algorithm/move.cpp
index d2f854030..60198ed5c 100644
--- a/test/algorithm/move.cpp
+++ b/test/algorithm/move.cpp
@@ -11,6 +11,8 @@
 #include <boost/fusion/algorithm/auxiliary/move.hpp>
 #include <utility>
 
+#include "../with_or_without_fallback.hpp"
+
 int main()
 {
     {
diff --git a/test/algorithm/none.cpp b/test/algorithm/none.cpp
index 83dfa7528..53bd0d772 100644
--- a/test/algorithm/none.cpp
+++ b/test/algorithm/none.cpp
@@ -12,6 +12,8 @@
 #include <boost/lambda/lambda.hpp>
 #include <boost/mpl/vector_c.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 namespace
 {
     struct search_for
diff --git a/test/algorithm/pop_back.cpp b/test/algorithm/pop_back.cpp
index fcb5b75cf..23bb02dc6 100644
--- a/test/algorithm/pop_back.cpp
+++ b/test/algorithm/pop_back.cpp
@@ -20,6 +20,8 @@
 #include <boost/array.hpp>
 #include <boost/mpl/vector_c.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 int
 main()
 {
diff --git a/test/algorithm/pop_front.cpp b/test/algorithm/pop_front.cpp
index df95b38c1..20581749c 100644
--- a/test/algorithm/pop_front.cpp
+++ b/test/algorithm/pop_front.cpp
@@ -13,6 +13,8 @@
 #include <boost/fusion/algorithm/transformation/pop_front.hpp>
 #include <boost/mpl/vector_c.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 int
 main()
 {
diff --git a/test/algorithm/push_back.cpp b/test/algorithm/push_back.cpp
index b53007fcf..1f896935d 100644
--- a/test/algorithm/push_back.cpp
+++ b/test/algorithm/push_back.cpp
@@ -16,6 +16,8 @@
 #include <boost/mpl/vector_c.hpp>
 #include <string>
 
+#include "../with_or_without_fallback.hpp"
+
 struct plus_one
 {
     template <typename T>
diff --git a/test/algorithm/push_front.cpp b/test/algorithm/push_front.cpp
index 8c63c5c3c..cb5bf185d 100644
--- a/test/algorithm/push_front.cpp
+++ b/test/algorithm/push_front.cpp
@@ -14,6 +14,8 @@
 #include <boost/mpl/vector_c.hpp>
 #include <string>
 
+#include "../with_or_without_fallback.hpp"
+
 int
 main()
 {
diff --git a/test/algorithm/remove.cpp b/test/algorithm/remove.cpp
index 76e0c737c..3b4ec024b 100644
--- a/test/algorithm/remove.cpp
+++ b/test/algorithm/remove.cpp
@@ -13,6 +13,8 @@
 #include <boost/fusion/algorithm/transformation/remove.hpp>
 #include <boost/mpl/vector.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 struct X
 {
     operator char const*() const
diff --git a/test/algorithm/remove_if.cpp b/test/algorithm/remove_if.cpp
index 62313d3a5..ed3be48dc 100644
--- a/test/algorithm/remove_if.cpp
+++ b/test/algorithm/remove_if.cpp
@@ -16,6 +16,8 @@
 #include <boost/mpl/not.hpp>
 #include <boost/mpl/vector.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 struct X
 {
     operator char const*() const
diff --git a/test/algorithm/replace.cpp b/test/algorithm/replace.cpp
index ddd651301..259f47b7c 100644
--- a/test/algorithm/replace.cpp
+++ b/test/algorithm/replace.cpp
@@ -14,6 +14,8 @@
 #include <boost/fusion/algorithm/transformation/replace.hpp>
 #include <string>
 
+#include "../with_or_without_fallback.hpp"
+
 int
 main()
 {
diff --git a/test/algorithm/replace_if.cpp b/test/algorithm/replace_if.cpp
index bad5905e1..7db580766 100644
--- a/test/algorithm/replace_if.cpp
+++ b/test/algorithm/replace_if.cpp
@@ -15,6 +15,8 @@
 #include <boost/fusion/algorithm/transformation/replace_if.hpp>
 #include <string>
 
+#include "../with_or_without_fallback.hpp"
+
 struct gt3
 {
     template <typename T>
diff --git a/test/algorithm/reverse.cpp b/test/algorithm/reverse.cpp
index 718d5b248..11ebb9095 100644
--- a/test/algorithm/reverse.cpp
+++ b/test/algorithm/reverse.cpp
@@ -13,6 +13,8 @@
 #include <boost/fusion/algorithm/transformation/reverse.hpp>
 #include <boost/mpl/range_c.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 int
 main()
 {
diff --git a/test/algorithm/reverse_fold.cpp b/test/algorithm/reverse_fold.cpp
index 7742bca84..30ebcfcdc 100644
--- a/test/algorithm/reverse_fold.cpp
+++ b/test/algorithm/reverse_fold.cpp
@@ -5,6 +5,8 @@
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 ==============================================================================*/
 
+#include "../with_or_without_fallback.hpp"
+
 #define BOOST_FUSION_TEST_REVERSE_FOLD
 #include "fold.hpp"
 #undef BOOST_FUSION_TEST_REVERSE_FOLD
diff --git a/test/algorithm/reverse_iter_fold.cpp b/test/algorithm/reverse_iter_fold.cpp
index 31e4cf265..41ac5b68b 100644
--- a/test/algorithm/reverse_iter_fold.cpp
+++ b/test/algorithm/reverse_iter_fold.cpp
@@ -5,6 +5,8 @@
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 ==============================================================================*/
 
+#include "../with_or_without_fallback.hpp"
+
 #define BOOST_FUSION_TEST_REVERSE_FOLD
 #define BOOST_FUSION_TEST_ITER_FOLD
 #include "fold.hpp"
diff --git a/test/algorithm/segmented_find.cpp b/test/algorithm/segmented_find.cpp
index 8ce0b6d55..e9654a4a6 100644
--- a/test/algorithm/segmented_find.cpp
+++ b/test/algorithm/segmented_find.cpp
@@ -9,6 +9,9 @@
 #include <boost/fusion/container/vector/vector.hpp>
 #include <boost/fusion/algorithm/query/find.hpp>
 #include <boost/fusion/container/generation/make_vector.hpp>
+
+#include "../with_or_without_fallback.hpp"
+
 #include "../sequence/tree.hpp"
 
 struct not_there {};
diff --git a/test/algorithm/segmented_find_if.cpp b/test/algorithm/segmented_find_if.cpp
index 98d963cff..804204a8a 100644
--- a/test/algorithm/segmented_find_if.cpp
+++ b/test/algorithm/segmented_find_if.cpp
@@ -11,6 +11,9 @@
 #include <boost/fusion/container/generation/make_vector.hpp>
 #include <boost/mpl/placeholders.hpp>
 #include <boost/type_traits/is_same.hpp>
+
+#include "../with_or_without_fallback.hpp"
+
 #include "../sequence/tree.hpp"
 
 struct not_there {};
diff --git a/test/algorithm/segmented_fold.cpp b/test/algorithm/segmented_fold.cpp
index af51ca89f..fdecbbed9 100644
--- a/test/algorithm/segmented_fold.cpp
+++ b/test/algorithm/segmented_fold.cpp
@@ -12,6 +12,9 @@
 #include <boost/fusion/container/vector/vector.hpp>
 #include <boost/fusion/algorithm/iteration/fold.hpp>
 #include <boost/fusion/container/generation/make_vector.hpp>
+
+#include "../with_or_without_fallback.hpp"
+
 #include "../sequence/tree.hpp"
 
 struct write_string
diff --git a/test/algorithm/segmented_for_each.cpp b/test/algorithm/segmented_for_each.cpp
index d1f4fe6ad..b37dedf3d 100644
--- a/test/algorithm/segmented_for_each.cpp
+++ b/test/algorithm/segmented_for_each.cpp
@@ -12,6 +12,9 @@
 #include <boost/fusion/algorithm/iteration/for_each.hpp>
 #include <boost/fusion/sequence/comparison/equal_to.hpp>
 #include <boost/fusion/sequence/io/out.hpp>
+
+#include "../with_or_without_fallback.hpp"
+
 #include "../sequence/tree.hpp"
 
 struct print
diff --git a/test/algorithm/ticket-5490.cpp b/test/algorithm/ticket-5490.cpp
index fedf733a2..b13093677 100644
--- a/test/algorithm/ticket-5490.cpp
+++ b/test/algorithm/ticket-5490.cpp
@@ -10,6 +10,8 @@
 #include <boost/mpl/placeholders.hpp>
 #include <boost/core/ignore_unused.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 using namespace boost::fusion;
 
 template <typename>
diff --git a/test/algorithm/transform.cpp b/test/algorithm/transform.cpp
index 8609f61cd..3598fbca7 100644
--- a/test/algorithm/transform.cpp
+++ b/test/algorithm/transform.cpp
@@ -17,6 +17,8 @@
 #include <boost/mpl/range_c.hpp>
 #include <boost/type_traits/is_reference.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 struct square
 {
     template<typename Sig>
diff --git a/test/algorithm/zip.cpp b/test/algorithm/zip.cpp
index b6a4f097e..7b94d183b 100644
--- a/test/algorithm/zip.cpp
+++ b/test/algorithm/zip.cpp
@@ -12,6 +12,8 @@
 #include <boost/fusion/adapted/mpl.hpp>
 #include <boost/mpl/vector.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 int main()
 {
     using namespace boost::fusion;
diff --git a/test/algorithm/zip2.cpp b/test/algorithm/zip2.cpp
index f35e4d5d8..aaaeda6b3 100644
--- a/test/algorithm/zip2.cpp
+++ b/test/algorithm/zip2.cpp
@@ -11,6 +11,8 @@
 #include <boost/fusion/adapted/mpl.hpp>
 #include <boost/mpl/vector.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 int main()
 {
     using namespace boost::fusion;
diff --git a/test/algorithm/zip_ignore.cpp b/test/algorithm/zip_ignore.cpp
index a12b58201..465fc2342 100644
--- a/test/algorithm/zip_ignore.cpp
+++ b/test/algorithm/zip_ignore.cpp
@@ -12,6 +12,8 @@
 #include <boost/fusion/iterator.hpp>
 #include <boost/fusion/sequence/intrinsic.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 int main()
 {
     using namespace boost::fusion;
diff --git a/test/constexpr_ctti_type_index_detection.cpp b/test/constexpr_ctti_type_index_detection.cpp
new file mode 100644
index 000000000..17c12ff17
--- /dev/null
+++ b/test/constexpr_ctti_type_index_detection.cpp
@@ -0,0 +1,46 @@
+/*=============================================================================
+    Copyright (c) 2023 Denis Mikhailov
+    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/type_index/ctti_type_index.hpp>
+
+namespace ns {
+struct user_defined_struct {
+  int first;
+  int second;
+};
+}
+
+// Helper function that returns true if `name` starts with `substr`
+template <std::size_t N>
+constexpr bool starts_with(const char* name, const char (&substr)[N]) noexcept {
+    static_assert(N > 0, "non a zero-terminated string passed");
+    for (std::size_t i = 0; i<N-1; ++i) {
+        if (name[i] != substr[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+
+// Function that returns name of the type without 'class ' or 'struct ' prefix
+template <class T>
+constexpr const char* name() noexcept {
+    const char* name = boost::typeindex::ctti_type_index::type_id<T>().raw_name();
+
+    // Some compilers add `class ` or `struct ` before the namespace, so we need to skip those words first
+    if (starts_with(name, "class ")) {
+        name += sizeof("class ") - 1;
+    } else if (starts_with(name, "struct ")) {
+        name += sizeof("struct ") - 1;
+    }
+
+    return name;
+}
+
+int main() {
+  static_assert(starts_with(name<ns::user_defined_struct>(), "ns::user_defined_struct"), "");
+}
+
diff --git a/test/functional/fused.cpp b/test/functional/fused.cpp
index 63a473485..1655cc609 100644
--- a/test/functional/fused.cpp
+++ b/test/functional/fused.cpp
@@ -18,6 +18,8 @@
 #include <boost/mpl/assert.hpp>
 #include <boost/mpl/empty_base.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 namespace fusion = boost::fusion;
 using boost::noncopyable;
 
diff --git a/test/functional/fused_function_object.cpp b/test/functional/fused_function_object.cpp
index cd3e2ea97..14c44f207 100644
--- a/test/functional/fused_function_object.cpp
+++ b/test/functional/fused_function_object.cpp
@@ -15,6 +15,8 @@
 #include <boost/fusion/container/generation/make_vector.hpp>
 #include <boost/fusion/container/vector.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 namespace fusion = boost::fusion;
 using boost::noncopyable;
 
diff --git a/test/functional/fused_procedure.cpp b/test/functional/fused_procedure.cpp
index 07b84e43e..49b59c023 100644
--- a/test/functional/fused_procedure.cpp
+++ b/test/functional/fused_procedure.cpp
@@ -15,6 +15,8 @@
 #include <boost/fusion/container/generation/make_vector.hpp>
 #include <boost/fusion/container/vector.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 namespace fusion = boost::fusion;
 using boost::noncopyable;
 
diff --git a/test/functional/invoke.cpp b/test/functional/invoke.cpp
index af3b813f4..5d7edfb9f 100644
--- a/test/functional/invoke.cpp
+++ b/test/functional/invoke.cpp
@@ -31,6 +31,8 @@
 #include <boost/fusion/iterator/advance.hpp>
 #include <boost/fusion/algorithm/transformation/join.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #include "../compile_time/sfinae_friendly.hpp"
 
 namespace mpl = boost::mpl;
diff --git a/test/functional/invoke_function_object.cpp b/test/functional/invoke_function_object.cpp
index 54cefc38d..fb5460ddc 100644
--- a/test/functional/invoke_function_object.cpp
+++ b/test/functional/invoke_function_object.cpp
@@ -30,6 +30,8 @@
 #include <boost/fusion/iterator/advance.hpp>
 #include <boost/fusion/algorithm/transformation/join.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #include "../compile_time/sfinae_friendly.hpp"
 
 namespace mpl = boost::mpl;
diff --git a/test/functional/invoke_procedure.cpp b/test/functional/invoke_procedure.cpp
index a608e3049..bba806b60 100644
--- a/test/functional/invoke_procedure.cpp
+++ b/test/functional/invoke_procedure.cpp
@@ -29,6 +29,8 @@
 #include <boost/fusion/iterator/advance.hpp>
 #include <boost/fusion/algorithm/transformation/join.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #include "../compile_time/sfinae_friendly.hpp"
 
 namespace mpl = boost::mpl;
diff --git a/test/functional/make_fused.cpp b/test/functional/make_fused.cpp
index 6503ee282..192cc4ab8 100644
--- a/test/functional/make_fused.cpp
+++ b/test/functional/make_fused.cpp
@@ -15,6 +15,8 @@
 #include <boost/fusion/container/generation/make_vector.hpp>
 #include <boost/fusion/container/vector.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 namespace fusion = boost::fusion;
 using boost::noncopyable;
 using boost::cref;
diff --git a/test/functional/make_fused_function_object.cpp b/test/functional/make_fused_function_object.cpp
index 9f803c4d8..f2d5fcdff 100644
--- a/test/functional/make_fused_function_object.cpp
+++ b/test/functional/make_fused_function_object.cpp
@@ -15,6 +15,8 @@
 #include <boost/fusion/container/generation/make_vector.hpp>
 #include <boost/fusion/container/vector.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 namespace fusion = boost::fusion;
 using boost::noncopyable;
 using boost::cref;
diff --git a/test/functional/make_fused_procedure.cpp b/test/functional/make_fused_procedure.cpp
index 51a82f782..3b445f433 100644
--- a/test/functional/make_fused_procedure.cpp
+++ b/test/functional/make_fused_procedure.cpp
@@ -15,6 +15,8 @@
 #include <boost/fusion/container/generation/make_vector.hpp>
 #include <boost/fusion/container/vector.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 namespace fusion = boost::fusion;
 using boost::noncopyable;
 using boost::cref;
diff --git a/test/functional/make_unfused.cpp b/test/functional/make_unfused.cpp
index b8ee99383..ec7bc75e8 100644
--- a/test/functional/make_unfused.cpp
+++ b/test/functional/make_unfused.cpp
@@ -24,6 +24,7 @@
 #include <boost/fusion/sequence/intrinsic/empty.hpp>
 #include <boost/fusion/algorithm/iteration/fold.hpp>
 
+#include "../with_or_without_fallback.hpp"
 
 namespace fusion = boost::fusion;
 namespace mpl = boost::mpl;
diff --git a/test/functional/unfused.cpp b/test/functional/unfused.cpp
index 21c0d42e6..47fcd8d1e 100644
--- a/test/functional/unfused.cpp
+++ b/test/functional/unfused.cpp
@@ -19,6 +19,8 @@
 #include <boost/fusion/sequence/intrinsic/empty.hpp>
 #include <boost/fusion/algorithm/iteration/fold.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 namespace fusion = boost::fusion;
 namespace mpl = boost::mpl;
 
diff --git a/test/functional/unfused_typed.cpp b/test/functional/unfused_typed.cpp
index a0f76d49d..a8a1f27f8 100644
--- a/test/functional/unfused_typed.cpp
+++ b/test/functional/unfused_typed.cpp
@@ -19,6 +19,8 @@
 
 #include <boost/fusion/algorithm/iteration/fold.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 namespace fusion = boost::fusion;
 namespace mpl = boost::mpl;
 using mpl::placeholders::_;
diff --git a/test/mock_fallback.hpp b/test/mock_fallback.hpp
new file mode 100644
index 000000000..3c180f06b
--- /dev/null
+++ b/test/mock_fallback.hpp
@@ -0,0 +1,34 @@
+/*=============================================================================
+    Copyright (c) 2023 Denis Mikhailov
+    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)
+==============================================================================*/
+
+// Mock fallback used in old compilers.
+
+#include <boost/mpl/integral_c.hpp>
+#include <boost/type_traits/enable_if.hpp>
+#include <boost/type_traits/is_function.hpp>
+
+template<typename T, typename S = void>
+struct my_is_implicitly_reflectable : boost::mpl::integral_c<bool, (sizeof(T) && false)> {
+};
+
+template<typename T>
+struct my_is_implicitly_reflectable<T, typename boost::enable_if<boost::is_function<T> >::type>
+    : boost::mpl::integral_c<bool, false> {
+};
+
+namespace boost { namespace fusion
+{
+    struct boost_my_reflectable_tag;
+    namespace detail
+    {
+        template<typename Sequence>
+        struct tag_of_fallback<Sequence, typename boost::enable_if<my_is_implicitly_reflectable<Sequence> >::type>
+        {
+            typedef boost_my_reflectable_tag type;
+        };
+    }
+}}
+
diff --git a/test/sequence/adapt_adt.cpp b/test/sequence/adapt_adt.cpp
index 00a149b72..608da24d7 100644
--- a/test/sequence/adapt_adt.cpp
+++ b/test/sequence/adapt_adt.cpp
@@ -32,6 +32,8 @@
 #include <iostream>
 #include <string>
 
+#include "../with_or_without_fallback.hpp"
+
 namespace ns
 {
     class point
diff --git a/test/sequence/adapt_adt_empty.cpp b/test/sequence/adapt_adt_empty.cpp
index 03e786b7a..e2f95fca7 100644
--- a/test/sequence/adapt_adt_empty.cpp
+++ b/test/sequence/adapt_adt_empty.cpp
@@ -27,6 +27,8 @@
 #include <boost/mpl/assert.hpp>
 #include <iostream>
 
+#include "../with_or_without_fallback.hpp"
+
 class empty_adt{};
 BOOST_FUSION_ADAPT_ADT(empty_adt,)
 
diff --git a/test/sequence/adapt_adt_named.cpp b/test/sequence/adapt_adt_named.cpp
index 19d2d8b11..dfd0a2e42 100644
--- a/test/sequence/adapt_adt_named.cpp
+++ b/test/sequence/adapt_adt_named.cpp
@@ -31,6 +31,8 @@
 #include <iostream>
 #include <string>
 
+#include "../with_or_without_fallback.hpp"
+
 namespace ns
 {
     class point
diff --git a/test/sequence/adapt_adt_named_empty.cpp b/test/sequence/adapt_adt_named_empty.cpp
index c7fa20331..117335f12 100644
--- a/test/sequence/adapt_adt_named_empty.cpp
+++ b/test/sequence/adapt_adt_named_empty.cpp
@@ -27,6 +27,8 @@
 #include <boost/mpl/assert.hpp>
 #include <iostream>
 
+#include "../with_or_without_fallback.hpp"
+
 class empty_adt{};
 BOOST_FUSION_ADAPT_ADT_NAMED(::empty_adt,empty_adt,)
 
diff --git a/test/sequence/adapt_assoc_adt.cpp b/test/sequence/adapt_assoc_adt.cpp
index a0dc22326..b26ea8cc9 100644
--- a/test/sequence/adapt_assoc_adt.cpp
+++ b/test/sequence/adapt_assoc_adt.cpp
@@ -20,6 +20,8 @@
 #include <iostream>
 #include <string>
 
+#include "../with_or_without_fallback.hpp"
+
 namespace ns
 {
     struct x_member;
diff --git a/test/sequence/adapt_assoc_adt_empty.cpp b/test/sequence/adapt_assoc_adt_empty.cpp
index 26cd98573..eb49e9126 100644
--- a/test/sequence/adapt_assoc_adt_empty.cpp
+++ b/test/sequence/adapt_assoc_adt_empty.cpp
@@ -27,6 +27,8 @@
 #include <boost/mpl/assert.hpp>
 #include <iostream>
 
+#include "../with_or_without_fallback.hpp"
+
 class empty_adt{};
 BOOST_FUSION_ADAPT_ASSOC_ADT(empty_adt,)
 
diff --git a/test/sequence/adapt_assoc_adt_named.cpp b/test/sequence/adapt_assoc_adt_named.cpp
index ecdd9028f..3d59f32fe 100644
--- a/test/sequence/adapt_assoc_adt_named.cpp
+++ b/test/sequence/adapt_assoc_adt_named.cpp
@@ -20,6 +20,8 @@
 #include <iostream>
 #include <string>
 
+#include "../with_or_without_fallback.hpp"
+
 namespace ns
 {
     struct x_member;
diff --git a/test/sequence/adapt_assoc_adt_named_empty.cpp b/test/sequence/adapt_assoc_adt_named_empty.cpp
index e2e268001..e58f1375b 100644
--- a/test/sequence/adapt_assoc_adt_named_empty.cpp
+++ b/test/sequence/adapt_assoc_adt_named_empty.cpp
@@ -27,6 +27,8 @@
 #include <boost/mpl/assert.hpp>
 #include <iostream>
 
+#include "../with_or_without_fallback.hpp"
+
 class empty_adt{};
 BOOST_FUSION_ADAPT_ASSOC_ADT_NAMED(::empty_adt,empty_adt,)
 
diff --git a/test/sequence/adapt_assoc_struct.cpp b/test/sequence/adapt_assoc_struct.cpp
index 6266e95f1..38df5f998 100644
--- a/test/sequence/adapt_assoc_struct.cpp
+++ b/test/sequence/adapt_assoc_struct.cpp
@@ -38,6 +38,8 @@
 #include <iostream>
 #include <string>
 
+#include "../with_or_without_fallback.hpp"
+
 namespace ns
 {
     struct x_member;
diff --git a/test/sequence/adapt_assoc_struct_empty.cpp b/test/sequence/adapt_assoc_struct_empty.cpp
index c7cadf947..626d4abab 100644
--- a/test/sequence/adapt_assoc_struct_empty.cpp
+++ b/test/sequence/adapt_assoc_struct_empty.cpp
@@ -27,6 +27,8 @@
 #include <boost/mpl/assert.hpp>
 #include <iostream>
 
+#include "../with_or_without_fallback.hpp"
+
 class empty_struct{};
 BOOST_FUSION_ADAPT_ASSOC_STRUCT(empty_struct,)
 
diff --git a/test/sequence/adapt_assoc_struct_named.cpp b/test/sequence/adapt_assoc_struct_named.cpp
index 966067871..839a6835b 100644
--- a/test/sequence/adapt_assoc_struct_named.cpp
+++ b/test/sequence/adapt_assoc_struct_named.cpp
@@ -18,6 +18,8 @@
 #include <iostream>
 #include <string>
 
+#include "../with_or_without_fallback.hpp"
+
 namespace ns
 {
     struct x_member;
diff --git a/test/sequence/adapt_assoc_struct_named_empty.cpp b/test/sequence/adapt_assoc_struct_named_empty.cpp
index a1783fd3b..79b027a28 100644
--- a/test/sequence/adapt_assoc_struct_named_empty.cpp
+++ b/test/sequence/adapt_assoc_struct_named_empty.cpp
@@ -27,6 +27,8 @@
 #include <boost/mpl/assert.hpp>
 #include <iostream>
 
+#include "../with_or_without_fallback.hpp"
+
 class empty_struct{};
 BOOST_FUSION_ADAPT_ASSOC_STRUCT_NAMED(::empty_struct,empty_struct,)
 
diff --git a/test/sequence/adapt_assoc_tpl_adt.cpp b/test/sequence/adapt_assoc_tpl_adt.cpp
index f416f46a8..11919af0d 100644
--- a/test/sequence/adapt_assoc_tpl_adt.cpp
+++ b/test/sequence/adapt_assoc_tpl_adt.cpp
@@ -20,6 +20,8 @@
 #include <iostream>
 #include <string>
 
+#include "../with_or_without_fallback.hpp"
+
 namespace ns
 {
     struct x_member;
diff --git a/test/sequence/adapt_assoc_tpl_adt_empty.cpp b/test/sequence/adapt_assoc_tpl_adt_empty.cpp
index f38ba7ac7..14af84343 100644
--- a/test/sequence/adapt_assoc_tpl_adt_empty.cpp
+++ b/test/sequence/adapt_assoc_tpl_adt_empty.cpp
@@ -27,6 +27,8 @@
 #include <boost/mpl/assert.hpp>
 #include <iostream>
 
+#include "../with_or_without_fallback.hpp"
+
 template <typename T>
 class empty_adt{};
 BOOST_FUSION_ADAPT_ASSOC_TPL_ADT((T), (empty_adt)(T),)
diff --git a/test/sequence/adapt_assoc_tpl_struct.cpp b/test/sequence/adapt_assoc_tpl_struct.cpp
index 49f42c5d2..5b2bba02c 100644
--- a/test/sequence/adapt_assoc_tpl_struct.cpp
+++ b/test/sequence/adapt_assoc_tpl_struct.cpp
@@ -33,6 +33,8 @@
 #include <iostream>
 #include <string>
 
+#include "../with_or_without_fallback.hpp"
+
 namespace ns
 {
     struct x_member;
diff --git a/test/sequence/adapt_assoc_tpl_struct_empty.cpp b/test/sequence/adapt_assoc_tpl_struct_empty.cpp
index 42795c419..b45407bd0 100644
--- a/test/sequence/adapt_assoc_tpl_struct_empty.cpp
+++ b/test/sequence/adapt_assoc_tpl_struct_empty.cpp
@@ -27,6 +27,8 @@
 #include <boost/mpl/assert.hpp>
 #include <iostream>
 
+#include "../with_or_without_fallback.hpp"
+
 template <typename T>
 class empty_struct{};
 BOOST_FUSION_ADAPT_ASSOC_TPL_STRUCT((T), (empty_struct)(T),)
diff --git a/test/sequence/adapt_struct.cpp b/test/sequence/adapt_struct.cpp
index 3518ff418..27a67c471 100644
--- a/test/sequence/adapt_struct.cpp
+++ b/test/sequence/adapt_struct.cpp
@@ -32,6 +32,8 @@
 #include <iostream>
 #include <string>
 
+#include "../with_or_without_fallback.hpp"
+
 namespace namespaced_type {
   typedef int integer;
 }
diff --git a/test/sequence/adapt_struct_empty.cpp b/test/sequence/adapt_struct_empty.cpp
index 202131d44..18564c01f 100644
--- a/test/sequence/adapt_struct_empty.cpp
+++ b/test/sequence/adapt_struct_empty.cpp
@@ -27,6 +27,8 @@
 #include <boost/mpl/assert.hpp>
 #include <iostream>
 
+#include "../with_or_without_fallback.hpp"
+
 class empty_struct{};
 BOOST_FUSION_ADAPT_STRUCT(empty_struct,)
 
diff --git a/test/sequence/adapt_struct_named.cpp b/test/sequence/adapt_struct_named.cpp
index ec5cf7bac..701944e20 100644
--- a/test/sequence/adapt_struct_named.cpp
+++ b/test/sequence/adapt_struct_named.cpp
@@ -31,6 +31,8 @@
 #include <iostream>
 #include <string>
 
+#include "../with_or_without_fallback.hpp"
+
 namespace ns
 {
     struct point
diff --git a/test/sequence/adapt_struct_named_empty.cpp b/test/sequence/adapt_struct_named_empty.cpp
index 7272f6f61..ae08d4022 100644
--- a/test/sequence/adapt_struct_named_empty.cpp
+++ b/test/sequence/adapt_struct_named_empty.cpp
@@ -27,6 +27,8 @@
 #include <boost/mpl/assert.hpp>
 #include <iostream>
 
+#include "../with_or_without_fallback.hpp"
+
 class empty_struct{};
 BOOST_FUSION_ADAPT_STRUCT_NAMED(::empty_struct,empty_struct,)
 
diff --git a/test/sequence/adapt_tpl_adt.cpp b/test/sequence/adapt_tpl_adt.cpp
index d917134a7..774cb3b53 100644
--- a/test/sequence/adapt_tpl_adt.cpp
+++ b/test/sequence/adapt_tpl_adt.cpp
@@ -32,6 +32,8 @@
 #include <iostream>
 #include <string>
 
+#include "../with_or_without_fallback.hpp"
+
 namespace ns
 {
     template<typename X, typename Y>
diff --git a/test/sequence/adapt_tpl_adt_empty.cpp b/test/sequence/adapt_tpl_adt_empty.cpp
index 82bf21214..f6c3c2bb7 100644
--- a/test/sequence/adapt_tpl_adt_empty.cpp
+++ b/test/sequence/adapt_tpl_adt_empty.cpp
@@ -27,6 +27,8 @@
 #include <boost/mpl/assert.hpp>
 #include <iostream>
 
+#include "../with_or_without_fallback.hpp"
+
 template <typename T>
 class empty_adt{};
 BOOST_FUSION_ADAPT_TPL_ADT((T), (empty_adt)(T),)
diff --git a/test/sequence/adapt_tpl_struct.cpp b/test/sequence/adapt_tpl_struct.cpp
index 1776cd62a..f3c75530a 100644
--- a/test/sequence/adapt_tpl_struct.cpp
+++ b/test/sequence/adapt_tpl_struct.cpp
@@ -28,6 +28,8 @@
 #include <iostream>
 #include <string>
 
+#include "../with_or_without_fallback.hpp"
+
 namespace ns
 {
     template<typename X, typename Y>
diff --git a/test/sequence/adapt_tpl_struct_empty.cpp b/test/sequence/adapt_tpl_struct_empty.cpp
index 5cb1d442e..72164bc1d 100644
--- a/test/sequence/adapt_tpl_struct_empty.cpp
+++ b/test/sequence/adapt_tpl_struct_empty.cpp
@@ -27,6 +27,8 @@
 #include <boost/mpl/assert.hpp>
 #include <iostream>
 
+#include "../with_or_without_fallback.hpp"
+
 template <typename T>
 class empty_struct{};
 BOOST_FUSION_ADAPT_TPL_STRUCT((T), (empty_struct)(T),)
diff --git a/test/sequence/adt_attribute_proxy.cpp b/test/sequence/adt_attribute_proxy.cpp
index eae4eb9a8..08d6c57f1 100644
--- a/test/sequence/adt_attribute_proxy.cpp
+++ b/test/sequence/adt_attribute_proxy.cpp
@@ -13,6 +13,8 @@
 #include <iostream>
 #include <string>
 
+#include "../with_or_without_fallback.hpp"
+
 namespace fusion=boost::fusion;
 
 template<typename Name, typename Age>
diff --git a/test/sequence/array.cpp b/test/sequence/array.cpp
index ca4a40ac9..43cc1f4bb 100644
--- a/test/sequence/array.cpp
+++ b/test/sequence/array.cpp
@@ -15,6 +15,8 @@
 
 #include <boost/mpl/assert.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 int main()
 {
     using namespace boost::fusion;
diff --git a/test/sequence/as_deque.cpp b/test/sequence/as_deque.cpp
index c56c598dd..8863e09dc 100644
--- a/test/sequence/as_deque.cpp
+++ b/test/sequence/as_deque.cpp
@@ -16,6 +16,7 @@
 
 #include <string>
 
+#include "../with_or_without_fallback.hpp"
 
 int main() {
     using namespace boost::fusion;
diff --git a/test/sequence/as_list.cpp b/test/sequence/as_list.cpp
index 8ee8bf128..b77c45fbf 100644
--- a/test/sequence/as_list.cpp
+++ b/test/sequence/as_list.cpp
@@ -15,6 +15,8 @@
 #include <boost/fusion/sequence/io/out.hpp>
 #include <boost/mpl/vector_c.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 int
 main()
 {
diff --git a/test/sequence/as_map.cpp b/test/sequence/as_map.cpp
index d2a89cc6c..4df860042 100644
--- a/test/sequence/as_map.cpp
+++ b/test/sequence/as_map.cpp
@@ -17,6 +17,8 @@
 #include <boost/fusion/sequence/io/out.hpp>
 #include <boost/fusion/support/pair.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 int
 main()
 {
@@ -29,7 +31,8 @@ main()
 
     {
         vector0<> empty;
-        std::cout << as_map(make_list(make_pair<int>('X'), make_pair<double>("Men"))) << std::endl;
+        // Conversion for std::string need to prevent 'error: ambiguous overload for ‘operator<<’ (operand types are ‘std::ostream’ {aka ‘std::basic_ostream<char>’} and ‘const char [4]’)'
+        std::cout << as_map(make_list(make_pair<int>('X'), make_pair<double>(std::string("Men")))) << std::endl;
         std::cout << as_map(push_back(empty, make_pair<int>(999))) << std::endl;
     }
 
diff --git a/test/sequence/as_map_assoc.cpp b/test/sequence/as_map_assoc.cpp
index bc9a6951c..a9ecc3418 100644
--- a/test/sequence/as_map_assoc.cpp
+++ b/test/sequence/as_map_assoc.cpp
@@ -17,6 +17,8 @@
 #include <boost/fusion/sequence/io/out.hpp>
 #include <boost/fusion/support/pair.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 namespace ns
 {
     struct x_member;
diff --git a/test/sequence/as_set.cpp b/test/sequence/as_set.cpp
index 97dd89e87..7d61697cf 100644
--- a/test/sequence/as_set.cpp
+++ b/test/sequence/as_set.cpp
@@ -18,6 +18,8 @@
 #include <boost/fusion/sequence/io/out.hpp>
 #include <boost/mpl/vector_c.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 int
 main()
 {
diff --git a/test/sequence/as_vector.cpp b/test/sequence/as_vector.cpp
index af1aaffb8..8485a1c3b 100644
--- a/test/sequence/as_vector.cpp
+++ b/test/sequence/as_vector.cpp
@@ -16,6 +16,8 @@
 #include <boost/mpl/vector_c.hpp>
 #include <string>
 
+#include "../with_or_without_fallback.hpp"
+
 int
 main()
 {
diff --git a/test/sequence/back_extended_deque.cpp b/test/sequence/back_extended_deque.cpp
index 368ec0c26..5da832635 100644
--- a/test/sequence/back_extended_deque.cpp
+++ b/test/sequence/back_extended_deque.cpp
@@ -20,6 +20,8 @@
 #include <boost/mpl/assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 int main()
 {
     using namespace boost::fusion;
diff --git a/test/sequence/boost_array.cpp b/test/sequence/boost_array.cpp
index f3f714700..0552ee05d 100644
--- a/test/sequence/boost_array.cpp
+++ b/test/sequence/boost_array.cpp
@@ -19,6 +19,8 @@
 
 #include <boost/mpl/assert.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 int main()
 {
     using namespace boost::fusion;
diff --git a/test/sequence/boost_pfr.cpp b/test/sequence/boost_pfr.cpp
new file mode 100644
index 000000000..afaed9c26
--- /dev/null
+++ b/test/sequence/boost_pfr.cpp
@@ -0,0 +1,203 @@
+/*=============================================================================
+    Copyright (c) 2021-2023 Denis Mikhailov
+    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_pfr.hpp"
+
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/sequence/intrinsic/at.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/fusion/sequence/intrinsic/empty.hpp>
+#include <boost/fusion/sequence/intrinsic/front.hpp>
+#include <boost/fusion/sequence/intrinsic/back.hpp>
+#include <boost/fusion/support/is_view.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+#include <boost/fusion/sequence/comparison/equal_to.hpp>
+#include <boost/fusion/sequence/comparison/not_equal_to.hpp>
+#include <boost/fusion/sequence/comparison/less.hpp>
+#include <boost/fusion/sequence/comparison/less_equal.hpp>
+#include <boost/fusion/sequence/comparison/greater.hpp>
+#include <boost/fusion/sequence/comparison/greater_equal.hpp>
+#include <boost/fusion/container/vector/vector.hpp>
+#include <boost/fusion/container/list/list.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/mpl.hpp>
+#include <boost/mpl/front.hpp>
+#include <boost/mpl/is_sequence.hpp>
+#include <boost/mpl/assert.hpp>
+#include <iostream>
+#include <string>
+
+namespace namespaced_type {
+    using integer = int;
+}
+
+namespace ns {
+    struct point {
+        int x;
+        int y;
+        namespaced_type::integer z;
+    };
+
+    struct guaranteed_nonconstexpr_string {
+        std::string value;
+        explicit guaranteed_nonconstexpr_string(std::string value) : value(std::move(value)) {
+            std::cout << "mark to ensure nonconstexpr" << std::endl;
+        }
+    };
+
+    inline bool operator== (const guaranteed_nonconstexpr_string& rhs, const guaranteed_nonconstexpr_string& lhs) {
+        return (rhs.value == lhs.value);
+    }
+
+    // Testing non-constexpr compatible types
+#if BOOST_PFR_USE_CPP17 != 0
+    struct employee {
+        guaranteed_nonconstexpr_string name;
+        guaranteed_nonconstexpr_string nickname;
+    };
+#endif // BOOST_PFR_USE_CPP17
+}
+
+struct s { int m; };
+
+int
+main()
+{
+    using boost::fusion::tuple_open;
+    using boost::fusion::tuple_close;
+    using boost::fusion::tuple_delimiter;
+    using boost::fusion::at_c;
+    using boost::fusion::make_vector;
+    using boost::fusion::front;
+    using boost::fusion::back;
+    using boost::fusion::vector;
+    using boost::fusion::list;
+    namespace traits = boost::fusion::traits;
+    namespace fusion = boost::fusion;
+    using ns::point;
+
+    // FIXME make this workable even with forced implicit reflection
+    // std::cout << tuple_open('[');
+    // std::cout << tuple_close(']');
+    // std::cout << tuple_delimiter(", ");
+
+    {
+        static_assert(!traits::is_view< point >::value, "");
+        point p = {123, 456, 789};
+
+        std::cout << at_c<0>(p) << std::endl;
+        std::cout << at_c<1>(p) << std::endl;
+        std::cout << at_c<2>(p) << std::endl;
+        boost::fusion::out(std::cout, p) << std::endl;
+        BOOST_TEST(p == make_vector(123, 456, 789));
+
+        at_c<0>(p) = 6;
+        at_c<1>(p) = 9;
+        at_c<2>(p) = 12;
+
+        BOOST_TEST(p == make_vector(6, 9, 12));
+
+        static_assert(boost::fusion::result_of::size<point>::value == 3, "");
+        static_assert(!boost::fusion::result_of::empty<point>::value, "");
+        static_assert(std::is_same<
+            boost::fusion::traits::tag_of<point>::type
+          , boost::fusion::boost_pfr_tag>::value, "");
+        static_assert(!boost::fusion::result_of::equal_to<boost::fusion::result_of::begin<point>::type,
+                                                          boost::fusion::result_of::end<point>::type>::value, "");
+
+        BOOST_TEST(front(p) == 6);
+        BOOST_TEST(back(p) == 12);
+    }
+
+    {
+        vector<int, float, int> v1(4, 2.f, 2);
+        point v2 = {5, 3, 3};
+        vector<long, double, int> v3(5, 4., 4);
+        BOOST_TEST(v1 < v2);
+        BOOST_TEST(v1 <= v2);
+        BOOST_TEST(v2 > v1);
+        BOOST_TEST(v2 >= v1);
+        BOOST_TEST(v2 < v3);
+        BOOST_TEST(v2 <= v3);
+        BOOST_TEST(v3 > v2);
+        BOOST_TEST(v3 >= v2);
+    }
+
+    {
+        // conversion from point to vector
+        point p = {5, 3, 3};
+        vector<int, long, int> v(p);
+        v = p;
+    }
+
+    {
+        // conversion from point to list
+        point p = {5, 3, 3};
+        list<int, long, int> l(p);
+        l = p;
+    }
+
+    { // begin/end
+        using namespace boost::fusion;
+        using boost::is_same;
+
+        using b = boost::fusion::result_of::begin<s>::type;
+        using e = boost::fusion::result_of::end<s>::type;
+        // this fails
+        static_assert(is_same<boost::fusion::result_of::next<b>::type, e>::value, "");
+    }
+
+    {
+        // FIXME
+        // mpl binding, it's possible after resolving https://github.com/boostorg/mpl/issues/71
+        //static_assert(boost::mpl::is_sequence<ns::point>::value, "");
+        //static_assert(boost::is_same<
+        //                  boost::fusion::result_of::value_at_c<ns::point,0>::type
+        //        , boost::mpl::front<ns::point>::type>::value, "");
+    }
+
+#if BOOST_PFR_USE_CPP17 != 0
+    {
+        ns::employee emp{ns::guaranteed_nonconstexpr_string("John Doe"),
+		                     ns::guaranteed_nonconstexpr_string("jdoe")};
+        std::cout << at_c<0>(emp).value << std::endl;
+        std::cout << at_c<1>(emp).value << std::endl;
+
+        fusion::vector<ns::guaranteed_nonconstexpr_string, ns::guaranteed_nonconstexpr_string> v1(
+            ns::guaranteed_nonconstexpr_string("John Doe"), ns::guaranteed_nonconstexpr_string("jdoe"));
+        BOOST_TEST(emp == v1);
+    }
+#endif // BOOST_PFR_USE_CPP17
+
+    {
+        int a[3] = {100, 200, 300};
+        static_assert(!std::is_same<
+            boost::fusion::traits::tag_of<decltype(a)>::type
+          , boost::fusion::boost_pfr_tag>::value, "");
+    }
+
+    {
+        using seq = ns::point;
+        using c_vec = const ns::point;
+        using first = boost::fusion::result_of::begin<seq>::type;
+        using c_first = boost::fusion::result_of::begin<c_vec>::type;
+
+        static_assert(boost::is_same<boost::fusion::result_of::value_of<first>::type, int>::value, "");
+        static_assert(boost::is_same<boost::fusion::result_of::value_of<c_first>::type, int>::value, "");
+    }
+
+    {
+        using seq = ns::point;
+        using c_vec = const ns::point;
+
+        BOOST_MPL_ASSERT((boost::is_same<boost::fusion::result_of::value_at<seq, boost::mpl::int_<0> >::type, int>));
+        BOOST_MPL_ASSERT((boost::is_same<boost::fusion::result_of::value_at<c_vec, boost::mpl::int_<0> >::type, int>));
+    }
+
+    return boost::report_errors();
+} 
+
+
diff --git a/test/sequence/boost_pfr.hpp b/test/sequence/boost_pfr.hpp
new file mode 100644
index 000000000..6fa965457
--- /dev/null
+++ b/test/sequence/boost_pfr.hpp
@@ -0,0 +1,27 @@
+/*=============================================================================
+    Copyright (c) 2023 Denis Mikhailov
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+
+// This header provides ability for testing Boost PFR integration(both implicit and explicit) in different ways to include it.
+
+#if BOOST_FUSION_USE_PFR_EXPLICIT_0
+#include <boost/fusion/adapted/boost_pfr_explicit.hpp>
+#elif BOOST_FUSION_USE_PFR_EXPLICIT_1
+#include <boost/fusion/include/boost_pfr_explicit.hpp>
+#elif BOOST_FUSION_USE_PFR_EXPLICIT_2
+#define BOOST_FUSION_PFR_ENABLE_IMPLICIT_REFLECTION 0
+#include <boost/fusion/adapted.hpp>
+
+#elif BOOST_FUSION_USE_PFR_IMPLICIT_0
+#include <boost/fusion/adapted/boost_pfr.hpp>
+#elif BOOST_FUSION_USE_PFR_IMPLICIT_1
+#include <boost/fusion/include/boost_pfr.hpp>
+#elif BOOST_FUSION_USE_PFR_IMPLICIT_2
+#include <boost/fusion/adapted.hpp>
+
+#else
+#error You have to specify the way you need to include Boost PFR integration.
+#endif
+
diff --git a/test/sequence/boost_pfr_convert.cpp b/test/sequence/boost_pfr_convert.cpp
new file mode 100644
index 000000000..6771bf088
--- /dev/null
+++ b/test/sequence/boost_pfr_convert.cpp
@@ -0,0 +1,66 @@
+/*=============================================================================
+    Copyright (c) 2021-2023 Denis Mikhailov
+    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_pfr.hpp"
+
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/sequence/intrinsic/at.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/fusion/sequence/intrinsic/empty.hpp>
+#include <boost/fusion/sequence/intrinsic/front.hpp>
+#include <boost/fusion/sequence/intrinsic/back.hpp>
+#include <boost/fusion/support/is_view.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+#include <boost/fusion/sequence/comparison/equal_to.hpp>
+#include <boost/fusion/sequence/comparison/not_equal_to.hpp>
+#include <boost/fusion/sequence/comparison/less.hpp>
+#include <boost/fusion/sequence/comparison/less_equal.hpp>
+#include <boost/fusion/sequence/comparison/greater.hpp>
+#include <boost/fusion/sequence/comparison/greater_equal.hpp>
+#include <boost/fusion/container/vector/vector.hpp>
+#include <boost/fusion/container/list/list.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/include/convert.hpp>
+#include <boost/fusion/mpl.hpp>
+#include <boost/mpl/front.hpp>
+#include <boost/mpl/is_sequence.hpp>
+#include <boost/mpl/assert.hpp>
+#include <iostream>
+#include <string>
+#include <cstring>
+
+#include <boost/fusion/include/vector.hpp>
+#include <boost/fusion/include/deque.hpp>
+#include <boost/fusion/include/list.hpp>
+#include <boost/fusion/include/boost_tuple.hpp>
+#include <boost/fusion/include/std_tuple.hpp>
+
+struct SimpleAggregate {
+    int first;
+    const char* second;
+};
+
+template <typename Tag, typename Seq>
+void test(Seq const& seq)
+{
+    const auto v = boost::fusion::convert<Tag>(seq);
+    BOOST_TEST((boost::fusion::at_c<0>(v) == 123));
+    BOOST_TEST((std::strcmp(boost::fusion::at_c<1>(v), "Hola!!!") == 0));
+}
+
+int
+main()
+{
+    SimpleAggregate seq{123, "Hola!!!"};
+    test<boost::fusion::vector_tag>(seq);
+    test<boost::fusion::deque_tag>(seq);
+    test<boost::fusion::cons_tag>(seq);
+    test<boost::fusion::boost_tuple_tag>(seq);
+    test<boost::fusion::std_tuple_tag>(seq);
+    return boost::report_errors();
+} 
+
+
diff --git a/test/sequence/boost_pfr_empty.cpp b/test/sequence/boost_pfr_empty.cpp
new file mode 100644
index 000000000..55173417d
--- /dev/null
+++ b/test/sequence/boost_pfr_empty.cpp
@@ -0,0 +1,104 @@
+/*=============================================================================
+    Copyright (c) 2021-2023 Denis Mikhailov
+    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_pfr.hpp"
+
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/fusion/sequence/intrinsic/empty.hpp>
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+#include <boost/fusion/iterator/equal_to.hpp>
+#include <boost/fusion/container/vector/vector.hpp>
+#include <boost/fusion/container/list/list.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/sequence/comparison/equal_to.hpp>
+#include <boost/fusion/sequence/comparison/not_equal_to.hpp>
+#include <boost/fusion/sequence/comparison/less.hpp>
+#include <boost/fusion/sequence/comparison/less_equal.hpp>
+#include <boost/fusion/sequence/comparison/greater.hpp>
+#include <boost/fusion/sequence/comparison/greater_equal.hpp>
+#include <boost/fusion/algorithm/iteration/for_each.hpp>
+#include <boost/fusion/mpl.hpp>
+#include <boost/fusion/support/is_view.hpp>
+#include <boost/mpl/is_sequence.hpp>
+#include <boost/mpl/assert.hpp>
+#include <iostream>
+
+struct empty_struct {};
+
+int
+main()
+{
+    using boost::fusion::tuple_open;
+    using boost::fusion::tuple_close;
+    using boost::fusion::tuple_delimiter;
+    using boost::fusion::make_vector;
+    using boost::fusion::vector;
+    using boost::fusion::list;
+    namespace traits = boost::fusion::traits;
+    namespace fusion = boost::fusion;
+
+    // FIXME make this workable even with forced implicit reflection
+    // std::cout << tuple_open('[');
+    // std::cout << tuple_close(']');
+    // std::cout << tuple_delimiter(", ");
+
+    {
+        BOOST_MPL_ASSERT_NOT((traits::is_view<empty_struct>));
+        BOOST_STATIC_ASSERT(!traits::is_view<empty_struct>::value);
+        empty_struct e;
+
+        boost::fusion::out(std::cout, e) << std::endl;
+        BOOST_TEST(e == make_vector());
+
+        BOOST_STATIC_ASSERT(fusion::result_of::size<empty_struct>::value == 0);
+        BOOST_MPL_ASSERT((fusion::result_of::empty<empty_struct>));
+
+        BOOST_MPL_ASSERT((fusion::result_of::equal_to<
+                          fusion::result_of::begin<empty_struct>::type,
+                fusion::result_of::end<empty_struct>::type>));
+    }
+
+    {
+        int counter = 0;
+        empty_struct empty;
+        boost::fusion::for_each(empty, [&](){counter+=1;});
+        BOOST_TEST(counter == 0);
+    }
+
+    {
+        fusion::vector<> v;
+        empty_struct e;
+        BOOST_TEST(v == e);
+        BOOST_TEST_NOT(e != v);
+        BOOST_TEST_NOT(v < e);
+        BOOST_TEST(v <= e);
+        BOOST_TEST_NOT(e > v);
+        BOOST_TEST(e >= v);
+    }
+
+    {
+        empty_struct e;
+
+        // conversion from empty_struct to vector
+        fusion::vector<> v(e);
+        v = e;
+
+        // FIXME
+        // conversion from empty_struct to list
+        //fusion::list<> l(e);
+        //l = e;
+    }
+
+    // FIXME
+    // mpl binding, it's possible after resolving https://github.com/boostorg/mpl/issues/71
+    // BOOST_MPL_ASSERT((mpl::is_sequence<empty_struct>));
+
+    return boost::report_errors();
+}
+
diff --git a/test/sequence/boost_pfr_explicit.cpp b/test/sequence/boost_pfr_explicit.cpp
new file mode 100644
index 000000000..7b370a497
--- /dev/null
+++ b/test/sequence/boost_pfr_explicit.cpp
@@ -0,0 +1,99 @@
+/*=============================================================================
+    Copyright (c) 2021-2023 Denis Mikhailov
+    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_pfr.hpp"
+
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/sequence/intrinsic/at.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/fusion/sequence/intrinsic/empty.hpp>
+#include <boost/fusion/sequence/intrinsic/front.hpp>
+#include <boost/fusion/sequence/intrinsic/back.hpp>
+#include <boost/fusion/support/is_view.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+#include <boost/fusion/sequence/comparison/equal_to.hpp>
+#include <boost/fusion/sequence/comparison/not_equal_to.hpp>
+#include <boost/fusion/sequence/comparison/less.hpp>
+#include <boost/fusion/sequence/comparison/less_equal.hpp>
+#include <boost/fusion/sequence/comparison/greater.hpp>
+#include <boost/fusion/sequence/comparison/greater_equal.hpp>
+#include <boost/fusion/container/vector/vector.hpp>
+#include <boost/fusion/container/list/list.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/mpl.hpp>
+#include <boost/mpl/front.hpp>
+#include <boost/mpl/is_sequence.hpp>
+#include <boost/mpl/assert.hpp>
+#include <iostream>
+#include <string>
+
+struct just_point {
+    int x;
+    int y;
+    int z;
+};
+
+struct point_declared_as_reflectable {
+    int x;
+    int y;
+    int z;
+};
+BOOST_FUSION_FORCE_PFR_REFLECTABLE(point_declared_as_reflectable)
+
+// Make sure tag_of can be used with an incomplete type, and explicit adapter for Boost PFR won't broke this
+struct incomplete;
+typedef boost::fusion::traits::tag_of<incomplete>::type Tag;
+BOOST_STATIC_ASSERT((boost::is_same<Tag, boost::fusion::non_fusion_tag>::value));
+
+int
+main()
+{
+    using namespace boost::fusion;
+    using namespace boost;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    {
+        static_assert(std::is_same<
+            boost::fusion::traits::tag_of<just_point>::type
+          , boost::fusion::non_fusion_tag>::value, "");
+    }
+
+    {
+        using point = point_declared_as_reflectable;
+        static_assert(!traits::is_view< point >::value, "");
+        point p = {123, 456, 789};
+
+        std::cout << at_c<0>(p) << std::endl;
+        std::cout << at_c<1>(p) << std::endl;
+        std::cout << at_c<2>(p) << std::endl;
+        std::cout << p << std::endl;
+        BOOST_TEST(p == make_vector(123, 456, 789));
+
+        at_c<0>(p) = 6;
+        at_c<1>(p) = 9;
+        at_c<2>(p) = 12;
+
+        BOOST_TEST(p == make_vector(6, 9, 12));
+
+        static_assert(boost::fusion::result_of::size<point>::value == 3, "");
+        static_assert(!boost::fusion::result_of::empty<point>::value, "");
+        static_assert(std::is_same<
+            boost::fusion::traits::tag_of<point>::type
+          , boost::fusion::boost_pfr_tag>::value, "");
+        static_assert(!boost::fusion::result_of::equal_to<boost::fusion::result_of::begin<point>::type,
+                                                          boost::fusion::result_of::end<point>::type>::value, "");
+
+        BOOST_TEST(front(p) == 6);
+        BOOST_TEST(back(p) == 12);
+    }
+
+    return boost::report_errors();
+} 
+
+
diff --git a/test/sequence/boost_pfr_force_macro.cpp b/test/sequence/boost_pfr_force_macro.cpp
new file mode 100644
index 000000000..e83bc9b08
--- /dev/null
+++ b/test/sequence/boost_pfr_force_macro.cpp
@@ -0,0 +1,42 @@
+/*=============================================================================
+    Copyright (c) 2021-2023 Denis Mikhailov
+    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_pfr.hpp"
+
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/support/tag_of.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+#define BOOST_FUSION_USE_PFR_ONLY_FORCE_0 1
+#include "boost_pfr_force_macro.hpp"
+
+int
+main()
+{
+    {
+        using Tag = boost::fusion::traits::tag_of<not_a_sequence>::type;
+        using Tag2 = boost::fusion::traits::tag_of<reflectable>::type;
+        using Tag3 = boost::fusion::traits::tag_of<not_a_sequence_tpl<int>>::type;
+        using Tag4 = boost::fusion::traits::tag_of<reflectable_tpl<int>>::type;
+        BOOST_STATIC_ASSERT((boost::is_same<Tag, boost::fusion::non_fusion_tag>::value));
+        BOOST_STATIC_ASSERT((!boost::is_same<Tag2, boost::fusion::non_fusion_tag>::value));
+        BOOST_STATIC_ASSERT((boost::is_same<Tag3, boost::fusion::non_fusion_tag>::value));
+        BOOST_STATIC_ASSERT((!boost::is_same<Tag4, boost::fusion::non_fusion_tag>::value));
+    }
+    {
+        using Tag = boost::fusion::traits::tag_of<const not_a_sequence>::type;
+        using Tag2 = boost::fusion::traits::tag_of<const reflectable>::type;
+        using Tag3 = boost::fusion::traits::tag_of<const not_a_sequence_tpl<int>>::type;
+        using Tag4 = boost::fusion::traits::tag_of<const reflectable_tpl<int>>::type;
+        BOOST_STATIC_ASSERT((boost::is_same<Tag, boost::fusion::non_fusion_tag>::value));
+        BOOST_STATIC_ASSERT((!boost::is_same<Tag2, boost::fusion::non_fusion_tag>::value));
+        BOOST_STATIC_ASSERT((boost::is_same<Tag3, boost::fusion::non_fusion_tag>::value));
+        BOOST_STATIC_ASSERT((!boost::is_same<Tag4, boost::fusion::non_fusion_tag>::value));
+    }
+    return boost::report_errors();
+} 
+
+
diff --git a/test/sequence/boost_pfr_force_macro.hpp b/test/sequence/boost_pfr_force_macro.hpp
new file mode 100644
index 000000000..3ea98a2bb
--- /dev/null
+++ b/test/sequence/boost_pfr_force_macro.hpp
@@ -0,0 +1,33 @@
+/*=============================================================================
+    Copyright (c) 2023 Denis Mikhailov
+    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 BOOST_FUSION_USE_PFR_ONLY_FORCE_0
+#include <boost/fusion/adapted/boost_pfr/force.hpp>
+#elif BOOST_FUSION_USE_PFR_ONLY_FORCE_1
+#include <boost/fusion/include/boost_pfr_force.hpp>
+#else
+#error You have to specify the way you need to include force macroes.
+#endif
+
+struct not_a_sequence {};
+BOOST_FUSION_FORCE_PFR_NONREFLECTABLE(not_a_sequence)
+
+struct reflectable {
+    explicit reflectable(int first, int second) {}
+};
+BOOST_FUSION_FORCE_PFR_REFLECTABLE(reflectable)
+
+template<typename T>
+struct not_a_sequence_tpl {};
+BOOST_FUSION_FORCE_PFR_NONREFLECTABLE_TPL(not_a_sequence_tpl)
+
+template<typename T>
+struct reflectable_tpl {
+    explicit reflectable_tpl(int first, int second) {}
+};
+BOOST_FUSION_FORCE_PFR_REFLECTABLE_TPL(reflectable_tpl)
+
+
diff --git a/test/sequence/boost_pfr_force_macro_only.cpp b/test/sequence/boost_pfr_force_macro_only.cpp
new file mode 100644
index 000000000..c2835c9d4
--- /dev/null
+++ b/test/sequence/boost_pfr_force_macro_only.cpp
@@ -0,0 +1,39 @@
+/*=============================================================================
+    Copyright (c) 2023 Denis Mikhailov
+    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/fusion/support/tag_of.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+#include "boost_pfr_force_macro.hpp"
+
+int
+main()
+{
+    {
+        typedef boost::fusion::traits::tag_of<not_a_sequence>::type Tag;
+        typedef boost::fusion::traits::tag_of<reflectable>::type Tag2;
+        typedef boost::fusion::traits::tag_of<not_a_sequence_tpl<int> >::type Tag3;
+        typedef boost::fusion::traits::tag_of<reflectable_tpl<int> >::type Tag4;
+        BOOST_STATIC_ASSERT((boost::is_same<Tag, boost::fusion::non_fusion_tag>::value));
+        BOOST_STATIC_ASSERT((boost::is_same<Tag2, boost::fusion::non_fusion_tag>::value));
+        BOOST_STATIC_ASSERT((boost::is_same<Tag3, boost::fusion::non_fusion_tag>::value));
+        BOOST_STATIC_ASSERT((boost::is_same<Tag4, boost::fusion::non_fusion_tag>::value));
+    }
+    {
+        typedef boost::fusion::traits::tag_of<const not_a_sequence>::type Tag;
+        typedef boost::fusion::traits::tag_of<const reflectable>::type Tag2;
+        typedef boost::fusion::traits::tag_of<const not_a_sequence_tpl<int> >::type Tag3;
+        typedef boost::fusion::traits::tag_of<const reflectable_tpl<int> >::type Tag4;
+        BOOST_STATIC_ASSERT((boost::is_same<Tag, boost::fusion::non_fusion_tag>::value));
+        BOOST_STATIC_ASSERT((boost::is_same<Tag2, boost::fusion::non_fusion_tag>::value));
+        BOOST_STATIC_ASSERT((boost::is_same<Tag3, boost::fusion::non_fusion_tag>::value));
+        BOOST_STATIC_ASSERT((boost::is_same<Tag4, boost::fusion::non_fusion_tag>::value));
+    }
+    return boost::report_errors();
+} 
+
+
diff --git a/test/sequence/boost_pfr_iterator.cpp b/test/sequence/boost_pfr_iterator.cpp
new file mode 100644
index 000000000..0d8010599
--- /dev/null
+++ b/test/sequence/boost_pfr_iterator.cpp
@@ -0,0 +1,136 @@
+/*=============================================================================
+    Copyright (c) 2021-2023 Denis Mikhailov
+    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_pfr.hpp"
+
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/sequence/intrinsic/at.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/fusion/sequence/intrinsic/empty.hpp>
+#include <boost/fusion/sequence/intrinsic/front.hpp>
+#include <boost/fusion/sequence/intrinsic/back.hpp>
+#include <boost/fusion/support/is_view.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+#include <boost/fusion/sequence/comparison/equal_to.hpp>
+#include <boost/fusion/sequence/comparison/not_equal_to.hpp>
+#include <boost/fusion/sequence/comparison/less.hpp>
+#include <boost/fusion/sequence/comparison/less_equal.hpp>
+#include <boost/fusion/sequence/comparison/greater.hpp>
+#include <boost/fusion/sequence/comparison/greater_equal.hpp>
+#include <boost/fusion/container/vector/vector.hpp>
+#include <boost/fusion/container/list/list.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/mpl.hpp>
+#include <boost/mpl/front.hpp>
+#include <boost/mpl/is_sequence.hpp>
+#include <boost/mpl/assert.hpp>
+#include <iostream>
+#include <string>
+
+struct A
+{
+    int first;
+    int second;
+    int third;
+};
+BOOST_FUSION_FORCE_PFR_REFLECTABLE(A)
+
+template<typename T1, typename T2, typename T3>
+struct is_same_thernary 
+    : std::integral_constant<bool, (std::is_same<T1, T2>::value && std::is_same<T2, T3>::value)>
+{
+};
+
+int
+main()
+{
+    {
+        A a{100, 200, 300};
+
+        using namespace boost::fusion;
+
+        static_assert(is_same_thernary<
+            boost::fusion::result_of::prior< boost::fusion::result_of::end<decltype(a)>::type >::type
+            , std::remove_const_t<decltype(prior(end(a)))>
+            , boost_pfr_iterator<A, 2>
+            >::value, "");
+
+        BOOST_TEST(*prior(end(a)) == 300);
+        BOOST_TEST(*next(begin(a)) == 200);
+        BOOST_TEST(distance(begin(a), end(a)) == 3);
+        BOOST_TEST(advance< boost::mpl::int_<3> >(begin(a)) == end(a));
+    }
+
+    {
+        A a;  // it must be instead of std::declval
+        const A ca{800, 600, 500};
+
+        using namespace boost::fusion;
+
+        static_assert(is_same_thernary<
+            boost::fusion::result_of::deref<decltype(begin(a))>::type
+            , decltype(deref(begin(a)))
+            , int&
+        >::value, "");
+        static_assert(is_same_thernary<
+            boost::fusion::result_of::deref<decltype(begin(ca))>::type
+            , decltype(deref(begin(ca)))
+            , const int&
+        >::value, "");
+
+        static_assert(is_same_thernary<
+            boost::fusion::result_of::deref<decltype( advance<boost::mpl::int_<-1>>(end(a)) )>::type
+            , decltype(deref(advance<boost::mpl::int_<-1>>(end(a))))
+            , int&
+        >::value, "");
+        static_assert(is_same_thernary<
+            boost::fusion::result_of::deref<decltype( advance<boost::mpl::int_<-1>>(end(ca)) )>::type
+            , decltype(deref(advance<boost::mpl::int_<-1>>(end(ca))))
+            , const int&
+        >::value, "");
+    }
+
+    {
+        A a;  // it must be instead of std::declval
+        const A ca{800, 600, 500};
+
+        using namespace boost::fusion;
+
+        static_assert(is_same_thernary<
+            boost::fusion::result_of::at_c<decltype(a), 0>::type
+            , decltype(at_c<0>(a))
+            , int&
+        >::value, "");
+        static_assert(is_same_thernary<
+            boost::fusion::result_of::at_c<decltype(ca), 0>::type
+            , decltype(at_c<0>(ca))
+            , const int&
+        >::value, "");
+    }
+
+    {
+        A a{100, 200, 300};
+        const A ca{800, 600, 500};
+
+        using namespace boost::fusion;
+
+        static_assert(is_same_thernary<
+            boost::fusion::result_of::value_of< boost::fusion::result_of::begin<decltype(a)>::type >::type
+            , boost::fusion::result_of::value_at< decltype(a), boost::mpl::int_<0> >::type
+            , int
+        >::value, "");
+
+        static_assert(is_same_thernary<
+            boost::fusion::result_of::value_of< boost::fusion::result_of::begin<decltype(ca)>::type >::type
+            , boost::fusion::result_of::value_at< decltype(ca), boost::mpl::int_<0> >::type
+            , int
+        >::value, "");
+    }
+
+    return boost::report_errors();
+} 
+
+
diff --git a/test/sequence/boost_pfr_reference.cpp b/test/sequence/boost_pfr_reference.cpp
new file mode 100644
index 000000000..602e15aca
--- /dev/null
+++ b/test/sequence/boost_pfr_reference.cpp
@@ -0,0 +1,30 @@
+/*=============================================================================
+    Copyright (c) 2023 Denis Mikhailov
+    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/fusion/adapted/boost_pfr.hpp>
+#include <boost/fusion/adapted/boost_pfr/force.hpp>
+#include <boost/fusion/support/tag_of.hpp>
+#include <type_traits>
+
+struct my_structure {
+    int first;
+    int second;
+};
+
+int
+main()
+{
+    using Tag = boost::fusion::traits::tag_of<my_structure>::type;
+    using Tag2 = boost::fusion::traits::tag_of<my_structure& >::type;
+    using Tag3 = boost::fusion::traits::tag_of<const my_structure& >::type;
+    static_assert(!std::is_same<Tag, boost::fusion::non_fusion_tag>::value, "");
+    static_assert(std::is_same<Tag2, boost::fusion::non_fusion_tag>::value, "");
+    static_assert(std::is_same<Tag3, boost::fusion::non_fusion_tag>::value, "");
+    return boost::report_errors();
+} 
+
+
diff --git a/test/sequence/boost_tuple.cpp b/test/sequence/boost_tuple.cpp
index abe7d3c83..4126491c8 100644
--- a/test/sequence/boost_tuple.cpp
+++ b/test/sequence/boost_tuple.cpp
@@ -33,6 +33,8 @@
 #include <iostream>
 #include <string>
 
+#include "../with_or_without_fallback.hpp"
+
 int
 main()
 {
diff --git a/test/sequence/boost_tuple_iterator.cpp b/test/sequence/boost_tuple_iterator.cpp
index 3ab096b9b..115a8bdb4 100644
--- a/test/sequence/boost_tuple_iterator.cpp
+++ b/test/sequence/boost_tuple_iterator.cpp
@@ -7,6 +7,8 @@
 
 #include <boost/fusion/adapted/boost_tuple.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE boost::tuple
 #define FUSION_TRAVERSAL_TAG forward_traversal_tag
 #define FUSION_NO_PRIOR
diff --git a/test/sequence/comparison.hpp b/test/sequence/comparison.hpp
index 2c954d0a5..eb34278f0 100644
--- a/test/sequence/comparison.hpp
+++ b/test/sequence/comparison.hpp
@@ -7,8 +7,11 @@
 ==============================================================================*/
 #include <boost/detail/lightweight_test.hpp>
 #include <boost/fusion/sequence/comparison.hpp>
+#include <boost/fusion/include/boost_pfr_force.hpp>
 
 struct not_a_fusion_container {};
+BOOST_FUSION_FORCE_PFR_NONREFLECTABLE(not_a_fusion_container)
+
 template <typename T>
 inline bool operator==(not_a_fusion_container, T const&) { return true; }
 template <typename T>
diff --git a/test/sequence/cons.cpp b/test/sequence/cons.cpp
index 88a04101c..f1031bf0e 100644
--- a/test/sequence/cons.cpp
+++ b/test/sequence/cons.cpp
@@ -22,6 +22,8 @@
 #include <boost/type_traits/is_same.hpp>
 #include <boost/mpl/lambda.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 int
 main()
 {
diff --git a/test/sequence/convert.hpp b/test/sequence/convert.hpp
index 233fabfb3..b60578723 100644
--- a/test/sequence/convert.hpp
+++ b/test/sequence/convert.hpp
@@ -9,6 +9,8 @@
 #include <string>
 #include <boost/config.hpp>
 #include <boost/core/lightweight_test.hpp>
+
+#include <boost/fusion/support/config.hpp>
 #include <boost/fusion/include/convert.hpp>
 #include <boost/fusion/include/at.hpp>
 
@@ -20,6 +22,13 @@
 #include <boost/fusion/include/std_tuple.hpp>
 #endif
 
+#if BOOST_FUSION_PFR_ENABLED
+#if BOOST_FUSION_PFR_ENABLE_IMPLICIT_REFLECTION
+#include <boost/fusion/adapted/boost_pfr.hpp>
+#endif
+#include <boost/fusion/adapted/boost_pfr_explicit.hpp>
+#endif
+
 template <typename Tag>
 void test(FUSION_SEQUENCE<int, std::string> const& seq)
 {
@@ -45,7 +54,10 @@ int main()
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
     test<boost::fusion::std_tuple_tag>(seq);
 #endif
-
+#if BOOST_FUSION_PFR_ENABLED
+    // There is no 'convert' for Boost PFR, and it's impossible to implement
+    //test<boost::fusion::boost_pfr_tag>(seq);
+#endif
     return boost::report_errors();
 }
 
diff --git a/test/sequence/convert_boost_tuple.cpp b/test/sequence/convert_boost_tuple.cpp
index 588ee4d7f..170167c1d 100644
--- a/test/sequence/convert_boost_tuple.cpp
+++ b/test/sequence/convert_boost_tuple.cpp
@@ -9,6 +9,8 @@
 #include <boost/tuple/tuple.hpp>
 #include <boost/fusion/include/boost_tuple.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE boost::tuples::tuple
 #include "convert.hpp"
 
diff --git a/test/sequence/convert_deque.cpp b/test/sequence/convert_deque.cpp
index 5be34d3f6..0ba46abb9 100644
--- a/test/sequence/convert_deque.cpp
+++ b/test/sequence/convert_deque.cpp
@@ -8,6 +8,8 @@
 
 #include <boost/fusion/include/deque.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE boost::fusion::deque
 #include "convert.hpp"
 
diff --git a/test/sequence/convert_list.cpp b/test/sequence/convert_list.cpp
index 57ad05078..228fe8c4e 100644
--- a/test/sequence/convert_list.cpp
+++ b/test/sequence/convert_list.cpp
@@ -8,6 +8,8 @@
 
 #include <boost/fusion/include/list.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE boost::fusion::list
 #include "convert.hpp"
 
diff --git a/test/sequence/convert_std_pair.cpp b/test/sequence/convert_std_pair.cpp
index aa350025a..05688e607 100644
--- a/test/sequence/convert_std_pair.cpp
+++ b/test/sequence/convert_std_pair.cpp
@@ -9,6 +9,8 @@
 #include <utility>
 #include <boost/fusion/include/std_pair.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE std::pair
 #include "convert.hpp"
 
diff --git a/test/sequence/convert_std_tuple.cpp b/test/sequence/convert_std_tuple.cpp
index 643f01cfe..1b1cc8980 100644
--- a/test/sequence/convert_std_tuple.cpp
+++ b/test/sequence/convert_std_tuple.cpp
@@ -16,5 +16,8 @@
 #include <tuple>
 #include <boost/fusion/include/std_tuple.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE std::tuple
 #include "convert.hpp"
+
diff --git a/test/sequence/convert_vector.cpp b/test/sequence/convert_vector.cpp
index b39014df2..ec76b4dc3 100644
--- a/test/sequence/convert_vector.cpp
+++ b/test/sequence/convert_vector.cpp
@@ -8,6 +8,8 @@
 
 #include <boost/fusion/include/vector.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE boost::fusion::vector
 #include "convert.hpp"
 
diff --git a/test/sequence/deduce_sequence.cpp b/test/sequence/deduce_sequence.cpp
index 3bccc20a1..f8c9b7dbe 100644
--- a/test/sequence/deduce_sequence.cpp
+++ b/test/sequence/deduce_sequence.cpp
@@ -18,6 +18,8 @@
 #include <functional>
 #endif
 
+#include "../with_or_without_fallback.hpp"
+
 using boost::is_same;
 using boost::reference_wrapper;
 using boost::fusion::traits::deduce;
diff --git a/test/sequence/define_assoc_struct.cpp b/test/sequence/define_assoc_struct.cpp
index 231621f89..11f2e37e7 100644
--- a/test/sequence/define_assoc_struct.cpp
+++ b/test/sequence/define_assoc_struct.cpp
@@ -15,6 +15,8 @@
 #include <boost/static_assert.hpp>
 #include <iostream>
 
+#include "../with_or_without_fallback.hpp"
+
 namespace ns
 {
     struct x_member;
diff --git a/test/sequence/define_assoc_struct_empty.cpp b/test/sequence/define_assoc_struct_empty.cpp
index 91dd2f350..0dd3f623c 100644
--- a/test/sequence/define_assoc_struct_empty.cpp
+++ b/test/sequence/define_assoc_struct_empty.cpp
@@ -16,6 +16,8 @@
 #include <boost/static_assert.hpp>
 #include <iostream>
 
+#include "../with_or_without_fallback.hpp"
+
 BOOST_FUSION_DEFINE_ASSOC_STRUCT(BOOST_PP_EMPTY(), empty_struct, )
 
 int
diff --git a/test/sequence/define_assoc_struct_move.cpp b/test/sequence/define_assoc_struct_move.cpp
index 07def389f..90cedadaa 100644
--- a/test/sequence/define_assoc_struct_move.cpp
+++ b/test/sequence/define_assoc_struct_move.cpp
@@ -8,6 +8,8 @@
 #include <boost/fusion/adapted/struct/define_assoc_struct.hpp>
 #include <utility>
 
+#include "../with_or_without_fallback.hpp"
+
 struct key_type;
 struct wrapper
 {
diff --git a/test/sequence/define_assoc_tpl_struct.cpp b/test/sequence/define_assoc_tpl_struct.cpp
index bdbcfe470..2ae7af9b4 100644
--- a/test/sequence/define_assoc_tpl_struct.cpp
+++ b/test/sequence/define_assoc_tpl_struct.cpp
@@ -16,6 +16,8 @@
 #include <iostream>
 #include <string>
 
+#include "../with_or_without_fallback.hpp"
+
 namespace ns
 {
     struct x_member;
diff --git a/test/sequence/define_assoc_tpl_struct_empty.cpp b/test/sequence/define_assoc_tpl_struct_empty.cpp
index 70d6ca500..85c258fe8 100644
--- a/test/sequence/define_assoc_tpl_struct_empty.cpp
+++ b/test/sequence/define_assoc_tpl_struct_empty.cpp
@@ -16,6 +16,8 @@
 #include <boost/static_assert.hpp>
 #include <iostream>
 
+#include "../with_or_without_fallback.hpp"
+
 BOOST_FUSION_DEFINE_ASSOC_TPL_STRUCT((M), BOOST_PP_EMPTY(), empty_struct, )
 
 int
diff --git a/test/sequence/define_assoc_tpl_struct_move.cpp b/test/sequence/define_assoc_tpl_struct_move.cpp
index dcffa5663..b977e3863 100644
--- a/test/sequence/define_assoc_tpl_struct_move.cpp
+++ b/test/sequence/define_assoc_tpl_struct_move.cpp
@@ -12,6 +12,8 @@
 #include <boost/fusion/adapted/struct/define_assoc_struct.hpp>
 #include <utility>
 
+#include "../with_or_without_fallback.hpp"
+
 struct key_type;
 struct wrapper
 {
diff --git a/test/sequence/define_struct.cpp b/test/sequence/define_struct.cpp
index 1243b9fe1..216bf8518 100644
--- a/test/sequence/define_struct.cpp
+++ b/test/sequence/define_struct.cpp
@@ -17,6 +17,8 @@
 #include <iostream>
 #include <string>
 
+#include "../with_or_without_fallback.hpp"
+
 BOOST_FUSION_DEFINE_STRUCT(
     (ns),
     point,
diff --git a/test/sequence/define_struct_empty.cpp b/test/sequence/define_struct_empty.cpp
index 1468b9174..39234abd7 100644
--- a/test/sequence/define_struct_empty.cpp
+++ b/test/sequence/define_struct_empty.cpp
@@ -16,6 +16,8 @@
 #include <boost/static_assert.hpp>
 #include <iostream>
 
+#include "../with_or_without_fallback.hpp"
+
 BOOST_FUSION_DEFINE_STRUCT(BOOST_PP_EMPTY(), empty_struct, )
 
 int
diff --git a/test/sequence/define_struct_inline.cpp b/test/sequence/define_struct_inline.cpp
index 4a3793b7e..0c5dc2795 100644
--- a/test/sequence/define_struct_inline.cpp
+++ b/test/sequence/define_struct_inline.cpp
@@ -17,6 +17,8 @@
 #include <iostream>
 #include <string>
 
+#include "../with_or_without_fallback.hpp"
+
 struct cls
 {
     BOOST_FUSION_DEFINE_STRUCT_INLINE(
diff --git a/test/sequence/define_struct_inline_empty.cpp b/test/sequence/define_struct_inline_empty.cpp
index 4168770a9..fc380746f 100644
--- a/test/sequence/define_struct_inline_empty.cpp
+++ b/test/sequence/define_struct_inline_empty.cpp
@@ -16,6 +16,8 @@
 #include <boost/static_assert.hpp>
 #include <iostream>
 
+#include "../with_or_without_fallback.hpp"
+
 BOOST_FUSION_DEFINE_STRUCT_INLINE(empty_struct, )
 
 int
diff --git a/test/sequence/define_struct_inline_move.cpp b/test/sequence/define_struct_inline_move.cpp
index 3c7074042..499ca4ec9 100644
--- a/test/sequence/define_struct_inline_move.cpp
+++ b/test/sequence/define_struct_inline_move.cpp
@@ -8,6 +8,8 @@
 #include <boost/fusion/adapted/struct/define_struct_inline.hpp>
 #include <utility>
 
+#include "../with_or_without_fallback.hpp"
+
 struct wrapper
 {
     int value;
diff --git a/test/sequence/define_struct_move.cpp b/test/sequence/define_struct_move.cpp
index 8732b59b1..c2f8811cd 100644
--- a/test/sequence/define_struct_move.cpp
+++ b/test/sequence/define_struct_move.cpp
@@ -8,6 +8,8 @@
 #include <boost/fusion/adapted/struct/define_struct.hpp>
 #include <utility>
 
+#include "../with_or_without_fallback.hpp"
+
 struct wrapper
 {
     int value;
diff --git a/test/sequence/define_tpl_struct.cpp b/test/sequence/define_tpl_struct.cpp
index b47ac6110..61ffcd0cc 100644
--- a/test/sequence/define_tpl_struct.cpp
+++ b/test/sequence/define_tpl_struct.cpp
@@ -17,6 +17,8 @@
 #include <iostream>
 #include <string>
 
+#include "../with_or_without_fallback.hpp"
+
 BOOST_FUSION_DEFINE_TPL_STRUCT(
     (X)(Y),
     (ns),
diff --git a/test/sequence/define_tpl_struct_empty.cpp b/test/sequence/define_tpl_struct_empty.cpp
index d8cf47dec..ef0849ab4 100644
--- a/test/sequence/define_tpl_struct_empty.cpp
+++ b/test/sequence/define_tpl_struct_empty.cpp
@@ -16,6 +16,8 @@
 #include <boost/static_assert.hpp>
 #include <iostream>
 
+#include "../with_or_without_fallback.hpp"
+
 BOOST_FUSION_DEFINE_TPL_STRUCT((M), BOOST_PP_EMPTY(), empty_struct, )
 
 int
diff --git a/test/sequence/define_tpl_struct_inline.cpp b/test/sequence/define_tpl_struct_inline.cpp
index 3a7c69e3e..735783b4e 100644
--- a/test/sequence/define_tpl_struct_inline.cpp
+++ b/test/sequence/define_tpl_struct_inline.cpp
@@ -17,6 +17,8 @@
 #include <iostream>
 #include <string>
 
+#include "../with_or_without_fallback.hpp"
+
 struct cls
 {
     BOOST_FUSION_DEFINE_TPL_STRUCT_INLINE(
diff --git a/test/sequence/define_tpl_struct_inline_empty.cpp b/test/sequence/define_tpl_struct_inline_empty.cpp
index 5cc0163fe..b5c62a83a 100644
--- a/test/sequence/define_tpl_struct_inline_empty.cpp
+++ b/test/sequence/define_tpl_struct_inline_empty.cpp
@@ -16,6 +16,8 @@
 #include <boost/static_assert.hpp>
 #include <iostream>
 
+#include "../with_or_without_fallback.hpp"
+
 BOOST_FUSION_DEFINE_TPL_STRUCT_INLINE((M), empty_struct, )
 
 int
diff --git a/test/sequence/define_tpl_struct_inline_move.cpp b/test/sequence/define_tpl_struct_inline_move.cpp
index 39a00079a..7af6e447e 100644
--- a/test/sequence/define_tpl_struct_inline_move.cpp
+++ b/test/sequence/define_tpl_struct_inline_move.cpp
@@ -8,6 +8,8 @@
 #include <boost/fusion/adapted/struct/define_struct_inline.hpp>
 #include <utility>
 
+#include "../with_or_without_fallback.hpp"
+
 struct wrapper
 {
     int value;
diff --git a/test/sequence/define_tpl_struct_move.cpp b/test/sequence/define_tpl_struct_move.cpp
index c4dd9ab63..59dedc56e 100644
--- a/test/sequence/define_tpl_struct_move.cpp
+++ b/test/sequence/define_tpl_struct_move.cpp
@@ -8,6 +8,8 @@
 #include <boost/fusion/adapted/struct/define_struct.hpp>
 #include <utility>
 
+#include "../with_or_without_fallback.hpp"
+
 struct wrapper
 {
     int value;
diff --git a/test/sequence/deque_comparison.cpp b/test/sequence/deque_comparison.cpp
index 9bbf4fd95..0e214fce8 100644
--- a/test/sequence/deque_comparison.cpp
+++ b/test/sequence/deque_comparison.cpp
@@ -8,6 +8,8 @@
 ==============================================================================*/
 #include <boost/fusion/container/deque/deque.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE deque
 #include "comparison.hpp"
 
diff --git a/test/sequence/deque_construction.cpp b/test/sequence/deque_construction.cpp
index 4fc8c8830..d79f64aac 100644
--- a/test/sequence/deque_construction.cpp
+++ b/test/sequence/deque_construction.cpp
@@ -8,6 +8,8 @@
 ==============================================================================*/
 #include <boost/fusion/container/deque/deque.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE deque
 #include "construction.hpp"
 
diff --git a/test/sequence/deque_copy.cpp b/test/sequence/deque_copy.cpp
index 5c48d5ecc..a8e12edff 100644
--- a/test/sequence/deque_copy.cpp
+++ b/test/sequence/deque_copy.cpp
@@ -10,6 +10,8 @@
 #include <boost/fusion/container/generation/make_deque.hpp>
 #include <boost/fusion/container/generation/deque_tie.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE deque
 #include "copy.hpp"
 
diff --git a/test/sequence/deque_hash.cpp b/test/sequence/deque_hash.cpp
index 01b36660a..39563f09b 100644
--- a/test/sequence/deque_hash.cpp
+++ b/test/sequence/deque_hash.cpp
@@ -6,6 +6,8 @@
 ==============================================================================*/
 #include <boost/fusion/container/deque/deque.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE deque
 #include "hash.hpp"
 
diff --git a/test/sequence/deque_is_constructible.cpp b/test/sequence/deque_is_constructible.cpp
index e08b4787e..86dca2d73 100644
--- a/test/sequence/deque_is_constructible.cpp
+++ b/test/sequence/deque_is_constructible.cpp
@@ -10,9 +10,12 @@
 #ifndef BOOST_NO_CXX11_HDR_TYPE_TRAITS
 #include <type_traits>
 #include <boost/fusion/include/deque.hpp>
+#include <boost/fusion/include/boost_pfr_force.hpp>
 
+#include "../with_or_without_fallback.hpp"
 
 struct Dummy { };
+BOOST_FUSION_FORCE_PFR_NONREFLECTABLE(Dummy)
 
 // Make sure deque's constructor is SFINAE-friendly.
 static_assert(!std::is_constructible<boost::fusion::deque<int>, Dummy const&>::value, "");
diff --git a/test/sequence/deque_iterator.cpp b/test/sequence/deque_iterator.cpp
index 10ce27f8b..e31b82c56 100644
--- a/test/sequence/deque_iterator.cpp
+++ b/test/sequence/deque_iterator.cpp
@@ -7,6 +7,8 @@
 ==============================================================================*/
 #include <boost/fusion/container/deque/deque.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE deque
 #define FUSION_TRAVERSAL_TAG bidirectional_traversal_tag
 #include "./iterator.hpp"
diff --git a/test/sequence/deque_make.cpp b/test/sequence/deque_make.cpp
index fe5705335..8f8eec7a6 100644
--- a/test/sequence/deque_make.cpp
+++ b/test/sequence/deque_make.cpp
@@ -9,6 +9,8 @@
 #include <boost/fusion/container/deque/deque.hpp>
 #include <boost/fusion/container/generation/make_deque.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE deque
 #include "make.hpp"
 
diff --git a/test/sequence/deque_misc.cpp b/test/sequence/deque_misc.cpp
index 402afaccc..897621868 100644
--- a/test/sequence/deque_misc.cpp
+++ b/test/sequence/deque_misc.cpp
@@ -10,6 +10,8 @@
 #include <boost/fusion/container/deque/convert.hpp>
 #include <boost/fusion/adapted/mpl.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define BOOST_FUSION_SEQUENCE_CONVERSION_IS_NOT_SEQUENCE__TYPE_PRESERVING
 
 #define FUSION_SEQUENCE deque
diff --git a/test/sequence/deque_move.cpp b/test/sequence/deque_move.cpp
index b3bdf11b7..b312b2588 100644
--- a/test/sequence/deque_move.cpp
+++ b/test/sequence/deque_move.cpp
@@ -8,6 +8,8 @@
 #define BOOST_FUSION_DONT_USE_PREPROCESSED_FILES
 #include <boost/fusion/container/deque/deque.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE boost::fusion::deque<std::vector<x>>
 #define FUSION_SEQUENCE2 boost::fusion::deque<std::vector<x>, x>
 
diff --git a/test/sequence/deque_mutate.cpp b/test/sequence/deque_mutate.cpp
index ff145061b..c2d47d5ed 100644
--- a/test/sequence/deque_mutate.cpp
+++ b/test/sequence/deque_mutate.cpp
@@ -8,6 +8,8 @@
 ==============================================================================*/
 #include <boost/fusion/container/deque/deque.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE deque
 #include "mutate.hpp"
 
diff --git a/test/sequence/deque_nest.cpp b/test/sequence/deque_nest.cpp
index fd69d151f..628e292d4 100644
--- a/test/sequence/deque_nest.cpp
+++ b/test/sequence/deque_nest.cpp
@@ -7,6 +7,8 @@
 #include <boost/fusion/container/deque/deque.hpp>
 #include <boost/core/lightweight_test.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE boost::fusion::deque
 #include "nest.hpp"
 
diff --git a/test/sequence/deque_tie.cpp b/test/sequence/deque_tie.cpp
index f6ee91600..ea9d16a5c 100644
--- a/test/sequence/deque_tie.cpp
+++ b/test/sequence/deque_tie.cpp
@@ -11,6 +11,8 @@
 #include <boost/fusion/container/generation/ignore.hpp>
 #include <boost/fusion/container/generation/make_deque.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE deque
 #include "tie.hpp"
 
diff --git a/test/sequence/deque_value_at.cpp b/test/sequence/deque_value_at.cpp
index 5b31504fb..da2feae56 100644
--- a/test/sequence/deque_value_at.cpp
+++ b/test/sequence/deque_value_at.cpp
@@ -8,6 +8,8 @@
 ==============================================================================*/
 #include <boost/fusion/container/deque/deque.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE deque
 #include "value_at.hpp"
 
diff --git a/test/sequence/detail/boost_pfr_utils.cpp b/test/sequence/detail/boost_pfr_utils.cpp
new file mode 100644
index 000000000..3ba07125e
--- /dev/null
+++ b/test/sequence/detail/boost_pfr_utils.cpp
@@ -0,0 +1,60 @@
+/*=============================================================================
+    Copyright (c) 2023 Denis Mikhailov
+    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/adapted/boost_pfr/tag_of_fallback.hpp>
+#include <boost/fusion/support/tag_of.hpp>
+
+#include <type_traits>
+#include <boost/type_traits/is_same.hpp>
+
+
+void test_starts_with() {
+    static_assert(!boost::fusion::detail::starts_with("tes", "test"), "");
+
+    static_assert(boost::fusion::detail::starts_with("test", "test"), "");
+    static_assert(boost::fusion::detail::starts_with("test", "tes"), "");
+    static_assert(boost::fusion::detail::starts_with("test", "te"), "");
+    static_assert(boost::fusion::detail::starts_with("test", "t"), "");
+    static_assert(boost::fusion::detail::starts_with("test", ""), "");
+
+    static_assert(!boost::fusion::detail::starts_with("test", "tesr"), "");
+    static_assert(!boost::fusion::detail::starts_with("test", "tet"), "");
+    static_assert(!boost::fusion::detail::starts_with("test", "tq"), "");
+    static_assert(!boost::fusion::detail::starts_with("test", "f"), "");
+
+    static_assert(!boost::fusion::detail::starts_with("", "test"), "");
+    static_assert(!boost::fusion::detail::starts_with("", "tes"), "");
+    static_assert(!boost::fusion::detail::starts_with("", "te"), "");
+    static_assert(!boost::fusion::detail::starts_with("", "t"), "");
+    static_assert(boost::fusion::detail::starts_with("", ""), "");
+}
+
+void test_in_namespace() {
+#if BOOST_FUSION_EXPECT_CTTI_TYPE_INDEX_CONSTEXPR_WHEN_UTILS_TEST
+    static_assert(boost::fusion::detail::in_namespace< boost::is_same<int,int> >("boost"), "");
+    static_assert(boost::fusion::detail::in_namespace< std::is_same<int,int> >("std"), "");
+    static_assert(!boost::fusion::detail::in_namespace< int >("std"), "");
+#endif
+}
+
+void test_constexpr_in_namespace_check_possible() {
+    using T = boost::is_same<int,int>;
+#if BOOST_FUSION_EXPECT_CTTI_TYPE_INDEX_CONSTEXPR_WHEN_UTILS_TEST
+    static_assert(boost::fusion::detail::constexpr_in_namespace_check_possible<T>::value, "");
+#elif BOOST_FUSION_EXPECT_CTTI_TYPE_INDEX_NONCONSTEXPR_WHEN_UTILS_TEST
+    static_assert(!boost::fusion::detail::constexpr_in_namespace_check_possible<T>::value, "");
+#else
+#error non properly configured
+#endif
+}
+
+int main() {
+    test_starts_with();
+    test_in_namespace();
+    test_constexpr_in_namespace_check_possible();
+}
+
+
diff --git a/test/sequence/filter_view.cpp b/test/sequence/filter_view.cpp
index 8ebe14767..79f225478 100644
--- a/test/sequence/filter_view.cpp
+++ b/test/sequence/filter_view.cpp
@@ -28,6 +28,8 @@
 #include <boost/mpl/bool.hpp>
 #include <boost/mpl/assert.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 struct X
 {
     operator char const*() const
diff --git a/test/sequence/flatten_view.cpp b/test/sequence/flatten_view.cpp
index da8e65273..fafdcb5c2 100644
--- a/test/sequence/flatten_view.cpp
+++ b/test/sequence/flatten_view.cpp
@@ -19,6 +19,7 @@
 #include <boost/fusion/iterator/distance.hpp>
 #include <boost/fusion/algorithm/auxiliary/copy.hpp>
 
+#include "../with_or_without_fallback.hpp"
 
 int main()
 {
diff --git a/test/sequence/front_extended_deque.cpp b/test/sequence/front_extended_deque.cpp
index cdbedeb3b..9a49aaaf0 100644
--- a/test/sequence/front_extended_deque.cpp
+++ b/test/sequence/front_extended_deque.cpp
@@ -20,6 +20,8 @@
 #include <boost/mpl/assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 int main()
 {
     using namespace boost::fusion;
diff --git a/test/sequence/github-159.cpp b/test/sequence/github-159.cpp
index e21d80c5c..7c5571e18 100644
--- a/test/sequence/github-159.cpp
+++ b/test/sequence/github-159.cpp
@@ -8,6 +8,8 @@
 #include <boost/fusion/container/vector/vector.hpp>
 #include <boost/type.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 int main()
 {
     boost::fusion::vector<int, float> v1;
diff --git a/test/sequence/github-176.cpp b/test/sequence/github-176.cpp
index 3f57df278..3f09102ce 100644
--- a/test/sequence/github-176.cpp
+++ b/test/sequence/github-176.cpp
@@ -15,6 +15,8 @@
 #include <boost/fusion/tuple/tuple.hpp>
 #include <boost/core/lightweight_test.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 template <typename Sequence>
 void test_at()
 {
diff --git a/test/sequence/hash.cpp b/test/sequence/hash.cpp
index 30b44055a..9146aca75 100644
--- a/test/sequence/hash.cpp
+++ b/test/sequence/hash.cpp
@@ -11,6 +11,8 @@
 #include <boost/fusion/include/adapt_struct.hpp>
 #include <boost/fusion/sequence/hash.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 struct test_struct
 {
     test_struct(bool bb, int ii, char cc, std::string const& ss) :
diff --git a/test/sequence/identity_view.cpp b/test/sequence/identity_view.cpp
index e74f9294f..a063ce407 100644
--- a/test/sequence/identity_view.cpp
+++ b/test/sequence/identity_view.cpp
@@ -41,6 +41,8 @@
 #include <boost/typeof/typeof.hpp>
 #include <boost/type_traits/remove_reference.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 struct abstract
 {
     virtual void foo() = 0;
diff --git a/test/sequence/io.cpp b/test/sequence/io.cpp
index d14f2af39..f9f336d97 100644
--- a/test/sequence/io.cpp
+++ b/test/sequence/io.cpp
@@ -22,6 +22,8 @@
 # include <sstream>
 #endif
 
+#include "../with_or_without_fallback.hpp"
+
 using boost::fusion::vector;
 using boost::fusion::make_vector;
 using boost::fusion::tuple_close;
diff --git a/test/sequence/iterator_range.cpp b/test/sequence/iterator_range.cpp
index 18f91af0a..41209bead 100644
--- a/test/sequence/iterator_range.cpp
+++ b/test/sequence/iterator_range.cpp
@@ -24,6 +24,8 @@
 #include <boost/mpl/assert.hpp>
 #include <boost/static_assert.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 int
 main()
 {
diff --git a/test/sequence/joint_view.cpp b/test/sequence/joint_view.cpp
index ba5659b74..81405f59b 100644
--- a/test/sequence/joint_view.cpp
+++ b/test/sequence/joint_view.cpp
@@ -22,6 +22,8 @@
 #include <boost/mpl/assert.hpp>
 #include <string>
 
+#include "../with_or_without_fallback.hpp"
+
 struct X
 {
     operator char const*() const
diff --git a/test/sequence/list_comparison.cpp b/test/sequence/list_comparison.cpp
index 2a02eba01..12d09889d 100644
--- a/test/sequence/list_comparison.cpp
+++ b/test/sequence/list_comparison.cpp
@@ -7,6 +7,8 @@
 ==============================================================================*/
 #include <boost/fusion/container/list/list.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE list
 #include "comparison.hpp"
 
diff --git a/test/sequence/list_construction.cpp b/test/sequence/list_construction.cpp
index a10b1e1a9..6be6d51a8 100644
--- a/test/sequence/list_construction.cpp
+++ b/test/sequence/list_construction.cpp
@@ -7,6 +7,8 @@
 ==============================================================================*/
 #include <boost/fusion/container/list/list.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE list
 #include "construction.hpp"
 
diff --git a/test/sequence/list_copy.cpp b/test/sequence/list_copy.cpp
index 797089e9c..fdb4041ce 100644
--- a/test/sequence/list_copy.cpp
+++ b/test/sequence/list_copy.cpp
@@ -9,6 +9,8 @@
 #include <boost/fusion/container/generation/make_list.hpp>
 #include <boost/fusion/container/generation/list_tie.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE list
 #include "copy.hpp"
 
diff --git a/test/sequence/list_hash.cpp b/test/sequence/list_hash.cpp
index 51203b273..8aebfc1d9 100644
--- a/test/sequence/list_hash.cpp
+++ b/test/sequence/list_hash.cpp
@@ -6,6 +6,8 @@
 ==============================================================================*/
 #include <boost/fusion/container/list/list.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE list
 #include "hash.hpp"
 
diff --git a/test/sequence/list_iterator.cpp b/test/sequence/list_iterator.cpp
index 62d670878..b1cbf3865 100644
--- a/test/sequence/list_iterator.cpp
+++ b/test/sequence/list_iterator.cpp
@@ -6,6 +6,8 @@
 ==============================================================================*/
 #include <boost/fusion/container/list/list.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE list
 #define FUSION_NO_PRIOR
 #define FUSION_TRAVERSAL_TAG forward_traversal_tag
diff --git a/test/sequence/list_make.cpp b/test/sequence/list_make.cpp
index 296b6063e..cb9c9d283 100644
--- a/test/sequence/list_make.cpp
+++ b/test/sequence/list_make.cpp
@@ -8,6 +8,8 @@
 #include <boost/fusion/container/list/list.hpp>
 #include <boost/fusion/container/generation/make_list.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE list
 #include "make.hpp"
 
diff --git a/test/sequence/list_misc.cpp b/test/sequence/list_misc.cpp
index 28d84854b..1a9c94bff 100644
--- a/test/sequence/list_misc.cpp
+++ b/test/sequence/list_misc.cpp
@@ -8,6 +8,8 @@
 #include <boost/fusion/container/list/list.hpp>
 #include <boost/fusion/container/list/convert.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE list
 #define FUSION_FORWARD_ONLY
 #include "misc.hpp"
diff --git a/test/sequence/list_mutate.cpp b/test/sequence/list_mutate.cpp
index b2736679c..3d2ec5b59 100644
--- a/test/sequence/list_mutate.cpp
+++ b/test/sequence/list_mutate.cpp
@@ -7,6 +7,8 @@
 ==============================================================================*/
 #include <boost/fusion/container/list/list.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE list
 #include "mutate.hpp"
 
diff --git a/test/sequence/list_nest.cpp b/test/sequence/list_nest.cpp
index 82df4864f..4115ca0b1 100644
--- a/test/sequence/list_nest.cpp
+++ b/test/sequence/list_nest.cpp
@@ -7,6 +7,8 @@
 #include <boost/fusion/container/list/list.hpp>
 #include <boost/core/lightweight_test.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE boost::fusion::list
 #include "nest.hpp"
 
diff --git a/test/sequence/list_tie.cpp b/test/sequence/list_tie.cpp
index 30c8ed83d..d08e5c68f 100644
--- a/test/sequence/list_tie.cpp
+++ b/test/sequence/list_tie.cpp
@@ -10,6 +10,8 @@
 #include <boost/fusion/container/generation/ignore.hpp>
 #include <boost/fusion/container/generation/make_list.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE list
 #include "tie.hpp"
 
diff --git a/test/sequence/list_value_at.cpp b/test/sequence/list_value_at.cpp
index 487968dae..431e4804a 100644
--- a/test/sequence/list_value_at.cpp
+++ b/test/sequence/list_value_at.cpp
@@ -7,6 +7,8 @@
 ==============================================================================*/
 #include <boost/fusion/container/list/list.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE list
 #include "value_at.hpp"
 
diff --git a/test/sequence/make_list.cpp b/test/sequence/make_list.cpp
index 296b6063e..cb9c9d283 100644
--- a/test/sequence/make_list.cpp
+++ b/test/sequence/make_list.cpp
@@ -8,6 +8,8 @@
 #include <boost/fusion/container/list/list.hpp>
 #include <boost/fusion/container/generation/make_list.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE list
 #include "make.hpp"
 
diff --git a/test/sequence/make_vector.cpp b/test/sequence/make_vector.cpp
index 8a687354a..95cf2c1db 100644
--- a/test/sequence/make_vector.cpp
+++ b/test/sequence/make_vector.cpp
@@ -8,6 +8,8 @@
 #include <boost/fusion/container/vector/vector.hpp>
 #include <boost/fusion/container/generation/make_vector.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE vector
 #include "make.hpp"
 
diff --git a/test/sequence/map.cpp b/test/sequence/map.cpp
index 5a130f8b3..bda8b0757 100644
--- a/test/sequence/map.cpp
+++ b/test/sequence/map.cpp
@@ -25,6 +25,7 @@
 #include <iostream>
 #include <string>
 
+#include "../with_or_without_fallback.hpp"
 
 struct copy_all
 {
diff --git a/test/sequence/map_comparison.cpp b/test/sequence/map_comparison.cpp
index 63f395153..fa57522ea 100644
--- a/test/sequence/map_comparison.cpp
+++ b/test/sequence/map_comparison.cpp
@@ -10,6 +10,8 @@
 #include <boost/detail/lightweight_test.hpp>
 #include <boost/fusion/sequence/comparison.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 struct key1 {};
 struct key2 {};
 struct key3 {};
diff --git a/test/sequence/map_construction.cpp b/test/sequence/map_construction.cpp
index 9c03b4268..c35734754 100644
--- a/test/sequence/map_construction.cpp
+++ b/test/sequence/map_construction.cpp
@@ -10,6 +10,8 @@
 #include <boost/detail/lightweight_test.hpp>
 #include <boost/fusion/sequence/intrinsic/at.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 struct key1 {};
 struct key2 {};
 struct key3 {};
diff --git a/test/sequence/map_copy.cpp b/test/sequence/map_copy.cpp
index b8218bdf2..786c43ffb 100644
--- a/test/sequence/map_copy.cpp
+++ b/test/sequence/map_copy.cpp
@@ -20,6 +20,8 @@
 #include <boost/static_assert.hpp>
 #include <string>
 
+#include "../with_or_without_fallback.hpp"
+
 struct k1 {};
 struct k2 {};
 struct k3 {};
diff --git a/test/sequence/map_misc.cpp b/test/sequence/map_misc.cpp
index 81da97539..47c326a49 100644
--- a/test/sequence/map_misc.cpp
+++ b/test/sequence/map_misc.cpp
@@ -20,6 +20,8 @@
 #include <boost/type_traits/is_same.hpp>
 #include <string>
 
+#include "../with_or_without_fallback.hpp"
+
 struct k1 {};
 struct k2 {};
 struct k3 {};
diff --git a/test/sequence/map_move.cpp b/test/sequence/map_move.cpp
index 9f9dd004f..7c5af3d62 100644
--- a/test/sequence/map_move.cpp
+++ b/test/sequence/map_move.cpp
@@ -8,6 +8,8 @@
 #define BOOST_FUSION_DONT_USE_PREPROCESSED_FILES
 #include <boost/fusion/container/map/map.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 struct k1 {};
 struct k2 {};
 
diff --git a/test/sequence/map_mutate.cpp b/test/sequence/map_mutate.cpp
index 68c27133b..3514d06ed 100644
--- a/test/sequence/map_mutate.cpp
+++ b/test/sequence/map_mutate.cpp
@@ -10,6 +10,8 @@
 #include <boost/detail/lightweight_test.hpp>
 #include <boost/fusion/sequence/intrinsic/at.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 struct k1 {};
 struct k2 {};
 struct k3 {};
diff --git a/test/sequence/map_tie.cpp b/test/sequence/map_tie.cpp
index a3547375f..d5138da0a 100644
--- a/test/sequence/map_tie.cpp
+++ b/test/sequence/map_tie.cpp
@@ -10,6 +10,8 @@
 #include <boost/fusion/container/generation/map_tie.hpp>
 #include <boost/fusion/sequence/intrinsic/at_key.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 struct key_zero;
 struct key_one;
 
diff --git a/test/sequence/nil.cpp b/test/sequence/nil.cpp
index bdc8c3528..15fd7b31c 100644
--- a/test/sequence/nil.cpp
+++ b/test/sequence/nil.cpp
@@ -10,6 +10,7 @@
 #include <boost/fusion/support/config.hpp>
 #include <boost/mpl/bool.hpp>
 
+#include "../with_or_without_fallback.hpp"
 
 int main() {
     using namespace boost::fusion;
diff --git a/test/sequence/nview.cpp b/test/sequence/nview.cpp
index dab982a52..5dcbd1f29 100644
--- a/test/sequence/nview.cpp
+++ b/test/sequence/nview.cpp
@@ -15,6 +15,8 @@
 #include <string>
 #include <iostream>
 
+#include "../with_or_without_fallback.hpp"
+
 struct test {
     int int_;
     std::string string_;
diff --git a/test/sequence/ref_vector.cpp b/test/sequence/ref_vector.cpp
index 8bd0929b8..1bbf06f0b 100644
--- a/test/sequence/ref_vector.cpp
+++ b/test/sequence/ref_vector.cpp
@@ -13,6 +13,8 @@
 #include <boost/type_traits/add_reference.hpp>
 #include <boost/fusion/include/adapt_struct.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 struct foo
 {
   double d; float f; short c;
diff --git a/test/sequence/repetitive_view.cpp b/test/sequence/repetitive_view.cpp
index 54da37bc8..8b8f1d6ee 100644
--- a/test/sequence/repetitive_view.cpp
+++ b/test/sequence/repetitive_view.cpp
@@ -21,6 +21,8 @@
 
 #include <boost/fusion/functional/generation/make_fused_procedure.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 struct check_equal
 {
     template<typename LHS, typename RHS>
diff --git a/test/sequence/reverse_view.cpp b/test/sequence/reverse_view.cpp
index 356b9b0bf..e8de1c2e5 100644
--- a/test/sequence/reverse_view.cpp
+++ b/test/sequence/reverse_view.cpp
@@ -28,6 +28,7 @@
 #include <boost/mpl/range_c.hpp>
 #include <boost/type_traits/is_same.hpp>
 
+#include "../with_or_without_fallback.hpp"
 
 int
 main()
diff --git a/test/sequence/segmented_iterator_range.cpp b/test/sequence/segmented_iterator_range.cpp
index 236a7e27d..8f5cd9310 100644
--- a/test/sequence/segmented_iterator_range.cpp
+++ b/test/sequence/segmented_iterator_range.cpp
@@ -19,8 +19,12 @@
 #include <boost/mpl/begin.hpp>
 #include <boost/mpl/next.hpp>
 #include <boost/static_assert.hpp>
+
+#include "../with_or_without_fallback.hpp"
+
 #include "tree.hpp"
 
+
 #ifdef _MSC_VER
 #  pragma warning(push)
 #  pragma warning(disable: 4512) // assignment operator could not be generated.
diff --git a/test/sequence/set.cpp b/test/sequence/set.cpp
index 714c36cda..a62d0c11c 100644
--- a/test/sequence/set.cpp
+++ b/test/sequence/set.cpp
@@ -25,6 +25,8 @@
 #include <iostream>
 #include <string>
 
+#include "../with_or_without_fallback.hpp"
+
 int
 main()
 {
diff --git a/test/sequence/single_view.cpp b/test/sequence/single_view.cpp
index 6fa517551..b31b94c44 100644
--- a/test/sequence/single_view.cpp
+++ b/test/sequence/single_view.cpp
@@ -25,6 +25,8 @@
 #include <boost/mpl/assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 struct X {};
 
 template <typename OS>
diff --git a/test/sequence/std_array.cpp b/test/sequence/std_array.cpp
index 50e09b398..ceec1db5f 100644
--- a/test/sequence/std_array.cpp
+++ b/test/sequence/std_array.cpp
@@ -26,6 +26,8 @@
 
 #include <boost/mpl/assert.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 int main()
 {
     using namespace boost::fusion;
diff --git a/test/sequence/std_pair.cpp b/test/sequence/std_pair.cpp
index 647e9b00c..dd304193d 100644
--- a/test/sequence/std_pair.cpp
+++ b/test/sequence/std_pair.cpp
@@ -31,6 +31,8 @@
 #include <string>
 #include <utility>
 
+#include "../with_or_without_fallback.hpp"
+
 int
 main()
 {
diff --git a/test/sequence/std_tuple.cpp b/test/sequence/std_tuple.cpp
index 3d7110710..d195cb237 100644
--- a/test/sequence/std_tuple.cpp
+++ b/test/sequence/std_tuple.cpp
@@ -21,6 +21,8 @@
 #include <tuple>
 #include <string>
 
+#include "../with_or_without_fallback.hpp"
+
 int main()
 {
     using namespace boost::fusion;
diff --git a/test/sequence/std_tuple_iterator.cpp b/test/sequence/std_tuple_iterator.cpp
index df283331f..75550ea8a 100644
--- a/test/sequence/std_tuple_iterator.cpp
+++ b/test/sequence/std_tuple_iterator.cpp
@@ -15,6 +15,8 @@
 
 #include <boost/fusion/adapted/std_tuple.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE std::tuple
 #define FUSION_TRAVERSAL_TAG random_access_traversal_tag
 #include "./iterator.hpp"
diff --git a/test/sequence/swap.cpp b/test/sequence/swap.cpp
index cac832b4b..dfcfcf816 100644
--- a/test/sequence/swap.cpp
+++ b/test/sequence/swap.cpp
@@ -17,6 +17,8 @@
 
 #include <vector>
 
+#include "../with_or_without_fallback.hpp"
+
 int main()
 {
     namespace fusion = boost::fusion;
diff --git a/test/sequence/transform_view.cpp b/test/sequence/transform_view.cpp
index 4f11e6b77..e5c008c1f 100644
--- a/test/sequence/transform_view.cpp
+++ b/test/sequence/transform_view.cpp
@@ -41,6 +41,8 @@
 #include <boost/typeof/typeof.hpp>
 #include <boost/type_traits/remove_reference.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 struct square
 {
     template<typename T>
diff --git a/test/sequence/tuple_comparison.cpp b/test/sequence/tuple_comparison.cpp
index 2b4433068..784d0835e 100644
--- a/test/sequence/tuple_comparison.cpp
+++ b/test/sequence/tuple_comparison.cpp
@@ -8,6 +8,8 @@
 #include <boost/fusion/tuple/tuple.hpp>
 #include <boost/fusion/adapted/mpl.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE tuple
 #include "comparison.hpp"
 
diff --git a/test/sequence/tuple_construction.cpp b/test/sequence/tuple_construction.cpp
index 127720279..c7bcbeb29 100644
--- a/test/sequence/tuple_construction.cpp
+++ b/test/sequence/tuple_construction.cpp
@@ -8,6 +8,8 @@
 #include <boost/fusion/tuple/tuple.hpp>
 #include <boost/fusion/adapted/mpl.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define NO_CONSTRUCT_FROM_NIL
 #define FUSION_SEQUENCE tuple
 #define FUSION_AT get
diff --git a/test/sequence/tuple_conversion.cpp b/test/sequence/tuple_conversion.cpp
index 861365de4..57fef2f2e 100644
--- a/test/sequence/tuple_conversion.cpp
+++ b/test/sequence/tuple_conversion.cpp
@@ -8,6 +8,8 @@
 #include <boost/detail/lightweight_test.hpp>
 #include <boost/fusion/tuple.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE boost::fusion::tuple
 #include "conversion.hpp"
 
diff --git a/test/sequence/tuple_copy.cpp b/test/sequence/tuple_copy.cpp
index 012973876..7746da80c 100644
--- a/test/sequence/tuple_copy.cpp
+++ b/test/sequence/tuple_copy.cpp
@@ -7,6 +7,8 @@
 ==============================================================================*/
 #include <boost/fusion/tuple.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE tuple
 #define FUSION_AT get
 #define FUSION_MAKE make_tuple
diff --git a/test/sequence/tuple_element.cpp b/test/sequence/tuple_element.cpp
index 0932e627e..3e95f71df 100644
--- a/test/sequence/tuple_element.cpp
+++ b/test/sequence/tuple_element.cpp
@@ -7,6 +7,8 @@
 ==============================================================================*/
 #include <boost/fusion/tuple.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE tuple
 #define FUSION_AT get
 #define FUSION_VALUE_AT(S, N) tuple_element<N, S>
diff --git a/test/sequence/tuple_hash.cpp b/test/sequence/tuple_hash.cpp
index e8f604ef5..df0656a17 100644
--- a/test/sequence/tuple_hash.cpp
+++ b/test/sequence/tuple_hash.cpp
@@ -6,6 +6,8 @@
 ==============================================================================*/
 #include <boost/fusion/tuple/tuple.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE tuple
 #include "hash.hpp"
 
diff --git a/test/sequence/tuple_make.cpp b/test/sequence/tuple_make.cpp
index 1a453b627..f24bbc1d3 100644
--- a/test/sequence/tuple_make.cpp
+++ b/test/sequence/tuple_make.cpp
@@ -7,6 +7,8 @@
 ==============================================================================*/
 #include <boost/fusion/tuple.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE boost::fusion::tuple
 #define FUSION_AT get
 #define FUSION_MAKE boost::fusion::make_tuple
diff --git a/test/sequence/tuple_misc.cpp b/test/sequence/tuple_misc.cpp
index 473efb61c..89d6d033f 100644
--- a/test/sequence/tuple_misc.cpp
+++ b/test/sequence/tuple_misc.cpp
@@ -9,6 +9,8 @@
 #include <boost/fusion/container/vector/convert.hpp>
 #include <boost/fusion/adapted/mpl.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE tuple
 #define FUSION_AT get
 #define FUSION_SIZE tuple_size
diff --git a/test/sequence/tuple_mutate.cpp b/test/sequence/tuple_mutate.cpp
index b6e72a610..075c0cc40 100644
--- a/test/sequence/tuple_mutate.cpp
+++ b/test/sequence/tuple_mutate.cpp
@@ -7,6 +7,8 @@
 ==============================================================================*/
 #include <boost/fusion/tuple.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE tuple
 #define FUSION_AT get
 #include "mutate.hpp"
diff --git a/test/sequence/tuple_nest.cpp b/test/sequence/tuple_nest.cpp
index 3344c5231..b43aad0a6 100644
--- a/test/sequence/tuple_nest.cpp
+++ b/test/sequence/tuple_nest.cpp
@@ -7,6 +7,8 @@
 #include <boost/fusion/tuple/tuple.hpp>
 #include <boost/core/lightweight_test.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE boost::fusion::tuple
 #include "nest.hpp"
 
diff --git a/test/sequence/tuple_tie.cpp b/test/sequence/tuple_tie.cpp
index 2d5ec24f6..80c339746 100644
--- a/test/sequence/tuple_tie.cpp
+++ b/test/sequence/tuple_tie.cpp
@@ -7,6 +7,8 @@
 ==============================================================================*/
 #include <boost/fusion/tuple.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE tuple
 #define FUSION_AT get
 #define FUSION_MAKE make_tuple
diff --git a/test/sequence/tuple_traits.cpp b/test/sequence/tuple_traits.cpp
index f065504a7..3a577b07a 100644
--- a/test/sequence/tuple_traits.cpp
+++ b/test/sequence/tuple_traits.cpp
@@ -11,6 +11,8 @@
 #include <boost/type_traits/is_constructible.hpp>
 #include <boost/type_traits/is_convertible.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE boost::fusion::tuple
 #define FUSION_ALT_SEQUENCE boost::fusion::vector
 #include "traits.hpp"
diff --git a/test/sequence/vector_comparison.cpp b/test/sequence/vector_comparison.cpp
index c23db8336..fe2e00b48 100644
--- a/test/sequence/vector_comparison.cpp
+++ b/test/sequence/vector_comparison.cpp
@@ -7,6 +7,8 @@
 ==============================================================================*/
 #include <boost/fusion/container/vector/vector.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE vector
 #include "comparison.hpp"
 
diff --git a/test/sequence/vector_construction.cpp b/test/sequence/vector_construction.cpp
index 8af5bc042..554790dd9 100644
--- a/test/sequence/vector_construction.cpp
+++ b/test/sequence/vector_construction.cpp
@@ -7,6 +7,8 @@
 ==============================================================================*/
 #include <boost/fusion/container/vector/vector.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE vector
 #include "construction.hpp"
 
diff --git a/test/sequence/vector_conversion.cpp b/test/sequence/vector_conversion.cpp
index 1ffd77cc6..a837f803e 100644
--- a/test/sequence/vector_conversion.cpp
+++ b/test/sequence/vector_conversion.cpp
@@ -9,6 +9,8 @@
 #include <boost/detail/lightweight_test.hpp>
 #include <boost/fusion/container/vector.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE boost::fusion::vector
 #include "conversion.hpp"
 
diff --git a/test/sequence/vector_copy.cpp b/test/sequence/vector_copy.cpp
index 8a4d26ce9..6f7b8fa94 100644
--- a/test/sequence/vector_copy.cpp
+++ b/test/sequence/vector_copy.cpp
@@ -9,6 +9,8 @@
 #include <boost/fusion/container/generation/make_vector.hpp>
 #include <boost/fusion/container/generation/vector_tie.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE vector
 #include "copy.hpp"
 
diff --git a/test/sequence/vector_hash.cpp b/test/sequence/vector_hash.cpp
index 6b6dcd24c..cbcedf042 100644
--- a/test/sequence/vector_hash.cpp
+++ b/test/sequence/vector_hash.cpp
@@ -6,6 +6,8 @@
 ==============================================================================*/
 #include <boost/fusion/container/vector/vector.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE vector 
 #include "hash.hpp"
 
diff --git a/test/sequence/vector_iterator.cpp b/test/sequence/vector_iterator.cpp
index a2ca7df73..71553ade7 100644
--- a/test/sequence/vector_iterator.cpp
+++ b/test/sequence/vector_iterator.cpp
@@ -7,6 +7,8 @@
 #include <boost/fusion/container/vector/vector.hpp>
 #include <boost/fusion/container/vector/vector_iterator.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE vector
 #define FUSION_TRAVERSAL_TAG random_access_traversal_tag
 #include "./iterator.hpp"
diff --git a/test/sequence/vector_make.cpp b/test/sequence/vector_make.cpp
index 8a687354a..95cf2c1db 100644
--- a/test/sequence/vector_make.cpp
+++ b/test/sequence/vector_make.cpp
@@ -8,6 +8,8 @@
 #include <boost/fusion/container/vector/vector.hpp>
 #include <boost/fusion/container/generation/make_vector.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE vector
 #include "make.hpp"
 
diff --git a/test/sequence/vector_misc.cpp b/test/sequence/vector_misc.cpp
index e2b273967..4f2eb3476 100644
--- a/test/sequence/vector_misc.cpp
+++ b/test/sequence/vector_misc.cpp
@@ -9,6 +9,8 @@
 #include <boost/fusion/container/vector/convert.hpp>
 #include <boost/fusion/adapted/mpl.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE vector
 #include "misc.hpp"
 
diff --git a/test/sequence/vector_move.cpp b/test/sequence/vector_move.cpp
index 3e9f0b6a7..b0554cbce 100644
--- a/test/sequence/vector_move.cpp
+++ b/test/sequence/vector_move.cpp
@@ -8,6 +8,8 @@
 #define BOOST_FUSION_DONT_USE_PREPROCESSED_FILES
 #include <boost/fusion/container/vector/vector.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE boost::fusion::vector<std::vector<x>>
 #define FUSION_SEQUENCE2 boost::fusion::vector<std::vector<x>, x>
 
diff --git a/test/sequence/vector_mutate.cpp b/test/sequence/vector_mutate.cpp
index 448bbf768..fb3d071df 100644
--- a/test/sequence/vector_mutate.cpp
+++ b/test/sequence/vector_mutate.cpp
@@ -7,6 +7,8 @@
 ==============================================================================*/
 #include <boost/fusion/container/vector/vector.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE vector
 #include "mutate.hpp"
 
diff --git a/test/sequence/vector_n.cpp b/test/sequence/vector_n.cpp
index 65e1032df..630b294c4 100644
--- a/test/sequence/vector_n.cpp
+++ b/test/sequence/vector_n.cpp
@@ -24,6 +24,7 @@
 #include <boost/fusion/algorithm/transformation/push_back.hpp>
 #include <boost/mpl/vector_c.hpp>
 
+#include "../with_or_without_fallback.hpp"
 
 int
 main()
diff --git a/test/sequence/vector_nest.cpp b/test/sequence/vector_nest.cpp
index 2627b3d7c..211aefed9 100644
--- a/test/sequence/vector_nest.cpp
+++ b/test/sequence/vector_nest.cpp
@@ -7,6 +7,8 @@
 #include <boost/fusion/container/vector/vector.hpp>
 #include <boost/core/lightweight_test.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE boost::fusion::vector
 #include "nest.hpp"
 
diff --git a/test/sequence/vector_tie.cpp b/test/sequence/vector_tie.cpp
index 123bf888e..70a87098e 100644
--- a/test/sequence/vector_tie.cpp
+++ b/test/sequence/vector_tie.cpp
@@ -10,6 +10,8 @@
 #include <boost/fusion/container/generation/ignore.hpp>
 #include <boost/fusion/container/generation/make_vector.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE vector
 #include "tie.hpp"
 
diff --git a/test/sequence/vector_traits.cpp b/test/sequence/vector_traits.cpp
index 470f11e69..82f37bce2 100644
--- a/test/sequence/vector_traits.cpp
+++ b/test/sequence/vector_traits.cpp
@@ -9,6 +9,8 @@
 #include <boost/fusion/container/list.hpp>
 #include <boost/fusion/container/vector.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE boost::fusion::vector
 #define FUSION_ALT_SEQUENCE boost::fusion::list
 #include "traits.hpp"
diff --git a/test/sequence/vector_value_at.cpp b/test/sequence/vector_value_at.cpp
index 191da4cf7..9e8a92da1 100644
--- a/test/sequence/vector_value_at.cpp
+++ b/test/sequence/vector_value_at.cpp
@@ -7,6 +7,8 @@
 ==============================================================================*/
 #include <boost/fusion/container/vector/vector.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE vector
 #include "value_at.hpp"
 
diff --git a/test/sequence/zip_view.cpp b/test/sequence/zip_view.cpp
index 83bfa8798..bdd06635a 100644
--- a/test/sequence/zip_view.cpp
+++ b/test/sequence/zip_view.cpp
@@ -29,6 +29,8 @@
 #include <boost/type_traits/is_same.hpp>
 #include <boost/static_assert.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 int main()
 {
     using namespace boost::fusion;
diff --git a/test/sequence/zip_view2.cpp b/test/sequence/zip_view2.cpp
index b63a27446..ee41f269b 100644
--- a/test/sequence/zip_view2.cpp
+++ b/test/sequence/zip_view2.cpp
@@ -30,6 +30,8 @@
 #include <boost/type_traits/is_same.hpp>
 #include <boost/static_assert.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 int main()
 {
     {
diff --git a/test/sequence/zip_view_ignore.cpp b/test/sequence/zip_view_ignore.cpp
index d22bf70ff..db8bb329b 100644
--- a/test/sequence/zip_view_ignore.cpp
+++ b/test/sequence/zip_view_ignore.cpp
@@ -15,6 +15,8 @@
 #include <boost/mpl/assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 int main()
 {
     using namespace boost::fusion;
diff --git a/test/support/and.cpp b/test/support/and.cpp
index 604a68d74..3694f8120 100644
--- a/test/support/and.cpp
+++ b/test/support/and.cpp
@@ -15,6 +15,8 @@
 #include <boost/mpl/bool.hpp>
 #include <boost/mpl/assert.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 using namespace boost;
 using namespace boost::fusion::detail;
 
diff --git a/test/support/config.cpp b/test/support/config.cpp
new file mode 100644
index 000000000..b69e731d0
--- /dev/null
+++ b/test/support/config.cpp
@@ -0,0 +1,18 @@
+/*=============================================================================
+    Copyright (c) 2021-2023 Denis Mikhailov
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+
+#include <boost/fusion/support/config.hpp>
+
+#include <iostream>
+
+int main() {
+    std::cout << "Platform info:" << '\n'
+        << "BOOST_FUSION_PFR_ENABLE_IMPLICIT_REFLECTION == " << BOOST_FUSION_PFR_ENABLE_IMPLICIT_REFLECTION << '\n'
+        << "BOOST_FUSION_PFR_ENABLED == " << BOOST_FUSION_PFR_ENABLED << '\n'
+        << "__cplusplus == " << __cplusplus << '\n'
+    ;
+}
+
diff --git a/test/support/config_pfr_0.cpp b/test/support/config_pfr_0.cpp
new file mode 100644
index 000000000..dac1ee957
--- /dev/null
+++ b/test/support/config_pfr_0.cpp
@@ -0,0 +1,17 @@
+/*=============================================================================
+    Copyright (c) 2021-2023 Denis Mikhailov
+    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)
+==============================================================================*/
+
+#define BOOST_PFR_ENABLED                       1
+#define BOOST_PFR_ENABLE_IMPLICIT_REFLECTION    0
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/static_assert.hpp>
+
+BOOST_STATIC_ASSERT(BOOST_FUSION_PFR_ENABLED == BOOST_PFR_ENABLED);
+BOOST_STATIC_ASSERT(BOOST_FUSION_PFR_ENABLE_IMPLICIT_REFLECTION == BOOST_PFR_ENABLE_IMPLICIT_REFLECTION);
+
+int main() { }
+
diff --git a/test/support/config_pfr_1.cpp b/test/support/config_pfr_1.cpp
new file mode 100644
index 000000000..a990e33b6
--- /dev/null
+++ b/test/support/config_pfr_1.cpp
@@ -0,0 +1,19 @@
+/*=============================================================================
+    Copyright (c) 2021-2023 Denis Mikhailov
+    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)
+==============================================================================*/
+
+#define BOOST_FUSION_PFR_ENABLED                       0
+#define BOOST_FUSION_PFR_ENABLE_IMPLICIT_REFLECTION    0
+#define BOOST_PFR_ENABLED                              1
+#define BOOST_PFR_ENABLE_IMPLICIT_REFLECTION           1
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/static_assert.hpp>
+
+BOOST_STATIC_ASSERT(BOOST_FUSION_PFR_ENABLED != BOOST_PFR_ENABLED);
+BOOST_STATIC_ASSERT(BOOST_FUSION_PFR_ENABLE_IMPLICIT_REFLECTION != BOOST_PFR_ENABLE_IMPLICIT_REFLECTION);
+
+int main() { }
+
diff --git a/test/support/config_pfr_fail_0.cpp b/test/support/config_pfr_fail_0.cpp
new file mode 100644
index 000000000..18ada07b0
--- /dev/null
+++ b/test/support/config_pfr_fail_0.cpp
@@ -0,0 +1,13 @@
+/*=============================================================================
+    Copyright (c) 2023 Denis Mikhailov
+    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)
+==============================================================================*/
+
+#define BOOST_PFR_ENABLED                                          0
+#define BOOST_FUSION_PFR_ENABLED                                   1
+
+#include <boost/fusion/support/config.hpp>
+
+int main() { }
+
diff --git a/test/support/config_pfr_fail_1.cpp b/test/support/config_pfr_fail_1.cpp
new file mode 100644
index 000000000..d504d11ed
--- /dev/null
+++ b/test/support/config_pfr_fail_1.cpp
@@ -0,0 +1,14 @@
+/*=============================================================================
+    Copyright (c) 2023 Denis Mikhailov
+    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)
+==============================================================================*/
+
+#define BOOST_PFR_ENABLED                                          1
+#define BOOST_PFR_ENABLE_IMPLICIT_REFLECTION                       0
+#define BOOST_FUSION_PFR_ENABLE_IMPLICIT_REFLECTION                1
+
+#include <boost/fusion/support/config.hpp>
+
+int main() { }
+
diff --git a/test/support/config_pfr_fail_2.cpp b/test/support/config_pfr_fail_2.cpp
new file mode 100644
index 000000000..76dc40d16
--- /dev/null
+++ b/test/support/config_pfr_fail_2.cpp
@@ -0,0 +1,13 @@
+/*=============================================================================
+    Copyright (c) 2023 Denis Mikhailov
+    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)
+==============================================================================*/
+
+#define BOOST_FUSION_PFR_ENABLED                                   0
+#define BOOST_FUSION_PFR_ENABLE_IMPLICIT_REFLECTION                1
+
+#include <boost/fusion/support/config.hpp>
+
+int main() { }
+
diff --git a/test/support/index_sequence.cpp b/test/support/index_sequence.cpp
index 019ae4742..8d65519be 100644
--- a/test/support/index_sequence.cpp
+++ b/test/support/index_sequence.cpp
@@ -14,6 +14,8 @@
 #include <boost/mpl/assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 using namespace boost::fusion;
 
 BOOST_MPL_ASSERT((boost::is_same<detail::make_index_sequence<0>::type, detail::index_sequence<> >));
diff --git a/test/support/is_sequence.cpp b/test/support/is_sequence.cpp
index 428f63545..eb7b18fc7 100644
--- a/test/support/is_sequence.cpp
+++ b/test/support/is_sequence.cpp
@@ -7,6 +7,7 @@
 #include <boost/fusion/support/is_sequence.hpp>
 #include <boost/static_assert.hpp>
 
+#include "../with_or_without_fallback.hpp"
 
 // Make sure fusion::is_sequence and fusion::is_native_fusion_sequence can be
 // used with an incomplete type.
diff --git a/test/support/is_view.cpp b/test/support/is_view.cpp
index 068f1a80d..c73865715 100644
--- a/test/support/is_view.cpp
+++ b/test/support/is_view.cpp
@@ -7,6 +7,7 @@
 #include <boost/fusion/support/is_view.hpp>
 #include <boost/static_assert.hpp>
 
+#include "../with_or_without_fallback.hpp"
 
 // Make sure fusion::is_view can be used with non fusion types.
 struct incomplete;
diff --git a/test/support/pair_deque.cpp b/test/support/pair_deque.cpp
index 27da30ec4..ae0295b62 100644
--- a/test/support/pair_deque.cpp
+++ b/test/support/pair_deque.cpp
@@ -6,6 +6,8 @@
 ==============================================================================*/
 #include <boost/fusion/container/deque/deque.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE deque
 #define TEST_TYPE int
 #include "./pair_container.hpp"
diff --git a/test/support/pair_list.cpp b/test/support/pair_list.cpp
index ce478ff68..1cc699198 100644
--- a/test/support/pair_list.cpp
+++ b/test/support/pair_list.cpp
@@ -6,6 +6,8 @@
 ==============================================================================*/
 #include <boost/fusion/container/list/list.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE list
 #define TEST_TYPE int
 #include "./pair_container.hpp"
diff --git a/test/support/pair_map.cpp b/test/support/pair_map.cpp
index d472ba269..8ac5fbe0f 100644
--- a/test/support/pair_map.cpp
+++ b/test/support/pair_map.cpp
@@ -6,6 +6,8 @@
 ==============================================================================*/
 #include <boost/fusion/container/map/map.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE map
 #define TEST_TYPE pair<int,int>
 #include "./pair_container.hpp"
diff --git a/test/support/pair_nest.cpp b/test/support/pair_nest.cpp
index fbc253cbe..bcd3c72db 100644
--- a/test/support/pair_nest.cpp
+++ b/test/support/pair_nest.cpp
@@ -7,6 +7,8 @@
 #include <boost/core/ignore_unused.hpp>
 #include <boost/fusion/support/pair.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 using namespace boost::fusion;
 
 template <typename C>
diff --git a/test/support/pair_set.cpp b/test/support/pair_set.cpp
index b346a8ba5..d1309b488 100644
--- a/test/support/pair_set.cpp
+++ b/test/support/pair_set.cpp
@@ -6,6 +6,8 @@
 ==============================================================================*/
 #include <boost/fusion/container/set/set.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE set
 #define TEST_TYPE int
 #include "./pair_container.hpp"
diff --git a/test/support/pair_vector.cpp b/test/support/pair_vector.cpp
index 62a4f2b55..19677b296 100644
--- a/test/support/pair_vector.cpp
+++ b/test/support/pair_vector.cpp
@@ -6,6 +6,8 @@
 ==============================================================================*/
 #include <boost/fusion/container/vector/vector.hpp>
 
+#include "../with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE vector
 #define TEST_TYPE int
 #include "./pair_container.hpp"
diff --git a/test/support/tag_of.cpp b/test/support/tag_of.cpp
index ee2da10d4..c71c5d1e6 100644
--- a/test/support/tag_of.cpp
+++ b/test/support/tag_of.cpp
@@ -8,6 +8,7 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 
+#include "../with_or_without_fallback.hpp"
 
 // Make sure tag_of can be used with an incomplete type.
 struct incomplete;
diff --git a/test/support/unused.cpp b/test/support/unused.cpp
index 8b9e62602..2d87ed0d8 100644
--- a/test/support/unused.cpp
+++ b/test/support/unused.cpp
@@ -13,6 +13,8 @@
 #include <utility>
 #endif
 
+#include "../with_or_without_fallback.hpp"
+
 struct T { };
 
 void unused_construction()
diff --git a/test/with_or_without_fallback.hpp b/test/with_or_without_fallback.hpp
new file mode 100644
index 000000000..ab2b20c62
--- /dev/null
+++ b/test/with_or_without_fallback.hpp
@@ -0,0 +1,21 @@
+/*=============================================================================
+    Copyright (c) 2023 Denis Mikhailov
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+
+// This header provides ability for regression test of Boost PFR adapter.
+
+#if BOOST_FUSION_USE_TAG_OF_FALLBACK
+
+#include <boost/fusion/adapted.hpp>
+#if !BOOST_FUSION_PFR_ENABLED || !BOOST_FUSION_PFR_ENABLE_IMPLICIT_REFLECTION
+#include "mock_fallback.hpp"
+#endif
+
+#elif BOOST_FUSION_DO_NOT_USE_TAG_OF_FALLBACK
+// just nothing
+#else
+#error Do you need to use tag_of fallback or you do not?
+#endif
+
diff --git a/util/test.jam b/util/test.jam
new file mode 100644
index 000000000..ed12f7445
--- /dev/null
+++ b/util/test.jam
@@ -0,0 +1,90 @@
+# Boost Fusion Library utility test Jamfile
+
+#  (C) Copyright Denis Mikhailov 2023.
+#  Use, modification, and distribution are subject to the 
+#  Boost Software License, Version 1.0. (See accompanying file 
+#  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#
+
+# the file contains Jam rules which are used in both the normal
+# boost test, as well as the fallback test and so other
+# tests.
+
+# import rules for testing conditional on config file variables
+import ../../config/checks/config : requires ;
+
+rule test-bfl-run_with_and_without_fallback ( sources + : args * : input-files * : requirements * : target-name ?
+    : default-build * ) {
+    local tests ;
+    if ! $(target-name)
+    {
+        target-name = $(sources[1]:B) ;
+    }
+    tests += [
+        run
+            $(sources)
+        :   $(args)
+        :   $(input-files)
+        :   <define>BOOST_FUSION_DO_NOT_USE_TAG_OF_FALLBACK=1
+            $(requirements)
+        :   $(target-name)__normal
+        :   $(default-build)
+    ] ;
+    tests += [
+        run
+            $(sources)
+        :   $(args)
+        :   $(input-files)
+        :   <define>BOOST_FUSION_USE_TAG_OF_FALLBACK=1
+            $(requirements)
+        :   $(target-name)__fallback
+        :   $(default-build)
+    ] ;
+    return $(tests) ;
+}
+
+rule test-bfl-compile_with_and_without_fallback ( sources : requirements * : target-name ? ) {
+    local tests ;
+    if ! $(target-name)
+    {
+        target-name = $(sources[1]:B) ;
+    }
+    tests += [
+        compile
+            $(sources)
+        :   <define>BOOST_FUSION_DO_NOT_USE_TAG_OF_FALLBACK=1
+            $(requirements)
+        :   $(target-name)__normal
+    ] ;
+    tests += [
+        compile
+            $(sources)
+        :   <define>BOOST_FUSION_USE_TAG_OF_FALLBACK=1
+            $(requirements)
+        :   $(target-name)__fallback
+    ] ;
+    return $(tests) ;
+}
+
+rule test-bfl-compile_strictly_without_fallback ( sources : requirements * : target-name ? ) {
+    local tests ;
+    if ! $(target-name)
+    {
+        target-name = $(sources[1]:B) ;
+    }
+    tests += [
+        compile
+            $(sources)
+        :   <define>BOOST_FUSION_DO_NOT_USE_TAG_OF_FALLBACK=1
+            $(requirements)
+        :   $(target-name)__normal
+    ] ;
+    tests += [
+        compile-fail
+            $(sources)
+        :   <define>BOOST_FUSION_USE_TAG_OF_FALLBACK=1
+            $(requirements)
+        :   $(target-name)__fallback
+    ] ;
+    return $(tests) ;
+}