Remove commented types in module export lists

These comments are rather less useful now that haddock can give docs
with the same informatino in the module synopsis.

Having to maintain them when making changes to the library is a pain,
and when people forget about doing so there is nothing that checks that
the comments are right, so mistakes tend to linger.

Of the comments that my script detected, 78 of 684 were already
incorrect in one way or another, e.g. missing context:
    Text.Show.showsPrec
    Comment type: Int -> a -> ShowS
    Actual type:  Show a => Int -> a -> ShowS
wrong context:
    Numeric.readInt
    Comment type: Integral a => a -> (Char -> Bool) -> (Char -> Int) -> ReadS a
    Actual type:  Num a => a -> (Char -> Bool) -> (Char -> Int) -> ReadS a
not following a class change (e.g. Num losing its Eq superclass):
    Text.Read.Lex.readOctP
    Comment type: Num a => ReadP a
    Actual type:  (Eq a, Num a) => ReadP a
not following the Exceptions change:
    GHC.Conc.childHandler
    Comment type: Exception -> IO ()
    Actual type:  SomeException -> IO ()
or just always been wrong:
    GHC.Stable.deRefStablePtr
    Comment type: StablePtr a -> a
    Actual type:  StablePtr a -> IO a

60 files changed, 772 insertions, 820 deletions

diff --git a/libraries/base/Control/Concurrent.hs b/libraries/base/Control/Concurrent.hs
index fa7fc4d3e1..95ad957b97 100644
--- a/libraries/base/Control/Concurrent.hs
+++ b/libraries/base/Control/Concurrent.hs
@@ -55,7 +55,7 @@ module Control.Concurrent (
         -- * Scheduling
 
         -- $conc_scheduling     
-        yield,                  -- :: IO ()
+        yield,
 
         -- ** Blocking
 
@@ -63,9 +63,9 @@ module Control.Concurrent (
 
 #ifdef __GLASGOW_HASKELL__
         -- ** Waiting
-        threadDelay,            -- :: Int -> IO ()
-        threadWaitRead,         -- :: Int -> IO ()
-        threadWaitWrite,        -- :: Int -> IO ()
+        threadDelay,
+        threadWaitRead,
+        threadWaitWrite,
 #endif
 
         -- * Communication abstractions
diff --git a/libraries/base/Control/Concurrent/Chan.hs b/libraries/base/Control/Concurrent/Chan.hs
index be10c0053c..5781b9f476 100644
--- a/libraries/base/Control/Concurrent/Chan.hs
+++ b/libraries/base/Control/Concurrent/Chan.hs
@@ -24,16 +24,16 @@ module Control.Concurrent.Chan
         Chan,                   -- abstract
 
           -- * Operations
-        newChan,                -- :: IO (Chan a)
-        writeChan,              -- :: Chan a -> a -> IO ()
-        readChan,               -- :: Chan a -> IO a
-        dupChan,                -- :: Chan a -> IO (Chan a)
-        unGetChan,              -- :: Chan a -> a -> IO ()
-        isEmptyChan,            -- :: Chan a -> IO Bool
+        newChan,
+        writeChan,
+        readChan,
+        dupChan,
+        unGetChan,
+        isEmptyChan,
 
           -- * Stream interface
-        getChanContents,        -- :: Chan a -> IO [a]
-        writeList2Chan,         -- :: Chan a -> [a] -> IO ()
+        getChanContents,
+        writeList2Chan,
    ) where
 
 import Prelude
diff --git a/libraries/base/Control/Concurrent/MVar.hs b/libraries/base/Control/Concurrent/MVar.hs
index 7acfbdcbcf..5f1b4fce6e 100644
--- a/libraries/base/Control/Concurrent/MVar.hs
+++ b/libraries/base/Control/Concurrent/MVar.hs
@@ -141,7 +141,7 @@ module Control.Concurrent.MVar
         , modifyMVarMasked
 #ifndef __HUGS__
         , mkWeakMVar
-        , addMVarFinalizer -- :: MVar a -> IO () -> IO ()
+        , addMVarFinalizer
 #endif
     ) where
 
diff --git a/libraries/base/Control/Monad.hs b/libraries/base/Control/Monad.hs
index eec9465283..1aa17381a7 100644
--- a/libraries/base/Control/Monad.hs
+++ b/libraries/base/Control/Monad.hs
@@ -21,9 +21,9 @@ module Control.Monad
       Functor(fmap)
     , Monad((>>=), (>>), return, fail)
 
-    , MonadPlus (   -- class context: Monad
-          mzero     -- :: (MonadPlus m) => m a
-        , mplus     -- :: (MonadPlus m) => m a -> m a -> m a
+    , MonadPlus (
+          mzero
+        , mplus
         )
     -- * Functions
 
@@ -32,47 +32,47 @@ module Control.Monad
 
     -- ** Basic @Monad@ functions
 
-    , mapM          -- :: (Monad m) => (a -> m b) -> [a] -> m [b]
-    , mapM_         -- :: (Monad m) => (a -> m b) -> [a] -> m ()
-    , forM          -- :: (Monad m) => [a] -> (a -> m b) -> m [b]
-    , forM_         -- :: (Monad m) => [a] -> (a -> m b) -> m ()
-    , sequence      -- :: (Monad m) => [m a] -> m [a]
-    , sequence_     -- :: (Monad m) => [m a] -> m ()
-    , (=<<)         -- :: (Monad m) => (a -> m b) -> m a -> m b
-    , (>=>)         -- :: (Monad m) => (a -> m b) -> (b -> m c) -> (a -> m c)
-    , (<=<)         -- :: (Monad m) => (b -> m c) -> (a -> m b) -> (a -> m c)
-    , forever       -- :: (Monad m) => m a -> m b
+    , mapM
+    , mapM_
+    , forM
+    , forM_
+    , sequence
+    , sequence_
+    , (=<<)
+    , (>=>)
+    , (<=<)
+    , forever
     , void
 
     -- ** Generalisations of list functions
 
-    , join          -- :: (Monad m) => m (m a) -> m a
-    , msum          -- :: (MonadPlus m) => [m a] -> m a
-    , mfilter       -- :: (MonadPlus m) => (a -> Bool) -> m a -> m a
-    , filterM       -- :: (Monad m) => (a -> m Bool) -> [a] -> m [a]
-    , mapAndUnzipM  -- :: (Monad m) => (a -> m (b,c)) -> [a] -> m ([b], [c])
-    , zipWithM      -- :: (Monad m) => (a -> b -> m c) -> [a] -> [b] -> m [c]
-    , zipWithM_     -- :: (Monad m) => (a -> b -> m c) -> [a] -> [b] -> m ()
-    , foldM         -- :: (Monad m) => (a -> b -> m a) -> a -> [b] -> m a 
-    , foldM_        -- :: (Monad m) => (a -> b -> m a) -> a -> [b] -> m ()
-    , replicateM    -- :: (Monad m) => Int -> m a -> m [a]
-    , replicateM_   -- :: (Monad m) => Int -> m a -> m ()
+    , join
+    , msum
+    , mfilter
+    , filterM
+    , mapAndUnzipM
+    , zipWithM
+    , zipWithM_
+    , foldM
+    , foldM_
+    , replicateM
+    , replicateM_
 
     -- ** Conditional execution of monadic expressions
 
-    , guard         -- :: (MonadPlus m) => Bool -> m ()
-    , when          -- :: (Monad m) => Bool -> m () -> m ()
-    , unless        -- :: (Monad m) => Bool -> m () -> m ()
+    , guard
+    , when
+    , unless
 
     -- ** Monadic lifting operators
 
-    , liftM         -- :: (Monad m) => (a -> b) -> (m a -> m b)
-    , liftM2        -- :: (Monad m) => (a -> b -> c) -> (m a -> m b -> m c)
-    , liftM3        -- :: ...
-    , liftM4        -- :: ...
-    , liftM5        -- :: ...
+    , liftM
+    , liftM2
+    , liftM3
+    , liftM4
+    , liftM5
 
-    , ap            -- :: (Monad m) => m (a -> b) -> m a -> m b
+    , ap
 
     ) where
 
diff --git a/libraries/base/Control/Monad/Fix.hs b/libraries/base/Control/Monad/Fix.hs
index a3d2c89d85..1508d62653 100644
--- a/libraries/base/Control/Monad/Fix.hs
+++ b/libraries/base/Control/Monad/Fix.hs
@@ -19,10 +19,8 @@
 -----------------------------------------------------------------------------
 
 module Control.Monad.Fix (
-        MonadFix(
-           mfix -- :: (a -> m a) -> m a
-         ),
-        fix     -- :: (a -> a) -> a
+        MonadFix(mfix),
+        fix
   ) where
 
 import Prelude
diff --git a/libraries/base/Control/Monad/ST.hs b/libraries/base/Control/Monad/ST.hs
index 29d79599eb..fe8a837cda 100644
--- a/libraries/base/Control/Monad/ST.hs
+++ b/libraries/base/Control/Monad/ST.hs
@@ -23,12 +23,12 @@
 module Control.Monad.ST (
         -- * The 'ST' Monad
         ST,             -- abstract, instance of Functor, Monad, Typeable.
-        runST,          -- :: (forall s. ST s a) -> a
-        fixST,          -- :: (a -> ST s a) -> ST s a
+        runST,
+        fixST,
 
         -- * Converting 'ST' to 'IO'
         RealWorld,              -- abstract
-        stToIO,                 -- :: ST RealWorld a -> IO a
+        stToIO,
 
         -- * Unsafe Functions
         unsafeInterleaveST,
diff --git a/libraries/base/Control/Monad/ST/Imp.hs b/libraries/base/Control/Monad/ST/Imp.hs
index e3feaa6a68..9f58af3711 100644
--- a/libraries/base/Control/Monad/ST/Imp.hs
+++ b/libraries/base/Control/Monad/ST/Imp.hs
@@ -22,17 +22,17 @@
 module Control.Monad.ST.Imp (
         -- * The 'ST' Monad
         ST,             -- abstract, instance of Functor, Monad, Typeable.
-        runST,          -- :: (forall s. ST s a) -> a
-        fixST,          -- :: (a -> ST s a) -> ST s a
+        runST,
+        fixST,
 
         -- * Converting 'ST' to 'IO'
         RealWorld,              -- abstract
-        stToIO,                 -- :: ST RealWorld a -> IO a
+        stToIO,
 
         -- * Unsafe operations
-        unsafeInterleaveST,     -- :: ST s a -> ST s a
-        unsafeIOToST,           -- :: IO a -> ST s a
-        unsafeSTToIO            -- :: ST s a -> IO a
+        unsafeInterleaveST,
+        unsafeIOToST,
+        unsafeSTToIO
     ) where
 
 #if !defined(__GLASGOW_HASKELL__)
diff --git a/libraries/base/Control/Monad/ST/Safe.hs b/libraries/base/Control/Monad/ST/Safe.hs
index e6c8e8cfdc..1e9c981895 100644
--- a/libraries/base/Control/Monad/ST/Safe.hs
+++ b/libraries/base/Control/Monad/ST/Safe.hs
@@ -20,13 +20,13 @@
 
 module Control.Monad.ST.Safe (
         -- * The 'ST' Monad
-        ST,             -- abstract, instance of Functor, Monad, Typeable.
-        runST,          -- :: (forall s. ST s a) -> a
-        fixST,          -- :: (a -> ST s a) -> ST s a
+        ST,             -- abstract
+        runST,
+        fixST,
 
         -- * Converting 'ST' to 'IO'
         RealWorld,              -- abstract
-        stToIO,                 -- :: ST RealWorld a -> IO a
+        stToIO,
     ) where
 
 import Control.Monad.ST.Imp
diff --git a/libraries/base/Data/Bits.hs b/libraries/base/Data/Bits.hs
index abbadbd665..747a481e21 100644
--- a/libraries/base/Data/Bits.hs
+++ b/libraries/base/Data/Bits.hs
@@ -21,30 +21,28 @@
 
 module Data.Bits ( 
   Bits(
-    (.&.), (.|.), xor, -- :: a -> a -> a
-    complement,        -- :: a -> a
-    shift,             -- :: a -> Int -> a
-    rotate,            -- :: a -> Int -> a
-    bit,               -- :: Int -> a
-    setBit,            -- :: a -> Int -> a
-    clearBit,          -- :: a -> Int -> a
-    complementBit,     -- :: a -> Int -> a
-    testBit,           -- :: a -> Int -> Bool
+    (.&.), (.|.), xor,
+    complement,
+    shift,
+    rotate,
+    bit,
+    setBit,
+    clearBit,
+    complementBit,
+    testBit,
     bitSizeMaybe,
-    bitSize,           -- :: a -> Int
-    isSigned,          -- :: a -> Bool
-    shiftL, shiftR,    -- :: a -> Int -> a
-    unsafeShiftL, unsafeShiftR,  -- :: a -> Int -> a
-    rotateL, rotateR,  -- :: a -> Int -> a
-    popCount           -- :: a -> Int
+    bitSize,
+    isSigned,
+    shiftL, shiftR,
+    unsafeShiftL, unsafeShiftR,
+    rotateL, rotateR,
+    popCount
   ),
   FiniteBits(finiteBitSize),
 
   bitDefault,
   testBitDefault,
   popCountDefault
-  -- instance Bits Int
-  -- instance Bits Integer
  ) where
 
 -- Defines the @Bits@ class containing bit-based operations.
diff --git a/libraries/base/Data/Bool.hs b/libraries/base/Data/Bool.hs
index 1f53177aef..b60cad91b5 100644
--- a/libraries/base/Data/Bool.hs
+++ b/libraries/base/Data/Bool.hs
@@ -19,10 +19,10 @@ module Data.Bool (
    -- * Booleans
    Bool(..),
    -- ** Operations 
-   (&&),        -- :: Bool -> Bool -> Bool
-   (||),        -- :: Bool -> Bool -> Bool
-   not,         -- :: Bool -> Bool
-   otherwise,   -- :: Bool
+   (&&),
+   (||),
+   not,
+   otherwise,
   ) where
 
 #ifdef __GLASGOW_HASKELL__
diff --git a/libraries/base/Data/Char.hs b/libraries/base/Data/Char.hs
index 26ca8a4c36..56f6487371 100644
--- a/libraries/base/Data/Char.hs
+++ b/libraries/base/Data/Char.hs
@@ -36,20 +36,20 @@ module Data.Char
     , GeneralCategory(..), generalCategory
 
     -- * Case conversion
-    , toUpper, toLower, toTitle  -- :: Char -> Char
+    , toUpper, toLower, toTitle
 
     -- * Single digit characters
-    , digitToInt        -- :: Char -> Int
-    , intToDigit        -- :: Int  -> Char
+    , digitToInt
+    , intToDigit
 
     -- * Numeric representations
-    , ord               -- :: Char -> Int
-    , chr               -- :: Int  -> Char
+    , ord
+    , chr
 
     -- * String representations
-    , showLitChar       -- :: Char -> ShowS
-    , lexLitChar        -- :: ReadS String
-    , readLitChar       -- :: ReadS Char 
+    , showLitChar
+    , lexLitChar
+    , readLitChar
     ) where
 
 #ifdef __GLASGOW_HASKELL__
