ByteString.Latin1

Latin-1 ByteString

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

Applied to a predicate and a ByteString, all determines if all elements of the ByteString satisfy the predicate.

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

Applied to a predicate and a ByteString, any determines if any element of the ByteString satisfies the predicate.

append :: ByteString -> ByteString -> ByteString

O(n) Append two ByteStrings

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

break p is equivalent to span (not . p).

breakEnd :: (Char -> Bool) -> ByteString -> (ByteString, ByteString)

breakEnd behaves like break but from the end of the ByteString

breakEnd p == spanEnd (not.p)

breakSubstring

Arguments

:: ByteString

String to search for

-> ByteString

String to search in

-> (ByteString, ByteString)

Head and tail of string broken at substring

Break a string on a substring, returning a pair of the part of the string prior to the match, and the rest of the string.

The following relationships hold:

break (== c) l == breakSubstring (singleton c) l

and:

findSubstring s l ==
   if null s then Just 0
             else case breakSubstring s l of
                      (x,y) | null y    -> Nothing
                            | otherwise -> Just (length x)

For example, to tokenise a string, dropping delimiters:

tokenise x y = h : if null t then [] else tokenise x (drop (length x) t)
    where (h,t) = breakSubstring x y

To skip to the first occurence of a string:

snd (breakSubstring x y)

To take the parts of a string before a delimiter:

fst (breakSubstring x y)

Note that calling `breakSubstring x` does some preprocessing work, so you should avoid unnecessarily duplicating breakSubstring calls with the same pattern.

concat :: [ByteString] -> ByteString

O(n) Concatenate a list of ByteStrings.

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

Map a function over a ByteString and concatenate the results

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

O(n) cons is analogous to (:) for lists, but of different complexity, as it requires a memcpy.

copy :: ByteString -> ByteString

O(n) Make a copy of the ByteString with its own storage. This is mainly useful to allow the rest of the data pointed to by the ByteString to be garbage collected, for example if a large string has been read in, and only a small part of it is needed in the rest of the program.

count :: Char -> ByteString -> Int

count returns the number of times its argument appears in the ByteString

count = length . elemIndices

Also

count '\n' == length . lines

But more efficiently than using length on the intermediate list.

drop :: Int -> ByteString -> ByteString

O(1) drop n xs returns the suffix of xs after the first n elements, or [] if n > length xs.

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

dropWhile p xs returns the suffix remaining after takeWhile p xs.

elem :: Char -> ByteString -> Bool

O(n) elem is the ByteString membership predicate. This implementation uses memchr(3).

elemIndex :: Char -> ByteString -> Maybe Int

O(n) The elemIndex function returns the index of the first element in the given ByteString which is equal (by memchr) to the query element, or Nothing if there is no such element.

elemIndexEnd :: Char -> ByteString -> Maybe Int

O(n) The elemIndexEnd function returns the last index of the element in the given ByteString which is equal to the query element, or Nothing if there is no such element. The following holds:

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

elemIndices :: Char -> ByteString -> [Int]

O(n) The elemIndices function extends elemIndex, by returning the indices of all elements equal to the query element, in ascending order.

empty :: ByteString

O(1) The empty ByteString

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

O(n) filter, applied to a predicate and a ByteString, returns a ByteString containing those characters that satisfy the predicate.

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

O(n) The find function takes a predicate and a ByteString, and returns the first element in matching the predicate, or Nothing if there is no such element.

findIndex :: (Char -> Bool) -> ByteString -> Maybe Int

The findIndex function takes a predicate and a ByteString and returns the index of the first element in the ByteString satisfying the predicate.

findIndices :: (Char -> Bool) -> ByteString -> [Int]

The findIndices function extends findIndex, by returning the indices of all elements satisfying the predicate, in ascending order.

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

'foldl\'' is like foldl, but strict in the accumulator.

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

'foldr\'' is a strict variant of foldr

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

foldr, applied to a binary operator, a starting value (typically the right-identity of the operator), and a packed string, reduces the packed string using the binary operator, from right to left.

group :: ByteString -> [ByteString]

The group function takes a ByteString and returns a list of ByteStrings such that the concatenation of the result is equal to the argument. Moreover, each sublist in the result contains only equal elements. For example,

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

