# Apply tuple to a function

`12345678910111213141516171819202122232425262728293031` | ```
#include <cstddef>
#include <tuple>
#include <type_traits>
#include <utility>
template<typename F, typename Tuple, size_t ...S >
decltype(auto) apply_tuple_impl(F&& fn, Tuple&& t, std::index_sequence<S...>)
{
return std::forward<F>(fn)(std::get<S>(std::forward<Tuple>(t))...);
}
template<typename F, typename Tuple>
decltype(auto) apply_from_tuple(F&& fn, Tuple&& t)
{
std::size_t constexpr tSize
= std::tuple_size<typename std::remove_reference<Tuple>::type>::value;
return apply_tuple_impl(std::forward<F>(fn),
std::forward<Tuple>(t),
std::make_index_sequence<tSize>());
}
int do_sum(int a, int b)
{
return a + b;
}
int main()
{
int sum = apply_from_tuple(do_sum, std::make_tuple(10, 20));
}
``` |

This pattern is licensed under the CC0 Public Domain Dedication.

## Intent

Unpack a tuple as the arguments of a function.

## Description

The `apply_from_tuple`

function template on lines 12–21 returns the
result of applying the function `fn`

to the values stored in the
`std::tuple`

`t`

. On lines 15–16, we store the
size of `t`

in `tSize`

, which is declared `constexpr`

so that
it can be evaluated at compile-time. On lines 18–20, we call
`apply_tuple_impl`

passing `t`

, `fn`

and an
`std::index_sequence`

which carries a parameter pack containing a sequence of integers
from `0`

to `tSize - 1`

.

The `apply_tuple_impl`

function template on lines 6–10 returns the
result of applying the function `fn`

using event element of the
tuple `t`

as arguments (on line 9). To do this, we expand the
parameter pack carried by the `std::index_sequence`

and apply
`std::get`

to the tuple for each
integer in the sequence. This way, all the elements of `t`

are
expanded and passed to the function.

**Note**: a `std::apply`

function has
been proposed as part of the Library Fundamentals TS for future
standardization.