Data.List.NonEmpty

data NonEmpty a Источник

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

Начиная с: base-4.9.0.0

map :: (a -> b) -> NonEmpty a -> NonEmpty b Исходный код

Применяет функцию к NonEmpty потоку.

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

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

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

scanl1 :: (a -> a -> a) -> NonEmpty a -> NonEmpty a Исходный код

scanl1 — вариант scanl, не принимающий начальное значение:

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

scanr1 :: (a -> a -> a) -> NonEmpty a -> NonEmpty a Исходный код

scanr1 — вариант scanr, не принимающий начальное значение.

transpose :: NonEmpty (NonEmpty a) -> NonEmpty (NonEmpty a) Исходный код

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

sortBy :: (a -> a -> Ordering) -> NonEmpty a -> NonEmpty a Исходный код

sortBy для NonEmpty работает так же, как sortBy

sortWith :: Ord o => (a -> o) -> NonEmpty a -> NonEmpty a Исходный код

sortWith для NonEmpty работает так же, как:

sortBy . comparing

length :: NonEmpty a -> Int Исходный код

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

compareLength :: NonEmpty a -> Int -> Ordering Исходный код

Используйте 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 Исходный код

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

tail :: NonEmpty a -> [a] Исходный код

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

last :: NonEmpty a -> a Исходный код

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

init :: NonEmpty a -> [a] Исходный код

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

singleton :: a -> NonEmpty a Исходный код

Создаёт список NonEmpty из одного элемента.

Начиная с: base-4.15

(<|) :: a -> NonEmpty a -> NonEmpty a infixr 5 Исходный код

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

cons :: a -> NonEmpty a -> NonEmpty a Исходный код

Синоним <|.

uncons :: NonEmpty a -> (a, Maybe (NonEmpty a)) Исходный код

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

unfoldr :: (a -> (b, Maybe a)) -> a -> NonEmpty b Исходный код

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

sort :: Ord a => NonEmpty a -> NonEmpty a Исходный код

Сортирует поток.

sortOn :: Ord b => (a -> b) -> NonEmpty a -> NonEmpty a Исходный код

Сортирует 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 Исходный код

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

inits :: Foldable f => f a -> NonEmpty [a] Исходный код

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

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

inits1 :: NonEmpty a -> NonEmpty (NonEmpty a) Исходный код

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

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

Начиная с: base-4.18

tails :: Foldable f => f a -> NonEmpty [a] Исходный код

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

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

tails1 :: NonEmpty a -> NonEmpty (NonEmpty a) Исходный код

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

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

Начиная с: base-4.18

append :: NonEmpty a -> NonEmpty a -> NonEmpty a Исходный код

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

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

Начиная с: base-4.16

appendList :: NonEmpty a -> [a] -> NonEmpty a Исходный код

Добавляет список в конец NonEmpty.

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

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

Начиная с: base-4.16

prependList :: [a] -> NonEmpty a -> NonEmpty a Исходный код

Добавляет список в начало NonEmpty.

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

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

Начиная с: base-4.16

iterate :: (a -> a) -> a -> NonEmpty a Исходный код

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

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

repeat :: a -> NonEmpty a Исходный код

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

cycle :: NonEmpty a -> NonEmpty a Исходный код

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

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

unfold :: (a -> (b, Maybe a)) -> a -> NonEmpty b Исходный код

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

insert :: (Foldable f, Ord a) => a -> f a -> NonEmpty a Исходный код

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

some1 :: Alternative f => f a -> f (NonEmpty a) Исходный код

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

take :: Int -> NonEmpty a -> [a] Исходный код

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

drop :: Int -> NonEmpty a -> [a] Исходный код

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

splitAt :: Int -> NonEmpty a -> ([a], [a]) Исходный код

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

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

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

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

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

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

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

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

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

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

Функция 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] Исходный код

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

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

groupBy :: Foldable f => (a -> a -> Bool) -> f a -> [NonEmpty a] Исходный код

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

groupWith :: (Foldable f, Eq b) => (a -> b) -> f a -> [NonEmpty a] Исходный код

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

groupAllWith :: Ord b => (a -> b) -> [a] -> [NonEmpty a] Исходный код

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

group1 :: Eq a => NonEmpty a -> NonEmpty (NonEmpty a) Исходный код

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

groupBy1 :: (a -> a -> Bool) -> NonEmpty a -> NonEmpty (NonEmpty a) Исходный код

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

groupWith1 :: Eq b => (a -> b) -> NonEmpty a -> NonEmpty (NonEmpty a) Исходный код

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

groupAllWith1 :: Ord b => (a -> b) -> NonEmpty a -> NonEmpty (NonEmpty a) Исходный код

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

permutations :: [a] -> NonEmpty [a] Исходный код

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

Начиная с: base-4.20.0.0

permutations1 :: NonEmpty a -> NonEmpty (NonEmpty a) Исходный код

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

permutations1 = fmap fromList . permutations . toList

Начиная с: base-4.20.0.0

isPrefixOf :: Eq a => [a] -> NonEmpty a -> Bool Исходный код

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

nub :: Eq a => NonEmpty a -> NonEmpty a Исходный код

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

nubBy :: (a -> a -> Bool) -> NonEmpty a -> NonEmpty a Исходный код

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

(!!) :: HasCallStack => NonEmpty a -> Int -> a infixl 9 Исходный код

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

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

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

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

zipWith :: (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c Исходный код

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

unzip :: NonEmpty (a, b) -> (NonEmpty a, NonEmpty b) Исходный код

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

fromList :: HasCallStack => [a] -> NonEmpty a Исходный код

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

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

toList :: NonEmpty a -> [a] Исходный код

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

nonEmpty :: [a] -> Maybe (NonEmpty a) Исходный код

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

xor :: NonEmpty Bool -> Bool Исходный код

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