package effect
- Source
- package.scala
- Alphabetic
- By Inheritance
- effect
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Type Members
- type Async[F[_]] = effect.kernel.Async[F]
- type Clock[F[_]] = effect.kernel.Clock[F]
- type Concurrent[F[_]] = effect.kernel.GenConcurrent[F, Throwable]
- type Cont[F[_], K, R] = effect.kernel.Cont[F, K, R]
- type Deferred[F[_], A] = effect.kernel.Deferred[F, A]
-
sealed abstract
case class
ExitCode extends Product with Serializable
Represents the exit code of an application.
Represents the exit code of an application.
code
is constrained to a range from 0 to 255, inclusive. - type Fiber[F[_], E, A] = effect.kernel.Fiber[F, E, A]
- type FiberIO[A] = effect.kernel.Fiber[IO, Throwable, A]
- type GenConcurrent[F[_], E] = effect.kernel.GenConcurrent[F, E]
- type GenSpawn[F[_], E] = effect.kernel.GenSpawn[F, E]
- type GenTemporal[F[_], E] = effect.kernel.GenTemporal[F, E]
-
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).
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. AnIO
is a data structure that represents just a description of a side effectful computation.IO
can describe synchronous or asynchronous computations that:- 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 ofMonadError
) 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 itsflatMap
evaluation. This means that you can safely callflatMap
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) }
- on evaluation yield exactly one result
2. can end in either success or failure and in case of failure
- trait IOApp extends AnyRef
- sealed trait IOLocal[A] extends AnyRef
- trait LiftIO[F[_]] extends AnyRef
- type MonadCancel[F[_], E] = effect.kernel.MonadCancel[F, E]
- type MonadCancelThrow[F[_]] = effect.kernel.MonadCancel[F, Throwable]
- type Outcome[F[_], E, A] = effect.kernel.Outcome[F, E, A]
- type OutcomeIO[A] = effect.kernel.Outcome[IO, Throwable, A]
- type ParallelF[F[_], A] = T[F, A]
- type Poll[F[_]] = effect.kernel.Poll[F]
- type Ref[F[_], A] = effect.kernel.Ref[F, A]
- type Resource[F[_], +A] = effect.kernel.Resource[F, A]
- type ResourceIO[A] = effect.kernel.Resource[IO, A]
- type Spawn[F[_]] = effect.kernel.GenSpawn[F, Throwable]
- type Sync[F[_]] = effect.kernel.Sync[F]
-
sealed abstract
class
SyncIO[+A] extends AnyRef
A pure abstraction representing the intention to perform a side effect, where the result of that side effect is obtained synchronously.
A pure abstraction representing the intention to perform a side effect, where the result of that side effect is obtained synchronously.
SyncIO
is similar to IO, but does not support asynchronous computations. Consequently, aSyncIO
can be run synchronously to obtain a result viaunsafeRunSync
. This is unlikeIO#unsafeRunSync
, which cannot be safely called in general -- doing so on the JVM blocks the calling thread while the async part of the computation is run and doing so on Scala.js throws an exception upon encountering an async boundary. - type Temporal[F[_]] = effect.kernel.GenTemporal[F, Throwable]
- type Unique[F[_]] = effect.kernel.Unique[F]
Value Members
- val Async: effect.kernel.Async.type
- val Clock: effect.kernel.Clock.type
- val Concurrent: effect.kernel.GenConcurrent.type
- val Deferred: effect.kernel.Deferred.type
- val GenConcurrent: effect.kernel.GenConcurrent.type
- val GenSpawn: effect.kernel.GenSpawn.type
- val GenTemporal: effect.kernel.GenTemporal.type
- val MonadCancel: effect.kernel.MonadCancel.type
- val MonadCancelThrow: effect.kernel.MonadCancel.type
- val Outcome: effect.kernel.Outcome.type
- val ParallelF: effect.kernel.Par.ParallelF.type
- val Ref: effect.kernel.Ref.type
- val Resource: effect.kernel.Resource.type
- val Spawn: effect.kernel.GenSpawn.type
- val Sync: effect.kernel.Sync.type
- val Temporal: effect.kernel.GenTemporal.type
- val Unique: effect.kernel.Unique.type
- object ExitCode extends Serializable
- object IO extends IOCompanionPlatform with IOLowPriorityImplicits
- object IOApp
- object IOLocal
- object LiftIO
- object SyncIO extends SyncIOCompanionPlatform with SyncIOLowPriorityImplicits
- object implicits extends AllSyntax with AllInstances