Hoogle Search

Within LTS Haskell 24.35 (ghc-9.10.3)

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

package store-streaming

Streaming interfaces for `store` Streaming interfaces for store
package stratosphere

EDSL for AWS CloudFormation EDSL for AWS CloudFormation
package streaming-attoparsec

Attoparsec integration for the streaming ecosystem Attoparsec integration for the streaming ecosystem.
package streaming-binary

Streaming interface to binary. Streaming interface to binary.
package streamly

Streaming, dataflow programming and declarative concurrency For upgrading to streamly-0.9.0+ please read the Streamly-0.9.0 upgrade guide. Streamly is a standard library for Haskell that focuses on C-like performance, modular combinators, and streaming data flow model. Streamly consists of two packages, the streamly-core package provides functionality that depends only on boot libraries, and the streamly package provides additional functionality like concurrency, time, lifted exceptions, and networking. For unified documentation visit the streamly website. Streamly provides unified, modular building blocks to build high-performance, concurrent, scalable applications in Haskell. Stream fusion optimizations in streamly enable exceptional modularity with high performance comparable to C. Streamly complements the Haskell base package, supplying additional functionality to quickly build general-purpose applications in Haskell. For high-level functionality built over streamly like streaming OS processes, shell programming, GNU coreutils, statistics, and compression libraries please see the streamly ecosystem packages. Performance with modularity:
- Performance on par with C (Benchmarks)
- API close to standard Haskell lists (Examples)
- Declarative concurrency with automatic scaling
- Filesystem, fsnotify, network, and Unicode support included
- Fast binary serialization (with optional JSON like features)
- More functionality is provided via many (ecosystem packages)
Unified and powerful abstractions:
- Unifies streams, arrays, folds, and parsers
- Unifies Data.List, list-t, and logict with streaming
- Unifies concurrency with standard streaming abstractions
- Unifies reactive, time-domain programming with streaming
- Unifies binary serialization and unboxed arrays
- Interworks with other streaming libraries
package streamly-bytestring

Library for streamly and bytestring interoperation. Please see the README on GitHub at https://github.com/psibi/streamly-bytestring#readme
package streamly-process

Use OS processes as stream transformation functions Use operating system (OS) commands in Haskell programs as if they were native Haskell functions, by treating their inputs and outputs as Haskell streams. This allows you to write high-level Haskell scripts that can perform tasks similar to shell scripts, but with C-like performance, and with strong safety guarantees, refactorability, and modularity.
package streams

Various Haskell 2010 stream comonads Various Haskell 2010 stream comonads. * Data.Stream.Future provides a coinductive anti-causal stream, or non-empty ZipList. The comonad provides access to only the tail of the stream. Like a conventional ZipList, this is not a monad.
```
data Future a = Last a | a :< Future a
```
- Data.Stream.Future.Skew provides a non-empty skew-binary random-access-list with the semantics of Data.Stream.Future. As with Data.Stream.Future this stream is not a Monad, since the Applicative instance zips streams of potentially differing lengths. The random-access-list structure provides a number of operations logarithmic access time, but makes Data.Stream.Future.Skew.cons less productive. Where applicable Data.Stream.Infinite.Skew may be more efficient, due to a lazier and more efficient Applicative instance.
- Data.Stream.Infinite provides a coinductive infinite anti-causal stream. The Comonad provides access to the tail of the stream and the Applicative zips streams together. Unlike Future, infinite stream form a Monad. The monad diagonalizes the Stream, which is consistent with the behavior of the Applicative, and the view of a Stream as a isomorphic to the reader monad from the natural numbers. Being infinite in length, there is no Alternative instance.
```
data Stream a = a :< Stream a
```
- Data.Stream.Infinite.Skew provides an infinite skew-binary random-access-list with the semantics of Data.Stream.Infinite Since every stream is infinite, the Applicative instance can be considerably less strict than the corresponding instance for Data.Stream.Future.Skew and performs asymptotically better.
- Data.Stream.Infinite.Functional.Zipper provides a bi-infinite sequence, represented as a pure function with an accumulating parameter added to optimize moving the current focus.
```
data Zipper a = !Integer :~ (Integer -> a)
```
- Data.Stream.Supply provides a comonadic supply of unique values, which are generated impurely as the tree is explored.
package strict-lens

Lenses for types in strict package Lenses for types in strict package.
package strict-tuple

Strict tuples Strict tuples.

Page 248 of many | Previous | Next