Packages

sealed abstract class IO[+A] extends IOPlatform[A]

A pure abstraction representing the intention to perform a side effect, where the result of that side effect may be obtained synchronously (via return) or asynchronously (via callback).

IO values are pure, immutable values and thus preserve referential transparency, being usable in functional programming. An IO is a data structure that represents just a description of a side effectful computation.

IO can describe synchronous or asynchronous computations that:

  1. on evaluation yield exactly one result 2. can end in either success or failure and in case of failure flatMap chains get short-circuited (IO implementing the algebra of MonadError) 3. can be canceled, but note this capability relies on the user to provide cancelation logic

Effects described via this abstraction are not evaluated until the "end of the world", which is to say, when one of the "unsafe" methods are used. Effectful results are not memoized, meaning that memory overhead is minimal (and no leaks), and also that a single effect may be run multiple times in a referentially-transparent manner. For example:

val ioa = IO.println("hey!")

val program = for {
  _ <- ioa
  _ <- ioa
} yield ()

program.unsafeRunSync()

The above will print "hey!" twice, as the effect will be re-run each time it is sequenced in the monadic chain.

IO is trampolined in its flatMap evaluation. This means that you can safely call flatMap in a recursive function of arbitrary depth, without fear of blowing the stack.

def fib(n: Int, a: Long = 0, b: Long = 1): IO[Long] =
  IO.pure(a + b) flatMap { b2 =>
    if (n > 0)
      fib(n - 1, b, b2)
    else
      IO.pure(a)
  }
Source
IO.scala
See also

IOApp for the preferred way of executing whole programs wrapped in IO

