add Control.Monad.Instances to nhc98 build

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

diff --git a/GHC/Base.lhs b/GHC/Base.lhs
index 5b6a676..cf3c5a3 100644 (file)
--- a/GHC/Base.lhs
+++ b/GHC/Base.lhs
@@ -362,8 +362,8 @@ augment g xs = g (:) xs
 "foldr/augment" forall k z xs (g::forall b. (a->b->b) -> b -> b) . 
                foldr k z (augment g xs) = g k (foldr k z xs)
 
-"foldr/id"                       foldr (:) [] = \x->x
-"foldr/app"            [1] forall xs ys. foldr (:) ys xs = xs ++ ys
+"foldr/id"                       foldr (:) [] = \x  -> x
+"foldr/app"            [1] forall ys. foldr (:) ys = \xs -> xs ++ ys
        -- Only activate this from phase 1, because that's
        -- when we disable the rule that expands (++) into foldr
 
@@ -560,7 +560,8 @@ data Ordering = LT | EQ | GT deriving (Eq, Ord)
 type String = [Char]
 
 {-| The character type 'Char' is an enumeration whose values represent
-Unicode (or equivalently ISO 10646) characters.
+Unicode (or equivalently ISO\/IEC 10646) characters
+(see <http://www.unicode.org/> for details).
 This set extends the ISO 8859-1 (Latin-1) character set
 (the first 256 charachers), which is itself an extension of the ASCII
 character set (the first 128 characters).
@@ -617,6 +618,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}
 
 
@@ -682,13 +685,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)@.
@@ -699,7 +715,8 @@ lazy x = x
 -- call to 'assert'.
 --
 -- Assertions can normally be turned on or off with a compiler flag
--- (for GHC, assertions are normally on unless the @-fignore-asserts@
+-- (for GHC, assertions are normally on unless optimisation is turned on 
+-- with @-O@ or the @-fignore-asserts@
 -- option is given).  When assertions are turned off, the first
 -- argument to 'assert' is ignored, and the second argument is
 -- returned as the result.
@@ -709,7 +726,13 @@ lazy x = x
 --     defined here in Base.lhs
 assert :: Bool -> a -> a
 assert pred r = r
- 
+
+breakpoint :: a -> a
+breakpoint r = r
+
+breakpointCond :: Bool -> a -> a
+breakpointCond _ r = r
+
 -- | Constant function.
 const                  :: a -> b -> a
 const x _              =  x
@@ -992,6 +1015,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