boost::mpl::vector< T > Struct Template Reference

Description

template<typename ... T>
struct boost::mpl::vector< T >

Adapter for Boost.MPL vectors.

Modeled concepts

It is possible for MPL vectors to model a couple of concepts. However, because they are only able to hold types, they lack the generality required to model concepts like Functor, Sequence and other related concepts.

1. Comparable
   Two MPL vectors are equal if and only if they contain the same number of types, and if all those types are equal.

   // Copyright Louis Dionne 2013-2017
   // Distributed under the Boost Software License, Version 1.0.
   // (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
    
   #include <boost/hana/assert.hpp>
   #include <boost/hana/equal.hpp>
   #include <boost/hana/ext/boost/mpl/vector.hpp>
   #include <boost/hana/not_equal.hpp>
    
   #include <boost/mpl/vector.hpp>
   namespace hana = boost::hana;
   namespace mpl = boost::mpl;
    
    
   BOOST_HANA_CONSTANT_CHECK(
       hana::equal(mpl::vector2<int, char>{}, mpl::vector<int, char>{})
   );
   BOOST_HANA_CONSTANT_CHECK(
       hana::not_equal(mpl::vector2<int, char>{}, mpl::vector<int, char, float>{})
   );
    
   int main() { }

2. Foldable
   Folding a MPL vector is equivalent to folding it as a Sequence.

   // Copyright Louis Dionne 2013-2017
   // Distributed under the Boost Software License, Version 1.0.
   // (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
    
   #include <boost/hana/assert.hpp>
   #include <boost/hana/equal.hpp>
   #include <boost/hana/ext/boost/mpl/vector.hpp>
   #include <boost/hana/ext/std/integral_constant.hpp>
   #include <boost/hana/fold_left.hpp>
   #include <boost/hana/if.hpp>
   #include <boost/hana/integral_constant.hpp>
   #include <boost/hana/plus.hpp>
   #include <boost/hana/type.hpp>
    
   #include <boost/mpl/vector.hpp>
   #include <type_traits>
   namespace hana = boost::hana;
   namespace mpl = boost::mpl;
    
    
   auto types = mpl::vector<long, float, short, float, long, long double>{};
   auto number_of_floats = hana::fold_left(types, hana::int_c<0>, [](auto count, auto t) {
       return hana::if_(hana::trait<std::is_floating_point>(t),
           count + hana::int_c<1>,
           count
       );
   });
    
   BOOST_HANA_CONSTANT_CHECK(number_of_floats == hana::int_c<3>);
    
   int main() { }

3. Iterable
   Iterating over a MPL vector is just iterating over each of the types it contains, as if it were a Sequence.

   // Copyright Louis Dionne 2013-2017
   // Distributed under the Boost Software License, Version 1.0.
   // (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
    
   #include <boost/hana/assert.hpp>
   #include <boost/hana/drop_front.hpp>
   #include <boost/hana/drop_while.hpp>
   #include <boost/hana/equal.hpp>
   #include <boost/hana/ext/boost/mpl/vector.hpp>
   #include <boost/hana/ext/std/integral_constant.hpp>
   #include <boost/hana/front.hpp>
   #include <boost/hana/type.hpp>
    
   #include <boost/mpl/vector.hpp>
   #include <type_traits>
   namespace hana = boost::hana;
   namespace mpl = boost::mpl;
    
    
   BOOST_HANA_CONSTANT_CHECK(hana::front(mpl::vector<int, char, void>{}) == hana::type_c<int>);
    
   BOOST_HANA_CONSTANT_CHECK(hana::equal(
       hana::drop_front(mpl::vector<int, char, void>{}),
       mpl::vector<char, void>{}
   ));
    
   BOOST_HANA_CONSTANT_CHECK(hana::equal(
       hana::drop_while(mpl::vector<float, double const, int, float&>{},
                        hana::trait<std::is_floating_point>),
       mpl::vector<int, float&>{}
   ));
    
   int main() { }

4. Searchable
   A MPL vector can be searched as if it were a tuple containing hana::types.

   // Copyright Louis Dionne 2013-2017
   // Distributed under the Boost Software License, Version 1.0.
   // (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
    
   #include <boost/hana/assert.hpp>
   #include <boost/hana/equal.hpp>
   #include <boost/hana/ext/boost/mpl/vector.hpp>
   #include <boost/hana/find.hpp>
   #include <boost/hana/find_if.hpp>
   #include <boost/hana/optional.hpp>
   #include <boost/hana/type.hpp>
    
   #include <boost/mpl/vector.hpp>
   namespace hana = boost::hana;
   namespace mpl = boost::mpl;
    
    
   BOOST_HANA_CONSTANT_CHECK(
       hana::find_if(mpl::vector<int, float, char const*>{}, hana::equal.to(hana::type_c<float>))
       ==
       hana::just(hana::type_c<float>)
   );
    
   BOOST_HANA_CONSTANT_CHECK(
       hana::find(mpl::vector<int, float, char const*>{}, hana::type_c<void>)
       ==
       hana::nothing
   );
    
   int main() { }

Conversion from any <tt>Foldable</tt>

A MPL vector can be created from any Foldable. More precisely, for a Foldable xs whose linearization is [x1, ..., xn],

to<ext::boost::mpl::vector_tag>(xs) == mpl::vector<t1, ..., tn>

where tk is the type of xk, or the type contained in xk if xk is a hana::type.

Warning

The limitations on the size of mpl::vectors are inherited by this conversion utility, and hence trying to convert a Foldable containing more than BOOST_MPL_LIMIT_VECTOR_SIZE elements is an error.

// Copyright Louis Dionne 2013-2017
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
 
#include <boost/hana/core/to.hpp>
#include <boost/hana/ext/boost/mpl/vector.hpp>
#include <boost/hana/tuple.hpp>
#include <boost/hana/type.hpp>
 
#include <boost/mpl/vector.hpp>
#include <type_traits>
namespace hana = boost::hana;
namespace mpl = boost::mpl;
 
 
auto xs = hana::make_tuple(hana::type_c<int>, hana::type_c<char>, hana::type_c<double>);
static_assert(std::is_same<
    decltype(hana::to<hana::ext::boost::mpl::vector_tag>(xs)),
    mpl::vector<int, char, double>
>{}, "");
 
int main() { }