Eliminate the baroque floating-point operators a la !<>=

[Michiel Helvensteijn]

Andrei Alexandrescu wrote:

> I think the floating-point operators:
> 
>    a !<>= b
>    a !<> b
>    a <> b
>    a <>= b
>    a !> b
>    a !>= b
>    a !< b
>    a !<= b
> 
> are useless.

Actually, I like the concept of comparison operators for partial orders.
When I first read the D1 specs, this set of operators was one of the
features I especially liked.

However, at the time I didn't realise they were solely for floating point
numbers. They would make more sense if they could be overloaded.

For example, they can be used for multi-objective optimization. With more
than one objective, you need a way to express comparability of two
potential solutions (<>= means comparable).

They would be good for expressing the subset relation, where < is the strict
subset relation and A <>= B would express that one of A and B is a subset
of the other.

Logically, they would be defined for the Boolean truth-values. False and
true are incomparable to each other, but equal to themselves.

And for those people that don't (want to) know about all of these extra
operators, they don't have to. What's more, when it comes to integers, <>
and != are equivalent, which is nice for those programmers that are
familiar with one, but not the other.

There's this thing, though. I would make it so !(a op b) is equivalent to
(a !op b). It's a nice property. The IEEE standard requires that you set a
certain exception flag when comparing with a NaN value, right? Well, just
set the flag with the extra operators as well. The !(a op b) = (a !op b)
thing can even be extended to the and/or/xor operators.

I know that most of these operators don't make sense with integers and
booleans. But you can give a compiler warning when you have a comparison
with a predictable return value.

In fact, everything I've said here is part of the Mist programming language.
Inspired by D's example. :-)

-- 
Michiel Helvensteijn