Prelude.hs

   1 {-# OPTIONS -fno-implicit-prelude #-}
   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   :  provisional
  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     ReadS, ShowS,
 115     Read(readsPrec, readList),
 116     Show(showsPrec, showList, show),
 117     reads, shows, read, lex,
 118     showChar, showString, readParen, showParen,
 119
 120     -- * Basic Input and output
 121     IO,
 122     -- ** Simple I\/O operations
 123     -- All I/O functions defined here are character oriented.  The
 124     -- treatment of the newline character will vary on different systems.
 125     -- For example, two characters of input, return and linefeed, may
 126     -- read as a single newline character.  These functions cannot be
 127     -- used portably for binary I/O.
 128     -- *** Output functions
 129     putChar,
 130     putStr, putStrLn, print,
 131     -- *** Input functions
 132     getChar,
 133     getLine, getContents, interact,
 134     -- *** Files
 135     FilePath,
 136     readFile, writeFile, appendFile, readIO, readLn,
 137     -- ** Exception handling in the I\/O monad
 138     IOError, ioError, userError, catch
 139
 140   ) where
 141
 142 #ifndef __HUGS__
 143 import Control.Monad
 144 import System.IO
 145 import Text.Read
 146 import Text.Show
 147 import Data.List
 148 import Data.Either
 149 import Data.Maybe
 150 import Data.Bool
 151 import Data.Tuple
 152 #endif
 153
 154 #ifdef __GLASGOW_HASKELL__
 155 import GHC.Base
 156 import GHC.IOBase
 157 import GHC.Exception
 158 import GHC.Read
 159 import GHC.Enum
 160 import GHC.Num
 161 import GHC.Real
 162 import GHC.Float
 163 import GHC.Show
 164 import GHC.Err   ( error, undefined )
 165 #endif
 166
 167 #ifdef __HUGS__
 168 import Hugs.Prelude
 169 #endif
 170
 171 #ifndef __HUGS__
 172 infixr 0 $!
 173
 174
 175 -- -----------------------------------------------------------------------------
 176 -- Miscellaneous functions
 177
 178 ($!)    :: (a -> b) -> a -> b
 179 f $! x  = x `seq` f x
 180 #endif
 181