Things to do

[harendra-kumar]

• Records
• Effects
• Logging

---

• Break into smaller packages to make the packaging modular
• GHC proposal to integrate fusion-plugin functionality
• Monomorphic stream type modules
• Concurrency. Simplify the implementation, with SVars as explicit Channels.
• Safe, high performance, unified path representation. See https://github.com/composewell/streamly/blob/master/design/paths.rst
  • FileSystem.File and FileSystem.Dir modules would be released once this is done.
• High performance time representation.
  • Release Streamly.Internal.Data.Time.* modules.
  • Many time based combinators are to be released once this is complete.
• Folds.
  • A simpler scan capable type
  • backtracking support in terminating folds
  • CPS representation for monad instance
  • Array stream folds
  • Functor general folds (unfoldMany for folds)
  • Turn all splitting operations, string search ops into folds (e.g. splitOnSeq)
  • Fold array streams using SIMD (e.g. takeEndBy, wordsBy) and combine the results. See word count example for how to combine fragments.
• Parsers.
  • Finish and release
  • performance benchmarking
  • JSON parser
  • String search and regexes (grep), find filters
  • Stream editing (sed)
  • Parse array streams using SIMD
• Builders. See Add a Builder data type for incremental appends #700 .
• Pipes. Modular, high performance transformation functions with full stream fusion. Several combinators are not yet released because we want them to be pipes instead of stream transformations. We can start with a simpler version to begin with. May need a CPS representation as well. A working impl is already present in https://github.com/composewell/streamly/blob/master/src/Streamly/Internal/Data/Pipe/Type.hs .
• Concurrency: Monoidal fragment combining library. For common use cases (e.g. line break, word break, string search etc.) provide readily available modular components to operate on arrays and combine them monoidally. See also Concurrent monad transformers #247 .
• Concurrent stream splitting/scanning
• Concurrent consumers - folds and parsers.
• Arrays
  • Mutable arrays, appending arrays
  • Array specific combinators (e.g. binary search, quicksort)
• Persistent buffers between stream stages
• streamly-unicode. See https://github.com/composewell/streamly/blob/master/design/unicode.md .
• FileSystem - Dir streams