Chapter 50. Boost.Fusion

The standard library provides numerous containers that have one thing in common: They are homogeneous. That is, containers from the standard library can only store elements of one type. A vector of the type std::vector<int> can only store int values, and a vector of type std::vector<std::string> can only store strings.

Boost.Fusion makes it possible to create heterogeneous containers. For example, you can create a vector whose first element is an int and whose second element is a string. In addition, Boost.Fusion provides algorithms to process heterogeneous containers. You can think of Boost.Fusion as the standard library for heterogeneous containers.

Strictly speaking, since C++11, the standard library has provided a heterogeneous container, std::tuple. You can use different types for the values stored in a tuple. boost:fusion::tuple in Boost.Fusion is a similar type. While the standard library doesn’t have much more to offer, tuples are just the starting place for Boost.Fusion.

Example 50.1. Processing Fusion tuples

  1. #include <boost/fusion/tuple.hpp>
  2. #include <string>
  3. #include <iostream>
  5. using namespace boost::fusion;
  7. int main()
  8. {
  9.   typedef tuple<int, std::string, bool, double> tuple_type;
  10.   tuple_type t{10, "Boost", true, 3.14};
  11.   std::cout << get<0>(t) << '\n';
  12.   std::cout << get<1>(t) << '\n';
  13.   std::cout << std::boolalpha << get<2>(t) << '\n';
  14.   std::cout << get<3>(t) << '\n';
  15. }

Example 50.1 defines a tuple consisting of an int, a std::string, a bool, and a double. The tuple is based on boost:fusion::tuple. In Example 50.1, the tuple is then instantiated, initialized, and the various elements are retrieved with boost::fusion::get() and written to standard output. The function boost::fusion::get() is similar to std::get(), which accesses elements in std::tuple.

Fusion tuples don’t differ from tuples from the standard library. Thus it’s no surprise that Boost.Fusion provides a function boost::fusion::make_tuple(), which works like std::make_tuple(). However, Boost.Fusion provides additional functions that go beyond what is offered in the standard library.

Example 50.2. Iterating over a tuple with boost::fusion::for_each()

  1. #include <boost/fusion/tuple.hpp>
  2. #include <boost/fusion/algorithm.hpp>
  3. #include <string>
  4. #include <iostream>
  6. using namespace boost::fusion;
  8. struct print
  9. {
  10.   template <typename T>
  11.   void operator()(const T &t) const
  12.   {
  13.     std::cout << std::boolalpha << t << '\n';
  14.   }
  15. };
  17. int main()
  18. {
  19.   typedef tuple<int, std::string, bool, double> tuple_type;
  20.   tuple_type t{10, "Boost", true, 3.14};
  21.   for_each(t, print{});
  22. }

Example 50.2 introduces the algorithm boost::fusion::foreach(), which iterates over a Fusion container. The function is used here to write the values in the tuple _t to standard output.

boost::fusion::for_each() is designed to work like std::for_each(). While std::for_each() only iterates over homogeneous containers, boost::fusion::for_each() works with heterogeneous containers. You pass a container, not an iterator, to boost::fusion::for_each(). If you don’t want to iterate over all elements in a container, you can use a view.

Example 50.3. Filtering a Fusion container with boost::fusion::filter_view

  1. #include <boost/fusion/tuple.hpp>
  2. #include <boost/fusion/view.hpp>
  3. #include <boost/fusion/algorithm.hpp>
  4. #include <boost/type_traits.hpp>
  5. #include <boost/mpl/arg.hpp>
  6. #include <string>
  7. #include <iostream>
  9. using namespace boost::fusion;
  11. struct print
  12. {
  13.   template <typename T>
  14.   void operator()(const T &t) const
  15.   {
  16.     std::cout << std::boolalpha << t << '\n';
  17.   }
  18. };
  20. int main()
  21. {
  22.   typedef tuple<int, std::string, bool, double> tuple_type;
  23.   tuple_type t{10, "Boost", true, 3.14};
  24.   filter_view<tuple_type, boost::is_integral<boost::mpl::arg<1>>> v{t};
  25.   for_each(v, print{});
  26. }

Boost.Fusion provides views, which act like containers but don’t store data. With views, data in a container can be accessed differently. Views are similar to adaptors from Boost.Range. However, while adaptors from Boost.Range can be applied to only one container, views from Boost.Fusion can span data from multiple containers.

Example 50.3 uses the class boost::fusion::filterview to filter the tuple _t. The filter directs boost::fusion::for_each() to only write elements based on an integral type.

boost::fusion::filter_view expects as a first template parameter the type of the container to filter. The second template parameter must be a predicate to filter elements. The predicate must filter the elements based on their type.

