Panic2Instance

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.

flatSequence with error accumulation

flatTraverse with error accumulation

For lazy monads: alias for IO2#syncThrowable. For strict monads, shorthand for F.fromTry(Try(effect))

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.forUnknownError))

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.forUnknownError)) *>
   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

sequence with error accumulation

sequence with error accumulation

sequence_ with error accumulation

traverse with error accumulation

traverse with error accumulation

traverse_ with error accumulation

Designate the effect uninterruptible, with the 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(())