X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=GHC%2FBase.lhs;h=a95d19d7faec5e98023b83b893d5335e1b727de9;hb=4ef39162b8ae3ab239009e6386b5787475f172d9;hp=32bf4983c7876a1289ce915e52d971b8bb633743;hpb=ca4bf46e5ccd5d1e007ac8051b6119ba99195f33;p=ghc-base.git

diff --git a/GHC/Base.lhs b/GHC/Base.lhs
index 32bf498..a95d19d 100644
--- 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,16 +58,12 @@ 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.
 
 \begin{code}
 {-# OPTIONS_GHC -fno-implicit-prelude #-}
+{-# OPTIONS_HADDOCK hide #-}
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  GHC.Base
@@ -362,8 +361,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
 
@@ -498,7 +497,6 @@ otherwise		:: Bool
 otherwise 		=  True
 \end{code}
 
-
 %*********************************************************
 %*							*
 \subsection{The @()@ type}
@@ -618,6 +616,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 +683,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)@.
@@ -700,7 +713,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.
@@ -710,7 +724,15 @@ 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
+
+data Opaque = forall a. O a
+
 -- | Constant function.
 const			:: a -> b -> a
 const x _		=  x
@@ -898,14 +920,26 @@ gtInt, geInt, eqInt, neInt, ltInt, leInt :: Int -> Int -> Bool
 "plusDouble x 0.0"   forall x#. (+##) x#    0.0## = x#
 "plusDouble 0.0 x"   forall x#. (+##) 0.0## x#    = x#
 "minusDouble x 0.0"  forall x#. (-##) x#    0.0## = x#
-"minusDouble x x"    forall x#. (-##) x#    x#    = 0.0##
-"timesDouble x 0.0"  forall x#. (*##) x#    0.0## = 0.0##
-"timesDouble 0.0 x"  forall x#. (*##) 0.0## x#    = 0.0##
 "timesDouble x 1.0"  forall x#. (*##) x#    1.0## = x#
 "timesDouble 1.0 x"  forall x#. (*##) 1.0## x#    = x#
 "divideDouble x 1.0" forall x#. (/##) x#    1.0## = x#
   #-}
 
+{-
+We'd like to have more rules, but for example:
+
+This gives wrong answer (0) for NaN - NaN (should be NaN):
+    "minusDouble x x"    forall x#. (-##) x#    x#    = 0.0##
+
+This gives wrong answer (0) for 0 * NaN (should be NaN):
+    "timesDouble 0.0 x"  forall x#. (*##) 0.0## x#    = 0.0##
+
+This gives wrong answer (0) for NaN * 0 (should be NaN):
+    "timesDouble x 0.0"  forall x#. (*##) x#    0.0## = 0.0##
+
+These are tested by num014.
+-}
+
 -- Wrappers for the shift operations.  The uncheckedShift# family are
 -- undefined when the amount being shifted by is greater than the size
 -- in bits of Int#, so these wrappers perform a check and return
@@ -993,6 +1027,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