Hi everyone
I'm a newbie to D and I've spent some time in the last few days messing around, seeing how things work.

I noticed in a news posting that you can overload operators statically.. i.e.

///////////////

class Test
{
	private char[] memstring;

	this(char[] newstring)
	{
		memstring = newstring.dup;
	}

	char[] toString()
	{
		return memstring;
	}

	static Test opCat(char[] newstring)
	{
		return new Test(newstring);
	}

/+
	Test opCat(char[] newstring)
	{
		return new Test(memstring ~ newstring);
	}
+/
}

int main(char[][] args)
{
	Test bob = Test ~ "hello there";
	writefln(bob);
	return 0;
}

////////////////

Browsing through the documentation I didn't come across any mention that static member operators were supported. I was just wondering if they are in fact intentional?

Also:
I notice that having 2 member functions with the same signature, one static and one not, does not work (compiler claims it a conflicts). In particular, the above case, when the non-static opCmp is uncommented it will no longer compile.

Is there any notes in the documentation to this effect? because I could not find any.

Thanks for any reply.

Stuart Murray wrote:
> Hi everyone
> I'm a newbie to D and I've spent some time in the last few days messing around, seeing how things work.
> 
> I noticed in a news posting that you can overload operators statically..
> i.e.
> 
> ///////////////
> 
> class Test
> {
> 	private char[] memstring;
> 	
> 	this(char[] newstring)
> 	{
> 		memstring = newstring.dup;
> 	}
> 	
> 	char[] toString()
> 	{
> 		return memstring;
> 	}
> 	
> 	static Test opCat(char[] newstring)
> 	{
> 		return new Test(newstring);
> 	}
> 	
> /+
> 	Test opCat(char[] newstring)
> 	{
> 		return new Test(memstring ~ newstring);
> 	}
> +/
> }
> 
> int main(char[][] args)
> {
> 	Test bob = Test ~ "hello there";
> 	writefln(bob);
> 	return 0;
> }
> 
> ////////////////
> 
> Browsing through the documentation I didn't come across any mention that static member operators were supported. I was just wondering if they are in fact intentional?
> 
> Also:
> I notice that having 2 member functions with the same signature, one static and one not, does not work (compiler claims it a conflicts). In particular, the above case, when the non-static opCmp is uncommented it will no longer compile.
> 
> Is there any notes in the documentation to this effect? because I could not find any.
> 
> Thanks for any reply.
> 

I haven't seen this either.  Are you sure that your static opCat actually works, and is in fact static?  That compiler allows you to put 'static' in several places where it has no effect.  I know that static opCall makes sense for structs, but that's about it when it comes to static operator overloads.  Besides, your code won't even compile, because there's no default constructor.

torhu wrote:
> Stuart Murray wrote:
>> Hi everyone
>> I'm a newbie to D and I've spent some time in the last few days messing around, seeing how things work.
>> 
>> I noticed in a news posting that you can overload operators statically..
>> i.e.
>> 
>> ///////////////
>> 
>> class Test
>> {
>> 	private char[] memstring;
>> 	
>> 	this(char[] newstring)
>> 	{
>> 		memstring = newstring.dup;
>> 	}
>> 	
>> 	char[] toString()
>> 	{
>> 		return memstring;
>> 	}
>> 	
>> 	static Test opCat(char[] newstring)
>> 	{
>> 		return new Test(newstring);
>> 	}
>> 	
>> /+
>> 	Test opCat(char[] newstring)
>> 	{
>> 		return new Test(memstring ~ newstring);
>> 	}
>> +/
>> }
>> 
>> int main(char[][] args)
>> {
>> 	Test bob = Test ~ "hello there";
>> 	writefln(bob);
>> 	return 0;
>> }
>> 
>> ////////////////
>> 
>> Browsing through the documentation I didn't come across any mention that static member operators were supported. I was just wondering if they are in fact intentional?
>> 
>> Also:
>> I notice that having 2 member functions with the same signature, one static and one not, does not work (compiler claims it a conflicts). In particular, the above case, when the non-static opCmp is uncommented it will no longer compile.
>> 
>> Is there any notes in the documentation to this effect? because I could not find any.
>> 
>> Thanks for any reply.
>> 
> 
> I haven't seen this either.  Are you sure that your static opCat actually works, and is in fact static?  That compiler allows you to put 'static' in several places where it has no effect.  I know that static opCall makes sense for structs, but that's about it when it comes to static operator overloads.  Besides, your code won't even compile, because there's no default constructor.

