Data.List

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

Присоединение двух списков, т.е.

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

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

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 — первый элемент списка, а xs — его остальная часть.

Since: base-4.8.0.0

null :: Foldable t => t a -> Bool Source

Проверка, пустая ли структура. Реализация по умолчанию оптимизирована для структур, похожих на списки cons, потому что нет универсального способа сделать лучше.

Since: base-4.8.0.0

length :: Foldable t => t a -> Int Source

Возвращает размер/длину конечной структуры как Int. Реализация по умолчанию оптимизирована для структур, похожих на списки cons, потому что нет универсального способа сделать лучше.

Since: base-4.8.0.0

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

\(\mathcal{O}(n)\). map f xs является списком, полученным путём применения f к каждому элементу xs, т.е.,

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

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

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

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

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

\(\mathcal{O}(n)\). Функция intersperse принимает элемент и список и «вставляет» этот элемент между элементами списка. Например,

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

intercalate :: [a] -> [[a]] -> [a] Source

intercalate xs xss эквивалентно (concat (intersperse xs xss)). Вставляет список xs между списками в xss и конкатенирует результат.

>>> intercalate ", " ["Lorem", "ipsum", "dolor"]
"Lorem, ipsum, dolor"

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

Функция transpose транспонирует строки и столбцы своего аргумента. Например,

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

Если некоторые строки короче последующих строк, их элементы пропускаются:

>>> transpose [[10,11],[20],[],[30,31,32]]
[[10,20,30],[11,31],[32]]

subsequences :: [a] -> [[a]] Source

Функция subsequences возвращает список всех подсписков аргумента.

>>> subsequences "abc"
["","a","b","ab","c","ac","bc","abc"]

permutations :: [a] -> [[a]] Source

Функция permutations возвращает список всех перестановок аргумента.

>>> permutations "abc"
["abc","bac","cba","bca","cab","acb"]

foldl :: Foldable t => (b -> a -> b) -> b -> t a -> b Source

Левоассоциативная свертка структуры.

В случае списков, foldl, при применении к бинарному оператору, начальному значению (обычно левому тождеству оператора) и списку, сводит список, используя бинарный оператор слева направо:

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

Обратите внимание, что для получения самого внешнего применения оператора должен быть пройден весь входной список. Это означает, что foldl' расходится, если ему подаётся бесконечный список.

Также обратите внимание, что если вам нужна эффективная левая свертка, вы, вероятно, захотите использовать foldl' вместо foldl. Причина в том, что последний не принуждает «внутренние» результаты (например, z `f` x1 в приведённом выше примере) до их применения к оператору (например, к (`f` x2)). Это приводит к цепи ленивых вычислений длиной \(\mathcal{O}(n)\) элементов, которые затем должны быть вычислены снаружи внутрь.

Для общей структуры Foldable это должно быть семантически идентично,

foldl f z = foldl f z . toList

foldl' :: Foldable t => (b -> a -> b) -> b -> t a -> b Source

Левоассоциативная свертка структуры, но с жёстким применением оператора.

Это гарантирует, что каждый шаг свертки принуждается к слабой нормальной форме до применения, избегая создания цепочки ленивых вычислений, которые в противном случае могли бы возникнуть. Это часто то, что вам нужно, чтобы строго свести конечный список к одному монолитный результату (например, length).

Для общей структуры Foldable это должно быть семантически идентично,

foldl' f z = foldl' f z . toList

Since: base-4.6.0.0

foldl1 :: Foldable t => (a -> a -> a) -> t a -> a Source

Вариант foldl без базового случая и, следовательно, может быть применён только к непустым структурам.

foldl1 f = foldl1 f . toList

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

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

foldr :: Foldable t => (a -> b -> b) -> b -> t a -> b Source

Справочная ассоциативная свертка структуры.

В случае списков, foldr, при применении к бинарному оператору, начальному значению (обычно правому тождеству оператора) и списку, уменьшает список с помощью бинарного оператора справа налево:

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

Обратите внимание, что, поскольку заголовок полученного выражения генерируется применением оператора к первому элементу списка, foldr может создавать завершающее выражение из бесконечного списка.

Для общей структуры Foldable это должно быть семантически идентично,

foldr f z = foldr f z . toList

foldr1 :: Foldable t => (a -> a -> a) -> t a -> a Source

Вариант foldr, у которого нет базового случая, и поэтому он может быть применен только к непустым структурам.