Linear Supertypes
IOPlatform[A], Serializable, AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. IO
  2. IOPlatform
  3. Serializable
  4. AnyRef
  5. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. def !>[B](that: IO[B]): IO[B]
  3. final def ##: Int
    Definition Classes
    AnyRef → Any
  4. def &>[B](that: IO[B]): IO[B]

    Runs this IO and the parameter in parallel.

    Runs this IO and the parameter in parallel.

    Failure in either of the IOs will cancel the other one. If the whole computation is canceled, both actions are also canceled.

  5. def *>[B](that: IO[B]): IO[B]

    Runs the current IO, then runs the parameter, keeping its result.

    Runs the current IO, then runs the parameter, keeping its result. The result of the first action is ignored. If the source fails, the other action won't run. Not suitable for use when the parameter is a recursive reference to the current expression.

    See also

    >> for the recursion-safe, lazily evaluated alternative

  6. def <&[B](that: IO[B]): IO[A]

    Like &>, but keeps the result of the source

  7. def <*[B](that: IO[B]): IO[A]

    Like *>, but keeps the result of the source.

    Like *>, but keeps the result of the source.

    For a similar method that also runs the parameter in case of failure or interruption, see guarantee.

  8. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  9. def >>[B](that: => IO[B]): IO[B]

    Runs the current IO, then runs the parameter, keeping its result.

    Runs the current IO, then runs the parameter, keeping its result. The result of the first action is ignored. If the source fails, the other action won't run. Evaluation of the parameter is done lazily, making this suitable for recursion.

    See also

    [*>] for the strictly evaluated alternative

  10. def andWait(duration: Duration): IO[A]

    Returns an IO that will wait for the given duration after the execution of the source before returning the result.

    Returns an IO that will wait for the given duration after the execution of the source before returning the result.

    duration

    The duration to wait after executing the source

  11. def as[B](b: B): IO[B]

    Replaces the result of this IO with the given value.

  12. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  13. def attempt: IO[Either[Throwable, A]]

    Materializes any sequenced exceptions into value space, where they may be handled.

    Materializes any sequenced exceptions into value space, where they may be handled.

    This is analogous to the catch clause in try/catch, being the inverse of IO.raiseError. Thus:

    IO.raiseError(ex).attempt.unsafeRunSync() === Left(ex)
    See also

    IO.raiseError

    rethrow

  14. def background: ResourceIO[IO[OutcomeIO[A]]]

    Returns a resource that will start execution of this IO in the background.

    Returns a resource that will start execution of this IO in the background.

    In case the resource is closed while this IO is still running (e.g. due to a failure in use), the background action will be canceled.

    See also

    cats.effect.kernel.GenSpawn#background for the generic version.

  15. def backgroundOn(ec: ExecutionContext): ResourceIO[IO[OutcomeIO[A]]]
  16. def both[B](that: IO[B]): IO[(A, B)]

    Runs the current and given IO in parallel, producing the pair of the results.

    Runs the current and given IO in parallel, producing the pair of the results. If either fails with an error, the result of the whole will be that error and the other will be canceled.

    See also

    bothOutcome for the version which produces the outcome of both effects executed in parallel

    race for the version which produces the result of the winner and cancels the loser of the race

  17. def bothOutcome[B](that: IO[B]): IO[(OutcomeIO[A], OutcomeIO[B])]

    Runs the current and given IO in parallel, producing the pair of the outcomes.

    Runs the current and given IO in parallel, producing the pair of the outcomes. Both outcomes are produced, regardless of whether they complete successfully.

    See also

    both for the version which embeds the outcomes to produce a pair of the results

    raceOutcome for the version which produces the outcome of the winner and cancels the loser of the race

  18. def bracket[B](use: (A) => IO[B])(release: (A) => IO[Unit]): IO[B]

    Returns an IO action that treats the source task as the acquisition of a resource, which is then exploited by the use function and then released.

    Returns an IO action that treats the source task as the acquisition of a resource, which is then exploited by the use function and then released.

    The bracket operation is the equivalent of the try {} catch {} finally {} statements from mainstream languages.

    The bracket operation installs the necessary exception handler to release the resource in the event of an exception being raised during the computation, or in case of cancelation.

    If an exception is raised, then bracket will re-raise the exception after performing the release. If the resulting task gets canceled, then bracket will still perform the release, but the yielded task will be non-terminating (equivalent with IO.never).

    Example:

    import java.io._
    
    def readFile(file: File): IO[String] = {
      // Opening a file handle for reading text
      val acquire = IO(new BufferedReader(
        new InputStreamReader(new FileInputStream(file), "utf-8")
      ))
    
      acquire.bracket { in =>
        // Usage part
        IO {
          // Yes, ugly Java, non-FP loop;
          // side-effects are suspended though
          var line: String = null
          val buff = new StringBuilder()
          do {
            line = in.readLine()
            if (line != null) buff.append(line)
          } while (line != null)
          buff.toString()
        }
      } { in =>
        // The release part
        IO(in.close())
      }
    }

    Note that in case of cancelation the underlying implementation cannot guarantee that the computation described by use doesn't end up executed concurrently with the computation from release. In the example above that ugly Java loop might end up reading from a BufferedReader that is already closed due to the task being canceled, thus triggering an error in the background with nowhere to get signaled.

    In this particular example, given that we are just reading from a file, it doesn't matter. But in other cases it might matter, as concurrency on top of the JVM when dealing with I/O might lead to corrupted data.

    For those cases you might want to do synchronization (e.g. usage of locks and semaphores) and you might want to use bracketCase, the version that allows you to differentiate between normal termination and cancelation.

    NOTE on error handling: in case both the release function and the use function throws, the error raised by release gets signaled.

    For example:

    val foo = new RuntimeException("Foo")
    val bar = new RuntimeException("Bar")
    IO("resource").bracket { _ =>
      // use
      IO.raiseError(foo)
    } { _ =>
      // release
      IO.raiseError(bar)
    }

    In this case the resulting IO will raise error foo, while the bar error gets reported on a side-channel. This is consistent with the behavior of Java's "Try with resources" except that no involved exceptions are mutated (i.e., in contrast to Java, bar isn't added as a suppressed exception to foo).

    use

    is a function that evaluates the resource yielded by the source, yielding a result that will get generated by the task returned by this bracket function

    release

    is a function that gets called after use terminates, either normally or in error, or if it gets canceled, receiving as input the resource that needs to be released

    See also

    bracketCase

  19. def bracketCase[B](use: (A) => IO[B])(release: (A, OutcomeIO[B]) => IO[Unit]): IO[B]

    Returns a new IO task that treats the source task as the acquisition of a resource, which is then exploited by the use function and then released, with the possibility of distinguishing between normal termination and cancelation, such that an appropriate release of resources can be executed.

    Returns a new IO task that treats the source task as the acquisition of a resource, which is then exploited by the use function and then released, with the possibility of distinguishing between normal termination and cancelation, such that an appropriate release of resources can be executed.

    The bracketCase operation is the equivalent of try {} catch {} finally {} statements from mainstream languages when used for the acquisition and release of resources.

    The bracketCase operation installs the necessary exception handler to release the resource in the event of an exception being raised during the computation, or in case of cancelation.

    In comparison with the simpler bracket version, this one allows the caller to differentiate between normal termination, termination in error and cancelation via an Outcome parameter.

    use

    is a function that evaluates the resource yielded by the source, yielding a result that will get generated by this function on evaluation

    release

    is a function that gets called after use terminates, either normally or in error, or if it gets canceled, receiving as input the resource that needs release, along with the result of use (cancelation, error or successful result)

    See also

    bracket

  20. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @native()
  21. def debug[B >: A](prefix: String = "DEBUG")(implicit S: Show[B] = Show.fromToString[B]): IO[A]

    Logs the value of this IO _(even if it is an error or if it was cancelled)_ to the standard output, using the implicit cats.Show instance.

    Logs the value of this IO _(even if it is an error or if it was cancelled)_ to the standard output, using the implicit cats.Show instance.

    This operation is intended as a quick debug, not as proper logging.

    prefix

    A custom prefix for the log message, DEBUG is used as the default.

  22. def delayBy(duration: Duration): IO[A]

    Returns an IO that will delay the execution of the source by the given duration.

    Returns an IO that will delay the execution of the source by the given duration.

    duration

    The duration to wait before executing the source

  23. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  24. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  25. def evalOn(ec: ExecutionContext): IO[A]

    Shifts the execution of the current IO to the specified ExecutionContext.

    Shifts the execution of the current IO to the specified ExecutionContext. All stages of the execution will default to the pool in question, and any asynchronous callbacks will shift back to the pool upon completion. Any nested use of evalOn will override the specified pool. Once the execution fully completes, default control will be shifted back to the enclosing (inherited) pool.

    See also

    IO.executionContext for obtaining the ExecutionContext on which the current IO is being executed

  26. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable])
  27. def flatMap[B](f: (A) => IO[B]): IO[B]

    Monadic bind on IO, used for sequentially composing two IO actions, where the value produced by the first IO is passed as input to a function producing the second IO action.

    Monadic bind on IO, used for sequentially composing two IO actions, where the value produced by the first IO is passed as input to a function producing the second IO action.

    Due to this operation's signature, flatMap forces a data dependency between two IO actions, thus ensuring sequencing (e.g. one action to be executed before another one).

    Any exceptions thrown within the function will be caught and sequenced into the IO, because due to the nature of asynchronous processes, without catching and handling exceptions, failures would be completely silent and IO references would never terminate on evaluation.

  28. def flatTap[B](f: (A) => IO[B]): IO[A]
  29. def flatten[B](implicit ev: <:<[A, IO[B]]): IO[B]
  30. def forceR[B](that: IO[B]): IO[B]
  31. def foreverM: IO[Nothing]

    Evaluates the current IO in an infinite loop, terminating only on error or cancelation.

    Evaluates the current IO in an infinite loop, terminating only on error or cancelation.

    IO.println("Hello, World!").foreverM    // continues printing forever
  32. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  33. def guarantee(finalizer: IO[Unit]): IO[A]

    Executes the given finalizer when the source is finished, either in success or in error, or if canceled.

    Executes the given finalizer when the source is finished, either in success or in error, or if canceled.

    This variant of guaranteeCase evaluates the given finalizer regardless of how the source gets terminated:

    • normal completion
    • completion in error
    • cancelation

    This equivalence always holds:

    io.guarantee(f) <-> IO.unit.bracket(_ => io)(_ => f)
    See also

    guaranteeCase for the version that can discriminate between termination conditions

  34. def guaranteeCase(finalizer: (OutcomeIO[A]) => IO[Unit]): IO[A]

    Executes the given finalizer when the source is finished, either in success or in error, or if canceled, allowing for differentiating between exit conditions.

    Executes the given finalizer when the source is finished, either in success or in error, or if canceled, allowing for differentiating between exit conditions.

    This variant of guarantee injects an Outcome in the provided function, allowing one to make a difference between:

    • normal completion
    • completion in error
    • cancelation

    This equivalence always holds:

    io.guaranteeCase(f) <-> IO.unit.bracketCase(_ => io)((_, e) => f(e))
    See also

    guarantee for the simpler version

  35. def handleError[B >: A](f: (Throwable) => B): IO[B]
  36. def handleErrorWith[B >: A](f: (Throwable) => IO[B]): IO[B]

    Handle any error, potentially recovering from it, by mapping it to another IO value.

    Handle any error, potentially recovering from it, by mapping it to another IO value.

    Implements ApplicativeError.handleErrorWith.

  37. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  38. def ifM[B](ifTrue: => IO[B], ifFalse: => IO[B])(implicit ev: <:<[A, Boolean]): IO[B]
  39. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  40. def iterateUntil(p: (A) => Boolean): IO[A]
  41. def iterateWhile(p: (A) => Boolean): IO[A]
  42. def map[B](f: (A) => B): IO[B]

    Functor map on IO.

    Functor map on IO. Given a mapping function, it transforms the value produced by the source, while keeping the IO context.

    Any exceptions thrown within the function will be caught and sequenced into the IO. Due to the nature of asynchronous processes, without catching and handling exceptions, failures would be completely silent and IO references would never terminate on evaluation.

  43. def memoize: IO[IO[A]]
  44. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  45. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  46. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  47. def onCancel(fin: IO[Unit]): IO[A]
  48. def onError(f: (Throwable) => IO[Unit]): IO[A]
  49. def option: IO[Option[A]]

    Replaces failures in this IO with an empty Option.

  50. def orElse[B >: A](other: => IO[B]): IO[B]

    Runs the current IO, if it fails with an error(exception), the other IO will be executed.

    Runs the current IO, if it fails with an error(exception), the other IO will be executed.

    other

    IO to be executed (if the current IO fails)

  51. def product[B](that: IO[B]): IO[(A, B)]
  52. def productL[B](that: IO[B]): IO[A]
  53. def productR[B](that: IO[B]): IO[B]
  54. def race[B](that: IO[B]): IO[Either[A, B]]
  55. def raceOutcome[B](that: IO[B]): IO[Either[OutcomeIO[A], OutcomeIO[B]]]
  56. def racePair[B](that: IO[B]): IO[Either[(OutcomeIO[A], FiberIO[B]), (FiberIO[A], OutcomeIO[B])]]
  57. def recover[B >: A](pf: PartialFunction[Throwable, B]): IO[B]

    Recover from certain errors by mapping them to an A value.

    Recover from certain errors by mapping them to an A value.

    Implements ApplicativeError.recover.

  58. def recoverWith[B >: A](pf: PartialFunction[Throwable, IO[B]]): IO[B]

    Recover from certain errors by mapping them to another IO value.

    Recover from certain errors by mapping them to another IO value.

    Implements ApplicativeError.recoverWith.

  59. def redeem[B](recover: (Throwable) => B, map: (A) => B): IO[B]

    Returns a new value that transforms the result of the source, given the recover or map functions, which get executed depending on whether the result ends in error or if it is successful.

    Returns a new value that transforms the result of the source, given the recover or map functions, which get executed depending on whether the result ends in error or if it is successful.

    This is an optimization on usage of attempt and map, this equivalence being true:

    io.redeem(recover, map) <-> io.attempt.map(_.fold(recover, map))

    Usage of redeem subsumes handleError because:

    io.redeem(fe, id) <-> io.handleError(fe)
    recover

    is a function used for error recover in case the source ends in error

    map

    is a function used for mapping the result of the source in case it ends in success

  60. def redeemWith[B](recover: (Throwable) => IO[B], bind: (A) => IO[B]): IO[B]

    Returns a new value that transforms the result of the source, given the recover or bind functions, which get executed depending on whether the result ends in error or if it is successful.

    Returns a new value that transforms the result of the source, given the recover or bind functions, which get executed depending on whether the result ends in error or if it is successful.

    This is an optimization on usage of attempt and flatMap, this equivalence being available:

    io.redeemWith(recover, bind) <-> io.attempt.flatMap(_.fold(recover, bind))

    Usage of redeemWith subsumes handleErrorWith because:

    io.redeemWith(fe, F.pure) <-> io.handleErrorWith(fe)

    Usage of redeemWith also subsumes flatMap because:

    io.redeemWith(F.raiseError, fs) <-> io.flatMap(fs)
    recover

    is the function that gets called to recover the source in case of error

    bind

    is the function that gets to transform the source in case of success

  61. def replicateA(n: Int): IO[List[A]]
  62. def replicateA_(n: Int): IO[Unit]
  63. def rethrow[B](implicit ev: <:<[A, Either[Throwable, B]]): IO[B]

    Inverse of attempt

    Inverse of attempt

    This function raises any materialized error.

    IO(Right(a)).rethrow === IO.pure(a)
    IO(Left(ex)).rethrow === IO.raiseError(ex)
    
    // Or more generally:
    io.attempt.rethrow === io // For any io.
    See also

    IO.raiseError

    attempt

  64. def start: IO[FiberIO[A]]

    Start execution of the source suspended in the IO context.

    Start execution of the source suspended in the IO context.

    This can be used for non-deterministic / concurrent execution. The following code is more or less equivalent with parMap2 (minus the behavior on error handling and cancelation):

    def par2[A, B](ioa: IO[A], iob: IO[B]): IO[(A, B)] =
      for {
        fa <- ioa.start
        fb <- iob.start
          a <- fa.join
          b <- fb.join
      } yield (a, b)

    Note in such a case usage of parMapN (via cats.Parallel) is still recommended because of behavior on error and cancelation — consider in the example above what would happen if the first task finishes in error. In that case the second task doesn't get canceled, which creates a potential memory leak.

    Also see background for a safer alternative.

  65. def startOn(ec: ExecutionContext): IO[FiberIO[A]]
  66. def syncStep(limit: Int): SyncIO[Either[IO[A], A]]

    Translates this IO[A] into a SyncIO value which, when evaluated, runs the original IO to its completion, the limit number of stages, or until the first stage that cannot be expressed with SyncIO (typically an asynchronous boundary).

    Translates this IO[A] into a SyncIO value which, when evaluated, runs the original IO to its completion, the limit number of stages, or until the first stage that cannot be expressed with SyncIO (typically an asynchronous boundary).

    limit

    The maximum number of stages to evaluate prior to forcibly yielding to IO

  67. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  68. def timed: IO[(FiniteDuration, A)]
  69. def timeout[A2 >: A](duration: Duration): IO[A2]

    Returns an IO that either completes with the result of the source within the specified time duration or otherwise raises a TimeoutException.

    Returns an IO that either completes with the result of the source within the specified time duration or otherwise raises a TimeoutException.

    The source is canceled in the event that it takes longer than the specified time duration to complete. Once the source has been successfully canceled (and has completed its finalizers), the TimeoutException will be raised. If the source is uncancelable, the resulting effect will wait for it to complete before raising the exception.

    duration

    is the time span for which we wait for the source to complete; in the event that the specified time has passed without the source completing, a TimeoutException is raised

  70. def timeoutAndForget(duration: Duration): IO[A]

    Returns an IO that either completes with the result of the source within the specified time duration or otherwise raises a TimeoutException.

    Returns an IO that either completes with the result of the source within the specified time duration or otherwise raises a TimeoutException.

    The source is canceled in the event that it takes longer than the specified time duration to complete. Unlike timeout, the cancelation of the source will be requested but not awaited, and the exception will be raised immediately upon the completion of the timer. This may more closely match intuitions about timeouts, but it also violates backpressure guarantees and intentionally leaks fibers.

    This combinator should be applied very carefully.

    duration

    The time span for which we wait for the source to complete; in the event that the specified time has passed without the source completing, a TimeoutException is raised

    See also

    timeout for a variant which respects backpressure and does not leak fibers

  71. def timeoutTo[A2 >: A](duration: Duration, fallback: IO[A2]): IO[A2]

    Returns an IO that either completes with the result of the source within the specified time duration or otherwise evaluates the fallback.

    Returns an IO that either completes with the result of the source within the specified time duration or otherwise evaluates the fallback.

    The source is canceled in the event that it takes longer than the specified time duration to complete. Once the source has been successfully canceled (and has completed its finalizers), the fallback will be sequenced. If the source is uncancelable, the resulting effect will wait for it to complete before evaluating the fallback.

    duration

    is the time span for which we wait for the source to complete; in the event that the specified time has passed without the source completing, the fallback gets evaluated

    fallback

    is the task evaluated after the duration has passed and the source canceled

  72. def to[F[_]](implicit F: LiftIO[F]): F[A]

    Converts the source IO into any F type that implements the LiftIO type class.

  73. def toString(): String
    Definition Classes
    IO → AnyRef → Any
  74. def uncancelable: IO[A]

    Makes the source IO uninterruptible such that a cats.effect.kernel.Fiber#cancel signal is ignored until completion.

    Makes the source IO uninterruptible such that a cats.effect.kernel.Fiber#cancel signal is ignored until completion.

    See also

    IO.uncancelable for constructing uncancelable IO values with user-configurable cancelable regions

  75. def unsafeRunAndForget()(implicit runtime: IORuntime): Unit

    Triggers the evaluation of the source and any suspended side effects therein, but ignores the result.

    Triggers the evaluation of the source and any suspended side effects therein, but ignores the result.

    This operation is similar to unsafeRunAsync, in that the evaluation can happen asynchronously, except no callback is required and therefore the result is ignored.

    Note that errors still get logged (via IO's internal logger), because errors being thrown should never be totally silent.

  76. def unsafeRunAsync(cb: (Either[Throwable, A]) => Unit)(implicit runtime: IORuntime): Unit

    Passes the result of the encapsulated effects to the given callback by running them as impure side effects.

    Passes the result of the encapsulated effects to the given callback by running them as impure side effects.

    Any exceptions raised within the effect will be passed to the callback in the Either. The callback will be invoked at most *once*. In addition, fatal errors will be printed. Note that it is very possible to construct an IO which never returns while still never blocking a thread, and attempting to evaluate that IO with this method will result in a situation where the callback is *never* invoked.

    As the name says, this is an UNSAFE function as it is impure and performs side effects. You should ideally only call this function once, at the very end of your program.

  77. def unsafeRunAsyncOutcome(cb: (Outcome[Id, Throwable, A]) => Unit)(implicit runtime: IORuntime): Unit
  78. def unsafeRunCancelable()(implicit runtime: IORuntime): () => Future[Unit]

    Evaluates the effect, returning a cancelation token that can be used to cancel it.

    Evaluates the effect, returning a cancelation token that can be used to cancel it.

    This is similar to unsafeRunAsync in that it evaluates the IO as a side effect in a non-blocking fashion, but uses a Future rather than an explicit callback. This function should really only be used if interoperating with code which uses Scala futures.

    See also

    IO.fromFuture

  79. final def unsafeRunSync()(implicit runtime: IORuntime): A

    Produces the result by running the encapsulated effects as impure side effects.

    Produces the result by running the encapsulated effects as impure side effects.

    If any component of the computation is asynchronous, the current thread will block awaiting the results of the async computation. By default, this blocking will be unbounded. To limit the thread block to some fixed time, use unsafeRunTimed instead.

    Any exceptions raised within the effect will be re-thrown during evaluation.

    As the name says, this is an UNSAFE function as it is impure and performs side effects, not to mention blocking, throwing exceptions, and doing other things that are at odds with reasonable software. You should ideally only call this function *once*, at the very end of your program.

    Definition Classes
    IOPlatform
  80. final def unsafeRunTimed(limit: FiniteDuration)(implicit runtime: IORuntime): Option[A]

    Similar to unsafeRunSync, except with a bounded blocking duration when awaiting asynchronous results.

    Similar to unsafeRunSync, except with a bounded blocking duration when awaiting asynchronous results. As soon as an async blocking limit is hit, evaluation immediately aborts and None is returned. Note that this does not run finalizers, which makes it quite different (and less safe) than other mechanisms for limiting evaluation time.

    val program: IO[A] = ...
    
    program.timeout(5.seconds).unsafeRunSync()
    program.unsafeRunTimed(5.seconds)

    The first line will run program for at most five seconds, interrupt the calculation, and run the finalizers for as long as they need to complete. The second line will run program for at most five seconds and then immediately release the latch, without interrupting program's ongoing execution.

    In other words, this function probably doesn't do what you think it does, and you probably don't want to use it outside of tests.

    Definition Classes
    IOPlatform
    See also

    unsafeRunSync

    IO.timeout for pure and safe version

  81. final def unsafeToCompletableFuture()(implicit runtime: IORuntime): CompletableFuture[A]
    Definition Classes
    IOPlatform
  82. def unsafeToFuture()(implicit runtime: IORuntime): Future[A]

    Evaluates the effect and produces the result in a Future.

    Evaluates the effect and produces the result in a Future.

    This is similar to unsafeRunAsync in that it evaluates the IO as a side effect in a non-blocking fashion, but uses a Future rather than an explicit callback. This function should really only be used if interoperating with code which uses Scala futures.

    See also

    IO.fromFuture

  83. def unsafeToFutureCancelable()(implicit runtime: IORuntime): (Future[A], () => Future[Unit])

    Evaluates the effect and produces the result in a Future, along with a cancelation token that can be used to cancel the original effect.

    Evaluates the effect and produces the result in a Future, along with a cancelation token that can be used to cancel the original effect.

    This is similar to unsafeRunAsync in that it evaluates the IO as a side effect in a non-blocking fashion, but uses a Future rather than an explicit callback. This function should really only be used if interoperating with code which uses Scala futures.

    See also

    IO.fromFuture

  84. def untilM[G[_], B >: A](cond: => IO[Boolean])(implicit arg0: Alternative[G]): IO[G[B]]
  85. def untilM_(cond: => IO[Boolean]): IO[Unit]
  86. def void: IO[Unit]

    Ignores the result of this IO.

  87. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  88. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  89. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()
  90. def whileM[G[_], B >: A](p: IO[Boolean])(implicit arg0: Alternative[G]): IO[G[B]]
  91. def whileM_(p: IO[Boolean]): IO[Unit]

Deprecated Value Members

  1. def syncStep: SyncIO[Either[IO[A], A]]
    Annotations
    @deprecated
    Deprecated

    (Since version 3.4.0) use syncStep(Int) instead

Inherited from IOPlatform[A]

Inherited from Serializable

Inherited from AnyRef

Inherited from Any

Ungrouped