passenger 6.0.7 → 6.0.8

data/src/cxx_supportlib/vendor-modified/boost/parameter/are_tagged_arguments.hpp

@@ -0,0 +1,125 @@
+// Copyright Cromwell D. Enage 2018.
+// 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_PARAMETER_ARE_TAGGED_ARGUMENTS_HPP
+#define BOOST_PARAMETER_ARE_TAGGED_ARGUMENTS_HPP
+
+#include <boost/parameter/config.hpp>
+
+#if defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING)
+
+namespace boost { namespace parameter {
+
+    template <typename TaggedArg0, typename ...TaggedArgs>
+    struct are_tagged_arguments;
+}} // namespace boost::parameter
+
+#include <boost/parameter/aux_/is_tagged_argument.hpp>
+
+namespace boost { namespace parameter {
+
+    template <typename TaggedArg0>
+    struct are_tagged_arguments<TaggedArg0>
+      : ::boost::parameter::aux::is_tagged_argument<TaggedArg0>
+    {
+    };
+}} // namespace boost::parameter
+
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/if.hpp>
+
+namespace boost { namespace parameter {
+
+    template <typename TaggedArg0, typename ...TaggedArgs>
+    struct are_tagged_arguments
+      : ::boost::mpl::if_<
+            ::boost::parameter::aux::is_tagged_argument<TaggedArg0>
+          , ::boost::parameter::are_tagged_arguments<TaggedArgs...>
+          , ::boost::mpl::false_
+        >::type
+    {
+    };
+}} // namespace boost::parameter
+
+#else   // !defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING)
+
+#define BOOST_PARAMETER_ARE_TAGGED_ARGUMENTS_END_Z(z, n, false_t) , false_t>
+/**/
+
+#include <boost/parameter/aux_/is_tagged_argument.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/preprocessor/cat.hpp>
+
+#define BOOST_PARAMETER_ARE_TAGGED_ARGUMENTS_BEGIN_Z(z, n, prefix)           \
+    ::boost::mpl::eval_if<                                                   \
+        ::boost::parameter::aux::is_tagged_argument<BOOST_PP_CAT(prefix, n)>,
+/**/
+
+#include <boost/parameter/aux_/void.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/preprocessor/arithmetic/sub.hpp>
+#include <boost/preprocessor/facilities/intercept.hpp>
+#include <boost/preprocessor/repetition/repeat.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
+
+#define BOOST_PARAMETER_ARE_TAGGED_ARGUMENTS_OVERLOADS_Z(z, n, prefix)       \
+    template <BOOST_PP_ENUM_PARAMS_Z(z, n, typename prefix)>                 \
+    struct are_tagged_arguments<                                             \
+        BOOST_PP_ENUM_PARAMS_Z(z, n, prefix)                                 \
+        BOOST_PP_ENUM_TRAILING_PARAMS_Z(                                     \
+            z                                                                \
+          , BOOST_PP_SUB(BOOST_PARAMETER_COMPOSE_MAX_ARITY, n)               \
+          , ::boost::parameter::void_ BOOST_PP_INTERCEPT                     \
+        )                                                                    \
+    > : BOOST_PP_CAT(BOOST_PP_REPEAT_, z)(                                   \
+            n                                                                \
+          , BOOST_PARAMETER_ARE_TAGGED_ARGUMENTS_BEGIN_Z                     \
+          , prefix                                                           \
+        )                                                                    \
+        ::boost::mpl::true_                                                  \
+        BOOST_PP_CAT(BOOST_PP_REPEAT_, z)(                                   \
+            n                                                                \
+          , BOOST_PARAMETER_ARE_TAGGED_ARGUMENTS_END_Z                       \
+          , ::boost::mpl::false_                                             \
+        )::type                                                              \
+    {                                                                        \
+    };
+/**/
+
+#include <boost/preprocessor/arithmetic/inc.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
+
+namespace boost { namespace parameter {
+
+    template <
+        BOOST_PP_ENUM_BINARY_PARAMS(
+            BOOST_PP_INC(BOOST_PARAMETER_COMPOSE_MAX_ARITY)
+          , typename TaggedArg
+          , = ::boost::parameter::void_ BOOST_PP_INTERCEPT
+        )
+    >
+    struct are_tagged_arguments;
+}} // namespace boost::parameter
+
+#include <boost/preprocessor/repetition/repeat_from_to.hpp>
+
+namespace boost { namespace parameter {
+
+    BOOST_PP_REPEAT_FROM_TO(
+        1
+      , BOOST_PP_INC(BOOST_PARAMETER_COMPOSE_MAX_ARITY)
+      , BOOST_PARAMETER_ARE_TAGGED_ARGUMENTS_OVERLOADS_Z
+      , TaggedArg
+    )
+}} // namespace boost::parameter
+
+#undef BOOST_PARAMETER_ARE_TAGGED_ARGUMENTS_OVERLOADS_Z
+#undef BOOST_PARAMETER_ARE_TAGGED_ARGUMENTS_BEGIN_Z
+#undef BOOST_PARAMETER_ARE_TAGGED_ARGUMENTS_END_Z
+
+#endif  // BOOST_PARAMETER_HAS_PERFECT_FORWARDING
+#endif  // include guard
+

data/src/cxx_supportlib/vendor-modified/boost/parameter/aux_/always_true_predicate.hpp

@@ -0,0 +1,42 @@
+// Copyright Cromwell D. Enage 2019.
+// 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_PARAMETER_AUX_ALWAYS_TRUE_PREDICATE_HPP
+#define BOOST_PARAMETER_AUX_ALWAYS_TRUE_PREDICATE_HPP
+
+#include <boost/parameter/config.hpp>
+#include <boost/mpl/bool.hpp>
+
+#if defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING)
+#if defined(BOOST_PARAMETER_CAN_USE_MP11)
+#include <boost/mp11/integral.hpp>
+#endif
+#else
+#include <boost/mpl/always.hpp>
+#endif
+
+namespace boost { namespace parameter { namespace aux {
+
+#if defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING)
+    struct always_true_predicate
+    {
+        template <typename ...>
+        struct apply
+        {
+            typedef ::boost::mpl::true_ type;
+        };
+
+#if defined(BOOST_PARAMETER_CAN_USE_MP11)
+        template <typename ...>
+        using fn = ::boost::mp11::mp_true;
+#endif
+    };
+#else
+    typedef ::boost::mpl::always< ::boost::mpl::true_> always_true_predicate;
+#endif  // BOOST_NO_CXX11_VARIADIC_TEMPLATES
+}}} // namespace boost::parameter::aux
+
+#endif  // include guard
+

data/src/cxx_supportlib/vendor-modified/boost/parameter/aux_/arg_list.hpp

@@ -1,437 +1,1331 @@
-// Copyright Daniel Wallin, David Abrahams 2005. Use, modification and
-// distribution is subject to the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
+// Copyright Daniel Wallin, David Abrahams 2005.
+// Copyright Cromwell D. Enage 2017.
+// 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 ARG_LIST_050329_HPP
-#define ARG_LIST_050329_HPP
+#ifndef BOOST_PARAMETER_AUX_ARG_LIST_HPP
+#define BOOST_PARAMETER_AUX_ARG_LIST_HPP
+
+namespace boost { namespace parameter { namespace aux {
+
+    //
+    // Structures used to build the tuple of actual arguments.  The tuple is a
+    // nested cons-style list of arg_list specializations terminated by an
+    // empty_arg_list.
+    //
+    // Each specialization of arg_list is derived from its successor in the
+    // list type.  This feature is used along with using declarations to build
+    // member function overload sets that can match against keywords.
+    //
+
+    // MPL sequence support
+    struct arg_list_tag;
+
+    template <typename T>
+    struct get_reference
+    {
+        typedef typename T::reference type;
+    };
+}}} // namespace boost::parameter::aux
+
+#include <boost/parameter/config.hpp>
+
+#if defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING)
+
+namespace boost { namespace parameter { namespace aux {
+
+    struct value_type_is_void
+    {
+    };
+
+    struct value_type_is_not_void
+    {
+    };
+}}} // namespace boost::parameter::aux
+
+#endif
 
 #include <boost/parameter/aux_/void.hpp>
