() has moved to ghc-prim:GHC.Unit, and the Eq and Ord instances to Data.Tuple

[ghc-base.git] / GHC / Real.lhs

diff --git a/GHC/Real.lhs b/GHC/Real.lhs
index f7e2eb2..d282058 100644 (file)
--- a/GHC/Real.lhs
+++ b/GHC/Real.lhs
@@ -1,5 +1,5 @@
 \begin{code}
-{-# OPTIONS_GHC -fno-implicit-prelude #-}
+{-# OPTIONS_GHC -XNoImplicitPrelude #-}
 {-# OPTIONS_HADDOCK hide #-}
 -----------------------------------------------------------------------------
 -- |
@@ -229,7 +229,7 @@ instance  Real Int  where
     toRational x        =  toInteger x % 1
 
 instance  Integral Int  where
-    toInteger i = int2Integer i  -- give back a full-blown Integer
+    toInteger (I# i) = smallInteger i
 
     a `quot` b
      | b == 0                     = divZeroError
@@ -283,10 +283,12 @@ instance  Integral Integer where
     n `rem`  d = n `remInteger`  d
 
     a `divMod` 0 = divZeroError
-    a `divMod` b = a `divModInteger` b
+    a `divMod` b = case a `divModInteger` b of
+                   (# x, y #) -> (x, y)
 
     a `quotRem` 0 = divZeroError
-    a `quotRem` b = a `quotRemInteger` b
+    a `quotRem` b = case a `quotRemInteger` b of
+                    (# q, r #) -> (q, r)
 
     -- use the defaults for div & mod
 \end{code}
@@ -342,7 +344,7 @@ instance  (Integral a)  => Enum (Ratio a)  where
     succ x              =  x + 1
     pred x              =  x - 1
 
-    toEnum n            =  fromInteger (int2Integer n) :% 1
+    toEnum n            =  fromIntegral n :% 1
     fromEnum            =  fromInteger . truncate
 
     enumFrom            =  numericEnumFrom
@@ -403,14 +405,18 @@ odd             =  not . even
         Integer -> Integer -> Integer,
         Integer -> Int -> Integer,
         Int -> Int -> Int #-}
-(^)             :: (Num a, Integral b) => a -> b -> a
-_ ^ 0           =  1
-x ^ n | n > 0   =  f x (n-1) x
-                   where f _ 0 y = y
-                         f a d y = g a d  where
-                                   g b i | even i  = g (b*b) (i `quot` 2)
-                                         | otherwise = f b (i-1) (b*y)
-_ ^ _           = error "Prelude.^: negative exponent"
+(^) :: (Num a, Integral b) => a -> b -> a
+x0 ^ y0 | y0 < 0    = error "Negative exponent"
+        | y0 == 0   = 1
+        | otherwise = f x0 y0
+    where -- f : x0 ^ y0 = x ^ y
+          f x y | even y    = f (x * x) (y `quot` 2)
+                | y == 1    = x
+                | otherwise = g (x * x) ((y - 1) `quot` 2) x
+          -- g : x0 ^ y0 = (x ^ y) * z
+          g x y z | even y = g (x * x) (y `quot` 2) z
+                  | y == 1 = x * z
+                  | otherwise = g (x * x) ((y - 1) `quot` 2) (x * z)
 
 -- | raise a number to an integral power
 {-# SPECIALISE (^^) ::
@@ -436,13 +442,19 @@ lcm _ 0         =  0
 lcm 0 _         =  0
 lcm x y         =  abs ((x `quot` (gcd x y)) * y)
 
-
 {-# RULES
 "gcd/Int->Int->Int"             gcd = gcdInt
-"gcd/Integer->Integer->Integer" gcd = gcdInteger
-"lcm/Integer->Integer->Integer" lcm = lcmInteger
  #-}
 
+-- XXX these optimisation rules are disabled for now to make it easier
+--     to experiment with other Integer implementations
+-- "gcd/Integer->Integer->Integer" gcd = gcdInteger'
+-- "lcm/Integer->Integer->Integer" lcm = lcmInteger
+--
+-- gcdInteger' :: Integer -> Integer -> Integer
+-- gcdInteger' 0 0 = error "GHC.Real.gcdInteger': gcd 0 0 is undefined"
+-- gcdInteger' a b = gcdInteger a b
+
 integralEnumFrom :: (Integral a, Bounded a) => a -> [a]
 integralEnumFrom n = map fromInteger [toInteger n .. toInteger (maxBound `asTypeOf` n)]