X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=GHC%2FBase.lhs;h=d3dcd46511020b8106bc05121f302ed8e7afca73;hb=fd14d1940233a4563d14a89fc195587c95750300;hp=988c94e46fda18645dea2c0df53b28929f31034e;hpb=9f9c1ba962b98906e1a750b16138344bc62a6fd3;p=ghc-base.git

diff --git a/GHC/Base.lhs b/GHC/Base.lhs
index 988c94e..d3dcd46 100644
--- a/GHC/Base.lhs
+++ b/GHC/Base.lhs
@@ -16,8 +16,6 @@ GHC.Prim		Has no implementation.  It defines built-in things, and
 		The source file is GHC.Prim.hi-boot, which is just
 		copied to make GHC.Prim.hi
 
-		Classes: CCallable, CReturnable
-
 GHC.Base	Classes: Eq, Ord, Functor, Monad
 		Types:   list, (), Int, Bool, Ordering, Char, String
 
@@ -163,14 +161,22 @@ class  Eq a  where
     x /= y		 = not (x == y)
     x == y		 = not (x /= y)
 
+-- | The 'Ord' class is used for totally ordered datatypes.
+--
+-- Instances of 'Ord' can be derived for any user-defined
+-- datatype whose constituent types are in 'Ord'.  The declared order
+-- of the constructors in the data declaration determines the ordering
+-- in derived 'Ord' instances.  The 'Ordering' datatype allows a single
+-- comparison to determine the precise ordering of two objects.
+--
+-- Minimal complete definition: either 'compare' or '<='.
+-- Using 'compare' can be more efficient for complex types.
+--
 class  (Eq a) => Ord a  where
     compare		 :: a -> a -> Ordering
     (<), (<=), (>), (>=) :: a -> a -> Bool
     max, min		 :: a -> a -> a
 
-    -- An instance of Ord should define either 'compare' or '<='.
-    -- Using 'compare' can be more efficient for complex types.
-
     compare x y
 	| x == y    = EQ
 	| x <= y    = LT	-- NB: must be '<=' not '<' to validate the
@@ -225,8 +231,10 @@ satisfy these laws.
 -}
 
 class  Monad m  where
-    (>>=)       :: m a -> (a -> m b) -> m b
-    (>>)        :: m a -> m b -> m b
+    (>>=)       :: forall a b. m a -> (a -> m b) -> m b
+    (>>)        :: forall a b. m a -> m b -> m b
+	-- Explicit for-alls so that we know what order to
+	-- give type arguments when desugaring
     return      :: a -> m a
     fail	:: String -> m a
 
@@ -583,10 +591,9 @@ eqString cs1      cs2	   = False
 
 \begin{code}
 data Int = I# Int#
--- ^A fixed-precision integer type with at least the range @[-2^29
--- .. 2^29-1]@.  The exact range for a given implementation can be
--- determined by using 'minBound' and 'maxBound' from the 'Bounded'
--- class.
+-- ^A fixed-precision integer type with at least the range @[-2^29 .. 2^29-1]@.
+-- The exact range for a given implementation can be determined by using
+-- 'Prelude.minBound' and 'Prelude.maxBound' from the 'Prelude.Bounded' class.
 
 zeroInt, oneInt, twoInt, maxInt, minInt :: Int
 zeroInt = I# 0#
@@ -634,7 +641,7 @@ compareInt# x# y#
 %*********************************************************
 
 \begin{code}
--- identity function
+-- | Identity function.
 id			:: a -> a
 id x			=  x
 
@@ -646,40 +653,48 @@ id x			=  x
 lazy :: a -> a
 lazy 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)@.
+
 -- 	SLPJ: in 5.04 etc 'assert' is in GHC.Prim,
 --	but from Template Haskell onwards it's simply
 --	defined here in Base.lhs
 assert :: Bool -> a -> a
 assert pred r = r
  
--- constant function
+-- | Constant function.
 const			:: a -> b -> a
 const x _		=  x
 
--- function composition
+-- | Function composition.
 {-# INLINE (.) #-}
 (.)	  :: (b -> c) -> (a -> b) -> a -> c
 (.) f g	x = f (g x)
 
--- flip f  takes its (first) two arguments in the reverse order of f.
+-- | @'flip' f@ takes its (first) two arguments in the reverse order of @f@.
 flip			:: (a -> b -> c) -> b -> a -> c
 flip f x y		=  f y x
 
--- right-associating infix application operator (useful in continuation-
--- passing style)
+-- | Application operator.  This operator is redundant, since ordinary
+-- application @(f x)@ means the same as @(f '$' x)@. However, '$' has
+-- low, right-associative binding precedence, so it sometimes allows
+-- parentheses to be omitted; for example:
+--
+-- >     f $ g $ h x  =  f (g (h x))
+--
+-- It is also useful in higher-order situations, such as @'map' ('$' 0) xs@,
+-- or @'Data.List.zipWith' ('$') fs xs@.
 {-# INLINE ($) #-}
 ($)			:: (a -> b) -> a -> b
 f $ x			=  f x
 
--- until p f  yields the result of applying f until p holds.
+-- | @'until' p f@ yields the result of applying @f@ until @p@ holds.
 until			:: (a -> Bool) -> (a -> a) -> a -> a
 until p f x | p x	=  x
 	    | otherwise =  until p f (f x)
 
--- asTypeOf is a type-restricted version of const.  It is usually used
--- as an infix operator, and its typing forces its first argument
+-- | 'asTypeOf' is a type-restricted version of 'const'.  It is usually
+-- used as an infix operator, and its typing forces its first argument
 -- (which is usually overloaded) to have the same type as the second.
 asTypeOf		:: a -> a -> a
 asTypeOf		=  const
@@ -687,25 +702,6 @@ asTypeOf		=  const
 
 %*********************************************************
 %*							*
-\subsection{CCallable instances}
-%*							*
-%*********************************************************
-
-Defined here to avoid orphans
-
-\begin{code}
-instance CCallable Char
-instance CReturnable Char
-
-instance CCallable   Int
-instance CReturnable Int
-
-instance CReturnable () -- Why, exactly?
-\end{code}
-
-
-%*********************************************************
-%*							*
 \subsection{Generics}
 %*							*
 %*********************************************************