ByteString +Data

data ByteString
bytestring Data.ByteString, bytestring Data.ByteString.Char8, bytestring Data.ByteString.Lazy, bytestring Data.ByteString.Lazy.Char8
A space-efficient representation of a Word8 vector, supporting many efficient operations. A ByteString contains 8-bit characters only. Instances of Eq, Ord, Read, Show, Data, Typeable
module Data.ByteString
bytestring Data.ByteString
A time and space-efficient implementation of byte vectors using packed Word8 arrays, suitable for high performance use, both in terms of large data quantities, or high speed requirements. Byte vectors are encoded as strict Word8 arrays of bytes, held in a ForeignPtr, and can be passed between C and Haskell with little effort. This module is intended to be imported qualified, to avoid name clashes with Prelude functions. eg. > import qualified Data.ByteString as B Original GHC implementation by Bryan O'Sullivan. Rewritten to use UArray by Simon Marlow. Rewritten to support slices and use ForeignPtr by David Roundy. Rewritten again and extended by Don Stewart and Duncan Coutts.
byteString :: ByteString -> Builder
bytestring Data.ByteString.Builder
Create a Builder denoting the same sequence of bytes as a strict ByteString. The Builder inserts large ByteStrings directly, but copies small ones to ensure that the generated chunks are large on average.
package bytestring
package
An efficient compact, immutable byte string type (both strict and lazy) suitable for binary or 8-bit character data. The ByteString type represents sequences of bytes or 8-bit characters. It is suitable for high performance use, both in terms of large data quantities, or high speed requirements. The ByteString functions follow the same style as Haskell's ordinary lists, so it is easy to convert code from using String to ByteString. Two ByteString variants are provided: * Strict ByteStrings keep the string as a single large array. This makes them convenient for passing data between C and Haskell. * Lazy ByteStrings use a lazy list of strict chunks which makes it suitable for I/O streaming tasks. The Char8 modules provide a character-based view of the same underlying ByteString types. This makes it convenient to handle mixed binary and 8-bit character content (which is common in many file formats and network protocols). The Builder module provides an efficient way to build up ByteStrings in an ad-hoc way by repeated concatenation. This is ideal for fast serialisation or pretty printing. There is also a ShortByteString type which has a lower memory overhead and can can be converted to or from a ByteString, but supports very few other operations. It is suitable for keeping many short strings in memory. ByteStrings are not designed for Unicode. For Unicode strings you should use the Text type from the text package. These modules are intended to be imported qualified, to avoid name clashes with Prelude functions, e.g. > import qualified Data.ByteString as BS Version 0.10.4.0
package bytestring-builder
package
This is the bytestring builder that is debuting in bytestring-0.10.4.0, which should be shipping with GHC 7.8, probably late in 2013. This builder has several nice simplifications and improvements, and more out-of-box functionality than the older blaze-builder. Note that this package detects which version of bytestring you are compiling against,  and if you are compiling against bytestring-0.10.4 or later, will be an empty package. This package lets the new interface and implementation be used with most older compilers without upgrading bytestring, which can be rather problematic.  In conjunction with blaze-builder-0.4 or later,  which offers an implementation of blaze-builder in terms of bytestring-builder, this should let most people try the new interface and implementation without causing undue compatibility problems with packages that depend on blaze-builder. GHC 7.6 did debut an almost identical interface and implementation, but with slightly different module names and organization.   Trying to re-export/rename the builder provided with 7.6 did not turn out to be very practical,  because this interface includes new functions that rely on Builder internals, which are not exported in 7.6.  Furthermore, these module names should be deprecated in 7.10. Version 0.10.4.0.1
package bytestring-class
package
In theory, this allows the design of more data-agnostic APIs. Version 0.0.0
package bytestring-csv
package
Parse CSV formatted data efficiently Version 0.1.2
package bytestring-delta
package
Compute a patch between two ByteStrings which can later be applied to the first to produce the second.  This can be used to save bandwidth and disk space when many strings differing by a small number of bytes need to be transmitted or stored. The underlying implementation is written in C, and can also be found at http://ccodearchive.net/info/bdelta.html. Currently, a patch does not save any space when two strings differ by more than 1000 bytes.  This arbitrary limit serves to keep applications from spiking in memory and CPU usage, as the algorithm uses quadratic space and time with respect to the length of the patch.  A better algorithm may be introduced in a future version of bytestring-delta. Version 0.1.0.1
package bytestring-handle
package
package bytestring-lexing
package
Parse and produce literals efficiently from strict or lazy bytestrings. Some benchmarks for this package can be found at: http://community.haskell.org/~wren/bytestring-lexing/test/bench/html Version 0.4.3
package bytestring-mmap
package
This library provides a wrapper to mmap(2), allowing files or devices to be lazily loaded into memory as strict or lazy ByteStrings, using the virtual memory subsystem to do on-demand loading. Version 0.2.2
package bytestring-nums
package
Parse numeric literals from ByteStrings. Version 0.3.6
package bytestring-plain
package
More compact representation for strict ByteStrings avoiding the overhead and indirection caused by ForeignPtr. This representation is useful to reduce the incurred memory overhead when operating with many small, long-lived, distinct byte strings (such as keys for containers). See documentation in Data.ByteString.Plain for more details about this representation. As an alternative, recent `bytestring` versions provide Data.ByteString.Short which has a similiar overhead but uses unpinned memory instead (and thus requires an additional string data copy in contrast to Data.ByteString.Plain which allows to share the string data with the associated Data.ByteString value). Version 0.1.0.1
package bytestring-progress
package
In some cases, it is useful to know how fast a ByteString is being consumed. Typically, this could be to report some measure of progress to a waiting user, but it could also be to perform some form of testing on input / consumption code. Version 1.0.3
package bytestring-rematch
package
package bytestring-show
package
Efficient conversion of values into readable byte strings. Version 0.3.5.5
package bytestring-trie
package
An efficient finite map from (byte)strings to values. The implementation is based on big-endian patricia trees, like Data.IntMap. We first trie on the elements of Data.ByteString and then trie on the big-endian bit representation of those elements. Patricia trees have efficient algorithms for union and other merging operations, but they're also quick for lookups and insertions. If you are only interested in being able to associate strings to values, then you may prefer the hashmap package which is faster for those only needing a map-like structure. This package is intended for those who need the extra capabilities that a trie-like structure can offer (e.g., structure sharing to reduce memory costs for highly redundant keys, taking the submap of all keys with a given prefix, contextual mapping, extracting the minimum and maximum keys, etc.) Version 0.2.3
byteStringCopy :: ByteString -> Builder
bytestring Data.ByteString.Builder.Extra
Construct a Builder that copies the strict ByteString. Use this function to create Builders from smallish (<= 4kb) ByteStrings or if you need to guarantee that the ByteString is not shared with the chunks generated by the Builder.
byteStringHex :: ByteString -> Builder
bytestring Data.ByteString.Builder
Encode each byte of a ByteString using its fixed-width hex encoding.
byteStringInsert :: ByteString -> Builder
bytestring Data.ByteString.Builder.Extra
Construct a Builder that always inserts the strict ByteString directly as a chunk. This implies flushing the output buffer, even if it contains just a single byte. You should therefore use byteStringInsert only for large (> 8kb) ByteStrings. Otherwise, the generated chunks are too fragmented to be processed efficiently afterwards.
package bytestringparser
package
package bytestringparser-temporary
package
AttoParsec with a small patch so I can get on with my parser. Version 0.4.1
package bytestringreadp
package
This is a library of parser combinators, originally written by Koen Claessen. It parses all alternatives in parallel, so it never keeps hold of the beginning of the input string, a common source of space leaks with other parsers.  The '(+++)' choice combinator is genuinely commutative; it makes no difference which branch is &quot;shorter&quot;. Adapted to use Data.ByteString by Gracjan Polak. Designed as a drop-in replacement for Text.ParserCombinators.ReadP. Version 0.2
byteStringThreshold :: Int -> ByteString -> Builder
bytestring Data.ByteString.Builder.Extra
Construct a Builder that copies the strict ByteStrings, if it is smaller than the treshold, and inserts it directly otherwise. For example, byteStringThreshold 1024 copies strict ByteStrings whose size is less or equal to 1kb, and inserts them directly otherwise. This implies that the average chunk-size of the generated lazy ByteString may be as low as 513 bytes, as there could always be just a single byte between the directly inserted 1025 byte, strict ByteStrings.
package base16-bytestring
package
Fast base16 (hex) encoding and decoding for ByteStrings Version 0.1.1.5
package base32-bytestring
package
base32 and base32hex codec according to RFC4648 http://tools.ietf.org/html/rfc4648 The package API is similar to base64-bytestring. Version 0.2.1.0
package base64-bytestring
package
Fast base64 encoding and decoding for ByteStrings Version 1.0.0.1
package explicit-iomodes-bytestring
package
Extends explicit-iomodes with ByteString operations Version 0.2.0.2
package irc-bytestring
package
A simple library for handling IRC protocol messages using bytestrings. Version 0.1
lazyByteString :: ByteString -> Builder
bytestring Data.ByteString.Builder
Create a Builder denoting the same sequence of bytes as a lazy ByteString. The Builder inserts large chunks of the lazy ByteString directly, but copies small ones to ensure that the generated chunks are large on average.
lazyByteStringCopy :: ByteString -> Builder
bytestring Data.ByteString.Builder.Extra
Construct a Builder that copies the lazy ByteString.
lazyByteStringHex :: ByteString -> Builder
bytestring Data.ByteString.Builder
Encode each byte of a lazy ByteString using its fixed-width hex encoding.
lazyByteStringInsert :: ByteString -> Builder
bytestring Data.ByteString.Builder.Extra
Construct a Builder that inserts all chunks of the lazy ByteString directly.
lazyByteStringThreshold :: Int -> ByteString -> Builder
bytestring Data.ByteString.Builder.Extra
Construct a Builder that uses the thresholding strategy of byteStringThreshold for each chunk of the lazy ByteString.
package network-bytestring
package
Fast, memory-efficient, low-level socket functions that use Data.ByteStrings instead of Strings. Version 0.1.3.4
package NumLazyByteString
package
Num, Enum, Eq, Integral, Ord, Real, and Show instances for Lazy ByteStrings Version 0.0.0.1
package pipes-bytestring
package
This library provides pipes utilities for ByteStrings Version 1.0.2
primMapByteStringBounded :: BoundedPrim Word8 -> ByteString -> Builder
bytestring Data.ByteString.Builder.Prim
Create a Builder that encodes each Word8 of a strict ByteString using a BoundedPrim. For example, we can write a Builder that filters a strict ByteString as follows. > import Data.ByteString.Builder.Primas P (word8, condB, emptyB) > filterBS p = P.condB p P.word8 P.emptyB
primMapByteStringFixed :: FixedPrim Word8 -> (ByteString -> Builder)
bytestring Data.ByteString.Builder.Prim
Heavy inlining. Encode all bytes of a strict ByteString from left-to-right with a FixedPrim. This function is quite versatile. For example, we can use it to construct a Builder that maps every byte before copying it to the buffer to be filled. > mapToBuilder :: (Word8 -> Word8) -> S.ByteString -> Builder > mapToBuilder f = encodeByteStringWithF (contramapF f word8) We can also use it to hex-encode a strict ByteString as shown by the byteStringHex example above.
primMapLazyByteStringBounded :: BoundedPrim Word8 -> ByteString -> Builder
bytestring Data.ByteString.Builder.Prim
Chunk-wise application of primMapByteStringBounded.

Show more results