add the Numeric and Prelude modules, and add ioError/catch to System.IO.Error
authorSimon Marlow <marlowsd@gmail.com>
Fri, 2 Jul 2010 13:37:36 +0000 (13:37 +0000)
committerSimon Marlow <marlowsd@gmail.com>
Fri, 2 Jul 2010 13:37:36 +0000 (13:37 +0000)
Numeric.hs [new file with mode: 0644]
Prelude.hs [new file with mode: 0644]
System/IO/Error.hs
haskell2010.cabal

diff --git a/Numeric.hs b/Numeric.hs
new file mode 100644 (file)
index 0000000..bb0d97d
--- /dev/null
@@ -0,0 +1,43 @@
+module Numeric (
+
+        -- * Showing
+
+        showSigned,       -- :: (Real a) => (a -> ShowS) -> Int -> a -> ShowS
+
+        showIntAtBase,    -- :: Integral a => a -> (a -> Char) -> a -> ShowS
+        showInt,          -- :: Integral a => a -> ShowS
+        showHex,          -- :: Integral a => a -> ShowS
+        showOct,          -- :: Integral a => a -> ShowS
+
+        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
+
+        floatToDigits,    -- :: (RealFloat a) => Integer -> a -> ([Int], Int)
+
+        -- * Reading
+
+        -- | /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
+
+        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
+
+        readFloat,        -- :: (RealFloat a) => ReadS a
+
+        lexDigits,        -- :: ReadS String
+
+        -- * Miscellaneous
+
+        fromRat,          -- :: (RealFloat a) => Rational -> a
+
+        ) where
+
+import "base" Numeric
diff --git a/Prelude.hs b/Prelude.hs
new file mode 100644 (file)
index 0000000..6f05ba6
--- /dev/null
@@ -0,0 +1,183 @@
+{-# OPTIONS_GHC -XNoImplicitPrelude -XBangPatterns #-}
+-- |
+-- The Haskell 2010 Prelude: a standard module imported by default
+-- into all Haskell modules.  For more documentation, see the Haskell 2010
+-- Report <http://www.haskell.org/onlinereport/>.
+
+module Prelude (
+
+    -- * Standard types, classes and related functions
+
+    -- ** Basic data types
+    Bool(False, True),
+    (&&), (||), not, otherwise,
+
+    Maybe(Nothing, Just),
+    maybe,
+
+    Either(Left, Right),
+    either,
+
+    Ordering(LT, EQ, GT),
+    Char, String,
+
+    -- *** Tuples
+    fst, snd, curry, uncurry,
+
+#if defined(__NHC__)
+    []((:), []),        -- Not legal Haskell 98;
+                        -- ... available through built-in syntax
+    module Data.Tuple,  -- Includes tuple types
+    ()(..),             -- Not legal Haskell 98
+    (->),               -- ... available through built-in syntax
+#endif
+#ifdef __HUGS__
+    (:),                -- Not legal Haskell 98
+#endif
+
+    -- ** Basic type classes
+    Eq((==), (/=)),
+    Ord(compare, (<), (<=), (>=), (>), max, min),
+    Enum(succ, pred, toEnum, fromEnum, enumFrom, enumFromThen,
+         enumFromTo, enumFromThenTo),
+    Bounded(minBound, maxBound),
+
+    -- ** Numbers
+
+    -- *** Numeric types
+    Int, Integer, Float, Double,
+    Rational,
+
+    -- *** Numeric type classes
+    Num((+), (-), (*), negate, abs, signum, fromInteger),
+    Real(toRational),
+    Integral(quot, rem, div, mod, quotRem, divMod, toInteger),
+    Fractional((/), recip, fromRational),
+    Floating(pi, exp, log, sqrt, (**), logBase, sin, cos, tan,
+             asin, acos, atan, sinh, cosh, tanh, asinh, acosh, atanh),
+    RealFrac(properFraction, truncate, round, ceiling, floor),
+    RealFloat(floatRadix, floatDigits, floatRange, decodeFloat,
+              encodeFloat, exponent, significand, scaleFloat, isNaN,
+              isInfinite, isDenormalized, isIEEE, isNegativeZero, atan2),
+
+    -- *** Numeric functions
+    subtract, even, odd, gcd, lcm, (^), (^^),
+    fromIntegral, realToFrac,
+
+    -- ** Monads and functors
+    Monad((>>=), (>>), return, fail),
+    Functor(fmap),
+    mapM, mapM_, sequence, sequence_, (=<<),
+
+    -- ** Miscellaneous functions
+    id, const, (.), flip, ($), until,
+    asTypeOf, error, undefined,
+    seq, ($!),
+
+    -- * List operations
+    map, (++), filter,
+    head, last, tail, init, null, length, (!!),
+    reverse,
+    -- ** Reducing lists (folds)
+    foldl, foldl1, foldr, foldr1,
+    -- *** Special folds
+    and, or, any, all,
+    sum, product,
+    concat, concatMap,
+    maximum, minimum,
+    -- ** Building lists
+    -- *** Scans
+    scanl, scanl1, scanr, scanr1,
+    -- *** Infinite lists
+    iterate, repeat, replicate, cycle,
+    -- ** Sublists
+    take, drop, splitAt, takeWhile, dropWhile, span, break,
+    -- ** Searching lists
+    elem, notElem, lookup,
+    -- ** Zipping and unzipping lists
+    zip, zip3, zipWith, zipWith3, unzip, unzip3,
+    -- ** Functions on strings
+    lines, words, unlines, unwords,
+
+    -- * Converting to and from @String@
+    -- ** Converting to @String@
+    ShowS,
+    Show(showsPrec, showList, show),
+    shows,
+    showChar, showString, showParen,
+    -- ** Converting from @String@
+    ReadS,
+    Read(readsPrec, readList),
+    reads, readParen, read, lex,
+
+    -- * Basic Input and output
+    IO,
+    -- ** Simple I\/O operations
+    -- All I/O functions defined here are character oriented.  The
+    -- treatment of the newline character will vary on different systems.
+    -- For example, two characters of input, return and linefeed, may
+    -- read as a single newline character.  These functions cannot be
+    -- used portably for binary I/O.
+    -- *** Output functions
+    putChar,
+    putStr, putStrLn, print,
+    -- *** Input functions
+    getChar,
+    getLine, getContents, interact,
+    -- *** Files
+    FilePath,
+    readFile, writeFile, appendFile, readIO, readLn,
+    -- ** Exception handling in the I\/O monad
+    IOError, ioError, userError, catch
+
+  ) where
+
+#ifndef __HUGS__
+import "base" Control.Monad
+import "base" System.IO
+import "base" System.IO.Error
+import "base" Data.List
+import "base" Data.Either
+import "base" Data.Maybe
+import "base" Data.Tuple
+#endif
+
+#ifdef __GLASGOW_HASKELL__
+import GHC.Base
+-- import GHC.IO
+-- import GHC.IO.Exception
+import Text.Read
+import GHC.Enum
+import GHC.Num
+import GHC.Real
+import GHC.Float
+import GHC.Show
+import GHC.Err   ( undefined )
+#endif
+
+#ifdef __HUGS__
+import Hugs.Prelude
+#endif
+
+#ifndef __HUGS__
+infixr 0 $!
+#endif
+
+-- -----------------------------------------------------------------------------
+-- Miscellaneous functions
+
+-- | Strict (call-by-value) application, defined in terms of 'seq'.
+($!)    :: (a -> b) -> a -> b
+#ifdef __GLASGOW_HASKELL__
+f $! x  = let !vx = x in f vx  -- see #2273
+#elif !defined(__HUGS__)
+f $! x  = x `seq` f x
+#endif
+
+#ifdef __HADDOCK__
+-- | The value of @'seq' a b@ is bottom if @a@ is bottom, and otherwise
+-- equal to @b@.  'seq' is usually introduced to improve performance by
+-- avoiding unneeded laziness.
+seq :: a -> b -> b
+seq _ y = y
+#endif
index c11ffde..657e59a 100644 (file)
@@ -37,7 +37,15 @@ module System.IO.Error (
     eofErrorType,
     illegalOperationErrorType, 
     permissionErrorType,
-    userErrorType
+    userErrorType,
+
+    -- * Throwing and catching I\/O errors
+
+    ioError,                    -- :: IOError -> IO a
+
+    catch,                      -- :: IO a -> (IOError -> IO a) -> IO a
+    try                         -- :: IO a -> IO (Either IOError a)
+
   ) where
 
 import "base" System.IO.Error hiding (IOError)
index 55d231d..26475b9 100644 (file)
@@ -14,7 +14,16 @@ build-type:     Simple
 Cabal-Version: >= 1.6
 
 Library
-    build-depends:     base >= 3 && < 5, array
+    build-depends:     base >= 4.3 && < 5, array
+
+    -- this hack adds a dependency on ghc-prim for Haddock.  The GHC
+    -- build system doesn't seem to track transitive dependencies when
+    -- running Haddock, and if we don't do this then Haddock can't
+    -- find the docs for things defined in ghc-prim.
+    if impl(ghc) {
+       build-depends: ghc-prim
+    }
+
     exposed-modules:
         Data.Array,
         Data.Char,
@@ -28,6 +37,8 @@ Library
         Data.Ratio,
         System.Environment,
         System.Exit,
+        Numeric,
+        Prelude,
 
         -- FFI modules
         Data.Int,