20 KiB
Changelog
0.8.1.1 (Dec 2021)
- Disable building FileSystem.Events where FS Events isn't supported.
0.8.1 (Nov 2021)
See docs/API-changelog.txt for new APIs introduced.
Bug Fixes
- Several bug fixes in the Array module:
- Fix writeN fold eating away one element when applied multiple times #1258.
- Fix potentially writing beyond allocated memory when shrinking. Likely cause of #944.
- Fix potentially writing beyond allocated memory when writing the last element. Likely cause of #944.
- Fix missing pointer touch could potentially cause use of freed memory.
- Fix unnecessary additional allocation due to a bug
- Fix a bug in classifySessionsBy, see PR #1311. The bug could cause premature ejection of a session when input events with the same key are split into multiple sessions.
Notable Internal API Changes
tapAsync
fromStreamly.Internal.Data.Stream.Parallel
has been moved toStreamly.Internal.Data.Stream.IsStream
and renamed totapAsyncK
.Fold2
has now been renamed toRefold
and the correspondingFold2
combinators have been either renamed or removed.
0.8.0 (Jun 2021)
See API Changelog for a complete list of signature changes and new APIs introduced.
Breaking changes
Streamly.Prelude
fold
: this function may now terminate early without consuming the entire stream. For example,fold Fold.head stream
would now terminate immediately after consuming the head element fromstream
. This may result in change of behavior in existing programs if the program relies on the evaluation of the full stream.
Streamly.Data.Unicode.Stream
- The following APIs no longer throw errors on invalid input, use new
APIs suffixed with a prime for strict behavior:
- decodeUtf8
- encodeLatin1
- encodeUtf8
- The following APIs no longer throw errors on invalid input, use new
APIs suffixed with a prime for strict behavior:
Streamly.Data.Fold
:- Several instances have been moved to the
Streamly.Data.Fold.Tee
module, please use theTee
type to adapt to the changes.
- Several instances have been moved to the
Bug Fixes
- Concurrent Streams: The monadic state for the stream is now propagated across threads. Please refer to #369 for more info.
Streamly.Prelude
:bracket
,handle
, andfinally
now also work correctly on streams that aren't fully drained. Also, the resource acquisition and release is atomic with respect to async exceptions.iterate
,iterateM
now consume O(1) space instead of O(n).fromFoldableM
is fixed to be concurrent.
Streamly.Network.Inet.TCP
:accept
andconnect
APIs now close the socket if an exception is thrown.Streamly.Network.Socket
:accept
now closes the socket if an exception is thrown.
Enhancements
- See API Changelog for a complete list of new modules and APIs introduced.
- The Fold type is now more powerful, the new termination behavior allows to express basic parsing of streams using folds.
- Many new Fold and Unfold APIs are added.
- A new module for console IO APIs is added.
- Experimental modules for the following are added:
- Parsing
- Deserialization
- File system event handling (fsnotify/inotify)
- Folds for streams of arrays
- Experimental
use-c-malloc
build flag to use the c librarymalloc
for array allocations. This could be useful to avoid pinned memory fragmentation.
Notable Internal/Pre-release API Changes
Breaking changes:
- The
Fold
type has changed to accommodate terminating folds. - Rename:
Streamly.Internal.Prelude
=>Streamly.Internal.Data.Stream.IsStream
- Several other internal modules have been renamed and re-factored.
Bug fixes:
- A bug was fixed in the conversion of
MicroSecond64
andMilliSecond64
(commite5119626
) - Bug fix:
classifySessionsBy
now flushes sessions at the end and terminates.
Miscellaneous
- Drop support for GHC 7.10.3.
- The examples in this package are moved to a new github repo streamly-examples
0.7.3 (February 2021)
Build Issues
- Fix build issues with primitive package version >= 0.7.1.
- Fix build issues on armv7.
0.7.2 (April 2020)
Bug Fixes
- Fix a bug in the
Applicative
andFunctor
instances of theFold
data type.
Build Issues
- Fix a bug that occasionally caused a build failure on windows when
used with
stack
orstack ghci
. - Now builds on 32-bit machines.
- Now builds with
primitive
package version >= 0.5.4 && <= 0.6.4.0 - Now builds with newer
QuickCheck
package version >= 2.14 && < 2.15. - Now builds with GHC 8.10.
0.7.1 (February 2020)
Bug Fixes
- Fix a bug that caused
findIndices
to return wrong indices in some cases. - Fix a bug in
tap
,chunksOf
that caused memory consumption to increase in some cases. - Fix a space leak in concurrent streams (
async
,wAsync
, andahead
) that caused memory consumption to increase with the number of elements in the stream, especially when built with-threaded
and used with-N
RTS option. The issue occurs only in cases when a worker thread happens to be used continuously for a long time. - Fix scheduling of WAsyncT stream style to be in round-robin fashion.
- Now builds with
containers
package version < 0.5.8. - Now builds with
network
package version >= 3.0.0.0 && < 3.1.0.0.
Behavior change
- Combinators in
Streamly.Network.Inet.TCP
no longer use TCPNoDelay
andReuseAddr
socket options by default. These options can now be specified using appropriate combinators.
Performance
- Now uses
fusion-plugin
package for predictable stream fusion optimizations - Significant improvement in performance of concurrent stream operations.
- Improved space and time performance of
Foldable
instance.
0.7.0 (November 2019)
Breaking changes
- Change the signature of
foldrM
to ensure that it is lazy - Change the signature of
iterateM
to ensure that it is lazy. scanx
would now require an additionalMonad m
constraint.
Behavior change
- Earlier
ParallelT
was unaffected bymaxBuffer
directive, nowmaxBuffer
can limit the buffer of aParallelT
stream as well. When the buffer becomes full, the producer threads block. ParallelT
streams no longer have an unlimited buffer by default. Now the buffer for parallel streams is limited to 1500 by default, the same as other concurrent stream types.
Deprecations
-
In
Streamly.Prelude
:runStream
has been replaced bydrain
runN
has been replaced bydrainN
runWhile
has been replaced bydrainWhile
fromHandle
has been deprecated. Please useStreamly.FileSystem.Handle.read
,Streamly.Data.Unicode.Stream.decodeUtf8
andsplitOnSuffix
withStreamly.Data.Fold.toList
to split the stream to a stream ofString
separated by a newline.toHandle
has been deprecated. Please useintersperse
andconcatUnfold
to add newlines to a stream,Streamly.Data.Unicode.Stream.encodeUtf8
for encoding andStreamly.FileSystem.Handle.write
for writing to a file handle.- Deprecate
scanx
,foldx
,foldxM
,foldr1
- Remove deprecated APIs
foldl
,foldlM
- Replace deprecated API
scan
with a new signature, to scan using Fold.
-
In
Streamly
module:runStream
has been deprecated, please useStreamly.Prelude.drain
-
Remove deprecated module
Streamly.Time
(moved to Streamly.Internal.Data.Time) -
Remove module
Streamly.Internal
(functionality moved to the Internal hierarchy)
Bug Fixes
- Fix a bug that caused
uniq
function to yield the same element twice. - Fix a bug that caused "thread blocked indefinitely in an MVar operation" exception in a parallel stream.
- Fix unbounded memory usage (leak) in
parallel
combinator. The bug manifests when large streams are combined usingparallel
.
Major Enhancements
This release contains a lot of new features and major enhancements. For more details on the new features described below please see the haddock docs of the modules on hackage.
Exception Handling
See Streamly.Prelude
for new exception handling combinators like before
,
after
, bracket
, onException
, finally
, handle
etc.
Composable Folds
Streamly.Data.Fold
module provides composable folds (stream consumers). Folds
allow splitting, grouping, partitioning, unzipping and nesting a stream onto
multiple folds without breaking the stream. Combinators are provided for
temporal and spatial window based fold operations, for example, to support
folding and aggregating data for timeout or inactivity based sessions.
Composable Unfolds
Streamly.Data.Unfold
module provides composable stream generators. Unfolds allow
high performance merging/flattening/combining of stream generators.
Streaming File IO
Streamly.FileSystem.Handle
provides handle based streaming file IO
operations.
Streaming Network IO
-
Streamly.Network.Socket
provides socket based streaming network IO operations. -
Streamly.Network.Inet.TCP
provides combinators to build Inet/TCP clients and servers.
Concurrent concatMap
The new concatMapWith
in Streamly.Prelude
combinator performs a
concatMap
using a supplied merge/concat strategy. This is a very
powerful combinator as you can, for example, concat streams
concurrently using this.
Other Enhancements
-
Add the following new features/modules:
- Unicode Strings:
Streamly.Data.Unicode.Stream
module provides encoding/decoding of character streams and other character stream operations. - Arrays:
Streamly.Memory.Array
module provides arrays for efficient in-memory buffering and efficient interfacing with IO.
- Unicode Strings:
-
Add the following to
Streamly.Prelude
:unfold
,fold
,scan
andpostscan
concatUnfold
to concat a stream after unfolding each elementintervalsOf
andchunksOf
splitOn
,splitOnSuffix
,splitWithSuffix
, andwordsBy
groups
,groupsBy
andgroupsByRolling
postscanl'
andpostscanlM'
intersperse
intersperse an element in between consecutive elements in streamtrace
combinator maps a monadic function on a stream just for side effectstap
redirects a copy of the stream to aFold
0.6.1 (March 2019)
Bug Fixes
- Fix a bug that caused
maxThreads
directive to be ignored when rate control was not used.
Enhancements
- Add GHCJS support
- Remove dependency on "clock" package
0.6.0 (December 2018)
Breaking changes
Monad
constraint may be needed on some of the existing APIs (findIndices
andelemIndices
).
Enhancements
- Add the following functions to Streamly.Prelude:
- Generation:
replicate
,fromIndices
,fromIndicesM
- Enumeration:
Enumerable
type class,enumerateFrom
,enumerateFromTo
,enumerateFromThen
,enumerateFromThenTo
,enumerate
,enumerateTo
- Running:
runN
,runWhile
- Folds:
(!!)
,maximumBy
,minimumBy
,the
- Scans:
scanl1'
, `scanl1M' - Filters:
uniq
,insertBy
,deleteBy
,findM
- Multi-stream:
eqBy
,cmpBy
,mergeBy
,mergeByM
,mergeAsyncBy
,mergeAsyncByM
,isPrefixOf
,isSubsequenceOf
,stripPrefix
,concatMap
,concatMapM
,indexed
,indexedR
- Generation:
- Following instances were added for
SerialT m
,WSerialT m
andZipSerialM m
:- When
m
~Identity
: IsList, Eq, Ord, Show, Read, IsString, NFData, NFData1, Traversable - When
m
isFoldable
: Foldable
- When
- Performance improvements
- Add benchmarks to measure composed and iterated operations
0.5.2 (October 2018)
Bug Fixes
- Cleanup any pending threads when an exception occurs.
- Fixed a livelock in ahead style streams. The problem manifests sometimes when multiple streams are merged together in ahead style and one of them is a nil stream.
- As per expected concurrency semantics each forked concurrent task must run
with the monadic state captured at the fork point. This release fixes a bug,
which, in some cases caused an incorrect monadic state to be used for a
concurrent action, leading to unexpected behavior when concurrent streams are
used in a stateful monad e.g.
StateT
. Particularly, this bug cannot affectReaderT
.
0.5.1 (September 2018)
- Performance improvements, especially space consumption, for concurrent streams
0.5.0 (September 2018)
Bug Fixes
- Leftover threads are now cleaned up as soon as the consumer is garbage collected.
- Fix a bug in concurrent function application that in certain cases would unnecessarily share the concurrency state resulting in incorrect output stream.
- Fix passing of state across
parallel
,async
,wAsync
,ahead
,serial
,wSerial
combinators. Without this fix combinators that rely on state passing e.g.maxThreads
andmaxBuffer
won't work across these combinators.
Enhancements
- Added rate limiting combinators
rate
,avgRate
,minRate
,maxRate
andconstRate
to control the yield rate of a stream. - Add
foldl1'
,foldr1
,intersperseM
,find
,lookup
,and
,or
,findIndices
,findIndex
,elemIndices
,elemIndex
,init
to Prelude
Deprecations
- The
Streamly.Time
module is now deprecated, its functionality is subsumed by the new rate limiting combinators.
0.4.1 (July 2018)
Bug Fixes
- foldxM was not fully strict, fixed.
0.4.0 (July 2018)
Breaking changes
- Signatures of
zipWithM
andzipAsyncWithM
have changed - Some functions in prelude now require an additional
Monad
constraint on the underlying type of the stream.
Deprecations
once
has been deprecated and renamed toyieldM
Enhancements
- Add concurrency control primitives
maxThreads
andmaxBuffer
. - Concurrency of a stream with bounded concurrency when used with
take
is now limited by the number of elements demanded bytake
. - Significant performance improvements utilizing stream fusion optimizations.
- Add
yield
to construct a singleton stream from a pure value - Add
repeat
to generate an infinite stream by repeating a pure value - Add
fromList
andfromListM
to generate streams from lists, faster thanfromFoldable
andfromFoldableM
- Add
map
as a synonym of fmap - Add
scanlM'
, the monadic version of scanl' - Add
takeWhileM
anddropWhileM
- Add
filterM
0.3.0 (June 2018)
Breaking changes
- Some prelude functions, to whom concurrency capability has been added, will
now require a
MonadAsync
constraint.
Bug Fixes
- Fixed a race due to which, in a rare case, we might block indefinitely on an MVar due to a lost wakeup.
- Fixed an issue in adaptive concurrency. The issue caused us to stop creating more worker threads in some cases due to a race. This bug would not cause any functional issue but may reduce concurrency in some cases.
Enhancements
- Added a concurrent lookahead stream type
Ahead
- Added
fromFoldableM
API that creates a stream from a container of monadic actions - Monadic stream generation functions
consM
,|:
,unfoldrM
,replicateM
,repeatM
,iterateM
andfromFoldableM
can now generate streams concurrently when used with concurrent stream types. - Monad transformation functions
mapM
andsequence
can now map actions concurrently when used at appropriate stream types. - Added concurrent function application operators to run stages of a stream processing function application pipeline concurrently.
- Added
mapMaybe
andmapMaybeM
.
0.2.1 (June 2018)
Bug Fixes
- Fixed a bug that caused some transformation ops to return incorrect results
when used with concurrent streams. The affected ops are
take
,filter
,takeWhile
,drop
,dropWhile
, andreverse
.
0.2.0 (May 2018)
Breaking changes
-
Changed the semantics of the Semigroup instance for
InterleavedT
,AsyncT
andParallelT
. The new semantics are as follows:- For
InterleavedT
,<>
operation interleaves two streams - For
AsyncT
,<>
now concurrently merges two streams in a left biased manner using demand based concurrency. - For
ParallelT
, the<>
operation now concurrently meges the two streams in a fairly parallel manner.
To adapt to the new changes, replace
<>
withserial
wherever it is used for stream types other thanStreamT
. - For
-
Remove the
Alternative
instance. To adapt to this change replace any usage of<|>
withparallel
andempty
withnil
. -
Stream type now defaults to the
SerialT
type unless explicitly specified using a type combinator or a monomorphic type. This change reduces puzzling type errors for beginners. It includes the following two changes:- Change the type of all stream elimination functions to use
SerialT
instead of a polymorphic type. This makes sure that the stream type is always fixed at all exits. - Change the type combinators (e.g.
parallely
) to only fix the argument stream type and the output stream type remains polymorphic.
Stream types may have to be changed or type combinators may have to be added or removed to adapt to this change.
- Change the type of all stream elimination functions to use
-
Change the type of
foldrM
to make it consistent withfoldrM
in base. -
async
is renamed tomkAsync
andasync
is now a new API with a different meaning. -
ZipAsync
is renamed toZipAsyncM
andZipAsync
is now ZipAsyncM specialized to the IO Monad. -
Remove the
MonadError
instance as it was not working correctly for parallel compositions. UseMonadThrow
instead for error propagation. -
Remove Num/Fractional/Floating instances as they are not very useful. Use
fmap
andliftA2
instead.
Deprecations
- Deprecate and rename the following symbols:
Streaming
toIsStream
runStreaming
torunStream
StreamT
toSerialT
InterleavedT
toWSerialT
ZipStream
toZipSerialM
ZipAsync
toZipAsyncM
interleaving
towSerially
zipping
tozipSerially
zippingAsync
tozipAsyncly
<=>
towSerial
<|
toasync
each
tofromFoldable
scan
toscanx
foldl
tofoldx
foldlM
tofoldxM
- Deprecate the following symbols for future removal:
runStreamT
runInterleavedT
runAsyncT
runParallelT
runZipStream
runZipAsync
Enhancements
- Add the following functions:
consM
and|:
operator to construct streams from monadic actionsonce
to create a singleton stream from a monadic actionrepeatM
to construct a stream by repeating a monadic actionscanl'
strict left scanfoldl'
strict left foldfoldlM'
strict left fold with a monadic fold functionserial
run two streams serially one after the otherasync
run two streams asynchronouslyparallel
run two streams in parallel (replaces<|>
)WAsyncT
stream type for BFS version ofAsyncT
composition
- Add simpler stream types that are specialized to the IO monad
- Put a bound (1500) on the output buffer used for asynchronous tasks
- Put a limit (1500) on the number of threads used for Async and WAsync types
0.1.2 (March 2018)
Enhancements
- Add
iterate
,iterateM
stream operations
Bug Fixes
- Fixed a bug that caused unexpected behavior when
pure
was used to inject values in Applicative composition ofZipStream
andZipAsync
types.
0.1.1 (March 2018)
Enhancements
- Make
cons
right associative and provide an operator form.:
for it - Add
null
,tail
,reverse
,replicateM
,scan
stream operations - Improve performance of some stream operations (
foldl
,dropWhile
)
Bug Fixes
- Fix the
product
operation. Earlier, it always returned 0 due to a bug - Fix the
last
operation, which returnedNothing
for singleton streams
0.1.0 (December 2017)
- Initial release