Why does the const rvalue qualified std::optional::value() return a const rvalue reference?

Question

std::optional::value() has the following two overloads

constexpr T& value() &;
constexpr const T & value() const &; 
constexpr T&& value() &&;
constexpr const T&& value() const &&;

What is the point of returning a const rvalue reference?

The only reason I can think of is to enable the compiler to help catch undefined behavior in (really really weird) cases like the following

auto r = std::cref(const_cast<const std::optional<int>&&>(
    std::optional<int>{}).value());

Where if the std::optional::value() had returned a const T& then the above code would compile and would lead to undefined behavior when the r reference_wrapper was used later.

Is there any other corner case in mind with the above returning a const T&&?

Answer 1

Sure. You have a const optional<T> in struct. You return an rvalue instance and access the optional member.

Because of how you constructed it, you can guarantee the optional is engaged in this case. So you call value(). The type T contains mutable state that can be efficiently be reused/stolen. The T const&& overload gives the consuming function permission to steal that state.

struct mutable_type {
  mutable std::vector<char> cache;
};
struct test_type {
  const std::optional<mutable_type> bob;
};
test_type factory( int x ) {
  if (x==0) return {};
  return {mutable_type({{1,2,x}})};
}

auto moved_into = factory(3).bob.value().cache;

This, I believe, moves the vector within bob, which is a const rvalue in this context. It relies on value() returning a const&& in a const&& context.