Data.ByteString.Lazy

import qualified Data.ByteString.Lazy as B

Тип ByteString

data ByteString Источник

Эффективное представление Word8 вектора, поддерживающее множество эффективных операций.

Ленивый ByteString содержит байты с 8 битами, или, используя операции из Data.ByteString.Lazy.Char8, может быть интерпретирован как содержащий символы с 8 битами.

Введение и удаление ByteString

empty :: ByteString Источник

O(1) Пустая ByteString

singleton :: Word8 -> ByteString Источник

O(1) Преобразование Word8 в ByteString

pack :: [Word8] -> ByteString Источник

O(n) Преобразование '[Word8]' в ByteString.

unpack :: ByteString -> [Word8] Источник

O(n) Преобразует ByteString в '[Word8]'.

fromStrict :: ByteString -> ByteString Источник

O(1) Преобразование строгого ByteString в ленивое ByteString.

toStrict :: ByteString -> ByteString Источник

O(n) Преобразование ленивого ByteString в строгий ByteString.

Обратите внимание, что это дорогая операция, которая заставляет весь ленивый ByteString попасть в память и затем копирует все данные. По возможности старайтесь избегать преобразования между строгими и ленивыми bytestrings.

fromChunks :: [ByteString] -> ByteString Источник

O(c) Преобразование списка строгих ByteString в ленивое ByteString.

toChunks :: ByteString -> [ByteString] Источник

O(c) Преобразование ленивого ByteString в список строгих ByteString.

foldrChunks :: (ByteString -> a -> a) -> a -> ByteString -> a Source

Потреблять куски ленивого ByteString с естественным правым слиянием.

foldlChunks :: (a -> ByteString -> a) -> a -> ByteString -> a Source

Потреблять куски ленивого ByteString с жёстким, рекурсивным с накоплением левого слияния.

Базовый интерфейс

cons :: Word8 -> ByteString -> ByteString infixr 5 Source

O(1) cons аналогичен '(:)' для списков.

cons' :: Word8 -> ByteString -> ByteString infixr 5 Source

O(1) В отличие от cons, 'cons\'' жёсткий относительно ByteString, к которому мы присоединяем. Более точно, он принуждает заголовок и первый кусок. Это делается для экономии памяти, так как он может объединить новый байт с первым «куском», а не начинать новый «кусок».

Это означает, что вы не можете использовать леничную рекурсивную конструкцию такого типа:

let xs = cons\' c xs in xs

Однако вы можете использовать cons, а также repeat и cycle, чтобы создать бесконечные ленивые ByteString.

snoc :: ByteString -> Word8 -> ByteString infixl 5 Source

O(n/c) Добавить байт в конец ByteString

append :: ByteString -> ByteString -> ByteString Source

O(n/c) Присоединить два ByteString

head :: ByteString -> Word8 Source

O(1) Извлечь первый элемент ByteString, который должен быть непустым.

uncons :: ByteString -> Maybe (Word8, ByteString) Source

O(1) Извлечь заголовок и хвост ByteString, вернув Nothing, если он пуст.

unsnoc :: ByteString -> Maybe (ByteString, Word8) Source

O(n/c) Извлечь init и last ByteString, вернув Nothing, если он пуст.

• Он не быстрее, чем использование init и last

last :: ByteString -> Word8 Source

O(n/c) Извлечь последний элемент ByteString, который должен быть конечным и непустым.

tail :: ByteString -> ByteString Source

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

init :: ByteString -> ByteString Source

O(n/c) Возвратить все элементы ByteString за исключением последнего.

null :: ByteString -> Bool Source

O(1) Проверить, является ли ByteString пустой.

length :: ByteString -> Int64 Source

O(n/c) length возвращает длину ByteString как Int64

Преобразование ByteStrings

map :: (Word8 -> Word8) -> ByteString -> ByteString Source

O(n) map f xs — это ByteString, полученная путём применения f к каждому элементу xs

reverse :: ByteString -> ByteString Source

O(n) reverse xs возвращает элементы xs в обратном порядке.

intersperse :: Word8 -> ByteString -> ByteString Source

Функция intersperse принимает байт и ByteString и «вставляет» этот байт между элементами ByteString. Она аналогична функции intersperse для списков.

intercalate :: ByteString -> [ByteString] -> ByteString Source

O(n) Функция intercalate принимает ByteString и список ByteStrings, конкатенирует список после вставки первого аргумента между каждым элементом списка.

transpose :: [ByteString] -> [ByteString] Source

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

Уменьшение ByteString (folds)

foldl :: (a -> Word8 -> a) -> a -> ByteString -> a Source

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

foldl' :: (a -> Word8 -> a) -> a -> ByteString -> a Source

'foldl\'' похожа на foldl, но строгая по аккумулятору.

foldl1 :: (Word8 -> Word8 -> Word8) -> ByteString -> Word8 Source

foldl1 является вариантом foldl, у которого нет аргумента начального значения, и поэтому его необходимо применять к непустому ByteStrings.

foldl1' :: (Word8 -> Word8 -> Word8) -> ByteString -> Word8 Source

'foldl1\'' похож на foldl1, но строгий по отношению к аккумулятору.

foldr :: (Word8 -> a -> a) -> a -> ByteString -> a Source

foldr, применяемый к бинарному оператору, начальному значению (обычно правому тождеству оператора) и ByteString, сворачивает ByteString с использованием бинарного оператора справа налево.

foldr1 :: (Word8 -> Word8 -> Word8) -> ByteString -> Word8 Source

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

Специальные сворачивания

concat :: [ByteString] -> ByteString Source

O(n) Объединение списка ByteStrings.

concatMap :: (Word8 -> ByteString) -> ByteString -> ByteString Source

Применение функции к ByteString и конкатенация результатов

any :: (Word8 -> Bool) -> ByteString -> Bool Source

O(n) Применяя предикат к ByteString, any определяет, удовлетворяет ли какой-либо элемент ByteString предикату.

all :: (Word8 -> Bool) -> ByteString -> Bool Source

O(n) Применяя предикат к ByteString, all определяет, удовлетворяют ли все элементы ByteString предикату.

maximum :: ByteString -> Word8 Source

O(n) maximum возвращает максимальное значение из ByteString.

minimum :: ByteString -> Word8 Source

O(n) minimum возвращает минимальное значение из ByteString.

Создание ByteStrings

Сканирования

scanl :: (Word8 -> Word8 -> Word8) -> Word8 -> ByteString -> ByteString Source

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.

Накопление отображений

mapAccumL :: (acc -> Word8 -> (acc, Word8)) -> acc -> ByteString -> (acc, ByteString) Source

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

mapAccumR :: (acc -> Word8 -> (acc, Word8)) -> acc -> ByteString -> (acc, ByteString) Source

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

Бесконечные ByteStrings

repeat :: Word8 -> ByteString Source

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

replicate :: Int64 -> Word8 -> ByteString Source

O(n) replicate n x — это ByteString длиной n с x значением каждого элемента.

cycle :: ByteString -> ByteString Source

cycle связывает конечную ByteString в циклическую, или, равнозначно, бесконечное повторение исходной ByteString.

iterate :: (Word8 -> Word8) -> Word8 -> ByteString Source

iterate f x возвращает бесконечную ByteString повторяющихся применений f к x.

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

Развертывание ByteStrings

unfoldr :: (a -> Maybe (Word8, a)) -> a -> ByteString Source

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

Подстроки

Разбиение строк

take :: Int64 -> ByteString -> ByteString Source

O(n/c) take n, применённая к ByteString xs, возвращает префикс xs длиной n, или xs саму себя, если n > length xs.

drop :: Int64 -> ByteString -> ByteString Source

O(n/c) drop n xs возвращает суффикс xs после первых n элементов, или [] если n > length xs.

splitAt :: Int64 -> ByteString -> (ByteString, ByteString) Source

O(n/c) splitAt n xs эквивалентно (take n xs, drop n xs).

takeWhile :: (Word8 -> Bool) -> ByteString -> ByteString Source

Функция takeWhile, применённая к предикату p и ByteString xs, возвращает наибольший префикс (возможно, пустой) xs элементов, удовлетворяющих p.

dropWhile :: (Word8 -> Bool) -> ByteString -> ByteString Source

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

span :: (Word8 -> Bool) -> ByteString -> (ByteString, ByteString) Source

