In my C++ version I have implementation
of two functions/operators using rect (rectangle) struct

struct rect {}
// test for intersection of two rects
inline bool operator&& ( rect r1, rect r2 ) {...}
// intersection of two rects
inline rect operator& ( rect r1, rect r2 ) {...}

It seems that in D I can implement only opAnd....
Did I miss something?

How operator && works in D actually?
Is it sort of

bit result = cast(bit)left & cast(bit)right;

?

Andrew.

Being able to overload && and || is a bad thing in C++, because it screws short-circuit evaluation. I've never seen a case that was of such utility that it outweighed this.

AFAIR, D does not support this, and if it does/did, I expect there'll be lots of howling about it.

"Andrew Fedoniouk" <news@terrainformatica.com> wrote in message news:d085h5$2jcj$1@digitaldaemon.com...
> In my C++ version I have implementation
> of two functions/operators using rect (rectangle) struct
>
> struct rect {}
> // test for intersection of two rects
> inline bool operator&& ( rect r1, rect r2 ) {...}
> // intersection of two rects
> inline rect operator& ( rect r1, rect r2 ) {...}
>
> It seems that in D I can implement only opAnd....
> Did I miss something?
>
> How operator && works in D actually?
> Is it sort of
>
> bit result = cast(bit)left & cast(bit)right;
>
> ?
>
> Andrew.
>
>
>
>
>
>
>
> 

So what's the solution in this instance?

What did the C++ operator&& do?
Was telling you if the rectangles overlap each other?

If so, is the solution to either write a method called "overlap" for the rectangle struct, or a stand-alone function to do it. eg.

struct rect {
  bool overlap(rect b) {}
}

bool overlap(rect a, rect b) {}

On Fri, 4 Mar 2005 10:17:46 +1100, Matthew <admin@stlsoft.dot.dot.dot.dot.org> wrote:
> Being able to overload && and || is a bad thing in C++, because it
> screws short-circuit evaluation. I've never seen a case that was of such
> utility that it outweighed this.
>
> AFAIR, D does not support this, and if it does/did, I expect there'll be
> lots of howling about it.
>
> "Andrew Fedoniouk" <news@terrainformatica.com> wrote in message
> news:d085h5$2jcj$1@digitaldaemon.com...
>> In my C++ version I have implementation
>> of two functions/operators using rect (rectangle) struct
>>
>> struct rect {}
>> // test for intersection of two rects
>> inline bool operator&& ( rect r1, rect r2 ) {...}
>> // intersection of two rects
>> inline rect operator& ( rect r1, rect r2 ) {...}
>>
>> It seems that in D I can implement only opAnd....
>> Did I miss something?
>>
>> How operator && works in D actually?
>> Is it sort of
>>
>> bit result = cast(bit)left & cast(bit)right;
>>
>> ?
>>
>> Andrew.

> So what's the solution in this instance?

Do you mean wrt rect intersections?

One should write intersect() methods/functions.

    class rect
    {
      . . .

    public:
      bool intersect(rect const &rhs) const;
      . . .
    };

    inline bool intersect(rect const &lhs, rect const &rhs)
    {
      return lhs.intersect(rhs);
    }

