[project @ 1999-02-01 10:02:15 by sof]

[ghc-hetmet.git] / ghc / lib / std / Prelude.lhs

diff --git a/ghc/lib/std/Prelude.lhs b/ghc/lib/std/Prelude.lhs
index 000dd10..6ba2bd5 100644 (file)
--- a/ghc/lib/std/Prelude.lhs
+++ b/ghc/lib/std/Prelude.lhs
@@ -9,91 +9,81 @@ module Prelude (
 
        -- Everything from these modules
     module PrelList,
-    module PrelIO,
-    module PrelTup,
 
-       -- From PrelBase
-    (->),
-    Eq(..), 
-    Ord(..), Ordering(..), 
-    Bounded(..), 
-    Enum(..), succ, pred, 
-    Show(..), ShowS, shows, show, showChar, showString, showParen,
-    Eval(..), seq, strict,
-    Bool(..), (&&), (||), not, otherwise,
-    Char, String, Int, Integer, Float, Double, Void,
-    Maybe(..), maybe,
-    Either(..), either,
+        -- Everything corresponding to the Report's PreludeText
+    ReadS, ShowS,
+    Read(readsPrec, readList),
+    Show(showsPrec, showList, show),
+    reads, shows, read, lex, 
+    showChar, showString, readParen, showParen,
+    
+        -- Everything corresponding to the Report's PreludeIO
+    FilePath, IOError,
+    ioError, userError, catch,
+    putChar, putStr, putStrLn, print,
+    getChar, getLine, getContents, interact,
+    readFile, writeFile, appendFile, readIO, readLn,
+
+    Bool(..),
+    Maybe(..),
+    Either(..),
+    Ordering(..), 
+    Char, String, Int, Integer, Float, Double, IO,
+    Rational,
+    []((:), []),
+    
+    module PrelTup,
+        -- Includes tuple types + fst, snd, curry, uncurry
     ()(..),            -- The unit type
-
+    (->),              -- functions
     
-    id, const, (.), flip, ($), until, asTypeOf, undefined,
-
-       -- From Error
-    error,
+    Eq(..),
+    Ord(..), 
+    Enum(..),
+    Bounded(..), 
+    Num((+), (-), (*), negate, abs, signum, fromInteger, fromInt{-glaExt-}),
+    Real(..),
+    Integral(quot, rem, div, mod, quotRem, divMod, toInteger, toInt{-partain-}),
+    Fractional(..),
+    Floating(..),
+    RealFrac(..),
+    RealFloat(..),
 
        -- From Monad
-    Functor(..), Monad(..), MonadZero(..), MonadPlus(..),
-    accumulate, sequence, mapM, mapM_, guard, filter, concat, applyM,
+    Monad(..),
+    Functor(..), 
+    mapM, mapM_, sequence, sequence_, (=<<),
 
-       -- From PrelRead
-    ReadS, Read(readsPrec, readList),
-    reads, read, lex, readParen, 
-
-       -- From PrelShow
-
-       -- From PrelNum
-    Ratio, Rational, 
-    (%), numerator, denominator, approxRational,
-
-    Num((+), (-), (*), negate, abs, signum, fromInteger, fromInt{-glaExt-}),
-    Real(toRational),
-    Integral(quot, rem, div, mod, quotRem, divMod, toInteger, toInt{-partain-}),
-    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),
+    maybe, either,
+    (&&), (||), not, otherwise,
     subtract, even, odd, gcd, lcm, (^), (^^), 
-    fromIntegral, fromRealFrac, atan2
+    fromIntegral, realToFrac,
+    --exported by PrelTup: fst, snd, curry, uncurry,
+    id, const, (.), flip, ($), until,
+    asTypeOf, error, undefined,
+    seq, ($!)
+
   ) where
 
 import PrelBase
-import PrelList
-import PrelIO
+import PrelList hiding ( takeUInt )
 import PrelRead
 import PrelNum
+import PrelNumExtra
 import PrelTup
 import PrelMaybe
 import PrelEither
 import PrelBounded
+import PrelConc
 import Monad
 import Maybe
-import PrelErr   ( error, seqError )
-
--- These can't conveniently be defined in PrelBase because they use numbers,
--- or I/O, so here's a convenient place to do them.
-
-strict      :: Eval a => (a -> b) -> a -> b
-strict f x  = x `seq` f x
-
+import PrelErr   ( error )
+import IO
 
--- "seq" is defined a bit wierdly (see below)
---
--- The reason for the strange "0# -> parError" case is that
--- it fools the compiler into thinking that seq is non-strict in
--- its second argument (even if it inlines seq at the call site).
--- If it thinks seq is strict in "y", then it often evaluates
--- "y" before "x", which is totally wrong.  
---
--- Just before converting from Core to STG there's a bit of magic
--- that recognises the seq# and eliminates the duff case.
+infixr 0 $!
 
-{-# INLINE seq  #-}
-seq :: Eval a => a -> b -> b
-seq  x y = case (seq#  x) of { 0# -> seqError; _ -> y }
+($!)    :: (a -> b) -> a -> b
+f $! x  = x `seq` f x
 
 -- It is expected that compilers will recognize this and insert error
 -- messages which are more appropriate to the context in which undefined