Safe Haskell | Safe |
---|---|

Language | Haskell98 |

- elemIndex :: Eq a => a -> [a] -> Maybe Int
- elemIndices :: Eq a => a -> [a] -> [Int]
- find :: (a -> Bool) -> [a] -> Maybe a
- findIndex :: (a -> Bool) -> [a] -> Maybe Int
- findIndices :: (a -> Bool) -> [a] -> [Int]
- nub :: Eq a => [a] -> [a]
- nubBy :: (a -> a -> Bool) -> [a] -> [a]
- delete :: Eq a => a -> [a] -> [a]
- deleteBy :: (a -> a -> Bool) -> a -> [a] -> [a]
- (\\) :: Eq a => [a] -> [a] -> [a]
- deleteFirstsBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
- union :: Eq a => [a] -> [a] -> [a]
- unionBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
- intersect :: Eq a => [a] -> [a] -> [a]
- intersectBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
- intersperse :: a -> [a] -> [a]
- transpose :: [[a]] -> [[a]]
- partition :: (a -> Bool) -> [a] -> ([a], [a])
- group :: Eq a => [a] -> [[a]]
- groupBy :: (a -> a -> Bool) -> [a] -> [[a]]
- inits :: [a] -> [[a]]
- tails :: [a] -> [[a]]
- isPrefixOf :: Eq a => [a] -> [a] -> Bool
- isSuffixOf :: Eq a => [a] -> [a] -> Bool
- mapAccumL :: (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])
- mapAccumR :: (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])
- sort :: Ord a => [a] -> [a]
- sortBy :: (a -> a -> Ordering) -> [a] -> [a]
- insert :: Ord a => a -> [a] -> [a]
- insertBy :: (a -> a -> Ordering) -> a -> [a] -> [a]
- maximumBy :: (a -> a -> Ordering) -> [a] -> a
- minimumBy :: (a -> a -> Ordering) -> [a] -> a
- genericLength :: Num i => [a] -> i
- genericTake :: Integral i => i -> [a] -> [a]
- genericDrop :: Integral i => i -> [a] -> [a]
- genericSplitAt :: Integral i => i -> [a] -> ([a], [a])
- genericIndex :: Integral i => [a] -> i -> a
- genericReplicate :: Integral i => i -> a -> [a]
- zip4 :: [a] -> [b] -> [c] -> [d] -> [(a, b, c, d)]
- zip5 :: [a] -> [b] -> [c] -> [d] -> [e] -> [(a, b, c, d, e)]
- zip6 :: [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [(a, b, c, d, e, f)]
- zip7 :: [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [(a, b, c, d, e, f, g)]
- zipWith4 :: (a -> b -> c -> d -> e) -> [a] -> [b] -> [c] -> [d] -> [e]
- zipWith5 :: (a -> b -> c -> d -> e -> f) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f]
- zipWith6 :: (a -> b -> c -> d -> e -> f -> g) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g]
- zipWith7 :: (a -> b -> c -> d -> e -> f -> g -> h) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [h]
- unzip4 :: [(a, b, c, d)] -> ([a], [b], [c], [d])
- unzip5 :: [(a, b, c, d, e)] -> ([a], [b], [c], [d], [e])
- unzip6 :: [(a, b, c, d, e, f)] -> ([a], [b], [c], [d], [e], [f])
- unzip7 :: [(a, b, c, d, e, f, g)] -> ([a], [b], [c], [d], [e], [f], [g])
- unfoldr :: (b -> Maybe (a, b)) -> b -> [a]
- map :: (a -> b) -> [a] -> [b]
- (++) :: [a] -> [a] -> [a]
- concat :: [[a]] -> [a]
- filter :: (a -> Bool) -> [a] -> [a]
- head :: [a] -> a
- last :: [a] -> a
- tail :: [a] -> [a]
- init :: [a] -> [a]
- null :: [a] -> Bool
- length :: [a] -> Int
- (!!) :: [a] -> Int -> a
- foldl :: (b -> a -> b) -> b -> [a] -> b
- foldl1 :: (a -> a -> a) -> [a] -> a
- scanl :: (b -> a -> b) -> b -> [a] -> [b]
- 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])

