abstract class Consumer[-In, +R] extends (Observable[In]) => Task[R] with Serializable
The Consumer is a specification of how to consume an observable.
It is a factory of subscribers with a completion callback attached, being effectively a way to transform observables into tasks for less error prone consuming of streams.
- Self Type
- Consumer[In, R]
- Source
- Consumer.scala
- Alphabetic
- By Inheritance
- Consumer
- Serializable
- Function1
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Instance Constructors
- new Consumer()
Abstract Value Members
- abstract def createSubscriber(cb: Callback[Throwable, R], s: Scheduler): (Subscriber[In], AssignableCancelable)
Builds a new Subscriber that can be subscribed to an Observable for consuming a stream, with a callback that should eventually get called with a materialized result.
Builds a new Subscriber that can be subscribed to an Observable for consuming a stream, with a callback that should eventually get called with a materialized result.
Notes:
- calling the callback must obey the contract for the Callback type
- the given callback should always get called, unless the upstream gets canceled
- the given callback can be called when the subscriber is finished processing, but not necessarily
- if the given callback isn't called after the subscriber is
done processing, then the
Taskreturned by apply loses the ability to cancel the stream, as thatTaskwill complete before the stream is finished
Concrete Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##: Int
- Definition Classes
- AnyRef → Any
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- def andThen[A](g: (Task[R]) => A): (Observable[In]) => A
- Definition Classes
- Function1
- Annotations
- @unspecialized()
- final def apply(source: Observable[In]): Task[R]
Given a source Observable, convert it into a Task by piggybacking on createSubscriber.
Given a source Observable, convert it into a Task by piggybacking on createSubscriber.
- Definition Classes
- Consumer → Function1
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native() @HotSpotIntrinsicCandidate()
- def compose[A](g: (A) => Observable[In]): (A) => Task[R]
- Definition Classes
- Function1
- Annotations
- @unspecialized()
- final def contramap[In2](f: (In2) => In): Consumer[In2, R]
Given a contravariant mapping function, transform the source consumer by transforming the input.
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- final def map[R2](f: (R) => R2): Consumer[In, R2]
Given a mapping function, when consuming a stream, applies the mapping function to the final result, thus modifying the output of the source consumer.
Given a mapping function, when consuming a stream, applies the mapping function to the final result, thus modifying the output of the source consumer.
Note that for applying the mapping function an asynchronous boundary is forced, otherwise it could trigger a stack overflow exception. For more efficient mapping of the result, it's probably better to
mapthe resultingTaskon Observable.consumeWith.- See also
mapTask for a variant that can map the output to a
Taskthat can be processed asynchronously.
- final def mapEval[F[_], R2](f: (R) => F[R2])(implicit F: TaskLike[F]): Consumer[In, R2]
Given a mapping function, when consuming a stream, applies the mapping function to the final result, thus modifying the output of the source consumer.
Given a mapping function, when consuming a stream, applies the mapping function to the final result, thus modifying the output of the source consumer.
The mapping function returns results using a generic
F[_]data type that must implement thecats.effect.Effecttype class. Examples of such classes arecats.effect.IOand monix.eval.Task, thus being able to do asynchronous processing.See mapTask for the version that's specialized on
Task. - final def mapTask[R2](f: (R) => Task[R2]): Consumer[In, R2]
Given a mapping function, when consuming a stream, applies the mapping function to the final result, thus modifying the output of the source consumer.
Given a mapping function, when consuming a stream, applies the mapping function to the final result, thus modifying the output of the source consumer.
The mapping function returns a Task that can be used to process results asynchronously.
Note that for applying the mapping function an asynchronous boundary is forced, otherwise it could trigger a stack overflow exception. For more efficient mapping of the result, it's probably better to
mapthe resultingTaskon Observable.consumeWith.See mapEval for the version that can work with any data type that implements
cats.effect.Effect. - final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def toString(): String
- Definition Classes
- Function1 → AnyRef → Any
- final def transformInput[In2](f: (Observable[In2]) => Observable[In]): Consumer[In2, R]
Given a function that transforms the input stream, uses it to transform the source consumer into one that accepts events of the type specified by the transformation function.
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
This is the API documentation for the Monix library.
Package Overview
monix.execution exposes lower level primitives for dealing with asynchronous execution:
Atomictypes, as alternative tojava.util.concurrent.atomicmonix.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
Observablepattern:Observableimplementationsmonix.tail exposes Iterant for purely functional pull based streaming:
BatchandBatchCursor, the alternatives to Scala'sIterableandIteratorrespectively 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.