Contents Index

Prelude

Documentation

_filter :: Bool -> ([a] -> [a]) -> [a] -> [a]

_foldr :: (a -> b -> b) -> [a] -> b -> b

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 -> [a] -> [a]

drop :: Int -> [a] -> [a]

splitAt :: Int -> [a] -> ([a], [a])

takeWhile :: (a -> Bool) -> [a] -> [a]

dropWhile :: (a -> Bool) -> [a] -> [a]

span :: (a -> Bool) -> [a] -> ([a], [a])

break :: (a -> Bool) -> [a] -> ([a], [a])

lines :: String -> [String]

words :: String -> [String]

unlines :: [String] -> String

unwords :: [String] -> String

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

sum :: Num a => [a] -> a

product :: Num a => [a] -> a

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])

type ReadS a = String -> [(a, String)]

type ShowS = String -> String

class Read a where

Methods readsPrec :: Int -> ReadS a readList :: ReadS [a] Instances Read All Read Any Read Bool Read BufferMode Read Char Read Double Read Float Read IOMode Read Int Read Integer Read Ordering Read SeekMode Read Word16 Read Word32 Read Word64 Read Word8 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 a, Read b, Read c, Read d, Read e, Read f) => Read (a, b, c, d, e, f) (Read a, Read b, Read c, Read d, Read e, Read f, Read g) => Read (a, b, c, d, e, f, g) (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h) => Read (a, b, c, d, e, f, g, h) (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i) => Read (a, b, c, d, e, f, g, h, i) (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j) => Read (a, b, c, d, e, f, g, h, i, j) (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k) => Read (a, b, c, d, e, f, g, h, i, j, k) (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k, Read l) => Read (a, b, c, d, e, f, g, h, i, j, k, l) (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k, Read l, Read m) => Read (a, b, c, d, e, f, g, h, i, j, k, l, m) (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k, Read l, Read m, Read n) => Read (a, b, c, d, e, f, g, h, i, j, k, l, m, n) (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k, Read l, Read m, Read n, Read o) => Read (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) Read a => Read (Maybe a) Read a => Read (Product a) (Read a, Ord a) => Read (Set a) Read a => Read (Sum a) Read a => Read [a] (Read a, Read b) => Read (Either a b) (Ord k, Read k, Read e) => Read (Map k e)

class Show a where

Methods showsPrec :: Int -> a -> ShowS show :: a -> String showList :: [a] -> ShowS showsType :: a -> ShowS Instances Show All Show Any Show Bool Show BufferMode Show Char Show Double Show Float Show Handle Show HandlePosn Show IOError Show IOMode Show InfoType Show Int Show Integer Show JsonNode Show Ordering Show ParseError Show SeekMode Show TypeRep Show Word16 Show Word32 Show Word64 Show Word8 Show () (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 a, Show b, Show c, Show d, Show e, Show f) => Show (a, b, c, d, e, f) (Show a, Show b, Show c, Show d, Show e, Show f, Show g) => Show (a, b, c, d, e, f, g) (Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h) => Show (a, b, c, d, e, f, g, h) (Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i) => Show (a, b, c, d, e, f, g, h, i) (Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j) => Show (a, b, c, d, e, f, g, h, i, j) (Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k) => Show (a, b, c, d, e, f, g, h, i, j, k) (Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l) => Show (a, b, c, d, e, f, g, h, i, j, k, l) (Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l, Show m) => Show (a, b, c, d, e, f, g, h, i, j, k, l, m) (Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l, Show m, Show n) => Show (a, b, c, d, e, f, g, h, i, j, k, l, m, n) (Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l, Show m, Show n, Show o) => Show (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) (Show a, Show b) => Show (a -> b) Show (FunPtr a) Show a => Show (IO a) Show a => Show (Maybe a) Show a => Show (Product a) Show (Ptr a) Show a => Show (Set a) Show a => Show (Sum a) Show a => Show [a] (Show a, Show b) => Show (Either a b) (Show k, Show a) => Show (Map k a)

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

showType :: Show a => a -> String

_readCon :: a -> String -> ReadS a

_readCon0 :: Bool -> a -> String -> ReadS a

_readField :: Read a => String -> String -> (String -> [(a -> b, String)]) -> ReadS b

_readConArg :: Read a => (String -> [(a -> b, String)]) -> ReadS b

