Fix Ord so Ord Double and Ord Float make sense

Consider:

let n = 0/0 :: Double in (n `compare` n, n < n, n == n, n > n)

In GHC and YHC this gives

(GT,False,False,False)

while in hugs it gives

(EQ,False,False,False)

Neither of these is very satisfactory, as I would expect

x `compare` y === EQ   =>   (x == y) === True
x `compare` y === GT   =>   (x > y) === True

and it's even less pleasant that the implementations differ for no good reason.

The Haskell report isn't currently very helpful on how comparing exceptional Doubles should behave, as it doesn't even say you need to have NaN etc:

http://haskell.org/onlinereport/basic.html#sect6.4
The results of exceptional conditions (such as overflow or 
underflow) on the fixed-precision numeric types are undefined; an
implementation may choose error (_|_, semantically), a truncated
value, or a special value such as infinity, indefinite, etc.

Four possible solutions to the problem have been proposed. While Haskell' would presumably continue not to legislate what implementations should do in this case, some of the solutions require changes to the report, so we do need to discuss it in the context of Haskell'.

The possible solutions are:

• compare should raise an exception (Haskell' doesn't need to be changed)
• compare, (<), (>), etc should raise an exception (Haskell' doesn't need to be changed)
• There should be no Ord instance for Float and Double (changes needed for Haskell')
• Add an Incomparable constructor to Ordering (changes needed for Haskell')

Trac metadata

Trac field	Value
Version
Type	Bug
TypeOfFailure	OtherFailure
Priority	normal
Resolution	Unresolved
Component	Proposal
Test case
Differential revisions
BlockedBy
Related
Blocking
CC
Operating system
Architecture

changed weight to 5

added Trac import + 1 deleted label

changed milestone to %⊥

moving non-milestoned many year old legacy tickets out of the way

added modification label

Set default priority (as this confuses Trac otherwise)