Give alternate default definition for (<=)

[Dannyu NDos]

I have following datatype for representing arbitrary computable numbers:

    newtype Computable = Inexact (Word -> Integer)

"Inexact" encapsulates Cauchy sequences.

min and max will halt:

    instance Ord Computable where
        min (Inexact f) (Inexact g) = Inexact (\n -> min (f n) (g n))
        max (Inexact f) (Inexact g) = Inexact (\n -> max (f n) (g n))

But comparison functions won't halt for same numbers:

        compare (Inexact f) (Inexact g) = go 0 where
            go n = compare (f n) (g n) <> go (n+1)

So in this case, it would be inappropriate to defaultly define min and max.

It would be nice if there was a function for alternately defining
comparison functions:

    defaultLessThan :: Ord a => a -> a -> Bool
    defaultLessThan x y = x == y || x == min x y

Then we can let (<=) = defaultLessThan.

Also I have to mention that the "realAbs" function I suggested in January
must be the following definition in this regard:

    realAbs x = max x (negate x)
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/libraries/attachments/20200508/8699f55e/attachment.html>