Question about coro::when_all result

[Toilettrauma]

Hi! When I use coro::when_all and then calling return_value() with std::move the result is l-value reference.
Like in this piece of code on MSVC:

  auto test_coro = [](std::string val) -> coro::task<std::string> {
    co_return val;
  };
  auto [task1, task2] = co_await coro::when_all(
    test_coro("blabla"),
    test_coro("bleh")
  );

  decltype(auto) result_from_1 = std::move(task1).return_value();

The type of result_from_1 is std::string&. Shouldn't it be std::string&&?
Or do I just need to move the value instead?

  decltype(auto) result_from_2 = std::move(task2.return_value());

[jbaldwin]

Hi I'll probably have some time to look at this next week, I am currently without a computer on vacation

[jbaldwin]

I did some testing and it seems like it behaves fine as long as you just use auto, is there a good reason you are using decltype (auto) as the variables defined type? The result you are getting seems expected since auto will strip the references and allow you to correctly get to the root object std::string where decltype(auto) is going to leave the references on since its basically forwarding it to some degree. My understanding on this might be limited/lacking but that is what seems to be going on to me.

TEST_CASE("when_all move return_value vs move when_all_task", "[when_all]")
{
    auto make_test = []() -> coro::task<void>
    {
        auto make_when_all_moves = [](std::string value) -> coro::task<std::string>
        {
            co_return value;
        };

        auto [task0, task1, task2, task3, task4, task5] = coro::sync_wait(coro::when_all(
            make_when_all_moves("nothing"),
            make_when_all_moves("foo"),
            make_when_all_moves("bar"),
            make_when_all_moves("foobar"),
            make_when_all_moves("foofoo"),
            make_when_all_moves("barfoo")
        ));

        auto result0 = task0.return_value();                        // std::string
        auto result1 = std::move(task1.return_value());             // std::string
        auto result2 = std::move(task2).return_value();             // std::string
        decltype (auto) result3 = task3.return_value();             // std::string&
        decltype (auto) result4 = std::move(task4.return_value());  // std::string&&
        decltype (auto) result5 = std::move(task5).return_value();  // std::string&&

        REQUIRE(result0 == "nothing");
        REQUIRE(result1 == "foo");
        REQUIRE(result2 == "bar");
        REQUIRE(result3 == "foobar");
        REQUIRE(result4 == "foofoo");
        REQUIRE(result5 == "barfoo");

        co_return;
    };

    coro::sync_wait(make_test());
}
``

[Toilettrauma]

Hi! Sorry for misunderstanding, because lack of extra information, I used decltype(auto) to clarify, that r-value task returns l-value reference to value, this cause compiler to use copy ctor. In your code, there are lines for result2 and result5. Does it really return r-value?

#include <coro/sync_wait.hpp>
#include <coro/when_all.hpp>
#include <coro/task.hpp>

#include <iostream>

struct TestObject {
	TestObject() = default;
	TestObject(const TestObject& other) {
		std::cout << "TestObject copy-ctor\n";
	}
	TestObject(TestObject&& other) {
		std::cout << "TestObject move-ctor\n";
	}
};

int main() {
	auto make_when_all_moves = []() -> coro::task<TestObject>
	{
		co_return {};
	};

	auto [task0, task1, task2] = coro::sync_wait(coro::when_all(
		make_when_all_moves(),
		make_when_all_moves(),
		make_when_all_moves()
	));

	std::cout << "\nGetting values\n";

	auto result0 = task0.return_value();
	auto result1 = std::move(task1.return_value());
	auto result2 = std::move(task2).return_value();
}

Result of the program for me in MSVC is:

TestObject move-ctor
TestObject move-ctor
TestObject move-ctor

Getting values
TestObject copy-ctor
TestObject move-ctor
TestObject copy-ctor

It shows, that the last moved task actually used copy contructor.
Hope this will be more precise for my problem.

[Toilettrauma]

I think it's because return_value() && getting promise & and so calling result() &, but when I move promise, it stops compiling with error "forward": no matching overloaded function found.

// when_all.hpp
// ...
    auto return_value() && -> decltype(auto)
    {
        if constexpr (std::is_void_v<return_type>)
        {
            m_coroutine.promise().result();
            return void_value{};
        }
        else
        {
            return m_coroutine.promise().result(); // << here, the promise is l-value
            // return std::move(m_coroutine.promise()).result(); // compile error
        }
    }
// ...