www.digitalmars.com         C & C++   DMDScript  

digitalmars.D - Functions as Struct Properties

reply Sam S E <eisenstat.aa sympatico.ca> writes:
Hi,

We already have the notation:

int[] array;
void foo(int[] a, int x);

foo(array, 3);
array.foo(3);	// means the same thing

so why not extend this to struct first arguments?
--Sam
Nov 22 2008
next sibling parent reply "Nick Sabalausky" <a a.a> writes:
"Sam S E" <eisenstat.aa sympatico.ca> wrote in message 
news:gga2ua$15v7$1 digitalmars.com...

 Hi,

 We already have the notation:

 int[] array;
 void foo(int[] a, int x);

 foo(array, 3);
 array.foo(3); // means the same thing

 so why not extend this to struct first arguments?
 --Sam



A lot of people want that to be extended to all types. It just doesn't seem 
to be happening for some reason. Another popular approach (my preference) is 
something closer to C#'s way of doing it:

int x;
void foo(extension int a, int b);
void bar(int a, int b);

foo(x, 3); // Ok
x.foo(3); // Ok

bar(x, 3); // Ok
x.bar(3); // Error
Nov 22 2008
parent Sam S E <eisenstat.aa sympatico.ca> writes:
Nick Sabalausky Wrote:


 "Sam S E" <eisenstat.aa sympatico.ca> wrote in message 
 news:gga2ua$15v7$1 digitalmars.com...

 Hi,

 We already have the notation:

 int[] array;
 void foo(int[] a, int x);

 foo(array, 3);
 array.foo(3); // means the same thing

 so why not extend this to struct first arguments?
 --Sam



 A lot of people want that to be extended to all types. It just doesn't seem 
 to be happening for some reason. Another popular approach (my preference) is 
 something closer to C#'s way of doing it:
 
 int x;
 void foo(extension int a, int b);
 void bar(int a, int b);
 
 foo(x, 3); // Ok
 x.foo(3); // Ok
 
 bar(x, 3); // Ok
 x.bar(3); // Error
 
 



That's a good idea, but I would put the keyword on the second case, since you
would rarely want to restrict the syntax, causing less typing. I also realized
that this could enable a more flexible op overloading syntax:

static Foo opAdd(invariant Foo x, int y)
{
    ...
}

Using current syntax, you can't make the Foo invariant. This has been causing
problems with porting a C++ program to D, since C++ supports:

class Foo
{
    ...
    Foo opAdd(int) const
    {
        ...
    }
}

--Sam
Nov 22 2008
prev sibling parent "Robert Jacques" <sandford jhu.edu> writes:
On Sat, 22 Nov 2008 18:00:26 -0500, Sam S E <eisenstat.aa sympatico.ca>  
wrote:


 Hi,

 We already have the notation:

 int[] array;
 void foo(int[] a, int x);

 foo(array, 3);
 array.foo(3);	// means the same thing

 so why not extend this to struct first arguments?
 --Sam



This was part of the "Future of D" talk at the D conference (see Uniform  
function types, page 9 http://s3.amazonaws.com/dconf2007/WalterAndrei.pdf )
Nov 22 2008