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

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

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

Execute a blocking action on a Blocking thread pool; current task will be safely parked until the blocking task finishes *

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

Execute a blocking impure effect on a Blocking thread pool; current task will be safely parked until the blocking task finishes *

Execute a blocking impure effect on a Blocking thread pool; current task will be safely parked until the blocking task finishes

If canceled, the task _MAY_ be killed via java.lang.Thread#interrupt. There is no guarantee that this method may promptly, or ever, interrupt the enclosed task, and it may be legally implemented as an alias to syncBlocking

THIS IS USUALLY UNSAFE unless calling well-written libraries that specifically handle java.lang.InterruptedException

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.