span p xs разбивает ByteString на два сегмента. Она эквивалентна (takeWhile p xs, dropWhile p xs)

break :: (Word8 -> Bool) -> ByteString -> (ByteString, ByteString) Source

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

group :: ByteString -> [ByteString] Source

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

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

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

groupBy :: (Word8 -> Word8 -> Bool) -> ByteString -> [ByteString] Source

Функция groupBy является неопределённой версией group.

inits :: ByteString -> [ByteString] Source

O(n) Возвращает все начальные сегменты заданного ByteString, в порядке возрастания длины.

tails :: ByteString -> [ByteString] Source

O(n) Возвращает все конечные сегменты заданного ByteString, в порядке убывания длины.

Разбиение на множество подстрок

split :: Word8 -> ByteString -> [ByteString] Source

O(n) Разбивает ByteString на части, разделенные байтом-аргументом, потребляя разделитель. Например:

split '\n' "a\nb\nd\ne" == ["a","b","d","e"]
split 'a'  "aXaXaXa"    == ["","X","X","X",""]
split 'x'  "x"          == ["",""]

и

intercalate [c] . split c == id
split == splitWith . (==)

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

splitWith :: (Word8 -> Bool) -> ByteString -> [ByteString] Source

O(n) Разбивает ByteString на компоненты, ограниченные разделителями, где предикат возвращает True для элемента-разделителя. Результирующие компоненты не содержат разделителей. Два смежных разделителя приводят к пустому компоненту в выводе. Пример:

splitWith (=='a') "aabbaca" == ["","","bb","c",""]
splitWith (=='a') []        == []

Предикаты

isPrefixOf :: ByteString -> ByteString -> Bool Source

O(n) Функция isPrefixOf принимает две ByteString и возвращает True, если первая является префиксом второй.

isSuffixOf :: ByteString -> ByteString -> Bool Source

O(n) Функция isSuffixOf принимает две ByteString и возвращает True, если первая является суффиксом второй.

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

isSuffixOf x y == reverse x `isPrefixOf` reverse y

Поиск произвольных подстрок

Поиск в ByteString

Поиск по равенству

elem :: Word8 -> ByteString -> Bool Source

O(n) elem - предикат принадлежности к ByteString.

notElem :: Word8 -> ByteString -> Bool Source

O(n) notElem - обратное к elem

Поиск с предикатом

find :: (Word8 -> Bool) -> ByteString -> Maybe Word8 Source

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

find f p = case findIndex f p of Just n -> Just (p ! n) ; _ -> Nothing

filter :: (Word8 -> Bool) -> ByteString -> ByteString Source

O(n) filter, применённая к предикату и ByteString, возвращает ByteString, содержащую те символы, которые удовлетворяют предикату.

partition :: (Word8 -> Bool) -> ByteString -> (ByteString, ByteString) Source

O(n) Функция partition принимает предикат и ByteString и возвращает пару ByteString, содержащих элементы, которые удовлетворяют и не удовлетворяют предикату соответственно; т.е.,

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

Индексирование ByteString

index :: ByteString -> Int64 -> Word8 Source

O(c) ByteString оператор индекса (индексации), начиная с 0.

elemIndex :: Word8 -> ByteString -> Maybe Int64 Source

O(n) Функция elemIndex возвращает индекс первого элемента в заданной ByteString, который равен запрошенному элементу, или Nothing, если такого элемента нет. Эта реализация использует memchr(3).

elemIndexEnd :: Word8 -> ByteString -> Maybe Int64 Source

O(n) Функция elemIndexEnd возвращает последний индекс элемента в заданной ByteString, который равен запрошенному элементу, или Nothing, если такого элемента нет. Следующее условие выполняется:

elemIndexEnd c xs ==
(-) (length xs - 1) `fmap` elemIndex c (reverse xs)

elemIndices :: Word8 -> ByteString -> [Int64] Source

O(n) Функция elemIndices расширяет elemIndex, возвращая индексы всех элементов, равных запрошенному элементу, в порядке возрастания. Эта реализация использует memchr(3).

findIndex :: (Word8 -> Bool) -> ByteString -> Maybe Int64 Source

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

