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. Expands to the length of the template parameter list for variant. Note: Conforming implementations of variant must allow at least ten template arguments. That is, BOOST_VARIANT_LIMIT_TYPES must be greater or equal to 10. Enumerate parameters for use with variant. 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 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 variant does not support references as bounded types. Defined only if variant does not support references as bounded types. 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. 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.)