+#include <boost/parameter/aux_/yesno.hpp>
 #include <boost/parameter/aux_/result_of0.hpp>
 #include <boost/parameter/aux_/default.hpp>
-#include <boost/parameter/aux_/parameter_requirements.hpp>
+
+#if defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING)
+#include <utility>
+
+#if defined(BOOST_PARAMETER_CAN_USE_MP11)
+#include <boost/mp11/integral.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/utility.hpp>
+#include <type_traits>
+#endif
+
+namespace boost { namespace parameter { namespace aux {
+
+    // Terminates arg_list<> and represents an empty list.  Since this is just
+    // the terminating case, you might want to look at arg_list first to get a
+    // feel for what's really happening here.
+    struct empty_arg_list
+    {
+        struct tagged_arg
+        {
+            typedef ::boost::parameter::void_ value_type;
+        };
+
+        // Variadic constructor also serves as default constructor.
+        template <typename ...Args>
+        inline BOOST_CONSTEXPR empty_arg_list(Args&&...)
+        {
+        }
+
+        // A metafunction class that, given a keyword and a default type,
+        // returns the appropriate result type for a keyword lookup given
+        // that default.
+        struct binding
+        {
+            template <typename KW, typename Default, typename Reference>
+            struct apply
+            {
+                typedef Default type;
+            };
+
+#if defined(BOOST_PARAMETER_CAN_USE_MP11)
+            template <typename KW, typename Default, typename Reference>
+            using fn = Default;
+#endif
+        };
+
+        // Terminator for has_key, indicating that the keyword is unique.
+        template <typename KW>
+        static ::boost::parameter::aux::no_tag has_key(KW*);
+
+        // If either of these operators are called, it means there is no
+        // argument in the list that matches the supplied keyword.  Just
+        // return the default value.
+        template <typename K, typename Default>
+        inline BOOST_CONSTEXPR Default&
+            operator[](::boost::parameter::aux::default_<K,Default> x) const
+        {
+            return x.value;
+        }
+
+        template <typename K, typename Default>
+        inline BOOST_CONSTEXPR Default&&
+            operator[](::boost::parameter::aux::default_r_<K,Default> x) const
+        {
+            return ::std::forward<Default>(x.value);
+        }
+
+        // If this operator is called, it means there is no argument in the
+        // list that matches the supplied keyword.  Just evaluate and return
+        // the default value.
+        template <typename K, typename F>
+        inline BOOST_CONSTEXPR
+        typename ::boost::parameter::aux::result_of0<F>::type
+            operator[](BOOST_PARAMETER_lazy_default_fallback<K,F> x) const
+        {
+            return x.compute_default();
+        }
+
+        // No argument corresponding to ParameterRequirements::key_type
+        // was found if we match this overload, so unless that parameter
+        // has a default, we indicate that the actual arguments don't
+        // match the function's requirements.
+        template <typename ParameterRequirements, typename ArgPack>
+        static typename ParameterRequirements::has_default
+            satisfies(ParameterRequirements*, ArgPack*);
+
+        // MPL sequence support
+        typedef ::boost::parameter::aux::empty_arg_list type; // convenience
+        // For dispatching to sequence intrinsics
+        typedef ::boost::parameter::aux::arg_list_tag tag;
+    };
+}}} // namespace boost::parameter::aux
+
+#include <boost/parameter/aux_/preprocessor/nullptr.hpp>
 #include <boost/parameter/aux_/yesno.hpp>
 #include <boost/parameter/aux_/is_maybe.hpp>
-#include <boost/parameter/config.hpp>
-
-#include <boost/mpl/apply.hpp>
+#include <boost/parameter/aux_/tagged_argument_fwd.hpp>
+#include <boost/parameter/aux_/parameter_requirements.hpp>
+#include <boost/parameter/aux_/augment_predicate.hpp>
+#include <boost/parameter/keyword_fwd.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/apply_wrap.hpp>
 #include <boost/mpl/assert.hpp>
-#include <boost/mpl/begin.hpp>
-#include <boost/mpl/end.hpp>
-#include <boost/mpl/iterator_tags.hpp>
-
-#include <boost/type_traits/add_reference.hpp>
 #include <boost/type_traits/is_same.hpp>