foldr1 f = foldr1 f . toList

concat :: Foldable t => t [a] -> [a] Source

Конкатенация всех элементов контейнера списков.

concatMap :: Foldable t => (a -> [b]) -> t a -> [b] Source

Применение функции ко всем элементам контейнера и конкатенация полученных списков.

and :: Foldable t => t Bool -> Bool Source

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

or :: Foldable t => t Bool -> Bool Source

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

any :: Foldable t => (a -> Bool) -> t a -> Bool Source

Определяет, удовлетворяет ли какой-либо элемент структуры предикату.

all :: Foldable t => (a -> Bool) -> t a -> Bool Source

Определяет, удовлетворяют ли все элементы структуры предикату.

sum :: (Foldable t, Num a) => t a -> a Source

Функция sum вычисляет сумму чисел структуры.

Since: base-4.8.0.0

product :: (Foldable t, Num a) => t a -> a Source

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

Since: base-4.8.0.0

maximum :: forall a. (Foldable t, Ord a) => t a -> a Source

Наибольший элемент непустой структуры.

Since: base-4.8.0.0

minimum :: forall a. (Foldable t, Ord a) => t a -> a Source

Наименьший элемент непустой структуры.

Since: base-4.8.0.0

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

\(\mathcal{O}(n)\). scanl аналогично foldl, но возвращает список последовательных уменьшенных значений слева:

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

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

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

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

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

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

\(\mathcal{O}(n)\). scanl1 — это вариант scanl, который не имеет аргумента начального значения:

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

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

\(\mathcal{O}(n)\). scanr — это правая двойственность scanl. Обратите внимание, что

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

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

\(\mathcal{O}(n)\). scanr1 — это вариант scanr, который не имеет аргумента начального значения.

mapAccumL :: Traversable t => (a -> b -> (a, c)) -> a -> t b -> (a, t c) Source

Функция mapAccumL ведет себя как комбинация fmap и foldl; она применяет функцию к каждому элементу структуры, передавая накопительный параметр слева направо и возвращая конечное значение этого накопителя вместе с новой структурой.

mapAccumR :: Traversable t => (a -> b -> (a, c)) -> a -> t b -> (a, t c) Source

Функция mapAccumR ведет себя как комбинация fmap и foldr; она применяет функцию к каждому элементу структуры, передавая накопительный параметр справа налево и возвращая конечное значение этого накопителя вместе с новой структурой.

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

iterate f x возвращает бесконечный список повторных применений f к x:

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

Обратите внимание, что iterate является ленивым, потенциально приводя к накоплению thunks, если потребитель не принуждает каждый итератор. См. iterate' для строгой версии этой функции.

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

iterate' — это строгая версия iterate.

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

repeat :: a -> [a] Source

repeat x — это бесконечный список, с x значением каждого элемента.

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

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

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

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

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