diff --git a/libraries/base/Data/Complex.hs b/libraries/base/Data/Complex.hs
index 1e32bd74fa..b0f549e14f 100644
--- a/libraries/base/Data/Complex.hs
+++ b/libraries/base/Data/Complex.hs
@@ -23,25 +23,16 @@ module Data.Complex
         -- * Rectangular form
           Complex((:+))
 
-        , realPart      -- :: (RealFloat a) => Complex a -> a
-        , imagPart      -- :: (RealFloat a) => Complex a -> a
+        , realPart
+        , imagPart
         -- * Polar form
-        , mkPolar       -- :: (RealFloat a) => a -> a -> Complex a
-        , cis           -- :: (RealFloat a) => a -> Complex a
-        , polar         -- :: (RealFloat a) => Complex a -> (a,a)
-        , magnitude     -- :: (RealFloat a) => Complex a -> a
-        , phase         -- :: (RealFloat a) => Complex a -> a
+        , mkPolar
+        , cis
+        , polar
+        , magnitude
+        , phase
         -- * Conjugate
-        , conjugate     -- :: (RealFloat a) => Complex a -> Complex a
-
-        -- Complex instances:
-        --
-        --  (RealFloat a) => Eq         (Complex a)
-        --  (RealFloat a) => Read       (Complex a)
-        --  (RealFloat a) => Show       (Complex a)
-        --  (RealFloat a) => Num        (Complex a)
-        --  (RealFloat a) => Fractional (Complex a)
-        --  (RealFloat a) => Floating   (Complex a)
+        , conjugate
 
         )  where
 
