Boost.Hana: boost::hana::tuple< Xn > Struct Template Reference

| Boost.Hana 1.5.0 Your standard library for metaprogramming |

Synopsis of associated functions | Friends | Public Member Functions | List of all members
boost::hana::tuple< Xn > Struct Template Reference
Data types

## 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::type`s. More...
template<typename T , T... v>
constexpr implementation_defined | tuple_c {}
| Create a tuple specialized for holding `hana::integral_constant`s. 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

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), "");
}
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::type`s.

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)>)
);
}
template<typename... Xn>
template<typename T , T... v>

constexpr implementation_defined tuple_c {}
| related

Create a tuple specialized for holding `hana::integral_constant`s.

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

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.