implicit final class AckExtensions[Self <: Future[Ack]] extends AnyVal
Helpers for dealing with synchronous Future[Ack] results,
powered by macros.
- Source
- Ack.scala
- Alphabetic
- By Inheritance
- AckExtensions
- AnyVal
- Any
- Hide All
- Show All
- Public
- All
Instance Constructors
- new AckExtensions(source: Self)
Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- Any
- final def ##(): Int
- Definition Classes
- Any
- final def ==(arg0: Any): Boolean
- Definition Classes
- Any
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def getClass(): Class[_ <: AnyVal]
- Definition Classes
- AnyVal → Any
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def isSynchronous: Boolean
Returns
trueif self is a direct reference toContinueorStop,falseotherwise. - val source: Self
- def syncFlatMap(f: (Ack) => Future[Ack])(implicit r: UncaughtExceptionReporter): Future[Ack]
Given a mapping function, returns a new future reference that is the result of a
flatMapoperation applied to the source.Given a mapping function, returns a new future reference that is the result of a
flatMapoperation applied to the source.Execution will happen without any hard asynchronous boundaries — in case the
sourceis anAckvalue (e.g.ContinueorStop) then execution will be immediate, otherwise execution will be trampolined (being execute on Monix'sTrampolineExecutionContext).WARN: in case the source is an
Ackvalue (e.g.ContinueorStop) and the execution being immediate, with no async boundaries, this means that application of this function is *stack unsafe*!Use with great care as an optimization. Don't use it in tail-recursive loops!
- f
is the mapping function used to transform the source
- r
is an exception reporter used for reporting errors triggered by
f
- def syncMap(f: (Ack) => Ack)(implicit r: UncaughtExceptionReporter): Future[Ack]
Given a mapping function, returns a new future reference that is the result of a
mapoperation applied to the source.Given a mapping function, returns a new future reference that is the result of a
mapoperation applied to the source.Execution will happen without any hard asynchronous boundaries — in case the
sourceis anAckvalue (e.g.ContinueorStop) then execution will be immediate, otherwise execution will be trampolined (being execute on Monix'sTrampolineExecutionContext).WARN: in case the source is an
Ackvalue (e.g.ContinueorStop) and the execution being immediate, with no async boundaries, this means that application of this function is *stack unsafe*!Use with great care as an optimization. Don't use it in tail-recursive loops!
- f
is the mapping function used to transform the source
- r
is an exception reporter used for reporting errors triggered by
f
- def syncOnComplete(f: (Try[Ack]) => Unit)(implicit r: UncaughtExceptionReporter): Unit
When the source future is completed, either through an exception, or a value, apply the provided function.
When the source future is completed, either through an exception, or a value, apply the provided function.
Execution will happen without any hard asynchronous boundaries — in case the
sourceis anAckvalue (e.g.ContinueorStop) then execution will be immediate, otherwise execution will be trampolined (being execute on Monix'sTrampolineExecutionContext).WARN: in case the source is an
Ackvalue (e.g.ContinueorStop) and the execution being immediate, with no async boundaries, this means that application of this function is *stack unsafe*!Use with great care as an optimization. Don't use it in tail-recursive loops!
- r
is a reporter for exceptions thrown by
f
- def syncOnContinue(thunk: => Unit)(implicit r: UncaughtExceptionReporter): Self
Executes the given
callbackonContinue.Executes the given
callbackonContinue.Execution will happen without any hard asynchronous boundaries — in case the
sourceis anAckvalue (e.g.ContinueorStop) then execution will be immediate, otherwise execution will be trampolined (being execute on Monix'sTrampolineExecutionContext).WARN: in case the source is an
Ackvalue (e.g.ContinueorStop) and the execution being immediate, with no async boundaries, this means that application of this function is *stack unsafe*!Use with great care as an optimization. Don't use it in tail-recursive loops!
- r
is an exception reporter used for reporting errors triggered by
thunk
- def syncOnContinueFollow[A](p: Promise[A], value: A): Self
If the source completes with a
Stop, then complete the given promise with a value. - def syncOnStopFollow[A](p: Promise[A], value: A): Self
If the source completes with a
Stop, then complete the given promise with a value. - def syncOnStopOrFailure(cb: (Option[Throwable]) => Unit)(implicit r: UncaughtExceptionReporter): Self
Executes the given
callbackonStopor onFailure(ex).Executes the given
callbackonStopor onFailure(ex).Execution will happen without any hard asynchronous boundaries — in case the
sourceis anAckvalue (e.g.ContinueorStop) then execution will be immediate, otherwise execution will be trampolined (being execute on Monix'sTrampolineExecutionContext).WARN: in case the source is an
Ackvalue (e.g.ContinueorStop) and the execution being immediate, with no async boundaries, this means that application of this function is *stack unsafe*!Use with great care as an optimization. Don't use it in tail-recursive loops!
- r
is an exception reporter used for reporting errors triggered by
cb
- def syncTryFlatten(implicit r: UncaughtExceptionReporter): Future[Ack]
Tries converting an already completed
Future[Ack]into a direct reference toContinueorStop.Tries converting an already completed
Future[Ack]into a direct reference toContinueorStop. Useful for collapsing async pipelines. - def toString(): String
- Definition Classes
- Any

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.