Data.List.NonEmpty

data NonEmpty a Source

Тип непустого (и нестрогого) списка.

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

map :: (a -> b) -> NonEmpty a -> NonEmpty b Источник

Применение функции к потоку, не содержащему пустоты.

intersperse :: a -> NonEmpty a -> NonEmpty a Источник

Функция 'intersperse x xs' чередует элементы списка с копиями элемента x.

intersperse 0 (1 :| [2,3]) == 1 :| [0,2,0,3]

scanl :: Foldable f => (b -> a -> b) -> b -> f a -> NonEmpty b Источник

Функция 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.

scanr :: Foldable f => (a -> b -> b) -> b -> f a -> NonEmpty b Source

scanr является правым двойником scanl. Обратите внимание, что

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

scanl1 :: (a -> a -> a) -> NonEmpty a -> NonEmpty a Source

scanl1 является вариантом scanl, не имеющим аргумента начального значения:

scanl1 f [x1, x2, ...] == x1 :| [x1 `f` x2, x1 `f` (x2 `f` x3), ...]

scanr1 :: (a -> a -> a) -> NonEmpty a -> NonEmpty a Source

scanr1 является вариантом scanr, не имеющим аргумента начального значения.

transpose :: NonEmpty (NonEmpty a) -> NonEmpty (NonEmpty a) Source

transpose для NonEmpty, ведет себя так же, как transpose. Строки/столбцы не обязаны иметь одинаковую длину, в этом случае > transpose . transpose /= id

sortBy :: (a -> a -> Ordering) -> NonEmpty a -> NonEmpty a Source

sortBy для NonEmpty, ведет себя так же, как sortBy

sortWith :: Ord o => (a -> o) -> NonEmpty a -> NonEmpty a Source

sortWith для NonEmpty, ведет себя так же, как:

sortBy . comparing

length :: NonEmpty a -> Int Source

Количество элементов в списке NonEmpty.

compareLength :: NonEmpty a -> Int -> Ordering Source

Используйте compareLength xs n в качестве более безопасной и быстрой альтернативы compare (length xs) n. Аналогично, лучше писать compareLength xs 10 == LT вместо length xs < 10.

В то время как length будет вынуждено пройти и пройти весь позвоночник xs (что может даже разойтись, если xs бесконечно), compareLength проходит не более n элементов для определения своего результата.

>>> compareLength ('a' :| []) 1
EQ
>>> compareLength ('a' :| ['b']) 3
LT
>>> compareLength (0 :| [1..]) 100
GT
>>> compareLength undefined 0
GT
>>> compareLength ('a' :| 'b' : undefined) 1
GT

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

head :: NonEmpty a -> a Source

Извлечь первый элемент потока.

tail :: NonEmpty a -> [a] Source

Извлечь, возможно, пустой хвост потока.

last :: NonEmpty a -> a Source

Извлечь последний элемент потока.

init :: NonEmpty a -> [a] Source

Извлечь все, кроме последнего элемента потока.

singleton :: a -> NonEmpty a Source

Построить список NonEmpty из одного элемента.

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

(<|) :: a -> NonEmpty a -> NonEmpty a infixr 5 Source

Добавить элемент в начало потока.

cons :: a -> NonEmpty a -> NonEmpty a Source

Синоним для <|.

uncons :: NonEmpty a -> (a, Maybe (NonEmpty a)) Source

uncons возвращает первый элемент потока и поток оставшихся элементов, если таковые имеются.

unfoldr :: (a -> (b, Maybe a)) -> a -> NonEmpty b Source

Функция unfoldr аналогична операции unfoldr из Data.List.

sort :: Ord a => NonEmpty a -> NonEmpty a Source

Сортировать поток.

sortOn :: Ord b => (a -> b) -> NonEmpty a -> NonEmpty a Source

Сортировать NonEmpty по заданной проекцией его элементов. См. sortOn для получения более подробной информации.

Примеры

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

>>> sortOn List.length ("jim" :| ["creed", "pam", "michael", "dwight", "kevin"])
"jim" :| ["pam","creed","kevin","dwight","michael"]

Примечания по производительности

>>> sortBy (comparing fst) $ (3, 1) :| [(2, 2), (1, 3)]
(1,3) :| [(2,2),(3,1)]

>>> (sortBy . comparing) fst $ (3, 1) :| [(2, 2), (1, 3)]
(1,3) :| [(2,2),(3,1)]

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

