Portability | semi-portable (CPP, MPTC, OverlappingInstances) |
---|---|

Stability | stable |

Maintainer | wren@community.haskell.org |

This module presents a type class for generic conversion between
numeric types, generalizing `realToFrac`

in order to overcome
problems with pivoting through `Rational`

- class (Real a, Fractional b) => RealToFrac a b where
- realToFrac :: a -> b

# Documentation

class (Real a, Fractional b) => RealToFrac a b whereSource

The `realToFrac`

function is defined to pivot through
a `Rational`

according to the haskell98 spec. This is non-portable
and problematic as discussed in Data.Number.Transfinite. Since
there is resistance to breaking from the spec, this class defines
a reasonable variant which deals with transfinite values
appropriately.

There is a generic instance from any Transfinite Real to any
Transfinite Fractional, using checks to ensure correctness. GHC
has specialized versions for some types which use primitive
converters instead, for large performance gains. (These definitions
are hidden from other compilers via CPP.) Due to a bug in Haddock
the specialized instances are shown twice and the generic instance
isn't shown at all. Since the instances are overlapped, you'll
need to give type signatures if the arguments to `realToFrac`

are polymorphic. There's also a generic instance for any Real
Fractional type to itself, thus if you write any generic instances
beware of incoherence.

If any of these restrictions (CPP, GHC-only optimizations,
OverlappingInstances) are onerous to you, contact the maintainer
(we like patches). Note that this *does* work for Hugs with
suitable options (e.g. `hugs -98 +o -F'cpp -P'`

). However, Hugs
doesn't allow `IncoherentInstances`

nor does it allow diamonds
with `OverlappingInstances`

, which restricts the ability to add
additional generic instances.

realToFrac :: a -> bSource

RealToFrac Double Float | |

RealToFrac Float Double | |

RealToFrac Int Double | |

RealToFrac Int Float | |

RealToFrac Integer Double | |

RealToFrac Integer Float | |

(Real a, Transfinite a, Fractional b, Transfinite b) => RealToFrac a b | |

(Real a, Fractional a) => RealToFrac a a |