• Sam S E (8/8) Nov 22 2008 Hi,
• Nick Sabalausky (12/20) Nov 22 2008 A lot of people want that to be extended to all types. It just doesn't s...
• Sam S E (16/46) Nov 22 2008 That's a good idea, but I would put the keyword on the second case, sinc...
• Robert Jacques (4/12) Nov 22 2008 This was part of the "Future of D" talk at the D conference (see Uniform...

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

"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 


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

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 

 
 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

"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 )