Hi,

from my understanding UFCS is supposed to work with operator overloading. I.e. in the following a + b should work

struct Foo {}

Foo opBinary(string op)(Foo lhs, Foo rhs) if (op == "+")
{
    return Foo.init;
}

unittest
{
    Foo a, b;
    a + b; // fails to compile
}

Is UFCS supposed to work with operator overloading, isn't it?

Jens

"Jens Mueller" <jens.k.mueller@gmx.de> wrote in message news:mailman.391.1336410464.24740.digitalmars-d@puremagic.com...
> Hi,
>
> from my understanding UFCS is supposed to work with operator overloading.
> I.e.
> in the following a + b should work
>
> struct Foo {}
>
> Foo opBinary(string op)(Foo lhs, Foo rhs) if (op == "+")
> {
>    return Foo.init;
> }
>
> unittest
> {
>    Foo a, b;
>    a + b; // fails to compile
> }
>
> Is UFCS supposed to work with operator overloading, isn't it?
>
> Jens

I don't know why that doesn't work (unless you just need to make it "auto c = a + b;" so it isn't a "statement has no effect"?), but FWIW that's not an example of UFCS. UFCS would mean calling your opBinary above like this:

a.opBinary!"+"(b)

Instead of this:

opBinary!"+"(a, b)

Still, not having non-member operator overloads is very bothersome.

On Tue, May 8, 2012 at 12:37 AM, Nick Sabalausky <SeeWebsiteToContactMe@semitwist.com> wrote:
> "Jens Mueller" <jens.k.mueller@gmx.de> wrote in message news:mailman.391.1336410464.24740.digitalmars-d@puremagic.com...
>> Hi,
>>
>> from my understanding UFCS is supposed to work with operator overloading.
>> I.e.
>> in the following a + b should work
>>
>> struct Foo {}
>>
>> Foo opBinary(string op)(Foo lhs, Foo rhs) if (op == "+")
>> {
>>    return Foo.init;
>> }
>>
>> unittest
>> {
>>    Foo a, b;
>>    a + b; // fails to compile
>> }
>>
>> Is UFCS supposed to work with operator overloading, isn't it?
>>
>> Jens
>
> I don't know why that doesn't work (unless you just need to make it "auto c = a + b;" so it isn't a "statement has no effect"?), but FWIW that's not an example of UFCS. UFCS would mean calling your opBinary above like this:
>
> a.opBinary!"+"(b)
>
> Instead of this:
>
> opBinary!"+"(a, b)
>
>
>



-- 
Bye,
Gor Gyolchanyan.

On 05/07/2012 10:37 PM, Nick Sabalausky wrote:
> "Jens Mueller"<jens.k.mueller@gmx.de>  wrote in message
> news:mailman.391.1336410464.24740.digitalmars-d@puremagic.com...
>> Hi,
>>
>> from my understanding UFCS is supposed to work with operator overloading.
>> I.e.
>> in the following a + b should work
>>
>> struct Foo {}
>>
>> Foo opBinary(string op)(Foo lhs, Foo rhs) if (op == "+")
>> {
>>     return Foo.init;
>> }
>>
>> unittest
>> {
>>     Foo a, b;
>>     a + b; // fails to compile
>> }
>>
>> Is UFCS supposed to work with operator overloading, isn't it?
>>
>> Jens
>
> I don't know why that doesn't work (unless you just need to make it "auto c
> = a + b;" so it isn't a "statement has no effect"?), but FWIW that's not an
> example of UFCS. UFCS would mean calling your opBinary above like this:
>
> a.opBinary!"+"(b)
>
> Instead of this:
>
> opBinary!"+"(a, b)
>
>

 a + b => a.opBinary!"+"(b) => opBinary!"+"(a, b)
       ^                    ^
standard rewrite           UFCS

Timon Gehr wrote:
> On 05/07/2012 10:37 PM, Nick Sabalausky wrote:
> >"Jens Mueller"<jens.k.mueller@gmx.de>  wrote in message news:mailman.391.1336410464.24740.digitalmars-d@puremagic.com...
> >>Hi,
> >>
> >>from my understanding UFCS is supposed to work with operator overloading.
> >>I.e.
> >>in the following a + b should work
> >>
> >>struct Foo {}
> >>
> >>Foo opBinary(string op)(Foo lhs, Foo rhs) if (op == "+")
> >>{
> >>    return Foo.init;
> >>}
> >>
> >>unittest
> >>{
> >>    Foo a, b;
> >>    a + b; // fails to compile
> >>}
> >>
> >>Is UFCS supposed to work with operator overloading, isn't it?
> >>
> >>Jens
> >
> >I don't know why that doesn't work (unless you just need to make it "auto c = a + b;" so it isn't a "statement has no effect"?), but FWIW that's not an example of UFCS. UFCS would mean calling your opBinary above like this:
> >
> >a.opBinary!"+"(b)
> >
> >Instead of this:
> >
> >opBinary!"+"(a, b)
> >
> >
> 
>  a + b => a.opBinary!"+"(b) => opBinary!"+"(a, b)
>        ^                    ^
> standard rewrite           UFCS

Yes. That's how it should be. I reported it.

Jens

"Timon Gehr" <timon.gehr@gmx.ch> wrote in message news:jobo5r$1cf7$1@digitalmars.com...
> On 05/07/2012 10:37 PM, Nick Sabalausky wrote:
>>
>> I don't know why that doesn't work (unless you just need to make it "auto
>> c
>> = a + b;" so it isn't a "statement has no effect"?), but FWIW that's not
>> an
>> example of UFCS. UFCS would mean calling your opBinary above like this:
>>
>> a.opBinary!"+"(b)
>>
>> Instead of this:
>>
>> opBinary!"+"(a, b)
>>
>>
>
>  a + b => a.opBinary!"+"(b) => opBinary!"+"(a, b)
>        ^                    ^
> standard rewrite           UFCS
>

/facepalm

Yea, I get it now ;)