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.

data ByteString

relude Relude.String.Reexport

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.
data ByteString

hasql Hasql.TestingKit.Preludes.Base

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.
module System.Process.ByteString

No documentation available.
module 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.
module URI.ByteString

URI.ByteString aims to be an RFC3986 compliant URI parser that uses efficient ByteStrings for parsing and representing the data. This module provides a URI datatype as well as a parser and serializer. Note that this library is an early release and may have issues. It is currently being used in production and no issues have been encountered, however. Please report any issues encountered to the issue tracker. This module also provides analogs to Lens over the various types in this library. These are written in a generic way to avoid a dependency on any particular lens library. You should be able to use these with a number of packages including lens and lens-family-core.
module Pipes.ByteString

This module provides pipes utilities for "byte streams", which are streams of strict ByteStrings chunks. Use byte streams to interact with both Handles and lazy ByteStrings. To stream to or from Handles, use fromHandle or toHandle. For example, the following program copies data from one file to another:
```
import Pipes
import qualified Pipes.ByteString as P
import System.IO

main =
withFile "inFile.txt"  ReadMode  $ \hIn  ->
withFile "outFile.txt" WriteMode $ \hOut ->
runEffect $ P.fromHandle hIn >-> P.toHandle hOut
```
You can stream to and from stdin and stdout using the predefined stdin and stdout pipes, like in the following "echo" program:
```
main = runEffect $ P.stdin >-> P.stdout
```
You can also translate pure lazy ByteStrings to and from pipes:
```
import qualified Data.ByteString.Lazy.Char8 as BL

main = runEffect $ P.fromLazy (BL.pack "Hello, world!\n") >-> P.stdout
```
In addition, this module provides many functions equivalent to lazy ByteString functions so that you can transform or fold byte streams. For example, to stream only the first three lines of stdin to stdout you would write:
```
import Lens.Family (over)
import Pipes
import qualified Pipes.ByteString as PB
import Pipes.Group (takes)

main = runEffect $ over PB.lines (takes 3) PB.stdin >-> PB.stdout
```
The above program will never bring more than one chunk (~ 32 KB) into memory, no matter how long the lines are. Note that functions in this library are designed to operate on streams that are insensitive to chunk boundaries. This means that they may freely split chunks into smaller chunks and discard empty chunks. However, they will never concatenate chunks in order to provide strict upper bounds on memory usage.
data ByteString

pipes-bytestring Pipes.ByteString

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.
data ByteString

protolude Protolude

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.
module Text.Regex.PCRE.ByteString

This exports instances of the high level API and the medium level API of compile,execute, and regexec.
module TextShow.Data.ByteString

TextShow instances for data types in the bytestring library. Since: 2

relude	Relude.String.Reexport

hasql	Hasql.TestingKit.Preludes.Base

pipes-bytestring	Pipes.ByteString

protolude	Protolude

Page 5 of many | Previous | Next