FunctionIO

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

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

def clone(): AnyRef

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

def equals(arg0: Any): Boolean

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

Returns a FunctionIO representing a failure with the specified E.

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]

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[_]

def hashCode(): Int

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

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

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]]

See FunctionIO.left

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

Lifts a 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

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

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]

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.

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

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