# Documentation

elemIndices :: Eq a => a -> [a] -> [Int] Source

The `elemIndices`

function extends `elemIndex`

, by returning the
indices of all elements equal to the query element, in ascending order.

findIndices :: (a -> Bool) -> [a] -> [Int] Source

The `findIndices`

function extends `findIndex`

, by returning the
indices of all elements satisfying the predicate, in ascending order.

(\\) :: Eq a => [a] -> [a] -> [a] infix 5 Source

The `\\`

function is list difference (non-associative).
In the result of `xs`

`\\`

`ys`

, the first occurrence of each element of
`ys`

in turn (if any) has been removed from `xs`

. Thus

(xs ++ ys) \\ xs == ys.

It is a special case of `deleteFirstsBy`

, which allows the programmer
to supply their own equality test.

deleteFirstsBy :: (a -> a -> Bool) -> [a] -> [a] -> [a] Source

The `deleteFirstsBy`

function takes a predicate and two lists and
returns the first list with the first occurrence of each element of
the second list removed.

union :: Eq a => [a] -> [a] -> [a] Source

The `union`

function returns the list union of the two lists.
For example,

"dog" `union` "cow" == "dogcw"

Duplicates, and elements of the first list, are removed from the
the second list, but if the first list contains duplicates, so will
the result.
It is a special case of `unionBy`

, which allows the programmer to supply
their own equality test.

intersect :: Eq a => [a] -> [a] -> [a] Source

The `intersect`

function takes the list intersection of two lists.
For example,

[1,2,3,4] `intersect` [2,4,6,8] == [2,4]

If the first list contains duplicates, so will the result.

[1,2,2,3,4] `intersect` [6,4,4,2] == [2,2,4]

It is a special case of `intersectBy`

, which allows the programmer to
supply their own equality test. If the element is found in both the first
and the second list, the element from the first list will be used.

intersectBy :: (a -> a -> Bool) -> [a] -> [a] -> [a] Source

The `intersectBy`

function is the non-overloaded version of `intersect`

.

intersperse :: a -> [a] -> [a] Source

The `intersperse`

