object FunctionIO extends Serializable
- Alphabetic
- By Inheritance
- FunctionIO
- Serializable
- Serializable
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
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
- @native() @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 typeE
. -
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 specifiedE
. -
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
intoFunctionIO
. -
final
def
fromFunctionM[E, A, B](f: (A) ⇒ IO[E, B]): FunctionIO[E, A, B]
Lifts a pure
A => IO[E, B]
intoFunctionIO
. -
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
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 theA
to thethen0
function, but otherwise returns the originalA
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 theA
to thethen0
function, but otherwise returns the originalA
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 theA
to thethen0
function, but if the condition returns false, passes theA
to theelse0
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
- Annotations
- @native()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
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, returnsLeft(a)
, but if the condition returns false, returnsRight(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
- @native() @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 theA
through the body to yield a newA
, 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 theA
through the body to yield a newA
, which repeats until the condition returns false. This is theFunctionIO
equivalent of awhile(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