GHC.List

Copyright	(c) The University of Glasgow 1994-2002
License	see libraries/base/LICENSE
Maintainer	cvs-ghc@haskell.org
Stability	internal
Portability	non-portable (GHC Extensions)
Safe Haskell	Trustworthy
Language	Haskell2010

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

\(\mathcal{O}(n)\). 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, ...]

>>> map (+1) [1, 2, 3]

(++) :: [a] -> [a] -> [a] infixr 5 Source

Добавление двух списков, т.е.

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

Если первый список не конечен, результатом является первый список.

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

\(\mathcal{O}(n)\). 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]

>>> filter odd [1, 2, 3]
[1,3]

concat :: [[a]] -> [a] Source

Конкатенация списка списков.

head :: [a] -> a Source

\(\mathcal{O}(1)\). Извлечение первого элемента списка, который должен быть непустым.

last :: [a] -> a Source

\(\mathcal{O}(n)\). Извлечение последнего элемента списка, который должен быть конечным и непустым.

tail :: [a] -> [a] Source

\(\mathcal{O}(1)\). Извлечение элементов после первого элемента списка, который должен быть непустым.

init :: [a] -> [a] Source

\(\mathcal{O}(n)\). Возвращает все элементы списка, кроме последнего. Список должен быть непустым.

uncons :: [a] -> Maybe (a, [a]) Source

\(\mathcal{O}(1)\). Разложение списка на его первый элемент и хвост. Если список пуст, возвращает Nothing. Если список непустой, возвращает Just (x, xs), где x is the head of the list and xs its tail.

Since: base-4.8.0.0

null :: [a] -> Bool Source

\(\mathcal{O}(1)\). Проверка, является ли список пустым.

length :: [a] -> Int Source

\(\mathcal{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

Оператор индексации (подстроки) списка, начиная с 0. Это экземпляр более общего genericIndex, который принимает индекс любого целочисленного типа.

foldl :: forall a b. (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

Список должен быть конечным.

foldl' :: forall a b. (b -> a -> b) -> b -> [a] -> b Source

Строгая версия foldl.

foldl1 :: (a -> a -> a) -> [a] -> a Source

foldl1 is a variant of foldl that has no starting value argument, and thus must be applied to non-empty lists.

foldl1' :: (a -> a -> a) -> [a] -> a Source

Строгая версия foldl1

scanl :: (b -> a -> b) -> b -> [a] -> [b] Source

\(\mathcal{O}(n)\). 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, ...]

Обратите внимание, что

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

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

\(\mathcal{O}(n)\). scanl1 is a variant of scanl that has no starting value argument:

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

scanl' :: (b -> a -> b) -> b -> [a] -> [b] Source

\(\mathcal{O}(n)\). Строгая накапливающая версия scanl

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

\(\mathcal{O}(n)\). 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

\(\mathcal{O}(n)\). 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), ...]

Обратите внимание, что iterate is lazy, potentially leading to thunk build-up if the consumer doesn't force each iterate. See iterate' for a strict variant of this function.

iterate' :: (a -> a) -> a -> [a] Source

iterate' is the strict version of iterate.

Это гарантирует, что результат каждого применения приводится к слабой головной нормальной форме перед продолжением.

repeat :: a -> [a] Source

repeat x is an infinite list, with x the value of every element.

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

replicate n x представляет собой список длиной n с x значением каждого элемента. Он является экземпляром более общего genericReplicate, в котором n может быть любого целочисленного типа.

cycle :: [a] -> [a] Source

cycle связывает конечный список в циклический, или, что эквивалентно, бесконечное повторение исходного списка. Это тождество для бесконечных списков.

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

take n, применённый к списку xs, возвращает префикс xs длиной n, или xs сам по себе, если 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] == []

Он является экземпляром более общего genericTake, в котором n может быть любого целочисленного типа.

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

drop n xs возвращает суффикс xs после первых n элементов, или [], если 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]

Он является экземпляром более общего genericDrop, в котором n может быть любого целочисленного типа.

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

Функция sum вычисляет сумму конечного списка чисел.

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

Функция product вычисляет произведение конечного списка чисел.

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

maximum возвращает максимальное значение из списка, который должен быть непустым, конечным и упорядоченного типа. Это частный случай maximumBy, который позволяет программисту указать свою собственную функцию сравнения.

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

minimum возвращает минимальное значение из списка, который должен быть непустым, конечным и упорядоченного типа. Это частный случай minimumBy, который позволяет программисту указать свою собственную функцию сравнения.

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

splitAt n xs возвращает кортеж, где первый элемент - это xs префикс длиной n, а второй элемент - остаток списка:

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

Он эквивалентен (take n xs, drop n xs), когда n не _|_ (splitAt _|_ xs = _|_). splitAt является экземпляром более общего genericSplitAt, в котором n может быть любого целочисленного типа.

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