Функция unfoldr является `дуальной' к foldr: в то время как foldr сводит список к обобщенному значению, unfoldr строит список из начального значения. Функция принимает элемент и возвращает Nothing если завершила построение списка, или возвращает Just (a,b), в этом случае a добавляется в начало списка, а b используется как следующий элемент в рекурсивном вызове. Например,

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

В некоторых случаях, unfoldr может отменить операцию foldr:

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

если выполняется следующее условие:

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

Простой пример использования unfoldr:

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

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 может быть любого целочисленного типа.

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

splitAt n 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]

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

Функция dropWhileEnd удаляет самый длинный суффикс списка, в котором заданный предикат выполняется для всех элементов. Например:

>>> dropWhileEnd isSpace "foo\n"
"foo"

>>> dropWhileEnd isSpace "foo bar"
"foo bar"

dropWhileEnd isSpace ("foo\n" ++ undefined) == "foo" ++ undefined

Since: base-4.5.0.0

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

stripPrefix :: Eq a => [a] -> [a] -> Maybe [a] Source

\(\mathcal{O}(\min(m,n))\). Функция stripPrefix удаляет заданный префикс из списка. Возвращает Nothing если список не начинается с заданного префикса, или Just список без префикса, если он есть.

>>> stripPrefix "foo" "foobar"
Just "bar"

>>> stripPrefix "foo" "foo"
Just ""

>>> stripPrefix "foo" "barfoo"
Nothing

>>> stripPrefix "foo" "barfoobaz"
Nothing

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

Функция group принимает список и возвращает список списков, таким образом, что конкатенация результата равна аргументу. Более того, каждый подсписок в результате содержит только одинаковые элементы. Например,

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

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

inits :: [a] -> [[a]] Source

Функция inits возвращает все начальные сегменты аргумента, начиная с самого короткого. Например,

>>> inits "abc"
["","a","ab","abc"]

Обратите внимание, что inits имеет следующее свойство строгости: inits (xs ++ _|_) = inits xs ++ _|_

В частности, inits _|_ = [] : _|_

tails :: [a] -> [[a]] Source

\(\mathcal{O}(n)\). Функция tails возвращает все конечные сегменты аргумента, начиная с самого длинного. Например,

>>> tails "abc"
["abc","bc","c",""]

Обратите внимание, что tails имеет следующее свойство строгости: tails _|_ = _|_ : _|_

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

\(\mathcal{O}(\min(m,n))\). Функция isPrefixOf принимает два списка и возвращает True тогда и только тогда, когда первый список является префиксом второго.

>>> "Hello" `isPrefixOf` "Hello World!"
True

>>> "Hello" `isPrefixOf` "Wello Horld!"
False

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

Функция isSuffixOf принимает два списка и возвращает True тогда и только тогда, когда первый список является суффиксом второго. Второй список должен быть конечным.

>>> "ld!" `isSuffixOf` "Hello World!"
True

>>> "World" `isSuffixOf` "Hello World!"
False

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

Функция isInfixOf принимает два списка и возвращает True тогда и только тогда, когда первый список полностью содержится в любом месте во втором списке.

>>> isInfixOf "Haskell" "I really like Haskell."
True

>>> isInfixOf "Ial" "I really like Haskell."
False

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

Функция isSubsequenceOf принимает две списки и возвращает True , если все элементы первого списка появляются, в порядке, во втором. Элементы не обязательно должны появляться последовательно.

isSubsequenceOf x y эквивалентно elem x (subsequences y).

Примеры

>>> isSubsequenceOf "GHC" "The Glorious Haskell Compiler"
True
>>> isSubsequenceOf ['a','d'..'z'] ['a'..'z']
True
>>> isSubsequenceOf [1..10] [10,9..0]
False

С: base-4.8.0.0

elem :: (Foldable t, Eq a) => a -> t a -> Bool infix 4 Исходный код

Является ли элемент присутствующим в структуре?

С: base-4.8.0.0

notElem :: (Foldable t, Eq a) => a -> t a -> Bool infix 4 Исходный код

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

lookup :: Eq a => a -> [(a, b)] -> Maybe b Исходный код

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

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

find :: Foldable t => (a -> Bool) -> t a -> Maybe a Исходный код

Функция find принимает предикат и структуру и возвращает самый левый элемент структуры, соответствующий предикату, или Nothing если такого элемента нет.

filter :: (a -> Bool) -> [a] -> [a] Исходный код

\(\mathcal{O}(n)\). filter, применённый к предикату и списку, возвращает список тех элементов, которые удовлетворяют предикату; т.е.,

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

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

partition :: (a -> Bool) -> [a] -> ([a], [a]) Исходный код

Функция partition принимает предикат и список и возвращает пару списков элементов, которые удовлетворяют и не удовлетворяют предикату, соответственно; т.е.,

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

>>> partition (`elem` "aeiou") "Hello World!"
("eoo","Hll Wrld!")

Эти функции рассматривают список xs как индексированную коллекцию, с индексами, изменяющимися от 0 до length xs - 1.

(!!) :: [a] -> Int -> a infixl 9 Исходный код

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

elemIndex :: Eq a => a -> [a] -> Maybe Int Исходный код

Функция elemIndex возвращает индекс первого элемента в заданном списке, который равен (по ==) элементу запроса, или Nothing если такого элемента нет.

>>> elemIndex 4 [0..]
Just 4

elemIndices :: Eq a => a -> [a] -> [Int] Исходный код

Функция elemIndices расширяет elemIndex, возвращая индексы всех элементов, равных элементу запроса, в порядке возрастания.

>>> elemIndices 'o' "Hello World"
[4,7]

findIndex :: (a -> Bool) -> [a] -> Maybe Int Исходный код

Функция findIndex принимает предикат и список и возвращает индекс первого элемента в списке, удовлетворяющего предикату, или Nothing если такого элемента нет.

>>> findIndex isSpace "Hello World!"
Just 5

findIndices :: (a -> Bool) -> [a] -> [Int] Исходный код

Функция findIndices расширяет findIndex, возвращая индексы всех элементов, удовлетворяющих предикату, в порядке возрастания.

>>> findIndices (`elem` "aeiou") "Hello World!"
[1,4,7]

zip :: [a] -> [b] -> [(a, b)] Исходный код

\(\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)] Исходный код

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

zip4 :: [a] -> [b] -> [c] -> [d] -> [(a, b, c, d)] Исходный код

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

unzip5 :: [(a, b, c, d, e)] -> ([a], [b], [c], [d], [e]) Source

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

unzip6 :: [(a, b, c, d, e, f)] -> ([a], [b], [c], [d], [e], [f]) Source

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

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

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

lines :: String -> [String] Source

Функция lines разбивает строку на список строк по символам новой строки. Результирующие строки не содержат символов новой строки.

Обратите внимание, что после разделения строки по символам новой строки, последняя часть строки рассматривается как строка, даже если она не заканчивается символом новой строки. Например,

>>> lines ""
[]

>>> lines "\n"
[""]

>>> lines "one"
["one"]

>>> lines "one\n"
["one"]

>>> lines "one\n\n"
["one",""]

>>> lines "one\ntwo"
["one","two"]

>>> lines "one\ntwo\n"
["one","two"]

Таким образом, lines s содержит по меньшей мере столько элементов, сколько символов новой строки в s.

words :: String -> [String] Source

Функция words разбивает строку на список слов, разделённых пробелами.

>>> words "Lorem ipsum\ndolor"
["Lorem","ipsum","dolor"]

unlines :: [String] -> String Source

Функция unlines — обратная функция к lines. Она объединяет строки, добавляя символ новой строки в конец каждой.

>>> unlines ["Hello", "World", "!"]
"Hello\nWorld\n!\n"

unwords :: [String] -> String Source

Функция unwords — обратная функция к words. Она объединяет слова с разделителями в виде пробелов.

>>> unwords ["Lorem", "ipsum", "dolor"]
"Lorem ipsum dolor"

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

\(\mathcal{O}(n^2)\). Функция nub удаляет дублирующие элементы из списка. В частности, она оставляет только первое вхождение каждого элемента. (Имя nub означает `сущность'.) Это частный случай nubBy, который позволяет программисту указать собственное сравнение на равенство.