+#include <boost/core/enable_if.hpp>
+
+namespace boost { namespace parameter { namespace aux {
+
+    // A tuple of tagged arguments, terminated with empty_arg_list.  Every
+    // TaggedArg is an instance of tagged_argument<> or
+    // tagged_argument_rref<>.
+    template <
+        typename TaggedArg
+      , typename Next = ::boost::parameter::aux::empty_arg_list
+#if defined(BOOST_PARAMETER_CAN_USE_MP11)
+      , typename EmitsErrors = ::boost::mp11::mp_true
+#else
+      , typename EmitsErrors = ::boost::mpl::true_
+#endif
+    >
+    class arg_list : public Next
+    {
+#if defined(BOOST_PARAMETER_CAN_USE_MP11)
+        using _holds_maybe = typename ::boost::parameter::aux
+        ::is_maybe<typename TaggedArg::value_type>::type;
+#else
+        typedef typename ::boost::parameter::aux
+        ::is_maybe<typename TaggedArg::value_type>::type _holds_maybe;
+#endif
+
+        TaggedArg arg;      // Stores the argument
+
+     public:
+        typedef TaggedArg tagged_arg;
+        typedef ::boost::parameter::aux::arg_list<TaggedArg,Next> self;
+        typedef typename TaggedArg::key_type key_type;
+
+#if defined(BOOST_PARAMETER_CAN_USE_MP11)
+        using reference = typename ::boost::mp11::mp_if<
+            _holds_maybe
+          , ::boost::parameter::aux
+            ::get_reference<typename TaggedArg::value_type>
+          , ::boost::parameter::aux::get_reference<TaggedArg>
+        >::type;
+
+        using value_type = ::boost::mp11
+        ::mp_if<_holds_maybe,reference,typename TaggedArg::value_type>;
+#else   // !defined(BOOST_PARAMETER_CAN_USE_MP11)
+        typedef typename ::boost::mpl::eval_if<
+            _holds_maybe
+          , ::boost::parameter::aux
+            ::get_reference<typename TaggedArg::value_type>
+          , ::boost::parameter::aux::get_reference<TaggedArg>
+        >::type reference;
+
+        typedef typename ::boost::mpl::if_<
+            _holds_maybe
+          , reference
+          , typename TaggedArg::value_type
+        >::type value_type;
+#endif  // BOOST_PARAMETER_CAN_USE_MP11
+
+        // Create a new list by prepending arg to a copy of tail.  Used when
+        // incrementally building this structure with the comma operator.
+        inline BOOST_CONSTEXPR arg_list(
+            TaggedArg const& head
+          , Next const& tail
+        ) : Next(tail), arg(head)
+        {
+        }
+
+        // Store the arguments in successive nodes of this list.
+        // Use tag dispatching to determine whether to forward all arguments
+        // to the Next constructor, or store the first argument and forward
+        // the rest. -- Cromwell D. Enage
+        template <typename A0>
+        inline BOOST_CONSTEXPR arg_list(
+            ::boost::parameter::aux::value_type_is_not_void
+          , A0&& a0
+        ) : Next(
+#if defined(BOOST_PARAMETER_CAN_USE_MP11)
+                ::boost::mp11::mp_if<
+                    ::std::is_same<
+#else
+                typename ::boost::mpl::if_<
+                    ::boost::is_same<
+#endif
+                        typename Next::tagged_arg::value_type
+                      , ::boost::parameter::void_
+                    >
+                  , ::boost::parameter::aux::value_type_is_void
+                  , ::boost::parameter::aux::value_type_is_not_void
+#if defined(BOOST_PARAMETER_CAN_USE_MP11)
+                >()
+#else
+                >::type()
+#endif
+            )
+          , arg(::std::forward<A0>(a0))
+        {
+        }
+
+        template <typename ...Args>
+        inline BOOST_CONSTEXPR arg_list(
+            ::boost::parameter::aux::value_type_is_void
+          , Args&&... args
+        ) : Next(
+#if defined(BOOST_PARAMETER_CAN_USE_MP11)
+                ::boost::mp11::mp_if<
+                    ::std::is_same<
+#else
+                typename ::boost::mpl::if_<
+                    ::boost::is_same<
+#endif
+                        typename Next::tagged_arg::value_type
+                      , ::boost::parameter::void_
+                    >
+                  , ::boost::parameter::aux::value_type_is_void
+                  , ::boost::parameter::aux::value_type_is_not_void
+#if defined(BOOST_PARAMETER_CAN_USE_MP11)
+                >()
+#else
+                >::type()
+#endif
+              , ::std::forward<Args>(args)...
+            )
+          , arg(::boost::parameter::aux::void_reference())
+        {
+        }
+
+        template <typename A0, typename A1, typename ...Args>
+        inline BOOST_CONSTEXPR arg_list(
+            ::boost::parameter::aux::value_type_is_not_void
+          , A0&& a0
+          , A1&& a1
+          , Args&&... args
+        ) : Next(
+#if defined(BOOST_PARAMETER_CAN_USE_MP11)
+                ::boost::mp11::mp_if<
+                    ::std::is_same<
+#else
+                typename ::boost::mpl::if_<
+                    ::boost::is_same<
+#endif
+                        typename Next::tagged_arg::value_type
+                      , ::boost::parameter::void_
+                    >
+                  , ::boost::parameter::aux::value_type_is_void
+                  , ::boost::parameter::aux::value_type_is_not_void
+#if defined(BOOST_PARAMETER_CAN_USE_MP11)
+                >()
+#else
+                >::type()
+#endif
+              , ::std::forward<A1>(a1)
+              , ::std::forward<Args>(args)...
+            )
+          , arg(::std::forward<A0>(a0))
+        {
+        }
+
+        // A metafunction class that, given a keyword and a default type,
+        // returns the appropriate result type for a keyword lookup given
+        // that default.
+        struct binding
+        {
+            typedef typename Next::binding next_binding;
+
+            template <typename KW, typename Default, typename Reference>
+            struct apply
+            {
+                typedef typename ::boost::mpl::eval_if<
+                    ::boost::is_same<KW,key_type>
+                  , ::boost::mpl::if_<Reference,reference,value_type>
+                  , ::boost::mpl
+                    ::apply_wrap3<next_binding,KW,Default,Reference>
+                >::type type;
+            };
+
+#if defined(BOOST_PARAMETER_CAN_USE_MP11)
+            template <typename KW, typename Default, typename Reference>
+            using fn = ::boost::mp11::mp_if<
+                ::std::is_same<KW,key_type>
+              , ::boost::mp11::mp_if<Reference,reference,value_type>
+              , ::boost::mp11::mp_apply_q<
+                    next_binding
+                  , ::boost::mp11::mp_list<KW,Default,Reference>
+                >
+            >;
+#endif
+        };
+
+        // Overload for key_type, so the assert below will fire
+        // if the same keyword is used again.
+        static ::boost::parameter::aux::yes_tag has_key(key_type*);
+        using Next::has_key;
+
+     private:
+#if defined(BOOST_PARAMETER_CAN_USE_MP11)
+        using _has_unique_key = ::boost::mp11::mp_bool<
+#else
+        typedef ::boost::mpl::bool_<
+#endif
+            sizeof(
+                Next::has_key(
+                    static_cast<key_type*>(BOOST_PARAMETER_AUX_PP_NULLPTR)
+                )
+            ) == sizeof(::boost::parameter::aux::no_tag)
+#if defined(BOOST_PARAMETER_CAN_USE_MP11)
+        >;
+#else
+        > _has_unique_key;
+#endif
+
+#if defined(BOOST_PARAMETER_CAN_USE_MP11)
+        static_assert(
+            !(EmitsErrors::value) || (_has_unique_key::value)
+          , "duplicate keyword"
+        );
+#else
+        BOOST_MPL_ASSERT_MSG(
+            !(EmitsErrors::value) || (_has_unique_key::value)
+          , duplicate_keyword
+          , (key_type)
+        );
+#endif
+
+        //
+        // Begin implementation of indexing operators
+        // for looking up specific arguments by name.
+        //
+
+        // Helpers that handle the case when TaggedArg is empty<T>.
+        template <typename D>
+        inline BOOST_CONSTEXPR reference
+#if defined(BOOST_PARAMETER_CAN_USE_MP11)
+            get_default(D const&, ::boost::mp11::mp_false) const
+#else
+            get_default(D const&, ::boost::mpl::false_) const
+#endif
+        {
+            return this->arg.get_value();
+        }
+
+        template <typename D>
+        inline BOOST_CONSTEXPR reference
+#if defined(BOOST_PARAMETER_CAN_USE_MP11)
+            get_default(D const& d, ::boost::mp11::mp_true) const
+#else
+            get_default(D const& d, ::boost::mpl::true_) const
+#endif
+        {
+            return (
+                this->arg.get_value()
+              ? this->arg.get_value().get()
+              : this->arg.get_value().construct(d.value)
+            );
+        }
+
+     public:
+        inline BOOST_CONSTEXPR reference
+            operator[](::boost::parameter::keyword<key_type> const&) const
+        {
+#if !defined(BOOST_NO_CXX14_CONSTEXPR)
+#if defined(BOOST_PARAMETER_CAN_USE_MP11)
+            static_assert(!_holds_maybe::value, "must not hold maybe");
+#elif !( \
+        BOOST_WORKAROUND(BOOST_GCC, >= 40700) && \
+        BOOST_WORKAROUND(BOOST_GCC, < 40900) \
+    ) && !BOOST_WORKAROUND(BOOST_GCC, >= 50000) && \
+    !BOOST_WORKAROUND(BOOST_MSVC, < 1910)
+            BOOST_MPL_ASSERT_NOT((_holds_maybe));
+#endif
+#endif
+            return this->arg.get_value();
+        }
+
+        template <typename Default>
+        inline BOOST_CONSTEXPR reference
+            operator[](
+                ::boost::parameter::aux::default_<key_type,Default> const& d
+            ) const
+        {
+            return this->get_default(d, _holds_maybe());
+        }
+
+        template <typename Default>
+        inline BOOST_CONSTEXPR reference
+            operator[](
+                ::boost::parameter::aux::default_r_<key_type,Default> const& d
+            ) const
+        {
+            return this->get_default(d, _holds_maybe());
+        }
+
+        template <typename Default>
+        inline BOOST_CONSTEXPR reference
+            operator[](
+                BOOST_PARAMETER_lazy_default_fallback<key_type,Default> const&
+            ) const
+        {
+#if !defined(BOOST_NO_CXX14_CONSTEXPR)
+#if defined(BOOST_PARAMETER_CAN_USE_MP11)
+            static_assert(!_holds_maybe::value, "must not hold maybe");
+#elif !( \
+        BOOST_WORKAROUND(BOOST_GCC, >= 40700) && \
+        BOOST_WORKAROUND(BOOST_GCC, < 40900) \
+    ) && !BOOST_WORKAROUND(BOOST_GCC, >= 50000) && \
+    !BOOST_WORKAROUND(BOOST_MSVC, < 1910)
+            BOOST_MPL_ASSERT_NOT((_holds_maybe));
+#endif
+#endif
+            return this->arg.get_value();
+        }
+
+        // Builds an overload set including operator[]s defined
+        // in base classes.
+        using Next::operator[];
+
+        //
+        // End of indexing support
+        //
+
+        // For parameter_requirements matching this node's key_type, return
+        // a bool constant wrapper indicating whether the requirements are
+        // satisfied by TaggedArg.  Used only for compile-time computation
+        // and never really called, so a declaration is enough.
+        template <typename HasDefault, typename Predicate, typename ArgPack>
+        static typename ::boost::lazy_enable_if<
+#if defined(BOOST_PARAMETER_CAN_USE_MP11)
+            ::boost::mp11::mp_if<
+                EmitsErrors
+              , ::boost::mp11::mp_true
+              , _has_unique_key
+            >
+          , ::boost::parameter::aux::augment_predicate_mp11<
+#else
+            typename ::boost::mpl::if_<
+                EmitsErrors
+              , ::boost::mpl::true_
+              , _has_unique_key
+            >::type
+          , ::boost::parameter::aux::augment_predicate<
+#endif
+                Predicate
+              , reference
+              , key_type
+              , value_type
+              , ArgPack
+            >
+        >::type
+            satisfies(
+                ::boost::parameter::aux::parameter_requirements<
+                    key_type
+                  , Predicate
+                  , HasDefault
+                >*
+              , ArgPack*
+            );
+
+        // Builds an overload set including satisfies functions defined
+        // in base classes.
+        using Next::satisfies;
+
+        // Comma operator to compose argument list without using parameters<>.
+        // Useful for argument lists with undetermined length.
+        template <typename KW, typename T2>
+        inline BOOST_CONSTEXPR ::boost::parameter::aux::arg_list<
+            ::boost::parameter::aux::tagged_argument<KW,T2>
+          , self
+        >
+            operator,(
+                ::boost::parameter::aux::tagged_argument<KW,T2> const& x
+            ) const
+        {
+            return ::boost::parameter::aux::arg_list<
+                ::boost::parameter::aux::tagged_argument<KW,T2>
+              , self
+            >(x, *this);
+        }
+
+        template <typename KW, typename T2>
+        inline BOOST_CONSTEXPR ::boost::parameter::aux::arg_list<
+            ::boost::parameter::aux::tagged_argument_rref<KW,T2>
+          , self
+        >
+            operator,(
+                ::boost::parameter::aux::tagged_argument_rref<KW,T2> const& x
+            ) const
+        {
+            return ::boost::parameter::aux::arg_list<
+                ::boost::parameter::aux::tagged_argument_rref<KW,T2>
+              , self
+            >(x, *this);
+        }
+
+        // MPL sequence support
+        typedef self type;        // Convenience for users
+        typedef Next tail_type;   // For the benefit of iterators
+        // For dispatching to sequence intrinsics
+        typedef ::boost::parameter::aux::arg_list_tag tag;
+    };
+}}} // namespace boost::parameter::aux
+
+#else   // !defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING)
+
 #include <boost/preprocessor/repetition/enum_params.hpp>
