This version fixes Task.memoize and Coeval.memoize, while
introducing even more and quite significant Task optimizations.
More details on performance to follow.
NOTE: version 2.0-RC13 was published immediately after version
2.0-RC12, due to a critical bug reported by Mark Tomko and
immediately fixed in
issue #215.
This release fixes one issue with Task, as it was discovered that
flatMap loops aren’t automatically cancelable, a small
oversight. Also CompositeCancelable.remove wasn’t working, a bug
introduced in the previous release. Another bug that was fixed is in
Consumer.foldLeftAsync, which wasn’t capturing errors properly.
This release introduces a major refactoring of the Task internal
workings of its trampoline, as a serious optimization. As an example
of what this brings, the conversion from a Future with
Task.fromFuture has near-zero overhead and the performance of
Task.gather and Task.gatherUnordered has improved significantly.
There are also breaking API changes, sorry about that, but these
should come sooner rather than later, before marking 2.0 final. The
zipWith (e.g. zipWith2, zipWith3) operators on Task and
Observable and the combineLatestWith operators on Observable
have been renamed to zipMap (e.g. zipMap2, etc) and
combineLatestMap respectively. This because zipMap describes the
operation much better and this name has also been used in the
Typelevel Cats / Dogs libraries at least.
This release adds some useful extension methods for Scheduler and
Callback, while optimizing and making safer some Task operations, like
gatherUnordered, ‘chooseFirstOfList’ and create. On Observable it
also changes how onOverflow behaves when specified in an OverflowStrategy.
This will be a breaking, but easy to fix change.
Release RC10 is the last release before 2.0, scheduled for September 1st (promise, cross my heart and hope to …).
BUG WARNING: this release contains a critical bug issue. Upgrade to the latest version as soon as possible.
Read more →This release fixes a bug in Task.mapBoth and thus the operations
depending on it, like Task.gather. It also fixes another bug in
the Cats Applicative instance for Task, adding a required overload
for running Tasks in parallel when using the applicative builder.
This release also changes the signatures of Task’s sequence, gather and
gatherUnordered to use the CanBuildFrom pattern, a contribution
by @guersam.
This release candidate is probably the last one before 2.0, assuming
new bugs aren’t found. Amongst others, it introduces an awesome
Consumer type which makes it possible to describe composable
consumers. For a teaser:
// For processing sums in parallel, useless of course, but can become
// really helpful for logic sprinkled with I/O bound stuff
val consumer = Consumer
.loadBalance(parallelism=10, Consumer.foldLeft(Coeval(0L))(_ + _))
.map(_.sum)
val observable: Observable[Int] = ???
// Our consumer turns our observable into a Task processing sums, w00t!
val task: Task[Long] = observable.runWith(consumer)
// Consume the whole stream and get the result
task.runAsync.foreach(println)