Monix3.4.0 < Back

Packages

package root
This is the API documentation for the Monix library.
Package Overview
monix.execution exposes lower level primitives for dealing with asynchronous execution:
- monix.execution.atomic exposes the Atomic types, as alternative to java.util.concurrent.atomic
- monix.execution.cancelables contains several useful Cancelable implementations
- monix.execution.schedulers contains several useful Scheduler implementations
- monix.execution.rstreams contains helpers for dealing with the Reactive Streams specification
- monix.execution.misc provides miscellaneous primitives useful for dealing with concurrency
- monix.execution.exceptions groups some exceptions thrown by the implementation
monix.catnap exposes pure abstractions built on top of the Cats-Effect type classes:
- monix.catnap.cancelables exposes pure counterparts to the cancelable data types described in monix.execution.cancelables
monix.eval is for dealing with evaluation of results, thus exposing Task and Coeval.
monix.reactive exposes the Observable pattern:
- monix.reactive.observables groups reusable Observable implementations
- monix.reactive.observers groups reusable Observer implementations
- monix.reactive.subjects exposes Subject and ConcurrentSubject, which are implementations of hot observables that function both as input and output
monix.tail exposes Iterant for purely functional pull based streaming:
- monix.tail.batches describes Batch and BatchCursor, the alternatives to Scala's Iterable and Iterator respectively that we are using within Iterant's encoding
You 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.
Definition Classes
root
package monix
Definition Classes
root
package reactive
Definition Classes
monix
package compression
Definition Classes
reactive
package instances
Definition Classes
reactive
package observables
Definition Classes
reactive
package observers
Definition Classes
reactive
package subjects
Definition Classes
reactive
Consumer
MulticastStrategy
Notification
Observable
ObservableLike
Observer
OverflowStrategy
Pipe

Observer

Companion object Observer

trait Observer[-A] extends Serializable

The Observer from the Rx pattern is the trio of callbacks that get subscribed to an Observable for receiving events.

The events received must follow the Rx grammar, which is: onNext * (onComplete | onError)?

That means an Observer can receive zero or multiple events, the stream ending either in one or zero onComplete or onError (just one, not both), and after onComplete or onError, a well behaved Observable implementation shouldn't send any more onNext events.

Source: Observer.scala

Linear Supertypes

Serializable, Any

Known Subclasses

Sync, BufferedSubscriber, CacheUntilConnectSubscriber, ConnectableSubscriber, SafeSubscriber, Subscriber, Sync, AsyncSubject, BehaviorSubject, ConcurrentSubject, PublishSubject, PublishToOneSubject, ReplaySubject, Subject

Ordering

Alphabetic
By Inheritance

Inherited

Observer
Serializable
Any

Hide All
Show All

Visibility

Public
Protected

Abstract Value Members

abstract def getClass(): Class[_ <: AnyRef]
Definition Classes
Any
abstract def onComplete(): Unit
abstract def onError(ex: Throwable): Unit
abstract def onNext(elem: A): Future[Ack]