-#include <boost/preprocessor/repetition/enum_binary_params.hpp>
 #include <boost/preprocessor/facilities/intercept.hpp>
 
-namespace boost { namespace parameter {
+namespace boost { namespace parameter { namespace aux {
 
-// Forward declaration for aux::arg_list, below.
-template<class T> struct keyword;
+    // Terminates arg_list<> and represents an empty list.  Since this is just
+    // the terminating case, you might want to look at arg_list first to get a
+    // feel for what's really happening here.
+    struct empty_arg_list
+    {
+        inline BOOST_CONSTEXPR empty_arg_list()
+        {
+        }
+
+        // Constructor taking BOOST_PARAMETER_COMPOSE_MAX_ARITY empty_arg_list
+        // arguments; this makes initialization.
+        inline BOOST_CONSTEXPR empty_arg_list(
+            BOOST_PP_ENUM_PARAMS(
+                BOOST_PARAMETER_COMPOSE_MAX_ARITY
+              , ::boost::parameter::void_ BOOST_PP_INTERCEPT
+            )
+        )
+        {
+        }
 
-namespace aux {
+        // A metafunction class that, given a keyword and a default type,
+        // returns the appropriate result type for a keyword lookup given
+        // that default.
+        struct binding
+        {
+            template <typename KW, typename Default, typename Reference>
+            struct apply
+            {
+                typedef Default type;
+            };
+        };
 
-// Tag type passed to MPL lambda.
-struct lambda_tag;
+        // Terminator for has_key, indicating that the keyword is unique.
+        template <typename KW>
+        static ::boost::parameter::aux::no_tag has_key(KW*);
 
-//
-// Structures used to build the tuple of actual arguments.  The
-// tuple is a nested cons-style list of arg_list specializations
-// terminated by an empty_arg_list.
-//
-// Each specialization of arg_list is derived from its successor in
-// the list type.  This feature is used along with using
-// declarations to build member function overload sets that can
-// match against keywords.
-//
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+        // The overload set technique doesn't work with these older compilers,
+        // so they need some explicit handholding.
 
-// MPL sequence support
-struct arg_list_tag;
-
-// Terminates arg_list<> and represents an empty list.  Since this
-// is just the terminating case you might want to look at arg_list
-// first, to get a feel for what's really happening here.
-
-struct empty_arg_list
-{
-    empty_arg_list() {}
-
-    // Constructor taking BOOST_PARAMETER_MAX_ARITY empty_arg_list
-    // arguments; this makes initialization
-    empty_arg_list(
-        BOOST_PP_ENUM_PARAMS(
-            BOOST_PARAMETER_MAX_ARITY, void_ BOOST_PP_INTERCEPT
-        ))
-    {}
-
-    // A metafunction class that, given a keyword and a default
-    // type, returns the appropriate result type for a keyword
-    // lookup given that default
-    struct binding
-    {
-        template<class KW, class Default, class Reference>
-        struct apply
+        // A metafunction class that, given a keyword, returns the type of the
+        // base sublist whose get() function can produce the value for that key.
+        struct key_owner
         {
-            typedef Default type;
+            template <typename KW>
+            struct apply
+            {
+                typedef ::boost::parameter::aux::empty_arg_list type;
+            };
         };
+#endif  // Borland workarounds needed
+
+        // If either of these operators are called, it means there is no
+        // argument in the list that matches the supplied keyword.  Just
+        // return the default value.
+        template <typename K, typename Default>
+        inline BOOST_CONSTEXPR Default&
+            operator[](::boost::parameter::aux::default_<K,Default> x) const
+        {
+            return x.value;
+        }
+
+        // If this operator is called, it means there is no argument in the
+        // list that matches the supplied keyword.  Just evaluate and return
+        // the default value.
+        template <typename K, typename F>
+        inline BOOST_CONSTEXPR
+        typename ::boost::parameter::aux::result_of0<F>::type
+            operator[](BOOST_PARAMETER_lazy_default_fallback<K,F> x) const
+        {
+            return x.compute_default();
+        }
+
+        // No argument corresponding to ParameterRequirements::key_type
+        // was found if we match this overload, so unless that parameter
+        // has a default, we indicate that the actual arguments don't
+        // match the function's requirements.
+        template <typename ParameterRequirements, typename ArgPack>
+        static typename ParameterRequirements::has_default
+            satisfies(ParameterRequirements*, ArgPack*);
+
+        // MPL sequence support
+        typedef ::boost::parameter::aux::empty_arg_list type; // convenience
+        // For dispatching to sequence intrinsics
+        typedef ::boost::parameter::aux::arg_list_tag tag;
     };
+}}} // namespace boost::parameter::aux
 
-    // Terminator for has_key, indicating that the keyword is unique
-    template <class KW>
-    static no_tag has_key(KW*);
+#include <boost/parameter/aux_/yesno.hpp>
+#include <boost/parameter/aux_/is_maybe.hpp>
+#include <boost/parameter/aux_/tagged_argument_fwd.hpp>
+#include <boost/parameter/aux_/parameter_requirements.hpp>
+#include <boost/parameter/aux_/augment_predicate.hpp>
+#include <boost/parameter/keyword_fwd.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/apply_wrap.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
+#include <boost/preprocessor/repetition/enum_shifted_params.hpp>
 
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+#if !defined(BOOST_NO_SFINAE) && !BOOST_WORKAROUND(BOOST_MSVC, < 1800)
+#include <boost/core/enable_if.hpp>
+#endif
+
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+#include <boost/parameter/aux_/preprocessor/nullptr.hpp>
+#endif
 
-    // The overload set technique doesn't work with these older
-    // compilers, so they need some explicit handholding.
+namespace boost { namespace parameter { namespace aux {
 
-    // A metafunction class that, given a keyword, returns the type
-    // of the base sublist whose get() function can produce the
-    // value for that key
-    struct key_owner
+    // A tuple of tagged arguments, terminated with empty_arg_list.  Every
+    // TaggedArg is an instance of tagged_argument<>.
+    template <
+        typename TaggedArg
+      , typename Next = ::boost::parameter::aux::empty_arg_list
+      , typename EmitsErrors = ::boost::mpl::true_
+    >
+    class arg_list : public Next
     {
-        template<class KW>
-        struct apply
+        typedef typename ::boost::parameter::aux
+        ::is_maybe<typename TaggedArg::value_type>::type _holds_maybe;
+
+        TaggedArg arg;      // Stores the argument
+
+     public:
+        typedef TaggedArg tagged_arg;
+        typedef ::boost::parameter::aux::arg_list<TaggedArg,Next> self;
+        typedef typename TaggedArg::key_type key_type;
+
+        typedef typename ::boost::mpl::eval_if<
+            _holds_maybe
+          , ::boost::parameter::aux
+            ::get_reference<typename TaggedArg::value_type>
+          , ::boost::parameter::aux::get_reference<TaggedArg>
+        >::type reference;
+
+        typedef typename ::boost::mpl::if_<
+            _holds_maybe
+          , reference
+          , typename TaggedArg::value_type
+        >::type value_type;
+
+        // Create a new list by prepending arg to a copy of tail.  Used when
+        // incrementally building this structure with the comma operator.
+        inline BOOST_CONSTEXPR arg_list(
+            TaggedArg const& head
+          , Next const& tail
+        ) : Next(tail), arg(head)
+        {
+        }
+
+        // Store the arguments in successive nodes of this list.
+        template <
+            // typename A0, typename A1, ...
+            BOOST_PP_ENUM_PARAMS(
+                BOOST_PARAMETER_COMPOSE_MAX_ARITY
+              , typename A
+            )
+        >
+        inline BOOST_CONSTEXPR arg_list(
+            // A0& a0, A1& a1, ...
+            BOOST_PP_ENUM_BINARY_PARAMS(
+                BOOST_PARAMETER_COMPOSE_MAX_ARITY
+              , A
+              , & a
+            )
+        ) : Next(
+                // a1, a2, ...
+                BOOST_PP_ENUM_SHIFTED_PARAMS(
+                    BOOST_PARAMETER_COMPOSE_MAX_ARITY
+                  , a
+                )
+              , ::boost::parameter::aux::void_reference()
+            )
+          , arg(a0)
+        {
+        }
+
+        // A metafunction class that, given a keyword and a default type,
+        // returns the appropriate result type for a keyword lookup given
+        // that default.
+        struct binding
+        {
+            typedef typename Next::binding next_binding;
+
+            template <typename KW, typename Default, typename Reference>
+            struct apply
+            {
+                typedef typename ::boost::mpl::eval_if<
+                    ::boost::is_same<KW,key_type>
+                  , ::boost::mpl::if_<Reference,reference,value_type>
+                  , ::boost::mpl::apply_wrap3<
+                        next_binding
+                      , KW
+                      , Default
+                      , Reference
+                    >
+                >::type type;
+            };
+        };
+
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+        // Overload for key_type, so the assert below will fire
+        // if the same keyword is used again.
+        static ::boost::parameter::aux::yes_tag has_key(key_type*);
+        using Next::has_key;
+
+     private:
+#if defined(BOOST_NO_SFINAE) || BOOST_WORKAROUND(BOOST_MSVC, < 1800)
+        BOOST_MPL_ASSERT_MSG(
+            sizeof(
+                Next::has_key(
+                    static_cast<key_type*>(BOOST_PARAMETER_AUX_PP_NULLPTR)
+                )
+            ) == sizeof(::boost::parameter::aux::no_tag)
+          , duplicate_keyword
+          , (key_type)
+        );
+#else
+        typedef ::boost::mpl::bool_<
+            sizeof(
+                Next::has_key(
+                    static_cast<key_type*>(BOOST_PARAMETER_AUX_PP_NULLPTR)
+                )
+            ) == sizeof(::boost::parameter::aux::no_tag)
+        > _has_unique_key;
+
+        BOOST_MPL_ASSERT_MSG(
+            !(EmitsErrors::value) || (_has_unique_key::value)
+          , duplicate_keyword
+          , (key_type)
+        );
+#endif  // SFINAE/MSVC workarounds needed
+#endif  // Borland workarounds not needed
+
+     private:
+        //
+        // Begin implementation of indexing operators
+        // for looking up specific arguments by name.
+        //
+
+        // Helpers that handle the case when TaggedArg is empty<T>.
+        template <typename D>
+        inline BOOST_CONSTEXPR reference
+            get_default(D const&, ::boost::mpl::false_) const
+        {
+            return this->arg.get_value();
+        }
+
+        template <typename D>
+        inline BOOST_CONSTEXPR reference
+            get_default(D const& d, ::boost::mpl::true_) const
+        {
+            return (
+                this->arg.get_value()
+              ? this->arg.get_value().get()
+              : this->arg.get_value().construct(d.value)
+            );
+        }
+
+     public:
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+        // These older compilers don't support the overload set creation
+        // idiom well, so we need to do all the return type calculation
+        // for the compiler and dispatch through an outer function template.
+
+        // A metafunction class that, given a keyword, returns the base
+        // sublist whose get() function can produce the value for that key.
+        struct key_owner
         {
-            typedef empty_arg_list type;
+            typedef typename Next::key_owner next_key_owner;
+
+            template <typename KW>
+            struct apply
+            {
+                typedef typename ::boost::mpl::eval_if<
+                    ::boost::is_same<KW,key_type>
+                  , ::boost::mpl::identity<
+                        ::boost::parameter::aux::arg_list<TaggedArg,Next>
+                    >
+                  , ::boost::mpl::apply_wrap1<next_key_owner,KW>
+                >::type type;
+            };
         };
+
+        // Outer indexing operators that dispatch to the right node's
+        // get() function.
+        template <typename KW>
+        inline BOOST_CONSTEXPR typename ::boost::mpl::apply_wrap3<
+            binding
+          , KW
+          , ::boost::parameter::void_
+          , ::boost::mpl::true_
+        >::type
+            operator[](::boost::parameter::keyword<KW> const& x) const
+        {
+            typename ::boost::mpl::apply_wrap1<key_owner,KW>::type const&
+                sublist = *this;
+            return sublist.get(x);
+        }
+
+        template <typename KW, typename Default>
+        inline BOOST_CONSTEXPR typename ::boost::mpl::apply_wrap3<
+            binding
+          , KW
+          , Default&
+          , ::boost::mpl::true_
+        >::type
+            operator[](
+                ::boost::parameter::aux::default_<KW,Default> const& x
+            ) const
+        {
+            typename ::boost::mpl::apply_wrap1<key_owner,KW>::type const&
+                sublist = *this;
+            return sublist.get(x);
+        }
+
+        template <typename KW, typename F>
+        inline BOOST_CONSTEXPR typename ::boost::mpl::apply_wrap3<
+            binding
+          , KW
+          , typename ::boost::parameter::aux::result_of0<F>::type
+          , ::boost::mpl::true_
+        >::type
+            operator[](
+                BOOST_PARAMETER_lazy_default_fallback<KW,F> const& x
+            ) const
+        {
+            typename ::boost::mpl::apply_wrap1<key_owner,KW>::type const&
+                sublist = *this;
+            return sublist.get(x);
+        }
+
+        // These just return the stored value; when empty_arg_list is reached,
+        // indicating no matching argument was passed, the default is
+        // returned, or if no default_ or lazy_default was passed, compilation
+        // fails.
+        inline BOOST_CONSTEXPR reference
+            get(::boost::parameter::keyword<key_type> const&) const
+        {
+            BOOST_MPL_ASSERT_NOT((_holds_maybe));
+            return this->arg.get_value();
+        }
+
+        template <typename Default>
+        inline BOOST_CONSTEXPR reference
+            get(
+                ::boost::parameter::aux::default_<key_type,Default> const& d
+            ) const
+        {
+            return this->get_default(d, _holds_maybe());
+        }
+
+        template <typename Default>
+        inline BOOST_CONSTEXPR reference
+            get(
+                BOOST_PARAMETER_lazy_default_fallback<key_type,Default> const&
+            ) const
+        {
+            return this->arg.get_value();
+        }
+#else   // !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+        inline BOOST_CONSTEXPR reference
+            operator[](::boost::parameter::keyword<key_type> const&) const
+        {
+            BOOST_MPL_ASSERT_NOT((_holds_maybe));
+            return this->arg.get_value();
+        }
+
+        template <typename Default>
+        inline BOOST_CONSTEXPR reference
+            operator[](
+                ::boost::parameter::aux::default_<key_type,Default> const& d
+            ) const
+        {
+            return this->get_default(d, _holds_maybe());
+        }
+
+        template <typename Default>
+        inline BOOST_CONSTEXPR reference
+            operator[](
+                BOOST_PARAMETER_lazy_default_fallback<key_type,Default> const&
+            ) const
+        {
+            BOOST_MPL_ASSERT_NOT((_holds_maybe));
+            return this->arg.get_value();
+        }
+
+        // Builds an overload set including operator[]s defined
+        // in base classes.
+        using Next::operator[];
+
+        //
+        // End of indexing support
+        //
+
+        // For parameter_requirements matching this node's key_type, return
+        // a bool constant wrapper indicating whether the requirements are
+        // satisfied by TaggedArg.  Used only for compile-time computation
+        // and never really called, so a declaration is enough.
+        template <typename HasDefault, typename Predicate, typename ArgPack>
+        static typename
+#if !defined(BOOST_NO_SFINAE) && !BOOST_WORKAROUND(BOOST_MSVC, < 1800)
+        ::boost::lazy_enable_if<
+            typename ::boost::mpl::if_<
+                EmitsErrors
+              , ::boost::mpl::true_
+              , _has_unique_key
+            >::type,
+#endif
+            ::boost::parameter::aux::augment_predicate<
+                Predicate
+              , reference
+              , key_type
+              , value_type
+              , ArgPack
+#if !defined(BOOST_NO_SFINAE) && !BOOST_WORKAROUND(BOOST_MSVC, < 1800)
+           >
+#endif
+        >::type
+            satisfies(
+                ::boost::parameter::aux::parameter_requirements<
+                    key_type
+                  , Predicate
+                  , HasDefault
+                >*
+              , ArgPack*
+            );
+
+        // Builds an overload set including satisfies functions defined
+        // in base classes.
+        using Next::satisfies;
+#endif  // Borland workarounds needed
+
+        // Comma operator to compose argument list without using parameters<>.
+        // Useful for argument lists with undetermined length.
+        template <typename KW, typename T2>
+        inline BOOST_CONSTEXPR ::boost::parameter::aux::arg_list<
+            ::boost::parameter::aux::tagged_argument<KW,T2>
+          , self
+        >
+            operator,(
+                ::boost::parameter::aux::tagged_argument<KW,T2> const& x
+            ) const
+        {
+            return ::boost::parameter::aux::arg_list<
+                ::boost::parameter::aux::tagged_argument<KW,T2>
+              , self
+            >(x, *this);
+        }
+
+        // MPL sequence support
+        typedef self type;        // Convenience for users
+        typedef Next tail_type;   // For the benefit of iterators
+        // For dispatching to sequence intrinsics
+        typedef ::boost::parameter::aux::arg_list_tag tag;
     };
+}}} // namespace boost::parameter::aux
+
+#endif  // BOOST_PARAMETER_HAS_PERFECT_FORWARDING
 
-    template <class K, class T>
-    T& get(default_<K,T> x) const
+#if defined(BOOST_PARAMETER_CAN_USE_MP11)
+
+namespace boost { namespace parameter { namespace aux {
+
+    template <typename ...ArgTuples>
+    struct arg_list_cons;
+
+    template <>
+    struct arg_list_cons<>
     {
-        return x.value;
-    }
+        using type = ::boost::parameter::aux::empty_arg_list;
+    };
 
-    template <class K, class F>
-    typename result_of0<F>::type
-    get(lazy_default<K,F> x) const
+    template <typename ArgTuple0, typename ...Tuples>
+    struct arg_list_cons<ArgTuple0,Tuples...>
     {
-        return x.compute_default();
-    }
-#endif
+        using type = ::boost::parameter::aux::arg_list<
+            typename ArgTuple0::tagged_arg
+          , typename ::boost::parameter::aux::arg_list_cons<Tuples...>::type
+          , typename ArgTuple0::emits_errors
+        >;
+    };
 
-    // If this function is called, it means there is no argument
-    // in the list that matches the supplied keyword. Just return
-    // the default value.
-    template <class K, class Default>
-    Default& operator[](default_<K, Default> x) const
+    template <
+        typename Keyword
+      , typename TaggedArg
+      , typename EmitsErrors = ::boost::mp11::mp_true
+    >
+    struct flat_like_arg_tuple
     {
-        return x.value;
-    }
-
-    // If this function is called, it means there is no argument
-    // in the list that matches the supplied keyword. Just evaluate
-    // and return the default value.
-    template <class K, class F>
-    typename result_of0<F>::type
-    operator[](
-        BOOST_PARAMETER_lazy_default_fallback<K,F> x) const
+        using tagged_arg = TaggedArg;
+        using emits_errors = EmitsErrors;
+    };
+
+    template <typename ...ArgTuples>
+    class flat_like_arg_list
+      : public ::boost::parameter::aux::arg_list_cons<ArgTuples...>::type
     {
-        return x.compute_default();
-    }
+        using _base_type = typename ::boost::parameter::aux
+        ::arg_list_cons<ArgTuples...>::type;
+
+     public:
+        inline BOOST_CONSTEXPR flat_like_arg_list(
+            typename _base_type::tagged_arg const& head
+          , typename _base_type::tail_type const& tail
+        ) : _base_type(head, tail)
+        {
+        }
 
-    // No argument corresponding to ParameterRequirements::key_type
-    // was found if we match this overload, so unless that parameter
-    // has a default, we indicate that the actual arguments don't
-    // match the function's requirements.
-    template <class ParameterRequirements, class ArgPack>
-    static typename ParameterRequirements::has_default
-    satisfies(ParameterRequirements*, ArgPack*);
+        template <typename ...Args>
+        inline BOOST_CONSTEXPR flat_like_arg_list(Args&&... args)
+          : _base_type(::std::forward<Args>(args)...)
+        {
+        }
+
+        using _base_type::operator[];
+        using _base_type::satisfies;
+
+        // Comma operator to compose argument list without using parameters<>.
+        // Useful for argument lists with undetermined length.
+        template <typename TaggedArg>
+        inline BOOST_CONSTEXPR ::boost::parameter::aux::flat_like_arg_list<
+            ::boost::parameter::aux::flat_like_arg_tuple<
+                typename TaggedArg::base_type::key_type
+              , typename TaggedArg::base_type
+            >
+          , ArgTuples...
+        >
+            operator,(TaggedArg const& x) const
+        {
+            return ::boost::parameter::aux::flat_like_arg_list<
+                ::boost::parameter::aux::flat_like_arg_tuple<
+                    typename TaggedArg::base_type::key_type
+                  , typename TaggedArg::base_type
+                >
+              , ArgTuples...
+            >(
+                static_cast<typename TaggedArg::base_type const&>(x)
+              , static_cast<_base_type const&>(*this)
+            );
+        }
+    };
 
-    // MPL sequence support
-    typedef empty_arg_list type;   // convenience
-    typedef arg_list_tag tag; // For dispatching to sequence intrinsics
-};
-
-// Forward declaration for arg_list::operator,
-template <class KW, class T>
-struct tagged_argument;
-
-template <class T>
-struct get_reference
-{
-    typedef typename T::reference type;
-};
-
-// A tuple of tagged arguments, terminated with empty_arg_list.
-// Every TaggedArg is an instance of tagged_argument<>.
-template <class TaggedArg, class Next = empty_arg_list>
-struct arg_list : Next
-{
-    typedef arg_list<TaggedArg,Next> self;
-    typedef typename TaggedArg::key_type key_type;
-
-    typedef typename is_maybe<typename TaggedArg::value_type>::type holds_maybe;
-
-    typedef typename mpl::eval_if<
-        holds_maybe
-      , get_reference<typename TaggedArg::value_type>
-      , get_reference<TaggedArg>
-    >::type reference;
-
-    typedef typename mpl::if_<
-        holds_maybe
-      , reference
-      , typename TaggedArg::value_type
-    >::type value_type;
-
-    TaggedArg arg;      // Stores the argument
-
-    // Store the arguments in successive nodes of this list
-    template< // class A0, class A1, ...
-        BOOST_PP_ENUM_PARAMS(BOOST_PARAMETER_MAX_ARITY, class A)
-    >
-    arg_list( // A0& a0, A1& a1, ...
-        BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PARAMETER_MAX_ARITY, A, & a)
-    )
-      : Next( // a1, a2, ...
-            BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PARAMETER_MAX_ARITY, a)
-          , void_reference()
-        )
-      , arg(a0)
-    {}
-
-    // Create a new list by prepending arg to a copy of tail.  Used
-    // when incrementally building this structure with the comma
-    // operator.
-    arg_list(TaggedArg head, Next const& tail)
-      : Next(tail)
-      , arg(head)
-    {}
-
-    // A metafunction class that, given a keyword and a default
-    // type, returns the appropriate result type for a keyword
-    // lookup given that default
-    struct binding
+    template <>
+    class flat_like_arg_list<>
+      : public ::boost::parameter::aux::empty_arg_list
     {
-        template <class KW, class Default, class Reference>
-        struct apply
+        using _base_type = ::boost::parameter::aux::empty_arg_list;
+
+     public:
+        template <typename ...Args>
+        inline BOOST_CONSTEXPR flat_like_arg_list(Args&&... args)
+          : _base_type(::std::forward<Args>(args)...)
         {
-          typedef typename mpl::eval_if<
-                boost::is_same<KW, key_type>
-              , mpl::if_<Reference, reference, value_type>
-              , mpl::apply_wrap3<typename Next::binding, KW, Default, Reference>
-          >::type type;
-        };
+        }
+
+        using _base_type::operator[];
+        using _base_type::satisfies;
+
+        // Comma operator to compose argument list without using parameters<>.
+        // Useful for argument lists with undetermined length.
+        template <typename TaggedArg>
+        inline BOOST_CONSTEXPR ::boost::parameter::aux::flat_like_arg_list<
+            ::boost::parameter::aux::flat_like_arg_tuple<
+                typename TaggedArg::base_type::key_type
+              , typename TaggedArg::base_type
+            >
+        >
+            operator,(TaggedArg const& x) const
+        {
+            return ::boost::parameter::aux::flat_like_arg_list<
+                ::boost::parameter::aux::flat_like_arg_tuple<
+                    typename TaggedArg::base_type::key_type
+                  , typename TaggedArg::base_type
+                >
+            >(
+                static_cast<typename TaggedArg::base_type const&>(x)
+              , static_cast<_base_type const&>(*this)
+            );
+        }
     };
+}}} // namespace boost::parameter::aux
 
