Prelude.hs

   1 {-# OPTIONS_GHC -XNoImplicitPrelude #-}
   2 -----------------------------------------------------------------------------
   3 -- |
   4 -- Module      :  Prelude
   5 -- Copyright   :  (c) The University of Glasgow 2001
   6 -- License     :  BSD-style (see the file libraries/base/LICENSE)
   7 --
   8 -- Maintainer  :  libraries@haskell.org
   9 -- Stability   :  stable
  10 -- Portability :  portable
  11 --
  12 -- The Prelude: a standard module imported by default into all Haskell
  13 -- modules.  For more documentation, see the Haskell 98 Report
  14 -- <http://www.haskell.org/onlinereport/>.
  15 --
  16 -----------------------------------------------------------------------------
  17
  18 module Prelude (
  19
  20     -- * Standard types, classes and related functions
  21
  22     -- ** Basic data types
  23     Bool(False, True),
  24     (&&), (||), not, otherwise,
  25
  26     Maybe(Nothing, Just),
  27     maybe,
  28
  29     Either(Left, Right),
  30     either,
  31
  32     Ordering(LT, EQ, GT),
  33     Char, String,
  34
  35     -- *** Tuples
  36     fst, snd, curry, uncurry,
  37
  38 #if defined(__NHC__)
  39     []((:), []),        -- Not legal Haskell 98;
  40                         -- ... available through built-in syntax
  41     module Data.Tuple,  -- Includes tuple types
  42     ()(..),             -- Not legal Haskell 98
  43     (->),               -- ... available through built-in syntax
  44 #endif
  45 #ifdef __HUGS__
  46     (:),                -- Not legal Haskell 98
  47 #endif
  48
  49     -- ** Basic type classes
  50     Eq((==), (/=)),
  51     Ord(compare, (<), (<=), (>=), (>), max, min),
  52     Enum(succ, pred, toEnum, fromEnum, enumFrom, enumFromThen,
  53          enumFromTo, enumFromThenTo),
  54     Bounded(minBound, maxBound),
  55
  56     -- ** Numbers
  57
  58     -- *** Numeric types
  59     Int, Integer, Float, Double,
  60     Rational,
  61
  62     -- *** Numeric type classes
  63     Num((+), (-), (*), negate, abs, signum, fromInteger),
  64     Real(toRational),
  65     Integral(quot, rem, div, mod, quotRem, divMod, toInteger),
  66     Fractional((/), recip, fromRational),
  67     Floating(pi, exp, log, sqrt, (**), logBase, sin, cos, tan,
  68              asin, acos, atan, sinh, cosh, tanh, asinh, acosh, atanh),
  69     RealFrac(properFraction, truncate, round, ceiling, floor),
  70     RealFloat(floatRadix, floatDigits, floatRange, decodeFloat,
  71               encodeFloat, exponent, significand, scaleFloat, isNaN,
  72               isInfinite, isDenormalized, isIEEE, isNegativeZero, atan2),
  73
  74     -- *** Numeric functions
  75     subtract, even, odd, gcd, lcm, (^), (^^),
  76     fromIntegral, realToFrac,
  77
  78     -- ** Monads and functors
  79     Monad((>>=), (>>), return, fail),
  80     Functor(fmap),
  81     mapM, mapM_, sequence, sequence_, (=<<),
  82
  83     -- ** Miscellaneous functions
  84     id, const, (.), flip, ($), until,
  85     asTypeOf, error, undefined,
  86     seq, ($!),
  87
  88     -- * List operations
  89     map, (++), filter,
  90     head, last, tail, init, null, length, (!!),
  91     reverse,
  92     -- ** Reducing lists (folds)
  93     foldl, foldl1, foldr, foldr1,
  94     -- *** Special folds
  95     and, or, any, all,
  96     sum, product,
  97     concat, concatMap,
  98     maximum, minimum,
  99     -- ** Building lists
 100     -- *** Scans
 101     scanl, scanl1, scanr, scanr1,
 102     -- *** Infinite lists
 103     iterate, repeat, replicate, cycle,
 104     -- ** Sublists
 105     take, drop, splitAt, takeWhile, dropWhile, span, break,
 106     -- ** Searching lists
 107     elem, notElem, lookup,
 108     -- ** Zipping and unzipping lists
 109     zip, zip3, zipWith, zipWith3, unzip, unzip3,
 110     -- ** Functions on strings
 111     lines, words, unlines, unwords,
 112
 113     -- * Converting to and from @String@
 114     -- ** Converting to @String@
 115     ShowS,
 116     Show(showsPrec, showList, show),
 117     shows,
 118     showChar, showString, showParen,
 119     -- ** Converting from @String@
 120     ReadS,
 121     Read(readsPrec, readList),
 122     reads, readParen, read, lex,
 123
 124     -- * Basic Input and output
 125     IO,
 126     -- ** Simple I\/O operations
 127     -- All I/O functions defined here are character oriented.  The
 128     -- treatment of the newline character will vary on different systems.
 129     -- For example, two characters of input, return and linefeed, may
 130     -- read as a single newline character.  These functions cannot be
 131     -- used portably for binary I/O.
 132     -- *** Output functions
 133     putChar,
 134     putStr, putStrLn, print,
 135     -- *** Input functions
 136     getChar,
 137     getLine, getContents, interact,
 138     -- *** Files
 139     FilePath,
 140     readFile, writeFile, appendFile, readIO, readLn,
 141     -- ** Exception handling in the I\/O monad
 142     IOError, ioError, userError, catch
 143
 144   ) where
 145
 146 #ifndef __HUGS__
 147 import Control.Monad
 148 import System.IO
 149 import Data.List
 150 import Data.Either
 151 import Data.Maybe
 152 import Data.Tuple
 153 #endif
 154
 155 #ifdef __GLASGOW_HASKELL__
 156 import GHC.Base
 157 import GHC.IOBase
 158 import GHC.Exception ( throw )
 159 import Text.Read
 160 import GHC.Enum
 161 import GHC.Num
 162 import GHC.Real
 163 import GHC.Float
 164 import GHC.Show
 165 import GHC.Err   ( error, undefined )
 166 #endif
 167
 168 import qualified Control.OldException as Old hiding ( throw )
 169
 170 #ifdef __HUGS__
 171 import Hugs.Prelude
 172 #endif
 173
 174 #ifndef __HUGS__
 175 infixr 0 $!
 176
 177 -- -----------------------------------------------------------------------------
 178 -- Miscellaneous functions
 179
 180 -- | Strict (call-by-value) application, defined in terms of 'seq'.
 181 ($!)    :: (a -> b) -> a -> b
 182 f $! x  = x `seq` f x
 183 #endif
 184
 185 #ifdef __HADDOCK__
 186 -- | The value of @'seq' a b@ is bottom if @a@ is bottom, and otherwise
 187 -- equal to @b@.  'seq' is usually introduced to improve performance by
 188 -- avoiding unneeded laziness.
 189 seq :: a -> b -> b
 190 seq _ y = y
 191 #endif
 192
 193 -- | The 'catch' function establishes a handler that receives any 'IOError'
 194 -- raised in the action protected by 'catch'.  An 'IOError' is caught by
 195 -- the most recent handler established by 'catch'.  These handlers are
 196 -- not selective: all 'IOError's are caught.  Exception propagation
 197 -- must be explicitly provided in a handler by re-raising any unwanted
 198 -- exceptions.  For example, in
 199 --
 200 -- > f = catch g (\e -> if IO.isEOFError e then return [] else ioError e)
 201 --
 202 -- the function @f@ returns @[]@ when an end-of-file exception
 203 -- (cf. 'System.IO.Error.isEOFError') occurs in @g@; otherwise, the
 204 -- exception is propagated to the next outer handler.
 205 --
 206 -- When an exception propagates outside the main program, the Haskell
 207 -- system prints the associated 'IOError' value and exits the program.
 208 --
 209 -- Non-I\/O exceptions are not caught by this variant; to catch all
 210 -- exceptions, use 'Control.Exception.catch' from "Control.Exception".
 211 catch :: IO a -> (IOError -> IO a) -> IO a
 212 catch io handler = io `Old.catch` handler'
 213     where handler' (Old.IOException ioe) = handler ioe
 214           handler' e                     = throw e
 215