Make Control.Exception buildable by nhc98.

[haskell-directory.git] / GHC / Base.lhs

diff --git a/GHC/Base.lhs b/GHC/Base.lhs
index 2cca920..c590366 100644 (file)
--- a/GHC/Base.lhs
+++ b/GHC/Base.lhs
@@ -19,7 +19,7 @@ GHC.Prim              Has no implementation.  It defines built-in things, and
 GHC.Base       Classes: Eq, Ord, Functor, Monad
                Types:   list, (), Int, Bool, Ordering, Char, String
 
-Data.Tup       Types: tuples, plus instances for GHC.Base classes
+Data.Tuple     Types: tuples, plus instances for GHC.Base classes
 
 GHC.Show       Class: Show, plus instances for GHC.Base/GHC.Tup types
 
@@ -27,6 +27,8 @@ GHC.Enum      Class: Enum,  plus instances for GHC.Base/GHC.Tup types
 
 Data.Maybe     Type: Maybe, plus instances for GHC.Base classes
 
+GHC.List       List functions
+
 GHC.Num                Class: Num, plus instances for Int
                Type:  Integer, plus instances for all classes so far (Eq, Ord, Num, Show)
 
@@ -41,11 +43,12 @@ GHC.Real    Classes: Real, Integral, Fractional, RealFrac
                Rational is needed here because it is mentioned in the signature
                of 'toRational' in class Real
 
+GHC.ST The ST monad, instances and a few helper functions
+
 Ix             Classes: Ix, plus instances for Int, Bool, Char, Integer, Ordering, tuples
 
 GHC.Arr                Types: Array, MutableArray, MutableVar
 
-               Does *not* contain any ByteArray stuff (see GHC.ByteArr)
                Arrays are used by a function in GHC.Float
 
 GHC.Float      Classes: Floating, RealFloat
@@ -55,11 +58,6 @@ GHC.Float    Classes: Floating, RealFloat
                It is a big module (900 lines)
                With a bit of luck, many modules can be compiled without ever reading GHC.Float.hi
 
-GHC.ByteArr    Types: ByteArray, MutableByteArray
-               
-               We want this one to be after GHC.Float, because it defines arrays
-               of unboxed floats.
-
 
 Other Prelude modules are much easier with fewer complex dependencies.
 
@@ -498,7 +496,6 @@ otherwise           :: Bool
 otherwise              =  True
 \end{code}
 
-
 %*********************************************************
 %*                                                     *
 \subsection{The @()@ type}
@@ -618,6 +615,8 @@ eqString (c1:cs1) (c2:cs2) = c1 == c2 && cs1 `eqString` cs2
 eqString cs1      cs2     = False
 
 {-# RULES "eqString" (==) = eqString #-}
+-- eqString also has a BuiltInRule in PrelRules.lhs:
+--     eqString (unpackCString# (Lit s1)) (unpackCString# (Lit s2) = s1==s2
 \end{code}
 
 
@@ -683,13 +682,26 @@ compareInt# x# y#
 id                     :: a -> a
 id x                   =  x
 
--- lazy function; this is just the same as id, but its unfolding
--- and strictness are over-ridden by the definition in MkId.lhs
--- That way, it does not get inlined, and the strictness analyser
--- sees it as lazy.  Then the worker/wrapper phase inlines it.
--- Result: happiness
+-- | The call '(lazy e)' means the same as 'e', but 'lazy' has a 
+-- magical strictness property: it is lazy in its first argument, 
+-- even though its semantics is strict.
 lazy :: a -> a
 lazy x = x
+-- Implementation note: its strictness and unfolding are over-ridden
+-- by the definition in MkId.lhs; in both cases to nothing at all.
+-- That way, 'lazy' does not get inlined, and the strictness analyser
+-- sees it as lazy.  Then the worker/wrapper phase inlines it.
+-- Result: happiness
+
+
+-- | The call '(inline f)' reduces to 'f', but 'inline' has a BuiltInRule
+-- that tries to inline 'f' (if it has an unfolding) unconditionally
+-- The 'NOINLINE' pragma arranges that inline only gets inlined (and
+-- hence eliminated) late in compilation, after the rule has had
+-- a god chance to fire.
+inline :: a -> a
+{-# NOINLINE[0] inline #-}
+inline x = x
 
 -- Assertion function.  This simply ignores its boolean argument.
 -- The compiler may rewrite it to @('assertError' line)@.
@@ -715,6 +727,17 @@ assert pred r = r
 breakpoint :: a -> a
 breakpoint r = r
 
+breakpointCond :: Bool -> a -> a
+breakpointCond _ r = r
+
+data Unknown 
+data Unknown1 a
+data Unknown2 a b
+data Unknown3 a b c
+data Unknown4 a b c d
+
+data Opaque = forall a. O a
+
 -- | Constant function.
 const                  :: a -> b -> a
 const x _              =  x
@@ -997,6 +1020,9 @@ unpackFoldrCString# :: Addr# -> (Char  -> a -> a) -> a -> a
 {-# NOINLINE [0] unpackFoldrCString# #-}
 -- Don't inline till right at the end;
 -- usually the unpack-list rule turns it into unpackCStringList
+-- It also has a BuiltInRule in PrelRules.lhs:
+--     unpackFoldrCString# "foo" c (unpackFoldrCString# "baz" c n)
+--       =  unpackFoldrCString# "foobaz" c n
 unpackFoldrCString# addr f z 
   = unpack 0#
   where