-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-    // Overload for key_type, so the assert below will fire if the
-    // same keyword is used again
-    static yes_tag has_key(key_type*);
-    using Next::has_key;
+#endif  // BOOST_PARAMETER_CAN_USE_MP11
 
-    BOOST_MPL_ASSERT_MSG(
-        sizeof(Next::has_key((key_type*)0)) == sizeof(no_tag)
-      , duplicate_keyword, (key_type)
-    );
+#include <boost/mpl/iterator_tags.hpp>
 
-#endif
-    //
-    // Begin implementation of indexing operators for looking up
-    // specific arguments by name
-    //
+namespace boost { namespace parameter { namespace aux {
 
-    // Helpers that handle the case when TaggedArg is
-    // empty<T>.
-    template <class D>
-    reference get_default(D const&, mpl::false_) const
+    // MPL sequence support
+    template <typename ArgumentPack>
+    struct arg_list_iterator
     {
-        return arg.value;
-    }
+        typedef ::boost::mpl::forward_iterator_tag category;
+
+        // The incremented iterator
+        typedef ::boost::parameter::aux
+        ::arg_list_iterator<typename ArgumentPack::tail_type> next;
 
-    template <class D>
-    reference get_default(D const& d, mpl::true_) const
+        // dereferencing yields the key type
+        typedef typename ArgumentPack::key_type type;
+    };
+
+    template <>
+    struct arg_list_iterator< ::boost::parameter::aux::empty_arg_list>
     {
-        return arg.value ? arg.value.get() : arg.value.construct(d.value);
-    }
+    };
+}}} // namespace boost::parameter::aux
 
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-    // These older compilers don't support the overload set creation
-    // idiom well, so we need to do all the return type calculation
-    // for the compiler and dispatch through an outer function template
-
-    // A metafunction class that, given a keyword, returns the base
-    // sublist whose get() function can produce the value for that
-    // key.
-    struct key_owner
+#include <boost/mpl/begin_end_fwd.hpp>
+
+// MPL sequence support
+namespace boost { namespace mpl {
+
+    template <>
+    struct begin_impl< ::boost::parameter::aux::arg_list_tag>
     {
-        template<class KW>
+        template <typename S>
         struct apply
         {
-          typedef typename mpl::eval_if<
-                boost::is_same<KW, key_type>
-              , mpl::identity<arg_list<TaggedArg,Next> >
-              , mpl::apply_wrap1<typename Next::key_owner,KW>
-          >::type type;
+            typedef ::boost::parameter::aux::arg_list_iterator<S> type;
         };
     };
 
-    // Outer indexing operators that dispatch to the right node's
-    // get() function.
-    template <class KW>
-    typename mpl::apply_wrap3<binding, KW, void_, mpl::true_>::type
-    operator[](keyword<KW> const& x) const
+    template <>
+    struct end_impl< ::boost::parameter::aux::arg_list_tag>
     {
-        typename mpl::apply_wrap1<key_owner, KW>::type const& sublist = *this;
-        return sublist.get(x);
-    }
+        template <typename>
+        struct apply
+        {
+            typedef ::boost::parameter::aux::arg_list_iterator<
+                ::boost::parameter::aux::empty_arg_list
+            > type;
+        };
+    };
+}} // namespace boost::mpl
 
