boost::hana::tuple< Xn > Struct Template Reference

Description

template<typename ... Xn>
struct boost::hana::tuple< Xn >

General purpose index-based heterogeneous sequence with a fixed length.

The tuple is the bread and butter for static metaprogramming. Conceptually, it is like a std::tuple; it is a container able of holding objects of different types and whose size is fixed at compile-time. However, Hana's tuple provides much more functionality than its std counterpart, and it is also much more efficient than all standard library implementations tested so far.

Tuples are index-based sequences. If you need an associative sequence with a key-based access, then you should consider hana::map or hana::set instead.

Note

When you use a container, remember not to make assumptions about its representation, unless the documentation gives you those guarantees. More details in the tutorial.

Modeled concepts

Sequence, and all the concepts it refines

Provided operators

For convenience, the following operators are provided:

xs == ys        ->          equal(xs, ys)
xs != ys        ->          not_equal(xs, ys)

xs < ys         ->          less(xs, ys)
xs <= ys        ->          less_equal(xs, ys)
xs > ys         ->          greater(xs, ys)
xs >= ys        ->          greater_equal(xs, ys)

xs | f          ->          chain(xs, f)

xs[n]           ->          at(xs, n)

Example

// 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/integral_constant.hpp>
#include <boost/hana/transform.hpp>
#include <boost/hana/tuple.hpp>

#include <string>
namespace hana = boost::hana;
using namespace hana::literals;


struct Fish { std::string name; };
struct Cat  { std::string name; };
struct Dog  { std::string name; };

int main() {
    hana::tuple<Fish, Cat, Dog> animals{{"Nemo"}, {"Garfield"}, {"Snoopy"}};
    animals[0_c].name = "Moby Dick"; // can modify elements in place, like std::tuple

    auto names = hana::transform(animals, [](auto a) {
      return a.name;
    });

    BOOST_HANA_RUNTIME_CHECK(names == hana::make_tuple("Moby Dick", "Garfield", "Snoopy"));
}

Inheritance diagram for boost::hana::tuple< Xn >:

Synopsis of associated functions
template<>
constexpr auto	make< tuple_tag >
	Function object for creating a tuple. More...
constexpr auto	make_tuple = make<tuple_tag>
	Alias to make<tuple_tag>; provided for convenience. More...
constexpr auto	to_tuple = to<tuple_tag>
	Equivalent to to<tuple_tag>; provided for convenience. More...
template<typename ... T>
constexpr implementation_defined	tuple_t {}
	Create a tuple specialized for holding hana::types. More...
template<typename T , T ... v>
constexpr implementation_defined	tuple_c {}
	Create a tuple specialized for holding hana::integral_constants. More...

Friends
template<typename ... T, typename F >
constexpr auto	operator| (tuple< T... >, F)
	Equivalent to hana::chain.
template<typename X , typename Y >
constexpr auto	operator== (X &&x, Y &&y)
	Equivalent to hana::equal
template<typename X , typename Y >
constexpr auto	operator!= (X &&x, Y &&y)
	Equivalent to hana::not_equal
template<typename X , typename Y >
constexpr auto	operator< (X &&x, Y &&y)
	Equivalent to hana::less
template<typename X , typename Y >
constexpr auto	operator> (X &&x, Y &&y)
	Equivalent to hana::greater
template<typename X , typename Y >
constexpr auto	operator<= (X &&x, Y &&y)
	Equivalent to hana::less_equal
template<typename X , typename Y >
constexpr auto	operator>= (X &&x, Y &&y)
	Equivalent to hana::greater_equal

Public Member Functions
constexpr	tuple ()
	Default constructs the tuple. Only exists when all the elements of the tuple are default constructible.
constexpr	tuple (Xn const &...xn)
	Initialize each element of the tuple with the corresponding element from xn.... Only exists when all the elements of the tuple are copy-constructible. More...
template<typename ... Yn>
constexpr	tuple (Yn &&...yn)
	Initialize each element of the tuple by perfect-forwarding the corresponding element in yn.... Only exists when all the elements of the created tuple are constructible from the corresponding perfect-forwarded value. More...
template<typename ... Yn>
constexpr	tuple (tuple< Yn... > const &other)
	Copy-initialize a tuple from another tuple. Only exists when all the elements of the constructed tuple are copy-constructible from the corresponding element in the source tuple.
template<typename ... Yn>
constexpr	tuple (tuple< Yn... > &&other)
	Move-initialize a tuple from another tuple. Only exists when all the elements of the constructed tuple are move-constructible from the corresponding element in the source tuple.