Sorry, it compiles.  And prints "hello there".  But it doesn't do what opCat is supposed to do, since it doesn't concatenate anything.  So it's might just accidental that the compiler allows this code at all.  It doesn't make much sense.

torhu Wrote:

> Stuart Murray wrote:
> > Hi everyone
> > I'm a newbie to D and I've spent some time in the last few days messing around, seeing how things work.
> > 
> > I noticed in a news posting that you can overload operators statically.. i.e.
> > 
> > ///////////////
> > 
> > class Test
> > {
> > 	private char[] memstring;
> > 
> > 	this(char[] newstring)
> > 	{
> > 		memstring = newstring.dup;
> > 	}
> > 
> > 	char[] toString()
> > 	{
> > 		return memstring;
> > 	}
> > 
> > 	static Test opCat(char[] newstring)
> > 	{
> > 		return new Test(newstring);
> > 	}
> > 
> > /+
> > 	Test opCat(char[] newstring)
> > 	{
> > 		return new Test(memstring ~ newstring);
> > 	}
> > +/
> > }
> > 
> > int main(char[][] args)
> > {
> > 	Test bob = Test ~ "hello there";
> > 	writefln(bob);
> > 	return 0;
> > }
> > 
> > ////////////////
> > 
> > Browsing through the documentation I didn't come across any mention that static member operators were supported. I was just wondering if they are in fact intentional?
> > 
> > Also:
> > I notice that having 2 member functions with the same signature, one static and one not, does not work (compiler claims it a conflicts). In particular, the above case, when the non-static opCmp is uncommented it will no longer compile.
> > 
> > Is there any notes in the documentation to this effect? because I could not find any.
> > 
> > Thanks for any reply.
> > 
> 
> I haven't seen this either.  Are you sure that your static opCat actually works, and is in fact static?  That compiler allows you to put 'static' in several places where it has no effect.  I know that static opCall makes sense for structs, but that's about it when it comes to static operator overloads.  Besides, your code won't even compile, because there's no default constructor.

The above compiled immediately before I pasted into my message. The only thing missing is import std.stdio.

I am fairly sure it is being used statically. Swapping the static form for the non-static form results in a compile error (because Test~"" would need to be replaced by new Test("")~""). In the section:

Test bob = Test ~ "hello";

No constructor is invoked directly, the constructor this(char[]) is used through the static opCat overload.

At least, thats how I read it.

"Stuart Murray" <stuart.w.murray@fakey.spambot.avoiding.gmail.com> wrote in message news:f42ted$23dg$1@digitalmars.com...
> Hi everyone
> I'm a newbie to D and I've spent some time in the last few days messing
> around, seeing how things work.
>
> I noticed in a news posting that you can overload operators statically..
> i.e.
> Browsing through the documentation I didn't come across any mention that
> static member operators were supported. I was just wondering if they are
> in fact intentional?

It's legal.  It's nice to have sometimes.  It doesn't have the same purpose as static/global operator overloads do in C++, though.  It basically just allows you to use the class/struct type as if it were a value.

> Also:
> I notice that having 2 member functions with the same signature, one
> static and one not, does not work (compiler claims it a conflicts). In
> particular, the above case, when the non-static opCmp is uncommented it
> will no longer compile.
>
> Is there any notes in the documentation to this effect? because I could not find any.

I don't know if it's mentioned anywhere, but since D allows you to access static members through instances of a type, it doesn't surprise me that it's illegal, because that would be ambiguous.