rio-0.1.22.0: A standard library for Haskell

Safe Haskell | None
Language | Haskell2010

RIO.ByteString

Description

Strict `ByteString`. Import as:

    import qualified RIO.ByteString as B

This module does not export any partial functions. For those, see RIO.ByteString.Partial

Synopsis

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

# Documentation

(!?) :: ByteString -> Int -> Maybe Word8 #

O(1) `ByteString` index, starting from 0, that returns `Just` if:

    0 <= n < length bs

Since: bytestring-0.11.0.0

index :: HasCallStack => ByteString -> Int -> Word8 #

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

This is a partial function, consider using `indexMaybe` instead.

empty :: ByteString #

O(1) The empty `ByteString`

concat :: [ByteString] -> ByteString #

O(n) Concatenate a list of ByteStrings.

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

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

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

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

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

length :: ByteString -> Int #

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

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 string 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 :: (Word8 -> Word8 -> Bool) -> ByteString -> [ByteString] #

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

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

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

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

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

unfoldr :: (a -> Maybe (Word8, 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 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]

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

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

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

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.

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

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

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

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

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

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

null :: ByteString -> Bool #

O(1) Test whether a ByteString is empty.

scanl #

Arguments

:: (Word8 -> Word8 -> Word8) | accumulator -> element -> new accumulator
-> Word8 | starting value of accumulator
-> ByteString | input of length n
-> ByteString | output of length n+1

`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

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

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

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

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

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

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

scanr #

Arguments

:: (Word8 -> Word8 -> Word8) | element -> accumulator -> new accumulator
-> Word8 | starting value of accumulator
-> ByteString | input of length n
-> ByteString | output of length n+1

`scanr` is similar to `foldr`, but returns a list of successive reduced values from the right.

    scanr f z [..., x{n-1}, xn] == [..., x{n-1} `f` (xn `f` z), xn `f` z, z]

Note that

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

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

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

replicate :: Int -> Word8 -> 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 = fst (unfoldrN w (\u -> Just (u,u)) c)

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

Similar to `takeWhile`, returns the longest (possibly empty) prefix of elements satisfying the predicate.

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

Similar to `dropWhile`, drops the longest (possibly empty) prefix of elements satisfying the predicate and returns the remainder.

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

drop :: Int -> ByteString -> ByteString #

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

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

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

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

Similar to `span`, returns the longest (possibly empty) prefix of elements satisfying the predicate and the remainder of the string.

`span` `p` is equivalent to ``break` (not . p)` and to `(`takeWhile` p &&& `dropWhile` p)`.

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

Similar to `break`, returns the longest (possibly empty) prefix of elements which do not satisfy the predicate and the remainder of the string.

`break` `p` is equivalent to ``span` (not . p)` and to `(`takeWhile` (not . p) &&& `dropWhile` (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

reverse :: ByteString -> ByteString #

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

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

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

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

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

elem :: Word8 -> ByteString -> Bool #

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

notElem :: Word8 -> ByteString -> Bool #

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

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

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

zipWith :: (Word8 -> Word8 -> 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.

count :: Word8 -> ByteString -> Int #

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.

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

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

dropWhileEnd :: (Word8 -> Bool) -> ByteString -> ByteString #

Similar to `dropWhileEnd`, drops the longest (possibly empty) suffix of elements satisfying the predicate and returns the remainder.

``dropWhileEnd` p` is equivalent to ``reverse` . `dropWhile` p . `reverse``.

Since: bytestring-0.10.12.0

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

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

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

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

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

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

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

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

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

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 implementation uses memcmp to compare the end of the string only, with no reverse required..

isInfixOf :: ByteString -> ByteString -> Bool #

Check whether one string is a substring of another.

intersperse :: Word8 -> ByteString -> ByteString #

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.

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

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.

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

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)

mapAccumL :: (acc -> Word8 -> (acc, Word8)) -> 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 ByteString.

mapAccumR :: (acc -> Word8 -> (acc, Word8)) -> 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.

inits :: ByteString -> [ByteString] #

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

tails :: ByteString -> [ByteString] #

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

sort :: ByteString -> ByteString #

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

singleton :: Word8 -> ByteString #

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

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

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

append :: ByteString -> ByteString -> ByteString #

O(n) Append two ByteStrings

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.

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

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

data ByteString #

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

Instances details

Data ByteString |
Instance details Defined in Data.ByteString.Internal.Type Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ByteString -> c ByteString # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ByteString # toConstr :: ByteString -> Constr # dataTypeOf :: ByteString -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ByteString) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ByteString) # gmapT :: (forall b. Data b => b -> b) -> ByteString -> ByteString # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ByteString -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ByteString -> r # gmapQ :: (forall d. Data d => d -> u) -> ByteString -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ByteString -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ByteString -> m ByteString # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ByteString -> m ByteString # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ByteString -> m ByteString #
IsString ByteString | Beware: `fromString` truncates multi-byte characters to octets. e.g. "枯朶に烏のとまりけり秋の暮" becomes �6k�nh~�Q��n�
Instance details Defined in Data.ByteString.Internal.Type Methods fromString :: String -> ByteString #
Monoid ByteString |
Instance details Defined in Data.ByteString.Internal.Type Methods mempty :: ByteString # mappend :: ByteString -> ByteString -> ByteString # mconcat :: [ByteString] -> ByteString #
Semigroup ByteString |
Instance details Defined in Data.ByteString.Internal.Type Methods (<>) :: ByteString -> ByteString -> ByteString # sconcat :: NonEmpty ByteString -> ByteString # stimes :: Integral b => b -> ByteString -> ByteString #
IsList ByteString | Since: bytestring-0.10.12.0
Instance details Defined in Data.ByteString.Internal.Type Associated Types
type Item ByteString |
Instance details Defined in Data.ByteString.Internal.Type type Item ByteString = Word8
Methods fromList :: [Item ByteString] -> ByteString # fromListN :: Int -> [Item ByteString] -> ByteString # toList :: ByteString -> [Item ByteString] #
Read ByteString |
Instance details Defined in Data.ByteString.Internal.Type Methods readsPrec :: Int -> ReadS ByteString # readList :: ReadS [ByteString] # readPrec :: ReadPrec ByteString # readListPrec :: ReadPrec [ByteString] #
Show ByteString |
Instance details Defined in Data.ByteString.Internal.Type Methods showsPrec :: Int -> ByteString -> ShowS # show :: ByteString -> String # showList :: [ByteString] -> ShowS #
NFData ByteString |
Instance details Defined in Data.ByteString.Internal.Type Methods rnf :: ByteString -> () #
Eq ByteString |
Instance details Defined in Data.ByteString.Internal.Type Methods (==) :: ByteString -> ByteString -> Bool # (/=) :: ByteString -> ByteString -> Bool #
Ord ByteString |
Instance details Defined in Data.ByteString.Internal.Type Methods compare :: ByteString -> ByteString -> Ordering # (<) :: ByteString -> ByteString -> Bool # (<=) :: ByteString -> ByteString -> Bool # (>) :: ByteString -> ByteString -> Bool # (>=) :: ByteString -> ByteString -> Bool # max :: ByteString -> ByteString -> ByteString # min :: ByteString -> ByteString -> ByteString #
Hashable ByteString |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> ByteString -> Int # hash :: ByteString -> Int #
Lift ByteString | Since: bytestring-0.11.2.0
Instance details Defined in Data.ByteString.Internal.Type Methods lift :: Quote m => ByteString -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => ByteString -> Code m ByteString #
type Item ByteString |
Instance details Defined in Data.ByteString.Internal.Type type Item ByteString = Word8

type StrictByteString = ByteString #

Type synonym for the strict flavour of `ByteString`.

Since: bytestring-0.11.2.0

fromStrict :: StrictByteString -> LazyByteString #

O(1) Convert a `StrictByteString` into a `LazyByteString`.

toStrict :: LazyByteString -> StrictByteString #

O(n) Convert a `LazyByteString` into a `StrictByteString`.

Note that this is an expensive operation that forces the whole `LazyByteString` into memory and then copies all the data. If possible, try to avoid converting back and forth between strict and lazy bytestrings.

indexMaybe :: ByteString -> Int -> Maybe Word8 #

O(1) `ByteString` index, starting from 0, that returns `Just` if:

    0 <= n < length bs

Since: bytestring-0.11.0.0

pack :: [Word8] -> ByteString #

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 `unsafePackAddress` (GHC only).

unpack :: ByteString -> [Word8] #

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

takeEnd :: Int -> ByteString -> ByteString #

O(1) ``takeEnd` n xs` is equivalent to ``drop` (`length` xs - n) xs`. Takes `n` elements from end of bytestring.

    >>> takeEnd 3 "abcdefg"
    "efg"
    >>> takeEnd 0 "abcdefg"
    ""
    >>> takeEnd 4 "abc"
    "abc"

Since: bytestring-0.11.1.0

takeWhileEnd :: (Word8 -> Bool) -> ByteString -> ByteString #

Returns the longest (possibly empty) suffix of elements satisfying the predicate.

``takeWhileEnd` p` is equivalent to ``reverse` . `takeWhile` p . `reverse``.

Since: bytestring-0.10.12.0

dropEnd :: Int -> ByteString -> ByteString #

O(1) ``dropEnd` n xs` is equivalent to ``take` (`length` xs - n) xs`. Drops `n` elements from end of bytestring.

    >>> dropEnd 3 "abcdefg"
    "abcd"
    >>> dropEnd 0 "abcdefg"
    "abcdefg"
    >>> dropEnd 4 "abc"
    ""

Since: bytestring-0.11.1.0

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

Returns the longest (possibly empty) suffix of elements which do not satisfy the predicate and the remainder of the string.

`breakEnd` `p` is equivalent to ``spanEnd` (not . p)` and to `(`takeWhileEnd` (not . p) &&& `dropWhileEnd` (not . p))`.

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

Returns the longest (possibly empty) suffix of elements satisfying the predicate and the remainder of the string.

`spanEnd` `p` is equivalent to ``breakEnd` (not . p)` and to `(`takeWhileEnd` p &&& `dropWhileEnd` p)`.

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 :: Word8 -> ByteString -> [ByteString] #

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

    split 10  "a\nb\nd\ne" == ["a","b","d","e"]   -- fromEnum '\n' == 10
    split 97  "aXaXaXa"    == ["","X","X","X",""] -- fromEnum 'a' == 97
    split 120 "x"          == ["",""]             -- fromEnum 'x' == 120
    split undefined ""     == []                  -- and not [""]

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 `ByteString`s that are slices of the original.

splitWith :: (Word8 -> 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 (==97) "aabbaca" == ["","","bb","c",""] -- fromEnum 'a' == 97
    splitWith undefined ""     == []                  -- and not [""]

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

unfoldrN :: Int -> (a -> Maybe (Word8, 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`:

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

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

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

isValidUtf8 :: ByteString -> Bool #

O(n) Check whether a `ByteString` represents valid UTF-8.

Since: bytestring-0.11.2.0

fromFilePath :: FilePath -> IO ByteString #

Convert a `FilePath` to a `ByteString`.

The `FilePath` type is expected to use the file system encoding as reported by `getFileSystemEncoding`. This encoding allows for round-tripping of arbitrary data on platforms that allow arbitrary bytes in their paths. This conversion function does the same thing that `openFile` would do when decoding the `FilePath`.

This function is in `IO` because the file system encoding can be changed. If the encoding can be assumed to be constant in your use case, you may invoke this function via `unsafePerformIO`.

Since: bytestring-0.11.2.0

toFilePath :: ByteString -> IO FilePath #

Convert a `ByteString` to a `FilePath`.

This function uses the file system encoding, and resulting `FilePath`s can be safely used with standard IO functions and will reference the correct path in the presence of arbitrary non-UTF-8 encoded paths.

This function is in `IO` because the file system encoding can be changed. If the encoding can be assumed to be constant in your use case, you may invoke this function via `unsafePerformIO`.

Since: bytestring-0.11.2.0

elemIndexEnd :: Word8 -> 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 = case elemIndex c (reverse xs) of
      Nothing -> Nothing
      Just i  -> Just (length xs - 1 - i)

findIndexEnd :: (Word8 -> Bool) -> ByteString -> Maybe Int #

O(n) The `findIndexEnd` function takes a predicate and a `ByteString` and returns the index of the last element in the ByteString satisfying the predicate.

Since: bytestring-0.10.12.0

packZipWith :: (Word8 -> Word8 -> Word8) -> ByteString -> ByteString -> ByteString #

A specialised version of `zipWith` for the common case of a simultaneous map over two ByteStrings, to build a 3rd.

Since: bytestring-0.11.1.0

initsNE :: ByteString -> NonEmpty ByteString #

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

Since: bytestring-0.11.4.0

tailsNE :: ByteString -> NonEmpty ByteString #

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

Since: bytestring-0.11.4.0

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

Lifted `hGetContents`

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

Lifted `writeFile`

getLine :: MonadIO m => m ByteString #

Lifted `getLine`

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

Lifted `hGetLine`

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

Lifted `hPutStr`

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

Lifted `putStr`

getContents :: MonadIO m => m ByteString #

Lifted `getContents`

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

Lifted `interact`

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

Lifted `readFile`

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

Lifted `appendFile`

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

Unlifted `useAsCString`

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

Unlifted `useAsCStringLen`

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

Lifted `hPut`

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

Lifted `packCString`

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

Lifted `packCStringLen`

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

Lifted `hPutNonBlocking`

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

Lifted `hGet`

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

Lifted `hGetNonBlocking`

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

Lifted `hGetSome`