Data.ByteString.Lens

lens-4.15.1: Lenses, Folds and Traversals

Copyright | (C) 2012-16 Edward Kmett
License | BSD-style (see the file LICENSE)
Maintainer | Edward Kmett <ekmett@gmail.com>
Stability | experimental
Portability | non-portable
Safe Haskell | None
Language | Haskell98

Data.ByteString.Lens

Description

Synopsis

- class IsByteString t where
- unpackedBytes :: IsByteString t => Iso' t [Word8]
- unpackedChars :: IsByteString t => Iso' t String
- pattern Bytes :: forall s. IsByteString s => [Word8] -> s
- pattern Chars :: forall s. IsByteString s => String -> s

# Documentation

class IsByteString t where #

Traversals for ByteStrings.

Minimal complete definition

packedBytes, packedChars

Methods

packedBytes :: Iso' [Word8] t #

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

    pack x ≡ x ^. packedBytes
    unpack x ≡ x ^. from packedBytes
    packedBytes ≡ from unpackedBytes

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

bytes :: IndexedTraversal' Int t Word8 #

Traverse each `Word8` in a strict or lazy `ByteString`

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:

    bytes ≡ unpackedBytes . traversed

    anyOf bytes (== 0x80) :: ByteString -> Bool

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

Instances

IsByteString ByteString # |
Methods packedBytes :: Iso' [Word8] ByteString # packedChars :: Iso' String ByteString # bytes :: IndexedTraversal' Int ByteString Word8 # chars :: IndexedTraversal' Int ByteString Char #
IsByteString ByteString # |
Methods packedBytes :: Iso' [Word8] ByteString # packedChars :: Iso' String ByteString # bytes :: IndexedTraversal' Int ByteString Word8 # chars :: IndexedTraversal' Int ByteString Char #

unpackedBytes :: IsByteString t => Iso' t [Word8] #

`unpack` (or `pack`) a `ByteString` into a list of bytes

    unpackedBytes ≡ from packedBytes
    unpack x ≡ x ^. unpackedBytes
    pack x ≡  x ^. from unpackedBytes

    unpackedBytes :: Iso' ByteString [Word8]
    unpackedBytes :: Iso' ByteString [Word8]

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

pattern Bytes :: forall s. IsByteString s => [Word8] -> s #

pattern Chars :: forall s. IsByteString s => String -> s #