Packages

object FunctionIO extends Serializable

Linear Supertypes
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. FunctionIO
  2. Serializable
  3. Serializable
  4. AnyRef
  5. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. final def _1[E, A, B]: FunctionIO[E, (A, B), A]

    Returns an effectful function that extracts out the first element of a tuple.

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

    Returns an effectful function that extracts out the second element of a tuple.

  6. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  7. def clone(): AnyRef
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @native() @throws( ... )
  8. final def compose[E, A, B, C](second: FunctionIO[E, B, C], first: FunctionIO[E, A, B]): FunctionIO[E, A, C]

    See FunctionIO.compose

  9. 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.

  10. 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.

  11. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  12. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  13. final def fail[E](e: E): FunctionIO[E, Any, Nothing]

    Returns a FunctionIO representing a failure with the specified E.

  14. def finalize(): Unit
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  15. 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

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

    Lifts a pure A => B into FunctionIO.

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

    Lifts a pure A => IO[E, B] into FunctionIO.

  18. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  19. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  20. final def identity[A]: FunctionIO[Nothing, A, A]

    Returns the identity effectful function, which performs no effects and merely returns its input unmodified.

  21. 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.

  22. 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.

  23. 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.

  24. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  25. 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.|||

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

    See FunctionIO.left

  27. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  28. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  29. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  30. final def right[E, A, B, C](k: FunctionIO[E, A, B]): FunctionIO[E, Either[C, A], Either[C, B]]

    See FunctionIO.left

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

    Lifts a value into the monad formed by FunctionIO.

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

    Lifts a non-strictly evaluated value into the monad formed by FunctionIO.

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

    Returns an effectful function that merely swaps the elements in a Tuple2.

  34. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  35. 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).

  36. def toString(): String
    Definition Classes
    AnyRef → Any
  37. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  38. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  39. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @throws( ... )
  40. 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.

  41. 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

Inherited from Serializable

Inherited from Serializable

Inherited from AnyRef

Inherited from Any

Ungrouped