execute two operations in order, return result of second operation

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

Construct an effect from an asynchronous callback-based API.

The callback provided to register must be invoked exactly once with either a success value wrapped in Right or an error wrapped in Left.

Example:

def readFile[F[+_, +_]: WeakAsync2](path: String): F[Throwable, String] = {
  F.async { cb =>
    asyncFileReader.read(path)(
      onSuccess = content => cb(Right(content)),
      onError = err => cb(Left(err))
    )
  }
}

Same as async, but registration action can use F capabilities. Registration action itself is uninterruptible, but the produced effect is interruptible.

Just as in async, registers async callback impurely, but also returns an F effect that will be executed to interrupt the async action if the current fiber is interrupted

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

parTraverseN with maxConcurrent set to the number of cores, or 2 when on single-core processor

Race two actions, the winner is the first action to TERMINATE, whether by success or failure

Race two actions, the winner is the first action to TERMINATE, whether by success or failure

Unlike race, the loser is not interrupted after the winner has terminated - whether by success or failure.

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

Capture an _exception-safe_ side-effect that returns another effect

Capture a side-effectful block of code that can throw exceptions and returns another effect

Capture an _exception-safe_ side-effect such as memory mutation or randomness

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

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(())

Returns an effect that executes both effects, in parallel, combining their results into a tuple. If either side fails, then the other side will be interrupted.

Returns an effect that executes both effects, in parallel, the left effect result is returned. If either side fails, then the other side will be interrupted.

Returns an effect that executes both effects, in parallel, the right effect result is returned. If either side fails, then the other side will be interrupted.

Returns an effect that executes both effects, in parallel, combining their results with the specified f function. If either side fails, then the other side will be interrupted.