Implement foldl with foldr
[packages/base.git] / Numeric.hs
index 167aa7b..4a1a5b1 100644 (file)
@@ -1,12 +1,12 @@
 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE CPP, NoImplicitPrelude, MagicHash #-}
+{-# 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
@@ -20,19 +20,21 @@ module Numeric (
 
         -- * 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
 
@@ -40,25 +42,23 @@ module Numeric (
         -- 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
+        readFloat,
 
-        lexDigits,        -- :: ReadS String
+        lexDigits,
 
         -- * Miscellaneous
 
-        fromRat,          -- :: (RealFloat a) => Rational -> a
+        fromRat,
 
         ) where
 
-#ifdef __GLASGOW_HASKELL__
 import GHC.Base
 import GHC.Read
 import GHC.Real
@@ -68,16 +68,7 @@ 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
 
@@ -100,7 +91,7 @@ readDec = readP_to_S L.readDecP
 -- | Read an unsigned number in hexadecimal notation.
 -- Both upper or lower case letters are allowed.
 readHex :: (Eq a, Num a) => ReadS a
-readHex = readP_to_S L.readHexP 
+readHex = readP_to_S L.readHexP
 
 -- | Reads an /unsigned/ 'RealFrac' value,
 -- expressed in decimal scientific notation.
@@ -111,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)
-       _        -> 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
@@ -180,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',
@@ -191,7 +181,28 @@ 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.
+--
+-- /Since: 4.7.0.0/
+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.
+--
+-- /Since: 4.7.0.0/
+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