_readConInfix :: (Read a, Read b) => Int -> Int -> Int -> Int -> (a -> b -> c) -> String -> ReadS c

type FilePath = String

data IOError

Constructors IOError String (Maybe String) (Maybe Handle) ErrNo EOFError String Handle PatternError String UserError String String Instances Eq IOError Show IOError

ioError :: IOError -> IO a

userError :: String -> IOError

catch :: IO a -> (IOError -> IO a) -> IO a

putChar :: Char -> IO ()

putStr :: String -> IO ()

putStrLn :: String -> IO ()

print :: Show a => a -> IO ()

getChar :: IO Char

getLine :: IO String

getContents :: IO [Char]

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

data Bool

Constructors True False Instances Bounded Bool Enum Bool Eq Bool Ord Bool Read Bool Show Bool Storable Bool

data Maybe a

Constructors Nothing Just a Instances Alternative Maybe Applicative Maybe Foldable Maybe Functor Maybe Monad Maybe MonadFix Maybe Traversable Maybe Eq a => Eq (Maybe a) Ord a => Ord (Maybe a) Read a => Read (Maybe a) Show a => Show (Maybe a)

data Either a b

Constructors Left a Right b Instances Functor (Either a) (Read a, Read b) => Read (Either a b) (Show a, Show b) => Show (Either a b)

data Ordering

Constructors LT EQ GT Instances Enum Ordering Eq Ordering Monoid Ordering Ord Ordering Read Ordering Show Ordering

type String = [Char]

type Rational = Ratio Integer

(%) :: Integral a => a -> a -> Ratio a

data [] a

Constructors [] (:) a [a] Instances Alternative [] Applicative [] Foldable [] Functor [] Monad [] MonadFix [] MonadPlus [] Traversable [] Eq a => Eq [a] Monoid [a] Ord a => Ord [a] Read a => Read [a] Show a => Show [a]

data ()

Constructors () Instances Eq () Ix () Monoid () Ord () Read () Show ()

data (,) a b

Constructors (,) a b Instances Monoid a => Applicative ((,) a) Functor ((,) a)

data (,,) a b c

Constructors (,,) a b c

data (,,,) a b c d

Constructors (,,,) a b c d

data (,,,,) a b c d e

Constructors (,,,,) a b c d e

data (,,,,,) a b c d e f

Constructors (,,,,,) a b c d e f

data (,,,,,,) a b c d e f g

Constructors (,,,,,,) a b c d e f g

data (,,,,,,,) a b c d e f g h

Constructors (,,,,,,,) a b c d e f g h

data (,,,,,,,,) a b c d e f g h i

Constructors (,,,,,,,,) a b c d e f g h i

data (,,,,,,,,,) a b c d e f g h i j

Constructors (,,,,,,,,,) a b c d e f g h i j

data (,,,,,,,,,,) a b c d e f g h i j k

Constructors (,,,,,,,,,,) a b c d e f g h i j k

data (,,,,,,,,,,,) a b c d e f g h i j k l

Constructors (,,,,,,,,,,,) a b c d e f g h i j k l

data (,,,,,,,,,,,,) a b c d e f g h i j k l m

Constructors (,,,,,,,,,,,,) a b c d e f g h i j k l m

data (,,,,,,,,,,,,,) a b c d e f g h i j k l m n

Constructors (,,,,,,,,,,,,,) a b c d e f g h i j k l m n

