SyncIO

Alias for productR.

Alias for productL.

Alias for flatMap(_ => that).

Alias for map(_ => b).

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 SyncIO.raiseError. Thus:

SyncIO.raiseError(ex).attempt.unsafeRunSync === Left(ex)

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

Due to this operation's signature, flatMap forces a data dependency between two SyncIO 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].

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

Implements ApplicativeError.handleErrorWith.

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

Any exceptions thrown within the function will be caught and sequenced into the result SyncIO[B].

Executes that only for the side effects.

Sequences that without propagating the value of the current SyncIO.

Translates this SyncIO to any F[_] data type that implements Sync.

Returns a string representation of the object.

The default representation is platform dependent.

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.

Alias for map(_ => ()).