diff --git a/Data/Number/LogFloat.hs b/Data/Number/LogFloat.hs
--- a/Data/Number/LogFloat.hs
+++ b/Data/Number/LogFloat.hs
@@ -13,6 +13,7 @@
 {-# OPTIONS_GHC -O2 -fvia-C -optc-O3 -fexcess-precision -fglasgow-exts #-}
 
 -- Version History
+-- (v0.11)  Broke Data.Number.RealToFrac out
 -- (v0.10)  Fixed bugs in Hugs for PartialOrd and Transfinite.
 --          Also added maxPO, minPO, comparingPO
 -- (v0.9.1) Fixed some PartialOrd stuff and sanitized documentation
diff --git a/Data/Number/RealToFrac.hs b/Data/Number/RealToFrac.hs
new file mode 100644
--- /dev/null
+++ b/Data/Number/RealToFrac.hs
@@ -0,0 +1,116 @@
+-- Needed to ensure correctness, and because we can't guarantee rules fire
+{-# LANGUAGE MultiParamTypeClasses
+           , OverlappingInstances
+           , CPP
+           #-}
+
+-- Glasgow extensions needed to enable the # kind
+{-# OPTIONS_GHC -fglasgow-exts #-}
+
+{-# OPTIONS_GHC -Wall -fwarn-tabs #-}
+
+----------------------------------------------------------------
+--                                                  ~ 2009.01.29
+-- |
+-- Module      :  Data.Number.RealToFrac
+-- Copyright   :  Copyright (c) 2007--2009 wren ng thornton
+-- License     :  BSD3
+-- Maintainer  :  wren@community.haskell.org
+-- Stability   :  experimental
+-- Portability :  non-portable (CPP, MPTC, OverlappingInstances)
+-- 
+-- This module presents a type class for generic conversion between
+-- numeric types, generalizing @realToFrac@ in order to overcome
+-- problems with pivoting through 'Rational'
+----------------------------------------------------------------
+module Data.Number.RealToFrac (RealToFrac(..)) where
+
+import Prelude hiding    (realToFrac, isInfinite, isNaN)
+import qualified Prelude (realToFrac)
+
+import Data.Number.Transfinite
+
+#ifdef __GLASGOW_HASKELL__
+import GHC.Exts
+    ( Int(..), Float(..), Double(..)
+    , int2Double#
+    , int2Float#
+    , double2Float#
+    , float2Double#
+    )
+#endif
+
+----------------------------------------------------------------
+-- | The 'Prelude.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.
+
+class (Real a, Fractional b) => RealToFrac a b where
+    realToFrac :: a -> b
+
+instance (Real a, Fractional a) => RealToFrac a a where
+    realToFrac = id
+
+instance (Real a, Transfinite a, Fractional b, Transfinite b)
+    => RealToFrac a b
+    where
+    realToFrac x
+        | isNaN      x = notANumber
+        | isInfinite x = if x > 0 then infinity
+                                  else negativeInfinity
+        | otherwise    = Prelude.realToFrac x
+
+
+#ifdef __GLASGOW_HASKELL__
+instance RealToFrac Int Float where
+    {-# INLINE realToFrac #-}
+    realToFrac (I# i) = F# (int2Float# i)
+
+instance RealToFrac Int Double where
+    {-# INLINE realToFrac #-}
+    realToFrac (I# i) = D# (int2Double# i)
+
+
+instance RealToFrac Integer Float where
+    -- TODO: is there a more primitive way?
+    realToFrac j = Prelude.realToFrac j
+
+instance RealToFrac Integer Double where
+    -- TODO: is there a more primitive way?
+    realToFrac j = Prelude.realToFrac j
+
+
+instance RealToFrac Float Double where
+    {-# INLINE realToFrac #-}
+    realToFrac (F# f) = D# (float2Double# f)
+    
+instance RealToFrac Double Float where
+    {-# INLINE realToFrac #-}
+    realToFrac (D# d) = F# (double2Float# d)
+#endif
+
+----------------------------------------------------------------
+----------------------------------------------------------- fin.
diff --git a/logfloat.cabal b/logfloat.cabal
--- a/logfloat.cabal
+++ b/logfloat.cabal
@@ -3,7 +3,7 @@
 ----------------------------------------------------------------
 
 Name:           logfloat
-Version:        0.11.0
+Version:        0.11.0.1
 Cabal-Version:  >= 1.2
 Build-Type:     Simple
 Stability:      experimental
@@ -15,7 +15,7 @@
 Homepage:       http://code.haskell.org/~wren/
 Category:       Data, Math, Natural Language Processing
 Synopsis:       Log-domain floating point numbers
-Description:    This module presents a class for storing numbers
+Description:    This module presents a type for storing numbers
                 in the log-domain. The main reason for doing this
                 is to prevent underflow when multiplying many
                 probabilities as is done in Hidden Markov Models.
@@ -32,6 +32,7 @@
 
 Library
     Exposed-Modules: Data.Number.LogFloat
+                   , Data.Number.RealToFrac
                    , Data.Number.Transfinite
                    , Data.Number.PartialOrd
                    , Hugs.RealFloat