The library is called Boost.Fusion because it combines two worlds: C++ programs process values at run time and types at compile time. For developers, values at run time are usually more important. Most tools from the standard library process values at run time. To process types at compile time, template meta programming is used. While values are processed depending on other values at run time, types are processed depending on other types at compile time. Boost.Fusion lets you process values depending on types.

The second template parameter passed to boost::fusion::filter_view is a predicate, which will be applied to every type in the tuple. The predicate expects a type as a parameter and returns true if the type should be part of the view. If false is returned, the type is filtered out.

Example 50.3 uses the class boost::isintegral from Boost.TypeTraits. boost::is_integral is a template that checks whether a type is integral. Because the template parameter has to be passed to boost::fusion::filter_view, a placeholder from Boost.MPL, boost::mpl::arg<1>, is used to create a lambda function. boost::mpl::arg<1> is similar to _boost::phoenix::place_holders::arg1 from Boost.Phoenix. In Example 50.3, the view v will contain only the int and bool elements from the tuple, and therefore, the example will write 10 and true to standard output.

Example 50.4. Accessing elements in Fusion containers with iterators

  1. #include <boost/fusion/tuple.hpp>
  2. #include <boost/fusion/iterator.hpp>
  3. #include <boost/mpl/int.hpp>
  4. #include <string>
  5. #include <iostream>
  7. using namespace boost::fusion;
  9. int main()
  10. {
  11.   typedef tuple<int, std::string, bool, double> tuple_type;
  12.   tuple_type t{10, "Boost", true, 3.14};
  13.   auto it = begin(t);
  14.   std::cout << *it << '\n';
  15.   auto it2 = advance<boost::mpl::int_<2>>(it);
  16.   std::cout << std::boolalpha << *it2 << '\n';
  17. }

After seeing boost::fusion::tuple and boost::fusion::for_each(), it shouldn’t come as a surprise to find iterators in Example 50.4. Boost.Fusion provides several free-standing functions, such as boost::fusion::begin() and boost::fusion::advance(), that work like the identically named functions from the standard library.

The number of steps the iterator is to be incremented is passed to boost::fusion::advance() as a template parameter. The example again uses boost::mpl::int_ from Boost.MPL.

boost::fusion::advance() returns an iterator of a different type from the one that was passed to the function. That’s why Example 50.4 uses a second iterator it2. You can’t assign the return value from boost::fusion::advance() to the first iterator it. Example 50.4 writes 10 and true to standard output.

In addition to the functions introduced in the example, Boost.Fusion provides other functions that work with iterators. These include the following: boost::fusion::end(), boost::fusion::distance(), boost::fusion::next() and boost::fusion::prior().

Example 50.5. A heterogeneous vector with boost::fusion::vector

  1. #include <boost/fusion/container.hpp>
  2. #include <boost/fusion/sequence.hpp>
  3. #include <boost/mpl/int.hpp>
  4. #include <string>
  5. #include <iostream>
  7. using namespace boost::fusion;
  9. int main()
  10. {
  11.   typedef vector<int, std::string, bool, double> vector_type;
  12.   vector_type v{10, "Boost", true, 3.14};
  13.   std::cout << at<boost::mpl::int_<0>>(v) << '\n';
  15.   auto v2 = push_back(v, 'X');
  16.   std::cout << size(v) << '\n';
  17.   std::cout << size(v2) << '\n';
  18.   std::cout << back(v2) << '\n';
  19. }

So far we’ve only seen one heterogeneous container, boost::fusion::tuple. Example 50.5 introduces another container, boost::fusion::vector.

boost::fusion::vector is a vector: elements are accessed with indexes. Access is not implemented using the operator operator[]. Instead, it’s implemented using boost::fusion::at(), a free-standing function. The index is passed as a template parameter wrapped with boost::mpl::int_.

This example adds a new element of type char to the vector. This is done with the free-standing function boost::fusion::push_back(). Two parameters are passed to boost::fusion::push_back(): the vector to add the element to and the value to add.

boost::fusion::pushback() returns a new vector. The vector _v isn’t changed. The new vector is a copy of the original vector with the added element.

This example gets the number of elements in the vectors v and v2 with boost::fusion::size() and writes both values to standard output. The program displays 4 and 5. It then calls boost::fusion::back() to get and write the last element in v2 to standard output, in this case the value is X.

If you look more closely at Example 50.5, you will notice that there is no difference between boost::fusion::tuple and boost::fusion::vector; they are the same. Thus, Example 50.5 will also work with boost::fusion::tuple.

Boost.Fusion provides additional heterogeneous containers, including: boost::fusion::deque, boost::fusion::list and boost::fusion::set. Example 50.6 introduces boost::fusion::map, a container for key/value pairs.

