IO

abstract def tag: Int

An integer that identifies the term in the IO sum type to which this instance belongs (e.g.

final def !=(arg0: Any): Boolean

final def ##(): Int

final def *>[E1 >: E, B](io: ⇒ IO[E1, B]): IO[E1, B]

A variant of flatMap that ignores the value produced by this action.

final def <*[E1 >: E, B](io: ⇒ IO[E1, B]): IO[E1, A]

Sequences the specified action after this action, but ignores the value produced by the action.

final def <>[E2, A1 >: A](that: ⇒ IO[E2, A1]): IO[E2, A1]

Alias for orElse.

final def <||>[E2, B](that: ⇒ IO[E2, B]): IO[E2, Either[A, B]]

Alias for orElseEither.

final def ==(arg0: Any): Boolean

final def as[A1 >: A]: IO[E, A1]

Widens the action type to any supertype.

final def asInstanceOf[T0]: T0

final def attempt: IO[Nothing, Either[E, A]]

Executes this action, capturing both failure and success and returning the result in an Either.

final def bimap[E2, B](f: (E) ⇒ E2, g: (A) ⇒ B): IO[E2, B]

Maps an IO[E, A] into an IO[E2, B] by applying the specified E => E2 and A => B functions to the output of this action.

final def bracket[E1 >: E, B](release: (A) ⇒ IO[Nothing, _])(use: (A) ⇒ IO[E1, B]): IO[E1, B]

When this action represents acquisition of a resource (for example, opening a file, launching a thread, etc.), bracket can be used to ensure the acquisition is not interrupted and the resource is released.

openFile("data.json").bracket(closeFile) { file =>
  for {
    header <- readHeader(file)
    ...
  } yield result
}

final def bracket0[E1 >: E, B](release: (A, Exit[E1, B]) ⇒ IO[Nothing, _])(use: (A) ⇒ IO[E1, B]): IO[E1, B]

A more powerful version of bracket that provides information on whether or not use succeeded to the release action.

final def bracketOnError[E1 >: E, B](release: (A) ⇒ IO[Nothing, _])(use: (A) ⇒ IO[E1, B]): IO[E1, B]

Executes the release action only if there was an error.

final def bracket_[E1 >: E, B](release: IO[Nothing, _])(use: IO[E1, B]): IO[E1, B]

A less powerful variant of bracket where the value produced by this action is not needed.

final def catchAll[E2, A1 >: A](h: (E) ⇒ IO[E2, A1]): IO[E2, A1]

Recovers from all errors.

openFile("config.json").catchAll(_ => IO.succeed(defaultConfig))

final def catchSome[E1 >: E, A1 >: A](pf: PartialFunction[E, IO[E1, A1]]): IO[E1, A1]

Recovers from some or all of the error cases.

openFile("data.json").catchSome {
  case FileNotFoundException(_) => openFile("backup.json")
}

def clone(): AnyRef

final def const[B](b: ⇒ B): IO[E, B]

Maps this action to the specified constant while preserving the effects of this action.

final def delay(duration: Duration): IO[E, A]

Delays this action by the specified amount of time.

final def ensuring(finalizer: IO[Nothing, _]): IO[E, A]

Executes the specified finalizer, whether this action succeeds, fails, or is interrupted.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def flatMap[E1 >: E, B](f0: (A) ⇒ IO[E1, B]): IO[E1, B]

Creates a composite action that represents this action followed by another one that may depend on the value produced by this one.

val parsed = readFile("foo.txt").flatMap(file => parseFile(file))

final def flatMapError[E2](f: (E) ⇒ IO[Nothing, E2]): IO[E2, A]

Creates a composite action that represents this action followed by another one that may depend on the error produced by this one.

val parsed = readFile("foo.txt").flatMapError(error => logErrorToFile(error))

final def flip: IO[A, E]

Swaps the error/value around, making it easier to handle errors.

final def flipWith[A1, E1](f: (IO[A, E]) ⇒ IO[A1, E1]): IO[E1, A1]

Swaps the error/value parameters, applies the function f and flips the parameters back

final def forever: IO[E, Nothing]

Repeats this action forever (until the first error).

final def fork: IO[Nothing, Fiber[E, A]]

Forks this action into its own separate fiber, returning immediately without the value produced by this action.

for {
  fiber <- subtask.fork
  // Do stuff...
  a <- fiber.join
} yield a

final def forkOn(ec: ExecutionContext): IO[E, Fiber[E, A]]

Forks an action that will be executed on the specified ExecutionContext.

final def forkWith(handler: (Cause[Any]) ⇒ IO[Nothing, _]): IO[Nothing, Fiber[E, A]]

A more powerful version of fork that allows specifying a handler to be invoked on any exceptions that are not handled by the forked fiber.

final def get[E1 >: E, B](implicit ev1: =:=[E1, Nothing], ev2: <:<[A, Option[B]]): IO[Unit, B]

Unwraps the optional success of this effect, but can fail with unit value.

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def leftMap[E2](f: (E) ⇒ E2): IO[E2, A]

Maps over the error type.

final def lock(executor: Executor): IO[E, A]

Locks the execution of this action to the specified executor.

final def managed(release: (A) ⇒ IO[Nothing, _]): Managed[E, A]

final def map[B](f: (A) ⇒ B): IO[E, B]

Maps an IO[E, A] into an IO[E, B] by applying the specified A => B function to the output of this action.

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final def on(ec: ExecutionContext): IO[E, A]

Executes the action on the specified ExecutionContext and then shifts back to the default one.

final def onError(cleanup: (Cause[E]) ⇒ IO[Nothing, _]): IO[E, A]

Runs the specified action if this action fails, providing the error to the action if it exists.

final def onInterrupt(cleanup: IO[Nothing, _]): IO[E, A]

Runs the specified action if this action is interrupted.

final def onTermination(cleanup: (Cause[Nothing]) ⇒ IO[Nothing, _]): IO[E, A]

Runs the specified action if this action is terminated, either because of a defect or because of interruption.

final def option: IO[Nothing, Option[A]]

Executes this action, skipping the error but returning optionally the success.

final def orDie[E1 >: E](implicit ev: =:=[E1, Throwable]): IO[Nothing, A]

Translates the checked error (if present) into termination.

final def orElse[E2, A1 >: A](that: ⇒ IO[E2, A1]): IO[E2, A1]

Executes this action and returns its value, if it succeeds, but otherwise executes the specified action.

final def orElseEither[E2, B](that: ⇒ IO[E2, B]): IO[E2, Either[A, B]]

Executes this action and returns its value, if it succeeds, but otherwise executes the specified action.

final def peek[E1 >: E, B](f: (A) ⇒ IO[E1, B]): IO[E1, A]

Calls the provided function with the result of this action, and sequences the resulting action after this action, but ignores the value produced by the action.

readFile("data.json").peek(putStrLn)

final def race[E1 >: E, A1 >: A](that: IO[E1, A1]): IO[E1, A1]

Races this action with the specified action, returning the first result to produce an A, whichever it is.

final def raceAttempt[E1 >: E, A1 >: A](that: IO[E1, A1]): IO[E1, A1]

Races this action with the specified action, returning the first result to *finish*, whether it is by producing a value or by failing with an error.

final def raceEither[E1 >: E, B](that: IO[E1, B]): IO[E1, Either[A, B]]

Races this action with the specified action, returning the first result to produce a value, whichever it is.

final def raceWith[E1, E2, B, C](that: IO[E1, B])(leftDone: (Exit[E, A], Fiber[E1, B]) ⇒ IO[E2, C], rightDone: (Exit[E1, B], Fiber[E, A]) ⇒ IO[E2, C]): IO[E2, C]

Races this action with the specified action, invoking the specified finisher as soon as one value or the other has been computed.

final def redeem[E2, B](err: (E) ⇒ IO[E2, B], succ: (A) ⇒ IO[E2, B]): IO[E2, B]

Recovers from errors by accepting one action to execute for the case of an error, and one action to execute for the case of success.

final def redeem0[E2, B](err: (Cause[E]) ⇒ IO[E2, B], succ: (A) ⇒ IO[E2, B]): IO[E2, B]

A more powerful version of redeem that allows recovering from any kind of failure except interruptions.

final def redeemPure[B](err: (E) ⇒ B, succ: (A) ⇒ B): IO[Nothing, B]

Less powerful version of redeem which always returns a successful IO[Nothing, B] after applying one of the given mapping functions depending on the result of this IO

final def repeat[B](schedule: Schedule[A, B], clock: Clock = Clock.Live): IO[E, B]

Repeats this action with the specified schedule until the schedule completes, or until the first failure.

final def repeatOrElse[E2, B](schedule: Schedule[A, B], orElse: (E, Option[B]) ⇒ IO[E2, B], clock: Clock = Clock.Live): IO[E2, B]

Repeats this action with the specified schedule until the schedule completes, or until the first failure.

final def repeatOrElse0[B, E2, C](schedule: Schedule[A, B], orElse: (E, Option[B]) ⇒ IO[E2, C], clock: Clock = Clock.Live): IO[E2, Either[C, B]]

Repeats this action with the specified schedule until the schedule completes, or until the first failure.

final def retry[E1 >: E, S](policy: Schedule[E1, S], clock: Clock = Clock.Live): IO[E1, A]

Retries with the specified retry policy.

final def retryOrElse[A2 >: A, E1 >: E, S, E2](policy: Schedule[E1, S], orElse: (E1, S) ⇒ IO[E2, A2], clock: Clock = Clock.Live): IO[E2, A2]

Retries with the specified schedule, until it fails, and then both the value produced by the schedule together with the last error are passed to the recovery function.

final def retryOrElse0[E1 >: E, S, E2, B](policy: Schedule[E1, S], orElse: (E1, S) ⇒ IO[E2, B], clock: Clock = Clock.Live): IO[E2, Either[B, A]]

Retries with the specified schedule, until it fails, and then both the value produced by the schedule together with the last error are passed to the recovery function.

final def run: IO[Nothing, Exit[E, A]]

Runs this action in a new fiber, resuming when the fiber terminates.

final def sandbox: IO[Cause[E], A]

Runs this action in a new fiber, resuming when the fiber terminates.

case class DomainError()

val veryBadIO: IO[DomainError, Unit] =
  IO.sync(5 / 0) *> IO.fail(DomainError())

val caught: IO[Nothing, Unit] =
  veryBadIO.sandboxed.catchAll {
    case Left((_: ArithmeticException) :: Nil) =>
      // Caught defect: divided by zero!
      IO.succeed(0)
    case Left(ts) =>
      // Caught unknown defects, shouldn't recover!
      IO.terminate0(ts)
    case Right(e) =>
      // Caught error: DomainError!
     IO.succeed(0)
  }

final def sandboxWith[E2, B](f: (IO[Cause[E], A]) ⇒ IO[Cause[E2], B]): IO[E2, B]

Companion helper to sandboxed.

case class DomainError()

val veryBadIO: IO[DomainError, Unit] =
  IO.sync(5 / 0) *> IO.fail(DomainError())

val caught: IO[DomainError, Unit] =
  veryBadIO.sandboxWith(_.catchSome {
    case Left((_: ArithmeticException) :: Nil) =>
      // Caught defect: divided by zero!
      IO.succeed(0)
  })

final def summarized[E1 >: E, B, C](f: (B, B) ⇒ C)(summary: IO[E1, B]): IO[E1, (C, A)]

Summarizes a action by computing some value before and after execution, and then combining the values to produce a summary, together with the result of execution.

final def supervise: IO[E, A]

Supervises this action, which ensures that any fibers that are forked by the action are interrupted when this action completes.

final def superviseWith(supervisor: (Iterable[Fiber[_, _]]) ⇒ IO[Nothing, _]): IO[E, A]

Supervises this action, which ensures that any fibers that are forked by the action are handled by the provided supervisor.

final def synchronized[T0](arg0: ⇒ T0): T0

final def timed: IO[E, (Duration, A)]

Returns a new action that executes this one and times the execution.

final def timed0[E1 >: E](nanoTime: IO[E1, Long]): IO[E1, (Duration, A)]

A more powerful variation of timed that allows specifying the clock.

final def timeout(d: Duration): IO[E, Option[A]]

Times out an action by the specified duration.

final def timeout0[B](z: B)(f: (A) ⇒ B)(duration: Duration): IO[E, B]

Times out this action by the specified duration.

IO.point(1).timeout0(Option.empty[Int])(Some(_))(1.second)

final def timeoutFail[E1 >: E](e: E1)(d: Duration): IO[E1, A]

Flattens a nested action with a specified duration.

final def to[E1 >: E, A1 >: A](p: Promise[E1, A1]): IO[Nothing, Boolean]

Keep or break a promise based on the result of this action.

def toString(): String

final def uninterruptible: IO[E, A]

Performs this action non-interruptibly.

final def unyielding: IO[E, A]

Marks this action as unyielding to the runtime system for better scheduling.

final def void: IO[E, Unit]

Maps this action to one producing unit, but preserving the effects of this action.

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

final def zip[E1 >: E, B](that: IO[E1, B]): IO[E1, (A, B)]

Sequentially zips this effect with the specified effect, combining the results into a tuple.

final def zipPar[E1 >: E, B](that: IO[E1, B]): IO[E1, (A, B)]

Executes both this action and the specified action in parallel, returning a tuple of their results.

final def zipWith[E1 >: E, B, C](that: IO[E1, B])(f: (A, B) ⇒ C): IO[E1, C]

Sequentially zips this effect with the specified effect using the specified combiner function.

final def zipWithPar[E1 >: E, B, C](that: IO[E1, B])(f: (A, B) ⇒ C): IO[E1, C]

Executes both this action and the specified action in parallel, combining their results using given function f.

final def fold[B](err: (E) ⇒ B, succ: (A) ⇒ B): IO[Nothing, B]

Alias for redeemPure

final def foldM[E2, B](err: (E) ⇒ IO[E2, B], succ: (A) ⇒ IO[E2, B]): IO[E2, B]

Alias for redeem