| Haskell Hierarchical Libraries (base package) | Contents | Index

GHC.List

Portability | non-portable (GHC Extensions)
Stability | internal
Maintainer | cvs-ghc@haskell.org

Description
The List data type and its operations
Synopsis

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])
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])
takeUInt_append :: Int# -> [b] -> [b] -> [b]

Documentation
map :: (a -> b) -> [a] -> [b]

`map` `f xs` is the list obtained by applying `f` to each element of `xs`, i.e.,

     map f [x1, x2, ..., xn] == [f x1, f x2, ..., f xn]
     map f [x1, x2, ...] == [f x1, f x2, ...]

(++) :: [a] -> [a] -> [a]

Append two lists, i.e.,

     [x1, ..., xm] ++ [y1, ..., yn] == [x1, ..., xm, y1, ..., yn]
     [x1, ..., xm] ++ [y1, ...] == [x1, ..., xm, y1, ...]

If the first list is not finite, the result is the first list.

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

`filter`, applied to a predicate and a list, returns the list of those elements that satisfy the predicate; i.e.,

     filter p xs = [ x | x <- xs, p x]

concat :: [[a]] -> [a]
Concatenate a list of lists.
head :: [a] -> a
Extract the first element of a list, which must be non-empty.
last :: [a] -> a
Extract the last element of a list, which must be finite and non-empty.
tail :: [a] -> [a]
Extract the elements after the head of a list, which must be non-empty.
init :: [a] -> [a]
Return all the elements of a list except the last one. The list must be finite and non-empty.
null :: [a] -> Bool
Test whether a list is empty.
length :: [a] -> Int
`length` returns the length of a finite list as an `Int`. It is an instance of the more general `genericLength`, the result type of which may be any kind of number.
(!!) :: [a] -> Int -> a
List index (subscript) operator, starting from 0. It is an instance of the more general `genericIndex`, which takes an index of any integral type.
foldl :: (a -> b -> a) -> a -> [b] -> a

`foldl`, applied to a binary operator, a starting value (typically the left-identity of the operator), and a list, reduces the list using the binary operator, from left to right:

     foldl f z [x1, x2, ..., xn] == (...((z `f` x1) `f` x2) `f`...) `f` xn

The list must be finite.

foldl1 :: (a -> a -> a) -> [a] -> a
`foldl1` is a variant of `foldl` that has no starting value argument, and thus must be applied to non-empty lists.
scanl :: (a -> b -> a) -> a -> [b] -> [a]

`scanl` is similar to `foldl`, but returns a list of successive reduced values from the left:

     scanl f z [x1, x2, ...] == [z, z `f` x1, (z `f` x1) `f` x2, ...]

Note that

     last (scanl f z xs) == foldl f z xs.

scanl1 :: (a -> a -> a) -> [a] -> [a]

`scanl1` is a variant of `scanl` that has no starting value argument:

     scanl1 f [x1, x2, ...] == [x1, x1 `f` x2, ...]

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

`foldr`, applied to a binary operator, a starting value (typically the right-identity of the operator), and a list, reduces the list using the binary operator, from right to left:

     foldr f z [x1, x2, ..., xn] == x1 `f` (x2 `f` ... (xn `f` z)...)

foldr1 :: (a -> a -> a) -> [a] -> a
`foldr1` is a variant of `foldr` that has no starting value argument, and thus must be applied to non-empty lists.
scanr :: (a -> b -> b) -> b -> [a] -> [b]

`scanr` is the right-to-left dual of `scanl`. Note that

     head (scanr f z xs) == foldr f z xs.

scanr1 :: (a -> a -> a) -> [a] -> [a]
`scanr1` is a variant of `scanr` that has no starting value argument.
iterate :: (a -> a) -> a -> [a]

`iterate` `f x` returns an infinite list of repeated applications of `f` to `x`:

     iterate f x == [x, f x, f (f x), ...]

