App

abstract def run(args: List[String]): IO[Nothing, ExitStatus]

The main function of the application, which will be passed the command-line arguments to the program and has to return an IO with the errors fully handled.

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

object ExitStatus

val MaxResumptionDepth: Int

This determines the maximum number of resumptions placed on the stack before a fiber is shifted over to a new thread to prevent stack overflow.

final val YieldMaxOpCount: Int(1048576)

Determines the maximum number of operations executed by a fiber before yielding to other fibers.

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def defaultHandler: (List[Throwable]) ⇒ IO[Nothing, Unit]

The default handler for unhandled exceptions in the main fiber, and any fibers it forks that recursively inherit the handler.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def impureCanceler(canceler: PureCanceler): Canceler

final def isInstanceOf[T0]: Boolean

final def main(args0: Array[String]): Unit

The Scala main function, intended to be called only by the Scala runtime.

final def ne(arg0: AnyRef): Boolean

def nonFatal(t: Throwable): Boolean

Utility function to avoid catching truly fatal exceptions.

final def notify(): Unit

final def notifyAll(): Unit

final def schedule[E, A](block: ⇒ A, duration: Duration): Async[E, Unit]

lazy val scheduledExecutor: ScheduledExecutorService

final def submit[A](block: ⇒ A): Unit

final def synchronized[T0](arg0: ⇒ T0): T0

val threadPool: ExecutorService

The main thread pool used for executing fibers.

def toString(): String

final def unsafeRun[E, A](io: IO[E, A]): A

Effectfully and synchronously interprets an IO[E, A], either throwing an error, running forever, or producing an A.

final def unsafeRunAsync[E, A](io: IO[E, A])(k: Callback[E, A]): Unit

final def unsafeRunSync[E, A](io: IO[E, A]): ExitResult[E, A]

Effectfully interprets an IO, blocking if necessary to obtain the result.

final def unsafeShutdownAndWait(timeout: Duration): Unit

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit