ByteString
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
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, and lazy lists of strict chunks, held in a ForeignPtr, and can be passed between C and Haskell with little effort.
Test coverage data for this library is available at: http://code.haskell.org/~dons/tests/bytestring/hpc_index.html
Version 0.9.2.1
In theory, this allows the design of more data-agnostic APIs.
Version 0.0.0
Parse CSV formatted data efficiently
Version 0.1.2
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
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
Parse numeric literals from ByteStrings.
Version 0.3.5
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.2.1
Efficient conversion of values into readable byte strings.
Version 0.3.5.1
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
AttoParsec with a small patch so I can get on with my parser.
Version 0.4.1
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 "shorter".
Adapted to use Data.ByteString by Gracjan Polak. Designed as a drop-in replacement for Text.ParserCombinators.ReadP.
Version 0.2
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. Polished and extended by Don Stewart.
This module provides access to the BSD socket interface. This module is generally more efficient than the String based network functions in Socket. For detailed documentation, consult your favorite POSIX socket reference. All functions communicate failures by converting the error number to IOError.
This module is made to be imported with Socket like so:
> import Network.Socket hiding (send, sendTo, recv, recvFrom)
> import Network.Socket.ByteString
POSIX support with ByteString file paths and environment strings.
This module exports exactly the same API as System.Posix, except that all file paths and environment strings are represented by ByteString instead of String. The System.Posix API implicitly translates all file paths and environment strings using the locale encoding, whereas this version of the API does no encoding or decoding and works directly in terms of raw bytes.
Note that if you do need to interpret file paths or environment strings as text, then some Unicode encoding or decoding should be applied first.
String-based POSIX directory support
Dynamic linker support through dlopen()
DLOpen support, old API Derived from GModule.chs by M.Weber & M.Chakravarty which is part of c2hs I left the API more or less the same, mostly the flags are different.
POSIX environment support
Functions defined by the POSIX standards for manipulating and querying the file system. Names of underlying POSIX functions are indicated whenever possible. A more complete documentation of the POSIX functions together with a more detailed description of different error conditions are usually available in the system's manual pages or from http://www.unix.org/version3/online.html (free registration required).
When a function that calls an underlying POSIX function fails, the errno code is converted to an IOError using errnoToIOError. For a list of which errno codes may be generated, consult the POSIX documentation for the underlying function.
POSIX IO support. These types and functions correspond to the unix functions open(2), close(2), etc. For more portable functions which are more like fopen(3) and friends from stdio.h, see System.IO.
POSIX process support. See also the System.Cmd and System.Process modules in the process package.
POSIX environment support
POSIX Terminal support
Make strict ByteStrings an instance of Stream with Char token type.
This provides ByteString instances for RegexMaker and RegexLike based on Text.Regex.Posix.Wrap, and a (RegexContext Regex ByteString ByteString) instance.
To use these instance, you would normally import Text.Regex.Posix. You only need to import this module to use the medium level API of the compile, regexec, and execute functions. All of these report error by returning Left values instead of undefined or error or fail.
The ByteString will only be passed to the library efficiently (as a pointer) if it ends in a NUL byte. Otherwise a temporary copy must be made with the 0 byte appended.
Fast base16 (hex) encoding and decoding for ByteStrings
Version 0.1.1.4
Fast base64 encoding and deconding for ByteStrings
Version 0.1.1.1
Extends explicit-iomodes with ByteString operations
Version 0.2.0.1
Fast, memory-efficient, low-level socket functions that use Data.ByteStrings instead of Strings.
Version 0.1.3.4
Num, Enum, Eq, Integral, Ord, Real, and Show instances for Lazy ByteStrings
Version 0.0.0.1
(deprecated)
Version 3.0.0.1
Extends safer-file-handles with ByteString operations
Version 0.3.0.1
Unix/Posix-specific functions for ByteStrings.
Provides ByteString file-descriptor based I/O API, designed loosely after the String file-descriptor based I/O API in System.Posix.IO. The functions here wrap standard C implementations of the functions specified by the ISO/IEC 9945-1:1990 (``POSIX.1'') and X/Open Portability Guide Issue 4, Version 2 (``XPG4.2'') specifications.
Note that this package doesn't require the unix package as a dependency. But you'll need it in order to get your hands on an Fd, so we're not offering a complete replacement.
Version 0.3.5.3
ByteStrings as type synonyms of Storable Vectors of Word8s
Version 0.0.0.1