It is a special case of groupBy, which allows the programmer to supply their own equality test. It is about 40% faster than groupBy (==)

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

The groupBy function is the non-overloaded version of group.

inits :: ByteString -> [ByteString]

O(n) Return all initial segments of the given ByteString, shortest first.

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

O(n) The intercalate function takes a ByteString and a list of ByteStrings and concatenates the list after interspersing the first argument between each element of the list.

intersperse :: Char -> ByteString -> ByteString

O(n) The intersperse function takes a Char and a ByteString and `intersperses' that Char between the elements of the ByteString. It is analogous to the intersperse function on Lists.

isInfixOf :: ByteString -> ByteString -> Bool

Check whether one string is a substring of another. isInfixOf p s is equivalent to not (null (findSubstrings p s)).

isPrefixOf :: ByteString -> ByteString -> Bool

O(n) The isPrefixOf function takes two ByteStrings and returns True if the first is a prefix of the second.

isSuffixOf :: ByteString -> ByteString -> Bool

O(n) The isSuffixOf function takes two ByteStrings and returns True iff the first is a suffix of the second.

The following holds:

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

However, the real implemenation uses memcmp to compare the end of the string only, with no reverse required..

length :: ByteString -> Int

O(1) length returns the length of a ByteString as an Int.

lines :: ByteString -> [ByteString]

lines breaks a ByteString up into a list of ByteStrings at newline Chars. The resulting strings do not contain newlines.

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

O(n) map f xs is the ByteString obtained by applying f to each element of xs

mapAccumL :: (acc -> Char -> (acc, Char)) -> acc -> ByteString -> (acc, ByteString)

The mapAccumL function behaves like a combination of map and foldl; it applies a function to each element of a ByteString, passing an accumulating parameter from left to right, and returning a final value of this accumulator together with the new list.

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

The mapAccumR function behaves like a combination of map and foldr; it applies a function to each element of a ByteString, passing an accumulating parameter from right to left, and returning a final value of this accumulator together with the new ByteString.

notElem :: Char -> ByteString -> Bool

O(n) notElem is the inverse of elem

null :: ByteString -> Bool

O(1) Test whether a ByteString is empty.

pack :: String -> ByteString

O(n) Convert a String into a ByteString

For applications with large numbers of string literals, pack can be a bottleneck.

packCString :: CString -> IO ByteString

O(n). Construct a new ByteString from a CString. The resulting ByteString is an immutable copy of the original CString, and is managed on the Haskell heap. The original CString must be null terminated.

packCStringLen :: CStringLen -> IO ByteString

O(n). Construct a new ByteString from a CStringLen. The resulting ByteString is an immutable copy of the original CStringLen. The ByteString is a normal Haskell value and will be managed on the Haskell heap.

packDecimal :: Integral a => a -> Maybe ByteString

Convert a non-negative integer into an (unsigned) ASCII decimal string. Returns Nothing on negative inputs.

packHexadecimal :: Integral a => a -> Maybe ByteString

Convert a non-negative integer into a lower-case ASCII hexadecimal string. Returns Nothing on negative inputs.

packOctal :: Integral a => a -> Maybe ByteString

Convert a non-negative integer into an ASCII octal string. Returns Nothing on negative inputs.

readDecimal :: Integral a => ByteString -> Maybe (a, ByteString)

Read an unsigned/non-negative integral value in ASCII decimal format. Returns Nothing if there is no integer at the beginning of the string, otherwise returns Just the integer read and the remainder of the string.

If you are extremely concerned with performance, then it is more performant to use this function at Int or Word and then to call fromIntegral to perform the conversion at the end. However, doing this will make your code succeptible to overflow bugs if the target type is larger than Int.

readInt :: ByteString -> Maybe (Int, ByteString)

readInt reads an Int from the beginning of the ByteString. If there is no integer at the beginning of the string, it returns Nothing, otherwise it just returns the int read, and the rest of the string.

readInteger :: ByteString -> Maybe (Integer, ByteString)

readInteger reads an Integer from the beginning of the ByteString. If there is no integer at the beginning of the string, it returns Nothing, otherwise it just returns the int read, and the rest of the string.

readHexadecimal :: Integral a => ByteString -> Maybe (a, ByteString)

Read a non-negative integral value in ASCII hexadecimal format. Returns Nothing if there is no integer at the beginning of the string, otherwise returns Just the integer read and the remainder of the string.

This function does not recognize the various hexadecimal sigils like "0x", but because there are so many different variants, those are best handled by helper functions which then use this function for the actual numerical parsing. This function recognizes both upper-case, lower-case, and mixed-case hexadecimal.

readOctal :: Integral a => ByteString -> Maybe (a, ByteString)

Read a non-negative integral value in ASCII octal format. Returns Nothing if there is no integer at the beginning of the string, otherwise returns Just the integer read and the remainder of the string.

This function does not recognize the various octal sigils like "0o", but because there are different variants, those are best handled by helper functions which then use this function for the actual numerical parsing.

readSigned :: Num a => (ByteString -> Maybe (a, ByteString)) -> ByteString -> Maybe (a, ByteString)

Adjust a reading function to recognize an optional leading sign. As with the other functions, we assume an ASCII-compatible encoding of the sign characters.

replicate :: Int -> Char -> ByteString

O(n) replicate n x is a ByteString of length n with x the value of every element. The following holds:

replicate w c = unfoldr w (\u -> Just (u,u)) c

This implemenation uses memset(3)

reverse :: ByteString -> ByteString

O(n) reverse xs efficiently returns the elements of xs in reverse order.

scanl :: (Char -> Char -> Char) -> Char -> ByteString -> ByteString

scanl is similar to foldl, but returns a list of successive reduced values from the left:

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

Note that

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

scanl1 :: (Char -> Char -> Char) -> ByteString -> ByteString

scanl1 is a variant of scanl that has no starting value argument:

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

scanr :: (Char -> Char -> Char) -> Char -> ByteString -> ByteString

scanr is the right-to-left dual of scanl.

scanr1 :: (Char -> Char -> Char) -> ByteString -> ByteString

scanr1 is a variant of scanr that has no starting value argument.

singleton :: Char -> ByteString

O(1) Convert a Char into a ByteString

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

O(n) Append a Char to the end of a ByteString. Similar to cons, this function performs a memcpy.

sort :: ByteString -> ByteString

O(n) Sort a ByteString efficiently, using counting sort.

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

span p xs breaks the ByteString into two segments. It is equivalent to (takeWhile p xs, dropWhile p xs)

spanEnd :: (Char -> Bool) -> ByteString -> (ByteString, ByteString)

spanEnd behaves like span but from the end of the ByteString. We have

spanEnd (not.isSpace) "x y z" == ("x y ","z")

and

spanEnd (not . isSpace) ps
   ==
let (x,y) = span (not.isSpace) (reverse ps) in (reverse y, reverse x)

split :: Char -> ByteString -> [ByteString]

O(n) Break a ByteString into pieces separated by the byte argument, consuming the delimiter. I.e.

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

and

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

As for all splitting functions in this library, this function does not copy the substrings, it just constructs new ByteStrings that are slices of the original.

splitAt :: Int -> ByteString -> (ByteString, ByteString)

O(1) splitAt n xs is equivalent to (take n xs, drop n xs).

splitWith :: (Char -> Bool) -> ByteString -> [ByteString]

O(n) Splits a ByteString into components delimited by separators, where the predicate returns True for a separator element. The resulting components do not contain the separators. Two adjacent separators result in an empty component in the output. eg.

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

stripPrefix :: ByteString -> ByteString -> Maybe ByteString

O(n) The stripPrefix function takes two ByteStrings and returns Just the remainder of the second iff the first is its prefix, and otherwise Nothing.

Since: bytestring-0.10.8.0

stripSuffix :: ByteString -> ByteString -> Maybe ByteString

O(n) The stripSuffix function takes two ByteStrings and returns Just the remainder of the second iff the first is its suffix, and otherwise Nothing.

tails :: ByteString -> [ByteString]

O(n) Return all final segments of the given ByteString, longest first.

take :: Int -> ByteString -> ByteString

O(1) take n, applied to a ByteString xs, returns the prefix of xs of length n, or xs itself if n > length xs.

takeWhile :: (Char -> Bool) -> ByteString -> ByteString

takeWhile, applied to a predicate p and a ByteString xs, returns the longest prefix (possibly empty) of xs of elements that satisfy p.

transpose :: [ByteString] -> [ByteString]

The transpose function transposes the rows and columns of its ByteString argument.

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

O(1) Extract the head and tail of a ByteString, returning Nothing if it is empty.

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

O(n), where n is the length of the result. The unfoldr function is analogous to the List 'unfoldr'. unfoldr builds a ByteString from a seed value. The function takes the element and returns Nothing if it is done producing the ByteString or returns Just (a,b), in which case, a is the next character in the string, and b is the seed value for further production.

Examples:

unfoldr (\x -> if x <= '9' then Just (x, succ x) else Nothing) '0' == "0123456789"

unfoldrN :: Int -> (a -> Maybe (Char, a)) -> a -> (ByteString, Maybe a)

O(n) Like unfoldr, unfoldrN builds a ByteString from a seed value. However, the length of the result is limited by the first argument to unfoldrN. This function is more efficient than unfoldr when the maximum length of the result is known.

The following equation relates unfoldrN and unfoldr:

unfoldrN n f s == take n (unfoldr f s)

unlines :: [ByteString] -> ByteString

unlines is an inverse operation to lines. It joins lines, after appending a terminating newline to each.

unpack :: ByteString -> [Char]

O(n) Converts a ByteString to a String.

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

O(1) Extract the init and last of a ByteString, returning Nothing if it is empty.

unwords :: [ByteString] -> ByteString

The unwords function is analogous to the unlines function, on words.

unzip :: [(Char, Char)] -> (ByteString, ByteString)

unzip transforms a list of pairs of Chars into a pair of ByteStrings. Note that this performs two pack operations.

useAsCString :: ByteString -> (CString -> IO a) -> IO a

O(n) construction Use a ByteString with a function requiring a null-terminated CString. The CString is a copy and will be freed automatically; it must not be stored or used after the subcomputation finishes.

useAsCStringLen :: ByteString -> (CStringLen -> IO a) -> IO a

O(n) construction Use a ByteString with a function requiring a CStringLen. As for useAsCString this function makes a copy of the original ByteString. It must not be stored or used after the subcomputation finishes.

words :: ByteString -> [ByteString]

words breaks a ByteString up into a list of words, which were delimited by Chars representing white space.

zip :: ByteString -> ByteString -> [(Char, Char)]

O(n) zip takes two ByteStrings and returns a list of corresponding pairs of Chars. If one input ByteString is short, excess elements of the longer ByteString are discarded. This is equivalent to a pair of unpack operations, and so space usage may be large for multi-megabyte ByteStrings

zipWith :: (Char -> Char -> a) -> ByteString -> ByteString -> [a]

zipWith generalises zip by zipping with the function given as the first argument, instead of a tupling function. For example, zipWith (+) is applied to two ByteStrings to produce the list of corresponding sums.

Optics

chars :: IsByteString t => IndexedTraversal' Int t Char

Traverse the individual bytes in a strict or lazy ByteString as characters.

When writing back to the ByteString it is assumed that every Char lies between '\x00' and '\xff'.

This Traversal walks each strict ByteString chunk in a tree-like fashion enable zippers to seek to locations more quickly and accelerate many monoidal queries, but up to associativity (and constant factors) it is equivalent to the much slower:

chars ≡ unpackedChars . traversed

anyOf chars (== 'c') :: ByteString -> Bool

packedChars :: IsByteString t => Iso' String t

pack (or unpack) a list of characters into a strict or lazy ByteString.

When writing back to the ByteString it is assumed that every Char lies between '\x00' and '\xff'.

pack x ≡ x ^. packedChars
unpack x ≡ x ^. from packedChars
packedChars ≡ from unpackedChars

unpackedChars :: IsByteString t => Iso' t String

unpack (or pack) a list of characters into a strict (or lazy) ByteString

When writing back to the ByteString it is assumed that every Char lies between '\x00' and '\xff'.

unpackedChars ≡ from packedChars
unpack x ≡ x ^. unpackedChars
pack x ≡ x ^. from unpackedChars

unpackedChars :: Iso' ByteString String
unpackedChars :: Iso' ByteString String