Hoogle Search

Within LTS Haskell 24.37 (ghc-9.10.3)

Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.

Exact lookup

1. type ByteString = JSString

   jsaddle-dom	JSDOM.Types

   No documentation available.

2. module Text.CSV.Lazy.ByteString

   The CSV (comma-separated value) format is defined by RFC 4180, "Common Format and MIME Type for Comma-Separated Values (CSV) Files", http://www.rfc-editor.org/rfc/rfc4180.txt This lazy parser can report all CSV formatting errors, whilst also returning all the valid data, so the user can choose whether to continue, to show warnings, or to halt on error. Valid fields retain information about their original location in the input, so a secondary parser from textual fields to typed values can give intelligent error messages. In a valid CSV file, all rows must have the same number of columns. This parser will flag a row with the wrong number of columns as a error. (But the error type contains the actual data, so the user can recover it if desired.) Completely blank lines are also treated as errors, and again the user is free either to filter these out or convert them to a row of actual null fields.

3. module Text.PortableLines.ByteString

   No documentation available.

4. module Text.RE.PCRE.ByteString

   No documentation available.

5. data ByteString

   sphinx	Text.Search.Sphinx.Types

   A space-efficient representation of a Word8 vector, supporting many efficient operations. A LazyByteString contains 8-bit bytes, or by using the operations from Data.ByteString.Lazy.Char8 it can be interpreted as containing 8-bit characters.

6. module UnliftIO.Streams.ByteString

   No documentation available.

7. data ByteString

   verset	Verset

   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.

8. package bytestring

   Fast, compact, strict and lazy byte strings with a list interface 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 be converted to or from a ByteString. It is suitable for keeping many short strings in memory, especially long-term, without incurring any possible heap fragmentation costs. 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
   

9. byteString :: StrictByteString -> Builder

   bytestring	Data.ByteString.Builder

   Create a Builder denoting the same sequence of bytes as a StrictByteString. The Builder inserts large StrictByteStrings directly, but copies small ones to ensure that the generated chunks are large on average.

10. byteString :: StrictByteString -> Builder

    bytestring	Data.ByteString.Builder.Internal

    Create a Builder denoting the same sequence of bytes as a StrictByteString. The Builder inserts large StrictByteStrings directly, but copies small ones to ensure that the generated chunks are large on average.

Page 13 of many | Previous | Next