FunctionIO

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
final def _1[E, A, B]: FunctionIO[E, (A, B), A]

Returns an effectful function that extracts out the first element of a tuple.
final def _2[E, A, B]: FunctionIO[E, (A, B), B]

Returns an effectful function that extracts out the second element of a tuple.
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
final def compose[E, A, B, C](second: FunctionIO[E, B, C], first: FunctionIO[E, A, B]): FunctionIO[E, A, C]

See FunctionIO.compose
final def effect[E, A, B](catcher: PartialFunction[Throwable, E])(f: (A) ⇒ B): FunctionIO[E, A, B]

Lifts an impure function into FunctionIO, converting throwables into the specified error type E.
final def effectTotal[A, B](f: (A) ⇒ B): FunctionIO[Nothing, A, B]

Lifts an impure function into FunctionIO, assuming any throwables are non-recoverable and do not need to be converted into errors.
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
final def fail[E](e: E): FunctionIO[E, Any, Nothing]

Returns a FunctionIO representing a failure with the specified E.
def finalize(): Unit

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

See @FunctionIO.flatMap
final def fromFunction[A, B](f: (A) ⇒ B): FunctionIO[Nothing, A, B]

Lifts a pure A => B into FunctionIO.
final def fromFunctionM[E, A, B](f: (A) ⇒ IO[E, B]): FunctionIO[E, A, B]

Lifts a pure A => IO[E, B] into FunctionIO.
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
final def identity[A]: FunctionIO[Nothing, A, A]

Returns the identity effectful function, which performs no effects and merely returns its input unmodified.
final def ifNotThen[E, A](cond: FunctionIO[E, A, Boolean])(then0: FunctionIO[E, A, A]): FunctionIO[E, A, A]

Returns a new effectful function that passes an A to the condition, and if the condition returns false, passes the A to the then0 function, but otherwise returns the original A unmodified.
final def ifThen[E, A](cond: FunctionIO[E, A, Boolean])(then0: FunctionIO[E, A, A]): FunctionIO[E, A, A]

Returns a new effectful function that passes an A to the condition, and if the condition returns true, passes the A to the then0 function, but otherwise returns the original A unmodified.
final def ifThenElse[E, A, B](cond: FunctionIO[E, A, Boolean])(then0: FunctionIO[E, A, B])(else0: FunctionIO[E, A, B]): FunctionIO[E, A, B]

Returns a new effectful function that passes an A to the condition, and if the condition returns true, passes the A to the then0 function, but if the condition returns false, passes the A to the else0 function.
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def join[E, A, B, C](l: FunctionIO[E, A, B], r: FunctionIO[E, C, B]): FunctionIO[E, Either[A, C], B]

See FunctionIO.|||
final def left[E, A, B, C](k: FunctionIO[E, A, B]): FunctionIO[E, Either[A, C], Either[B, C]]

See FunctionIO.left
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
final def right[E, A, B, C](k: FunctionIO[E, A, B]): FunctionIO[E, Either[C, A], Either[C, B]]

See FunctionIO.left
final def succeed[B](b: B): FunctionIO[Nothing, Any, B]

Lifts a value into the monad formed by FunctionIO.
final def succeedLazy[B](b: ⇒ B): FunctionIO[Nothing, Any, B]

Lifts a non-strictly evaluated value into the monad formed by FunctionIO.
final def swap[E, A, B]: FunctionIO[E, (A, B), (B, A)]

Returns an effectful function that merely swaps the elements in a Tuple2.
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
final def test[E, A](k: FunctionIO[E, A, Boolean]): FunctionIO[E, A, Either[A, A]]

Returns a new effectful function that passes an A to the condition, and if the condition returns true, returns Left(a), but if the condition returns false, returns Right(a).
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( ... )
final def whileDo[E, A](check: FunctionIO[E, A, Boolean])(body: FunctionIO[E, A, A]): FunctionIO[E, A, A]

Returns a new effectful function that passes an A to the condition, and if the condition returns true, passes the A through the body to yield a new A, which repeats until the condition returns false.
Returns a new effectful function that passes an A to the condition, and if the condition returns true, passes the A through the body to yield a new A, which repeats until the condition returns false. This is the FunctionIO equivalent of a while(cond) { body } loop.
final def zipWith[E, A, B, C, D](l: FunctionIO[E, A, B], r: FunctionIO[E, A, C])(f: (B, C) ⇒ D): FunctionIO[E, A, D]

See FunctionIO.zipWith

Related Docs: trait FunctionIO | package zio

object FunctionIO extends Serializable

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def _1[E, A, B]: FunctionIO[E, (A, B), A]

final def _2[E, A, B]: FunctionIO[E, (A, B), B]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def compose[E, A, B, C](second: FunctionIO[E, B, C], first: FunctionIO[E, A, B]): FunctionIO[E, A, C]

final def effect[E, A, B](catcher: PartialFunction[Throwable, E])(f: (A) ⇒ B): FunctionIO[E, A, B]

final def effectTotal[A, B](f: (A) ⇒ B): FunctionIO[Nothing, A, B]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

final def fail[E](e: E): FunctionIO[E, Any, Nothing]

def finalize(): Unit

final def flatMap[E, A, B, C](fa: FunctionIO[E, A, B], f: (B) ⇒ FunctionIO[E, A, C]): FunctionIO[E, A, C]

final def fromFunction[A, B](f: (A) ⇒ B): FunctionIO[Nothing, A, B]

final def fromFunctionM[E, A, B](f: (A) ⇒ IO[E, B]): FunctionIO[E, A, B]

final def getClass(): Class[_]

def hashCode(): Int

final def identity[A]: FunctionIO[Nothing, A, A]

final def ifNotThen[E, A](cond: FunctionIO[E, A, Boolean])(then0: FunctionIO[E, A, A]): FunctionIO[E, A, A]

final def ifThen[E, A](cond: FunctionIO[E, A, Boolean])(then0: FunctionIO[E, A, A]): FunctionIO[E, A, A]

final def ifThenElse[E, A, B](cond: FunctionIO[E, A, Boolean])(then0: FunctionIO[E, A, B])(else0: FunctionIO[E, A, B]): FunctionIO[E, A, B]

final def isInstanceOf[T0]: Boolean

final def join[E, A, B, C](l: FunctionIO[E, A, B], r: FunctionIO[E, C, B]): FunctionIO[E, Either[A, C], B]

final def left[E, A, B, C](k: FunctionIO[E, A, B]): FunctionIO[E, Either[A, C], Either[B, C]]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final def right[E, A, B, C](k: FunctionIO[E, A, B]): FunctionIO[E, Either[C, A], Either[C, B]]

final def succeed[B](b: B): FunctionIO[Nothing, Any, B]

final def succeedLazy[B](b: ⇒ B): FunctionIO[Nothing, Any, B]

final def swap[E, A, B]: FunctionIO[E, (A, B), (B, A)]

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

final def test[E, A](k: FunctionIO[E, A, Boolean]): FunctionIO[E, A, Either[A, A]]

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

final def whileDo[E, A](check: FunctionIO[E, A, Boolean])(body: FunctionIO[E, A, A]): FunctionIO[E, A, A]

final def zipWith[E, A, B, C, D](l: FunctionIO[E, A, B], r: FunctionIO[E, A, C])(f: (B, C) ⇒ D): FunctionIO[E, A, D]

Inherited from Serializable

Inherited from Serializable

Inherited from AnyRef

Inherited from Any

Ungrouped