package observables
- Alphabetic
- Public
- All
Type Members
- final class CachedObservable[+A] extends Observable[A]
A
CachedObservable
is an observable that wraps a regular Observable, initiating the connection on the firstsubscribe()
and then staying connected for as long as the source is emitting.A
CachedObservable
is an observable that wraps a regular Observable, initiating the connection on the firstsubscribe()
and then staying connected for as long as the source is emitting.NOTE: this is NOT a ConnectableObservable and being a hot data-source you've got no way to cancel the source.
- abstract class ChainedObservable[+A] extends Observable[A]
A
StackedObservable
is an Observable type used in operators that end up being used in loops and that need to be memory safe (e.g.A
StackedObservable
is an Observable type used in operators that end up being used in loops and that need to be memory safe (e.g.++
,suspend
).This is achieved with the same trick used in the monix.eval.Task implementation. The problem with recursive operators is that they are leaving work behind due to the need to return a
Cancelable
and thus leak memory.As a general rule of thumb, not all observables can be chain-able. For example if the received
Subscriber
gets wrapped in another subscriber instance, then chaining will not be safe unless theonNext
,onError
andonComplete
events introduce asynchronous boundaries as well, which is overkill. - abstract class ConnectableObservable[+A] extends Observable[A]
Represents an Observable that waits for the call to
connect()
before starting to emit elements to its subscriber(s).Represents an Observable that waits for the call to
connect()
before starting to emit elements to its subscriber(s).Represents a hot observable (an observable that shares its data-source to multiple subscribers).
- Annotations
- @UnsafeBecauseImpure()
- abstract class GroupedObservable[K, +V] extends Observable[V]
A
GroupedObservable
is an observable type generated byObservable.groupBy
.A
GroupedObservable
is an observable type generated byObservable.groupBy
. It has the following properties:- comes accompanied with a
key
property after which the grouping was made- supports a single subscriber, throwing
IllegalStateException
if you attempt multiple subscriptions - final class RefCountObservable[+A] extends Observable[A]
A
RefCountObservable
is an observable that wraps a ConnectableObservable, initiating the connection on the firstsubscribe()
and then staying connected as long as there is at least one subscription active.
Value Members
- object CachedObservable extends Serializable
- object ChainedObservable extends Serializable
- object CombineObservable extends Newtype1[Observable]
Newtype encoding for an Observable datatype that has a cats.Apply instance which uses Observable.combineLatest to combine elements needed for implementing cats.NonEmptyParallel
- object ConnectableObservable extends Serializable
- object GroupedObservable extends Serializable
- object RefCountObservable extends Serializable
This is the API documentation for the Monix library.
Package Overview
monix.execution exposes lower level primitives for dealing with asynchronous execution:
Atomic
types, as alternative tojava.util.concurrent.atomic
monix.catnap exposes pure abstractions built on top of the Cats-Effect type classes:
monix.eval is for dealing with evaluation of results, thus exposing Task and Coeval.
monix.reactive exposes the
Observable
pattern:Observable
implementationsmonix.tail exposes Iterant for purely functional pull based streaming:
Batch
andBatchCursor
, the alternatives to Scala'sIterable
andIterator
respectively that we are using within Iterant's encodingYou can control evaluation with type you choose - be it Task, Coeval, cats.effect.IO or your own as long as you provide correct cats-effect or cats typeclass instance.