Fix a couple of imports
[packages/base.git] / 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