repeat :: a -> [a]
`repeat` `x` is an infinite list, with `x` the value of every element.
replicate :: Int -> a -> [a]
`replicate` `n x` is a list of length `n` with `x` the value of every element. It is an instance of the more general `genericReplicate`, in which `n` may be of any integral type.
cycle :: [a] -> [a]
`cycle` ties a finite list into a circular one, or equivalently, the infinite repetition of the original list. It is the identity on infinite lists.
take :: Int -> [a] -> [a]
`take` `n`, applied to a list `xs`, returns the prefix of `xs` of length `n`, or `xs` itself if `n > `length` xs`. It is an instance of the more general `genericTake`, in which `n` may be of any integral type.
drop :: Int -> [a] -> [a]
`drop` `n xs` returns the suffix of `xs` after the first `n` elements, or `[]` if `n > `length` xs`. It is an instance of the more general `genericDrop`, in which `n` may be of any integral type.
splitAt :: Int -> [a] -> ([a], [a])
`splitAt` `n xs` is equivalent to `(`take` n xs, `drop` n xs)`. It is an instance of the more general `genericSplitAt`, in which `n` may be of any integral type.
takeWhile :: (a -> Bool) -> [a] -> [a]
`takeWhile`, applied to a predicate `p` and a list `xs`, returns the longest prefix (possibly empty) of `xs` of elements that satisfy `p`.
dropWhile :: (a -> Bool) -> [a] -> [a]
`dropWhile` `p xs` returns the suffix remaining after `takeWhile` `p xs`.
span :: (a -> Bool) -> [a] -> ([a], [a])
`span` `p xs` is equivalent to `(`takeWhile` p xs, `dropWhile` p xs)`
break :: (a -> Bool) -> [a] -> ([a], [a])
`break` `p` is equivalent to ``span` (`not` . p)`.
reverse :: [a] -> [a]
`reverse` `xs` returns the elements of `xs` in reverse order. `xs` must be finite.
and :: [Bool] -> Bool
`and` returns the conjunction of a Boolean list. For the result to be `True`, the list must be finite; `False`, however, results from a `False` value at a finite index of a finite or infinite list.
or :: [Bool] -> Bool
`or` returns the disjunction of a Boolean list. For the result to be `False`, the list must be finite; `True`, however, results from a `True` value at a finite index of a finite or infinite list.
any :: (a -> Bool) -> [a] -> Bool
Applied to a predicate and a list, `any` determines if any element of the list satisfies the predicate.
all :: (a -> Bool) -> [a] -> Bool
Applied to a predicate and a list, `all` determines if all elements of the list satisfy the predicate.
elem :: Eq a => a -> [a] -> Bool
`elem` is the list membership predicate, usually written in infix form, e.g., `x `elem` xs`.
notElem :: Eq a => a -> [a] -> Bool
`notElem` is the negation of `elem`.
lookup :: Eq a => a -> [(a, b)] -> Maybe b
`lookup` `key assocs` looks up a key in an association list.
maximum :: Ord a => [a] -> a
`maximum` returns the maximum value from a list, which must be non-empty, finite, and of an ordered type. It is a special case of `maximumBy`, which allows the programmer to supply their own comparison function.
minimum :: Ord a => [a] -> a
`minimum` returns the minimum value from a list, which must be non-empty, finite, and of an ordered type. It is a special case of `minimumBy`, which allows the programmer to supply their own comparison function.
concatMap :: (a -> [b]) -> [a] -> [b]
Map a function over a list and concatenate the results.
zip :: [a] -> [b] -> [(a, b)]
`zip` takes two lists and returns a list of corresponding pairs. If one input list is short, excess elements of the longer list are discarded.
zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]
`zip3` takes three lists and returns a list of triples, analogous to `zip`.
zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
`zipWith` generalises `zip` by zipping with the function given as the first argument, instead of a tupling function. For example, ``zipWith` (+)` is applied to two lists to produce the list of corresponding sums.
zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
The `zipWith3` function takes a function which combines three elements, as well as three lists and returns a list of their point-wise combination, analogous to `zipWith`.
unzip :: [(a, b)] -> ([a], [b])
`unzip` transforms a list of pairs into a list of first components and a list of second components.
unzip3 :: [(a, b, c)] -> ([a], [b], [c])
The `unzip3` function takes a list of triples and returns three lists, analogous to `unzip`.
takeUInt_append :: Int# -> [b] -> [b] -> [b]
Produced by Haddock version 0.6