Otdfbt

What would be a valid use case for a signature like this?:

T&& foo();

Or is the rvalue ref only intended for use as argument?

How would one use a function like this?

T&& t = foo(); // is this a thing? And when would t get destructed?

For a free function it doesn't make much sense to return a rvalue reference. If it is a non-static local object then you never want to return a reference or pointer to it because it will be destroyed after the function returns. It can possibly make sense to return a rvalue reference to an object that you passed to the function though. It really depends on the use case for if it makes sense or not.

One thing that can greatly benefit from returning an rvalue reference is a member function of a temporary object. Lets say you have

class foo

 std::vector<int> bar
public:
 foo(int n) : bar(n) 
 std::vector<int>& get_vec() return bar; 
;

If you do

auto vec = foo(10).get_vec();

you have to copy because get_vec returns an lvalue. If you instead use

class foo

 std::vector<int> bar
public:
 foo(int n) : bar(n) 
 std::vector<int>& get_vec() & return bar; 
 std::vector<int>&& get_vec() && return std::move(bar); 
;

Then vec would be able to move the vector returned by get_vec and you save yourself an expensive copy operation.

T&& t = foo(); // is this a thing? And when would t get destructed?

An rvalue reference is really similar to a lvalue reference. Think about your example like it was normal references:

T& foo();

T& t = foo(); // when is t destroyed?

The answer is that t is still valid to use as long as the object is refers to lives.

The same answer still applies to you rvalue reference example.

But... does it make sense to return an rvalue reference?

Sometimes, yes. But very rarely.

consider this:

std::vector<int> v = ...;

// type is std::tuple<std::vector<int>&&>
auto parameters = std::forward_as_tuple(std::move(v));

// fwd is a rvalue reference since std::get returns one.
// fwd is valid as long as v is.
decltype(auto) fwd = std::get<0>(parameters);

// useful for calling function in generic context without copying
consume(std::get<0>(parameters));

So yes there are example. Here, another interesting one:

struct wrapper 

 auto operator*() & -> Heavy& 
 return heavy;
 

 auto operator*() && -> Heavy&& 
 return std::move(heavy);
 

private:
 Heavy instance;
;

// by value
void use_heavy(Heavy);

// since the wrapper is a temporary, the
// Heavy contained will be a temporary too. 
use_heavy(*make_wrapper());

I think a use case would be to explicitly give permission to "empty" some non-local variable. Perhaps something like this:

class Logger

public:
 void log(const char* msg)
 logs.append(msg);
 
 std::vector<std::string>&& dumpLogs()
 return std::move(logs);
 
private:
 std::vector<std::string> logs;
;

But I admit I made this up now, I never actually used it and it also can be done like this:

std::vector<std::string> dumpLogs()
 auto dumped_logs = logs;
 return dumped_logs;