{-# OPTIONS -fno-implicit-prelude #-} ----------------------------------------------------------------------------- -- | -- Module : Prelude -- Copyright : (c) The University of Glasgow 2001 -- License : BSD-style (see the file libraries/base/LICENSE) -- -- Maintainer : libraries@haskell.org -- Stability : provisional -- Portability : portable -- -- The Prelude: a standard module imported by default into all Haskell -- modules. For more documentation, see the Haskell 98 Report -- <http://www.haskell.org/onlinereport/>. -- ----------------------------------------------------------------------------- module Prelude ( module Prelude, -- * Standard types, classes and related functions -- ** Basic data types Bool(False, True), (&&), (||), not, otherwise, Maybe(Nothing, Just), maybe, Either(Left, Right), either, Ordering(LT, EQ, GT), Char, String, -- *** Tuples fst, snd, curry, uncurry, -- (:), -- Not legal Haskell 98 -- ** Basic type classes Eq((==), (/=)), Ord(compare, (<), (<=), (>=), (>), max, min), Enum(succ, pred, toEnum, fromEnum, enumFrom, enumFromThen, enumFromTo, enumFromThenTo), Bounded(minBound, maxBound), -- ** Numbers -- *** Numeric types Int, Integer, Float, Double, Rational, -- *** Numeric type classes Num((+), (-), (*), negate, abs, signum, fromInteger), Real(toRational), Integral(quot, rem, div, mod, quotRem, divMod, toInteger), Fractional((/), recip, fromRational), Floating(pi, exp, log, sqrt, (**), logBase, sin, cos, tan, asin, acos, atan, sinh, cosh, tanh, asinh, acosh, atanh), RealFrac(properFraction, truncate, round, ceiling, floor), RealFloat(floatRadix, floatDigits, floatRange, decodeFloat, encodeFloat, exponent, significand, scaleFloat, isNaN, isInfinite, isDenormalized, isIEEE, isNegativeZero, atan2), -- *** Numeric functions subtract, even, odd, gcd, lcm, (^), (^^), fromIntegral, realToFrac, -- ** Monads and functors Monad((>>=), (>>), return, fail), Functor(fmap), mapM, mapM_, sequence, sequence_, (=<<), -- ** Miscellaneous functions id, const, (.), flip, ($), until, asTypeOf, error, undefined, seq, ($!), -- * List operations map, (++), filter, head, last, tail, init, null, length, (!!), reverse, -- ** Reducing lists (folds) foldl, foldl1, foldr, foldr1, -- *** Special folds and, or, any, all, sum, product, concat, concatMap, maximum, minimum, -- ** Building lists -- *** Scans scanl, scanl1, scanr, scanr1, -- *** Infinite lists iterate, repeat, replicate, cycle, -- ** Sublists take, drop, splitAt, takeWhile, dropWhile, span, break, -- ** Searching lists elem, notElem, lookup, -- ** Zipping and unzipping lists zip, zip3, zipWith, zipWith3, unzip, unzip3, -- ** Functions on strings lines, words, unlines, unwords, -- * Converting to and from @String@ ReadS, ShowS, Read(readsPrec, readList), Show(showsPrec, showList, show), reads, shows, read, lex, showChar, showString, readParen, showParen, -- * Basic Input and output IO, -- ** Simple I\/O operations -- All I/O functions defined here are character oriented. The -- treatment of the newline character will vary on different systems. -- For example, two characters of input, return and linefeed, may -- read as a single newline character. These functions cannot be -- used portably for binary I/O. -- *** Output functions putChar, putStr, putStrLn, print, -- *** Input functions getChar, getLine, getContents, interact, -- *** Files FilePath, readFile, writeFile, appendFile, readIO, readLn, -- ** Exception handling in the I\/O monad IOError, ioError, userError, catch ) where import Hugs.Prelude infixr 5 : -- this fixity declaration is hard-wired into Hugs data [a] = [] | a : [a] deriving (Eq, Ord) data (->) a b data () = () deriving (Eq, Ord, {-Ix,-} Enum, Read, Show, Bounded) data (a,b) = (,) a b deriving (Eq, Ord, {-Ix,-} Read, Show, Bounded) data (a,b,c) = (,,) a b c deriving (Eq, Ord, {-Ix,-} Read, Show, Bounded) data (a,b,c,d) = (,,,) a b c d deriving (Eq, Ord, {-Ix,-} Read, Show, Bounded) data (a,b,c,d,e) = (,,,,) a b c d e deriving (Eq, Ord, {-Ix,-} Read, Show, Bounded) data (a,b,c,d,e,f) = (,,,,,) a b c d e f deriving (Eq, Ord, {-Ix,-} Read, Show, Bounded) data (a,b,c,d,e,f,g) = (,,,,,,) a b c d e f g deriving (Eq, Ord, {-Ix,-} Read, Show, Bounded) data (a,b,c,d,e,f,g,h) = (,,,,,,,) a b c d e f g h deriving (Eq, Ord, {-Ix,-} Read, Show, Bounded) data (a,b,c,d,e,f,g,h,i) = (,,,,,,,,) a b c d e f g h i deriving (Eq, Ord, {-Ix,-} Read, Show, Bounded) data (a,b,c,d,e,f,g,h,i,j) = (,,,,,,,,,) a b c d e f g h i j deriving (Eq, Ord, {-Ix,-} Read, Show, Bounded) data (a,b,c,d,e,f,g,h,i,j,k) = (,,,,,,,,,,) a b c d e f g h i j k deriving (Eq, Ord, {-Ix,-} Read, Show, Bounded) data (a,b,c,d,e,f,g,h,i,j,k,l) = (,,,,,,,,,,,) a b c d e f g h i j k l deriving (Eq, Ord, {-Ix,-} Read, Show, Bounded) data (a,b,c,d,e,f,g,h,i,j,k,l,m,n) = (,,,,,,,,,,,,,) a b c d e f g h i j k l m n deriving (Eq, Ord, {-Ix,-} Read, Show, Bounded) -- Extra definitions for PFE ------------------------------------------------- -- For use in derived Ord instances: lexOrder EQ o = o lexOrder o _ = o -- For use in derived Read instances: readToken x t s = [(x,r)|(t',r)<-lex s,t'==t] readParenArg :: Int -> ReadS a -> ReadS a readParenArg d = readParen (10<=d) readArgument s = readsPrec 10 s rf `readAp` rx = \ s0 -> [(f x,s2) | (f,s1)<-rf s0,(x,s2)<-rx s1] readChoice rd1 rd2 s = rd1 s ++ rd2 s -- For use in derived Show instances: showParenArg :: Int -> ShowS -> ShowS showParenArg d = showParen (10<=d) showArgument x = showChar ' ' . showsPrec 10 x
(HTML for this module was generated on 2006-08-12. About the conversion tool.)