object CancelableF
- Source
- CancelableF.scala
- Alphabetic
- By Inheritance
- CancelableF
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Type Members
Value Members
- def apply[F[_]](token: F[Unit])(implicit F: Sync[F]): F[CancelableF[F]]
Given a token that does not guarantee idempotency, wraps it in a CancelableF value that guarantees the given token will execute only once.
- def cancelAll[F[_]](seq: CancelableF[F]*)(implicit F: Sync[F]): CancelToken[F]
Given a collection of cancelables, creates a token that on evaluation will cancel them all.
Given a collection of cancelables, creates a token that on evaluation will cancel them all.
This function collects non-fatal exceptions and throws them all at the end as a composite, in a platform specific way:
- for the JVM "Suppressed Exceptions" are used
- for JS they are wrapped in a
CompositeException
- def cancelAllTokens[F[_]](seq: CancelToken[F]*)(implicit F: Sync[F]): CancelToken[F]
Given a collection of cancel tokens, creates a token that on evaluation will cancel them all.
Given a collection of cancel tokens, creates a token that on evaluation will cancel them all.
This function collects non-fatal exceptions and throws them all at the end as a composite, in a platform specific way:
- for the JVM "Suppressed Exceptions" are used
- for JS they are wrapped in a
CompositeException
- def collection[F[_]](refs: CancelableF[F]*)(implicit F: Sync[F]): CancelableF[F]
Builds a CancelableF reference from a sequence, cancelling everything when
cancelgets evaluated. - def empty[F[_]](implicit F: Applicative[F]): CancelableF[F]
Returns a dummy CancelableF that doesn't do anything.
- def unsafeApply[F[_]](token: F[Unit])(implicit F: Sync[F]): CancelableF[F]
Unsafe version of apply.
Unsafe version of apply.
This function is unsafe because creating the returned BooleanCancelableF allocates internal shared mutable state, thus breaking referential transparency, which can catch users by surprise.
- Annotations
- @UnsafeBecauseImpure()
- def wrap[F[_]](token: CancelToken[F]): CancelableF[F]
Wraps a cancellation token into a CancelableF instance.
Wraps a cancellation token into a CancelableF instance.
Compared with apply the returned value does not guarantee idempotency.
N.B. the returned result is as pure as the wrapped result. Since we aren't allocating mutable internal state for creating this value, we don't need to return the value in
F[_], like in apply.
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.