findIndices :: (Word8 -> Bool) -> ByteString -> [Int64] Source

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

count :: Word8 -> ByteString -> Int64 Source

count возвращает количество вхождений своего аргумента в ByteString

count = length . elemIndices

Но более эффективно, чем использование length на промежуточном списке.

Сжатие и распаковку ByteString

zip :: ByteString -> ByteString -> [(Word8, Word8)] Источник

O(n) zip принимает две ByteString и возвращает список соответствующих пар байтов. Если одна входная ByteString короче, избыточные элементы более длинной ByteString отбрасываются. Это эквивалентно паре unpack операций.

zipWith :: (Word8 -> Word8 -> a) -> ByteString -> ByteString -> [a] Источник

zipWith обобщает zip , сжимая с помощью функции, заданной в качестве первого аргумента, вместо функции туплинга. Например, zipWith (+) применяется к двум ByteStrings, чтобы получить список соответствующих сумм.

unzip :: [(Word8, Word8)] -> (ByteString, ByteString) Источник

O(n) unzip преобразует список пар байтов в пару ByteStrings. Обратите внимание, что это выполняет две pack операции.

Отсортированные ByteStrings

Преобразования низкого уровня

Копирование ByteStrings

copy :: ByteString -> ByteString Источник

O(n) Создать копию ByteString со своим собственным хранилищем. Это главным образом полезно, чтобы позволить остальной части данных, на которые указывает ByteString , быть собраны сборщиком мусора, например, если большая строка была прочитана, и только небольшая ее часть нужна в остальной части программы.

Ввод-вывод с ByteString

Стандартный ввод и вывод

getContents :: IO ByteString Источник

getContents. Эквивалентно hGetContents stdin. Будет читать лениво

putStr :: ByteString -> IO () Источник

Записать ByteString в стандартный вывод

putStrLn :: ByteString -> IO () Источник

Записать ByteString в стандартный вывод, добавив байт новой строки

interact :: (ByteString -> ByteString) -> IO () Источник

Функция interact принимает функцию типа ByteString -> ByteString в качестве аргумента. Весь ввод со стандартного устройства ввода передается в эту функцию в качестве аргумента, а полученная строка выводится на стандартное устройство вывода.

Файлы

readFile :: FilePath -> IO ByteString Источник

Прочитать весь файл лениво в ByteString. Дескриптор файла будет оставаться открытым до тех пор, пока не будет достигнут конец файла.

writeFile :: FilePath -> ByteString -> IO () Source

Записать ByteString в файл.

appendFile :: FilePath -> ByteString -> IO () Source

Добавить ByteString в файл.

Ввод-вывод с дескрипторами

hGetContents :: Handle -> IO ByteString Source

Прочитать содержимое всего дескриптора лениво в ByteString. Блоки прочитываются по мере необходимости, используя размер блока по умолчанию.

После достижения конца файла, дескриптор закрывается.

Примечание: дескриптор должен быть помещен в двоичный режим с hSetBinaryMode для правильной работы hGetContents.

hGet :: Handle -> Int -> IO ByteString Source

Прочитать n байтов в ByteString, непосредственно из указанного Handle.

hGetNonBlocking :: Handle -> Int -> IO ByteString Source

hGetNonBlocking аналогичен hGet, за исключением того, что он никогда не будет блокироваться, ожидая доступности данных, а вместо этого возвращает только доступные данные. Если данных для чтения нет, hGetNonBlocking возвращает empty.

Примечание: в Windows и с реализациями Haskell, отличными от GHC, эта функция работает неправильно; она ведет себя идентично hGet.

hPut :: Handle -> ByteString -> IO () Source

Выводит ByteString в указанный Handle.

hPutNonBlocking :: Handle -> ByteString -> IO ByteString Source

Аналогично hPut, но никогда не блокируется. Вместо этого возвращает любой фрагмент, который не был записан. Этот фрагмент может быть empty, если вся строка была записана, или вся исходная строка, если ничего не было записано. Также возможны частичные записи.

Примечание: в Windows и с реализациями Haskell, отличными от GHC, эта функция работает неправильно; она ведет себя идентично hPut.

hPutStr :: Handle -> ByteString -> IO () Source

Синоним hPut, для совместимости