>>> nub [1,2,3,4,3,2,1,2,4,3,5]
[1,2,3,4,5]

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

\(\mathcal{O}(n)\). Функция delete x удаляет первое вхождение элемента x из своего списка-аргумента. Например,

>>> delete 'a' "banana"
"bnana"

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

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

Функция \\ — это разность списков (неассоциативная). В результате xs \\ ys, первое вхождение каждого элемента из ys в свою очередь (если таковое есть) удаляется из xs. Таким образом,

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

>>> "Hello World!" \\ "ell W"
"Hoorld!"

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

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

Функция union возвращает объединение двух списков. Например,

>>> "dog" `union` "cow"
"dogcw"

Дубликаты и элементы первого списка удаляются из второго, но если в первом списке есть дубликаты, они будут и в результате. Это частный случай unionBy, который позволяет программисту указать собственное сравнение на равенство.

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

Функция intersect вычисляет пересечение двух списков. Например,

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

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

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

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

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

Функция sort реализует стабильный алгоритм сортировки. Это частный случай sortBy, который позволяет программисту указать собственную функцию сравнения.

Элементы упорядочиваются по возрастанию, сохраняя дубликаты в порядке их появления в исходном списке.

>>> sort [1,6,4,3,2,5]
[1,2,3,4,5,6]

sortOn :: Ord b => (a -> b) -> [a] -> [a] Source

Отсортировать список, сравнивая результаты функции ключа, применённой к каждому элементу. sortOn f эквивалентно sortBy (comparing f), но обладает преимуществом производительности, так как оценивает f только один раз для каждого элемента в входном списке. Это называется парадигмой «декорировать-сортировать-разыдекорировать» или преобразованием Шварца.

Элементы упорядочены от наименьшего к наибольшему, сохраняя дубликаты в порядке их появления во входном списке.

>>> sortOn fst [(2, "world"), (4, "!"), (1, "Hello")]
[(1,"Hello"),(2,"world"),(4,"!")]