function takes an element and a list and
`intersperses' that element between the elements of the list.
For example,

intersperse ',' "abcde" == "a,b,c,d,e"

transpose :: [[a]] -> [[a]] Source

The `transpose`

function transposes the rows and columns of its argument.
For example,

transpose [[1,2,3],[4,5,6]] == [[1,4],[2,5],[3,6]]

partition :: (a -> Bool) -> [a] -> ([a], [a]) Source

The `partition`

function takes a predicate a list and returns
the pair of lists of elements which do and do not satisfy the
predicate, respectively; i.e.,

partition p xs == (filter p xs, filter (not . p) xs)

group :: Eq a => [a] -> [[a]] Source

The `group`

function takes a list and returns a list of lists such
that the concatenation of the result is equal to the argument. Moreover,
each sublist in the result contains only equal elements. For example,

group "Mississippi" = ["M","i","ss","i","ss","i","pp","i"]

It is a special case of `groupBy`

, which allows the programmer to supply
their own equality test.

isPrefixOf :: Eq a => [a] -> [a] -> Bool Source

The `isPrefixOf`

function takes two lists and returns `True`

iff the first list is a prefix of the second.

isSuffixOf :: Eq a => [a] -> [a] -> Bool Source

The `isSuffixOf`

function takes two lists and returns `True`

iff the first list is a suffix of the second.
Both lists must be finite.

insert :: Ord a => a -> [a] -> [a] Source

The `insert`

function takes an element and a list and inserts the
element into the list at the first position where it is less
than or equal to the next element. In particular, if the list
is sorted before the call, the result will also be sorted.
It is a special case of `insertBy`

, which allows the programmer to
supply their own comparison function.

maximumBy :: (a -> a -> Ordering) -> [a] -> a Source

The `maximumBy`

function takes a comparison function and a list
and returns the greatest element of the list by the comparison function.
The list must be finite and non-empty.

minimumBy :: (a -> a -> Ordering) -> [a] -> a Source

The `minimumBy`

function takes a comparison function and a list
and returns the least element of the list by the comparison function.
The list must be finite and non-empty.

genericLength :: Num i => [a] -> i Source

The `genericLength`

function is an overloaded version of `length`

. In
particular, instead of returning an `Int`

, it returns any type which is
an instance of `Num`

. It is, however, less efficient than `length`

.

genericTake :: Integral i => i -> [a] -> [a] Source

The `genericTake`

function is an overloaded version of `take`

, which
accepts any `Integral`

value as the number of elements to take.

genericDrop :: Integral i => i -> [a] -> [a] Source

The `genericDrop`

function is an overloaded version of `drop`

, which
accepts any `Integral`

value as the number of elements to drop.

genericSplitAt :: Integral i => i -> [a] -> ([a], [a]) Source

The `genericSplitAt`

function is an overloaded version of `splitAt`

, which
accepts any `Integral`

value as the position at which to split.

genericIndex :: Integral i => [a] -> i -> a Source

The `genericIndex`

function is an overloaded version of `!!`

, which
accepts any `Integral`

value as the index.

genericReplicate :: Integral i => i -> a -> [a] Source

The `genericReplicate`

function is an overloaded version of `replicate`

,
which accepts any `Integral`

value as the number of repetitions to make.

zipWith6 :: (a -> b -> c -> d -> e -> f -> g) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] Source

zipWith7 :: (a -> b -> c -> d -> e -> f -> g -> h) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [h] Source

unfoldr :: (b -> Maybe (a, b)) -> b -> [a] Source

The `unfoldr`

function is a `dual' to `foldr`

: while `foldr`

reduces a list to a summary value, `unfoldr`

builds a list from
a seed value. The function takes the element and returns `Nothing`

if it is done producing the list or returns `Just`

`(a,b)`

, in which
case, `a`

is a prepended to the list and `b`

is used as the next
element in a recursive call. For example,

iterate f == unfoldr (\x -> Just (x, f x))

In some cases, `unfoldr`

can undo a `foldr`

operation:

unfoldr f' (foldr f z xs) == xs

if the following holds:

f' (f x y) = Just (x,y) f' z = Nothing

A simple use of unfoldr:

unfoldr (\b -> if b == 0 then Nothing else Just (b, b-1)) 10 [10,9,8,7,6,5,4,3,2,1]

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] infixr 5 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 :: (a -> Bool) -> [a] -> [a] Source

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

Return all the elements of a list except the last one. The list must be non-empty.

*O(n)*. `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 infixl 9 Source

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 :: (b -> a -> b) -> b -> [a] -> b 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.

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

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

replicate :: Int -> a -> [a] Source

`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`

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

`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 `genericTake`

,
in which `n`

may be of any integral type.

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

`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 `genericDrop`

,
in which `n`

may be of any integral type.

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

`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 `genericSplitAt`

,
in which `n`

may be of any integral type.

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

`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] == []

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

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

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

`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],[])

lines :: String -> [String] Source

`lines`

breaks a string up into a list of strings at newline
characters. The resulting strings do not contain newlines.

words :: String -> [String] Source

`words`

breaks a string up into a list of words, which were delimited
by white space.

`reverse`

`xs`

returns the elements of `xs`

in reverse order.
`xs`

must be finite.

lookup :: Eq a => a -> [(a, b)] -> Maybe b Source

`lookup`

`key assocs`

looks up a key in an association list.

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

The `product`

function computes the product of a finite list of numbers.

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.