Example 50.6. A heterogeneous map with boost::fusion::map

  1. #include <boost/fusion/container.hpp>
  2. #include <boost/fusion/sequence.hpp>
  3. #include <boost/fusion/algorithm.hpp>
  4. #include <string>
  5. #include <iostream>
  7. using namespace boost::fusion;
  9. int main()
  10. {
  11.   auto m = make_map<int, std::string, bool, double>("Boost", 10, 3.14, true);
  12.   if (has_key<std::string>(m))
  13.     std::cout << at_key<std::string>(m) << '\n';
  14.   auto m2 = erase_key<std::string>(m);
  15.   auto m3 = push_back(m2, make_pair<float>('X'));
  16.   std::cout << std::boolalpha << has_key<std::string>(m3) << '\n';
  17. }

Example 50.6 creates a heterogeneous map with boost::fusion::map(). The map’s type is boost::fusion::map, which isn’t written out in the example thanks to the keyword auto.

A map of type boost::fusion::map stores key/value pairs like std::map does. However, the keys in the Fusion map are types. A key/value pair consists of a type and a value mapped to that type. The value may be a different type than the key. In Example 50.6, the string “Boost” is mapped to the key int.

After the map has been created, boost::fusion::has_key() is called to check whether a key std::string exists. Then, boost::fusion::at_key() is called to get the value mapped to that key. Because the number 10 is mapped to std::string, it is written to standard output.

The key/value pair is then erased with boost::fusion::erasekey(). This doesn’t change the map _m. boost::fusion::erase_key() returns a new map which is missing the erased key/value pair.

The call to boost::fusion::push_back() adds a new key/value pair to the map. The key is float and the value is “X”. boost::fusion::make_pair() is called to create the new key/value pair. This function is similar to std::make_pair().

Finally, boost::fusion::has_key() is called again to check whether the map has a key std::string. Because it was erased, false is returned.

Please note that you don’t need to call boost::fusion::has_key() to check whether a key exists before you call boost::fusion::at_key(). If a key is passed to boost::fusion::at_key() that doesn’t exist in the map, you get a compiler error.

Example 50.7. Fusion adaptors for structures

  1. #include <boost/fusion/adapted.hpp>
  2. #include <boost/fusion/sequence.hpp>
  3. #include <boost/mpl/int.hpp>
  4. #include <iostream>
  6. struct strct
  7. {
  8.   int i;
  9.   double d;
  10. };
  12. BOOST_FUSION_ADAPT_STRUCT(strct,
  13.   (int, i)
  14.   (double, d)
  15. )
  17. using namespace boost::fusion;
  19. int main()
  20. {
  21.   strct s = {10, 3.14};
  22.   std::cout << at<boost::mpl::int_<0>>(s) << '\n';
  23.   std::cout << back(s) << '\n';
  24. }

Boost.Fusion provides several macros that let you use structures as Fusion containers. This is possible because structures can act as heterogeneous containers. Example 50.7 defines a structure which can be used as a Fusion container thanks to the macro BOOST_FUSION_ADAPT_STRUCT. This makes it possible to use the structure with functions like boost::fusion::at() or boost::fusion::back().

Example 50.8. Fusion support for std::pair

  1. #include <boost/fusion/adapted.hpp>
  2. #include <boost/fusion/sequence.hpp>
  3. #include <boost/mpl/int.hpp>
  4. #include <utility>
  5. #include <iostream>
  7. using namespace boost::fusion;
  9. int main()
  10. {
  11.   auto p = std::make_pair(10, 3.14);
  12.   std::cout << at<boost::mpl::int_<0>>(p) << '\n';
  13.   std::cout << back(p) << '\n';
  14. }

Boost.Fusion supports structures such as std::pair and boost::tuple without having to use macros. You just need to include the header file boost/fusion/adapted.hpp (see Example 50.8).

Exercise

Make debug() write the member variables of the structures used in the program to standard output:

  1. #include <boost/math/constants/constants.hpp>
  2. #include <iostream>
  4. struct animal
  5. {
  6.     std::string name;
  7.     int legs;
  8.     bool has_tail;
  9. };
  11. struct important_numbers
  12. {
  13.     const float pi = boost::math::constants::pi<float>();
  14.     const double e = boost::math::constants::e<double>();
  15. };
  17. template <class T>
  18. void debug(const T &t)
  19. {
  20.     // TODO: Write member variables of t to standard output.
  21. }
  23. int main()
  24. {
  25.     animal a{ "cat", 4, true };
  26.     debug(a);
  28.     important_numbers in;
  29.     debug(in);
  30. }