С момента: base-4.8.0.0

insert :: Ord a => a -> [a] -> [a] Источник

\(\mathcal{O}(n)\). Функция insert принимает элемент и список и вставляет элемент в список в первой позиции, где он меньше или равен следующему элементу. В частности, если список отсортирован перед вызовом, результат также будет отсортирован. Это частный случай insertBy, который позволяет программисту указать свою собственную функцию сравнения.

>>> insert 4 [1,2,3,5,6,7]
[1,2,3,4,5,6,7]

По соглашению перегруженные функции имеют аналог без перегрузки, имя которого имеет суффикс `By'.

Часто бывает удобно использовать эти функции совместно с on, например sortBy (compare `on` fst).

Предполагается, что предикат определяет эквивалентность.

nubBy :: (a -> a -> Bool) -> [a] -> [a] Источник

Функция nubBy ведёт себя точно так же, как nub, за исключением того, что она использует предоставленный пользователем предикат равенства вместо перегруженной функции ==.

>>> nubBy (\x y -> mod x 3 == mod y 3) [1,2,4,5,6]
[1,2,6]

deleteBy :: (a -> a -> Bool) -> a -> [a] -> [a] Источник

\(\mathcal{O}(n)\). Функция deleteBy ведёт себя как delete, но принимает предикат равенства, задаваемый пользователем.

>>> deleteBy (<=) 4 [1..10]
[1,2,3,5,6,7,8,9,10]

deleteFirstsBy :: (a -> a -> Bool) -> [a] -> [a] -> [a] Источник

Функция deleteFirstsBy принимает предикат и два списка и возвращает первый список с удалённым первым вхождением каждого элемента из второго списка.

unionBy :: (a -> a -> Bool) -> [a] -> [a] -> [a] Источник

Функция unionBy является вариантом без перегрузки для union.

intersectBy :: (a -> a -> Bool) -> [a] -> [a] -> [a] Источник

Функция intersectBy является вариантом без перегрузки для intersect.

groupBy :: (a -> a -> Bool) -> [a] -> [[a]] Источник

Функция groupBy является вариантом без перегрузки для group.

Функция предполагает определение полного порядка.

sortBy :: (a -> a -> Ordering) -> [a] -> [a] Источник

Функция sortBy является вариантом без перегрузки для sort.

>>> sortBy (\(a,_) (b,_) -> compare a b) [(2, "world"), (4, "!"), (1, "Hello")]
[(1,"Hello"),(2,"world"),(4,"!")]

insertBy :: (a -> a -> Ordering) -> a -> [a] -> [a] Источник

\(\mathcal{O}(n)\). Вариант без перегрузки для insert.

maximumBy :: Foldable t => (a -> a -> Ordering) -> t a -> a Источник

Наибольший элемент непустой структуры относительно заданной функции сравнения.

minimumBy :: Foldable t => (a -> a -> Ordering) -> t a -> a Источник

Наименьший элемент непустой структуры относительно заданной функции сравнения.

Префикс `generic' указывает на перегруженную функцию, которая является обобщённой версией функции из Prelude.

genericLength :: Num i => [a] -> i Источник

\(\mathcal{O}(n)\). Функция genericLength является перегруженной версией length. В частности, вместо возвращения Int, она возвращает любой тип, который является экземпляром Num. Однако она менее эффективна, чем length.

>>> genericLength [1, 2, 3] :: Int
3
>>> genericLength [1, 2, 3] :: Float
3.0

genericTake :: Integral i => i -> [a] -> [a] Источник

Функция genericTake является перегруженной версией take, которая принимает любое значение Integral в качестве числа элементов для взятия.

genericDrop :: Integral i => i -> [a] -> [a] Источник

Функция genericDrop является перегруженной версией drop, которая принимает любое значение Integral в качестве числа элементов для удаления.

genericSplitAt :: Integral i => i -> [a] -> ([a], [a]) Источник

Функция genericSplitAt является перегруженной версией splitAt, которая принимает любое значение Integral в качестве позиции для разделения.

genericIndex :: Integral i => [a] -> i -> a Источник

Функция genericIndex является перегруженной версией !!, которая принимает любое значение Integral в качестве индекса.

genericReplicate :: Integral i => i -> a -> [a] Источник

Функция genericReplicate является перегруженной версией replicate, которая принимает любое значение Integral в качестве числа повторений.