template<typename ... Yn>
constexpr tuple &	operator= (tuple< Yn... > const &other)
	Assign a tuple to another tuple. Only exists when all the elements of the destination tuple are assignable from the corresponding element in the source tuple.
template<typename ... Yn>
constexpr tuple &	operator= (tuple< Yn... > &&other)
	Move-assign a tuple to another tuple. Only exists when all the elements of the destination tuple are move-assignable from the corresponding element in the source tuple.
template<typename N >
decltype(auto) constexpr	operator[] (N &&n)
	Equivalent to hana::at

Associated functions

make< tuple_tag >

template<typename ... Xn>

template<>

constexpr auto make< tuple_tag >

related

Initial value:

= [](auto&& ...xs) {
        return tuple<std::decay_t<decltype(xs)>...>{forwarded(xs)...};
    }

Function object for creating a tuple.

Given zero or more objects xs..., make<tuple_tag> returns a new tuple containing those objects. The elements are held by value inside the resulting tuple, and they are hence copied or moved in. This is analogous to std::make_tuple for creating Hana tuples.

Example

// 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/core/make.hpp>
#include <boost/hana/equal.hpp>
#include <boost/hana/tuple.hpp>

#include <string>
namespace hana = boost::hana;


int main() {
    auto xs = hana::make<hana::tuple_tag>(1, 2, '3', std::string{"456"});

    constexpr auto ys = hana::make<hana::tuple_tag>(1, '2', 3.456);
    static_assert(ys == hana::make_tuple(1, '2', 3.456), "");
}

make_tuple

template<typename ... Xn>

constexpr auto make_tuple = make<tuple_tag>

related

Alias to make<tuple_tag>; provided for convenience.

to_tuple

template<typename ... Xn>

constexpr auto to_tuple = to<tuple_tag>

related

Equivalent to to<tuple_tag>; provided for convenience.

tuple_t

template<typename ... Xn>

template<typename ... T>

constexpr implementation_defined tuple_t {}

related

Create a tuple specialized for holding hana::types.

This is functionally equivalent to make<tuple_tag>(type_c<T>...), except that using tuple_t allows the library to perform some compile-time optimizations. Also note that the type of the objects returned by tuple_t and an equivalent call to make<tuple_tag> may differ.

Example

// 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/core/to.hpp>
#include <boost/hana/equal.hpp>
#include <boost/hana/tuple.hpp>
#include <boost/hana/type.hpp>
namespace hana = boost::hana;


int main() {
    BOOST_HANA_CONSTANT_CHECK(
        hana::to_tuple(hana::tuple_t<int, char, void, int(float)>)
            ==
        hana::make_tuple(hana::type_c<int>, hana::type_c<char>, hana::type_c<void>, hana::type_c<int(float)>)
    );
}

tuple_c

template<typename ... Xn>

template<typename T , T ... v>

constexpr implementation_defined tuple_c {}

related

Create a tuple specialized for holding hana::integral_constants.

This is functionally equivalent to make<tuple_tag>(integral_c<T, v>...), except that using tuple_c allows the library to perform some compile-time optimizations. Also note that the type of the objects returned by tuple_c and an equivalent call to make<tuple_tag> may differ.

Example

// 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/core/to.hpp>
#include <boost/hana/equal.hpp>
#include <boost/hana/front.hpp>
#include <boost/hana/integral_constant.hpp>
#include <boost/hana/tuple.hpp>
namespace hana = boost::hana;


int main() {
    BOOST_HANA_CONSTANT_CHECK(
        hana::tuple_c<int, 0, 1, 2>
            ==
        hana::make_tuple(hana::int_c<0>, hana::int_c<1>, hana::int_c<2>)
    );

    BOOST_HANA_CONSTANT_CHECK(hana::front(hana::tuple_c<int, 0, 1, 2>) == hana::int_c<0>);
}

Constructor & Destructor Documentation

tuple() [1/2]

template<typename ... Xn>

constexpr boost::hana::tuple< Xn >::tuple

(

Xn const &...

xn

)

Initialize each element of the tuple with the corresponding element from xn.... Only exists when all the elements of the tuple are copy-constructible.

Note

Unlike the corresponding constructor for std::tuple, this constructor is not explicit. This allows returning a tuple from a function with the brace-initialization syntax.

tuple() [2/2]

template<typename ... Xn>

template<typename ... Yn>

constexpr boost::hana::tuple< Xn >::tuple

(

Yn &&...

yn

)

Initialize each element of the tuple by perfect-forwarding the corresponding element in yn.... Only exists when all the elements of the created tuple are constructible from the corresponding perfect-forwarded value.

Note

Unlike the corresponding constructor for std::tuple, this constructor is not explicit. This allows returning a tuple from a function with the brace-initialization syntax.