-    template <class KW, class Default>
-    typename mpl::apply_wrap3<binding, KW, Default&, mpl::true_>::type
-    operator[](default_<KW, Default> x) const
-    {
-        typename mpl::apply_wrap1<key_owner, KW>::type const& sublist = *this;
-        return sublist.get(x);
-    }
-
-    template <class KW, class F>
-    typename mpl::apply_wrap3<
-        binding,KW
-      , typename result_of0<F>::type
-      , mpl::true_
-    >::type
-    operator[](lazy_default<KW,F> x) const
-    {
-        typename mpl::apply_wrap1<key_owner, KW>::type const& sublist = *this;
-        return sublist.get(x);
-    }
-
-    // These just return the stored value; when empty_arg_list is
-    // reached, indicating no matching argument was passed, the
-    // default is returned, or if no default_ or lazy_default was
-    // passed, compilation fails.
-    reference get(keyword<key_type> const&) const
-    {
-        BOOST_MPL_ASSERT_NOT((holds_maybe));
-        return arg.value;
-    }
+#include <boost/parameter/value_type.hpp>
+#include <boost/mpl/has_key_fwd.hpp>
+#include <boost/type_traits/is_void.hpp>
 
-    template <class Default>
-    reference get(default_<key_type,Default> const& d) const
-    {
-        return get_default(d, holds_maybe());
-    }
+namespace boost { namespace mpl {
 
-    template <class Default>
-    reference get(lazy_default<key_type, Default>) const
+    template <>
+    struct has_key_impl< ::boost::parameter::aux::arg_list_tag>
     {
-        return arg.value;
-    }
+        template <typename ArgList, typename Keyword>
+        struct apply
+        {
+            typedef typename ::boost::mpl::if_<
+                ::boost::is_void<
+                    typename ::boost::parameter
+                    ::value_type<ArgList,Keyword,void>::type
+                >
+              , ::boost::mpl::false_
+              , ::boost::mpl::true_
+            >::type type;
+        };
+    };
+}} // namespace boost::mpl
 
