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.
SyncIO
is similar to IO, but does not support asynchronous
computations. Consequently, a SyncIO
can be run synchronously
to obtain a result via unsafeRunSync
. This is unlike
IO#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.
- Source
- SyncIO.scala
- Alphabetic
- By Inheritance
- SyncIO
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
def
*>[B](that: SyncIO[B]): SyncIO[B]
Alias for
productR
.Alias for
productR
.- See also
-
def
<*[B](that: SyncIO[B]): SyncIO[A]
Alias for
productL
.Alias for
productL
.- See also
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
>>[B](that: SyncIO[B]): SyncIO[B]
Alias for
flatMap(_ => that)
.Alias for
flatMap(_ => that)
.- See also
-
def
as[B](b: B): SyncIO[B]
Alias for
map(_ => b)
.Alias for
map(_ => b)
.- See also
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
attempt: SyncIO[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 intry
/catch
, being the inverse ofSyncIO.raiseError
. Thus:SyncIO.raiseError(ex).attempt.unsafeRunSync === Left(ex)
- See also
-
def
clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native() @HotSpotIntrinsicCandidate()
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
flatMap[B](f: (A) ⇒ SyncIO[B]): SyncIO[B]
Monadic bind on
SyncIO
, used for sequentially composing twoSyncIO
actions, where the value produced by the firstSyncIO
is passed as input to a function producing the secondSyncIO
action.Monadic bind on
SyncIO
, used for sequentially composing twoSyncIO
actions, where the value produced by the firstSyncIO
is passed as input to a function producing the secondSyncIO
action.Due to this operation's signature,
flatMap
forces a data dependency between twoSyncIO
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 in to the result
SyncIO[B]
.- f
the bind function
- returns
SyncIO
produced by applyingf
to the result of the currentSyncIO
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @HotSpotIntrinsicCandidate()
-
def
handleErrorWith[B >: A](f: (Throwable) ⇒ SyncIO[B]): SyncIO[B]
Handle any error, potentially recovering from it, by mapping it to another
SyncIO
value.Handle any error, potentially recovering from it, by mapping it to another
SyncIO
value.Implements
ApplicativeError.handleErrorWith
. -
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @HotSpotIntrinsicCandidate()
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
def
map[B](f: (A) ⇒ B): SyncIO[B]
Functor map on
SyncIO
.Functor map on
SyncIO
. Given a mapping function, it transforms the value produced by the source, while keeping theSyncIO
context.Any exceptions thrown within the function will be caught and sequenced into the result
SyncIO[B]
.- f
the mapping function
- returns
SyncIO
that evaluates to the value obtained by applyingf
to the result of the currentSyncIO
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @HotSpotIntrinsicCandidate()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @HotSpotIntrinsicCandidate()
-
def
productL[B](that: SyncIO[B]): SyncIO[A]
Executes
that
only for the side effects.Executes
that
only for the side effects.- that
SyncIO
to be executed after thisSyncIO
- returns
SyncIO
which sequences the effects ofthat
but evaluates to the result of thisSyncIO
-
def
productR[B](that: SyncIO[B]): SyncIO[B]
Sequences
that
without propagating the value of the currentSyncIO
.Sequences
that
without propagating the value of the currentSyncIO
.- that
SyncIO
to be executed after thisSyncIO
- returns
SyncIO
which sequences the effects ofthat
- def redeem[B](recover: (Throwable) ⇒ B, map: (A) ⇒ B): SyncIO[B]
- def redeemWith[B](recover: (Throwable) ⇒ SyncIO[B], bind: (A) ⇒ SyncIO[B]): SyncIO[B]
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
to[F[_]](implicit F: Sync[F]): F[A]
Converts the source
SyncIO
into anyF
type that implements the Sync type class. -
def
toString(): String
- Definition Classes
- SyncIO → AnyRef → Any
-
def
unsafeRunSync(): 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.
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 and throws exceptions. You should ideally only call this function *once*, at the very end of your program.
- returns
the result of evaluating this
SyncIO
-
def
void: SyncIO[Unit]
Alias for
map(_ => ())
.Alias for
map(_ => ())
.- See also
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
Deprecated Value Members
-
def
finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] ) @Deprecated
- Deprecated