|
| 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 | | | 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 | | | 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]) | | | errorEmptyList :: String -> a | | | takeUInt_append :: Int# -> [b] -> [b] -> [b] |
|
|
| Documentation |
|
| map :: (a -> b) -> [a] -> [b] | Source |
|
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] | Source |
|
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, 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]
|
|
|
| Concatenate a list of lists.
|
|
|
| Extract the first element of a list, which must be non-empty.
|
|
|
| Extract the last element of a list, which must be finite and non-empty.
|
|
|
| Extract the elements after the head of a list, which must be non-empty.
|
|
|
| Return all the elements of a list except the last one.
The list must be finite and non-empty.
|
|
|
| Test whether a list is empty.
|
|
|
| length returns the length of a finite list as an Int.
It is an instance of the more general Data.List.genericLength,
the result type of which may be any kind of number.
|
|
|
| List index (subscript) operator, starting from 0.
It is an instance of the more general Data.List.genericIndex,
which takes an index of any integral type.
|
|
| foldl :: (a -> b -> a) -> a -> [b] -> a | Source |
|
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.
|
|
| scanl :: (a -> b -> a) -> a -> [b] -> [a] | Source |
|
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] | Source |
|
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 | Source |
|
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 | Source |
|
| 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] | Source |
|
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] | Source |
|
| scanr1 is a variant of scanr that has no starting value argument.
|
|
| iterate :: (a -> a) -> a -> [a] | Source |
|
iterate f x returns an infinite list of repeated applications
of f to x:
iterate f x == [x, f x, f (f x), ...]
|
|
|
| repeat x is an infinite list, with x the value of every element.
|
|
|
| replicate n x is a list of length n with x the value of
every element.
It is an instance of the more general Data.List.genericReplicate,
in which n may be of any integral type.
|
|
|
| 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 n, applied to a list xs, returns the prefix of xs
of length n, or xs itself if n > length xs:
take 5 "Hello World!" == "Hello"
take 3 [1,2,3,4,5] == [1,2,3]
take 3 [1,2] == [1,2]
take 3 [] == []
take (-1) [1,2] == []
take 0 [1,2] == []
It is an instance of the more general Data.List.genericTake,
in which n may be of any integral type.
|
|
|
drop n xs returns the suffix of xs
after the first n elements, or [] if n > length xs:
drop 6 "Hello World!" == "World!"
drop 3 [1,2,3,4,5] == [4,5]
drop 3 [1,2] == []
drop 3 [] == []
drop (-1) [1,2] == [1,2]
drop 0 [1,2] == [1,2]
It is an instance of the more general Data.List.genericDrop,
in which n may be of any integral type.
|
|
|
splitAt n xs returns a tuple where first element is xs prefix of
length n and second element is the remainder of the list:
splitAt 6 "Hello World!" == ("Hello ","World!")
splitAt 3 [1,2,3,4,5] == ([1,2,3],[4,5])
splitAt 1 [1,2,3] == ([1],[2,3])
splitAt 3 [1,2,3] == ([1,2,3],[])
splitAt 4 [1,2,3] == ([1,2,3],[])
splitAt 0 [1,2,3] == ([],[1,2,3])
splitAt (-1) [1,2,3] == ([],[1,2,3])
It is equivalent to (take n xs, drop n xs).
splitAt is an instance of the more general Data.List.genericSplitAt,
in which n may be of any integral type.
|
|
|
takeWhile, applied to a predicate p and a list xs, returns the
longest prefix (possibly empty) of xs of elements that satisfy p:
takeWhile (< 3) [1,2,3,4,1,2,3,4] == [1,2]
takeWhile (< 9) [1,2,3] == [1,2,3]
takeWhile (< 0) [1,2,3] == []
|
|
|
dropWhile p xs returns the suffix remaining after takeWhile p xs:
dropWhile (< 3) [1,2,3,4,5,1,2,3] == [3,4,5,1,2,3]
dropWhile (< 9) [1,2,3] == []
dropWhile (< 0) [1,2,3] == [1,2,3]
|
|
|
span, applied to a predicate p and a list xs, returns a tuple where
first element is longest prefix (possibly empty) of xs of elements that
satisfy p and second element is the remainder of the list:
span (< 3) [1,2,3,4,1,2,3,4] == ([1,2],[3,4,1,2,3,4])
span (< 9) [1,2,3] == ([1,2,3],[])
span (< 0) [1,2,3] == ([],[1,2,3])
span p xs is equivalent to (takeWhile p xs, dropWhile p xs)
|
|
|
break, applied to a predicate p and a list xs, returns a tuple where
first element is longest prefix (possibly empty) of xs of elements that
do not satisfy p and second element is the remainder of the list:
break (> 3) [1,2,3,4,1,2,3,4] == ([1,2,3],[4,1,2,3,4])
break (< 9) [1,2,3] == ([],[1,2,3])
break (> 9) [1,2,3] == ([1,2,3],[])
break p is equivalent to span (not . p).
|
|
|
| reverse xs returns the elements of xs in reverse order.
xs must be finite.
|
|
|
| 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 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.
|
|
|
| Applied to a predicate and a list, any determines if any element
of the list satisfies the predicate.
|
|
|
| Applied to a predicate and a list, all determines if all elements
of the list satisfy the predicate.
|
|
|
| elem is the list membership predicate, usually written in infix form,
e.g., x `elem` xs.
|
|
|
| notElem is the negation of elem.
|
|
|
| lookup key assocs looks up a key in an association list.
|
|
| concatMap :: (a -> [b]) -> [a] -> [b] | Source |
|
| Map a function over a list and concatenate the results.
|
|
| zip :: [a] -> [b] -> [(a, b)] | Source |
|
| 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)] | Source |
|
| zip3 takes three lists and returns a list of triples, analogous to
zip.
|
|
| zipWith :: (a -> b -> c) -> [a] -> [b] -> [c] | Source |
|
| 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] | Source |
|
| 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]) | Source |
|
| 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]) | Source |
|
| The unzip3 function takes a list of triples and returns three
lists, analogous to unzip.
|
|
|
|
| takeUInt_append :: Int# -> [b] -> [b] -> [b] | Source |
|
|
| Produced by Haddock version 2.0.0.0 |
