Improve properFraction for Ratio

We define

    properFraction (x:%y) = (fromInteger (toInteger q), r:%y)
      where (q, r) = quotRem x y

The first problem is that this produces a lazy pair. The second problem is that it uses fromInteger . toInteger rather than fromIntegral; the latter has rewrite rules that the former lacks. The whole thing should be written as

    properFraction (x:%y) = (q', r:%y)
      where !(q, r) = quotRem x y
            !q' = fromIntegral q

or possibly

    properFraction (x:%y) = (fromIntegral q, r:%y)
      where !(q, r) = quotRem x y

The latter is better if someone only wants the fractional part and is using Integral types for which fromIntegral is unusually expensive, but I don't know if that's really worth worrying about.

Trac metadata

Trac field	Value
Version	8.6.3
Type	Task
TypeOfFailure	OtherFailure
Priority	normal
Resolution	Unresolved
Component	Core Libraries
Test case
Differential revisions
BlockedBy
Related
Blocking
CC
Operating system
Architecture

changed milestone to %8.10.1

changed weight to 5

added Ttask Trac import core libraries labels

added runtime perf label

added Pnormal label

removed milestone

@treeowl I am +1 on this, but with one change:

    properFraction (x:%y) = (fromIntegral q, r:%y)
      where
        q = quot x y
        r = rem  x y

The reason is that quotRem will compile to include a division instruction, but separate quot and rem are replaced by much faster bitwise operations. (I don't know why GHC is bad at this particular optimisation).