final def !=(arg0: Any): Boolean

Definition Classes: AnyRef → Any

final def ##(): Int

Definition Classes: AnyRef → Any

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

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

Definition Classes: IO

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.

Definition Classes: IO

final def <>[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.

Definition Classes: IO

final def <||>[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.

Definition Classes: IO

final def ==(arg0: Any): Boolean

Definition Classes: AnyRef → Any

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

Widens the action type to any supertype.

Widens the action type to any supertype. While map suffices for this purpose, this method is significantly faster for this purpose.

Definition Classes: IO

final def asInstanceOf[T0]: T0

Definition Classes: Any

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

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

Executes this action, capturing both failure and success and returning the result in an Either. This method is useful for recovering from IO actions that may fail.

The error parameter of the returned IO is Nothing, since it is guaranteed the IO action does not raise any errors.

Definition Classes: IO

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.

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. Repeated applications of bimap (io.bimap(f1, g1).bimap(f2, g2)...bimap(f10000, g20000)) are guaranteed stack safe to a depth of at least 10,000.

Definition Classes: IO

final def bracket[E1 >: E, B](release: (A) ⇒ IO[Nothing, Unit])(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.

The function does two things:

1. Ensures this action, which acquires the resource, will not be interrupted. Of course, acquisition may fail for internal reasons (an uncaught exception). 2. Ensures the release action will not be interrupted, and will be executed so long as this action successfully acquires the resource.

In between acquisition and release of the resource, the use action is executed.

If the release action fails, then the entire action will fail even if the use action succeeds. If this fail-fast behavior is not desired, errors produced by the release action can be caught and ignored.

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

Definition Classes: IO

final def bracket0[E1 >: E, B](release: (A, ExitResult[E1, B]) ⇒ IO[Nothing, Unit])(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.

Definition Classes: IO

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

Executes the release action only if there was an error.

Definition Classes: IO

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

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

Definition Classes: IO

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

Recovers from all errors.

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

Definition Classes: IO

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

Definition Classes: IO

def clone(): AnyRef

Attributes: protected[java.lang]
Definition Classes: AnyRef
Annotations: @native() @throws( ... )

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

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

Definition Classes: IO

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

Delays this action by the specified amount of time.

Definition Classes: IO

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

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

Executes the specified finalizer, whether this action succeeds, fails, or is interrupted. This method should not be used for cleaning up resources, because it's possible the fiber will be interrupted after acquisition but before the finalizer is added.

Definition Classes: IO

final def eq(arg0: AnyRef): Boolean

Definition Classes: AnyRef

def equals(arg0: Any): Boolean

Definition Classes: AnyRef → Any

def finalize(): Unit

Attributes: protected[java.lang]
Definition Classes: AnyRef
Annotations: @throws( classOf[java.lang.Throwable] )

val finalizer: IO[Nothing, 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))

Definition Classes: IO

final def forever: IO[E, Nothing]

Repeats this action forever (until the first error).

Repeats this action forever (until the first error). For more sophisticated schedules, see the repeat method.

Definition Classes: IO

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.

The Fiber[E, A] returned by this action can be used to interrupt the forked fiber with some exception, or to join the fiber to "await" its computed value.

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

Definition Classes: IO

final def fork0(handler: (List[Throwable]) ⇒ IO[Nothing, Unit]): 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.

Definition Classes: IO

final def getClass(): Class[_]

Definition Classes: AnyRef → Any
Annotations: @native()

def hashCode(): Int

Definition Classes: AnyRef → Any
Annotations: @native()

val io: IO[E, A]

final def isInstanceOf[T0]: Boolean

Definition Classes: Any

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

Maps over the error type.

Maps over the error type. This can be used to lift a "smaller" error into a "larger" error.

Definition Classes: IO

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

Definition Classes: IO

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.

Maps an IO[E, A] into an IO[E, B] by applying the specified A => B function to the output of this action. Repeated applications of map (io.map(f1).map(f2)...map(f10000)) are guaranteed stack safe to a depth of at least 10,000.

Definition Classes: IO

final def ne(arg0: AnyRef): Boolean

Definition Classes: AnyRef

final def notify(): Unit

Definition Classes: AnyRef
Annotations: @native()

final def notifyAll(): Unit

Definition Classes: AnyRef
Annotations: @native()

final def onError(cleanup: (ExitResult[E, Nothing]) ⇒ IO[Nothing, Unit]): IO[E, A]

Runs the cleanup action if this action errors, providing the error to the cleanup action if it exists.

Runs the cleanup action if this action errors, providing the error to the cleanup action if it exists. The cleanup action will not be interrupted.

Definition Classes: IO

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.

Definition Classes: IO

final def par[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.

Executes both this action and the specified action in parallel, returning a tuple of their results. If either individual action fails, then the returned action will fail.

Definition Classes: IO

final def parWith[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.

Executes both this action and the specified action in parallel, combining their results using given function f. If either individual action fails, then the returned action will fail.

TODO: Replace with optimized primitive.

Definition Classes: IO

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)

Definition Classes: IO

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.

Races this action with the specified action, returning the first result to produce an A, whichever it is. If neither action succeeds, then the action will fail with some error.

Definition Classes: IO

final def raceBoth[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.

Races this action with the specified action, returning the first result to produce a value, whichever it is. If neither action succeeds, then the action will fail with some error.

Definition Classes: IO

final def raceWith[E1 >: E, A1 >: A, B, C](that: IO[E1, B])(finishLeft: (A1, Fiber[E1, B]) ⇒ IO[E1, C], finishRight: (B, Fiber[E1, A1]) ⇒ IO[E1, C]): IO[E1, C]

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

Definition Classes: IO

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.

This method has better performance than attempt since no intermediate value is allocated and does not require subsequent calls to flatMap to define the next action.

The error parameter of the returned IO may be chosen arbitrarily, since it will depend on the IOs returned by the given continuations.

Definition Classes: IO

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

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

Definition Classes: IO

final def repeat[B](schedule: Schedule[A, B]): IO[E, B]

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

Definition Classes: IO

final def repeatOrElse[E1 >: E, B](schedule: Schedule[A, B], orElse: (E, B) ⇒ IO[E1, B]): IO[E1, B]

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

Repeats this action with the specified schedule until the schedule completes, or until the first failure. In the event of failure the progress to date, together with the error, will be passed to the specified handler.

Definition Classes: IO

final def repeatOrElse0[E1 >: E, B, C](schedule: Schedule[A, B], orElse: (E, B) ⇒ IO[E1, C]): IO[E1, Either[C, B]]

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

Repeats this action with the specified schedule until the schedule completes, or until the first failure. In the event of failure the progress to date, together with the error, will be passed to the specified handler.

Definition Classes: IO

final def retry[E1 >: E, S](policy: Schedule[E1, S]): IO[E1, A]

Retries with the specified retry policy.

Definition Classes: IO

final def retryOrElse[A2 >: A, E1 >: E, S, E2](policy: Schedule[E1, S], orElse: (E1, S) ⇒ IO[E2, A2]): 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.

Definition Classes: IO

final def retryOrElse0[E1 >: E, S, E2, B](policy: Schedule[E1, S], orElse: (E1, S) ⇒ IO[E2, B]): 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.

Definition Classes: IO

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

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

Definition Classes: IO

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

Companion helper to sandboxed.

Has a performance penalty due to forking a new fiber.

Allows recovery, and partial recovery, from errors and defects alike, as in:

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.now(0)
  })

Using sandboxWith with catchSome is better than using io.sandboxed.catchAll with a partial match, because in the latter, if the match fails, the original defects will be lost and replaced by a MatchError

Definition Classes: IO

final def sandboxed: IO[Either[List[Throwable], E], A]

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

If the fiber fails with an error it will be captured in Right side of the error Either If the fiber terminates because of defect, list of defects will be captured in the Left side of the Either

Allows recovery from errors and defects alike, as in:

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.now(0)
    case Left(ts) =>
      // Caught unknown defects, shouldn't recover!
      IO.terminate0(ts)
    case Right(e) =>
      // Caught error: DomainError!
     IO.now(0)
  }

Definition Classes: IO

final def seq[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.

Definition Classes: IO

final def seqWith[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.

Definition Classes: IO

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.

Definition Classes: IO

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

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

Definition Classes: IO

final def supervised: IO[E, A]

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

Definition Classes: IO

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

Definition Classes: AnyRef

def tag: Int

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

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

Definition Classes: Ensuring → IO

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

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

Definition Classes: IO

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

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

Definition Classes: IO

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

Times out this action by the specified duration.

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

Definition Classes: IO

def toString(): String

Definition Classes: AnyRef → Any

final def uninterruptibly: IO[E, A]

Performs this action non-interruptibly.

Performs this action non-interruptibly. This will prevent the action from being terminated externally, but the action may fail for internal reasons (e.g. an uncaught error) or terminate due to defect.

Definition Classes: IO

final def void: IO[E, Unit]

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

Definition Classes: IO

final def wait(): Unit

Definition Classes: AnyRef
Annotations: @throws( ... )

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

Definition Classes: AnyRef
Annotations: @throws( ... )

final def wait(arg0: Long): Unit

Definition Classes: AnyRef
Annotations: @native() @throws( ... )

Packages

Ensuring

final class Ensuring[E, A] extends IO[E, A]

Value Members

Inherited from IO[E, A]

Inherited from AnyRef

Inherited from Any

Ungrouped

Packages

Ensuring 

final class Ensuring[E, A] extends IO[E, A]

Value Members

Inherited from IO[E, A]

Inherited from AnyRef

Inherited from Any

Ungrouped

Ensuring