-#else
+#include <boost/mpl/count_fwd.hpp>
+#include <boost/mpl/int.hpp>
 
-    reference operator[](keyword<key_type> const&) const
-    {
-        BOOST_MPL_ASSERT_NOT((holds_maybe));
-        return arg.value;
-    }
+namespace boost { namespace mpl {
 
-    template <class Default>
-    reference operator[](default_<key_type, Default> const& d) const
+    template <>
+    struct count_impl< ::boost::parameter::aux::arg_list_tag>
     {
-        return get_default(d, holds_maybe());
-    }
+        template <typename ArgList, typename Keyword>
+        struct apply
+        {
+            typedef typename ::boost::mpl::if_<
+                ::boost::is_void<
+                    typename ::boost::parameter
+                    ::value_type<ArgList,Keyword,void>::type
+                >
+              , ::boost::mpl::int_<0>
+              , ::boost::mpl::int_<1>
+            >::type type;
+        };
+    };
+}} // namespace boost::mpl
 
-    template <class Default>
-    reference operator[](lazy_default<key_type, Default>) const
-    {
-        BOOST_MPL_ASSERT_NOT((holds_maybe));
-        return arg.value;
-    }
+#include <boost/mpl/key_type_fwd.hpp>
+#include <boost/mpl/identity.hpp>
 
