Update use of role annotations to new syntax.
[packages/base.git] / Numeric.hs
index 89ac0ca..88b2e1a 100644 (file)
@@ -1,10 +1,12 @@
-{-# OPTIONS -fno-implicit-prelude #-}
+{-# LANGUAGE Trustworthy #-}
+{-# LANGUAGE NoImplicitPrelude, MagicHash #-}
+
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Numeric
 -- Copyright   :  (c) The University of Glasgow 2002
 -- License     :  BSD-style (see the file libraries/base/LICENSE)
--- 
+--
 -- Maintainer  :  libraries@haskell.org
 -- Stability   :  provisional
 -- Portability :  portable
 
 module Numeric (
 
-       -- * Showing
+        -- * Showing
 
-       showSigned,       -- :: (Real a) => (a -> ShowS) -> Int -> a -> ShowS
+        showSigned,
 
-        showIntAtBase,    -- :: Integral a => a -> (a -> Char) -> a -> ShowS
-       showInt,          -- :: Integral a => a -> ShowS
-        showHex,          -- :: Integral a => a -> ShowS
-        showOct,          -- :: Integral a => a -> ShowS
+        showIntAtBase,
+        showInt,
+        showHex,
+        showOct,
 
-       showEFloat,       -- :: (RealFloat a) => Maybe Int -> a -> ShowS
-       showFFloat,       -- :: (RealFloat a) => Maybe Int -> a -> ShowS
-       showGFloat,       -- :: (RealFloat a) => Maybe Int -> a -> ShowS
-       showFloat,        -- :: (RealFloat a) => a -> ShowS
+        showEFloat,
+        showFFloat,
+        showGFloat,
+        showFFloatAlt,
+        showGFloatAlt,
+        showFloat,
 
-       floatToDigits,    -- :: (RealFloat a) => Integer -> a -> ([Int], Int)
+        floatToDigits,
 
-       -- * Reading
+        -- * Reading
 
-       -- | /NB:/ 'readInt' is the \'dual\' of 'showIntAtBase',
-       -- and 'readDec' is the \`dual\' of 'showInt'.
-       -- The inconsistent naming is a historical accident.
+        -- | /NB:/ 'readInt' is the \'dual\' of 'showIntAtBase',
+        -- and 'readDec' is the \`dual\' of 'showInt'.
+        -- The inconsistent naming is a historical accident.
 
-       readSigned,       -- :: (Real a) => ReadS a -> ReadS a
+        readSigned,
 
-       readInt,          -- :: (Integral a) => a -> (Char -> Bool)
-                         --         -> (Char -> Int) -> ReadS a
-       readDec,          -- :: (Integral a) => ReadS a
-       readOct,          -- :: (Integral a) => ReadS a
-       readHex,          -- :: (Integral a) => ReadS a
+        readInt,
+        readDec,
+        readOct,
+        readHex,
 
-       readFloat,        -- :: (RealFloat a) => ReadS a
-       
-       lexDigits,        -- :: ReadS String
+        readFloat,
 
-       -- * Miscellaneous
+        lexDigits,
 
-        fromRat,          -- :: (RealFloat a) => Rational -> a
+        -- * Miscellaneous
 
-       ) where
+        fromRat,
+
+        ) where
 
-#ifdef __GLASGOW_HASKELL__
 import GHC.Base
 import GHC.Read
 import GHC.Real
@@ -66,39 +68,30 @@ import GHC.Show
 import Data.Maybe
 import Text.ParserCombinators.ReadP( ReadP, readP_to_S, pfail )
 import qualified Text.Read.Lex as L
-#else
-import Data.Char
-#endif
-
-#ifdef __HUGS__
-import Hugs.Prelude
-import Hugs.Numeric
-#endif
 
-#ifdef __GLASGOW_HASKELL__
 -- -----------------------------------------------------------------------------
 -- Reading
 
 -- | Reads an /unsigned/ 'Integral' value in an arbitrary base.
 readInt :: Num a
-  => a                 -- ^ the base
-  -> (Char -> Bool)    -- ^ a predicate distinguishing valid digits in this base
-  -> (Char -> Int)     -- ^ a function converting a valid digit character to an 'Int'
+  => a                  -- ^ the base
+  -> (Char -> Bool)     -- ^ a predicate distinguishing valid digits in this base
+  -> (Char -> Int)      -- ^ a function converting a valid digit character to an 'Int'
   -> ReadS a
 readInt base isDigit valDigit = readP_to_S (L.readIntP base isDigit valDigit)
 
 -- | Read an unsigned number in octal notation.
-readOct :: Num a => ReadS a
+readOct :: (Eq a, Num a) => ReadS a
 readOct = readP_to_S L.readOctP
 
 -- | Read an unsigned number in decimal notation.
-readDec :: Num a => ReadS a
+readDec :: (Eq a, Num a) => ReadS a
 readDec = readP_to_S L.readDecP
 
 -- | Read an unsigned number in hexadecimal notation.
 -- Both upper or lower case letters are allowed.
-readHex :: Num a => ReadS a
-readHex = readP_to_S L.readHexP 
+readHex :: (Eq a, Num a) => ReadS a
+readHex = readP_to_S L.readHexP
 
 -- | Reads an /unsigned/ 'RealFrac' value,
 -- expressed in decimal scientific notation.
@@ -109,9 +102,8 @@ readFloatP :: RealFrac a => ReadP a
 readFloatP =
   do tok <- L.lex
      case tok of
-       L.Rat y  -> return (fromRational y)
-       L.Int i  -> return (fromInteger i)
-       other    -> pfail
+       L.Number n -> return $ fromRational $ L.numberToRational n
+       _          -> pfail
 
 -- It's turgid to have readSigned work using list comprehensions,
 -- but it's specified as a ReadS to ReadS transformer
@@ -120,24 +112,24 @@ readFloatP =
 -- | Reads a /signed/ 'Real' value, given a reader for an unsigned value.
 readSigned :: (Real a) => ReadS a -> ReadS a
 readSigned readPos = readParen False read'
-                    where read' r  = read'' r ++
-                                     (do
-                                       ("-",s) <- lex r
-                                       (x,t)   <- read'' s
-                                       return (-x,t))
-                          read'' r = do
-                              (str,s) <- lex r
-                              (n,"")  <- readPos str
-                              return (n,s)
+                     where read' r  = read'' r ++
+                                      (do
+                                        ("-",s) <- lex r
+                                        (x,t)   <- read'' s
+                                        return (-x,t))
+                           read'' r = do
+                               (str,s) <- lex r
+                               (n,"")  <- readPos str
+                               return (n,s)
 
 -- -----------------------------------------------------------------------------
 -- Showing
 
 -- | Show /non-negative/ 'Integral' numbers in base 10.
 showInt :: Integral a => a -> ShowS
-showInt n cs
-    | n < 0     = error "Numeric.showInt: can't show negative numbers"
-    | otherwise = go n cs
+showInt n0 cs0
+    | n0 < 0    = error "Numeric.showInt: can't show negative numbers"
+    | otherwise = go n0 cs0
     where
     go n cs
         | n < 10    = case unsafeChr (ord '0' + fromIntegral n) of
@@ -152,14 +144,14 @@ showInt n cs
 -- mutual module deps.
 
 {-# SPECIALIZE showEFloat ::
-       Maybe Int -> Float  -> ShowS,
-       Maybe Int -> Double -> ShowS #-}
+        Maybe Int -> Float  -> ShowS,
+        Maybe Int -> Double -> ShowS #-}
 {-# SPECIALIZE showFFloat ::
-       Maybe Int -> Float  -> ShowS,
-       Maybe Int -> Double -> ShowS #-}
+        Maybe Int -> Float  -> ShowS,
+        Maybe Int -> Double -> ShowS #-}
 {-# SPECIALIZE showGFloat ::
-       Maybe Int -> Float  -> ShowS,
-       Maybe Int -> Double -> ShowS #-}
+        Maybe Int -> Float  -> ShowS,
+        Maybe Int -> Double -> ShowS #-}
 
 -- | Show a signed 'RealFloat' value
 -- using scientific (exponential) notation (e.g. @2.45e2@, @1.5e-3@).
@@ -178,7 +170,7 @@ showEFloat    :: (RealFloat a) => Maybe Int -> a -> ShowS
 showFFloat    :: (RealFloat a) => Maybe Int -> a -> ShowS
 
 -- | Show a signed 'RealFloat' value
--- using standard decimal notation for arguments whose absolute value lies 
+-- using standard decimal notation for arguments whose absolute value lies
 -- between @0.1@ and @9,999,999@, and scientific notation otherwise.
 --
 -- In the call @'showGFloat' digs val@, if @digs@ is 'Nothing',
@@ -189,31 +181,48 @@ showGFloat    :: (RealFloat a) => Maybe Int -> a -> ShowS
 showEFloat d x =  showString (formatRealFloat FFExponent d x)
 showFFloat d x =  showString (formatRealFloat FFFixed d x)
 showGFloat d x =  showString (formatRealFloat FFGeneric d x)
-#endif  /* __GLASGOW_HASKELL__ */
+
+-- | Show a signed 'RealFloat' value
+-- using standard decimal notation (e.g. @245000@, @0.0015@).
+--
+-- This behaves as 'showFFloat', except that a decimal point
+-- is always guaranteed, even if not needed.
+showFFloatAlt    :: (RealFloat a) => Maybe Int -> a -> ShowS
+
+-- | Show a signed 'RealFloat' value
+-- using standard decimal notation for arguments whose absolute value lies
+-- between @0.1@ and @9,999,999@, and scientific notation otherwise.
+--
+-- This behaves as 'showFFloat', except that a decimal point
+-- is always guaranteed, even if not needed.
+showGFloatAlt    :: (RealFloat a) => Maybe Int -> a -> ShowS
+
+showFFloatAlt d x =  showString (formatRealFloatAlt FFFixed d True x)
+showGFloatAlt d x =  showString (formatRealFloatAlt FFGeneric d True x)
 
 -- ---------------------------------------------------------------------------
 -- Integer printing functions
 
 -- | Shows a /non-negative/ 'Integral' number using the base specified by the
 -- first argument, and the character representation specified by the second.
-showIntAtBase :: Integral a => a -> (Int -> Char) -> a -> ShowS
-showIntAtBase base toChr n r
+showIntAtBase :: (Integral a, Show a) => a -> (Int -> Char) -> a -> ShowS
+showIntAtBase base toChr n0 r0
   | base <= 1 = error ("Numeric.showIntAtBase: applied to unsupported base " ++ show base)
-  | n <  0    = error ("Numeric.showIntAtBase: applied to negative number " ++ show n)
-  | otherwise = showIt (quotRem n base) r
+  | n0 <  0   = error ("Numeric.showIntAtBase: applied to negative number " ++ show n0)
+  | otherwise = showIt (quotRem n0 base) r0
    where
     showIt (n,d) r = seq c $ -- stricter than necessary
       case n of
         0 -> r'
-       _ -> showIt (quotRem n base) r'
+        _ -> showIt (quotRem n base) r'
      where
-      c  = toChr (fromIntegral d) 
+      c  = toChr (fromIntegral d)
       r' = c : r
 
 -- | Show /non-negative/ 'Integral' numbers in base 16.
-showHex :: Integral a => a -> ShowS
+showHex :: (Integral a,Show a) => a -> ShowS
 showHex = showIntAtBase 16 intToDigit
 
 -- | Show /non-negative/ 'Integral' numbers in base 8.
-showOct :: Integral a => a -> ShowS
+showOct :: (Integral a, Show a) => a -> ShowS
 showOct = showIntAtBase 8  intToDigit