takeWhile, применённый к предикату p и списку xs, возвращает самый длинный префикс (возможно, пустой) xs элементов, которые удовлетворяют 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 :: (a -> Bool) -> [a] -> [a] Source

dropWhile p xs возвращает оставшийся суффикс после 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 :: (a -> Bool) -> [a] -> ([a], [a]) Source

span, применённый к предикату p и списку xs, возвращает кортеж, где первый элемент - это самый длинный префикс (возможно, пустой) xs элементов, которые удовлетворяют p, а второй элемент - остаток списка:

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 эквивалентен (takeWhile p xs, dropWhile p xs)

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

break, применённый к предикату p и списку xs, возвращает кортеж, где первый элемент - это самый длинный префикс (возможно, пустой) xs элементов, которые не удовлетворяют p, а второй элемент - остаток списка:

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 эквивалентен span (not . p).

reverse :: [a] -> [a] Source

reverse xs возвращает элементы xs в обратном порядке. xs должен быть конечным.

and :: [Bool] -> Bool Source

and возвращает конъюнкцию булевого списка. Для того чтобы результат был True, список должен быть конечным; False, однако, результаты получаются из False значения с конечным индексом конечного или бесконечного списка.

or :: [Bool] -> Bool Source

or возвращает дизъюнкцию булевого списка. Для того чтобы результат был False, список должен быть конечным; True, однако, результаты получаются из True значения с конечным индексом конечного или бесконечного списка.

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

Применённый к предикату и списку, any определяет, удовлетворяет ли какой-либо элемент списка предикату. Для того чтобы результат был False, список должен быть конечным; True, однако, результаты получаются из True значения для предиката, применённого к элементу с конечным индексом конечного или бесконечного списка.

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

Применённый к предикату и списку, all определяет, удовлетворяют ли все элементы списка предикату. Для того чтобы результат был True, список должен быть конечным; False, однако, результаты получаются из False значения для предиката, применённого к элементу с конечным индексом конечного или бесконечного списка.

elem :: Eq a => a -> [a] -> Bool infix 4 Source

elem является предикатом принадлежности к списку, обычно записываемым в инфиксной форме, например, x `elem` xs. Для того чтобы результат был False, список должен быть конечным; True, однако, результаты получаются из элемента, равного x, найденного с конечным индексом конечного или бесконечного списка.

notElem :: Eq a => a -> [a] -> Bool infix 4 Source

notElem является отрицанием elem.

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

\(\mathcal{O}(n)\). lookup key assocs выполняет поиск ключа в ассоциативном списке.

>>> lookup 2 [(1, "first"), (2, "second"), (3, "third")]
Just "second"

concatMap :: (a -> [b]) -> [a] -> [b] Source

Применяет функцию к каждому элементу списка и конкатенирует результаты.

zip :: [a] -> [b] -> [(a, b)] Source

\(\mathcal{O}(\min(m,n))\). zip берёт две последовательности и возвращает последовательность соответствующих пар.

zip [1, 2] ['a', 'b'] = [(1, 'a'), (2, 'b')]

Если один из входных списков короче, то избыточные элементы более длинного списка отбрасываются:

zip [1] ['a', 'b'] = [(1, 'a')]
zip [1, 2] ['a'] = [(1, 'a')]

zip является правой леностью:

zip [] _|_ = []
zip _|_ [] = _|_

zip способна к слиянию списков, но ограничена первым аргументом-списком и результирующим списком.

zip3 :: [a] -> [b] -> [c] -> [(a, b, c)] Source

zip3 берёт три списка и возвращает список троек, аналогично zip. Она способна к слиянию списков, но ограничена первым аргументом-списком и результирующим списком.

zipWith :: (a -> b -> c) -> [a] -> [b] -> [c] Source

\(\mathcal{O}(\min(m,n))\). zipWith обобщает zip путём сжатия с помощью функции, заданной в качестве первого аргумента, вместо функции, создающей кортежи. Например, zipWith (+) применяется к двум спискам, чтобы получить список соответствующих сумм:

>>> zipWith (+) [1, 2, 3] [4, 5, 6]
[5,7,9]

zipWith является правой леностью:

zipWith f [] _|_ = []

zipWith способна к слиянию списков, но ограничена первым аргументом-списком и результирующим списком.

zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d] Source

Функция zipWith3 принимает функцию, которая объединяет три элемента, а также три списка и возвращает список их точечного комбинирования, аналогично zipWith. Она способна к слиянию списков, но ограничена первым аргументом-списком и результирующим списком.

unzip :: [(a, b)] -> ([a], [b]) Source

unzip преобразует список пар в список первых компонентов и список вторых компонентов.

unzip3 :: [(a, b, c)] -> ([a], [b], [c]) Source

Функция unzip3 принимает список троек и возвращает три списка, аналогично unzip.

errorEmptyList :: String -> a Source