rio-0.1.8.0: A standard library for Haskell

Safe Haskell | None
Language | Haskell2010

RIO.ByteString

Description

Strict `ByteString`. Import as:

    import qualified RIO.ByteString as B

Synopsis

- data ByteString
- copy :: ByteString -> ByteString
- sort :: ByteString -> ByteString
- tails :: ByteString -> [ByteString]
- inits :: ByteString -> [ByteString]
- unzip :: [(Word8, Word8)] -> (ByteString, ByteString)
- zipWith :: (Word8 -> Word8 -> a) -> ByteString -> ByteString -> [a]
- zip :: ByteString -> ByteString -> [(Word8, Word8)]
- breakSubstring :: ByteString -> ByteString -> (ByteString, ByteString)
- isInfixOf :: ByteString -> ByteString -> Bool
- stripSuffix :: ByteString -> ByteString -> Maybe ByteString
- isSuffixOf :: ByteString -> ByteString -> Bool
- stripPrefix :: ByteString -> ByteString -> Maybe ByteString
- isPrefixOf :: ByteString -> ByteString -> Bool
- partition :: (Word8 -> Bool) -> ByteString -> (ByteString, ByteString)
- find :: (Word8 -> Bool) -> ByteString -> Maybe Word8
- filter :: (Word8 -> Bool) -> ByteString -> ByteString
- notElem :: Word8 -> ByteString -> Bool
- elem :: Word8 -> ByteString -> Bool
- findIndices :: (Word8 -> Bool) -> ByteString -> [Int]
- findIndex :: (Word8 -> Bool) -> ByteString -> Maybe Int
- count :: Word8 -> ByteString -> Int
- elemIndices :: Word8 -> ByteString -> [Int]
- elemIndexEnd :: Word8 -> ByteString -> Maybe Int
- elemIndex :: Word8 -> ByteString -> Maybe Int
- index :: ByteString -> Int -> Word8
- intercalate :: ByteString -> [ByteString] -> ByteString
- groupBy :: (Word8 -> Word8 -> Bool) -> ByteString -> [ByteString]
- group :: ByteString -> [ByteString]
- split :: Word8 -> ByteString -> [ByteString]
- splitWith :: (Word8 -> Bool) -> ByteString -> [ByteString]
- spanEnd :: (Word8 -> Bool) -> ByteString -> (ByteString, ByteString)
- span :: (Word8 -> Bool) -> ByteString -> (ByteString, ByteString)
- breakEnd :: (Word8 -> Bool) -> ByteString -> (ByteString, ByteString)
- break :: (Word8 -> Bool) -> ByteString -> (ByteString, ByteString)
- dropWhile :: (Word8 -> Bool) -> ByteString -> ByteString
- takeWhile :: (Word8 -> Bool) -> ByteString -> ByteString
- splitAt :: Int -> ByteString -> (ByteString, ByteString)
- drop :: Int -> ByteString -> ByteString
- take :: Int -> ByteString -> ByteString
- unfoldrN :: Int -> (a -> Maybe (Word8, a)) -> a -> (ByteString, Maybe a)
- unfoldr :: (a -> Maybe (Word8, a)) -> a -> ByteString
- replicate :: Int -> Word8 -> ByteString
- scanr1 :: (Word8 -> Word8 -> Word8) -> ByteString -> ByteString
- scanr :: (Word8 -> Word8 -> Word8) -> Word8 -> ByteString -> ByteString
- scanl1 :: (Word8 -> Word8 -> Word8) -> ByteString -> ByteString
- scanl :: (Word8 -> Word8 -> Word8) -> Word8 -> ByteString -> ByteString
- mapAccumR :: (acc -> Word8 -> (acc, Word8)) -> acc -> ByteString -> (acc, ByteString)
- mapAccumL :: (acc -> Word8 -> (acc, Word8)) -> acc -> ByteString -> (acc, ByteString)
- all :: (Word8 -> Bool) -> ByteString -> Bool
- any :: (Word8 -> Bool) -> ByteString -> Bool
- concatMap :: (Word8 -> ByteString) -> ByteString -> ByteString
- concat :: [ByteString] -> ByteString
- foldr' :: (Word8 -> a -> a) -> a -> ByteString -> a
- foldr :: (Word8 -> a -> a) -> a -> ByteString -> a
- foldl' :: (a -> Word8 -> a) -> a -> ByteString -> a
- foldl :: (a -> Word8 -> a) -> a -> ByteString -> a
- transpose :: [ByteString] -> [ByteString]
- intersperse :: Word8 -> ByteString -> ByteString
- reverse :: ByteString -> ByteString
- map :: (Word8 -> Word8) -> ByteString -> ByteString
- append :: ByteString -> ByteString -> ByteString
- unsnoc :: ByteString -> Maybe (ByteString, Word8)
- uncons :: ByteString -> Maybe (Word8, ByteString)
- snoc :: ByteString -> Word8 -> ByteString
- cons :: Word8 -> ByteString -> ByteString
- length :: ByteString -> Int
- null :: ByteString -> Bool
- unpack :: ByteString -> [Word8]
- pack :: [Word8] -> ByteString
- singleton :: Word8 -> ByteString
- empty :: ByteString
- packCString :: MonadIO m => CString -> m ByteString
- packCStringLen :: MonadIO m => CStringLen -> m ByteString
- useAsCString :: MonadUnliftIO m => ByteString -> (CString -> m a) -> m a
- useAsCStringLen :: MonadUnliftIO m => ByteString -> (CStringLen -> m a) -> m a
- getLine :: MonadIO m => m ByteString
- getContents :: MonadIO m => m ByteString
- putStr :: MonadIO m => ByteString -> m ()
- interact :: MonadIO m => (ByteString -> ByteString) -> m ()
- readFile :: MonadIO m => FilePath -> m ByteString
- writeFile :: MonadIO m => FilePath -> ByteString -> m ()
- appendFile :: MonadIO m => FilePath -> ByteString -> m ()
- hGetLine :: MonadIO m => Handle -> m ByteString
- hGetContents :: MonadIO m => Handle -> m ByteString
- hGet :: MonadIO m => Handle -> Int -> m ByteString
- hGetSome :: MonadIO m => Handle -> Int -> m ByteString
- hGetNonBlocking :: MonadIO m => Handle -> Int -> m ByteString
- hPut :: MonadIO m => Handle -> ByteString -> m ()
- hPutNonBlocking :: MonadIO m => Handle -> ByteString -> m ByteString
- hPutStr :: MonadIO m => Handle -> ByteString -> m ()

