|
Prelude | Portability | portable | Stability | provisional | Maintainer | libraries@haskell.org |
|
|
|
|
Contents |
- Basic data types
- Basic type classes
- Numeric type classes
- List operations
- Converting to and from String
- Simple I/O operations
- Monads
- Miscellaneous functions
|
|
Description |
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/.
|
|
Synopsis |
|
| | | | | | | | | | type String = [Char] | | | | | | | | | | | | type Rational = Ratio Integer | | class Eq a where | | | class (Eq a) => Ord a where | | | class Enum a where | | | class Bounded a where | | | class (Eq a, Show a) => Num a where | | | class (Num a, Ord a) => Real a where | | | class (Real a, Enum a) => Integral a where | | | class (Num a) => Fractional a where | | | class (Fractional a) => Floating a where | | | class (Real a, Fractional a) => RealFrac a where | | | class (RealFrac a, Floating a) => RealFloat a where | | | map :: (a -> b) -> [a] -> [b] | | (++) :: [a] -> [a] -> [a] | | filter :: (a -> Bool) -> [a] -> [a] | | concat :: [[a]] -> [a] | | head :: [a] -> a | | last :: [a] -> a | | tail :: [a] -> [a] | | init :: [a] -> [a] | | null :: [a] -> Bool | | length :: [a] -> Int | | (!!) :: [a] -> Int -> a | | foldl :: (a -> b -> a) -> a -> [b] -> a | | foldl1 :: (a -> a -> a) -> [a] -> a | | scanl :: (a -> b -> a) -> a -> [b] -> [a] | | scanl1 :: (a -> a -> a) -> [a] -> [a] | | foldr :: (a -> b -> b) -> b -> [a] -> b | | foldr1 :: (a -> a -> a) -> [a] -> a | | scanr :: (a -> b -> b) -> b -> [a] -> [b] | | scanr1 :: (a -> a -> a) -> [a] -> [a] | | iterate :: (a -> a) -> a -> [a] | | repeat :: a -> [a] | | replicate :: Int -> a -> [a] | | cycle :: [a] -> [a] | | take :: Int -> [b] -> [b] | | drop :: Int -> [b] -> [b] | | splitAt :: Int -> [b] -> ([b], [b]) | | takeWhile :: (a -> Bool) -> [a] -> [a] | | dropWhile :: (a -> Bool) -> [a] -> [a] | | span :: (a -> Bool) -> [a] -> ([a], [a]) | | break :: (a -> Bool) -> [a] -> ([a], [a]) | | reverse :: [a] -> [a] | | and :: [Bool] -> Bool | | or :: [Bool] -> Bool | | any :: (a -> Bool) -> [a] -> Bool | | all :: (a -> Bool) -> [a] -> Bool | | elem :: (Eq a) => a -> [a] -> Bool | | notElem :: (Eq a) => a -> [a] -> Bool | | lookup :: (Eq a) => a -> [(a, b)] -> Maybe b | | maximum :: (Ord a) => [a] -> a | | minimum :: (Ord a) => [a] -> a | | concatMap :: (a -> [b]) -> [a] -> [b] | | zip :: [a] -> [b] -> [(a, b)] | | zip3 :: [a] -> [b] -> [c] -> [(a, b, c)] | | zipWith :: (a -> b -> c) -> [a] -> [b] -> [c] | | zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d] | | unzip :: [(a, b)] -> ([a], [b]) | | unzip3 :: [(a, b, c)] -> ([a], [b], [c]) | | lines :: String -> [String] | | words :: String -> [String] | | unlines :: [String] -> String | | unwords :: [String] -> String | | sum :: (Num a) => [a] -> a | | product :: (Num a) => [a] -> a | | type ReadS a = String -> [(a, String)] | | type ShowS = String -> String | | class Read a where | | | class Show a where | | | reads :: (Read a) => ReadS a | | shows :: (Show a) => a -> ShowS | | read :: (Read a) => String -> a | | lex :: ReadS String | | showChar :: Char -> ShowS | | showString :: String -> ShowS | | readParen :: Bool -> ReadS a -> ReadS a | | showParen :: Bool -> ShowS -> ShowS | | ioError :: IOError -> IO a | | userError :: String -> IOError | | catch :: IO a -> (IOError -> IO a) -> IO a | | type FilePath = String | | type IOError = IOException | | putChar :: Char -> IO () | | putStr :: String -> IO () | | putStrLn :: String -> IO () | | print :: (Show a) => a -> IO () | | getChar :: IO Char | | getLine :: IO String | | getContents :: IO String | | interact :: (String -> String) -> IO () | | readFile :: FilePath -> IO String | | writeFile :: FilePath -> String -> IO () | | appendFile :: FilePath -> String -> IO () | | readIO :: (Read a) => String -> IO a | | readLn :: (Read a) => IO a | | class Monad m where | | | class Functor f where | fmap :: (a -> b) -> f a -> f b |
| | mapM :: (Monad m) => (a -> m b) -> [a] -> m [b] | | mapM_ :: (Monad m) => (a -> m b) -> [a] -> m () | | sequence :: (Monad m) => [m a] -> m [a] | | sequence_ :: (Monad m) => [m a] -> m () | | (=<<) :: (Monad m) => (a -> m b) -> m a -> m b | | maybe :: b -> (a -> b) -> Maybe a -> b | | either :: (a -> c) -> (b -> c) -> Either a b -> c | | (&&) :: Bool -> Bool -> Bool | | (||) :: Bool -> Bool -> Bool | | not :: Bool -> Bool | | otherwise :: Bool | | subtract :: (Num a) => a -> a -> a | | even :: (Integral a) => a -> Bool | | odd :: (Integral a) => a -> Bool | | gcd :: (Integral a) => a -> a -> a | | lcm :: (Integral a) => a -> a -> a | | (^) :: (Num a, Integral b) => a -> b -> a | | (^^) :: (Fractional a, Integral b) => a -> b -> a | | fromIntegral :: (Integral a, Num b) => a -> b | | realToFrac :: (Real a, Fractional b) => a -> b | | fst :: (a, b) -> a | | snd :: (a, b) -> b | | curry :: ((a, b) -> c) -> a -> b -> c | | uncurry :: (a -> b -> c) -> (a, b) -> c | | id :: a -> a | | const :: a -> b -> a | | (.) :: (b -> c) -> (a -> b) -> a -> c | | flip :: (a -> b -> c) -> b -> a -> c | | ($) :: (a -> b) -> a -> b | | until :: (a -> Bool) -> (a -> a) -> a -> a | | asTypeOf :: a -> a -> a | | error :: String -> a | | undefined :: a | | ($!) :: (a -> b) -> a -> b |
|
|
|
Basic data types |
|
data Bool |
The Bool type is an enumeration. It is defined with False
first so that the corresponding Enum instance will give fromEnum
False the value zero, and fromEnum True the value 1. | Constructors | | Instances | |
|
|
data Maybe a |
The Maybe type encapsulates an optional value. A value of type
Maybe a either contains a value of type a (represented as Just a),
or it is empty (represented as Nothing). Using Maybe is a good way to
deal with errors or exceptional cases without resorting to drastic
measures such as error. The Maybe type is also a monad. It is a simple kind of error
monad, where all errors are represented by Nothing. A richer
error monad can be built using the Either type. | Constructors | | Instances | |
|
|
data Either a b |
The Either type represents values with two possibilities: a value of
type Either a b is either Left a or Right b. The Either type is sometimes used to represent a value which is
either correct or an error; by convention, the Left constructor is
used to hold an error value and the Right constructor is used to
hold a correct value (mnemonic: "right" also means "correct").
| Constructors | | Instances | |
|
|
data Ordering |
Represents an ordering relationship between two values: less
than, equal to, or greater than. An Ordering is returned by
compare. | Constructors | | Instances | |
|
|
data Char |
The character type Char is an enumeration whose values represent
Unicode characters. A character literal in Haskell has type Char. To convert a Char to or from an Int, use toEnum and
fromEnum from the Enum class respectively (equivalently
ord and chr also do the trick).
| Instances | |
|
|
type String = [Char] |
A String is a list of characters. String constants in Haskell are values
of type String.
|
|
data Int |
A fixed-precision integer type with at least the range [-2^29
.. 2^29-1]. The exact range for a given implementation can be
determined by using minBound and maxBound from the Bounded
class. | Instances | |
|
|
data Integer |
Arbitrary-precision integers. | Instances | |
|
|
data Float |
Single-precision floating point numbers. | Instances | |
|
|
data Double |
Double-precision floating point numbers. | Instances | |
|
|
data IO a |
A value of type IO a is a computation which, when performed,
does some I/O before returning a value of type a. There is really only one way to "perform" an I/O action: bind it to
Main.main in your program. When your program is run, the I/O will
be performed. It isn't possible to perform I/O from an arbitrary
function, unless that function is itself in the IO monad and called
at some point, directly or indirectly, from Main.main. IO is a monad, so IO actions can be combined using either the do-notation
or the >> and >>= operations from the Monad class.
| Instances | |
|
|
type Rational = Ratio Integer |
Arbitrary-precision rational numbers, represented as a ratio of
two Integer values. A rational number may be constructed using
the % operator. |
|
Basic type classes |
|
class Eq a where |
The Eq class defines equality (==) and inequality (/=).
All the basic datatypes exported by the Prelude are instances of Eq,
and Eq may be derived for any datatype whose constituents are also
instances of Eq. Minimal complete definition: either == or /=.
| | Methods | (==) :: a -> a -> Bool | | (/=) :: a -> a -> Bool |
| | Instances | Eq ThreadId | (Ix ix) => Eq (UArray ix Bool) | (Ix ix) => Eq (UArray ix Char) | (Ix ix) => Eq (UArray ix Int) | (Ix ix) => Eq (UArray ix Word) | (Ix ix) => Eq (UArray ix (Ptr a)) | (Ix ix) => Eq (UArray ix (FunPtr a)) | (Ix ix) => Eq (UArray ix Float) | (Ix ix) => Eq (UArray ix Double) | (Ix ix) => Eq (UArray ix (StablePtr a)) | (Ix ix) => Eq (UArray ix Int8) | (Ix ix) => Eq (UArray ix Int16) | (Ix ix) => Eq (UArray ix Int32) | (Ix ix) => Eq (UArray ix Int64) | (Ix ix) => Eq (UArray ix Word8) | (Ix ix) => Eq (UArray ix Word16) | (Ix ix) => Eq (UArray ix Word32) | (Ix ix) => Eq (UArray ix Word64) | (RealFloat a, Eq a) => Eq (Complex a) | Eq TypeRep | Eq TyCon | Eq Key | Eq KeyPr | (Eq a, Eq b) => Eq (Either a b) | (Eq key, Eq elt) => Eq (FiniteMap key elt) | (Eq a) => Eq (Maybe a) | Eq PackedString | (Eq a) => Eq (Set a) | (Eq a, Eq b) => Eq (a, b) | (Eq a, Eq b, Eq c) => Eq (a, b, c) | (Eq a, Eq b, Eq c, Eq d) => Eq (a, b, c, d) | (Eq a, Eq b, Eq c, Eq d, Eq e) => Eq (a, b, c, d, e) | (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f) => Eq (a, b, c, d, e, f) | (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g) => Eq (a, b, c, d, e, f, g) | (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h) => Eq (a, b, c, d, e, f, g, h) | (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i) => Eq (a, b, c, d, e, f, g, h, i) | (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j) => Eq (a, b, c, d, e, f, g, h, i, j) | (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k) => Eq (a, b, c, d, e, f, g, h, i, j, k) | (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l) => Eq (a, b, c, d, e, f, g, h, i, j, k, l) | (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m) => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m) | (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n) => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m, n) | (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n, Eq o) => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) | Eq Unique | (Eq a) => Eq (Poly a) | Eq ALPHA_ | Eq BETA_ | Eq GAMMA_ | Eq OrdALPHA_ | Eq OrdBETA_ | Eq OrdGAMMA_ | Eq Errno | Eq CChar | Eq CSChar | Eq CUChar | Eq CShort | Eq CUShort | Eq CInt | Eq CUInt | Eq CLong | Eq CULong | Eq CLLong | Eq CULLong | Eq CFloat | Eq CDouble | Eq CLDouble | Eq CPtrdiff | Eq CSize | Eq CWchar | Eq CSigAtomic | Eq CClock | Eq CTime | Eq (STArray s i e) | (Ix i, Eq e) => Eq (Array i e) | (Eq a) => Eq [a] | Eq () | Eq Char | Eq Int | Eq Bool | Eq Ordering | Eq Float | Eq Double | Eq (ForeignPtr a) | Eq HandlePosn | Eq IOModeEx | Eq SeekMode | Eq (MVar a) | Eq Handle | Eq (IORef a) | Eq (IOArray i e) | Eq Exception | Eq IOException | Eq IOErrorType | Eq BufferState | Eq BufferMode | Eq ArithException | Eq AsyncException | Eq ArrayException | Eq ExitCode | Eq IOMode | Eq Int64 | Eq Int8 | Eq Int16 | Eq Int32 | Eq Integer | Eq (Ptr a) | Eq (FunPtr a) | (Integral a, Eq a) => Eq (Ratio a) | Eq (STRef s a) | Eq (StablePtr a) | Eq Word64 | Eq Word | Eq Word8 | Eq Word16 | Eq Word32 | Eq Permissions | Eq TimeLocale | Eq (StableName a) | Eq FDType | Eq CDev | Eq CIno | Eq CMode | Eq COff | Eq CPid | Eq CSsize | Eq CGid | Eq CNlink | Eq CUid | Eq CCc | Eq CSpeed | Eq CTcflag | Eq CRLim | Eq Fd | Eq Month | Eq Day | Eq ClockTime | Eq CalendarTime | Eq TimeDiff | Eq Lexeme |
|
|
|
class (Eq a) => Ord a where |
| Methods | compare :: a -> a -> Ordering | | (<) :: a -> a -> Bool | | (<=) :: a -> a -> Bool | | (>) :: a -> a -> Bool | | (>=) :: a -> a -> Bool | | max :: a -> a -> a | | min :: a -> a -> a |
| | Instances | Ord ThreadId | (Ix ix) => Ord (UArray ix Bool) | (Ix ix) => Ord (UArray ix Char) | (Ix ix) => Ord (UArray ix Int) | (Ix ix) => Ord (UArray ix Word) | (Ix ix) => Ord (UArray ix (Ptr a)) | (Ix ix) => Ord (UArray ix (FunPtr a)) | (Ix ix) => Ord (UArray ix Float) | (Ix ix) => Ord (UArray ix Double) | (Ix ix) => Ord (UArray ix Int8) | (Ix ix) => Ord (UArray ix Int16) | (Ix ix) => Ord (UArray ix Int32) | (Ix ix) => Ord (UArray ix Int64) | (Ix ix) => Ord (UArray ix Word8) | (Ix ix) => Ord (UArray ix Word16) | (Ix ix) => Ord (UArray ix Word32) | (Ix ix) => Ord (UArray ix Word64) | (Ord a, Ord b) => Ord (Either a b) | (Ord a) => Ord (Maybe a) | Ord PackedString | (Ord a, Ord b) => Ord (a, b) | (Ord a, Ord b, Ord c) => Ord (a, b, c) | (Ord a, Ord b, Ord c, Ord d) => Ord (a, b, c, d) | (Ord a, Ord b, Ord c, Ord d, Ord e) => Ord (a, b, c, d, e) | (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f) => Ord (a, b, c, d, e, f) | (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g) => Ord (a, b, c, d, e, f, g) | (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h) => Ord (a, b, c, d, e, f, g, h) | (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i) => Ord (a, b, c, d, e, f, g, h, i) | (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j) => Ord (a, b, c, d, e, f, g, h, i, j) | (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k) => Ord (a, b, c, d, e, f, g, h, i, j, k) | (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l) => Ord (a, b, c, d, e, f, g, h, i, j, k, l) | (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l, Ord m) => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m) | (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l, Ord m, Ord n) => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n) | (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l, Ord m, Ord n, Ord o) => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) | Ord Unique | (Ord a) => Ord (Poly a) | Ord OrdALPHA_ | Ord OrdBETA_ | Ord OrdGAMMA_ | Ord CChar | Ord CSChar | Ord CUChar | Ord CShort | Ord CUShort | Ord CInt | Ord CUInt | Ord CLong | Ord CULong | Ord CLLong | Ord CULLong | Ord CFloat | Ord CDouble | Ord CLDouble | Ord CPtrdiff | Ord CSize | Ord CWchar | Ord CSigAtomic | Ord CClock | Ord CTime | (Ix i, Ord e) => Ord (Array i e) | (Ord a) => Ord [a] | Ord () | Ord Char | Ord Int | Ord Bool | Ord Ordering | Ord Float | Ord Double | Ord (ForeignPtr a) | Ord SeekMode | Ord BufferMode | Ord ArithException | Ord AsyncException | Ord ArrayException | Ord ExitCode | Ord IOMode | Ord Int64 | Ord Int8 | Ord Int16 | Ord Int32 | Ord Integer | Ord (Ptr a) | Ord (FunPtr a) | (Integral a) => Ord (Ratio a) | Ord Word64 | Ord Word | Ord Word8 | Ord Word16 | Ord Word32 | Ord Permissions | Ord TimeLocale | Ord CDev | Ord CIno | Ord CMode | Ord COff | Ord CPid | Ord CSsize | Ord CGid | Ord CNlink | Ord CUid | Ord CCc | Ord CSpeed | Ord CTcflag | Ord CRLim | Ord Fd | Ord Month | Ord Day | Ord ClockTime | Ord CalendarTime | Ord TimeDiff |
|
|
|
class Enum a where |
| Methods | succ :: a -> a | | pred :: a -> a | | toEnum :: Int -> a | | fromEnum :: a -> Int | | enumFrom :: a -> [a] | | enumFromThen :: a -> a -> [a] | | enumFromTo :: a -> a -> [a] | | enumFromThenTo :: a -> a -> a -> [a] |
| | Instances | |
|
|
class Bounded a where |
| Methods | minBound :: a | | maxBound :: a |
| | Instances | Bounded CChar | Bounded CSChar | Bounded CUChar | Bounded CShort | Bounded CUShort | Bounded CInt | Bounded CUInt | Bounded CLong | Bounded CULong | Bounded CLLong | Bounded CULLong | Bounded CPtrdiff | Bounded CSize | Bounded CWchar | Bounded CSigAtomic | Bounded CClock | Bounded CTime | Bounded () | (Bounded a, Bounded b) => Bounded (a, b) | (Bounded a, Bounded b, Bounded c) => Bounded (a, b, c) | (Bounded a, Bounded b, Bounded c, Bounded d) => Bounded (a, b, c, d) | Bounded Bool | Bounded Ordering | Bounded Char | Bounded Int | Bounded Int8 | Bounded Int16 | Bounded Int32 | Bounded Int64 | Bounded Word | Bounded Word8 | Bounded Word16 | Bounded Word32 | Bounded Word64 | Bounded CIno | Bounded CMode | Bounded COff | Bounded CPid | Bounded CSsize | Bounded CGid | Bounded CNlink | Bounded CUid | Bounded CTcflag | Bounded CRLim | Bounded Fd | Bounded Month | Bounded Day |
|
|
|
Numeric type classes |
|
class (Eq a, Show a) => Num a where |
| Methods | (+) :: a -> a -> a | | (-) :: a -> a -> a | | (*) :: a -> a -> a | | negate :: a -> a | | abs :: a -> a | | signum :: a -> a | | fromInteger :: Integer -> a |
| | Instances | |
|
|
class (Num a, Ord a) => Real a where |
|
|
class (Real a, Enum a) => Integral a where |
| Methods | quot :: a -> a -> a | | rem :: a -> a -> a | | div :: a -> a -> a | | mod :: a -> a -> a | | quotRem :: a -> a -> (a, a) | | divMod :: a -> a -> (a, a) | | toInteger :: a -> Integer |
| | Instances | |
|
|
class (Num a) => Fractional a where |
| Methods | (/) :: a -> a -> a | | recip :: a -> a | | fromRational :: Rational -> a |
| | Instances | |
|
|
class (Fractional a) => Floating a where |
| Methods | pi :: a | | exp :: a -> a | | log :: a -> a | | sqrt :: a -> a | | (**) :: a -> a -> a | | logBase :: a -> a -> a | | sin :: a -> a | | cos :: a -> a | | tan :: a -> a | | asin :: a -> a | | acos :: a -> a | | atan :: a -> a | | sinh :: a -> a | | cosh :: a -> a | | tanh :: a -> a | | asinh :: a -> a | | acosh :: a -> a | | atanh :: a -> a |
| | Instances | |
|
|
class (Real a, Fractional a) => RealFrac a where |
|
|
class (RealFrac a, Floating a) => RealFloat a where |
| Methods | floatRadix :: a -> Integer | | floatDigits :: a -> Int | | floatRange :: a -> (Int, Int) | | decodeFloat :: a -> (Integer, Int) | | encodeFloat :: Integer -> Int -> a | | exponent :: a -> Int | | significand :: a -> a | | scaleFloat :: Int -> a -> a | | isNaN :: a -> Bool | | isInfinite :: a -> Bool | | isDenormalized :: a -> Bool | | isNegativeZero :: a -> Bool | | isIEEE :: a -> Bool | | atan2 :: a -> a -> a |
| | Instances | |
|
|
List operations |
|
map :: (a -> b) -> [a] -> [b] |
|
(++) :: [a] -> [a] -> [a] |
|
filter :: (a -> Bool) -> [a] -> [a] |
|
concat :: [[a]] -> [a] |
|
head :: [a] -> a |
|
last :: [a] -> a |
|
tail :: [a] -> [a] |
|
init :: [a] -> [a] |
|
null :: [a] -> Bool |
|
length :: [a] -> Int |
|
(!!) :: [a] -> Int -> a |
|
foldl :: (a -> b -> a) -> a -> [b] -> a |
|
foldl1 :: (a -> a -> a) -> [a] -> a |
|
scanl :: (a -> b -> a) -> a -> [b] -> [a] |
|
scanl1 :: (a -> a -> a) -> [a] -> [a] |
|
foldr :: (a -> b -> b) -> b -> [a] -> b |
|
foldr1 :: (a -> a -> a) -> [a] -> a |
|
scanr :: (a -> b -> b) -> b -> [a] -> [b] |
|
scanr1 :: (a -> a -> a) -> [a] -> [a] |
|
iterate :: (a -> a) -> a -> [a] |
|
repeat :: a -> [a] |
|
replicate :: Int -> a -> [a] |
|
cycle :: [a] -> [a] |
|
take :: Int -> [b] -> [b] |
|
drop :: Int -> [b] -> [b] |
|
splitAt :: Int -> [b] -> ([b], [b]) |
|
takeWhile :: (a -> Bool) -> [a] -> [a] |
|
dropWhile :: (a -> Bool) -> [a] -> [a] |
|
span :: (a -> Bool) -> [a] -> ([a], [a]) |
|
break :: (a -> Bool) -> [a] -> ([a], [a]) |
|
reverse :: [a] -> [a] |
|
and :: [Bool] -> Bool |
|
or :: [Bool] -> Bool |
|
any :: (a -> Bool) -> [a] -> Bool |
|
all :: (a -> Bool) -> [a] -> Bool |
|
elem :: (Eq a) => a -> [a] -> Bool |
|
notElem :: (Eq a) => a -> [a] -> Bool |
|
lookup :: (Eq a) => a -> [(a, b)] -> Maybe b |
|
maximum :: (Ord a) => [a] -> a |
|
minimum :: (Ord a) => [a] -> a |
|
concatMap :: (a -> [b]) -> [a] -> [b] |
|
zip :: [a] -> [b] -> [(a, b)] |
|
zip3 :: [a] -> [b] -> [c] -> [(a, b, c)] |
|
zipWith :: (a -> b -> c) -> [a] -> [b] -> [c] |
|
zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d] |
|
unzip :: [(a, b)] -> ([a], [b]) |
|
unzip3 :: [(a, b, c)] -> ([a], [b], [c]) |
|
lines :: String -> [String] |
|
words :: String -> [String] |
|
unlines :: [String] -> String |
|
unwords :: [String] -> String |
|
sum :: (Num a) => [a] -> a |
|
product :: (Num a) => [a] -> a |
|
Converting to and from String |
|
type ReadS a = String -> [(a, String)] |
A parser for a type a, represented as a function that takes a
String and returns a list of possible parses (a,String) pairs. |
|
type ShowS = String -> String |
|
class Read a where |
| Methods | | | Instances | (RealFloat a, Read a) => Read (Complex a) | Read CChar | Read CSChar | Read CUChar | Read CShort | Read CUShort | Read CInt | Read CUInt | Read CLong | Read CULong | Read CLLong | Read CULLong | Read CFloat | Read CDouble | Read CLDouble | Read CPtrdiff | Read CSize | Read CWchar | Read CSigAtomic | Read CClock | Read CTime | Read IOModeEx | Read SeekMode | Read BufferMode | Read ExitCode | Read IOMode | Read Int8 | Read Int16 | Read Int32 | Read Int64 | Read Char | Read Bool | Read Ordering | (Read a) => Read (Maybe a) | (Read a, Read b) => Read (Either a b) | (Read a) => Read [a] | (Ix a, Read a, Read b) => Read (Array a b) | Read Lexeme | Read Int | Read Integer | Read Float | Read Double | (Integral a, Read a) => Read (Ratio a) | Read () | (Read a, Read b) => Read (a, b) | (Read a, Read b, Read c) => Read (a, b, c) | (Read a, Read b, Read c, Read d) => Read (a, b, c, d) | (Read a, Read b, Read c, Read d, Read e) => Read (a, b, c, d, e) | Read Word | Read Word8 | Read Word16 | Read Word32 | Read Word64 | Read Permissions | Read CDev | Read CIno | Read CMode | Read COff | Read CPid | Read CSsize | Read CGid | Read CNlink | Read CUid | Read CCc | Read CSpeed | Read CTcflag | Read CRLim | Read Fd | Read StdGen | Read Month | Read Day | Read CalendarTime | Read TimeDiff |
|
|
|
class Show a where |
| Methods | | | Instances | Show ThreadId | (Ix ix, Show ix) => Show (UArray ix Bool) | (Ix ix, Show ix) => Show (UArray ix Char) | (Ix ix, Show ix) => Show (UArray ix Int) | (Ix ix, Show ix) => Show (UArray ix Word) | (Ix ix, Show ix) => Show (UArray ix Float) | (Ix ix, Show ix) => Show (UArray ix Double) | (Ix ix, Show ix) => Show (UArray ix Int8) | (Ix ix, Show ix) => Show (UArray ix Int16) | (Ix ix, Show ix) => Show (UArray ix Int32) | (Ix ix, Show ix) => Show (UArray ix Int64) | (Ix ix, Show ix) => Show (UArray ix Word8) | (Ix ix, Show ix) => Show (UArray ix Word16) | (Ix ix, Show ix) => Show (UArray ix Word32) | (Ix ix, Show ix) => Show (UArray ix Word64) | (Ix ix, Show ix, Show e) => Show (DiffArray ix e) | (Ix ix, Show ix) => Show (DiffUArray ix Char) | (Ix ix, Show ix) => Show (DiffUArray ix Int) | (Ix ix, Show ix) => Show (DiffUArray ix Word) | (Ix ix, Show ix) => Show (DiffUArray ix Float) | (Ix ix, Show ix) => Show (DiffUArray ix Double) | (Ix ix, Show ix) => Show (DiffUArray ix Int8) | (Ix ix, Show ix) => Show (DiffUArray ix Int16) | (Ix ix, Show ix) => Show (DiffUArray ix Int32) | (Ix ix, Show ix) => Show (DiffUArray ix Int64) | (Ix ix, Show ix) => Show (DiffUArray ix Word8) | (Ix ix, Show ix) => Show (DiffUArray ix Word16) | (Ix ix, Show ix) => Show (DiffUArray ix Word32) | (Ix ix, Show ix) => Show (DiffUArray ix Word64) | (RealFloat a, Show a) => Show (Complex a) | Show Dynamic | Show TypeRep | Show TyCon | Show PackedString | Show (Poly a) | Show CChar | Show CSChar | Show CUChar | Show CShort | Show CUShort | Show CInt | Show CUInt | Show CLong | Show CULong | Show CLLong | Show CULLong | Show CFloat | Show CDouble | Show CLDouble | Show CPtrdiff | Show CSize | Show CWchar | Show CSigAtomic | Show CClock | Show CTime | Show (Ptr a) | Show (FunPtr a) | (Ix a, Show a, Show b) => Show (Array a b) | Show Float | Show Double | Show (ForeignPtr a) | Show HandlePosn | Show IOModeEx | Show SeekMode | Show HandleType | Show Handle | Show ArithException | Show AsyncException | Show ArrayException | Show Exception | Show IOErrorType | Show IOException | Show BufferMode | Show ExitCode | Show IOMode | Show Int8 | Show Int16 | Show Int32 | Show Int64 | Show Integer | (Integral a) => Show (Ratio a) | Show (ST s a) | Show () | (Show a) => Show [a] | Show Bool | Show Ordering | Show Char | Show Int | (Show a) => Show (Maybe a) | (Show a, Show b) => Show (Either a b) | (Show a, Show b) => Show (a, b) | (Show a, Show b, Show c) => Show (a, b, c) | (Show a, Show b, Show c, Show d) => Show (a, b, c, d) | (Show a, Show b, Show c, Show d, Show e) => Show (a, b, c, d, e) | Show Word | Show Word8 | Show Word16 | Show Word32 | Show Word64 | Show Permissions | Show TimeLocale | Show CDev | Show CIno | Show CMode | Show COff | Show CPid | Show CSsize | Show CGid | Show CNlink | Show CUid | Show CCc | Show CSpeed | Show CTcflag | Show CRLim | Show Fd | Show StdGen | Show ClockTime | Show Month | Show Day | Show CalendarTime | Show TimeDiff | Show Html | Show HtmlAttr | Show HtmlTable | Show HotLink | (Show a) => Show (BlockTable a) | Show ParseError | Show Doc | Show Lexeme | Show (a -> b) |
|
|
|
reads :: (Read a) => ReadS a |
|
shows :: (Show a) => a -> ShowS |
|
read :: (Read a) => String -> a |
|
lex :: ReadS String |
|
showChar :: Char -> ShowS |
|
showString :: String -> ShowS |
|
readParen :: Bool -> ReadS a -> ReadS a |
|
showParen :: Bool -> ShowS -> ShowS |
|
Simple I/O operations |
|
ioError :: IOError -> IO a |
|
userError :: String -> IOError |
|
catch :: IO a -> (IOError -> IO a) -> IO a |
|
type FilePath = String |
|
type IOError = IOException |
The Haskell 98 type for exceptions in the IO monad.
In Haskell 98, this is an opaque type. |
|
putChar :: Char -> IO () |
|
putStr :: String -> IO () |
|
putStrLn :: String -> IO () |
|
print :: (Show a) => a -> IO () |
|
getChar :: IO Char |
|
getLine :: IO String |
|
getContents :: IO String |
|
interact :: (String -> String) -> IO () |
|
readFile :: FilePath -> IO String |
|
writeFile :: FilePath -> String -> IO () |
|
appendFile :: FilePath -> String -> IO () |
|
readIO :: (Read a) => String -> IO a |
|
readLn :: (Read a) => IO a |
|
Monads |
|
class Monad m where |
The Monad class defines the basic operations over a monad.
Instances of Monad should satisfy the following laws: return a >>= k == k a
m >>= return == m
m >>= (\x -> k x >>= h) == (m >>= k) >>= h Instances of both Monad and Functor should additionally satisfy the law: fmap f xs == xs >>= return . f The instances of Monad for lists, Maybe and IO defined in the Prelude
satisfy these laws.
| | Methods | (>>=) :: m a -> (a -> m b) -> m b | | (>>) :: m a -> m b -> m b | | return :: a -> m a | | fail :: String -> m a |
| | Instances | |
|
|
class Functor f where |
The Functor class is used for types that can be mapped over.
Instances of Functor should satisfy the following laws: fmap id == id
fmap (f . g) == fmap f . fmap g The instances of Functor for lists, Maybe and IO defined in the Prelude
satisfy these laws.
| | Methods | fmap :: (a -> b) -> f a -> f b |
| | Instances | |
|
|
mapM :: (Monad m) => (a -> m b) -> [a] -> m [b] |
|
mapM_ :: (Monad m) => (a -> m b) -> [a] -> m () |
|
sequence :: (Monad m) => [m a] -> m [a] |
|
sequence_ :: (Monad m) => [m a] -> m () |
|
(=<<) :: (Monad m) => (a -> m b) -> m a -> m b |
|
Miscellaneous functions |
|
maybe :: b -> (a -> b) -> Maybe a -> b |
|
either :: (a -> c) -> (b -> c) -> Either a b -> c |
|
(&&) :: Bool -> Bool -> Bool |
Boolean "and" |
|
(||) :: Bool -> Bool -> Bool |
Boolean "or" |
|
not :: Bool -> Bool |
Boolean "not" |
|
otherwise :: Bool |
otherwise is defined as the value True. It helps to make
guards more readable. eg. f x | x < 0 = ...
| otherwise = ... |
|
subtract :: (Num a) => a -> a -> a |
|
even :: (Integral a) => a -> Bool |
|
odd :: (Integral a) => a -> Bool |
|
gcd :: (Integral a) => a -> a -> a |
|
lcm :: (Integral a) => a -> a -> a |
|
(^) :: (Num a, Integral b) => a -> b -> a |
|
(^^) :: (Fractional a, Integral b) => a -> b -> a |
|
fromIntegral :: (Integral a, Num b) => a -> b |
|
realToFrac :: (Real a, Fractional b) => a -> b |
|
fst :: (a, b) -> a |
|
snd :: (a, b) -> b |
|
curry :: ((a, b) -> c) -> a -> b -> c |
|
uncurry :: (a -> b -> c) -> (a, b) -> c |
|
id :: a -> a |
|
const :: a -> b -> a |
|
(.) :: (b -> c) -> (a -> b) -> a -> c |
|
flip :: (a -> b -> c) -> b -> a -> c |
|
($) :: (a -> b) -> a -> b |
|
until :: (a -> Bool) -> (a -> a) -> a -> a |
|
asTypeOf :: a -> a -> a |
|
error :: String -> a |
|
undefined :: a |
|
($!) :: (a -> b) -> a -> b |
|
Produced by Haddock version 0.4 |