data (,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o

Constructors (,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o

data (,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p

Constructors (,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p

data (,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q

Constructors (,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q

data (,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r

Constructors (,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r

data (,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s

Constructors (,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s

data (,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t

Constructors (,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t

->

class Eq a where

Methods (==) :: a -> a -> Bool (/=) :: a -> a -> Bool Instances Eq All Eq Any Eq Bool Eq BufferMode Eq Char Eq ConstItemType Eq Double Eq Float Eq Handle Eq HandleError Eq HandlePosn Eq IOError Eq IOMode Eq InfoType Eq Int Eq Integer Eq Message Eq Ordering Eq PackedString Eq ParseError Eq SeekMode Eq Word16 Eq Word32 Eq Word64 Eq Word8 Eq () (Eq a, Eq b) => Eq (a, b) (Eq a, Eq b, Eq c) => Eq (a, b, c) Eq (ForeignPtr a) Eq (FunPtr a) Eq a => Eq (Maybe a) Eq a => Eq (Product a) Eq (Ptr a) Eq a => Eq (Set a) Eq a => Eq (Sum a) Eq a => Eq [a] (Eq k, Eq a) => Eq (Map k a)

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 All Ord Any Ord Bool Ord BufferMode Ord Char Ord Double Ord Float Ord IOMode Ord Int Ord Integer Ord Ordering Ord PackedString Ord ParseError Ord SeekMode Ord Word16 Ord Word32 Ord Word64 Ord Word8 Ord () (Ord a, Ord b) => Ord (a, b) (Ord a, Ord b, Ord c) => Ord (a, b, c) Ord (ForeignPtr a) Ord (FunPtr a) Ord a => Ord (Maybe a) Ord a => Ord (Product a) Ord (Ptr a) Ord a => Ord (Set a) Ord a => Ord (Sum a) Ord a => Ord [a] (Ord k, Ord v) => Ord (Map k v)

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 Enum Bool Enum BufferMode Enum Char Enum ConstItemType Enum Double Enum Float Enum HandleError Enum IOMode Enum InfoType Enum Int Enum Integer Enum Ordering Enum SeekMode Enum Word16 Enum Word32 Enum Word64 Enum Word8 Enum (Ptr a)

class Bounded a where

Methods minBound :: a maxBound :: a Instances Bounded All Bounded Any Bounded Bool Bounded IOMode Bounded Int Bounded SeekMode Bounded Word16 Bounded Word32 Bounded Word64 Bounded Word8 (Bounded a, Bounded b) => Bounded (a, b) (Bounded a, Bounded b, Bounded c) => Bounded (a, b, c) Bounded a => Bounded (Product a) Bounded a => Bounded (Sum a)

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 Num Double Num Float Num Int Num Integer Num Word16 Num Word32 Num Word64 Num Word8

class (Num a, Ord a) => Real a where

Methods toRational :: a -> Rational Instances Real Double Real Float Real Int Real Integer Real Word16 Real Word32 Real Word64 Real Word8

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 Integral Int Integral Integer Integral Word16 Integral Word32 Integral Word64 Integral Word8

class Num a => Fractional a where

Methods (/) :: a -> a -> a recip :: a -> a fromRational :: Rational -> a Instances Fractional Double Fractional Float

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 Floating Double Floating Float

class (Real a, Fractional a) => RealFrac a where

Methods properFraction :: Integral b => a -> (b, a) truncate :: Integral b => a -> b round :: Integral b => a -> b ceiling :: Integral b => a -> b floor :: Integral b => a -> b Instances RealFrac Double RealFrac Float

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 RealFloat Double RealFloat Float

class Monad m where

Methods (>>=) :: m a -> (a -> m b) -> m b (>>) :: m a -> m b -> m b return :: a -> m a fail :: String -> m a Instances Monad IO Monad Maybe Monad [] Monad ((->) r)

class Functor f where

Methods fmap :: (a -> b) -> f a -> f b Instances Functor IO Functor Id Functor Maybe Functor ZipList Functor [] Functor (Const m) Functor (Either a) Functor (Map k) Monad m => Functor (WrappedMonad m) Functor ((,) a) Functor ((->) r) Arrow a => Functor (WrappedArrow a 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

numericEnumFrom :: Fractional a => a -> [a]

numericEnumFromTo :: (Fractional a, Ord a) => a -> a -> [a]

numericEnumFromThen :: Fractional a => a -> a -> [a]

numericEnumFromThenTo :: (Fractional a, Ord a) => a -> a -> a -> [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

seq :: a -> b -> b

($!) :: (a -> b) -> a -> b

_seq :: a -> b -> b

_filter :: Bool -> ([a] -> [a]) -> [a] -> [a]

_foldr :: (a -> b -> b) -> [a] -> b -> b

_fromEnum :: a -> Int

_toEnum :: Int -> a

_enumFromTo :: a -> Int -> [a]

_enumFromThen :: a -> a -> Int -> [a]

_enumFromThenTo :: a -> a -> Int -> [a]

_enumIndex :: String -> (a, a) -> a -> Int

_enumRange :: (a, a) -> [a]

_enumInRange :: (a, a) -> a -> Bool

Produced by Haddock version 0.8