For me, this approach has some merits, but this particular example is something that, to me, makes much more sense as a free function.

Do you have further examples? 

On Sun, 8 Mar 2020, 21:55 Phil Bouchard via Std-Proposals, <std-proposals@lists.isocpp.org> wrote:

Well I believe a proposal should be open for debate, just like a thesis.

We both agree these overloads should be simplified but we disagree on the syntax.

I saw the recursive lambda thing and I think I already talked to you before regarding CV overloads but we were proposing the following syntax:

struct A

{

    template <bool BC>

        void foo() bool<BC>

        {

        }

};

And regarding the this generic overloading I still believe the following syntax is cleaner:

struct A

{

    template <typename T>

        bool compare(T const &);

};

template <typename C, typename T>

    void C::compare(C const &)

    {

        ...

    }

Because with your syntax I could technically reassign "self":

struct A

{

    template <typename C, typename T>

        bool compare(this C & c, T const &);

};

template <typename C, typename T>

    bool C::compare(this C & c, T const &) // redundant C here

    {

        static C sc = C();

        c = sc; // in theory we could do this unless you patch the compilers with a new error for that specific case

    }


--

Phil Bouchard
Founder
C.: (819) 328-4743

Fornux Logo


On 3/8/20 5:37 AM, Gašper Ažman wrote:
I meant that you should consider the incremental value of your proposal over p0847, which is on track for c++23 unless serious issues crop up

On Sat, Mar 7, 2020, 19:04 Phil Bouchard <phil@fornux.com> wrote:

The syntaxes are way different:

http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2020/p0847r4.html

In your case the compiler will have to change all of its rules for the number of parameters "operator" overloads. For example:

struct A

{

    int value;

    ...

    template <typename Self>

        bool operator < (this Self && self, A const & a) // 2 parameters... ok

        {

            return self.value < a.value;

        }


        bool operator < (A const & a) // 1 parameter... ok

        {

            return value < a.value;

        }

};


--

Phil Bouchard
Founder
C.: (819) 328-4743

Fornux Logo


On 3/7/20 1:35 PM, Gašper Ažman wrote:
P0847

On Sat, Mar 7, 2020, 18:33 Phil Bouchard via Std-Proposals <std-proposals@lists.isocpp.org> wrote:

Alright, I'm pretty sure this is not implemented yet. Suppose you have:

struct A

{

    int value;

    ...

    template <typename T>

        int compare(T const & t) const;

}


struct B

{

    int value;

    ...

    template <typename T>

        int compare(T const & t) const;

}


Then a generic way to define the same functionality for all classes would be to have a "template 'this'":

template <typename C, typename T>

        inline int C::compare(T const & t) const

        {

            return value == t.value ? 0 : value < t.value ? -1 : 1;

        }


(Please include my email address in your replies)


--

Phil Bouchard
Founder
C.: (819) 328-4743

Fornux Logo
--
Std-Proposals mailing list
Std-Proposals@lists.isocpp.org
https://lists.isocpp.org/mailman/listinfo.cgi/std-proposals
--
Std-Proposals mailing list
Std-Proposals@lists.isocpp.org
https://lists.isocpp.org/mailman/listinfo.cgi/std-proposals