-    // Builds an overload set including operator[]s defined in base
-    // classes.
-    using Next::operator[];
+namespace boost { namespace mpl {
 
-    //
-    // End of indexing support
-    //
+    template <>
+    struct key_type_impl< ::boost::parameter::aux::arg_list_tag>
+    {
+        template <typename ArgList, typename Keyword>
+        struct apply
+        {
+            typedef typename ::boost::mpl::eval_if<
+                ::boost::is_void<
+                    typename ::boost::parameter
+                    ::value_type<ArgList,Keyword,void>::type
+                >
+              , void
+              , ::boost::mpl::identity<Keyword>
+            >::type type;
+        };
+    };
+}} // namespace boost::mpl
 
+#include <boost/mpl/value_type_fwd.hpp>
 
-    //
-    // For parameter_requirements matching this node's key_type,
-    // return a bool constant wrapper indicating whether the
-    // requirements are satisfied by TaggedArg.  Used only for
-    // compile-time computation and never really called, so a
-    // declaration is enough.
-    //
-    template <class HasDefault, class Predicate, class ArgPack>
-    static typename mpl::apply_wrap2<
-        typename mpl::lambda<Predicate, lambda_tag>::type
-      , value_type, ArgPack
-    >::type
-    satisfies(
-        parameter_requirements<key_type,Predicate,HasDefault>*
-      , ArgPack*
-    );
-
-    // Builds an overload set including satisfies functions defined
-    // in base classes.
-    using Next::satisfies;
-#endif
+namespace boost { namespace mpl {
 
-    // Comma operator to compose argument list without using parameters<>.
-    // Useful for argument lists with undetermined length.
-    template <class KW, class T2>
-    arg_list<tagged_argument<KW, T2>, self>
-    operator,(tagged_argument<KW,T2> x) const
+    template <>
+    struct value_type_impl< ::boost::parameter::aux::arg_list_tag>
+      : ::boost::mpl::key_type_impl< ::boost::parameter::aux::arg_list_tag>
     {
-        return arg_list<tagged_argument<KW,T2>, self>(x, *this);
-    }
+    };
+}} // namespace boost::mpl
 
-    // MPL sequence support
-    typedef self type;             // Convenience for users
-    typedef Next tail_type;        // For the benefit of iterators
-    typedef arg_list_tag tag; // For dispatching to sequence intrinsics
-};
+#include <boost/mpl/at_fwd.hpp>
 
-// MPL sequence support
-template <class ArgumentPack>
-struct arg_list_iterator
-{
-    typedef mpl::forward_iterator_tag category;
+namespace boost { namespace mpl {
 
-    // The incremented iterator
-    typedef arg_list_iterator<typename ArgumentPack::tail_type> next;
+    template <>
+    struct at_impl< ::boost::parameter::aux::arg_list_tag>
+      : ::boost::mpl::key_type_impl< ::boost::parameter::aux::arg_list_tag>
+    {
+    };
+}} // namespace boost::mpl
 
-    // dereferencing yields the key type
-    typedef typename ArgumentPack::key_type type;
-};
+#include <boost/mpl/order_fwd.hpp>
+#include <boost/mpl/void.hpp>
+#include <boost/mpl/find.hpp>
+#include <boost/mpl/distance.hpp>
 
-template <>
-struct arg_list_iterator<empty_arg_list> {};
+namespace boost { namespace mpl {
 
-}} // namespace parameter::aux
+    template <>
+    struct order_impl< ::boost::parameter::aux::arg_list_tag>
+    {
+        template <typename ArgList, typename Keyword>
+        struct apply
+        {
+            typedef typename ::boost::mpl::find<ArgList,Keyword>::type Itr;
+            typedef typename ::boost::mpl::eval_if<
+                ::boost::is_void<
+                    typename ::boost::parameter
+                    ::value_type<ArgList,Keyword,void>::type
+                >
+              , ::boost::mpl::identity< ::boost::mpl::void_>
+              , ::boost::mpl::distance<
+                    Itr
+                  , ::boost::parameter::aux::arg_list_iterator<
+                        ::boost::parameter::aux::empty_arg_list
+                    >
+                >
+            >::type type;
+        };
+    };
+}} // namespace boost::mpl
 
-// MPL sequence support
-namespace mpl
-{
-  template <>
-  struct begin_impl<parameter::aux::arg_list_tag>
-  {
-      template <class S>
-      struct apply
-      {
-          typedef parameter::aux::arg_list_iterator<S> type;
-      };
-  };
-
-  template <>
-  struct end_impl<parameter::aux::arg_list_tag>
-  {
-      template <class>
-      struct apply
-      {
-          typedef parameter::aux::arg_list_iterator<parameter::aux::empty_arg_list> type;
-      };
-  };
-}
-
-} // namespace boost
-
-#endif // ARG_LIST_050329_HPP
+#endif  // include guard