object IO extends IOCompanionPlatform with IOLowPriorityImplicits
- Source
- IO.scala
- Alphabetic
- By Inheritance
- IO
- IOLowPriorityImplicits
- IOCompanionPlatform
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Type Members
-
class
IOMonoid[A] extends IOSemigroup[A] with Monoid[IO[A]]
- Attributes
- protected
-
class
IOSemigroup[A] extends Semigroup[IO[A]]
- Attributes
- protected
- Definition Classes
- IOLowPriorityImplicits
-
class
IOSemigroupK extends SemigroupK[IO]
- Attributes
- protected
- type Par[A] = T[IO, A]
Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- def apply[A](thunk: ⇒ A): IO[A]
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
- def async[A](k: ((Either[Throwable, A]) ⇒ Unit) ⇒ IO[Option[IO[Unit]]]): IO[A]
- implicit def asyncForIO: kernel.Async[IO]
- def async_[A](k: ((Either[Throwable, A]) ⇒ Unit) ⇒ Unit): IO[A]
-
def
blocking[A](thunk: ⇒ A): IO[A]
- Definition Classes
- IOCompanionPlatform
- def both[A, B](left: IO[A], right: IO[B]): IO[(A, B)]
- def bothOutcome[A, B](left: IO[A], right: IO[B]): IO[(OutcomeIO[A], OutcomeIO[B])]
- def bracketFull[A, B](acquire: (Poll[IO]) ⇒ IO[A])(use: (A) ⇒ IO[B])(release: (A, OutcomeIO[B]) ⇒ IO[Unit]): IO[B]
- def canceled: IO[Unit]
- def cede: IO[Unit]
-
def
clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
- implicit val consoleForIO: Console[IO]
-
def
cont[K, R](body: Cont[IO, K, R]): IO[R]
This is a low-level API which is meant for implementors, please use
background
,start
,async
, orDeferred
instead, depending on the use case - def defer[A](thunk: ⇒ IO[A]): IO[A]
- def deferred[A]: IO[Deferred[IO, A]]
- def delay[A](thunk: ⇒ A): IO[A]
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- def eval[A](fa: Eval[A]): IO[A]
- def executionContext: IO[ExecutionContext]
-
def
finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
def
fromCompletableFuture[A](fut: IO[CompletableFuture[A]]): IO[A]
- Definition Classes
- IOCompanionPlatform
- def fromEither[A](e: Either[Throwable, A]): IO[A]
- def fromFuture[A](fut: IO[Future[A]]): IO[A]
- def fromOption[A](o: Option[A])(orElse: ⇒ Throwable): IO[A]
- def fromTry[A](t: Try[A]): IO[A]
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
interruptible[A](many: Boolean)(thunk: ⇒ A): IO[A]
- Definition Classes
- IOCompanionPlatform
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- implicit def monoidForIO[A](implicit arg0: Monoid[A]): Monoid[IO[A]]
- def monotonic: IO[FiniteDuration]
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def never[A]: IO[A]
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
def
parSequenceN[T[_], A](n: Int)(tma: T[IO[A]])(implicit arg0: Traverse[T]): IO[T[A]]
Like
Parallel.parSequence
, but limits the degree of parallelism. -
def
parTraverseN[T[_], A, B](n: Int)(ta: T[A])(f: (A) ⇒ IO[B])(implicit arg0: Traverse[T]): IO[T[B]]
Like
Parallel.parTraverse
, but limits the degree of parallelism. - implicit def parallelForIO: Aux[IO, Par]
-
def
print[A](a: A)(implicit S: Show[A] = Show.fromToString[A]): IO[Unit]
Prints a value to the standard output using the implicit
cats.Show
instance.Prints a value to the standard output using the implicit
cats.Show
instance.- a
value to be printed to the standard output
- See also
cats.effect.std.Console
for more standard input, output and error operations
-
def
println[A](a: A)(implicit S: Show[A] = Show.fromToString[A]): IO[Unit]
Prints a value to the standard output followed by a new line using the implicit
cats.Show
instance.Prints a value to the standard output followed by a new line using the implicit
cats.Show
instance.- a
value to be printed to the standard output
- See also
cats.effect.std.Console
for more standard input, output and error operations
- def pure[A](value: A): IO[A]
- def race[A, B](left: IO[A], right: IO[B]): IO[Either[A, B]]
- def racePair[A, B](left: IO[A], right: IO[B]): IO[Either[(OutcomeIO[A], FiberIO[B]), (FiberIO[A], OutcomeIO[B])]]
- def raiseError[A](t: Throwable): IO[A]
-
def
raiseUnless(cond: Boolean)(e: ⇒ Throwable): IO[Unit]
Returns
raiseError
whencond
is false, otherwise IO.unitReturns
raiseError
whencond
is false, otherwise IO.unitval tooMany = 5 val x: Int = ??? IO.raiseUnless(x < tooMany)(new IllegalArgumentException("Too many"))
Example: -
def
raiseWhen(cond: Boolean)(e: ⇒ Throwable): IO[Unit]
Returns
raiseError
when thecond
is true, otherwiseIO.unit
Returns
raiseError
when thecond
is true, otherwiseIO.unit
val tooMany = 5 val x: Int = ??? IO.raiseWhen(x >= tooMany)(new IllegalArgumentException("Too many"))
Example: -
def
readLine: IO[String]
Reads a line as a string from the standard input using the platform's default charset, as per
java.nio.charset.Charset.defaultCharset()
.Reads a line as a string from the standard input using the platform's default charset, as per
java.nio.charset.Charset.defaultCharset()
.The effect can raise a
java.io.EOFException
if no input has been consumed before the EOF is observed. This should never happen with the standard input, unless it has been replaced with a finitejava.io.InputStream
throughjava.lang.System#setIn
or similar.- returns
an IO effect that describes reading the user's input from the standard input as a string
- See also
cats.effect.std.Console#readLineWithCharset
for reading using a customjava.nio.charset.Charset
- def realTime: IO[FiniteDuration]
-
def
realTimeInstant: IO[Instant]
- Definition Classes
- IOCompanionPlatform
- def ref[A](a: A): IO[Ref[IO, A]]
-
implicit
def
semigroupForIO[A](implicit arg0: Semigroup[A]): Semigroup[IO[A]]
- Definition Classes
- IOLowPriorityImplicits
- implicit val semigroupKForIO: SemigroupK[IO]
- implicit def showForIO[A](implicit arg0: Show[A]): Show[IO[A]]
-
implicit
def
showForIONoPure[A]: Show[IO[A]]
- Definition Classes
- IOLowPriorityImplicits
- def sleep(delay: FiniteDuration): IO[Unit]
- def stub: IO[Nothing]
-
def
suspend[A](hint: Type)(thunk: ⇒ A): IO[A]
- Definition Classes
- IOCompanionPlatform
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
toString(): String
- Definition Classes
- AnyRef → Any
- def uncancelable[A](body: (Poll[IO]) ⇒ IO[A]): IO[A]
- def unit: IO[Unit]
-
def
unlessA(cond: Boolean)(action: ⇒ IO[Unit]): IO[Unit]
Returns the given argument if
cond
is false, otherwiseIO.Unit
Returns the given argument if
cond
is false, otherwiseIO.Unit
- See also
IO.whenA for the inverse
IO.raiseWhen for conditionally raising an error
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
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()
-
def
whenA(cond: Boolean)(action: ⇒ IO[Unit]): IO[Unit]
Returns the given argument if
cond
is true, otherwiseIO.Unit
Returns the given argument if
cond
is true, otherwiseIO.Unit
- See also
IO.unlessA for the inverse
IO.raiseWhen for conditionally raising an error