I am not sure I like this. I can see this as adding functionality to classes and struct that were never designed to add functionality to. 
Also how would this interact with classes that derived from A and C or using thing like std::tuple or std::pair?

On Tue, Feb 25, 2020 at 2:05 PM Владимир Прокофьев via Std-Proposals <std-proposals@lists.isocpp.org> wrote:

I have a proposal for the operator of function.

Imagine the completed and finished struct which we cannot modify without breaking compatibility.

file: a.h

    struct A
        int a1 = 0;
        int a2 = 0;
        int GetA1() const { return a1; }
        int GetA2() const { return a2; }

I need to add a new functional for this struct and add a new function to perform some actions under object of this struct:
Because struct A is declared in a file which we cannot modify, I have to declare a separate function:

    int diff(const A& a)
        return a.a1 - a.a2;

and use it as like a regular function:

    A a;

    int d = diff(a);

with the new `operator function` it will look like:

      // same as
    // int diff(const &A a)
    // {
    //    return a.a1 - a.a2;
    // }
    operator int(const A& a) diff
        return a.a1 - a.a2;

    int d = a.diff();

This is a sintax sugar, but it helps to make code simpler.

It can be confusing with some sort of arguments:

    operator int(A* a) base
        return a->a1 + a->a2;

    A *aa = &a;
    int d = aa.base(); // use `.` notation with a pointer

It supports inheritance:

    struct B : A
        int d;

    int d = b.diff();


The `operator function` brings another kind of object - multiple.

    struct C
        int c;

    // same as
    // int mult(const A& a, const C& c)
    // {
    //    return a.diff() * c.c;
    // }
    operator int(const A& a, const C& c) mult
        return a.diff() * c.c;

It can be used when several objects are combined to perform some common action(s):
    A a;
    C c;
    int m = [a,c].mult();

    auto o = [a,c];

    int m = o.mult();

//  work with `o` like with a single object.

//    int m = mult(a,c);

The `operator function` allow extending any frozen functional without intervention
into the complete code, but it makes code looks like already provides desired functional with
additional declaration.

With best regards.


Std-Proposals mailing list