IO
Related Docs:
class IO
| package effect
Suspends a synchronous side effect in IO.
Suspends a synchronous side effect in IO.
Any exceptions thrown by the effect will be caught and sequenced
into the IO.
Suspends an asynchronous side effect in IO.
Suspends an asynchronous side effect in IO.
The given function will be invoked during evaluation of the IO
to "schedule" the asynchronous callback, where the callback is
the parameter passed to that function. Only the first
invocation of the callback will be effective! All subsequent
invocations will be silently dropped.
As a quick example, you can use this function to perform a
parallel computation given an ExecutorService:
def fork[A](body: => A)(implicit E: ExecutorService): IO[A] = { IO async { cb => E.execute(new Runnable { def run() = try cb(Right(body)) catch { case NonFatal(t) => cb(Left(t)) } }) } }
The fork function will do exactly what it sounds like: take a
thunk and an ExecutorService and run that thunk on the thread
pool. Or rather, it will produce an IO which will do those
things when run; it does *not* schedule the thunk until the
resulting IO is run! Note that there is no thread blocking in
this implementation; the resulting IO encapsulates the callback
in a pure and monadic fashion without using threads.
This function can be thought of as a safer, lexically-constrained
version of Promise, where IO is like a safer, lazy version of
Future.
Lifts an Eval into IO.
Lifts an Eval into IO.
This function will preserve the evaluation semantics of any
actions that are lifted into the pure IO. Eager Eval
instances will be converted into thunk-less IO (i.e. eager
IO), while lazy eval and memoized will be executed as such.
Constructs an IO which evaluates the given Future and
produces the result (or failure).
Constructs an IO which evaluates the given Future and
produces the result (or failure).
Because Future eagerly evaluates, as well as because it
memoizes, this function takes its parameter as a cats.Eval,
which could be lazily evaluated. If this laziness is
appropriately threaded back to the definition site of the
Future, it ensures that the computation is fully managed by
IO and thus referentially transparent.
The cats.Eval type allows fine grained control of how the
passed Future reference gets evaluated. Example:
import cats.Eval.{always, later, now} // Lazy evaluation, equivalent with by-name params IO.fromFuture(always(f)) // Memoized, lazy evaluation, equivalent with lazy val IO.fromFuture(later(f)) // Eager evaluation IO.fromFuture(now(f))
Note that the continuation of the computation resulting from
a Future will run on the future's thread pool. There is no
thread shifting here; the ExecutionContext is solely for the
benefit of the Future.
Roughly speaking, the following identities hold:
IO.fromFuture(always(f)).unsafeToFuture() === f // true-ish (except for memoization) IO.fromFuture(always(ioa.unsafeToFuture())) === ioa // true
Suspends a pure value in IO.
Suspends a pure value in IO.
This should only be used if the value in question has
"already" been computed! In other words, something like
IO.pure(readLine) is most definitely not the right thing to do!
However, IO.pure(42) is correct and will be more efficient
(when evaluated) than IO(42), due to avoiding the allocation of
extra thunks.
Constructs an IO which sequences the specified exception.
Constructs an IO which sequences the specified exception.
If this IO is run using unsafeRunSync or unsafeRunTimed,
the exception will be thrown. This exception can be "caught" (or
rather, materialized into value-space) using the attempt
method.
Suspends a synchronous side effect which produces an IO in IO.
Suspends a synchronous side effect which produces an IO in IO.
This is useful for trampolining (i.e. when the side effect is
conceptually the allocation of a stack frame). Any exceptions
thrown by the side effect will be caught and sequenced into the
IO.
Alias for IO.pure(()).