reverse :: NonEmpty a -> NonEmpty a Source

reverse конечный поток NonEmpty.

inits :: Foldable f => f a -> NonEmpty [a] Source

Функция inits принимает поток xs и возвращает все конечные префиксы xs, начиная с самого короткого. Результат является NonEmpty, потому что результат всегда содержит пустой список в качестве первого элемента.

inits [1,2,3] == [] :| [[1], [1,2], [1,2,3]]
inits [1] == [] :| [[1]]
inits [] == [] :| []

inits1 :: NonEmpty a -> NonEmpty (NonEmpty a) Source

Функция inits1 принимает NonEmpty поток xs и возвращает все NonEmpty конечные префиксы xs, начиная с самого короткого.

inits1 (1 :| [2,3]) == (1 :| []) :| [1 :| [2], 1 :| [2,3]]
inits1 (1 :| []) == (1 :| []) :| []

Since: base-4.18

tails :: Foldable f => f a -> NonEmpty [a] Source

Функция tails принимает поток xs и возвращает все суффиксы xs, начиная с самого длинного. Результат является NonEmpty, потому что результат всегда содержит пустой список в качестве последнего элемента.

tails [1,2,3] == [1,2,3] :| [[2,3], [3], []]
tails [1] == [1] :| [[]]
tails [] == [] :| []

tails1 :: NonEmpty a -> NonEmpty (NonEmpty a) Source

Функция tails1 принимает NonEmpty поток xs и возвращает все непустые суффиксы xs, начиная с самого длинного.

tails1 (1 :| [2,3]) == (1 :| [2,3]) :| [2 :| [3], 3 :| []]
tails1 (1 :| []) == (1 :| []) :| []

Since: base-4.18

append :: NonEmpty a -> NonEmpty a -> NonEmpty a Source

Мономорфная версия <> для NonEmpty.

>>> append (1 :| []) (2 :| [3])
1 :| [2,3]

Since: base-4.16

appendList :: NonEmpty a -> [a] -> NonEmpty a Source

Присоединить список к концу NonEmpty.

>>> appendList (1 :| [2,3]) []
1 :| [2,3]

>>> appendList (1 :| [2,3]) [4,5]
1 :| [2,3,4,5]

Since: base-4.16

prependList :: [a] -> NonEmpty a -> NonEmpty a Source

Присоединить список к началу NonEmpty.

>>> prependList [] (1 :| [2,3])
1 :| [2,3]

>>> prependList [negate 1, 0] (1 :| [2, 3])
-1 :| [0,1,2,3]

Since: base-4.16

iterate :: (a -> a) -> a -> NonEmpty a Source

iterate f x генерирует бесконечную последовательность повторных применений f к x.

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

repeat :: a -> NonEmpty a Source

repeat x возвращает постоянный поток, где все элементы равны x.

cycle :: NonEmpty a -> NonEmpty a Source

cycle xs возвращает бесконечное повторение xs:

cycle (1 :| [2,3]) = 1 :| [2,3,1,2,3,...]

unfold :: (a -> (b, Maybe a)) -> a -> NonEmpty b Source

unfold создаёт новый поток, многократно применяя функцию развёртывания к начальному значению для создания элемента типа b и нового начального значения. Когда функция развёртывания возвращает Nothing вместо нового начального значения, поток завершается.

insert :: (Foldable f, Ord a) => a -> f a -> NonEmpty a Source

insert x xs вставляет x в последнюю позицию в xs, где оно всё ещё меньше или равно следующему элементу. В частности, если список отсортирован предварительно, результат также будет отсортирован.

some1 :: Alternative f => f a -> f (NonEmpty a) Source

some1 x последовательно x один или несколько раз.

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

take n xs возвращает первые n элементы xs.

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

drop n xs отбрасывает первые n элементы из начала последовательности xs.

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

splitAt n xs возвращает пару, состоящую из префикса xs длины n и оставшегося потока, непосредственно следующего за этим префиксом.

'splitAt' n xs == ('take' n xs, 'drop' n xs)
xs == ys ++ zs where (ys, zs) = 'splitAt' n xs

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

takeWhile p xs возвращает самый длинный префикс потока xs, для которого выполняется предикат p.

dropWhile :: (a -> Bool) -> NonEmpty a -> [a] Source

