@@ -8,56 +8,55 @@
88
99## Stream`ing` `Concurrent`ly
1010
11−Streamly, short for streaming concurrently, is a simple yet powerful streaming
12−library with concurrent merging and concurrent nested looping support. A stream
13−is just like a list except that it is a list of monadic actions rather than
14−pure values. Streamly streams can be generated, consumed, combined, or
15−transformed serially or concurrently. We can loop over a stream serially or
16−concurrently. We can also have serial or concurrent nesting of loops. For
17−those familiar with the list transformer concept streamly is a concurrent list
18−transformer. Streamly uses standard composition abstractions. Concurrent
19−composition is just the same as serial composition except that we use a simple
20−combinator to request a concurrent composition instead of serial. The
21−programmer does not have to be aware of threads, locking or synchronization to
22−write scalable concurrent programs.
23−
24−Streamly provides functionality that is equivalent to streaming libraries
25−like [pipes](https://hackage.haskell.org/package/pipes) and
26−[conduit](https://hackage.haskell.org/package/conduit) but with a list like
27−API. The streaming API of streamly is close to the monadic streams API of the
28−[vector](https://hackage.haskell.org/package/vector) package and similar in
29−concept to the [streaming](https://hackage.haskell.org/package/streaming)
30−package. In addition to providing streaming functionality, streamly subsumes
11+Streamly, short for streaming concurrently, provides monadic streams, with a
12+simple API, almost identical to standard lists, and an in-built support for
13+concurrency. By using stream-style combinators on stream composition,
14+streams can be generated, merged, chained, mapped, zipped, and consumed
15+concurrently – providing a generalized high level programming framework
16+unifying streaming and concurrency. Controlled concurrency allows even infinite
17+streams to be evaluated concurrently. Concurrency is auto scaled based on
18+feedback from the stream consumer. The programmer does not have to be aware of
19+threads, locking or synchronization to write scalable concurrent programs.
20+
21+The basic streaming functionality of streamly is equivalent to that provided by
22+streaming libraries like
23+[vector](https://hackage.haskell.org/package/vector),
24+[streaming](https://hackage.haskell.org/package/streaming),
25+[pipes](https://hackage.haskell.org/package/pipes), and
26+[conduit](https://hackage.haskell.org/package/conduit).
27+In addition to providing streaming functionality, streamly subsumes
3128the functionality of list transformer libraries like `pipes` or
32−[list-t](https://hackage.haskell.org/package/list-t) and also the logic
29+[list-t](https://hackage.haskell.org/package/list-t), and also the logic
3330programming library [logict](https://hackage.haskell.org/package/logict). On
3431the concurrency side, it subsumes the functionality of the
3532[async](https://hackage.haskell.org/package/async) package. Because it supports
3633streaming with concurrency we can write FRP applications similar in concept to
3734[Yampa](https://hackage.haskell.org/package/Yampa) or
38−[reflex](https://hackage.haskell.org/package/reflex). To understand the
39−streaming library ecosystem and where streamly fits in you may want to read
40−[streaming libraries](https://github.com/composewell/streaming-benchmarks#streaming-libraries)
41−as well. Also see the [Comparison with Existing
42−Packages](https://hackage.haskell.org/package/streamly/docs/Streamly-Tutorial.html)
43−section in the streamly tutorial.
35+[reflex](https://hackage.haskell.org/package/reflex).
4436
4537Why use streamly?
4638
47− * Simple list like streaming API, if you know how to use lists then you know
48− how to use streamly.
49− * Powerful yet simple and scalable concurrency. Concurrency is not intrusive,
50− concurrent programs are written exactly the same way as non-concurrent
51− ones. There is no other package that provides such high level, simple and
52− flexible concurrency support.
53− * It is a general programming framework providing you all the necessary tools
54− to solve a wide range of programming problems, unifying the functionality
55− provided by several disparate packages in a concise and simple API.
56− * Best in class performance. See
39+ * _Simplicity_: Simple list like streaming API, if you know how to use lists
40+ then you know how to use streamly. This library is built with simplicity
41+ and ease of use as a design goal.
42+ * _Concurrency_: Simple, powerful, and scalable concurrency. Concurrency is
43+ built-in, and not intrusive, concurrent programs are written exactly the
44+ same way as non-concurrent ones.
45+ * _Generality_: Unifies functionality provided by several disparate packages
46+ (streaming, concurrency, list transformer, logic programming, reactive
47+ programming) in a concise API.
48+ * _Performance_: Streamly is designed for high performance. See
5749 [streaming-benchmarks](https://github.com/composewell/streaming-benchmarks)
5850 for a comparison of popular streaming libraries on micro-benchmarks.
5951
60− For more information, see:
52+For more details on streaming library ecosystem and where streamly fits in,
53+please see
54+[streaming libraries](https://github.com/composewell/streaming-benchmarks#streaming-libraries).
55+Also, see the [Comparison with Existing
56+Packages](https://hackage.haskell.org/package/streamly/docs/Streamly-Tutorial.html)
57+section in the streamly tutorial.
58+
59+For more information on streamly, see:
6160
6261 * [Streamly.Tutorial](https://hackage.haskell.org/package/streamly/docs/Streamly-Tutorial.html) module in the haddock documentation for a detailed introduction
6362 * [examples](https://github.com/composewell/streamly/tree/master/examples) directory in the package for some simple practical examples
@@ -265,7 +264,7 @@ import Path.IO (listDir, getCurrentDir)
265264import Streamly
266265import qualified Streamly.Prelude as S
267266
268−main = runStream $ asyncly $ getCurrentDir >>= readdir
267+main = runStream $ aheadly $ getCurrentDir >>= readdir
269268 where readdir d = do
270269 (dirs, files) <- S.once $ listDir d
271270 S.once $ mapM_ putStrLn $ map show files
@@ -275,8 +274,8 @@ main = runStream $ asyncly $ getCurrentDir >>= readdir
275274
276275In the above examples we do not think in terms of threads, locking or
277276synchronization, rather we think in terms of what can run in parallel, the rest
278−is taken care of automatically. When using `asyncly` the programmer does
279−not have to worry about how many threads are to be created they are
277+is taken care of automatically. When using `aheadly` the programmer does
278+not have to worry about how many threads are to be created, they are
280279automatically adjusted based on the demand of the consumer.
281280
282281The concurrency facilities provided by streamly can be compared with