@@ -3,80 +3,70 @@ name: streamly
33version: 0.6.1
44synopsis: Beautiful Streaming, Concurrent and Reactive Composition
55description:
6− Streamly, short for streaming concurrently, provides monadic streams, with a
7− simple API, almost identical to standard lists, and an in-built support for
8− concurrency. Streams can be generated, merged, chained, mapped, zipped, and
9− consumed concurrently – providing a generalized high level programming
10− framework unifying streaming and concurrency. Controlled concurrency allows
11− even infinite streams to be evaluated concurrently. Concurrency is auto
12− scaled based on feedback from the stream consumer. Programmer does not
13− have to be aware of threads, locking or synchronization to write scalable
14− concurrent programs.
6+ Streamly is a framework for writing programs in a high level, declarative
7+ data flow programming paradigm. It provides a simple API, very close to
8+ standard Haskell lists. A program is expressed as a composition of data
9+ processing pipes, generally known as streams. Streams can be generated,
10+ merged, chained, mapped, zipped, and consumed concurrently – enabling a high
11+ level, declarative yet concurrent composition of programs. Programs can be
12+ concurrent or non-concurrent without any significant change. Concurrency is
13+ auto scaled based on consumption rate. Programmers do not have to be aware
14+ of threads, locking or synchronization to write scalable concurrent programs.
15+ Streamly provides C like performance, orders of magnitude better compared to
16+ existing streaming libraries.
1517 .
16− In addition to the basic streaming functionality provided by
17− streaming libraries like
18+ Streamly is designed to express the full spectrum of programs with highest
19+ performance. Do not think that if you are writing a small and simple program
20+ it may not be for you. It expresses a small "hello world" program with the
21+ same efficiency, simplicity and elegance as a large scale concurrent
22+ application. It unifies many different aspects of special purpose libraries
23+ into a single yet simple framework.
24+ .
25+ Streamly covers the functionality provided by Haskell lists as well as the
26+ functionality provided by streaming libraries like
1827 <https://hackage.haskell.org/package/streaming streaming>,
1928 <https://hackage.haskell.org/package/pipes pipes>, and
20− <https://hackage.haskell.org/package/conduit conduit> streamly provides
29+ <https://hackage.haskell.org/package/conduit conduit> with a simpler API and
30+ better performance. Streamly provides
2131 advanced stream composition including various ways of appending, merging,
2232 zipping, splitting, grouping, distributing, partitioning and unzipping of
2333 streams with true streaming and with concurrency. Streamly subsumes the
2434 functionality of list transformer libraries like @pipes@ or
2535 <https://hackage.haskell.org/package/list-t list-t> and also the logic
26− programming library <https://hackage.haskell.org/package/logict logict>. On
27− the concurrency side, it subsumes the basic concurrency functionality
28− provided by the <https://hackage.haskell.org/package/async async> package and
29− provides much more powerful high level concurrent streaming composition.
30− Because it supports streaming with concurrency we can write FRP applications
31− similar in concept to <https://hackage.haskell.org/package/Yampa Yampa> or
32− <https://hackage.haskell.org/package/reflex reflex>.
36+ programming library <https://hackage.haskell.org/package/logict logict>.
37+ The grouping, splitting and windowing combinators in streamly can be compared
38+ to the window operators in <https://flink.apache.org/ Apache Flink>.
39+ However, compared to Flink streamly has a pure functional, succinct and
40+ expressive API.
3341 .
34− The grouping, splitting and windowing combinators in streamly can substitute
35− the window operators in <https://flink.apache.org/ Apache Flink>. However,
36− compared to Flink streamly has a pure functional, succinct and expressive API
37− that is applicable to full spectrum of applications, from a "hello world"
38− application to large scale concurrent applications, with equal efficiency.
39− For those familiar with <http://reactivex.io/ Reactive Extensions>, streamly
40− has similarities with the RxJs API. For most RxJs combinators you
41− can find corresponding combinators in streamly.
42+ The concurrency capabilities of streamly are much more advanced and powerful
43+ compared to the basic concurrency functionality provided by the
44+ <https://hackage.haskell.org/package/async async> package. Streamly is a
45+ first class reactive programming library. If you are familiar with
46+ <http://reactivex.io/ Reactive Extensions> you will find that it is very
47+ similar. For most RxJs combinators you can find or write corresponding ones
48+ in streamly. Streamly can be used as an alternative to
49+ <https://hackage.haskell.org/package/Yampa Yampa> or
50+ <https://hackage.haskell.org/package/reflex reflex> as well.
4251 .
4352 Streamly focuses on practical engineering with high performance. From well
4453 written streamly programs one can expect performance competitive to C. High
4554 performance streaming eliminates the need for string and text libraries like
4655 <https://hackage.haskell.org/package/bytestring bytestring>,
4756 <https://hackage.haskell.org/package/text text> and their lazy and strict
48− flavors. All the confusion and cognitive overhead arising from different
49− string types is eliminated. The only basic types are arrays for storage and
50− streams for processing. Strings and text are simply streams of 'Char' as they
51− should be. Even Haskell lists can be replaced by pure streams. Arrays
52− provided by streamly have performance at par with the vector library.
53− .
54− Streamly interoperates with popular Haskell streaming libraries, see
55− the interoperation section in "Streamly.Tutorial".
56− .
57− Why use streamly?
58− .
59− * /Simplicity/: Simple list like streaming API, if you know how to use lists
60− then you know how to use streamly. This library is built with simplicity
61− and ease of use as a primary design goal.
62− * /Concurrency/: Simple, powerful, and scalable concurrency. Concurrency is
63− built-in, and not intrusive, concurrent programs are written exactly the
64− same way as non-concurrent ones.
65− * /Generality/: Unifies functionality provided by several disparate packages
66− (streaming, concurrency, list transformer, logic programming, reactive
67− programming) in a concise API.
68− * /Performance/: Streamly is designed for high performance.
69− It employs stream fusion optimizations for best possible performance.
70− Serial peformance is equivalent to the venerable `vector` library in most
71− cases and even better in some cases. Concurrent performance is unbeatable.
72− See
73− <https://github.com/composewell/streaming-benchmarks streaming-benchmarks>
74− for a comparison of popular streaming libraries on micro-benchmarks.
57+ flavors. The confusion and cognitive overhead arising from different
58+ string types is eliminated. The two fundamental types in streamly are arrays
59+ for storage and streams for processing. Strings and text are simply streams
60+ or arrays of 'Char' as they should be. Arrays in streamly have performance
61+ at par with the vector library.
7562 .
7663 Where to find more information:
7764 .
7865 * /Quick Overview/: <src/README.md README file> in the package
66+ * /Building/: <src/docs/Build.md Build guide> for optimal performance
7967 * /Detailed Tutorial/: "Streamly.Tutorial" module in the haddock documentation
68+ * /Interoperation/: "Streamly.Tutorial" module for interop with other
69+ streaming libraries
8070 * /Reference Documentation/: Haddock documentation for the respective modules
8171 * /Examples/: <src/examples examples directory> in the package
8272 * /Guides/: <src/docs docs directory> in the package, for documentation on