diff --git a/libraries/base/Data/Data.hs b/libraries/base/Data/Data.hs
index 0a29668546..4dd229a4cd 100644
--- a/libraries/base/Data/Data.hs
+++ b/libraries/base/Data/Data.hs
@@ -32,10 +32,10 @@ module Data.Data (
 
         -- * The Data class for processing constructor applications
         Data(
-                gfoldl,         -- :: ... -> a -> c a
-                gunfold,        -- :: ... -> Constr -> c a
-                toConstr,       -- :: a -> Constr
-                dataTypeOf,     -- :: a -> DataType
+                gfoldl,
+                gunfold,
+                toConstr,
+                dataTypeOf,
                 dataCast1,      -- mediate types and unary type constructors
                 dataCast2,      -- mediate types and binary type constructors
                 -- Generic maps defined in terms of gfoldl 
@@ -50,54 +50,54 @@ module Data.Data (
             ),
 
         -- * Datatype representations
-        DataType,       -- abstract, instance of: Show
+        DataType,       -- abstract
         -- ** Constructors
-        mkDataType,     -- :: String   -> [Constr] -> DataType
-        mkIntType,      -- :: String -> DataType
-        mkFloatType,    -- :: String -> DataType
-        mkCharType,     -- :: String -> DataType
-        mkNoRepType,    -- :: String -> DataType
+        mkDataType,
+        mkIntType,
+        mkFloatType,
+        mkCharType,
+        mkNoRepType,
         -- ** Observers
-        dataTypeName,   -- :: DataType -> String
-        DataRep(..),    -- instance of: Eq, Show
-        dataTypeRep,    -- :: DataType -> DataRep
+        dataTypeName,
+        DataRep(..),
+        dataTypeRep,
         -- ** Convenience functions
-        repConstr,      -- :: DataType -> ConstrRep -> Constr
-        isAlgType,      -- :: DataType -> Bool
-        dataTypeConstrs,-- :: DataType -> [Constr]
-        indexConstr,    -- :: DataType -> ConIndex -> Constr
-        maxConstrIndex, -- :: DataType -> ConIndex
-        isNorepType,    -- :: DataType -> Bool
+        repConstr,
+        isAlgType,
+        dataTypeConstrs,
+        indexConstr,
+        maxConstrIndex,
+        isNorepType,
 
         -- * Data constructor representations
-        Constr,         -- abstract, instance of: Eq, Show
+        Constr,         -- abstract
         ConIndex,       -- alias for Int, start at 1
-        Fixity(..),     -- instance of: Eq, Show
+        Fixity(..),
         -- ** Constructors
-        mkConstr,       -- :: DataType -> String -> Fixity -> Constr
-        mkIntegralConstr,-- :: (Integral a) => DataType -> a -> Constr
-        mkRealConstr,   -- :: (Real a) => DataType -> a -> Constr
-        mkCharConstr,   -- :: DataType -> Char -> Constr
+        mkConstr,
+        mkIntegralConstr,
+        mkRealConstr,
+        mkCharConstr,
         -- ** Observers
-        constrType,     -- :: Constr   -> DataType
-        ConstrRep(..),  -- instance of: Eq, Show
-        constrRep,      -- :: Constr   -> ConstrRep
-        constrFields,   -- :: Constr   -> [String]
-        constrFixity,   -- :: Constr   -> Fixity
+        constrType,
+        ConstrRep(..),
+        constrRep,
+        constrFields,
+        constrFixity,
         -- ** Convenience function: algebraic data types
-        constrIndex,    -- :: Constr   -> ConIndex
+        constrIndex,
         -- ** From strings to constructors and vice versa: all data types
-        showConstr,     -- :: Constr   -> String
-        readConstr,     -- :: DataType -> String -> Maybe Constr
+        showConstr,
+        readConstr,
 
         -- * Convenience functions: take type constructors apart
-        tyconUQname,    -- :: String -> String
-        tyconModule,    -- :: String -> String
+        tyconUQname,
+        tyconModule,
 
         -- * Generic operations defined in terms of 'gunfold'
-        fromConstr,     -- :: Constr -> a
-        fromConstrB,    -- :: ... -> Constr -> a
-        fromConstrM     -- :: Monad m => ... -> Constr -> m a
+        fromConstr,
+        fromConstrB,
+        fromConstrM
 
   ) where
 
diff --git a/libraries/base/Data/Dynamic.hs b/libraries/base/Data/Dynamic.hs
index 11501b8c98..03a34cf3c6 100644
--- a/libraries/base/Data/Dynamic.hs
+++ b/libraries/base/Data/Dynamic.hs
@@ -33,9 +33,9 @@ module Data.Dynamic
         Dynamic,        -- abstract, instance of: Show, Typeable
 
         -- * Converting to and from @Dynamic@
-        toDyn,          -- :: Typeable a => a -> Dynamic
-        fromDyn,        -- :: Typeable a => Dynamic -> a -> a
-        fromDynamic,    -- :: Typeable a => Dynamic -> Maybe a
+        toDyn,
+        fromDyn,
+        fromDynamic,
         
         -- * Applying functions of dynamic type
         dynApply,
diff --git a/libraries/base/Data/Either.hs b/libraries/base/Data/Either.hs
index 2dbe9e8f77..0fd862e025 100644
--- a/libraries/base/Data/Either.hs
+++ b/libraries/base/Data/Either.hs
@@ -20,10 +20,10 @@
 
 module Data.Either (
    Either(..),
-   either,           -- :: (a -> c) -> (b -> c) -> Either a b -> c
-   lefts,            -- :: [Either a b] -> [a]
-   rights,           -- :: [Either a b] -> [b]
-   partitionEithers, -- :: [Either a b] -> ([a],[b])
+   either,
+   lefts,
+   rights,
+   partitionEithers,
  ) where
 
 #include "Typeable.h"
diff --git a/libraries/base/Data/IORef.hs b/libraries/base/Data/IORef.hs
index 580013232b..a66ce1bc0a 100644
--- a/libraries/base/Data/IORef.hs
+++ b/libraries/base/Data/IORef.hs
@@ -19,17 +19,17 @@ module Data.IORef
   ( 
         -- * IORefs
         IORef,                -- abstract, instance of: Eq, Typeable
-        newIORef,             -- :: a -> IO (IORef a)
-        readIORef,            -- :: IORef a -> IO a
-        writeIORef,           -- :: IORef a -> a -> IO ()
-        modifyIORef,          -- :: IORef a -> (a -> a) -> IO ()
-        modifyIORef',         -- :: IORef a -> (a -> a) -> IO ()
-        atomicModifyIORef,    -- :: IORef a -> (a -> (a,b)) -> IO b
-        atomicModifyIORef',   -- :: IORef a -> (a -> (a,b)) -> IO b
+        newIORef,
+        readIORef,
+        writeIORef,
+        modifyIORef,
+        modifyIORef',
+        atomicModifyIORef,
+        atomicModifyIORef',
         atomicWriteIORef,
 
 #if !defined(__PARALLEL_HASKELL__) && defined(__GLASGOW_HASKELL__)
-        mkWeakIORef,          -- :: IORef a -> IO () -> IO (Weak (IORef a))
+        mkWeakIORef,
 #endif
         -- ** Memory Model
 
diff --git a/libraries/base/Data/Ix.hs b/libraries/base/Data/Ix.hs
index 4af5db334d..44fc4099ba 100644
--- a/libraries/base/Data/Ix.hs
+++ b/libraries/base/Data/Ix.hs
@@ -21,10 +21,10 @@ module Data.Ix
     (
     -- * The 'Ix' class
         Ix
-          ( range       -- :: (Ix a) => (a,a) -> [a]
-          , index       -- :: (Ix a) => (a,a) -> a   -> Int
-          , inRange     -- :: (Ix a) => (a,a) -> a   -> Bool
-          , rangeSize   -- :: (Ix a) => (a,a) -> Int
+          ( range
+          , index
+          , inRange
+          , rangeSize
           )
     -- Ix instances:
     --
diff --git a/libraries/base/Data/List.hs b/libraries/base/Data/List.hs
index 7a05939552..431ae1bc4e 100644
--- a/libraries/base/Data/List.hs
+++ b/libraries/base/Data/List.hs
@@ -24,152 +24,152 @@ module Data.List
 
    -- * Basic functions
 
-     (++)              -- :: [a] -> [a] -> [a]
-   , head              -- :: [a] -> a
-   , last              -- :: [a] -> a
-   , tail              -- :: [a] -> [a]
-   , init              -- :: [a] -> [a]
-   , null              -- :: [a] -> Bool
-   , length            -- :: [a] -> Int
+     (++)
+   , head
+   , last
+   , tail
+   , init
+   , null
+   , length
 
    -- * List transformations
-   , map               -- :: (a -> b) -> [a] -> [b]
-   , reverse           -- :: [a] -> [a]
+   , map
+   , reverse
 
-   , intersperse       -- :: a -> [a] -> [a]
-   , intercalate       -- :: [a] -> [[a]] -> [a]
-   , transpose         -- :: [[a]] -> [[a]]
+   , intersperse
+   , intercalate
+   , transpose
    
-   , subsequences      -- :: [a] -> [[a]]
-   , permutations      -- :: [a] -> [[a]]
+   , subsequences
+   , permutations
 
    -- * Reducing lists (folds)
 
-   , foldl             -- :: (b -> a -> b) -> b -> [a] -> b
-   , foldl'            -- :: (b -> a -> b) -> b -> [a] -> b
-   , foldl1            -- :: (a -> a -> a) -> [a] -> a
-   , foldl1'           -- :: (a -> a -> a) -> [a] -> a
-   , foldr             -- :: (a -> b -> b) -> b -> [a] -> b
-   , foldr1            -- :: (a -> a -> a) -> [a] -> a
+   , foldl
+   , foldl'
+   , foldl1
+   , foldl1'
+   , foldr
+   , foldr1
 
    -- ** Special folds
 
-   , concat            -- :: [[a]] -> [a]
-   , concatMap         -- :: (a -> [b]) -> [a] -> [b]
-   , and               -- :: [Bool] -> Bool
-   , or                -- :: [Bool] -> Bool
-   , any               -- :: (a -> Bool) -> [a] -> Bool
-   , all               -- :: (a -> Bool) -> [a] -> Bool
-   , sum               -- :: (Num a) => [a] -> a
-   , product           -- :: (Num a) => [a] -> a
-   , maximum           -- :: (Ord a) => [a] -> a
-   , minimum           -- :: (Ord a) => [a] -> a
+   , concat
+   , concatMap
+   , and
+   , or
+   , any
+   , all
+   , sum
+   , product
+   , maximum
+   , minimum
 
    -- * Building lists
 
    -- ** Scans
-   , scanl             -- :: (b -> a -> b) -> b -> [a] -> [b]
-   , scanl1            -- :: (a -> a -> a) -> [a] -> [a]
-   , scanr             -- :: (a -> b -> b) -> b -> [a] -> [b]
-   , scanr1            -- :: (a -> a -> a) -> [a] -> [a]
+   , scanl
+   , scanl1
+   , scanr
+   , scanr1
 
    -- ** Accumulating maps
-   , mapAccumL         -- :: (a -> b -> (a,c)) -> a -> [b] -> (a,[c])
-   , mapAccumR         -- :: (a -> b -> (a,c)) -> a -> [b] -> (a,[c])
+   , mapAccumL
+   , mapAccumR
 
    -- ** Infinite lists
-   , iterate           -- :: (a -> a) -> a -> [a]
-   , repeat            -- :: a -> [a]
-   , replicate         -- :: Int -> a -> [a]
-   , cycle             -- :: [a] -> [a]
+   , iterate
+   , repeat
+   , replicate
+   , cycle
 
    -- ** Unfolding
-   , unfoldr           -- :: (b -> Maybe (a, b)) -> b -> [a]
+   , unfoldr
 
    -- * Sublists
 
    -- ** Extracting sublists
-   , take              -- :: Int -> [a] -> [a]
-   , drop              -- :: Int -> [a] -> [a]
-   , splitAt           -- :: Int -> [a] -> ([a], [a])
+   , take
+   , drop
+   , splitAt
 
-   , takeWhile         -- :: (a -> Bool) -> [a] -> [a]
-   , dropWhile         -- :: (a -> Bool) -> [a] -> [a]
-   , dropWhileEnd      -- :: (a -> Bool) -> [a] -> [a]
-   , span              -- :: (a -> Bool) -> [a] -> ([a], [a])
-   , break             -- :: (a -> Bool) -> [a] -> ([a], [a])
+   , takeWhile
+   , dropWhile
+   , dropWhileEnd
+   , span
+   , break
 
-   , stripPrefix       -- :: Eq a => [a] -> [a] -> Maybe [a]
+   , stripPrefix
 
-   , group             -- :: Eq a => [a] -> [[a]]
+   , group
 
-   , inits             -- :: [a] -> [[a]]
-   , tails             -- :: [a] -> [[a]]
+   , inits
+   , tails
 
    -- ** Predicates
-   , isPrefixOf        -- :: (Eq a) => [a] -> [a] -> Bool
-   , isSuffixOf        -- :: (Eq a) => [a] -> [a] -> Bool
-   , isInfixOf         -- :: (Eq a) => [a] -> [a] -> Bool
+   , isPrefixOf
+   , isSuffixOf
+   , isInfixOf
 
    -- * Searching lists
 
    -- ** Searching by equality
-   , elem              -- :: a -> [a] -> Bool
-   , notElem           -- :: a -> [a] -> Bool
-   , lookup            -- :: (Eq a) => a -> [(a,b)] -> Maybe b
+   , elem
+   , notElem
+   , lookup
 
    -- ** Searching with a predicate
-   , find              -- :: (a -> Bool) -> [a] -> Maybe a
-   , filter            -- :: (a -> Bool) -> [a] -> [a]
-   , partition         -- :: (a -> Bool) -> [a] -> ([a], [a])
+   , find
+   , filter
+   , partition
 
    -- * Indexing lists
    -- | These functions treat a list @xs@ as a indexed collection,
    -- with indices ranging from 0 to @'length' xs - 1@.
 
-   , (!!)              -- :: [a] -> Int -> a
+   , (!!)
 
-   , elemIndex         -- :: (Eq a) => a -> [a] -> Maybe Int
-   , elemIndices       -- :: (Eq a) => a -> [a] -> [Int]
+   , elemIndex
+   , elemIndices
 
-   , findIndex         -- :: (a -> Bool) -> [a] -> Maybe Int
-   , findIndices       -- :: (a -> Bool) -> [a] -> [Int]
+   , findIndex
+   , findIndices
 
    -- * Zipping and unzipping lists
 
-   , zip               -- :: [a] -> [b] -> [(a,b)]
+   , zip
    , zip3
    , zip4, zip5, zip6, zip7
 
-   , zipWith           -- :: (a -> b -> c) -> [a] -> [b] -> [c]
+   , zipWith
    , zipWith3
    , zipWith4, zipWith5, zipWith6, zipWith7
 
-   , unzip             -- :: [(a,b)] -> ([a],[b])
+   , unzip
    , unzip3
    , unzip4, unzip5, unzip6, unzip7
 
    -- * Special lists
 
    -- ** Functions on strings
-   , lines             -- :: String   -> [String]
-   , words             -- :: String   -> [String]
-   , unlines           -- :: [String] -> String
-   , unwords           -- :: [String] -> String
+   , lines
+   , words
+   , unlines
+   , unwords
 
    -- ** \"Set\" operations
 
-   , nub               -- :: (Eq a) => [a] -> [a]
+   , nub
 
-   , delete            -- :: (Eq a) => a -> [a] -> [a]
-   , (\\)              -- :: (Eq a) => [a] -> [a] -> [a]
+   , delete
+   , (\\)
 
-   , union             -- :: (Eq a) => [a] -> [a] -> [a]
-   , intersect         -- :: (Eq a) => [a] -> [a] -> [a]
+   , union
+   , intersect
 
    -- ** Ordered lists
-   , sort              -- :: (Ord a) => [a] -> [a]
-   , insert            -- :: (Ord a) => a -> [a] -> [a]
+   , sort
+   , insert
 
    -- * Generalized functions
 
@@ -183,30 +183,30 @@ module Data.List
 
    -- *** User-supplied equality (replacing an @Eq@ context)
    -- | The predicate is assumed to define an equivalence.
-   , nubBy             -- :: (a -> a -> Bool) -> [a] -> [a]
-   , deleteBy          -- :: (a -> a -> Bool) -> a -> [a] -> [a]
-   , deleteFirstsBy    -- :: (a -> a -> Bool) -> [a] -> [a] -> [a]
-   , unionBy           -- :: (a -> a -> Bool) -> [a] -> [a] -> [a]
-   , intersectBy       -- :: (a -> a -> Bool) -> [a] -> [a] -> [a]
-   , groupBy           -- :: (a -> a -> Bool) -> [a] -> [[a]]
+   , nubBy
+   , deleteBy
+   , deleteFirstsBy
+   , unionBy
+   , intersectBy
+   , groupBy
 
    -- *** User-supplied comparison (replacing an @Ord@ context)
    -- | The function is assumed to define a total ordering.
-   , sortBy            -- :: (a -> a -> Ordering) -> [a] -> [a]
-   , insertBy          -- :: (a -> a -> Ordering) -> a -> [a] -> [a]
-   , maximumBy         -- :: (a -> a -> Ordering) -> [a] -> a
-   , minimumBy         -- :: (a -> a -> Ordering) -> [a] -> a
+   , sortBy
+   , insertBy
+   , maximumBy
+   , minimumBy
 
    -- ** The \"@generic@\" operations
    -- | The prefix \`@generic@\' indicates an overloaded function that
    -- is a generalized version of a "Prelude" function.
 
-   , genericLength     -- :: (Integral a) => [b] -> a
-   , genericTake       -- :: (Integral a) => a -> [b] -> [b]
-   , genericDrop       -- :: (Integral a) => a -> [b] -> [b]
-   , genericSplitAt    -- :: (Integral a) => a -> [b] -> ([b], [b])
-   , genericIndex      -- :: (Integral a) => [b] -> a -> b
-   , genericReplicate  -- :: (Integral a) => a -> b -> [b]
+   , genericLength
+   , genericTake
+   , genericDrop
+   , genericSplitAt
+   , genericIndex
+   , genericReplicate
 
    ) where
 
diff --git a/libraries/base/Data/Maybe.hs b/libraries/base/Data/Maybe.hs
index aafe8928bd..728c981755 100644
--- a/libraries/base/Data/Maybe.hs
+++ b/libraries/base/Data/Maybe.hs
@@ -17,19 +17,18 @@
 
 module Data.Maybe
    (
-     Maybe(Nothing,Just)-- instance of: Eq, Ord, Show, Read,
-                        --              Functor, Monad, MonadPlus
-
-   , maybe              -- :: b -> (a -> b) -> Maybe a -> b
-
-   , isJust             -- :: Maybe a -> Bool
-   , isNothing          -- :: Maybe a -> Bool
-   , fromJust           -- :: Maybe a -> a
-   , fromMaybe          -- :: a -> Maybe a -> a
-   , listToMaybe        -- :: [a] -> Maybe a
-   , maybeToList        -- :: Maybe a -> [a]
-   , catMaybes          -- :: [Maybe a] -> [a]
-   , mapMaybe           -- :: (a -> Maybe b) -> [a] -> [b]
+     Maybe(Nothing,Just)
+
+   , maybe
+
+   , isJust
+   , isNothing
+   , fromJust
+   , fromMaybe
+   , listToMaybe
+   , maybeToList
+   , catMaybes
+   , mapMaybe
    ) where
 
 #ifdef __GLASGOW_HASKELL__
diff --git a/libraries/base/Data/Ratio.hs b/libraries/base/Data/Ratio.hs
index d3d29c8bb9..a9f726e849 100644
--- a/libraries/base/Data/Ratio.hs
+++ b/libraries/base/Data/Ratio.hs
@@ -18,21 +18,10 @@
 module Data.Ratio
     ( Ratio
     , Rational
-    , (%)               -- :: (Integral a) => a -> a -> Ratio a
-    , numerator         -- :: (Integral a) => Ratio a -> a
-    , denominator       -- :: (Integral a) => Ratio a -> a
-    , approxRational    -- :: (RealFrac a) => a -> a -> Rational
-
-    -- Ratio instances: 
-    --   (Integral a) => Eq   (Ratio a)
-    --   (Integral a) => Ord  (Ratio a)
-    --   (Integral a) => Num  (Ratio a)
-    --   (Integral a) => Real (Ratio a)
-    --   (Integral a) => Fractional (Ratio a)
-    --   (Integral a) => RealFrac (Ratio a)
-    --   (Integral a) => Enum     (Ratio a)
-    --   (Read a, Integral a) => Read (Ratio a)
-    --   (Integral a) => Show     (Ratio a)
+    , (%)
+    , numerator
+    , denominator
+    , approxRational
 
   ) where
 
diff --git a/libraries/base/Data/STRef.hs b/libraries/base/Data/STRef.hs
index 7c884e512b..f8e6e13c58 100644
--- a/libraries/base/Data/STRef.hs
+++ b/libraries/base/Data/STRef.hs
@@ -17,12 +17,12 @@
 
 module Data.STRef (
         -- * STRefs
-        STRef,          -- abstract, instance Eq
-        newSTRef,       -- :: a -> ST s (STRef s a)
-        readSTRef,      -- :: STRef s a -> ST s a
-        writeSTRef,     -- :: STRef s a -> a -> ST s ()
-        modifySTRef,    -- :: STRef s a -> (a -> a) -> ST s ()
-        modifySTRef'    -- :: STRef s a -> (a -> a) -> ST s ()
+        STRef,          -- abstract
+        newSTRef,
+        readSTRef,
+        writeSTRef,
+        modifySTRef,
+        modifySTRef'
  ) where
 
 import Prelude
diff --git a/libraries/base/Data/STRef/Lazy.hs b/libraries/base/Data/STRef/Lazy.hs
index 7c9a74e9b5..039b03f3b5 100644
--- a/libraries/base/Data/STRef/Lazy.hs
+++ b/libraries/base/Data/STRef/Lazy.hs
@@ -16,11 +16,11 @@
 
 module Data.STRef.Lazy (
         -- * STRefs
-        ST.STRef,       -- abstract, instance Eq
-        newSTRef,       -- :: a -> ST s (STRef s a)
-        readSTRef,      -- :: STRef s a -> ST s a
-        writeSTRef,     -- :: STRef s a -> a -> ST s ()
-        modifySTRef     -- :: STRef s a -> (a -> a) -> ST s ()
+        ST.STRef,       -- abstract
+        newSTRef,
+        readSTRef,
+        writeSTRef,
+        modifySTRef
  ) where
 
 import Control.Monad.ST.Lazy.Safe
diff --git a/libraries/base/Data/Tuple.hs b/libraries/base/Data/Tuple.hs
index 30f93c5e63..12684c3ac4 100644
--- a/libraries/base/Data/Tuple.hs
+++ b/libraries/base/Data/Tuple.hs
@@ -18,11 +18,11 @@
 -----------------------------------------------------------------------------
 
 module Data.Tuple
-  ( fst         -- :: (a,b) -> a
-  , snd         -- :: (a,b) -> a
-  , curry       -- :: ((a, b) -> c) -> a -> b -> c
-  , uncurry     -- :: (a -> b -> c) -> ((a, b) -> c)
-  , swap        -- :: (a,b) -> (b,a)
+  ( fst
+  , snd
+  , curry
+  , uncurry
+  , swap
 #ifdef __NHC__
   , (,)(..)
   , (,,)(..)
diff --git a/libraries/base/Data/Typeable.hs b/libraries/base/Data/Typeable.hs
index 73c989b52c..d43ad50253 100644
--- a/libraries/base/Data/Typeable.hs
+++ b/libraries/base/Data/Typeable.hs
@@ -39,10 +39,10 @@ module Data.Typeable
   (
 
         -- * The Typeable class
-        Typeable( typeOf ),     -- :: a -> TypeRep
+        Typeable( typeOf ),
 
         -- * Type-safe cast
-        cast,                   -- :: (Typeable a, Typeable b) => a -> Maybe b
+        cast,
         gcast,                  -- a generalisation of cast
 
         -- * Type representations
@@ -50,48 +50,48 @@ module Data.Typeable
         showsTypeRep,
 
         TyCon,          -- abstract, instance of: Eq, Show, Typeable
-        tyConString,    -- :: TyCon   -> String
-        tyConPackage,   -- :: TyCon   -> String
-        tyConModule,    -- :: TyCon   -> String
-        tyConName,      -- :: TyCon   -> String
+        tyConString,
+        tyConPackage,
+        tyConModule,
+        tyConName,
 
         -- * Construction of type representations
-        mkTyCon,        -- :: String  -> TyCon
-        mkTyCon3,       -- :: String  -> String -> String -> TyCon
-        mkTyConApp,     -- :: TyCon   -> [TypeRep] -> TypeRep
-        mkAppTy,        -- :: TypeRep -> TypeRep   -> TypeRep
-        mkFunTy,        -- :: TypeRep -> TypeRep   -> TypeRep
+        mkTyCon,
+        mkTyCon3,
+        mkTyConApp,
+        mkAppTy,
+        mkFunTy,
 
         -- * Observation of type representations
-        splitTyConApp,  -- :: TypeRep -> (TyCon, [TypeRep])
-        funResultTy,    -- :: TypeRep -> TypeRep   -> Maybe TypeRep
-        typeRepTyCon,   -- :: TypeRep -> TyCon
-        typeRepArgs,    -- :: TypeRep -> [TypeRep]
-        typeRepKey,     -- :: TypeRep -> IO TypeRepKey
+        splitTyConApp,
+        funResultTy,
+        typeRepTyCon,
+        typeRepArgs,
+        typeRepKey,
         TypeRepKey,     -- abstract, instance of Eq, Ord
 
         -- * The other Typeable classes
         -- | /Note:/ The general instances are provided for GHC only.
-        Typeable1( typeOf1 ),   -- :: t a -> TypeRep
-        Typeable2( typeOf2 ),   -- :: t a b -> TypeRep
-        Typeable3( typeOf3 ),   -- :: t a b c -> TypeRep
-        Typeable4( typeOf4 ),   -- :: t a b c d -> TypeRep
-        Typeable5( typeOf5 ),   -- :: t a b c d e -> TypeRep
-        Typeable6( typeOf6 ),   -- :: t a b c d e f -> TypeRep
-        Typeable7( typeOf7 ),   -- :: t a b c d e f g -> TypeRep
-        gcast1,                 -- :: ... => c (t a) -> Maybe (c (t' a))
-        gcast2,                 -- :: ... => c (t a b) -> Maybe (c (t' a b))
+        Typeable1( typeOf1 ),
+        Typeable2( typeOf2 ),
+        Typeable3( typeOf3 ),
+        Typeable4( typeOf4 ),
+        Typeable5( typeOf5 ),
+        Typeable6( typeOf6 ),
+        Typeable7( typeOf7 ),
+        gcast1,
+        gcast2,
 
         -- * Default instances
         -- | /Note:/ These are not needed by GHC, for which these instances
         -- are generated by general instance declarations.
-        typeOfDefault,  -- :: (Typeable1 t, Typeable a) => t a -> TypeRep
-        typeOf1Default, -- :: (Typeable2 t, Typeable a) => t a b -> TypeRep
-        typeOf2Default, -- :: (Typeable3 t, Typeable a) => t a b c -> TypeRep
-        typeOf3Default, -- :: (Typeable4 t, Typeable a) => t a b c d -> TypeRep
-        typeOf4Default, -- :: (Typeable5 t, Typeable a) => t a b c d e -> TypeRep
-        typeOf5Default, -- :: (Typeable6 t, Typeable a) => t a b c d e f -> TypeRep
-        typeOf6Default  -- :: (Typeable7 t, Typeable a) => t a b c d e f g -> TypeRep
+        typeOfDefault,
+        typeOf1Default,
+        typeOf2Default,
+        typeOf3Default,
+        typeOf4Default,
+        typeOf5Default,
+        typeOf6Default
 
   ) where
 
diff --git a/libraries/base/Data/Unique.hs b/libraries/base/Data/Unique.hs
index 3443c9aaee..b8aa6cd63a 100644
--- a/libraries/base/Data/Unique.hs
+++ b/libraries/base/Data/Unique.hs
@@ -21,9 +21,9 @@
 
 module Data.Unique (
    -- * Unique objects
-   Unique,              -- instance (Eq, Ord)
-   newUnique,           -- :: IO Unique
-   hashUnique           -- :: Unique -> Int
+   Unique,
+   newUnique,
+   hashUnique
  ) where
 
 import Prelude
diff --git a/libraries/base/Debug/Trace.hs b/libraries/base/Debug/Trace.hs
index 998b4a4b5e..f5839eead2 100644
--- a/libraries/base/Debug/Trace.hs
+++ b/libraries/base/Debug/Trace.hs
@@ -21,10 +21,10 @@
 module Debug.Trace (
         -- * Tracing
         -- $tracing
-        trace,            -- :: String -> a -> a
+        trace,
         traceShow,
         traceStack,
-        traceIO,          -- :: String -> IO ()
+        traceIO,
         putTraceMsg,
 
         -- * Eventlog tracing
diff --git a/libraries/base/Foreign/C/Error.hs b/libraries/base/Foreign/C/Error.hs
index 3f16d27ef4..17ab2d0716 100644
--- a/libraries/base/Foreign/C/Error.hs
+++ b/libraries/base/Foreign/C/Error.hs
@@ -19,7 +19,7 @@ module Foreign.C.Error (
 
   -- * Haskell representations of @errno@ values
 
-  Errno(..),            -- instance: Eq
+  Errno(..),
 
   -- ** Common @errno@ symbols
   -- | Different operating systems and\/or C libraries often support
@@ -42,44 +42,33 @@ module Foreign.C.Error (
   eTOOMANYREFS, eTXTBSY, eUSERS, eWOULDBLOCK, eXDEV,
 
   -- ** 'Errno' functions
-                        -- :: Errno
-  isValidErrno,         -- :: Errno -> Bool
+  isValidErrno,
 
   -- access to the current thread's "errno" value
   --
-  getErrno,             -- :: IO Errno
-  resetErrno,           -- :: IO ()
+  getErrno,
+  resetErrno,
 
   -- conversion of an "errno" value into IO error
   --
-  errnoToIOError,       -- :: String       -- location
-                        -- -> Errno        -- errno
-                        -- -> Maybe Handle -- handle
-                        -- -> Maybe String -- filename
-                        -- -> IOError
+  errnoToIOError,
 
   -- throw current "errno" value
   --
-  throwErrno,           -- ::                String               -> IO a
+  throwErrno,
 
   -- ** Guards for IO operations that may fail
 
-  throwErrnoIf,         -- :: (a -> Bool) -> String -> IO a       -> IO a
-  throwErrnoIf_,        -- :: (a -> Bool) -> String -> IO a       -> IO ()
-  throwErrnoIfRetry,    -- :: (a -> Bool) -> String -> IO a       -> IO a
-  throwErrnoIfRetry_,   -- :: (a -> Bool) -> String -> IO a       -> IO ()
-  throwErrnoIfMinus1,   -- :: Num a 
-                        -- =>                String -> IO a       -> IO a
-  throwErrnoIfMinus1_,  -- :: Num a 
-                        -- =>                String -> IO a       -> IO ()
+  throwErrnoIf,
+  throwErrnoIf_,
+  throwErrnoIfRetry,
+  throwErrnoIfRetry_,
+  throwErrnoIfMinus1,
+  throwErrnoIfMinus1_,
   throwErrnoIfMinus1Retry,
-                        -- :: Num a 
-                        -- =>                String -> IO a       -> IO a
   throwErrnoIfMinus1Retry_,  
-                        -- :: Num a 
-                        -- =>                String -> IO a       -> IO ()
-  throwErrnoIfNull,     -- ::                String -> IO (Ptr a) -> IO (Ptr a)
-  throwErrnoIfNullRetry,-- ::                String -> IO (Ptr a) -> IO (Ptr a)
+  throwErrnoIfNull,
+  throwErrnoIfNullRetry,
 
   throwErrnoIfRetryMayBlock, 
   throwErrnoIfRetryMayBlock_,
diff --git a/libraries/base/Foreign/C/String.hs b/libraries/base/Foreign/C/String.hs
index a55f856165..8be917ac07 100644
--- a/libraries/base/Foreign/C/String.hs
+++ b/libraries/base/Foreign/C/String.hs
@@ -26,8 +26,8 @@
 module Foreign.C.String (   -- representation of strings in C
   -- * C strings
 
-  CString,           -- = Ptr CChar
-  CStringLen,        -- = (Ptr CChar, Int)
+  CString,
+  CStringLen,
 
   -- ** Using a locale-dependent encoding
 
@@ -42,20 +42,20 @@ module Foreign.C.String (   -- representation of strings in C
 
   -- conversion of C strings into Haskell strings
   --
-  peekCString,       -- :: CString    -> IO String
-  peekCStringLen,    -- :: CStringLen -> IO String
+  peekCString,
+  peekCStringLen,
 
   -- conversion of Haskell strings into C strings
   --
-  newCString,        -- :: String -> IO CString
-  newCStringLen,     -- :: String -> IO CStringLen
+  newCString,
+  newCStringLen,
 
   -- conversion of Haskell strings into C strings using temporary storage
   --
-  withCString,       -- :: String -> (CString    -> IO a) -> IO a
-  withCStringLen,    -- :: String -> (CStringLen -> IO a) -> IO a
+  withCString,
+  withCStringLen,
 
-  charIsRepresentable, -- :: Char -> IO Bool
+  charIsRepresentable,
 
   -- ** Using 8-bit characters
 
@@ -63,20 +63,20 @@ module Foreign.C.String (   -- representation of strings in C
   -- that are ignorant of Unicode.  These functions should be used with
   -- care, as a loss of information can occur.
 
-  castCharToCChar,   -- :: Char -> CChar
-  castCCharToChar,   -- :: CChar -> Char
+  castCharToCChar,
+  castCCharToChar,
 
-  castCharToCUChar,  -- :: Char -> CUChar
-  castCUCharToChar,  -- :: CUChar -> Char
-  castCharToCSChar,  -- :: Char -> CSChar
-  castCSCharToChar,  -- :: CSChar -> Char
+  castCharToCUChar,
+  castCUCharToChar,
+  castCharToCSChar,
+  castCSCharToChar,
 
-  peekCAString,      -- :: CString    -> IO String
-  peekCAStringLen,   -- :: CStringLen -> IO String
-  newCAString,       -- :: String -> IO CString
-  newCAStringLen,    -- :: String -> IO CStringLen
-  withCAString,      -- :: String -> (CString    -> IO a) -> IO a
-  withCAStringLen,   -- :: String -> (CStringLen -> IO a) -> IO a
+  peekCAString,
+  peekCAStringLen,
+  newCAString,
+  newCAStringLen,
+  withCAString,
+  withCAStringLen,
 
   -- * C wide strings
 
@@ -88,15 +88,15 @@ module Foreign.C.String (   -- representation of strings in C
   --
   -- * UTF-16 (as used on Windows systems).
 
-  CWString,          -- = Ptr CWchar
-  CWStringLen,       -- = (Ptr CWchar, Int)
+  CWString,
+  CWStringLen,
 
-  peekCWString,      -- :: CWString    -> IO String
-  peekCWStringLen,   -- :: CWStringLen -> IO String
-  newCWString,       -- :: String -> IO CWString
-  newCWStringLen,    -- :: String -> IO CWStringLen
-  withCWString,      -- :: String -> (CWString    -> IO a) -> IO a
-  withCWStringLen,   -- :: String -> (CWStringLen -> IO a) -> IO a
+  peekCWString,
+  peekCWStringLen,
+  newCWString,
+  newCWStringLen,
+  withCWString,
+  withCWStringLen,
 
   ) where
 
diff --git a/libraries/base/Foreign/Marshal/Alloc.hs b/libraries/base/Foreign/Marshal/Alloc.hs
index 515af4a83b..c38f0cc689 100644
--- a/libraries/base/Foreign/Marshal/Alloc.hs
+++ b/libraries/base/Foreign/Marshal/Alloc.hs
@@ -46,19 +46,19 @@
 module Foreign.Marshal.Alloc (
   -- * Memory allocation
   -- ** Local allocation
-  alloca,       -- :: Storable a =>        (Ptr a -> IO b) -> IO b
-  allocaBytes,  -- ::               Int -> (Ptr a -> IO b) -> IO b
-  allocaBytesAligned,  -- ::        Int -> Int -> (Ptr a -> IO b) -> IO b
+  alloca,
+  allocaBytes,
+  allocaBytesAligned,
 
   -- ** Dynamic allocation
-  malloc,       -- :: Storable a =>        IO (Ptr a)
-  mallocBytes,  -- ::               Int -> IO (Ptr a)
+  malloc,
+  mallocBytes,
 
-  realloc,      -- :: Storable b => Ptr a        -> IO (Ptr b)
-  reallocBytes, -- ::               Ptr a -> Int -> IO (Ptr a)
+  realloc,
+  reallocBytes,
 
-  free,         -- :: Ptr a -> IO ()
-  finalizerFree -- :: FinalizerPtr a
+  free,
+  finalizerFree
 ) where
 
 import Data.Maybe
diff --git a/libraries/base/Foreign/Marshal/Array.hs b/libraries/base/Foreign/Marshal/Array.hs
index 04825aa22d..60121796c3 100644
--- a/libraries/base/Foreign/Marshal/Array.hs
+++ b/libraries/base/Foreign/Marshal/Array.hs
@@ -21,47 +21,47 @@ module Foreign.Marshal.Array (
 
   -- ** Allocation
   --
-  mallocArray,    -- :: Storable a => Int -> IO (Ptr a)
-  mallocArray0,   -- :: Storable a => Int -> IO (Ptr a)
+  mallocArray,
+  mallocArray0,
 
-  allocaArray,    -- :: Storable a => Int -> (Ptr a -> IO b) -> IO b
-  allocaArray0,   -- :: Storable a => Int -> (Ptr a -> IO b) -> IO b
+  allocaArray,
+  allocaArray0,
 
-  reallocArray,   -- :: Storable a => Ptr a -> Int -> IO (Ptr a)
-  reallocArray0,  -- :: Storable a => Ptr a -> Int -> IO (Ptr a)
+  reallocArray,
+  reallocArray0,
 
   -- ** Marshalling
   --
-  peekArray,      -- :: Storable a =>         Int -> Ptr a -> IO [a]
-  peekArray0,     -- :: (Storable a, Eq a) => a   -> Ptr a -> IO [a]
+  peekArray,
+  peekArray0,
 
-  pokeArray,      -- :: Storable a =>      Ptr a -> [a] -> IO ()
-  pokeArray0,     -- :: Storable a => a -> Ptr a -> [a] -> IO ()
+  pokeArray,
+  pokeArray0,
 
   -- ** Combined allocation and marshalling
   --
-  newArray,       -- :: Storable a =>      [a] -> IO (Ptr a)
-  newArray0,      -- :: Storable a => a -> [a] -> IO (Ptr a)
+  newArray,
+  newArray0,
 
-  withArray,      -- :: Storable a =>      [a] -> (Ptr a -> IO b) -> IO b
-  withArray0,     -- :: Storable a => a -> [a] -> (Ptr a -> IO b) -> IO b
+  withArray,
+  withArray0,
 
-  withArrayLen,   -- :: Storable a =>      [a] -> (Int -> Ptr a -> IO b) -> IO b
-  withArrayLen0,  -- :: Storable a => a -> [a] -> (Int -> Ptr a -> IO b) -> IO b
+  withArrayLen,
+  withArrayLen0,
 
   -- ** Copying
 
   -- | (argument order: destination, source)
-  copyArray,      -- :: Storable a => Ptr a -> Ptr a -> Int -> IO ()
-  moveArray,      -- :: Storable a => Ptr a -> Ptr a -> Int -> IO ()
+  copyArray,
+  moveArray,
 
   -- ** Finding the length
   --
-  lengthArray0,   -- :: (Storable a, Eq a) => a -> Ptr a -> IO Int
+  lengthArray0,
 
   -- ** Indexing
   --
-  advancePtr,     -- :: Storable a => Ptr a -> Int -> Ptr a
+  advancePtr,
 ) where
 
 import Foreign.Ptr      (Ptr, plusPtr)
diff --git a/libraries/base/Foreign/Marshal/Error.hs b/libraries/base/Foreign/Marshal/Error.hs
index 4236d44b40..3048ffe063 100644
--- a/libraries/base/Foreign/Marshal/Error.hs
+++ b/libraries/base/Foreign/Marshal/Error.hs
@@ -17,17 +17,15 @@
 -----------------------------------------------------------------------------
 
 module Foreign.Marshal.Error (
-  throwIf,       -- :: (a -> Bool) -> (a -> String) -> IO a       -> IO a
-  throwIf_,      -- :: (a -> Bool) -> (a -> String) -> IO a       -> IO ()
-  throwIfNeg,    -- :: (Ord a, Num a) 
-                 -- =>                (a -> String) -> IO a       -> IO a
-  throwIfNeg_,   -- :: (Ord a, Num a)
-                 -- =>                (a -> String) -> IO a       -> IO ()
-  throwIfNull,   -- ::                String        -> IO (Ptr a) -> IO (Ptr a)
+  throwIf,
+  throwIf_,
+  throwIfNeg,
+  throwIfNeg_,
+  throwIfNull,
 
   -- Discard return value
   --
-  void           -- IO a -> IO ()
+  void
 ) where
 
 import Foreign.Ptr
diff --git a/libraries/base/Foreign/Marshal/Pool.hs b/libraries/base/Foreign/Marshal/Pool.hs
index 6953c0b285..ccb0f415ad 100644
--- a/libraries/base/Foreign/Marshal/Pool.hs
+++ b/libraries/base/Foreign/Marshal/Pool.hs
@@ -23,27 +23,27 @@
 module Foreign.Marshal.Pool (
    -- * Pool management
    Pool,
-   newPool,             -- :: IO Pool
-   freePool,            -- :: Pool -> IO ()
-   withPool,            -- :: (Pool -> IO b) -> IO b
+   newPool,
+   freePool,
+   withPool,
 
    -- * (Re-)Allocation within a pool
-   pooledMalloc,        -- :: Storable a => Pool                 -> IO (Ptr a)
-   pooledMallocBytes,   -- ::               Pool          -> Int -> IO (Ptr a)
+   pooledMalloc,
+   pooledMallocBytes,
 
-   pooledRealloc,       -- :: Storable a => Pool -> Ptr a        -> IO (Ptr a)
-   pooledReallocBytes,  -- ::               Pool -> Ptr a -> Int -> IO (Ptr a)
+   pooledRealloc,
+   pooledReallocBytes,
 
-   pooledMallocArray,   -- :: Storable a => Pool ->          Int -> IO (Ptr a)
-   pooledMallocArray0,  -- :: Storable a => Pool ->          Int -> IO (Ptr a)
+   pooledMallocArray,
+   pooledMallocArray0,
 
-   pooledReallocArray,  -- :: Storable a => Pool -> Ptr a -> Int -> IO (Ptr a)
-   pooledReallocArray0, -- :: Storable a => Pool -> Ptr a -> Int -> IO (Ptr a)
+   pooledReallocArray,
+   pooledReallocArray0,
 
    -- * Combined allocation and marshalling
-   pooledNew,           -- :: Storable a => Pool -> a            -> IO (Ptr a)
-   pooledNewArray,      -- :: Storable a => Pool ->      [a]     -> IO (Ptr a)
-   pooledNewArray0      -- :: Storable a => Pool -> a -> [a]     -> IO (Ptr a)
+   pooledNew,
+   pooledNewArray,
+   pooledNewArray0
 ) where
 
 #ifdef __GLASGOW_HASKELL__
diff --git a/libraries/base/Foreign/Marshal/Utils.hs b/libraries/base/Foreign/Marshal/Utils.hs
index c9e1fd6e4d..d21222d9f9 100644
--- a/libraries/base/Foreign/Marshal/Utils.hs
+++ b/libraries/base/Foreign/Marshal/Utils.hs
@@ -20,32 +20,29 @@ module Foreign.Marshal.Utils (
 
   -- ** Combined allocation and marshalling
   --
-  with,          -- :: Storable a => a -> (Ptr a -> IO b) -> IO b
-  new,           -- :: Storable a => a -> IO (Ptr a)
+  with,
+  new,
 
   -- ** Marshalling of Boolean values (non-zero corresponds to 'True')
   --
-  fromBool,      -- :: Num a => Bool -> a
-  toBool,        -- :: Num a => a -> Bool
+  fromBool,
+  toBool,
 
   -- ** Marshalling of Maybe values
   --
-  maybeNew,      -- :: (      a -> IO (Ptr a))
-                 -- -> (Maybe a -> IO (Ptr a))
-  maybeWith,     -- :: (      a -> (Ptr b -> IO c) -> IO c)
-                 -- -> (Maybe a -> (Ptr b -> IO c) -> IO c)
-  maybePeek,     -- :: (Ptr a -> IO        b )
-                 -- -> (Ptr a -> IO (Maybe b))
+  maybeNew,
+  maybeWith,
+  maybePeek,
 
   -- ** Marshalling lists of storable objects
   --
-  withMany,      -- :: (a -> (b -> res) -> res) -> [a] -> ([b] -> res) -> res
+  withMany,
 
   -- ** Haskellish interface to memcpy and memmove
   -- | (argument order: destination, source)
   --
-  copyBytes,     -- :: Ptr a -> Ptr a -> Int -> IO ()
-  moveBytes,     -- :: Ptr a -> Ptr a -> Int -> IO ()
+  copyBytes,
+  moveBytes,
 ) where
 
 import Data.Maybe
diff --git a/libraries/base/Foreign/Ptr.hs b/libraries/base/Foreign/Ptr.hs
index 3bab833593..b0a1a8ab8e 100644
--- a/libraries/base/Foreign/Ptr.hs
+++ b/libraries/base/Foreign/Ptr.hs
@@ -29,22 +29,22 @@ module Foreign.Ptr (
 
     -- * Data pointers
 
-    Ptr,      -- data Ptr a
-    nullPtr,      -- :: Ptr a
-    castPtr,      -- :: Ptr a -> Ptr b
-    plusPtr,      -- :: Ptr a -> Int -> Ptr b
-    alignPtr,     -- :: Ptr a -> Int -> Ptr a
-    minusPtr,     -- :: Ptr a -> Ptr b -> Int
+    Ptr,
+    nullPtr,
+    castPtr,
+    plusPtr,
+    alignPtr,
+    minusPtr,
 
     -- * Function pointers
 
-    FunPtr,      -- data FunPtr a
-    nullFunPtr,      -- :: FunPtr a
-    castFunPtr,      -- :: FunPtr a -> FunPtr b
-    castFunPtrToPtr, -- :: FunPtr a -> Ptr b
-    castPtrToFunPtr, -- :: Ptr a -> FunPtr b
+    FunPtr,
+    nullFunPtr,
+    castFunPtr,
+    castFunPtrToPtr,
+    castPtrToFunPtr,
 
-    freeHaskellFunPtr, -- :: FunPtr a -> IO ()
+    freeHaskellFunPtr,
     -- Free the function pointer created by foreign export dynamic.
 
 #ifndef __NHC__
diff --git a/libraries/base/Foreign/StablePtr.hs b/libraries/base/Foreign/StablePtr.hs
index d0b6625e50..78bdc9db66 100644
--- a/libraries/base/Foreign/StablePtr.hs
+++ b/libraries/base/Foreign/StablePtr.hs
@@ -20,11 +20,11 @@
 module Foreign.StablePtr
         ( -- * Stable references to Haskell values
           StablePtr          -- abstract
-        , newStablePtr       -- :: a -> IO (StablePtr a)
-        , deRefStablePtr     -- :: StablePtr a -> IO a
-        , freeStablePtr      -- :: StablePtr a -> IO ()
-        , castStablePtrToPtr -- :: StablePtr a -> Ptr ()
-        , castPtrToStablePtr -- :: Ptr () -> StablePtr a
+        , newStablePtr
+        , deRefStablePtr
+        , freeStablePtr
+        , castStablePtrToPtr
+        , castPtrToStablePtr
         , -- ** The C-side interface
 
           -- $cinterface
diff --git a/libraries/base/Foreign/Storable.hs b/libraries/base/Foreign/Storable.hs
index 753dc83f5f..bf3735b9e0 100644
--- a/libraries/base/Foreign/Storable.hs
+++ b/libraries/base/Foreign/Storable.hs
@@ -23,14 +23,14 @@
 
 module Foreign.Storable
         ( Storable(
-             sizeOf,         -- :: a -> Int
-             alignment,      -- :: a -> Int
-             peekElemOff,    -- :: Ptr a -> Int      -> IO a
-             pokeElemOff,    -- :: Ptr a -> Int -> a -> IO ()
-             peekByteOff,    -- :: Ptr b -> Int      -> IO a
-             pokeByteOff,    -- :: Ptr b -> Int -> a -> IO ()
-             peek,           -- :: Ptr a             -> IO a
-             poke)           -- :: Ptr a        -> a -> IO ()
+             sizeOf,
+             alignment,
+             peekElemOff,
+             pokeElemOff,
+             peekByteOff,
+             pokeByteOff,
+             peek,
+             poke)
         ) where
 
 
diff --git a/libraries/base/GHC/Conc.lhs b/libraries/base/GHC/Conc.lhs
index ad8cfc469e..914db3ff27 100644
--- a/libraries/base/GHC/Conc.lhs
+++ b/libraries/base/GHC/Conc.lhs
@@ -30,66 +30,66 @@ module GHC.Conc
         ( ThreadId(..)
 
         -- * Forking and suchlike
-        , forkIO        -- :: IO a -> IO ThreadId
+        , forkIO
         , forkIOUnmasked
         , forkIOWithUnmask
         , forkOn
-        , forkOnIO      -- :: Int -> IO a -> IO ThreadId
+        , forkOnIO
         , forkOnIOUnmasked
         , forkOnWithUnmask
-        , numCapabilities -- :: Int
-        , getNumCapabilities -- :: IO Int
-        , setNumCapabilities -- :: Int -> IO ()
-        , getNumProcessors   -- :: IO Int
-        , numSparks       -- :: IO Int
-        , childHandler  -- :: Exception -> IO ()
-        , myThreadId    -- :: IO ThreadId
-        , killThread    -- :: ThreadId -> IO ()
-        , throwTo       -- :: ThreadId -> Exception -> IO ()
-        , par           -- :: a -> b -> b
-        , pseq          -- :: a -> b -> b
+        , numCapabilities
+        , getNumCapabilities
+        , setNumCapabilities
+        , getNumProcessors
+        , numSparks
+        , childHandler
+        , myThreadId
+        , killThread
+        , throwTo
+        , par
+        , pseq
         , runSparks
-        , yield         -- :: IO ()
-        , labelThread   -- :: ThreadId -> String -> IO ()
-        , mkWeakThreadId -- :: ThreadId -> IO (Weak ThreadId)
+        , yield
+        , labelThread
+        , mkWeakThreadId
 
         , ThreadStatus(..), BlockReason(..)
-        , threadStatus  -- :: ThreadId -> IO ThreadStatus
+        , threadStatus
         , threadCapability
 
         -- * Waiting
-        , threadDelay           -- :: Int -> IO ()
-        , registerDelay         -- :: Int -> IO (TVar Bool)
-        , threadWaitRead        -- :: Int -> IO ()
-        , threadWaitWrite       -- :: Int -> IO ()
-        , closeFdWith           -- :: (Fd -> IO ()) -> Fd -> IO ()
+        , threadDelay
+        , registerDelay
+        , threadWaitRead
+        , threadWaitWrite
+        , closeFdWith
 
         -- * TVars
         , STM(..)
-        , atomically    -- :: STM a -> IO a
-        , retry         -- :: STM a
-        , orElse        -- :: STM a -> STM a -> STM a
-        , throwSTM      -- :: Exception e => e -> STM a
-        , catchSTM      -- :: Exception e => STM a -> (e -> STM a) -> STM a
-        , alwaysSucceeds -- :: STM a -> STM ()
-        , always        -- :: STM Bool -> STM ()
+        , atomically
+        , retry
+        , orElse
+        , throwSTM
+        , catchSTM
+        , alwaysSucceeds
+        , always
         , TVar(..)
-        , newTVar       -- :: a -> STM (TVar a)
-        , newTVarIO     -- :: a -> STM (TVar a)
-        , readTVar      -- :: TVar a -> STM a
-        , readTVarIO    -- :: TVar a -> IO a
-        , writeTVar     -- :: a -> TVar a -> STM ()
-        , unsafeIOToSTM -- :: IO a -> STM a
+        , newTVar
+        , newTVarIO
+        , readTVar
+        , readTVarIO
+        , writeTVar
+        , unsafeIOToSTM
 
         -- * Miscellaneous
         , withMVar
 #ifdef mingw32_HOST_OS
-        , asyncRead     -- :: Int -> Int -> Int -> Ptr a -> IO (Int, Int)
-        , asyncWrite    -- :: Int -> Int -> Int -> Ptr a -> IO (Int, Int)
-        , asyncDoProc   -- :: FunPtr (Ptr a -> IO Int) -> Ptr a -> IO Int
+        , asyncRead
+        , asyncWrite
+        , asyncDoProc
 
-        , asyncReadBA   -- :: Int -> Int -> Int -> Int -> MutableByteArray# RealWorld -> IO (Int, Int)
-        , asyncWriteBA  -- :: Int -> Int -> Int -> Int -> MutableByteArray# RealWorld -> IO (Int, Int)
+        , asyncReadBA
+        , asyncWriteBA
 #endif
 
 #ifndef mingw32_HOST_OS
@@ -103,8 +103,8 @@ module GHC.Conc
         , win32ConsoleHandler
         , toWin32ConsoleEvent
 #endif
-        , setUncaughtExceptionHandler      -- :: (Exception -> IO ()) -> IO ()
-        , getUncaughtExceptionHandler      -- :: IO (Exception -> IO ())
+        , setUncaughtExceptionHandler
+        , getUncaughtExceptionHandler
 
         , reportError, reportStackOverflow
         ) where
diff --git a/libraries/base/GHC/Conc/IO.hs b/libraries/base/GHC/Conc/IO.hs
index 64a479e7c1..94a63a9878 100644
--- a/libraries/base/GHC/Conc/IO.hs
+++ b/libraries/base/GHC/Conc/IO.hs
@@ -34,19 +34,19 @@ module GHC.Conc.IO
         ( ensureIOManagerIsRunning
 
         -- * Waiting
-        , threadDelay           -- :: Int -> IO ()
-        , registerDelay         -- :: Int -> IO (TVar Bool)
-        , threadWaitRead        -- :: Int -> IO ()
-        , threadWaitWrite       -- :: Int -> IO ()
-        , closeFdWith           -- :: (Fd -> IO ()) -> Fd -> IO ()
+        , threadDelay
+        , registerDelay
+        , threadWaitRead
+        , threadWaitWrite
+        , closeFdWith
 
 #ifdef mingw32_HOST_OS
-        , asyncRead     -- :: Int -> Int -> Int -> Ptr a -> IO (Int, Int)
-        , asyncWrite    -- :: Int -> Int -> Int -> Ptr a -> IO (Int, Int)
-        , asyncDoProc   -- :: FunPtr (Ptr a -> IO Int) -> Ptr a -> IO Int
+        , asyncRead
+        , asyncWrite
+        , asyncDoProc
 
-        , asyncReadBA   -- :: Int -> Int -> Int -> Int -> MutableByteArray# RealWorld -> IO (Int, Int)
-        , asyncWriteBA  -- :: Int -> Int -> Int -> Int -> MutableByteArray# RealWorld -> IO (Int, Int)
+        , asyncReadBA
+        , asyncWriteBA
 
         , ConsoleEvent(..)
         , win32ConsoleHandler
diff --git a/libraries/base/GHC/Conc/Sync.lhs b/libraries/base/GHC/Conc/Sync.lhs
index 4d289c63b5..ec266e9017 100644
--- a/libraries/base/GHC/Conc/Sync.lhs
+++ b/libraries/base/GHC/Conc/Sync.lhs
@@ -40,56 +40,56 @@ module GHC.Conc.Sync
         ( ThreadId(..)
 
         -- * Forking and suchlike
-        , forkIO        -- :: IO a -> IO ThreadId
+        , forkIO
         , forkIOUnmasked
         , forkIOWithUnmask
-        , forkOn      -- :: Int -> IO a -> IO ThreadId
+        , forkOn
         , forkOnIO    -- DEPRECATED
         , forkOnIOUnmasked
         , forkOnWithUnmask
-        , numCapabilities -- :: Int
-        , getNumCapabilities -- :: IO Int
-        , setNumCapabilities -- :: Int -> IO ()
-        , getNumProcessors   -- :: IO Int
-        , numSparks      -- :: IO Int
-        , childHandler  -- :: Exception -> IO ()
-        , myThreadId    -- :: IO ThreadId
-        , killThread    -- :: ThreadId -> IO ()
-        , throwTo       -- :: ThreadId -> Exception -> IO ()
-        , par           -- :: a -> b -> b
-        , pseq          -- :: a -> b -> b
+        , numCapabilities
+        , getNumCapabilities
+        , setNumCapabilities
+        , getNumProcessors
+        , numSparks
+        , childHandler
+        , myThreadId
+        , killThread
+        , throwTo
+        , par
+        , pseq
         , runSparks
-        , yield         -- :: IO ()
-        , labelThread   -- :: ThreadId -> String -> IO ()
-        , mkWeakThreadId -- :: ThreadId -> IO (Weak ThreadId)
+        , yield
+        , labelThread
+        , mkWeakThreadId
 
         , ThreadStatus(..), BlockReason(..)
-        , threadStatus  -- :: ThreadId -> IO ThreadStatus
+        , threadStatus
         , threadCapability
 
         -- * TVars
         , STM(..)
-        , atomically    -- :: STM a -> IO a
-        , retry         -- :: STM a
-        , orElse        -- :: STM a -> STM a -> STM a
-        , throwSTM      -- :: Exception e => e -> STM a
-        , catchSTM      -- :: Exception e => STM a -> (e -> STM a) -> STM a
-        , alwaysSucceeds -- :: STM a -> STM ()
-        , always        -- :: STM Bool -> STM ()
+        , atomically
+        , retry
+        , orElse
+        , throwSTM
+        , catchSTM
+        , alwaysSucceeds
+        , always
         , TVar(..)
-        , newTVar       -- :: a -> STM (TVar a)
-        , newTVarIO     -- :: a -> STM (TVar a)
-        , readTVar      -- :: TVar a -> STM a
-        , readTVarIO    -- :: TVar a -> IO a
-        , writeTVar     -- :: a -> TVar a -> STM ()
-        , unsafeIOToSTM -- :: IO a -> STM a
+        , newTVar
+        , newTVarIO
+        , readTVar
+        , readTVarIO
+        , writeTVar
+        , unsafeIOToSTM
 
         -- * Miscellaneous
         , withMVar
         , modifyMVar_
 
-        , setUncaughtExceptionHandler      -- :: (Exception -> IO ()) -> IO ()
-        , getUncaughtExceptionHandler      -- :: IO (Exception -> IO ())
+        , setUncaughtExceptionHandler
+        , getUncaughtExceptionHandler
 
         , reportError, reportStackOverflow
 
diff --git a/libraries/base/GHC/Conc/Windows.hs b/libraries/base/GHC/Conc/Windows.hs
index 0170b06412..ceb6b40e35 100644
--- a/libraries/base/GHC/Conc/Windows.hs
+++ b/libraries/base/GHC/Conc/Windows.hs
@@ -27,12 +27,12 @@ module GHC.Conc.Windows
        , registerDelay
 
        -- * Miscellaneous
-       , asyncRead     -- :: Int -> Int -> Int -> Ptr a -> IO (Int, Int)
-       , asyncWrite    -- :: Int -> Int -> Int -> Ptr a -> IO (Int, Int)
-       , asyncDoProc   -- :: FunPtr (Ptr a -> IO Int) -> Ptr a -> IO Int
+       , asyncRead
+       , asyncWrite
+       , asyncDoProc
 
-       , asyncReadBA   -- :: Int -> Int -> Int -> Int -> MutableByteArray# RealWorld -> IO (Int, Int)
-       , asyncWriteBA  -- :: Int -> Int -> Int -> Int -> MutableByteArray# RealWorld -> IO (Int, Int)
+       , asyncReadBA
+       , asyncWriteBA
 
        , ConsoleEvent(..)
        , win32ConsoleHandler
diff --git a/libraries/base/GHC/Err.lhs b/libraries/base/GHC/Err.lhs
index ed1dcb9766..964bc0cda9 100644
--- a/libraries/base/GHC/Err.lhs
+++ b/libraries/base/GHC/Err.lhs
@@ -25,14 +25,14 @@
 -- #hide
 module GHC.Err
        (
-         absentErr                 -- :: a
-       , divZeroError              -- :: a
-       , ratioZeroDenominatorError -- :: a
-       , overflowError             -- :: a
+         absentErr
+       , divZeroError
+       , ratioZeroDenominatorError
+       , overflowError
 
-       , error                     -- :: String -> a
+       , error
 
-       , undefined                 -- :: a
+       , undefined
        ) where
 
 import GHC.Types
diff --git a/libraries/base/GHC/Foreign.hs b/libraries/base/GHC/Foreign.hs
index 4eef2ebc2f..3924d404a5 100644
--- a/libraries/base/GHC/Foreign.hs
+++ b/libraries/base/GHC/Foreign.hs
@@ -20,20 +20,20 @@ module GHC.Foreign (
     
     -- conversion of C strings into Haskell strings
     --
-    peekCString,       -- :: TextEncoding -> CString    -> IO String
-    peekCStringLen,    -- :: TextEncoding -> CStringLen -> IO String
+    peekCString,
+    peekCStringLen,
     
     -- conversion of Haskell strings into C strings
     --
-    newCString,        -- :: TextEncoding -> String -> IO CString
-    newCStringLen,     -- :: TextEncoding -> String -> IO CStringLen
+    newCString,
+    newCStringLen,
     
     -- conversion of Haskell strings into C strings using temporary storage
     --
-    withCString,       -- :: TextEncoding -> String -> (CString    -> IO a) -> IO a
-    withCStringLen,    -- :: TextEncoding -> String -> (CStringLen -> IO a) -> IO a
+    withCString,
+    withCStringLen,
     
-    charIsRepresentable, -- :: TextEncoding -> Char -> IO Bool
+    charIsRepresentable,
   ) where
 
 import Foreign.Marshal.Array
diff --git a/libraries/base/GHC/MVar.hs b/libraries/base/GHC/MVar.hs
index 6a10748e2d..cd2ca33dd8 100644
--- a/libraries/base/GHC/MVar.hs
+++ b/libraries/base/GHC/MVar.hs
@@ -20,14 +20,14 @@
 module GHC.MVar (
         -- * MVars
           MVar(..)
-        , newMVar       -- :: a -> IO (MVar a)
-        , newEmptyMVar  -- :: IO (MVar a)
-        , takeMVar      -- :: MVar a -> IO a
-        , putMVar       -- :: MVar a -> a -> IO ()
-        , tryTakeMVar   -- :: MVar a -> IO (Maybe a)
-        , tryPutMVar    -- :: MVar a -> a -> IO Bool
-        , isEmptyMVar   -- :: MVar a -> IO Bool
-        , addMVarFinalizer -- :: MVar a -> IO () -> IO ()
+        , newMVar
+        , newEmptyMVar
+        , takeMVar
+        , putMVar
+        , tryTakeMVar
+        , tryPutMVar
+        , isEmptyMVar
+        , addMVarFinalizer
     ) where
 
 import GHC.Base
diff --git a/libraries/base/GHC/Pack.lhs b/libraries/base/GHC/Pack.lhs
index 79708cb950..91fa6ddffc 100644
--- a/libraries/base/GHC/Pack.lhs
+++ b/libraries/base/GHC/Pack.lhs
@@ -27,10 +27,10 @@ module GHC.Pack
        (
         -- (**) - emitted by compiler.
 
-        packCString#,      -- :: [Char] -> ByteArray#    (**)
+        packCString#,
         unpackCString,
-        unpackCString#,    -- :: Addr# -> [Char]         (**)
-        unpackNBytes#,     -- :: Addr# -> Int# -> [Char] (**)
+        unpackCString#,
+        unpackNBytes#,
         unpackFoldrCString#,  -- (**)
         unpackAppendCString#,  -- (**)
        ) 
diff --git a/libraries/base/GHC/Read.lhs b/libraries/base/GHC/Read.lhs
index 96b5b2d4c1..b0869aa133 100644
--- a/libraries/base/GHC/Read.lhs
+++ b/libraries/base/GHC/Read.lhs
@@ -23,20 +23,20 @@ module GHC.Read
   ( Read(..)   -- class
 
   -- ReadS type
-  , ReadS      -- :: *; = String -> [(a,String)]
+  , ReadS
 
   -- H98 compatibility
-  , lex         -- :: ReadS String
-  , lexLitChar  -- :: ReadS String
-  , readLitChar -- :: ReadS Char
-  , lexDigits   -- :: ReadS String
+  , lex
+  , lexLitChar
+  , readLitChar
+  , lexDigits
 
   -- defining readers
-  , lexP       -- :: ReadPrec Lexeme
-  , paren      -- :: ReadPrec a -> ReadPrec a
-  , parens     -- :: ReadPrec a -> ReadPrec a
-  , list       -- :: ReadPrec a -> ReadPrec [a]
-  , choose     -- :: [(String, ReadPrec a)] -> ReadPrec a
+  , lexP
+  , paren
+  , parens
+  , list
+  , choose
   , readListDefault, readListPrecDefault
 
   -- Temporary
diff --git a/libraries/base/GHC/Stable.lhs b/libraries/base/GHC/Stable.lhs
index e660917be4..439689583b 100644
--- a/libraries/base/GHC/Stable.lhs
+++ b/libraries/base/GHC/Stable.lhs
@@ -24,11 +24,11 @@
 -- #hide
 module GHC.Stable (
         StablePtr(..),
-        newStablePtr,         -- :: a -> IO (StablePtr a)    
-        deRefStablePtr,       -- :: StablePtr a -> a
-        freeStablePtr,        -- :: StablePtr a -> IO ()
-        castStablePtrToPtr,   -- :: StablePtr a -> Ptr ()
-        castPtrToStablePtr    -- :: Ptr () -> StablePtr a
+        newStablePtr,
+        deRefStablePtr,
+        freeStablePtr,
+        castStablePtrToPtr,
+        castPtrToStablePtr
     ) where
 
 import GHC.Ptr
diff --git a/libraries/base/Numeric.hs b/libraries/base/Numeric.hs
index c29d7b9ccd..a990cfb000 100644
--- a/libraries/base/Numeric.hs
+++ b/libraries/base/Numeric.hs
@@ -20,19 +20,19 @@ module Numeric (
 
         -- * Showing
 
-        showSigned,       -- :: (Real a) => (a -> ShowS) -> Int -> a -> ShowS
+        showSigned,
 
-        showIntAtBase,    -- :: Integral a => a -> (a -> Char) -> a -> ShowS
-        showInt,          -- :: Integral a => a -> ShowS
-        showHex,          -- :: Integral a => a -> ShowS
-        showOct,          -- :: Integral a => a -> ShowS
+        showIntAtBase,
+        showInt,
+        showHex,
+        showOct,
 
-        showEFloat,       -- :: (RealFloat a) => Maybe Int -> a -> ShowS
-        showFFloat,       -- :: (RealFloat a) => Maybe Int -> a -> ShowS
-        showGFloat,       -- :: (RealFloat a) => Maybe Int -> a -> ShowS
-        showFloat,        -- :: (RealFloat a) => a -> ShowS
+        showEFloat,
+        showFFloat,
+        showGFloat,
+        showFloat,
 
-        floatToDigits,    -- :: (RealFloat a) => Integer -> a -> ([Int], Int)
+        floatToDigits,
 
         -- * Reading
 
@@ -40,21 +40,20 @@ module Numeric (
         -- and 'readDec' is the \`dual\' of 'showInt'.
         -- The inconsistent naming is a historical accident.
 
-        readSigned,       -- :: (Real a) => ReadS a -> ReadS a
+        readSigned,
 
-        readInt,          -- :: (Integral a) => a -> (Char -> Bool)
-                          --         -> (Char -> Int) -> ReadS a
-        readDec,          -- :: (Integral a) => ReadS a
-        readOct,          -- :: (Integral a) => ReadS a
-        readHex,          -- :: (Integral a) => ReadS a
+        readInt,
+        readDec,
+        readOct,
+        readHex,
 
-        readFloat,        -- :: (RealFloat a) => ReadS a
+        readFloat,
 
-        lexDigits,        -- :: ReadS String
+        lexDigits,
 
         -- * Miscellaneous
 
-        fromRat,          -- :: (RealFloat a) => Rational -> a
+        fromRat,
 
         ) where
 
diff --git a/libraries/base/System/Environment.hs b/libraries/base/System/Environment.hs
index 1f3321327e..c74286f29d 100644
--- a/libraries/base/System/Environment.hs
+++ b/libraries/base/System/Environment.hs
@@ -17,11 +17,11 @@
 
 module System.Environment
     (
-      getArgs,            -- :: IO [String]
-      getProgName,        -- :: IO String
-      getExecutablePath,  -- :: IO FilePath
-      getEnv,             -- :: String -> IO String
-      lookupEnv,          -- :: String -> IO (Maybe String)
+      getArgs,
+      getProgName,
+      getExecutablePath,
+      getEnv,
+      lookupEnv,
 #ifndef __NHC__
       withArgs,
       withProgName,
diff --git a/libraries/base/System/Exit.hs b/libraries/base/System/Exit.hs
index 2f63024b18..441b8c5cf5 100644
--- a/libraries/base/System/Exit.hs
+++ b/libraries/base/System/Exit.hs
@@ -18,9 +18,9 @@
 module System.Exit
     (
       ExitCode(ExitSuccess,ExitFailure)
-    , exitWith      -- :: ExitCode -> IO a
-    , exitFailure   -- :: IO a
-    , exitSuccess   -- :: IO a
+    , exitWith
+    , exitFailure
+    , exitSuccess
   ) where
 
 import Prelude
diff --git a/libraries/base/System/IO.hs b/libraries/base/System/IO.hs
index 31aa0e88c6..3ff8396bb2 100644
--- a/libraries/base/System/IO.hs
+++ b/libraries/base/System/IO.hs
@@ -19,12 +19,12 @@
 module System.IO (
     -- * The IO monad
 
-    IO,                        -- instance MonadFix
-    fixIO,                     -- :: (a -> IO a) -> IO a
+    IO,
+    fixIO,
 
     -- * Files and handles
 
-    FilePath,                  -- :: String
+    FilePath,
 
     Handle,             -- abstract, instance of: Eq, Show.
 
@@ -42,27 +42,27 @@ module System.IO (
     -- | Three handles are allocated during program initialisation,
     -- and are initially open.
 
-    stdin, stdout, stderr,   -- :: Handle
+    stdin, stdout, stderr,
 
     -- * Opening and closing files
 
     -- ** Opening files
 
     withFile,
-    openFile,                  -- :: FilePath -> IOMode -> IO Handle
+    openFile,
     IOMode(ReadMode,WriteMode,AppendMode,ReadWriteMode),
 
     -- ** Closing files
 
-    hClose,                    -- :: Handle -> IO ()
+    hClose,
 
     -- ** Special cases
 
     -- | These functions are also exported by the "Prelude".
 
-    readFile,                  -- :: FilePath -> IO String
-    writeFile,                 -- :: FilePath -> String -> IO ()
-    appendFile,                -- :: FilePath -> String -> IO ()
+    readFile,
+    writeFile,
+    appendFile,
 
     -- ** File locking
 
@@ -72,100 +72,100 @@ module System.IO (
 
     -- ** Determining and changing the size of a file
 
-    hFileSize,                 -- :: Handle -> IO Integer
+    hFileSize,
 #ifdef __GLASGOW_HASKELL__
-    hSetFileSize,              -- :: Handle -> Integer -> IO ()
+    hSetFileSize,
 #endif
 
     -- ** Detecting the end of input
 
-    hIsEOF,                    -- :: Handle -> IO Bool
-    isEOF,                     -- :: IO Bool
+    hIsEOF,
+    isEOF,
 
     -- ** Buffering operations
 
     BufferMode(NoBuffering,LineBuffering,BlockBuffering),
-    hSetBuffering,             -- :: Handle -> BufferMode -> IO ()
-    hGetBuffering,             -- :: Handle -> IO BufferMode
-    hFlush,                    -- :: Handle -> IO ()
+    hSetBuffering,
+    hGetBuffering,
+    hFlush,
 
     -- ** Repositioning handles
 
-    hGetPosn,                  -- :: Handle -> IO HandlePosn
-    hSetPosn,                  -- :: HandlePosn -> IO ()
+    hGetPosn,
+    hSetPosn,
     HandlePosn,                -- abstract, instance of: Eq, Show.
 
-    hSeek,                     -- :: Handle -> SeekMode -> Integer -> IO ()
+    hSeek,
     SeekMode(AbsoluteSeek,RelativeSeek,SeekFromEnd),
 #if !defined(__NHC__)
-    hTell,                     -- :: Handle -> IO Integer
+    hTell,
 #endif
 
     -- ** Handle properties
 
-    hIsOpen, hIsClosed,        -- :: Handle -> IO Bool
-    hIsReadable, hIsWritable,  -- :: Handle -> IO Bool
-    hIsSeekable,               -- :: Handle -> IO Bool
+    hIsOpen, hIsClosed,
+    hIsReadable, hIsWritable,
+    hIsSeekable,
 
     -- ** Terminal operations (not portable: GHC\/Hugs only)
 
 #if !defined(__NHC__)
-    hIsTerminalDevice,          -- :: Handle -> IO Bool
+    hIsTerminalDevice,
 
-    hSetEcho,                   -- :: Handle -> Bool -> IO ()
-    hGetEcho,                   -- :: Handle -> IO Bool
+    hSetEcho,
+    hGetEcho,
 #endif
 
     -- ** Showing handle state (not portable: GHC only)
 
 #ifdef __GLASGOW_HASKELL__
-    hShow,                      -- :: Handle -> IO String
+    hShow,
 #endif
 
     -- * Text input and output
 
     -- ** Text input
 
-    hWaitForInput,             -- :: Handle -> Int -> IO Bool
-    hReady,                    -- :: Handle -> IO Bool
-    hGetChar,                  -- :: Handle -> IO Char
-    hGetLine,                  -- :: Handle -> IO [Char]
-    hLookAhead,                -- :: Handle -> IO Char
-    hGetContents,              -- :: Handle -> IO [Char]
+    hWaitForInput,
+    hReady,
+    hGetChar,
+    hGetLine,
+    hLookAhead,
+    hGetContents,
 
     -- ** Text output
 
-    hPutChar,                  -- :: Handle -> Char -> IO ()
-    hPutStr,                   -- :: Handle -> [Char] -> IO ()
-    hPutStrLn,                 -- :: Handle -> [Char] -> IO ()
-    hPrint,                    -- :: Show a => Handle -> a -> IO ()
+    hPutChar,
+    hPutStr,
+    hPutStrLn,
+    hPrint,
 
     -- ** Special cases for standard input and output
 
     -- | These functions are also exported by the "Prelude".
 
-    interact,                  -- :: (String -> String) -> IO ()
-    putChar,                   -- :: Char   -> IO ()
-    putStr,                    -- :: String -> IO () 
-    putStrLn,                  -- :: String -> IO ()
-    print,                     -- :: Show a => a -> IO ()
-    getChar,                   -- :: IO Char
-    getLine,                   -- :: IO String
-    getContents,               -- :: IO String
-    readIO,                    -- :: Read a => String -> IO a
-    readLn,                    -- :: Read a => IO a
+    interact,
+    putChar,
+    putStr,
+    putStrLn,
+    print,
+    getChar,
+    getLine,
+    getContents,
+    readIO,
+    readLn,
 
     -- * Binary input and output
 
     withBinaryFile,
-    openBinaryFile,            -- :: FilePath -> IOMode -> IO Handle
-    hSetBinaryMode,            -- :: Handle -> Bool -> IO ()
-    hPutBuf,                   -- :: Handle -> Ptr a -> Int -> IO ()
-    hGetBuf,                   -- :: Handle -> Ptr a -> Int -> IO Int
+    openBinaryFile,
+    hSetBinaryMode,
+    hPutBuf,
+    hGetBuf,
 #if !defined(__NHC__) && !defined(__HUGS__)
-    hGetBufSome,               -- :: Handle -> Ptr a -> Int -> IO Int
-    hPutBufNonBlocking,        -- :: Handle -> Ptr a -> Int -> IO Int
-    hGetBufNonBlocking,        -- :: Handle -> Ptr a -> Int -> IO Int
+    hGetBufSome,
+    hPutBufNonBlocking,
+    hGetBufNonBlocking,
 #endif
 
     -- * Temporary files
diff --git a/libraries/base/System/IO/Error.hs b/libraries/base/System/IO/Error.hs
index 4259676839..8d939c08b3 100644
--- a/libraries/base/System/IO/Error.hs
+++ b/libraries/base/System/IO/Error.hs
@@ -18,18 +18,16 @@
 module System.IO.Error (
 
     -- * I\/O errors
-    IOError,                    -- = IOException
+    IOError,
 
-    userError,                  -- :: String  -> IOError
+    userError,
 
-    mkIOError,                  -- :: IOErrorType -> String -> Maybe Handle
-                                --    -> Maybe FilePath -> IOError
+    mkIOError,
 
-    annotateIOError,            -- :: IOError -> String -> Maybe Handle
-                                --    -> Maybe FilePath -> IOError
+    annotateIOError,
 
     -- ** Classifying I\/O errors
-    isAlreadyExistsError,       -- :: IOError -> Bool
+    isAlreadyExistsError,
     isDoesNotExistError,
     isAlreadyInUseError,
     isFullError, 
@@ -39,22 +37,22 @@ module System.IO.Error (
     isUserError,
 
     -- ** Attributes of I\/O errors
-    ioeGetErrorType,            -- :: IOError -> IOErrorType
-    ioeGetLocation,             -- :: IOError -> String
-    ioeGetErrorString,          -- :: IOError -> String
-    ioeGetHandle,               -- :: IOError -> Maybe Handle
-    ioeGetFileName,             -- :: IOError -> Maybe FilePath
-
-    ioeSetErrorType,            -- :: IOError -> IOErrorType -> IOError
-    ioeSetErrorString,          -- :: IOError -> String -> IOError
-    ioeSetLocation,             -- :: IOError -> String -> IOError
-    ioeSetHandle,               -- :: IOError -> Handle -> IOError
-    ioeSetFileName,             -- :: IOError -> FilePath -> IOError
+    ioeGetErrorType,
+    ioeGetLocation,
+    ioeGetErrorString,
+    ioeGetHandle,
+    ioeGetFileName,
+
+    ioeSetErrorType,
+    ioeSetErrorString,
+    ioeSetLocation,
+    ioeSetHandle,
+    ioeSetFileName,
 
     -- * Types of I\/O error
     IOErrorType,                -- abstract
 
-    alreadyExistsErrorType,     -- :: IOErrorType
+    alreadyExistsErrorType,
     doesNotExistErrorType,
     alreadyInUseErrorType,
     fullErrorType,
@@ -64,7 +62,7 @@ module System.IO.Error (
     userErrorType,
 
     -- ** 'IOErrorType' predicates
-    isAlreadyExistsErrorType,   -- :: IOErrorType -> Bool
+    isAlreadyExistsErrorType,
     isDoesNotExistErrorType,
     isAlreadyInUseErrorType,
     isFullErrorType, 
@@ -75,12 +73,12 @@ module System.IO.Error (
 
     -- * Throwing and catching I\/O errors
 
-    ioError,                    -- :: IOError -> IO a
+    ioError,
 
-    catchIOError,               -- :: IO a -> (IOError -> IO a) -> IO a
-    tryIOError,                 -- :: IO a -> IO (Either IOError a)
+    catchIOError,
+    tryIOError,
 
-    modifyIOError,              -- :: (IOError -> IOError) -> IO a -> IO a
+    modifyIOError,
   ) where
 
 #ifndef __HUGS__
diff --git a/libraries/base/System/IO/Unsafe.hs b/libraries/base/System/IO/Unsafe.hs
index 33620a3f77..6ac4af61de 100644
--- a/libraries/base/System/IO/Unsafe.hs
+++ b/libraries/base/System/IO/Unsafe.hs
@@ -17,9 +17,9 @@
 
 module System.IO.Unsafe (
    -- * Unsafe 'System.IO.IO' operations
-   unsafePerformIO,     -- :: IO a -> a
-   unsafeDupablePerformIO, -- :: IO a -> a
-   unsafeInterleaveIO,  -- :: IO a -> IO a
+   unsafePerformIO,
+   unsafeDupablePerformIO,
+   unsafeInterleaveIO,
    unsafeFixIO,
   ) where
 
diff --git a/libraries/base/System/Info.hs b/libraries/base/System/Info.hs
index c9f623d1ff..c475be3eb7 100644
--- a/libraries/base/System/Info.hs
+++ b/libraries/base/System/Info.hs
@@ -18,10 +18,10 @@
 
 module System.Info
    (
-       os,		    -- :: String
-       arch,		    -- :: String
-       compilerName,	    -- :: String
-       compilerVersion	    -- :: Version
+       os,
+       arch,
+       compilerName,
+       compilerVersion
    ) where
 
 import Prelude
diff --git a/libraries/base/System/Mem.hs b/libraries/base/System/Mem.hs
index 8e8a1bc2e0..665f69e0dc 100644
--- a/libraries/base/System/Mem.hs
+++ b/libraries/base/System/Mem.hs
@@ -19,7 +19,7 @@
 -----------------------------------------------------------------------------
 
 module System.Mem (
- 	performGC	-- :: IO ()
+        performGC
   ) where
  
 import Prelude
diff --git a/libraries/base/System/Mem/Weak.hs b/libraries/base/System/Mem/Weak.hs
index 71b8446c15..9691649668 100644
--- a/libraries/base/System/Mem/Weak.hs
+++ b/libraries/base/System/Mem/Weak.hs
@@ -55,15 +55,15 @@ module System.Mem.Weak (
 	Weak,	    		-- abstract
 
 	-- * The general interface
-	mkWeak,      		-- :: k -> v -> Maybe (IO ()) -> IO (Weak v)
-	deRefWeak, 		-- :: Weak v -> IO (Maybe v)
-	finalize,		-- :: Weak v -> IO ()
+	mkWeak,
+	deRefWeak,
+	finalize,
 
 	-- * Specialised versions
-	mkWeakPtr, 		-- :: k -> Maybe (IO ()) -> IO (Weak k)
-	addFinalizer, 		-- :: key -> IO () -> IO ()
-	mkWeakPair, 		-- :: k -> v -> Maybe (IO ()) -> IO (Weak (k,v))
-	-- replaceFinaliser	-- :: Weak v -> IO () -> IO ()
+	mkWeakPtr,
+	addFinalizer,
+	mkWeakPair,
+	-- replaceFinaliser
 
 	-- * A precise semantics
 	
diff --git a/libraries/base/Text/ParserCombinators/ReadP.hs b/libraries/base/Text/ParserCombinators/ReadP.hs
index cfcb3bda07..ce7c26af43 100644
--- a/libraries/base/Text/ParserCombinators/ReadP.hs
+++ b/libraries/base/Text/ParserCombinators/ReadP.hs
@@ -29,50 +29,50 @@ module Text.ParserCombinators.ReadP
   ( 
   -- * The 'ReadP' type
 #ifndef __NHC__
-  ReadP,      -- :: * -> *; instance Functor, Monad, MonadPlus
+  ReadP,
 #else
-  ReadPN,     -- :: * -> * -> *; instance Functor, Monad, MonadPlus
+  ReadPN,
 #endif
   
   -- * Primitive operations
-  get,        -- :: ReadP Char
-  look,       -- :: ReadP String
-  (+++),      -- :: ReadP a -> ReadP a -> ReadP a
-  (<++),      -- :: ReadP a -> ReadP a -> ReadP a
-  gather,     -- :: ReadP a -> ReadP (String, a)
+  get,
+  look,
+  (+++),
+  (<++),
+  gather,
   
   -- * Other operations
-  pfail,      -- :: ReadP a
-  eof,        -- :: ReadP ()
-  satisfy,    -- :: (Char -> Bool) -> ReadP Char
-  char,       -- :: Char -> ReadP Char
-  string,     -- :: String -> ReadP String
-  munch,      -- :: (Char -> Bool) -> ReadP String
-  munch1,     -- :: (Char -> Bool) -> ReadP String
-  skipSpaces, -- :: ReadP ()
-  choice,     -- :: [ReadP a] -> ReadP a
-  count,      -- :: Int -> ReadP a -> ReadP [a]
-  between,    -- :: ReadP open -> ReadP close -> ReadP a -> ReadP a
-  option,     -- :: a -> ReadP a -> ReadP a
-  optional,   -- :: ReadP a -> ReadP ()
-  many,       -- :: ReadP a -> ReadP [a]
-  many1,      -- :: ReadP a -> ReadP [a]
-  skipMany,   -- :: ReadP a -> ReadP ()
-  skipMany1,  -- :: ReadP a -> ReadP ()
-  sepBy,      -- :: ReadP a -> ReadP sep -> ReadP [a]
-  sepBy1,     -- :: ReadP a -> ReadP sep -> ReadP [a]
-  endBy,      -- :: ReadP a -> ReadP sep -> ReadP [a]
-  endBy1,     -- :: ReadP a -> ReadP sep -> ReadP [a]
-  chainr,     -- :: ReadP a -> ReadP (a -> a -> a) -> a -> ReadP a
-  chainl,     -- :: ReadP a -> ReadP (a -> a -> a) -> a -> ReadP a
-  chainl1,    -- :: ReadP a -> ReadP (a -> a -> a) -> ReadP a
-  chainr1,    -- :: ReadP a -> ReadP (a -> a -> a) -> ReadP a
-  manyTill,   -- :: ReadP a -> ReadP end -> ReadP [a]
+  pfail,
+  eof,
+  satisfy,
+  char,
+  string,
+  munch,
+  munch1,
+  skipSpaces,
+  choice,
+  count,
+  between,
+  option,
+  optional,
+  many,
+  many1,
+  skipMany,
+  skipMany1,
+  sepBy,
+  sepBy1,
+  endBy,
+  endBy1,
+  chainr,
+  chainl,
+  chainl1,
+  chainr1,
+  manyTill,
   
   -- * Running a parser
-  ReadS,      -- :: *; = String -> [(a,String)]
-  readP_to_S, -- :: ReadP a -> ReadS a
-  readS_to_P, -- :: ReadS a -> ReadP a
+  ReadS,
+  readP_to_S,
+  readS_to_P,
   
   -- * Properties
   -- $properties
diff --git a/libraries/base/Text/ParserCombinators/ReadPrec.hs b/libraries/base/Text/ParserCombinators/ReadPrec.hs
index faf53a9a4b..ba59facb8b 100644
--- a/libraries/base/Text/ParserCombinators/ReadPrec.hs
+++ b/libraries/base/Text/ParserCombinators/ReadPrec.hs
@@ -17,32 +17,32 @@
 
 module Text.ParserCombinators.ReadPrec
   ( 
-  ReadPrec,      -- :: * -> *; instance Functor, Monad, MonadPlus
+  ReadPrec,
   
   -- * Precedences
-  Prec,          -- :: *; = Int
-  minPrec,       -- :: Prec; = 0
+  Prec,
+  minPrec,
 
   -- * Precedence operations
-  lift,          -- :: ReadP a -> ReadPrec a
-  prec,          -- :: Prec -> ReadPrec a -> ReadPrec a
-  step,          -- :: ReadPrec a -> ReadPrec a
-  reset,         -- :: ReadPrec a -> ReadPrec a
+  lift,
+  prec,
+  step,
+  reset,
 
   -- * Other operations
   -- | All are based directly on their similarly-named 'ReadP' counterparts.
-  get,           -- :: ReadPrec Char
-  look,          -- :: ReadPrec String
-  (+++),         -- :: ReadPrec a -> ReadPrec a -> ReadPrec a
-  (<++),         -- :: ReadPrec a -> ReadPrec a -> ReadPrec a
-  pfail,         -- :: ReadPrec a
-  choice,        -- :: [ReadPrec a] -> ReadPrec a
+  get,
+  look,
+  (+++),
+  (<++),
+  pfail,
+  choice,
 
   -- * Converters
-  readPrec_to_P, -- :: ReadPrec a       -> (Int -> ReadP a)
-  readP_to_Prec, -- :: (Int -> ReadP a) -> ReadPrec a
-  readPrec_to_S, -- :: ReadPrec a       -> (Int -> ReadS a)
-  readS_to_Prec, -- :: (Int -> ReadS a) -> ReadPrec a
+  readPrec_to_P,
+  readP_to_Prec,
+  readPrec_to_S,
+  readS_to_Prec,
   )
  where
 
diff --git a/libraries/base/Text/Read.hs b/libraries/base/Text/Read.hs
index 88784ac90d..0216df9d3b 100644
--- a/libraries/base/Text/Read.hs
+++ b/libraries/base/Text/Read.hs
@@ -23,27 +23,27 @@
 
 module Text.Read (
    -- * The 'Read' class
-   Read(..),            -- The Read class
-   ReadS,               -- String -> Maybe (a,String)
+   Read(..),
+   ReadS,
 
    -- * Haskell 98 functions
-   reads,               -- :: (Read a) => ReadS a
-   read,                -- :: (Read a) => String -> a
-   readParen,           -- :: Bool -> ReadS a -> ReadS a
-   lex,                 -- :: ReadS String
+   reads,
+   read,
+   readParen,
+   lex,
 
 #if defined(__GLASGOW_HASKELL__) || defined(__HUGS__)
    -- * New parsing functions
    module Text.ParserCombinators.ReadPrec,
    L.Lexeme(..),
-   lexP,                -- :: ReadPrec Lexeme
-   parens,              -- :: ReadPrec a -> ReadPrec a
+   lexP,
+   parens,
 #endif
 #ifdef __GLASGOW_HASKELL__
-   readListDefault,     -- :: Read a => ReadS [a]
-   readListPrecDefault, -- :: Read a => ReadPrec [a]
-   readEither,          -- :: Read a => String -> Either String a
-   readMaybe            -- :: Read a => String -> Maybe a
+   readListDefault,
+   readListPrecDefault,
+   readEither,
+   readMaybe
 #endif
 
  ) where
diff --git a/libraries/base/Text/Read/Lex.hs b/libraries/base/Text/Read/Lex.hs
index 7c99f0c8a0..f5a07f1658 100644
--- a/libraries/base/Text/Read/Lex.hs
+++ b/libraries/base/Text/Read/Lex.hs
@@ -17,19 +17,19 @@
 
 module Text.Read.Lex
   -- lexing types
-  ( Lexeme(..)  -- :: *; Show, Eq
+  ( Lexeme(..)
 
   , numberToInteger, numberToRational, numberToRangedRational
 
   -- lexer
-  , lex         -- :: ReadP Lexeme      Skips leading spaces
-  , hsLex       -- :: ReadP String
-  , lexChar     -- :: ReadP Char        Reads just one char, with H98 escapes
-
-  , readIntP    -- :: Num a => a -> (Char -> Bool) -> (Char -> Int) -> ReadP a
-  , readOctP    -- :: Num a => ReadP a
-  , readDecP    -- :: Num a => ReadP a
-  , readHexP    -- :: Num a => ReadP a
+  , lex
+  , hsLex
+  , lexChar
+
+  , readIntP
+  , readOctP
+  , readDecP
+  , readHexP
   )
  where
 
diff --git a/libraries/base/Text/Show.hs b/libraries/base/Text/Show.hs
index 0ee9e50fba..d37f71594e 100644
--- a/libraries/base/Text/Show.hs
+++ b/libraries/base/Text/Show.hs
@@ -17,17 +17,13 @@
 -----------------------------------------------------------------------------
 
 module Text.Show (
-   ShowS,               -- String -> String
-   Show(
-      showsPrec,        -- :: Int -> a -> ShowS
-      show,             -- :: a   -> String
-      showList          -- :: [a] -> ShowS 
-    ),
-   shows,               -- :: (Show a) => a -> ShowS
-   showChar,            -- :: Char -> ShowS
-   showString,          -- :: String -> ShowS
-   showParen,           -- :: Bool -> ShowS -> ShowS
-   showListWith,        -- :: (a -> ShowS) -> [a] -> ShowS 
+   ShowS,
+   Show(showsPrec, show, showList),
+   shows,
+   showChar,
+   showString,
+   showParen,
+   showListWith,
  ) where
 
 #ifdef __GLASGOW_HASKELL__