IO - molecule.io.IO

Instance Constructors

new IO(ask: (UThreadContext, (A) ⇒ Unit) ⇒ Unit)

ask
function called to "execute" or "ask for" the result of the IO action.

Value Members

final def !=(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def !=(arg0: Any): Boolean

Definition Classes
Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def $[B](f: (A) ⇒ B): IO[B]

Apply a function to the result of this action.
Apply a function to the result of this action.
B
the type of the resulting action.
f
the function to apply.
returns
the transformed action.

Annotations
@inline()
final def <~[B](next: ⇒ IO[B]): IO[A]

Sequence an action after this one and return the result of this action.
Sequence an action after this one and return the result of this action.
B
the type of the next action.
next
the next action.
returns
the result of this action.
final def <~\[B](react: (A) ⇒ IO[B]): IO[A]

An operator that acts like bind but returns the result of the previous action.
An operator that acts like bind but returns the result of the previous action.
B
the type of the next action.
react
the function used to create the next action.
returns
the result of the previous action.
final def ==(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def ==(arg0: Any): Boolean

Definition Classes
Any
final def >>[B](next: ⇒ IO[B]): IO[B]

Operator equivalent to andThen.
Operator equivalent to andThen.
B
the type of the next action.
next
the next action.
returns
the result of the next action.

Annotations
@inline()
def >>&[B](next: ⇒ IO[B]): IO[A]

Sequence to unrelated actions and return the result of the first action.
Sequence to unrelated actions and return the result of the first action.
B
the type of the next action.
next
the next action.
returns
the result of the first action.
def >>&\[B](react: (A) ⇒ IO[B]): IO[A]

An operator that acts like bind but returns the result of the previous action.
An operator that acts like bind but returns the result of the previous action.
B
the type of the next action.
react
the function used to create the next action.
returns
the result of the previous action.
final def >>\[B](react: (A) ⇒ IO[B]): IO[B]

The monadic bind operator.
The monadic bind operator.
B
the type of the next action.
react
the function used to create the next action.
returns
the next action.

Annotations
@inline()
final def andThen[B](next: ⇒ IO[B]): IO[B]

Sequence an action after this one and return the result of that action.
Sequence an action after this one and return the result of that action.
B
the type of the next action.
next
the next action.
returns
the result of the next action.

Annotations
@inline()
final def asInstanceOf[T0]: T0

Definition Classes
Any
def bind[B](react: (A) ⇒ IO[B]): IO[B]

Bind the result of this action to the argument of a function resulting in the next IO action to execute.
Bind the result of this action to the argument of a function resulting in the next IO action to execute. In other words, the new action created by bind passes control to the action created as a reaction to the result of the current action.
B
the type of the next action.
react
the function used to create the next action.
returns
the next action.
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def filter(p: (A) ⇒ Boolean): IO[A]

Function required by Scala for pattern matching
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def flatMap[B](f: (A) ⇒ IO[B]): IO[B]

Same as bind
Same as bind

Annotations
@inline()
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def map[B](f: (A) ⇒ B): IO[B]

Apply a function to the result of this action.
Apply a function to the result of this action.
B
the type of the resulting action.
f
the function to apply.
returns
the transformed action.
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def orCatch[B >: A](f: PartialFunction[Signal, IO[B]]): IO[B]

Execute an action or catch a user-level exception raised by this action.
Execute an action or catch a user-level exception raised by this action. If a user-level exception is thrown, any resource dynamically acquired by this action is shutdown. Then, if its signal matches a signal for which the partial function is defined the action results in the action defined by the partial function handler. Otherwise, the signal is propageted further in the parent's context.
f
the partial function invoked if a user-level exception occurs.
returns
a managed action.
def par[B](other: IO[B])(implicit ma: Message[A], mb: Message[B]): IO[~[A, B]]

Interleave the execution of this action with the execution of another action.
Interleave the execution of this action with the execution of another action.
other
the other action
returns
the pair of both results (implicit conversions allow to match ~ as a tuple, otherwise use flatten x methods).
def seq[B](next: IO[B]): IO[~[A, B]]

Sequence an action after this one and return a pair containing the results of both actions.
Sequence an action after this one and return a pair containing the results of both actions.
B
the type of the next action.
next
the next action.
returns
the pair with both results (implicit conversions allow to match ~ as a tuple, otherwise use flatten x methods).
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
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( ... )
def |*|[B](action: IO[B])(implicit ma: Message[A], mb: Message[B]): IO[Unit]

Same as par but discard the result.
Same as par but discard the result.
action
the other action.
returns
an action that returns Unit after both actions have terminated.
def |~|[B](other: IO[B])(implicit ma: Message[A], mb: Message[B]): IO[~[A, B]]

Operator for par.
Operator for par.
returns
an action that returns the results of both actions in a pair.
final def ~[B](next: IO[B]): IO[~[A, B]]

Sequence an action after this one and return a pair containing the results of both actions.
Sequence an action after this one and return a pair containing the results of both actions.
B
the type of the next action.
next
the next action.
returns
the pair with both results (implicit conversions allow to match ~ as a tuple, otherwise use flatten x methods).

Annotations
@inline()
final def ~>[B](next: ⇒ IO[B]): IO[B]

Sequence an action after this one and return the result of that action.
Sequence an action after this one and return the result of that action.
B
the type of the next action.
next
the next action.
returns
the result of the next action.

Annotations
@inline()
final def ~>\[B](f: (A) ⇒ IO[B]): IO[B]

Same as bind
Same as bind

Annotations
@inline()

IO

final class IO[+A] extends AnyRef

Instance Constructors

new IO(ask: (UThreadContext, (A) ⇒ Unit) ⇒ Unit)

Value Members

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def $[B](f: (A) ⇒ B): IO[B]

final def <~[B](next: ⇒ IO[B]): IO[A]

final def <~\[B](react: (A) ⇒ IO[B]): IO[A]

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

final def >>[B](next: ⇒ IO[B]): IO[B]

def >>&[B](next: ⇒ IO[B]): IO[A]

def >>&\[B](react: (A) ⇒ IO[B]): IO[A]

final def >>\[B](react: (A) ⇒ IO[B]): IO[B]

final def andThen[B](next: ⇒ IO[B]): IO[B]

final def asInstanceOf[T0]: T0

def bind[B](react: (A) ⇒ IO[B]): IO[B]

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def filter(p: (A) ⇒ Boolean): IO[A]

def finalize(): Unit

final def flatMap[B](f: (A) ⇒ IO[B]): IO[B]

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def map[B](f: (A) ⇒ B): IO[B]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def orCatch[B >: A](f: PartialFunction[Signal, IO[B]]): IO[B]

def par[B](other: IO[B])(implicit ma: Message[A], mb: Message[B]): IO[~[A, B]]

def seq[B](next: IO[B]): IO[~[A, B]]

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

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def |*|[B](action: IO[B])(implicit ma: Message[A], mb: Message[B]): IO[Unit]

def |~|[B](other: IO[B])(implicit ma: Message[A], mb: Message[B]): IO[~[A, B]]

final def ~[B](next: IO[B]): IO[~[A, B]]

final def ~>[B](next: ⇒ IO[B]): IO[B]

final def ~>\[B](f: (A) ⇒ IO[B]): IO[B]

Inherited from AnyRef

Inherited from Any

Ungrouped