Boost.Hana  1.5.0
Your standard library for metaprogramming
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 <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 tupleoperator= (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 tupleoperator= (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

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 <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), "");
}
template<typename... Xn>
constexpr auto make_tuple = make<tuple_tag>
related

Alias to make<tuple_tag>; provided for convenience.

template<typename... Xn>
constexpr auto to_tuple = to<tuple_tag>
related

Equivalent to to<tuple_tag>; provided for convenience.

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)
namespace hana = boost::hana;
int main() {
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)>)
);
}
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)
namespace hana = boost::hana;
int main() {
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

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