IO3

Capture an exception-safe side-effect such as memory mutation or randomness

Capture a side-effectful block of code that can throw exceptions

execute two operations in order, return result of second operation

execute two operations in order, same as *>, but return result of first operation

Like bracketCase, but acquire can contain marked interruptible regions as in uninterruptibleExcept

Run release action only on a failure – any failure, INCLUDING interruption. Do not run release action if use finished successfully.

Extracts the optional value or fails with the errorOnNone error

Extracts the optional value, or executes the fallbackOnNone effect

Extracts the optional value, or returns the given valueOnNone value

Run cleanup on both success and failure, if the failure IS NOT an interruption.

Run cleanup only on a failure – any failure, INCLUDING interruption. Do not run cleanup if use finished successfully.

Run cleanup only on interruption. Do not run cleanup if use finished successfully.

Execute an action repeatedly until its result satisfies the given predicate and return that result, discarding all others.

Apply an effectful function iteratively until its result satisfies the given predicate and return that result.

Execute an action repeatedly until its result fails to satisfy the given predicate and return that result, discarding all others.

Apply an effectful function iteratively until its result fails to satisfy the given predicate and return that result.

map errors from two operations into a new error if both fail

execute two operations in order, map their results

execute second operation only if the first one fails

Retries this effect until its error satisfies the specified predicate.

Retries this effect until its error satisfies the specified effectful predicate.

Retries this effect while its error satisfies the specified predicate.

Retries this effect while its error satisfies the specified effectful predicate.

Signal interruption to this fiber.

This is NOT the same as

 F.halt(Exit.Interrupted(Trace.empty))

The code above exits with Exit.Interrupted failure unconditionally, whereas sendInterruptToSelf will not exit when in an uninterruptible region. Example:

 F.uninterruptible {
   F.halt(Exit.Interrupted(Trace.empty)) *>
   F.sync(println("Hello!")) // interrupted above. Hello _not_ printed
 }

But with sendInterruptToSelf:

 F.uninterruptible {
   F.sendInterruptToSelf *>
   F.sync(println("Hello!")) // Hello IS printed.
 } *> F.sync(println("Impossible")) // interrupted immediately after `uninterruptible` block ends. Impossible _not_ printed

Designate the effect uninterruptible, with exception of regions in it that are specifically marked to restore previous interruptibility status using the provided RestoreInterruption function

for-comprehensions sugar:

 for {
   (1, 2) <- F.pure((2, 1))
 } yield ()

Use widenError to for pattern matching with non-Throwable errors:

 val f = for {
   (1, 2) <- F.pure((2, 1)).widenError[Option[Unit]]
 } yield ()
 // f: F[Option[Unit], Unit] = F.fail(Some(())