Ord methods are surprisingly strict

[Andreas Abel]

Someone who knows the lore.  Thanks for the enlightening references!

Another reason for <= to be strict is symmetry.  Why would

   False <= undefined = True

be preferable to

   undefined <= True  = True  ?

And we cannot have both.  The natural assumption is that neither of 
these hold.
That said, my self-defined instances of Ord are usually not that strict.

--Andreas

On 2020-05-07 20:00, Sven Panne wrote:
> Am Do., 7. Mai 2020 um 15:26 Uhr schrieb David Feuer 
> <david.feuer at gmail.com <mailto:david.feuer at gmail.com>>:
> 
>     I believe this is all about strictness analysis. If these were lazy,
>     then users would have to be very careful to force the lazy arguments
>     when they don't need that laziness to avoid building unnecessary thunks.
> 
> 
> This argument holds basically for every potentially lazy function, and I 
> fail to see why comparisons should be special, so this is not really 
> convincing. :-) We have easy ways to make things more strict, but not 
> the other way around.
> 
> In any case, it has historically been the case that the reference 
> implementations in the Haskell language/library report define the 
> strictness of the defined functions, too. Otherwise things could be very 
> surprising, in both ways (too lazy, too strict). Furthermore, the report 
> is *very* explicit about the derived instances: 
> https://www.haskell.org/onlinereport/haskell2010/haskellch11.html#x18-18300011.1 And 
> (), Bool, ... are defined via deriving: 
> https://www.haskell.org/onlinereport/haskell2010/haskellch9.html#x16-1710009