On Mon, Aug 29, 2022 at 10:08 AM Marcin Jaczewski via Std-Proposals <std-proposals@lists.isocpp.org> wrote:
pon., 29 sie 2022 o 15:54 Михаил Найденов via Std-Proposals <std-proposals@lists.isocpp.org> napisał(a):
> I personally think, this should be a minimal-syntax, non-overridable, unary postscript operator that will work for both forward and move, much like cast-to-T&& today
> template <typename T> Dog(T&& name) : name(name&&) {} //< forward
> Name(string&& aName) : name(aName&&)  //< move

There have been proposals (at least informally — maybe formally?) for the unary `>>` operator, as in
    Dog(auto&& name) : name_(>>name) {}  // in lieu of std::forward<decltype(name)>(name)
    Name(std::string name) : name_(>>name) {}  // arguably a misuse? but would work anyway, if not artificially prohibited
Barry Revzin has been involved in this area.

The close-at-hand way to get this into C++ would be via a cast to `decltype(name)`, which has been proposed and seen by the Committee under the name `decltype(auto)(x)`. When `x` is a reference variable, `decltype(x)` is the proper reference type. This would give us:
    Dog(auto&& name) : name_(decltype(auto)(name)) {}
    Name(std::string name) : name_(std::move(name)) {}
However, at last report it sounds like the Committee wasn't a big fan of how arcane this looked.
Notice that the `decltype` is critical here; if you were to do `auto(name)`, you'd always get a copy, because `name` is an lvalue.
    Dog(auto&& name) : name_(auto(name)) {}  // valid C++23, but does not do forwarding!!

> On Mon, Aug 29, 2022 at 2:31 AM Amar Saric via Std-Proposals <std-proposals@lists.isocpp.org> wrote:
>> #define ref_forward(p)  (std::forward<pf::\
>>         remove_rvalue_reference<typename pf::\
>>         check_if_ref<decltype(p)>::type>>(p))
>> #define ref_to_rvalue(p) (std::move(p))

Amar, you propose a "simplification" that is dozens of lines long, and ends up delegating to `std::forward` anyway. That's... unnecessary.
std::forward is nothing more than a cast to a reference type. You can do it like this — and my impression is that some people do, in real production code.

    #define FWD(x) decltype(x)(x)

When `decltype(x)` is an rvalue reference type, this is a move. When `decltype(x)` is an lvalue reference type, this is a no-op.

You don't need a macro for `std::move(x)`, as it's already pretty short. (Certainly shorter than your `ref_to_rvalue(x)`!)