An effect that requests self-cancelation on the current fiber.

canceled has a return type of F[Unit] instead of F[Nothing] due to execution continuing in a masked region. In the following example, the fiber requests self-cancelation in a masked region, so cancelation is suppressed until the fiber is completely unmasked. fa will run but fb will not. If canceled had a return type of F[Nothing], then it would not be possible to continue execution to fa (there would be no Nothing value to pass to the flatMap).

F.uncancelable { _ =>
  F.canceled *> fa
} *> fb

Analogous to productR, but suppresses short-circuiting behavior except for cancelation.

Monotonic time subject to the law that (monotonic, monotonic).mapN(_ <= _)

Analogous to java.lang.System.nanoTime.

Registers a finalizer that is invoked if cancelation is observed during the evaluation of fa. If the evaluation of fa completes without encountering a cancelation, the finalizer is unregistered before proceeding.

Note that if fa is uncancelable (e.g. created via uncancelable) then fin won't be fired.

F.onCancel(F.uncancelable(_ => F.canceled), fin) <-> F.unit

During finalization, all actively registered finalizers are run exactly once. The order by which finalizers are run is dictated by nesting: innermost finalizers are run before outermost finalizers. For example, in the following program, the finalizer f1 is run before the finalizer f2:

F.onCancel(F.onCancel(F.canceled, f1), f2)

If a finalizer throws an error during evaluation, the error is suppressed, and implementations may choose to report it via a side channel. Finalizers are always uncancelable, so cannot otherwise be interrupted.

A representation of the current system time

Analogous to java.lang.System.currentTimeMillis.

Indicates the default "root scope" semantics of the F in question. For types which do not implement auto-cancelation, this value may be set to CancelScope.Uncancelable, which behaves as if all values F[A] are wrapped in an implicit "outer" uncancelable which cannot be polled. Most IO-like types will define this to be Cancelable.

Masks cancelation on the current fiber. The argument to body of type Poll[F] is a natural transformation F ~> F that enables polling. Polling causes a fiber to unmask within a masked region so that cancelation can be observed again.

In the following example, cancelation can be observed only within fb and nowhere else:

F.uncancelable { poll =>
  fa *> poll(fb) *> fc
}

If a fiber is canceled while it is masked, the cancelation is suppressed for as long as the fiber remains masked. Whenever the fiber is completely unmasked again, the cancelation will be respected.

Masks can also be stacked or nested within each other. If multiple masks are active, all masks must be undone so that cancelation can be observed. In order to completely unmask within a multi-masked region the poll corresponding to each mask must be applied to the effect, outermost-first.

F.uncancelable { p1 =>
  F.uncancelable { p2 =>
    fa *> p2(p1(fb)) *> fc
  }
}

The following operations are no-ops:

1. Polling in the wrong order
2. Subsequent polls when applying the same poll more than once: poll(poll(fa)) is equivalent to poll(fa)
3. Applying a poll bound to one fiber within another fiber

Like Sync.delay but intended for thread blocking operations. blocking will shift the execution of the blocking operation to a separate threadpool to avoid blocking on the main execution context. See the thread-model documentation for more information on why this is necessary. Note that the created effect will be uncancelable; if you need cancelation then you should use Sync.interruptible or Sync.interruptibleMany.

Sync[F].blocking(scala.io.Source.fromFile("path").mkString)

A pattern for safely interacting with effectful lifecycles.

If acquire completes successfully, use is called. If use succeeds, fails, or is canceled, release is guaranteed to be called exactly once.

acquire is uncancelable. release is uncancelable. use is cancelable by default, but can be masked.

A pattern for safely interacting with effectful lifecycles.

If acquire completes successfully, use is called. If use succeeds, fails, or is canceled, release is guaranteed to be called exactly once.

acquire is uncancelable. release is uncancelable. use is cancelable by default, but can be masked.

A pattern for safely interacting with effectful lifecycles.

If acquire completes successfully, use is called. If use succeeds, fails, or is canceled, release is guaranteed to be called exactly once.

If use succeeds the returned value B is returned. If use returns an exception, the exception is returned.

acquire is uncancelable by default, but can be unmasked. release is uncancelable. use is cancelable by default, but can be masked.

Suspends the evaluation of an F[_] reference.

Equivalent to FlatMap.flatten for pure expressions, the purpose of this function is to suspend side effects in F[_].

The synchronous FFI - lifts any by-name parameter into the F[_] context.

Equivalent to Applicative.pure for pure expressions, the purpose of this function is to suspend side effects in F. Use Sync.delay if your side effect is not thread-blocking; otherwise you should use Sync.blocking (uncancelable) or Sync.interruptible (cancelable).

Specifies an effect that is always invoked after evaluation of fa completes, regardless of the outcome.

This function can be thought of as a combination of flatTap, onError, and onCancel.

Specifies an effect that is always invoked after evaluation of fa completes, but depends on the outcome.

This function can be thought of as a combination of flatTap, onError, and onCancel.

Like Sync.blocking but will attempt to abort the blocking operation using thread interrupts in the event of cancelation. The interrupt will be attempted only once.

Like Sync.blocking but will attempt to abort the blocking operation using thread interrupts in the event of cancelation. The interrupt will be attempted repeatedly until the blocking operation completes or exits.