cats-effect/cats.effect/SyncIO$

SyncIO

object SyncIO extends SyncIOCompanionPlatform with SyncIOLowPriorityImplicits
Companion
class
trait Sum
trait Mirror
trait SyncIOLowPriorityImplicits
trait SyncIOCompanionPlatform
class Object
trait Matchable
class Any

Type members

Inherited classlikes

protected class SyncIOSemigroup[A](val A: Semigroup[A])
Inhertied from
SyncIOLowPriorityImplicits

Inherited types

type MirroredElemLabels <: Tuple
The names of the product elements
Inhertied from
Mirror
type MirroredLabel <: String
The name of the type
Inhertied from
Mirror

Value members

Methods

def apply[A](thunk: => A): SyncIO[A]
Suspends a synchronous side effect in SyncIO.
Any exceptions thrown by the effect will be caught and sequenced
into the SyncIO.
Value Params
thunk
side effectful expression to be suspended in SyncIO
Returns
a SyncIO that will be evaluated to the side effectful expression thunk
def defer[A](thunk: => SyncIO[A]): SyncIO[A]
Suspends a synchronous side effect which produces a SyncIO in SyncIO.
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
SyncIO.
Value Params
thunk
SyncIO expression to be suspended in SyncIO
Returns
a SyncIO that will be evaluated to the value of the suspended thunk
def delay[A](thunk: => A): SyncIO[A]
Alias for apply.
See also
def eval[A](fa: Eval[A]): SyncIO[A]
Lifts an Eval into SyncIO.
This function will preserve the evaluation semantics of any
actions that are lifted into the pure SyncIO. Eager Eval
instances will be converted into thunk-less SyncIO (i.e. eager
SyncIO), while lazy eval and memoized will be executed as such.
Value Params
fa
Eval instance to be lifted in SyncIO
Returns
SyncIO that will be evaluated to the value of the lifted fa
def pure[A](value: A): SyncIO[A]
Suspends a pure value in SyncIO.
This should ''only'' be used if the value in question has
"already" been computed! In other words, something like
SyncIO.pure(readLine) is most definitely not the right thing to do!
However, SyncIO.pure(42) is correct and will be more efficient
(when evaluated) than SyncIO(42), due to avoiding the allocation of
extra thunks.
Value Params
value
precomputed value used as the result of the SyncIO
Returns
an already evaluated SyncIO holding value
def raiseError[A](t: Throwable): SyncIO[A]
Constructs a SyncIO which sequences the specified exception.
If this SyncIO is run using unsafeRunSync the exception will
be thrown. This exception can be "caught" (or rather, materialized
into value-space) using the attempt method.
Value Params
t
java.lang.Throwable value to fail with
Returns
a SyncIO that results in failure with value t
See also
def unit: SyncIO[Unit]
Alias for SyncIO.pure(())
See also
def fromEither[A](e: Either[Throwable, A]): SyncIO[A]
Lifts an Either[Throwable, A] into SyncIO, raising the throwable if
it exists.
Value Params
e
either value to be lifted
Returns
SyncIO that evaluates to the value of e or fail with its Throwable instance
def fromOption[A](o: Option[A])(orElse: => Throwable): SyncIO[A]
Lifts an Option[A] into SyncIO, raising orElse if the provided
option value is empty.
Value Params
o
option value to be lifted
orElse
expression that evaluates to Throwable
Returns
SyncIO that evaluates to the optional value o or fail with the orElse expression
def fromTry[A](t: Try[A]): SyncIO[A]
Lifts a Try[A] into SyncIO, raising the throwable if it exists.
Value Params
t
try value to be lifted
Returns
SyncIO that evaluates to the value of t if successful, or fails with its Throwable instance

Fields

val monotonic: SyncIO[FiniteDuration]
val realTime: SyncIO[FiniteDuration]

Inherited methods

final def realTimeInstant: SyncIO[Instant]
Inhertied from
SyncIOCompanionPlatform

Implicits

Implicits

implicit def showForSyncIO[A](A: Show[A]): Show[SyncIO[A]]
implicit def monoidForIO[A](evidence$1: Monoid[A]): Monoid[SyncIO[A]]
implicit def syncForSyncIO: Sync[[A] =>> SyncIO[A]] & MonadCancel[[A] =>> SyncIO[A], Throwable]

Inherited implicits

implicit def semigroupForIO[A](evidence$2: Semigroup[A]): Semigroup[SyncIO[A]]
Inhertied from
SyncIOLowPriorityImplicits