# Documentation

data ByteString Source #

A space-efficient representation of a `Word8` vector, supporting many efficient operations.

A `ByteString` contains 8-bit bytes, or by using the operations from Data.ByteString.Char8 it can be interpreted as containing 8-bit characters.

Instances

Eq ByteString |
Instance details Defined in Data.ByteString.Internal Methods (==) :: ByteString -> ByteString -> Bool Source # (/=) :: ByteString -> ByteString -> Bool Source #
Data ByteString |

Instance details

Defined in Data.ByteString.Internal

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ByteString -> c ByteString Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ByteString Source #

toConstr :: ByteString -> Constr Source #

dataTypeOf :: ByteString -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ByteString) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ByteString) Source #

gmapT :: (forall b. Data b => b -> b) -> ByteString -> ByteString Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ByteString -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ByteString -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> ByteString -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ByteString -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ByteString -> m ByteString Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ByteString -> m ByteString Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ByteString -> m ByteString Source #

Ord ByteString |

Instance details

Defined in Data.ByteString.Internal

Methods

compare :: ByteString -> ByteString -> Ordering Source #

(<) :: ByteString -> ByteString -> Bool Source #

(<=) :: ByteString -> ByteString -> Bool Source #

(>) :: ByteString -> ByteString -> Bool Source #

(>=) :: ByteString -> ByteString -> Bool Source #

max :: ByteString -> ByteString -> ByteString Source #

min :: ByteString -> ByteString -> ByteString Source #

