This post describes the relationship between Monix and Cats-Effect, their history and when each should be used.
]]>3.0.0 release is near and it’s going to be huge. This is the first of the two
release candidates planned, see below for the timeline.
The theme of the 3.x series are:
Task, in concert with its cats-effect integrationObservable, CancelableFuture, etc.monix.tail.Iterant, a purely functional, pull-based
streaming alternativeFeatured presentation:
]]>2.3.x.
Upgrade to 2.3.3 is recommended, as it contains critical bug fixes!
See list below for more details.
A release for the 3.0.0-Mx series will follow either today or tomorrow.
2.3.0 is out now.
It is a major release that remains binary and source compatible with
2.2.x.
In summary we’ve got a replacement for Scala’s NonFatal,
a new Task.deferAction builder for defering tasks with an injected scheduler,
Task and Coeval run-loop optimizations, the Observable.observeOn
operation after popular request, a Consumer.transformInput for
transforming consumers by transforming their input stream,
fixes for the reactive streams integration and more.
See details below.
2.2.4 is out now.
It is a minor release that’s binary and source compatible with
2.2.x, fixing a bugs and upgrading Scala.js:
Observable.firstStartedOf fails due to off-by-one errorconcatMap / mapTask trigger invalid state warning
on raiseError childrenChanges:
CompositeCancelable.getAndResetTo, needed for the new
firstStartedOf implementation0.6.15, handing deprecation
warnings in TaskApp
Upgrade should be safe, being binary compatible with all previous
2.2.x versions.
2.2.3 is out now.
It is a minor release that’s binary and source compatible with
2.2.x, fixing a critical bug that happens in Scala 2.12, due to
changes to how flatMap is implemented in scala.concurrent.Future:
Ack.Continue.transformWith and Ack.Stop.transformWith
are not stack-safeImpact of this bug: it does NOT impact most (probably all)
functionality in Monix, because Monix rarely flatMaps direct
Continue references (due to batching and optimizations) and we have
had extensive tests for long loops that could trigger this problem.
However this bug can be dangerous for people that have implemented the communication protocol (as described in the docs) by themselves. If you’re using Monix with Scala 2.12, then upgrade immediately.
Upgrade should be safe, being binary compatible with all previous
2.2.x versions.
2.2.2 is out now.
It is a minor release that’s binary and source compatible with 2.2.x.
In summary:
Task, for providing stability
and preventing cascading failures in distributed systemsTask!.memoizeOnSuccess and Coeval!.memoizeOnSuccess
operators that only caches the result (with idempotency guarantees)
for successful results, while re-evaluating the source on failuresTask.deferFutureAction that helps with wrapping
Future-enabled APIs without requiring ExecutionContext in the
function signature, since Task can inject it for youSingleAssignmentCancelable.plusOne for helping with building
Consumer objectsmonix.execution
Task.sequence now has lazy behavior in evaluating the given
sequence (previously we were doing a foldLeft on that sequence,
which could have strict behavior, depending on the collection type)Details below!
]]>2.2.1 is out now.
It is a major release that shouldn’t be considered binary compatible with 2.1.x,
even though it is source compatible. This is due to several operators being
changed in Observable and Task, but extension methods are provided for the older
versions, therefore source compatibility is maintained.
As a summary: the new MVar synchronization primitive, performance improvements
in Observable.concatMap and in the Task run-loop, new SchedulerService
interface for shutting down schedulers, bug fixes and upgrade to Cats 0.9.0.
See details below.
Version 2.1.2 is out now.
It is a minor release, binary compatible with 2.1.x,
upgrading Scala to 2.12.1 and fixing a bug in Observable.bufferSliding.
See Bug #275.
Version 2.1.1 is out now, while version 2.1.0 was out
on Nov 9.
The official announcement was then postponed because we waited to see
if bug reports are going to happen. Today version 2.1.1 was
released, fixing such a problem.
To use the new version, include this in your build.sbt (and use
%%% for Scala.js):
libraryDependencies += "io.monix" %% "monix" % "2.1.1"
The new version supports:
The theme of the 2.1 release has been performance optimizations, in
some cases quite massive, improving Task and parallelizing work by
means of the new Observable.mapAsync or by TaskSemaphore.
build.sbt:
libraryDependencies += "io.monix" %% "monix" % "2.0.6"
This version is published for Scala 2.12.0 final release, incrementing the dependency on Minitest to 0.27 and on Scalaz to 7.2.7.
]]>build.sbt:
libraryDependencies += "io.monix" %% "monix" % "2.0.5"
AsyncScheduler.scheduleAtFixedRate and scheduleWithFixedDelay on the JVM
have incorrect behavior.
In order to upgrade, just increment the version number in build.sbt:
libraryDependencies += "io.monix" %% "monix" % "2.0.4"
LocalBatchingExecutor
(affects Task usage).
]]>IllegalStateException logged in parallel consumer, when streaming
gets canceled due to a subscriber triggering an errorThis bug if basically harmless, it’s only effect being to log
unnecessary IllegalStateExceptions by means of
Scheduler.reportError.
Enjoy!
]]>0.7.2, Scalaz to 7.2.6 and
Scala to 2.12.0-RC1.
The upgrade isn’t necessary, unless you’re using monix-cats and are
affected by Cats #1346.
Today marks the release of the 2.0.0 version. Here’s what happened
since 1.0:
Observable has been reviewed and
changed quite significantly, making observable streams cancelableObservable operators where refactored and improvedTask, Coeval
and Observable are provably Monads :-)Today Monix 2.0.0 is being released for Scala 2.10.6, 2.11.8 and
2.12.0-M5, Scala.js 0.6.11, Cats 0.7.0 and Scalaz 7.2.5.
You can hit the documentation, or experiment in ScalaFiddle and see Monix in your browser, or take a look at monix-sample, a client/server communication sample with both sides handled by Monix (see it running).
]]>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.
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.
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.
]]>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.
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)
Task.materializeAttempt and
consequently Task.onErrorHandleWith. It also adds
Scalaz integration and a TaskApp to make your
friends jealous. Also the Atomic references in project Sincron are
being brought back into Monix proper, in monix-execution, because
project Sincron is for all intents and purposes part of Monix and
has no further ambitions.
]]>Applicative instance for Task,
changes the Observable.buffer operators to match the behavior in ReactiveX,
adds observable builders from java.io.InputStream and Reader,
adds Observable.executeOn, along with other utils and refactors the
Pipe and ConcurrentSubject builders. Also contains bug fixes.
]]>Task
operators doOnFinish, gather and gatherUnordered and changes
the behavior of Task.sequence. Also contains a critical bug fix.
]]>BehaviorSubject
and ReplaySubject, making them release subscribers that stopped
the stream while connecting, allowing them to be garbage collected
faster. This is a very common use-case.
]]>Task’s implementation and introducing Coeval. See
Issue #141 for details.
]]>