Boost.Hana  1.0.2
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.

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-2016
// 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-2016
// 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-2016
// 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-2016
// 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_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.