Read ByteString |
Instance details Defined in Data.ByteString.Internal Methods readsPrec :: Int -> ReadS ByteString Source # readList :: ReadS [ByteString] Source # readPrec :: ReadPrec ByteString Source # readListPrec :: ReadPrec [ByteString] Source #
Show ByteString |
Instance details Defined in Data.ByteString.Internal Methods showsPrec :: Int -> ByteString -> ShowS Source # show :: ByteString -> String Source # showList :: [ByteString] -> ShowS Source #
IsString ByteString |
Instance details Defined in Data.ByteString.Internal Methods fromString :: String -> ByteString Source #
Semigroup ByteString |
Instance details Defined in Data.ByteString.Internal Methods (<>) :: ByteString -> ByteString -> ByteString Source # sconcat :: NonEmpty ByteString -> ByteString Source # stimes :: Integral b => b -> ByteString -> ByteString Source #
Monoid ByteString |
Instance details Defined in Data.ByteString.Internal Methods mempty :: ByteString Source # mappend :: ByteString -> ByteString -> ByteString Source # mconcat :: [ByteString] -> ByteString Source #
NFData ByteString |
Instance details Defined in Data.ByteString.Internal Methods rnf :: ByteString -> () Source #
Hashable ByteString |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> ByteString -> Int Source # hash :: ByteString -> Int Source #

copy :: ByteString -> ByteString Source #

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.

sort :: ByteString -> ByteString Source #

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

tails :: ByteString -> [ByteString] Source #

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

inits :: ByteString -> [ByteString] Source #

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

unzip :: [(Word8, Word8)] -> (ByteString, ByteString) Source #

O(n) `unzip` transforms a list of pairs of bytes into a pair of ByteStrings. Note that this performs two `pack` operations.

zipWith :: (Word8 -> Word8 -> a) -> ByteString -> ByteString -> [a] Source #

`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.

zip :: ByteString -> ByteString -> [(Word8, Word8)] Source #

O(n) `zip` takes two ByteStrings and returns a list of corresponding pairs of bytes. If one input ByteString is short, excess elements of the longer ByteString are discarded. This is equivalent to a pair of `unpack` operations.

breakSubstring Source #

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.

isInfixOf :: ByteString -> ByteString -> Bool Source #

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

stripSuffix :: ByteString -> ByteString -> Maybe ByteString Source #

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`.

isSuffixOf :: ByteString -> ByteString -> Bool Source #

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..

stripPrefix :: ByteString -> ByteString -> Maybe ByteString Source #

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

isPrefixOf :: ByteString -> ByteString -> Bool Source #

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

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

O(n) The `partition` function takes a predicate a ByteString and returns the pair of ByteStrings with elements which do and do not satisfy the predicate, respectively; i.e.,

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

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

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.

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

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

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

notElem :: Word8 -> ByteString -> Bool Source #

O(n) `notElem` is the inverse of `elem`

elem :: Word8 -> ByteString -> Bool Source #

O(n) `elem` is the `ByteString` membership predicate.

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

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

findIndex :: (Word8 -> Bool) -> ByteString -> Maybe Int Source #

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

count :: Word8 -> ByteString -> Int Source #

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

    count = length . elemIndices

But more efficiently than using length on the intermediate list.

elemIndices :: Word8 -> ByteString -> [Int] Source #

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

elemIndexEnd :: Word8 -> ByteString -> Maybe Int Source #

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)

elemIndex :: Word8 -> ByteString -> Maybe Int Source #

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

index :: ByteString -> Int -> Word8 Source #

O(1) `ByteString` index (subscript) operator, starting from 0.

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

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

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

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

group :: ByteString -> [ByteString] Source #

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 (==)

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

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.

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

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",""]
    splitWith (=='a') []        == []

spanEnd :: (Word8 -> Bool) -> ByteString -> (ByteString, ByteString) Source #

`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)

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

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

breakEnd :: (Word8 -> Bool) -> ByteString -> (ByteString, ByteString) Source #

`breakEnd` behaves like `break` but from the end of the `ByteString`

breakEnd p == spanEnd (not.p)

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

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

Under GHC, a rewrite rule will transform break (==) into a call to the specialised breakByte:

    break ((==) x) = breakByte x
    break (==x) = breakByte x

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

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

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

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

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

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

drop :: Int -> ByteString -> ByteString Source #

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

take :: Int -> ByteString -> ByteString Source #

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

unfoldrN :: Int -> (a -> Maybe (Word8, a)) -> a -> (ByteString, Maybe a) Source #

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`:

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

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

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 byte in the string, and `b` is the seed value for further production.

Examples:

       unfoldr (\x -> if x <= 5 then Just (x, x + 1) else Nothing) 0
    == pack [0, 1, 2, 3, 4, 5]

