Provides forward declarations of the ``boost::variant``, ``boost::make_variant_over``, ``boost::make_recursive_variant``, and ``boost::make_recursive_variant_over`` class templates and the `boost::recursive_variant_` tag type. Also defines several preprocessor symbols, as described below.

Enumerate parameters for use with ``variant``.

Expands to variadic template list in the following manner: ``

                BOOST_VARIANT_ENUM_PARAMS(T)                    => T0, TN...
                BOOST_VARIANT_ENUM_PARAMS(class T)              => class T0, class... TN
                BOOST_VARIANT_ENUM_PARAMS(class Something)      => class Something0, class... SomethingN
                BOOST_VARIANT_ENUM_PARAMS(typename Something)   => typename Something0, typename... SomethingN
                BOOST_VARIANT_ENUM_PARAMS(Something)            => Something0, SomethingN...
                BOOST_VARIANT_ENUM_PARAMS(Something)            => Something0, SomethingN...

Otherwise expands to a comma-separated sequence of length `BOOST_VARIANT_LIMIT_TYPES`, where each element in the sequence consists of the concatenation of param with its zero-based index into the sequence. That is, `param ## 0, param ## 1, ..., param ## BOOST_VARIANT_LIMIT_TYPES - 1`.

Rationale: This macro greatly simplifies for the user the process of declaring ``variant`` types in function templates or explicit partial specializations of class templates, as shown in the tutorial.

Enumerate all but the first parameter for use with ``variant``.

Expands to variadic template list in the following manner: ``

                BOOST_VARIANT_ENUM_SHIFTED_PARAMS(T)                    => TN...
                BOOST_VARIANT_ENUM_SHIFTED_PARAMS(class T)              => class... TN
                BOOST_VARIANT_ENUM_SHIFTED_PARAMS(class Something)      => class... SomethingN
                BOOST_VARIANT_ENUM_SHIFTED_PARAMS(typename Something)   => typename... SomethingN
                BOOST_VARIANT_ENUM_SHIFTED_PARAMS(Something)            => SomethingN...
                BOOST_VARIANT_ENUM_SHIFTED_PARAMS(Something)            => SomethingN...

Otherwise expands to a comma-separated sequence of length `BOOST_VARIANT_LIMIT_TYPES - 1`, where each element in the sequence consists of the concatenation of param with its one-based index into the sequence. That is, `param ## 1, ..., param ## BOOST_VARIANT_LIMIT_TYPES - 1`.

Note: This macro results in the same expansion as `BOOST_VARIANT_ENUM_PARAMS` -- but without the first term.

Indicates absence of support for specifying the bounded types of a ``variant`` by the elements of a type sequence.

Defined only if ``make_variant_over`` and ``make_recursive_variant_over`` are not supported for some reason on the target compiler.

Define this macro if you do not wish to have a ``std::hash`` specialization for ``boost::variant``.

Indicates ``make_recursive_variant`` operates in an implementation-defined manner.

Defined only if ``make_recursive_variant`` does not operate as documented on the target compiler, but rather in an implementation-defined manner.

Implementation Note: If `BOOST_VARIANT_NO_FULL_RECURSIVE_VARIANT_SUPPORT` is defined for the target compiler, the current implementation uses the MPL lambda mechanism to approximate the desired behavior. (In most cases, however, such compilers do not have full lambda support either.)