Update some user guides

core/docs/Changelog.md

@@ -9,9 +9,13 @@ full list of deprecations, additions, and changes to the function signatures.
 
 * Added APIs for prompt cleanup of resources, allowing guaranteed
   cleanup as an alternative to GC-based cleanup.
+* Added operations for fair nesting of inner and outer streams for
+  exploring them equally, generally useful but especially useful for logic
+  programming use cases.
 * Introduced `Streamly.Data.Scanl` with a new `Scanl` type. Scans can
   split a stream into multiple streams, process them independently, and
   merge the results. The `Fold` type is now split into `Fold` and `Scanl`.
+* Added `RingArray` module for high-performance, unboxed circular buffers.
 * Added `Streamly.FileSystem.Path` module with a `Path` type for flexibly typed
   file system paths.
 * Added `Streamly.FileSystem.DirIO` and `Streamly.FileSystem.FileIO` to replace

core/streamly-core.cabal

@@ -1,4 +1,4 @@
-cabal-version:      2.2
+cabal-version:      2.4
 name:               streamly-core
 version:            0.3.0
 synopsis:           Streaming, parsers, arrays, serialization and more

docs/User/Project/ApiChangelogs/0.8.3.txt → docs/User/Project/ApiChangelogs/0.7.3-0.8.0.txt

@@ -2,14 +2,6 @@
 # ~~~ means deprecated module
 # ~~ means deprecated symbol
 
-#----------------------------
-# Changes from 0.8.0 to 0.8.1
-#----------------------------
-
-@@@ Streamly.FileSystem.Handle
-++ getChunk :: MonadIO m => Int -> Handle -> m (Array Word8)
-++ putChunk :: (MonadIO m, Storable a) => Handle -> Array a -> m ()
-
 #----------------------------
 # Changes from 0.7.3 to 0.8.0
 #----------------------------

docs/User/Project/ApiChangelogs/0.8.0-0.8.1.txt

@@ -0,0 +1,11 @@
+# API diff as generated by cabal-diff with minor edits.
+# ~~~ means deprecated module
+# ~~ means deprecated symbol
+
+#----------------------------
+# Changes from 0.8.0 to 0.8.1
+#----------------------------
+
+@@@ Streamly.FileSystem.Handle
+++ getChunk :: MonadIO m => Int -> Handle -> m (Array Word8)
+++ putChunk :: (MonadIO m, Storable a) => Handle -> Array a -> m ()

docs/User/Tutorials/module-structure-and-quick-examples.md

@@ -6,16 +6,16 @@ performance.
 
 Streamly consists of two packages: "streamly-core" and "streamly".
 [streamly-core](https://hackage.haskell.org/package/streamly-core)
-provides basic features, and depends only on GHC boot libraries, while
+provides most of the core functionality, and depends only on GHC boot libraries, while
 [streamly](https://hackage.haskell.org/package/streamly) provides
 higher-level features like concurrency, time based streaming
 combinators, lifted exceptions, and streaming network operations.
 
-In streamly there are two core data structures, streams and arrays. They
-are computing duals of each other, streams are for dataflow style
-processing while arrays are for storing data.  Both taken together
-are powerful tools for general purpose programming in a functional or
-dataflow style.
+Streamly is built around two core data structures: streams and
+arrays. They are computational duals—streams enable dataflow-style
+processing, while arrays provide efficient data storage. Together, they
+form a powerful foundation for general-purpose programming in
+functional and dataflow paradigms.
 
 The general data processing functionality in `streamly` can be divided
 into following categories:
@@ -35,18 +35,18 @@ following categories:
 
 ## Streams
 
-In functional programming, stream processing paradigm is a higher level
-alternative to the low level looping paradigm found in imperative
-programming. The `Stream` abstraction in streamly represents data as a
-sequence of items of the same type.  Functional operations are used to
-process and transform each item in the stream to a new stream of the
-same or different type.
+In functional programming, the **stream processing paradigm** offers
+a higher-level alternative to the low-level looping constructs of
+imperative programming. In Streamly, the `Stream` abstraction models
+data as a sequence of items of the same type. Functional operations can
+then be applied to process and transform each item, producing a new
+stream of either the same or a different type.
 
 ### Stream Type
 
-Following is a contrived example which generates a stream consisting of a
-sequence of integers, then increments each one by 1, takes the first two
-elements, adds them and prints the result:
+The following contrived example generates a stream of integers,
+increments each element by 1, takes the first two elements, adds them
+together, and prints the result:
 
 ```haskell
 import Data.Function ((&))
@@ -73,9 +73,9 @@ output. The `Fold.sum` function above is a `Fold` which consumes an
 integer stream as input and returns their sum as output. The fold is
 driven using the `Stream.fold` combinator.
 
-Folds can be composed using combinators, for example, the `teeWith` combinator
-combines two folds such that the input of the resulting fold is passed through
-both of them.
+Folds can be composed using combinators. For example, the `teeWith`
+combinator combines two folds so that the input stream is fed into both
+the folds simultaneously.
 
 ```haskell
 f :: Monad m => Fold.Fold m Int (Int, Int)

docs/User/Tutorials/performance-considerations.md

@@ -107,14 +107,13 @@ arrays store data without an additional heap pointer wrapper
 
 * Streamly.Data.Array
 * Streamly.Data.MutArray
-* Streamly.Internal.Data.RingArray
+* Streamly.Data.RingArray
 
 For storing boxed heap objects, boxed arrays are provided in the following
 modules:
 
 * Streamly.Data.Array.Generic
 * Streamly.Data.MutArray.Generic
-* Streamly.Internal.Data.RingArray.Generic
 
 Unboxed arrays can be pinned (cannot be moved by GC) or
 unpinned. However, pinned or unpinned nature of the memory is not