ByteString -network -package

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.
module System.Posix.ByteString
unix System.Posix.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.
module System.Posix.Directory.ByteString
unix System.Posix.Directory.ByteString
String-based POSIX directory support
module System.Posix.DynamicLinker.ByteString
unix System.Posix.DynamicLinker.ByteString
Dynamic linker support through dlopen()
module System.Posix.DynamicLinker.Module.ByteString
unix System.Posix.DynamicLinker.Module.ByteString
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.
module System.Posix.Env.ByteString
unix System.Posix.Env.ByteString
POSIX environment support
module System.Posix.Files.ByteString
unix System.Posix.Files.ByteString
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.
module System.Posix.IO.ByteString
unix System.Posix.IO.ByteString
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.
module System.Posix.Process.ByteString
unix System.Posix.Process.ByteString
POSIX process support. See also the System.Cmd and System.Process modules in the process package.
module System.Posix.Temp.ByteString
unix System.Posix.Temp.ByteString
POSIX temporary file and directory creation functions.
module System.Posix.Terminal.ByteString
unix System.Posix.Terminal.ByteString
POSIX Terminal support
module Text.Parsec.ByteString
parsec Text.Parsec.ByteString
Make strict ByteStrings an instance of Stream with Char token type.
module Text.Regex.Posix.ByteString
regex-posix Text.Regex.Posix.ByteString
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.
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.
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.
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.
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.

Show more results