GHC/Types.hs

   1 -----------------------------------------------------------------------------
   2 -- |
   3 -- Module      :  GHC.Types
   4 -- Copyright   :  (c) The University of Glasgow 2009
   5 -- License     :  see libraries/ghc-prim/LICENSE
   6 --
   7 -- Maintainer  :  cvs-ghc@haskell.org
   8 -- Stability   :  internal
   9 -- Portability :  non-portable (GHC Extensions)
  10 --
  11 -- GHC type definitions.
  12 -- Use GHC.Exts from the base package instead of importing this
  13 -- module directly.
  14 --
  15 -----------------------------------------------------------------------------
  16
  17 {-# OPTIONS_GHC -XNoImplicitPrelude #-}
  18
  19 module GHC.Types (Bool(..), Char(..), Int(..), Float(..), Double(..), IO(..)) where
  20
  21 import GHC.Prim
  22 -- We need Inl etc behind the scenes for the type definitions
  23 import GHC.Generics ()
  24
  25 infixr 5 :
  26
  27 data [] a = [] | a : [a]
  28
  29 data Bool = False | True
  30
  31 {-| The character type 'Char' is an enumeration whose values represent
  32 Unicode (or equivalently ISO\/IEC 10646) characters
  33 (see <http://www.unicode.org/> for details).
  34 This set extends the ISO 8859-1 (Latin-1) character set
  35 (the first 256 charachers), which is itself an extension of the ASCII
  36 character set (the first 128 characters).
  37 A character literal in Haskell has type 'Char'.
  38
  39 To convert a 'Char' to or from the corresponding 'Int' value defined
  40 by Unicode, use 'Prelude.toEnum' and 'Prelude.fromEnum' from the
  41 'Prelude.Enum' class respectively (or equivalently 'ord' and 'chr').
  42 -}
  43 data Char = C# Char#
  44
  45 data Int = I# Int#
  46 -- ^A fixed-precision integer type with at least the range @[-2^29 .. 2^29-1]@.
  47 -- The exact range for a given implementation can be determined by using
  48 -- 'Prelude.minBound' and 'Prelude.maxBound' from the 'Prelude.Bounded' class.
  49
  50 -- | Single-precision floating point numbers.
  51 -- It is desirable that this type be at least equal in range and precision
  52 -- to the IEEE single-precision type.
  53 data Float      = F# Float#
  54
  55 -- | Double-precision floating point numbers.
  56 -- It is desirable that this type be at least equal in range and precision
  57 -- to the IEEE double-precision type.
  58 data Double     = D# Double#
  59
  60 {-|
  61 A value of type @'IO' a@ is a computation which, when performed,
  62 does some I\/O before returning a value of type @a@.
  63
  64 There is really only one way to \"perform\" an I\/O action: bind it to
  65 @Main.main@ in your program.  When your program is run, the I\/O will
  66 be performed.  It isn't possible to perform I\/O from an arbitrary
  67 function, unless that function is itself in the 'IO' monad and called
  68 at some point, directly or indirectly, from @Main.main@.
  69
  70 'IO' is a monad, so 'IO' actions can be combined using either the do-notation
  71 or the '>>' and '>>=' operations from the 'Monad' class.
  72 -}
  73 newtype IO a = IO (State# RealWorld -> (# State# RealWorld, a #))
  74