replicate :: Int -> Word8 -> ByteString Source #

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)`

scanr1 :: (Word8 -> Word8 -> Word8) -> ByteString -> ByteString Source #

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

scanr :: (Word8 -> Word8 -> Word8) -> Word8 -> ByteString -> ByteString Source #

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

scanl1 :: (Word8 -> Word8 -> Word8) -> ByteString -> ByteString Source #

`scanl1` is a variant of `scanl` that has no starting value argument. This function will fuse.

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

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

`scanl` is similar to `foldl`, but returns a list of successive reduced values from the left. This function will fuse.

    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.

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

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.

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

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.

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

O(n) Applied to a predicate and a `ByteString`, `all` determines if all elements of the `ByteString` satisfy the predicate.

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

O(n) Applied to a predicate and a ByteString, `any` determines if any element of the `ByteString` satisfies the predicate.

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

Map a function over a `ByteString` and concatenate the results

concat :: [ByteString] -> ByteString Source #

O(n) Concatenate a list of ByteStrings.

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

`foldr'` is like `foldr`, but strict in the accumulator.

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

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

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

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

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

`foldl`, applied to a binary operator, a starting value (typically the left-identity of the operator), and a ByteString, reduces the ByteString using the binary operator, from left to right.

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

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

intersperse :: Word8 -> ByteString -> ByteString Source #

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

reverse :: ByteString -> ByteString Source #

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

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

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

append :: ByteString -> ByteString -> ByteString Source #

O(n) Append two ByteStrings

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

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

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

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

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

O(n) Append a byte to the end of a `ByteString`

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

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

length :: ByteString -> Int Source #

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

null :: ByteString -> Bool Source #

O(1) Test whether a ByteString is empty.

unpack :: ByteString -> [Word8] Source #

O(n) Converts a `ByteString` to a `[`Word8`]`.

pack :: [Word8] -> ByteString Source #

O(n) Convert a `[`Word8`]` into a `ByteString`.

For applications with large numbers of string literals, pack can be a bottleneck. In such cases, consider using packAddress (GHC only).

singleton :: Word8 -> ByteString Source #

O(1) Convert a `Word8` into a `ByteString`

empty :: ByteString Source #

O(1) The empty `ByteString`

packCString :: MonadIO m => CString -> m ByteString Source #

Lifted `packCString`

packCStringLen :: MonadIO m => CStringLen -> m ByteString Source #

Lifted `packCStringLen`

useAsCString :: MonadUnliftIO m => ByteString -> (CString -> m a) -> m a Source #

Unlifted `useAsCString`

useAsCStringLen :: MonadUnliftIO m => ByteString -> (CStringLen -> m a) -> m a Source #

Unlifted `useAsCStringLen`

getLine :: MonadIO m => m ByteString Source #

Lifted `getLine`

getContents :: MonadIO m => m ByteString Source #

Lifted `getContents`

putStr :: MonadIO m => ByteString -> m () Source #

Lifted `putStr`

interact :: MonadIO m => (ByteString -> ByteString) -> m () Source #

Lifted `interact`

readFile :: MonadIO m => FilePath -> m ByteString Source #

Lifted `readFile`

writeFile :: MonadIO m => FilePath -> ByteString -> m () Source #

Lifted `writeFile`

appendFile :: MonadIO m => FilePath -> ByteString -> m () Source #

Lifted `appendFile`

hGetLine :: MonadIO m => Handle -> m ByteString Source #

Lifted `hGetLine`

hGetContents :: MonadIO m => Handle -> m ByteString Source #

Lifted `hGetContents`

hGet :: MonadIO m => Handle -> Int -> m ByteString Source #

Lifted `hGet`

hGetSome :: MonadIO m => Handle -> Int -> m ByteString Source #

Lifted `hGetSome`

hGetNonBlocking :: MonadIO m => Handle -> Int -> m ByteString Source #

Lifted `hGetNonBlocking`

hPut :: MonadIO m => Handle -> ByteString -> m () Source #

Lifted `hPut`

hPutNonBlocking :: MonadIO m => Handle -> ByteString -> m ByteString Source #

Lifted `hPutNonBlocking`

hPutStr :: MonadIO m => Handle -> ByteString -> m () Source #

Lifted `hPutStr`