The object operator

[BBasile via Digitalmars-d]

On Friday, 14 August 2015 at 04:17:25 UTC, TheHamster wrote:
> For class types, a special operator is defined to return the 
> class object for method calls rather than the return value from 
> the call itself. The use of the operator places the return 
> types in special variables to be accessed easily. The operator 
> is simply a syntax helper and is along the lines of UFCS.
>
> e.g.,
>
> class myClass
> {
>      Do(int x) { return x + 2; }
>
> }
>
> auto myObj = new myClass();
> assert(@@myObj.Do(3).Do(4).Do(5) == 7);
>
> Of course, such a silly example is not very helpful but 
> demonstrates the concept.
>
> To make such a syntax work well, I believe one then needs a 
> further operator to access the last return value.
>
> e.g.,
>
> assert(@@myObj.Do(3).Do(@).Do(@2) == 9);
>
> Where the same symbol is used for there return value 
> placeholders and indices are used to access nested calls return 
> value with @ defaulting to @1.
>
> Essentially such syntax allows for easily doing nested calls.
>
> The only down side is that the operator could only be used on 
> one method call at a type in the nesting. (or multiple or 
> parameritized operators would be required)
>
> Obviously @ would not be the symbol of choice.

Actually you can already do that by encapsulating a field an 
playing with a property setter that also return `this`:

---
class Foo
{
     private int _field;
     Foo bar(int x) {_field += x + 2; return this;}
     int bar(){return _field;}
}

void main(string[] args)
{
     auto foo = new Foo;
     // same as assert(@@myObj.Do(3).Do(@).Do(@2) == 9);
     assert(foo.bar(3).bar(foo.bar).bar(foo.bar).bar == 9);

     auto f = new Foo;
     // same as assert(@@myObj.Do(3).Do(@).Do(@2) == 9);
     with(f) {assert(bar(3).bar(bar).bar(bar).bar == 9);}
}
---