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. 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.)