forked from boostorg/mp11
56 lines
2.3 KiB
Plaintext
56 lines
2.3 KiB
Plaintext
////
|
|
Copyright 2017 Peter Dimov
|
|
|
|
Distributed under the Boost Software License, Version 1.0.
|
|
|
|
See accompanying file LICENSE_1_0.txt or copy at
|
|
http://www.boost.org/LICENSE_1_0.txt
|
|
////
|
|
|
|
[#tuple]
|
|
# Tuple Operations, <boost/mp11/tuple.hpp>
|
|
:toc:
|
|
:toc-title:
|
|
:idprefix:
|
|
|
|
## tuple_apply(f, tp)
|
|
|
|
template<class F, class Tp> constexpr /*...*/ tuple_apply(F&& f, Tp&& tp);
|
|
|
|
`tuple_apply(f, tp)` returns `std::forward<F>(f)(std::get<J>(std::forward<Tp>(tp))...)` for `J` in 0..`N-1`,
|
|
where `N` is `std::tuple_size<typename std::remove_reference<Tp>::type>::value`. Same as `std::apply` in C++17.
|
|
|
|
## construct_from_tuple<T>(tp)
|
|
|
|
template<class T, class Tp> T construct_from_tuple(Tp&& tp);
|
|
|
|
`construct_from_tuple<T>(tp)` returns `T(std::get<J>(std::forward<Tp>(tp))...)` for `J` in 0..`N-1`,
|
|
where `N` is `std::tuple_size<typename std::remove_reference<Tp>::type>::value`. Same as `std::make_from_tuple` in {cpp}17.
|
|
The name of the function doesn't match the {cpp}17 one to avoid ambiguities when both are visible or in unqualified calls.
|
|
|
|
## tuple_for_each(tp, f)
|
|
|
|
template<class Tp, class F> constexpr F tuple_for_each(Tp&& tp, F&& f);
|
|
|
|
`tuple_for_each(tp, f)` applies the function object `f` to each element of `tp` in order by evaluating the
|
|
expression `f(std::get<J>(std::forward<Tp>(tp)))` for `J` in 0..`N-1`, where `N` is `std::tuple_size<typename std::remove_reference<Tp>::type>::value`.
|
|
|
|
Returns `std::forward<F>(f)`.
|
|
|
|
## tuple_transform(f, tp...)
|
|
|
|
template<class F, class... Tp> constexpr /*...*/ tuple_transform(F const& f, Tp&&... tp);
|
|
|
|
`tuple_transform(f, tp...)` accepts a function object `f` followed by one or more tuples of equal length
|
|
(`std::tuple`, `std::pair` and `std::array` are considered tuples.)
|
|
|
|
The callable `f` must accept as many arguments as there are tuples. The function object is called with the
|
|
first elements of each tuple, with the second elements of each tuple, and so on, as if by evaluating
|
|
the expression `f(std::get<J>(std::forward<Tp>(tp))...)` for `J` in 0..`N-1`, where `N` is the length of
|
|
the tuples.
|
|
|
|
The order in which the elements of the tuples are processed is unspecified.
|
|
|
|
The results are returned as a `std::tuple<T...>` with `T...` deduced from the return values of `f` (lvalue
|
|
references are preserved, rvalue references are returned by value.)
|