• etep kkow.net (20/20) Jun 06 2005 I think D should special case the builtin comparison operators instead o...
• Eric Fredricksen (4/29) Mar 05 2007 To chime in, I think instead all silent information-losing casts should ...

etep kkow.net writes:

I think D should special case the builtin comparison operators instead of
treating them as binary operators in terms of the integer promotion rules. This
is really trivial to implement: if the lhs and rhs are integers and one is
unsigned and the other is signed, either promote them to a signed integer that
can hold the whole range of values or convert the expression internally to
(using C's integer promotion rules):

lhs is signed, rhs is unsigned
((lhs < 0) || (lhs < rhs))  for "lhs < rhs"
((lhs < 0) && (lhs OP rhs)) otherwise

lhs is unsigned, rhs is signed
((rhs < 0) || (lhs > rhs))  for "lhs > rhs"
((rhs > 0) && (lhs OP rhs)) otherwise

except force lhs and rhs to both be evaluated for side effects (and only once).

With the C promotion rules, the expression to the right of the short-circuit
operators are done using unsigned integers, so you can verify yourself that
these are correct. The reason for the promotion rules in C is to reduce the
complexity of handling lots of different operands and to unify the return type
of the expression (since it's a truth value, special casing it this way for the
operands is no problem).

(reverse my username to contact me)

Eric Fredricksen <efredricksen gmail.com> writes:

To chime in, I think instead all silent information-losing casts should be done
away with.

I'm a little new to D so I was dumbfounded to discover that 0u > -1 evaluates
to false. Both sides should be promoted to a large enough type to hold each
before doing the comparison.

Can anyone tell me if there is a plan to make such a change?

etep kkow.net Wrote:

 I think D should special case the builtin comparison operators instead of
 treating them as binary operators in terms of the integer promotion rules. This
 is really trivial to implement: if the lhs and rhs are integers and one is
 unsigned and the other is signed, either promote them to a signed integer that
 can hold the whole range of values or convert the expression internally to
 (using C's integer promotion rules):
 
 lhs is signed, rhs is unsigned
 ((lhs < 0) || (lhs < rhs))  for "lhs < rhs"
 ((lhs < 0) && (lhs OP rhs)) otherwise
 
 lhs is unsigned, rhs is signed
 ((rhs < 0) || (lhs > rhs))  for "lhs > rhs"
 ((rhs > 0) && (lhs OP rhs)) otherwise
 
 except force lhs and rhs to both be evaluated for side effects (and only once).
 
 With the C promotion rules, the expression to the right of the short-circuit
 operators are done using unsigned integers, so you can verify yourself that
 these are correct. The reason for the promotion rules in C is to reduce the
 complexity of handling lots of different operands and to unify the return type
 of the expression (since it's a truth value, special casing it this way for the
 operands is no problem).
 
 (reverse my username to contact me)