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
 
 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
 
 
 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
 
 
 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)
 
 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
 
                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
 
 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
                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
 
                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.
 
 
 Other Prelude modules are much easier with fewer complex dependencies.
 

@@ -498,7 +496,6 @@ otherwise           :: Bool
 otherwise              =  True
 \end{code}
 
 otherwise              =  True
 \end{code}
 

-

 %*********************************************************
 %*                                                     *
 \subsection{The @()@ type}
 %*********************************************************
 %*                                                     *
 \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 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}
 
 
 \end{code}
 
 

@@ -683,13 +682,26 @@ compareInt# x# y#
 id                     :: a -> a
 id x                   =  x
 
 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
 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)@.
 
 -- 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
 
 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
 -- | 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
 {-# 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
 unpackFoldrCString# addr f z 
   = unpack 0#
   where