Data.ByteString.Lazy.Char8

import qualified Data.ByteString.Lazy.Char8 as C

Тип ByteString

data ByteString Source

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

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

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

empty :: ByteString Source

O(1) Пустая ByteString

singleton :: Char -> ByteString Source

O(1) Преобразует Char в ByteString

pack :: [Char] -> ByteString Source

O(n) Преобразует String в ByteString.

unpack :: ByteString -> [Char] Source

O(n) Преобразует ByteString в String.

fromChunks :: [ByteString] -> ByteString Source

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

toChunks :: ByteString -> [ByteString] Source

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

fromStrict :: ByteString -> ByteString Source

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

toStrict :: ByteString -> ByteString Source

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

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

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

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

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

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

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

Это означает, что вы не можете использовать ленивое рекурсивное построение, подобное этому:

let xs = cons\' c xs in xs

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

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

O(n) Добавить Char в конец ByteString. Аналогично cons, эта функция выполняет memcpy.

append :: ByteString -> ByteString -> ByteString Source

O(n/c) Объединение двух ByteString

head :: ByteString -> Char Source

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

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

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

last :: ByteString -> Char Source

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

tail :: ByteString -> ByteString Source

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

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

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

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

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

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

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

reverse :: ByteString -> ByteString Source

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

intersperse :: Char -> ByteString -> ByteString Source

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

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

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

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

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

Сведение ByteString (свертки)

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

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

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

'foldl\' — это как foldl, но строгое относительно аккумулятора.

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

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

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

'foldl1\'' — это как foldl1, но строгое относительно аккумулятора.

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

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

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

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

Специальные свертки

concat :: [ByteString] -> ByteString Source

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

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

Применить функцию к ByteString и объединить результаты

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

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

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

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

maximum :: ByteString -> Char Source

maximum возвращает максимальное значение из ByteString

minimum :: ByteString -> Char Source

minimum возвращает минимальное значение из ByteString

Создание ByteString

Считывание

scanl :: (Char -> Char -> Char) -> Char -> 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 -> Char -> (acc, Char)) -> acc -> ByteString -> (acc, ByteString) Source

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

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

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

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

repeat :: Char -> ByteString Source

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

replicate :: Int64 -> Char -> ByteString Source

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

cycle :: ByteString -> ByteString Source

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

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

iterate f x возвращает бесконечную ByteString с многократным применением f к x:

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

Разворачивание ByteString

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

O(n) Функция unfoldr аналогична List '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 :: (Char -> Bool) -> ByteString -> ByteString Source

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

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

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

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

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

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

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

group :: ByteString -> [ByteString] Source

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

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

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

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

Функция groupBy является неперегруженной версией group

inits :: ByteString -> [ByteString] Source

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

tails :: ByteString -> [ByteString] Source

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

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

split :: Char -> 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 :: (Char -> Bool) -> ByteString -> [ByteString] Source

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

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

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

lines :: ByteString -> [ByteString] Source

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

Начиная с bytestring 0.9.0.3, эта функция более строгая, чем ее аналог для списков.

words :: ByteString -> [ByteString] Source

words разбивает ByteString на список слов, которые были ограничены символами пробела. И

tokens isSpace = words

unlines :: [ByteString] -> ByteString Source

unlines — обратная операция к lines. Она объединяет строки, после добавления завершающей новой строки к каждой.

unwords :: [ByteString] -> ByteString Source

Функция unwords аналогична функции unlines для слов.

Предикаты

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 :: Char -> ByteString -> Bool Source

O(n) elem — предикат членства. Эта реализация использует memchr(3)

notElem :: Char -> ByteString -> Bool Source

O(n) notElem — обратная функция elem

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

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

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

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

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

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

index :: ByteString -> Int64 -> Char Source

O(1) Оператор индекса (подстроки), начиная с 0.

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

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

elemIndices :: Символ -> ByteString -> [Int64] Источник

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

findIndex :: (Символ -> Bool) -> ByteString -> Может быть Int64 Источник

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

findIndices :: (Символ -> Bool) -> ByteString -> [Int64] Источник

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

count :: Символ -> ByteString -> Int64 Источник

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

count      == length . elemIndices
count '\n' == length . lines

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

Сборка и распаковку ByteString

zip :: ByteString -> ByteString -> [(Символ, Символ)] Источник

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

zipWith :: (Символ -> Символ -> a) -> ByteString -> ByteString -> [a] Источник

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

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

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

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

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

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

Чтение из ByteString

readInt :: ByteString -> Может быть (Целое число, ByteString) Источник

readInt считывает целое число Int с начала ByteString. Если в начале строки нет целого числа, возвращается Nothing, иначе возвращается только что прочитанное целое число и остальная часть строки.

readInteger :: ByteString -> Может быть (Целое число, ByteString) Источник

readInteger считывает целое число Integer с начала ByteString. Если в начале строки нет целого числа, возвращается Nothing, иначе возвращается только что прочитанное целое число и остальная часть строки.

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

Ввод-вывод ByteString использует двоичный режим без декодирования символов или преобразования новой строки. То, что он не соблюдает режим новой строки в Handle, считается недостатком и может быть изменено в будущих версиях.

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

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

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

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

Записать ByteString в stdout

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

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

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

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

Файлы

readFile :: Путь к файлу -> IO ByteString Источник

Прочитать весь файл лениво в ByteString.

writeFile :: Путь к файлу -> ByteString -> IO () Источник

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

appendFile :: Путь к файлу -> ByteString -> IO () Источник

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

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

hGetContents :: Дескриптор файла -> IO ByteString Источник

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

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

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

hGet :: Дескриптор файла -> Целое число -> IO ByteString Источник

Прочитать 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, для совместимости.

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

Запись ByteString в обработчик с добавлением байта новой строки.