Can you invert the order of argument-expansion in an initializer-list?

Question

I am writing a custom interpreted language, which uses a LIFO-stack for data-manipulation. At two places, I need to be able to construct a tuple from values that are stored on the stack. In principle, this code would look like this:

template
[[nodiscard]] inline std::tuple popTupleFromStack(Stack& stack)
{
    return { stack.Pop()... };
}

However, there is a fundamental problem with the LIFO-ordering of the stack: The initializer-list order dictates that calls happen left-to-right, which means that it would actually try to pop the elements in the completely inverse order. Is there any easy way to inverse this order?

I know that fold-expressions allow you to specify left- or right-folds, but it doesn't seem that you can use fold-expressions when you need to initialize an object with the result.

The closes I've come is manually specifying overloadings for the potential number of arguments in the tuple:

template
[[nodiscard]] inline std::tuple popStackTuple(Stack& stack)
{
    return { stack.Pop() };
}

template
[[nodiscard]] inline std::tuple popStackTuple(Stack& stack)
{
    Arg1 arg1 = stack.Pop();
    Arg0 arg0 = stack.Pop();

    return { arg0, arg1 };
}

But this obviously limits the number of arguments I can support, and/or results in a lot of "unnecessary" code. And it seems like such a minor thing not being able to be done with modern C++ (I have everything up to, including C++20 at my disposal if it makes any difference).

user_2684539 · Answer

You might reverse tuple afterward

template 
auto reverse_tuple_impl(std::index_sequence, Tuple& tuple)
{
    using res_type = std::tuple>...>;
Is, std::decay_t>>;
    return res_type(std::get(tuple)...);
}

template 
auto reverse_tuple(std::tuple& tuple)
{
    return reverse_tuple_impl(std::index_sequence_for(), tuple);
}

Demo

user_6022656 · Answer

Non a great improvement but... if you can use C++20, so template lambdas, you can embed the helper function inside reverse_tuple()

template 
auto reverse_tuple (std::tuple & tuple)
 {
   return [&] (std::index_sequence)
      { return std::make_tuple(std::get(tuple)...); }
    (std::index_sequence_for{});
 }

Can you invert the order of argument-expansion in an initializer-list?

2 Answers