Would this be a language or a library change?   With user defined decay, you mean conversion operators defined in the class? And new ones should be added for specific standard library types?   Or do you mean an automatic decay / conversion, even if not specified in the class?   Or is it specifically about rules, if type deduction is done with auto or for templates?   -----Ursprüngliche Nachricht----- Von:Marcin Jaczewski via Std-Proposals <std-proposals_at_[hidden]> Gesendet:Do 20.03.2025 17:16 Betreff:[std-proposals] User defined decay operator An:std-proposals <std-proposals_at_[hidden]>; CC:Marcin Jaczewski <marcinjaczewski86_at_[hidden]>; Right now the only type that undergoes decaying is C array (aside of refs or bit fields). Some consider this "bad feature" but for me this is more is "bad implementation" of "good feature". I think that many user defined types could benefit from this functionality. Proxy objects: ```    std::vector<bool> ff = { false, false };    for (auto b : ff)    {        b = true;    }    assert(ff[0] == true); ``` Expression templates: ``` auto matrix = Matrix2x2{1, 2, 3, 4} auto mul = matrix * Vector2{3, 4}; Vector2 v = mul + Vector2{1, 1}; //UB because `mul` is expression and dangle temporal vector ``` Recent problem discussed on this mailing list with ref types: ``` auto [a, b] = std::minmax(foo, 10); auto c = a; // UB if `a` refer to `10` ``` Another could be a safer version of C array that is not copyable like `std::array` and instead of decay to pointer, it will decay to `std::span`. And finally if someone desires to ban "Almost Always Auto" as it could be useful for very heavy types for unexpected copies in generic code (by setting `= delete`). ``` auto x = a; //error auto& x = a; //ok, no decay NestedVector x = a; //ok auto x = NestedVector{ a }; //ok ``` Code that enable it would look like: ``` struct Foo {    Bar operator auto()    {        return Bar{};    } }; struct auto_ptr //pre C++11 unique_ptr {    //nothing change but in places where it could be used diagnostic is raised    [[obsolete]] auto_ptr operator auto() = default; }; struct MyArray {    //ban decay from temp objects like return from functions.    std::span<int> operator auto() && = deleted;    std::span<int> operator auto(); }; template<typename T1, typename T2> struct MyTuple {    T1 t1;    T2 t2;    //decay propagate to members, making ref tuple safer to use if returned form `std::minmax`    MyTuple<std::decay_t<T1>, std::decay_t<T2>> operator auto() { return { t1, t2 }; } }; ``` When a type has multiple `operator auto` then all versions need to return the same type. Additionally, the returned type need not have a decay operator (or its `=default`). Overall this make `auto x =` generally more safe to use and more regular. -- Std-Proposals mailing list Std-Proposals_at_[hidden] https://lists.isocpp.org/mailman/listinfo.cgi/std-proposals