@@ -3,80 +3,70 @@ name: streamly
3version: 0.6.1
3version: 0.6.1
4synopsis: Beautiful Streaming, Concurrent and Reactive Composition
4synopsis: Beautiful Streaming, Concurrent and Reactive Composition
5description:
5description:
6− Streamly, short for streaming concurrently, provides monadic streams, with a
6+ Streamly is a framework for writing programs in a high level, declarative
7− simple API, almost identical to standard lists, and an in-built support for
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,
8− concurrency. Streams can be generated, merged, chained, mapped, zipped, and
10+ merged, chained, mapped, zipped, and consumed concurrently – enabling a high
9− consumed concurrently – providing a generalized high level programming
11+ level, declarative yet concurrent composition of programs. Programs can be
10− framework unifying streaming and concurrency. Controlled concurrency allows
12+ concurrent or non-concurrent without any significant change. Concurrency is
11− even infinite streams to be evaluated concurrently. Concurrency is auto
13+ auto scaled based on consumption rate. Programmers do not have to be aware
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+ of threads, locking or synchronization to write scalable concurrent programs.
14− concurrent programs.
15+ Streamly provides C like performance, orders of magnitude better compared to
16+ existing streaming libraries.
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.
16− In addition to the basic streaming functionality provided by
25+ Streamly covers the functionality provided by Haskell lists as well as the
17− streaming libraries like
26+ functionality provided by streaming libraries like
18 <https://hackage.haskell.org/package/streaming streaming>,
27 <https://hackage.haskell.org/package/streaming streaming>,
19 <https://hackage.haskell.org/package/pipes pipes>, and
28 <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
21 advanced stream composition including various ways of appending, merging,
31 advanced stream composition including various ways of appending, merging,
22 zipping, splitting, grouping, distributing, partitioning and unzipping of
32 zipping, splitting, grouping, distributing, partitioning and unzipping of
23 streams with true streaming and with concurrency. Streamly subsumes the
33 streams with true streaming and with concurrency. Streamly subsumes the
24 functionality of list transformer libraries like @pipes@ or
34 functionality of list transformer libraries like @pipes@ or
25 <https://hackage.haskell.org/package/list-t list-t> and also the logic
35 <https://hackage.haskell.org/package/list-t list-t> and also the logic
26− programming library <https://hackage.haskell.org/package/logict logict>. On
36+ programming library <https://hackage.haskell.org/package/logict logict>.
27− the concurrency side, it subsumes the basic concurrency functionality
37+ The grouping, splitting and windowing combinators in streamly can be compared
28− provided by the <https://hackage.haskell.org/package/async async> package and
38+ to the window operators in <https://flink.apache.org/ Apache Flink>.
29− provides much more powerful high level concurrent streaming composition.
39+ However, compared to Flink streamly has a pure functional, succinct and
30− Because it supports streaming with concurrency we can write FRP applications
40+ expressive API.
31− similar in concept to <https://hackage.haskell.org/package/Yampa Yampa> or
32− <https://hackage.haskell.org/package/reflex reflex>.
34− The grouping, splitting and windowing combinators in streamly can substitute
42+ The concurrency capabilities of streamly are much more advanced and powerful
35− the window operators in <https://flink.apache.org/ Apache Flink>. However,
43+ compared to the basic concurrency functionality provided by the
36− compared to Flink streamly has a pure functional, succinct and expressive API
44+ <https://hackage.haskell.org/package/async async> package. Streamly is a
37− that is applicable to full spectrum of applications, from a "hello world"
45+ first class reactive programming library. If you are familiar with
38− application to large scale concurrent applications, with equal efficiency.
39− For those familiar with <http://reactivex.io/ Reactive Extensions>, streamly
46+ <http://reactivex.io/ Reactive Extensions> you will find that it is very
40− has similarities with the RxJs API. For most RxJs combinators you
47+ similar. For most RxJs combinators you can find or write corresponding ones
41− can find corresponding combinators in streamly.
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.
43 Streamly focuses on practical engineering with high performance. From well
52 Streamly focuses on practical engineering with high performance. From well
44 written streamly programs one can expect performance competitive to C. High
53 written streamly programs one can expect performance competitive to C. High
45 performance streaming eliminates the need for string and text libraries like
54 performance streaming eliminates the need for string and text libraries like
46 <https://hackage.haskell.org/package/bytestring bytestring>,
55 <https://hackage.haskell.org/package/bytestring bytestring>,
47 <https://hackage.haskell.org/package/text text> and their lazy and strict
56 <https://hackage.haskell.org/package/text text> and their lazy and strict
48− flavors. All the confusion and cognitive overhead arising from different
57+ flavors. The confusion and cognitive overhead arising from different
49− string types is eliminated. The only basic types are arrays for storage and
58+ string types is eliminated. The two fundamental types in streamly are arrays
50− streams for processing. Strings and text are simply streams of 'Char' as they
59+ for storage and streams for processing. Strings and text are simply streams
51− should be. Even Haskell lists can be replaced by pure streams. Arrays
60+ or arrays of 'Char' as they should be. Arrays in streamly have performance
52− provided by streamly have performance at par with the vector library.
61+ at par with the vector library.
54− Streamly interoperates with popular Haskell streaming libraries, see
55− the interoperation section in "Streamly.Tutorial".
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.
73− <https://github.com/composewell/streaming-benchmarks streaming-benchmarks>
74− for a comparison of popular streaming libraries on micro-benchmarks.
76 Where to find more information:
63 Where to find more information:
78 * /Quick Overview/: <src/README.md README file> in the package
65 * /Quick Overview/: <src/README.md README file> in the package
66+ * /Building/: <src/docs/Build.md Build guide> for optimal performance
79 * /Detailed Tutorial/: "Streamly.Tutorial" module in the haddock documentation
67 * /Detailed Tutorial/: "Streamly.Tutorial" module in the haddock documentation
68+ * /Interoperation/: "Streamly.Tutorial" module for interop with other
80 * /Reference Documentation/: Haddock documentation for the respective modules
70 * /Reference Documentation/: Haddock documentation for the respective modules
81 * /Examples/: <src/examples examples directory> in the package
71 * /Examples/: <src/examples examples directory> in the package
82 * /Guides/: <src/docs docs directory> in the package, for documentation on
72 * /Guides/: <src/docs docs directory> in the package, for documentation on