dropWhile p xs возвращает суффикс, оставшийся после takeWhile p xs.

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

span p xs возвращает самый длинный префикс xs, удовлетворяющий p, вместе с остальной частью потока.

'span' p xs == ('takeWhile' p xs, 'dropWhile' p xs)
xs == ys ++ zs where (ys, zs) = 'span' p xs

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

Функция break p эквивалентна span (not . p).

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

filter p xs удаляет любые элементы из xs, которые не удовлетворяют p.

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

Функция partition принимает предикат p и поток xs, и возвращает пару списков. Первый список соответствует элементам xs , для которых выполняется условие p; второй — элементам xs , для которых условие p не выполняется.

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

group :: (Foldable f, Eq a) => f a -> [NonEmpty a] Source

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

>>> group "Mississippi"
['M' :| "",'i' :| "",'s' :| "s",'i' :| "",'s' :| "s",'i' :| "",'p' :| "p",'i' :| ""]

groupBy :: Foldable f => (a -> a -> Bool) -> f a -> [NonEmpty a] Source

groupBy работает так же, как group, но использует предоставленный предикат равенства вместо ==.

groupWith :: (Foldable f, Eq b) => (a -> b) -> f a -> [NonEmpty a] Source

groupWith работает так же, как group, но использует предоставленное отображение при сравнении на равенство.

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

groupAllWith работает как groupWith, но сначала сортирует список, чтобы каждая группа эквивалентности содержала не более одного списка в выходе.

group1 :: Eq a => NonEmpty a -> NonEmpty (NonEmpty a) Source

group1 работает так же, как group, но использует знание о том, что на входе непустой список, чтобы гарантировать, что выход также непустой.

groupBy1 :: (a -> a -> Bool) -> NonEmpty a -> NonEmpty (NonEmpty a) Source

groupBy1 относится к group1 так же, как groupBy относится к group.

groupWith1 :: Eq b => (a -> b) -> NonEmpty a -> NonEmpty (NonEmpty a) Source

groupWith1 относится к group1 так же, как groupWith относится к group.

groupAllWith1 :: Ord b => (a -> b) -> NonEmpty a -> NonEmpty (NonEmpty a) Source

groupAllWith1 относится к groupWith1 так же, как groupAllWith относится к groupWith.

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

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

Since: base-4.20.0.0

permutations1 :: NonEmpty a -> NonEmpty (NonEmpty a) Source

permutations1 работает так же, как permutations, но использует знание о том, что вход непустой, чтобы получить выход, где каждый элемент непустой.

permutations1 = fmap fromList . permutations . toList

Since: base-4.20.0.0

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

Функция isPrefixOf возвращает True , если первый аргумент является префиксом второго.

nub :: Eq a => NonEmpty a -> NonEmpty a Source

Функция nub удаляет дублирующие элементы из списка. В частности, она сохраняет только первое вхождение каждого элемента. (Название nub означает «суть».) Это частный случай nubBy, который позволяет программисту указать собственное условие неравенства.

nubBy :: (a -> a -> Bool) -> NonEmpty a -> NonEmpty a Source

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

(!!) :: HasCallStack => NonEmpty a -> Int -> a infixl 9 Source

xs !! n возвращает элемент потока xs с индексом n. Обратите внимание, что начало потока имеет индекс 0.

Внимание: отрицательный или неверный индекс вызовет ошибку.

zip :: NonEmpty a -> NonEmpty b -> NonEmpty (a, b) Source

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

zipWith :: (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c Source

Функция zipWith обобщает zip. Вместо туплирования элементов, элементы объединяются с помощью функции, переданной в качестве первого аргумента.

unzip :: Functor f => f (a, b) -> (f a, f b) Source

Функция unzip является обратной функцией zip.

fromList :: HasCallStack => [a] -> NonEmpty a Источник

Преобразует обычный список в NonEmpty поток.

Вызывает ошибку, если входной список пустой.

toList :: NonEmpty a -> [a] Источник

Эффективно преобразует поток в обычный список.

nonEmpty :: [a] -> Maybe (NonEmpty a) Источник

Эффективно преобразует обычный список в NonEmpty поток, возвращая Nothing в случае пустого входного списка.

xor :: NonEmpty Bool -> Bool Источник

Вычисляет n-арную логическую операцию исключающего ИЛИ над NonEmpty списком.