std::apply may not be properly implemented - c++

Question

std::apply is mentioned in few stackoverflow answers and n3658, n3915 and usually defined as:
template <typename F, typename Tuple, size_t... I>
decltype(auto) apply_impl(F&& f, Tuple&& t, index_sequence<I...>) {
return forward<F>(f)(get<I>(forward<Tuple>(t))...);
}
template <typename F, typename Tuple>
decltype(auto) apply(F&& f, Tuple&& t) {
using Indices = make_index_sequence<tuple_size<decay_t<Tuple>>::value>;
return apply_impl(forward<F>(f), forward<Tuple>(t), Indices{});
}
However the reference implementation std::apply function fails to compile in such context (tested with clang 3.8 and gcc 5.2):
std::apply ([] (int&) {} , std::make_tuple (42));
One possible workaround is simply to remove std::forward<Tuple> from apply_impl but leave the universal reference intact:
template <typename F, typename Tuple, size_t... I>
decltype(auto) apply_impl(F&& f, Tuple&& t, index_sequence<I...>) {
return forward<F>(f)(get<I>(t)...);
}
Is there any drawbacks of this workaround? Is there more convenient solution possible?
UPDATE: Another possible workaround without changing std::apply (inspired by this SO answer):
template <typename T> constexpr T& make_tmp (T&& t) noexcept { return t; }
...
std::apply ([] (int& i) {} , make_tmp (std::make_tuple (42)));
Is it correct and result well defined?

Answer 1

When you have a temporary tuple containing a temporary object (or a reference to a temporary object), a function that demands a writable reference is right to reject the application. The function expects callers to pay attention to what it writes, and you are deterministicly discarding it.
Here is code that compiles:
int main() {
int i = 42;
std::apply ([] (int&) {} , std::tie(i) );
}
make_tuple creates a tuple of copies. apply then invokes the passed-in f on the soon to be discarded copies: these are quite properly treated as rvalues.
If you have an object which you want to pass by-reference through std::apply, put a reference to it in the tuple, not a copy of it. Then the rvalue-ness of the tuple within apply does not apply to reference contents.
For std::get<N>(some_tuple) to return an rvalue, either:
(A) the nth element must be a copy, and the tuple must be an rvalue
(B) the nth element must be an rvalue reference, and the tuple must be an rvalue reference
By storing an lvalue reference, std::get will never return an rvalue reference.
You probably want to call std::tie or std::forward_as_tuple depending on the situation. std::make_tuple is for when you want to create a copy in the tuple, not when you are storing references to other objects.
There are ways to allow you to pass rvalues as lvalues when you do want to discard any modifications, but those are usually bad ideas, and they should be done in client code with big warning stickers all over the place, not implicitly in a library.
template<class T>
T& as_lvalue( T&& t ) { return t; }
is a simple one.