streamly: Streaming, dataflow programming and declarative concurrency

[ array, bsd3, concurrency, dataflow, filesystem, library, list, logic, network, non-determinism, parsing, pipes, reactivity, streaming, streamly, time, unicode ] [ Propose Tags ]

Streamly comprises 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 the missing functionality to quickly build general-purpose applications in Haskell. For high-level functionality built over streamly like streaming system 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

  • 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

  • Interworks with other streaming libraries


[Skip to Readme]

Modules

[Index] [Quick Jump]

Flags

Manual Flags

NameDescriptionDefault
fusion-plugin

Use fusion plugin for benchmarks and executables

Disabled
inspection

Enable inspection testing

Disabled
debug

Debug build with asserts enabled

Disabled
dev

Development build

Disabled
has-llvm

Use llvm backend for code generation

Disabled
opt

off=GHC default, on=-O2

Enabled
limit-build-mem

Limits memory when building

Disabled
use-unliftio

Use unliftio-core instead of monad-control

Disabled

Use -f <flag> to enable a flag, or -f -<flag> to disable that flag. More info

Downloads

Maintainer's Corner

Package maintainers

For package maintainers and hackage trustees

Candidates

Versions [RSS] 0.1.0, 0.1.1, 0.1.2, 0.2.0, 0.2.1, 0.3.0, 0.4.0, 0.4.1, 0.5.0, 0.5.1, 0.5.2, 0.6.0, 0.6.1, 0.7.0, 0.7.1, 0.7.2, 0.7.3, 0.7.3.1, 0.8.0, 0.8.1, 0.8.1.1, 0.8.2, 0.8.3, 0.9.0
Change log CHANGELOG.md
Dependencies atomic-primops (>=0.8 && <0.9), base (>=4.12 && <4.19), containers (>=0.6.0 && <0.7), deepseq (>=1.4.4 && <1.5), directory (>=1.2.2 && <1.4), exceptions (>=0.8.0 && <0.11), hashable (>=1.3 && <1.5), heaps (>=0.3 && <0.5), lockfree-queue (>=0.2.4 && <0.3), monad-control (>=1.0 && <1.1), mtl (>=2.2.2 && <2.4), network (>=2.6 && <3.2), streamly-core (==0.1.0), template-haskell (>=2.14 && <2.20), transformers (>=0.5.5 && <0.7), transformers-base (>=0.4 && <0.5), unicode-data (>=0.1 && <0.5), unordered-containers (>=0.2 && <0.3), Win32 (>=2.6 && <2.14) [details]
License BSD-3-Clause
Copyright 2017 Composewell Technologies
Author Composewell Technologies
Maintainer streamly@composewell.com
Category Streamly, Concurrency, Streaming, Dataflow, Pipes, Reactivity, List, Logic, Non-determinism, Parsing, Array, Time, Unicode, Filesystem, Network
Home page https://streamly.composewell.com
Bug tracker https://github.com/composewell/streamly/issues
Source repo head: git clone https://github.com/composewell/streamly
Uploaded by adithyaov at 2023-03-13T14:30:19Z
Distributions LTSHaskell:0.8.1.1, NixOS:0.8.1.1, Stackage:0.9.0
Reverse Dependencies 31 direct, 4 indirect [details]
Downloads 14595 total (217 in the last 30 days)
Rating 2.5 (votes: 6) [estimated by Bayesian average]
Your Rating
  • λ
  • λ
  • λ
Status Docs uploaded by user
Build status unknown [no reports yet]

Readme for streamly-0.9.0

[back to package description]

Streamly: Idiomatic Haskell with C-Like Performance

Gitter chat Hackage

Streamly is a powerful Haskell library that provides developers with the essential building blocks to create safe, scalable, modular, and high-performance software. With Streamly, developers can enjoy the benefits of Haskell's type safety while leveraging C-like program performance. Streamly offers a comprehensive range of features, comprising:

  • Haskell's strong type safety.
  • C-program-like performance capabilities.
  • Flexible, modular building blocks.
  • Idiomatic functional programming.
  • Fearless, declarative concurrency for seamless parallel execution.
  • A collection of ecosystem libraries for fast and efficient development.

Check out the Streamly Setup and Usage Guide and Quick Overview for an introduction to the library. For more detailed documentation, visit the Haskell Streamly website.

Blazing Fast

Streamly delivers C-like speed in Haskell by fusing stream pipelines using the stream-fusion technique, resulting in compiled code that is equivalent to handwritten C code, eliminating intermediate allocations and function calls.

For a comprehensive comparison of Streamly to other Haskell streaming libraries, check out our streaming benchmarks page. In fact, Streamly's fused loops can be up to 100 times faster than those of libraries without stream fusion.

Declarative Concurrency

Streamly introduces declarative concurrency to standard functional streaming abstractions. Declarative concurrency abstracts away the low-level details of concurrency management, such as locks and threads, and allows for easier and safer parallelization of code. For example, with Streamly you can do things like repeat actions concurrently to generate a stream of results, map functions concurrently on a stream, and combine multiple streams concurrently to create a single output stream.

Unified API

Streamly provides a comprehensive and unified API for basic programming needs, covering a wide range of areas including streaming, concurrency, logic programming, reactive programming, pinned and unpinned arrays, serialization, builders, parsers, unicode processing, file-io, file system events, and network-io. By unifying functionality from disparate Haskell libraries, Streamly simplifies development while delivering equivalent or improved performance. Additionally, the complexity of handling combinations of lazy, strict, bytestring, and text is eliminated by using streams for lazy evaluation, and by generalizing bytestring and text to arrays.

Check out Streamly's documentation for more information about Streamly's features.

Batteries Included

In addition to the fundamental programming constructs, Streamly also provides higher-level functionality through supporting packages such as streamly-process, streamly-shell, and streamly-coreutils that are essential for general programming tasks. Check out the streamly-examples repository for some program snippets.

Highly Modular

Traditionally, you must choose between modularity and performance when writing code. However, with Haskell Streamly, you can have the best of both worlds. By taking advantage of GHC's stream fusion optimizations (such as case-of-case and spec-constr), Streamly achieves performance comparable to an equivalent C program while still allowing for highly modular code.

Credits

The following authors/libraries have influenced or inspired this library in a significant way:

Please see the credits directory for a full list of contributors, credits and licenses.

Licensing

Streamly is an open source project available under a liberal BSD-3-Clause license

Contributing to Streamly

As an open project we welcome contributions:

Getting Support

Professional support is available for Streamly: please contact support@composewell.com.

You can also join our community chat channel on Gitter.