The difference in discoverability of the source is (or should be!!) obvious:

    rect    r1;
    rect    r2;

    if(r1.intersect(r2))
    {
        . . .

or

    if(intersect(r1, r2))
    {
        . . .

vs

    if(r1 && r2)
    {
        . . .



> What did the C++ operator&& do?

Not sure what you mean here. I'll assume you're asking about the circumvention of short circuit evaluation

    bool    b1;
    bool    f(int);

    if( b1 && f(101))
    {

the function f() is _only_ called if b1 is true. If b1 is false, then f() is not called.

However, when one overloads && in C++ _for any type_, both sides are evaluated, and short-circuit evaluation no longer applies. There is nothing from the syntax of the expression to suggest this important change in meaning. Imagine the consequences for template code!!


> If so, is the solution to either write a method called "overlap" for the  rectangle struct, or a stand-alone function to do it. eg.
>
> struct rect {
>   bool overlap(rect b) {}
> }
>
> bool overlap(rect a, rect b) {}

Indeed. With some const references .... ;)

>
> On Fri, 4 Mar 2005 10:17:46 +1100, Matthew <admin@stlsoft.dot.dot.dot.dot.org> wrote:
>> Being able to overload && and || is a bad thing in C++, because it
>> screws short-circuit evaluation. I've never seen a case that was of
>> such
>> utility that it outweighed this.
>>
>> AFAIR, D does not support this, and if it does/did, I expect there'll
>> be
>> lots of howling about it.
>>
>> "Andrew Fedoniouk" <news@terrainformatica.com> wrote in message news:d085h5$2jcj$1@digitaldaemon.com...
>>> In my C++ version I have implementation
>>> of two functions/operators using rect (rectangle) struct
>>>
>>> struct rect {}
>>> // test for intersection of two rects
>>> inline bool operator&& ( rect r1, rect r2 ) {...}
>>> // intersection of two rects
>>> inline rect operator& ( rect r1, rect r2 ) {...}
>>>
>>> It seems that in D I can implement only opAnd....
>>> Did I miss something?
>>>
>>> How operator && works in D actually?
>>> Is it sort of
>>>
>>> bit result = cast(bit)left & cast(bit)right;
>>>
>>> ?
>>>
>>> Andrew.

Matthew, I will agree with you if there (in D) would not such features as operator overloading. But they are there. But not in full.

I am porting
http://www.terrainformatica.com/org/gool/geometry.h
which we are using in years. And & and && are make sense there
and help a lot. Trust me.

'&' and '&&' are semanticly different.
First one returns value of arguments type second one returns bool.

Compact representation is what makes languages different from
one another. It is like VB.NET and C#.NET, the first one is dying
despite of the fact that these two are just two faces of the same stuff
these days.

Well... I can live without &&. I even can live without operator overloading
at all.
Probably it makes sense to remove it from language? Or at least
move them out of the Cathedral?

> AFAIR, D does not support this, and if it does/did, I expect there'll be lots of howling about it.

this? what about 'this'? Are you talking about ctor/dtor names in structs? Sorry, didn't get the meaning of this statement.

Andrew.

>> In my C++ version I have implementation
>> of two functions/operators using rect (rectangle) struct
>>
>> struct rect {}
>> // test for intersection of two rects
>> inline bool operator&& ( rect r1, rect r2 ) {...}
>> // intersection of two rects
>> inline rect operator& ( rect r1, rect r2 ) {...}
>>
>> It seems that in D I can implement only opAnd....
>> Did I miss something?
>>
>> How operator && works in D actually?
>> Is it sort of
>>
>> bit result = cast(bit)left & cast(bit)right;
>>
>> ?
>>
>> Andrew.
>>
>>
>>
>>
>>
>>
>>
>>
>
> 

"Andrew Fedoniouk" <news@terrainformatica.com> wrote in message news:d0875e$2kuh$1@digitaldaemon.com...
> Matthew, I will agree with you if there (in D) would not such features as operator overloading. But they are there. But not in full.
>
> I am porting
> http://www.terrainformatica.com/org/gool/geometry.h
> which we are using in years. And & and && are make sense there
> and help a lot. Trust me.

They only help you because you know that the meaning of && has been subverted for elements of code with which you're familiar, and that you remain mindful of that by your constant exposure to it.

The fact remains that any chance to the meaning of built-in operators is only 'workable' in a general sense if (almost) the entire community is aware of them _and_ accepts them. The two instances of which I'm aware are string concatenation in C++, Java, .NET and insertion/extraction operators in C++. (The latter stink terribly, but for other reasons than that they violate the principle.)

> '&' and '&&' are semanticly different.
> First one returns value of arguments type second one returns bool.

Of course. I have no (all-encompassing) objection to the overloading of &.

> Well... I can live without &&. I even can live without operator
> overloading at all.
> Probably it makes sense to remove it from language?

No, but some of the current ones may need looking at.

>> AFAIR, D does not support this, and if it does/did, I expect there'll be lots of howling about it.
>
> this? what about 'this'? Are you talking about ctor/dtor names in structs?

overloading &&.

But like I said, only as far as I recall.

> Sorry, didn't get the meaning of this statement.
>
> Andrew.
>
>>> In my C++ version I have implementation
>>> of two functions/operators using rect (rectangle) struct
>>>
>>> struct rect {}
>>> // test for intersection of two rects
>>> inline bool operator&& ( rect r1, rect r2 ) {...}
>>> // intersection of two rects
>>> inline rect operator& ( rect r1, rect r2 ) {...}
>>>
>>> It seems that in D I can implement only opAnd....
>>> Did I miss something?
>>>
>>> How operator && works in D actually?
>>> Is it sort of
>>>
>>> bit result = cast(bit)left & cast(bit)right;
>>>
>>> ?
>>>
>>> Andrew.
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>
>>
>
> 

I have posted confusingly, you see, Q1 was directed at Matthew, but Q2 was directed at the OP.. I need to label things when I do that ;)

On Fri, 4 Mar 2005 10:30:54 +1100, Matthew <admin@stlsoft.dot.dot.dot.dot.org> wrote:
>> So what's the solution in this instance?
>
> Do you mean wrt rect intersections?

Yep.

>> What did the C++ operator&& do?
>
> Not sure what you mean here. I'll assume you're asking about the
> circumvention of short circuit evaluation

I wasn't. I was asking wrt to rect intersections. Your explaination was welcome regardless, I see the problem now.

>> If so, is the solution to either write a method called "overlap" for
>> the  rectangle struct, or a stand-alone function to do it. eg.
>>
>> struct rect {
>>   bool overlap(rect b) {}
>> }
>>
>> bool overlap(rect a, rect b) {}
>
> Indeed. With some const references .... ;)

If I had my way 'in' would be const and pass by reference when appropriate.

Regan

> What did the C++ operator&& do?
> Was telling you if the rectangles overlap each other?

Yes it is.

// returns intersection
rect  operator&(rect r1, rect r2) {  return (r1 & r2).is_empty();  }

// do they overlap or not?
bool operator&&(rect r1, rect r2) {  return (r1 & r2).is_empty();  }

// does r1  contain p2 or not?
bool operator&&(rect r1, point p2) {  return [...true/false...];  }

// the same as previous
bool operator&&(point p2, rect r1) {  return [...true/false...];  }

// union of two rects
bool operator | (rect r1, rect r2) {  .... return outline;  }

// region of parts not in r1 and not in r2
rect[]  operator^ (rect r1, rect r2) { return ...;  }

etc.


> If so, is the solution to either write a method called "overlap" for the rectangle struct, or a stand-alone function to do it. eg.
>
> struct rect {
>   bool overlap(rect b) {}
> }
>

Sure I can do that. I also can use method array.item(int idx)
instead of redefining of opIndex.

I am not against this.
I can understand arguments like short-circuit evaluation.
If this is the case of omitting of && overloading then
this is fine. Reasonable enough to keep compiler simple.

Andrew.



> bool overlap(rect a, rect b) {}
>
> On Fri, 4 Mar 2005 10:17:46 +1100, Matthew <admin@stlsoft.dot.dot.dot.dot.org> wrote:
>> Being able to overload && and || is a bad thing in C++, because it screws short-circuit evaluation. I've never seen a case that was of such utility that it outweighed this.
>>
>> AFAIR, D does not support this, and if it does/did, I expect there'll be lots of howling about it.
>>
>> "Andrew Fedoniouk" <news@terrainformatica.com> wrote in message news:d085h5$2jcj$1@digitaldaemon.com...
>>> In my C++ version I have implementation
>>> of two functions/operators using rect (rectangle) struct
>>>
>>> struct rect {}
>>> // test for intersection of two rects
>>> inline bool operator&& ( rect r1, rect r2 ) {...}
>>> // intersection of two rects
>>> inline rect operator& ( rect r1, rect r2 ) {...}
>>>
>>> It seems that in D I can implement only opAnd....
>>> Did I miss something?
>>>
>>> How operator && works in D actually?
>>> Is it sort of
>>>
>>> bit result = cast(bit)left & cast(bit)right;
>>>
>>> ?
>>>
>>> Andrew.