X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=GHC%2FTypes.hs;h=59ce3860a1a26af6f5f783a96cc8301dac602678;hb=49d560213f818de8ed7713ed9c3bf2ed210b076a;hp=a611b83e2b542e3d1a7cec1c3a71a00254297afc;hpb=c8ff966d1e0451d07ba12bfd1d7d0e43d032c694;p=ghc-prim.git

diff --git a/GHC/Types.hs b/GHC/Types.hs
index a611b83..59ce386 100644
--- a/GHC/Types.hs
+++ b/GHC/Types.hs
@@ -1,7 +1,22 @@
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  GHC.Types
+-- Copyright   :  (c) The University of Glasgow 2009
+-- License     :  see libraries/ghc-prim/LICENSE
+--
+-- Maintainer  :  cvs-ghc@haskell.org
+-- Stability   :  internal
+-- Portability :  non-portable (GHC Extensions)
+--
+-- GHC type definitions.
+-- Use GHC.Exts from the base package instead of importing this
+-- module directly.
+--
+-----------------------------------------------------------------------------
 
 {-# OPTIONS_GHC -XNoImplicitPrelude #-}
 
-module GHC.Types where
+module GHC.Types (Bool(..), Char(..), Int(..), Float(..), Double(..), IO(..)) where
 
 import GHC.Prim
 -- We need Inl etc behind the scenes for the type definitions
@@ -11,6 +26,20 @@ infixr 5 :
 
 data [] a = [] | a : [a]
 
+data Bool = False | True
+
+{-| The character type 'Char' is an enumeration whose values represent
+Unicode (or equivalently ISO\/IEC 10646) characters
+(see <http://www.unicode.org/> for details).
+This set extends the ISO 8859-1 (Latin-1) character set
+(the first 256 charachers), which is itself an extension of the ASCII
+character set (the first 128 characters).
+A character literal in Haskell has type 'Char'.
+
+To convert a 'Char' to or from the corresponding 'Int' value defined
+by Unicode, use 'Prelude.toEnum' and 'Prelude.fromEnum' from the
+'Prelude.Enum' class respectively (or equivalently 'ord' and 'chr').
+-}
 data Char = C# Char#
 
 data Int = I# Int#
@@ -28,3 +57,18 @@ data Float      = F# Float#
 -- to the IEEE double-precision type.
 data Double     = D# Double#
 
+{-|
+A value of type @'IO' a@ is a computation which, when performed,
+does some I\/O before returning a value of type @a@.
+
+There is really only one way to \"perform\" an I\/O action: bind it to
+@Main.main@ in your program.  When your program is run, the I\/O will
+be performed.  It isn't possible to perform I\/O from an arbitrary
+function, unless that function is itself in the 'IO' monad and called
+at some point, directly or indirectly, from @Main.main@.
+
+'IO' is a monad, so 'IO' actions can be combined using either the do-notation
+or the '>>' and '>>=' operations from the 'Monad' class.
+-}
+newtype IO a = IO (State# RealWorld -> (# State# RealWorld, a #))
+