c

Always

final case classAlways[+A](f: () => A) extends Coeval[A] with Product with Serializable

Constructs a lazy Coeval instance.

This type can be used for "lazy" values. In some sense it is equivalent to using a Function0 value.

Source
Coeval.scala
Linear Supertypes
Product, Equals, Coeval[A], Serializable, () => A, AnyRef, Any
Ordering
1. Alphabetic
2. By Inheritance
Inherited
1. Always
2. Product
3. Equals
4. Coeval
5. Serializable
6. Function0
7. AnyRef
8. Any
1. Hide All
2. Show All
Visibility
1. Public
2. Protected

Instance Constructors

1. new Always(f: () => A)

Value Members

1. final def !=(arg0: Any)
Definition Classes
AnyRef → Any
2. final def ##(): Int
Definition Classes
AnyRef → Any
3. final def ==(arg0: Any)
Definition Classes
AnyRef → Any
4. final def >>[B](that: => Coeval[B]): Coeval[B]

Runs this underlying computation first and then, when successful, the given one.

Runs this underlying computation first and then, when successful, the given one. Returns the result of the given underlying computation.

Example:

```val combined = Coeval{println("first"); "first"} >> Coeval{println("second"); "second"}
// Prints "first" and then "second"
// Result value will be "second"```
Definition Classes
Coeval
5. def apply(): A

Evaluates the underlying computation and returns the result.

Evaluates the underlying computation and returns the result.

NOTE: this can throw exceptions.

```// For didactic purposes, don't do shared vars at home :-)
var i = 0
val fa = Coeval { i += 1; i }

fa() // => 1
fa() // => 2
fa() // => 3```

UNSAFE — this operation can trigger the execution of side effects, which break referential transparency and is thus not a pure function.

In FP code use with care, suspended in another `Coeval` or Task, or at the edge of the FP program.

Definition Classes
AlwaysCoeval → Function0
6. final def asInstanceOf[T0]: T0
Definition Classes
Any
7. final def attempt: Coeval[Either[Throwable, A]]

Creates a new Coeval that will expose any triggered error from the source.

Creates a new Coeval that will expose any triggered error from the source.

```val fa: Coeval[Int] =
Coeval.raiseError[Int](new RuntimeException("dummy"))

val fe: Coeval[Either[Throwable, Int]] =
fa.attempt

fe.map {
case Left(_) => Int.MaxValue
case Right(v) => v
}```

By exposing errors by lifting the `Coeval`'s result into an `Either` value, we can handle those errors in `flatMap` transformations.

Also see materialize for working with Scala's Try or redeemWith for an alternative.

Definition Classes
Coeval
8. final def bracket[B](use: (A) => Coeval[B])(release: (A) => Coeval[Unit]): Coeval[B]

Returns a task that treats the source as the acquisition of a resource, which is then exploited by the `use` function and then `released`.

Returns a task that treats the source as the acquisition of a resource, which is then exploited by the `use` function and then `released`.

The `bracket` operation is the equivalent of the `try {} finally {}` statements from mainstream languages, installing the necessary exception handler to release the resource in the event of an exception being raised during the computation. If an exception is raised, then `bracket` will re-raise the exception after performing the `release`.

Example:

```import java.io._

def readFile(file: File): Coeval[String] = {
// Opening a file handle for reading text
))

acquire.bracket { in =>
// Usage part
Coeval.eval {
// Yes, ugly Java, non-FP loop;
// side-effects are suspended though
var line: String = null
val buff = new StringBuilder()
do {
if (line != null) buff.append(line)
} while (line != null)
buff.toString()
}
} { in =>
// The release part
Coeval.eval(in.close())
}
}```

NOTE on error handling: one big difference versus `try {} finally {}` is that, in case both the `release` function and the `use` function throws, the error raised by `use` gets signaled and the error raised by `release` gets reported with `System.err` for Coeval or with Scheduler.reportFailure for Task.

For example:

```Coeval("resource").bracket { _ =>
// use
Coeval.raiseError(new RuntimeException("Foo"))
} { _ =>
// release
Coeval.raiseError(new RuntimeException("Bar"))
}```

In this case the error signaled downstream is `"Foo"`, while the `"Bar"` error gets reported. This is consistent with the behavior of Haskell's `bracket` operation and NOT with `try {} finally {}` from Scala, Java or JavaScript.

use

is a function that evaluates the resource yielded by the source, yielding a result that will get generated by the task returned by this `bracket` function

release

is a function that gets called after `use` terminates, either normally or in error, receiving as input the resource that needs to be released

Definition Classes
Coeval
9. final def bracketCase[B](use: (A) => Coeval[B])(release: (A, ExitCase[Throwable]) => Coeval[Unit]): Coeval[B]

Returns a new task that treats the source task as the acquisition of a resource, which is then exploited by the `use` function and then `released`, with the possibility of distinguishing between successful completion and failure, such that an appropriate release of resources can be executed.

Returns a new task that treats the source task as the acquisition of a resource, which is then exploited by the `use` function and then `released`, with the possibility of distinguishing between successful completion and failure, such that an appropriate release of resources can be executed.

The `bracketCase` operation is the equivalent of `try {} catch {} finally {}` statements from mainstream languages when used for the acquisition and release of resources.

The `bracketCase` operation installs the necessary exception handler to release the resource in the event of an exception being raised during the computation.

In comparison with the simpler bracket version, this one allows the caller to differentiate between normal termination and termination in error via an `ExitCase` parameter.

use

is a function that evaluates the resource yielded by the source, yielding a result that will get generated by this function on evaluation

release

is a function that gets called after `use` terminates, either normally or in error, receiving as input the resource that needs that needs release, along with the result of `use`

Definition Classes
Coeval
10. final def bracketE[B](use: (A) => Coeval[B])(release: (A, Either[Throwable, B]) => Coeval[Unit]): Coeval[B]

Returns a task that treats the source task as the acquisition of a resource, which is then exploited by the `use` function and then `released`, with the possibility of distinguishing between successful termination and error, such that an appropriate release of resources can be executed.

Returns a task that treats the source task as the acquisition of a resource, which is then exploited by the `use` function and then `released`, with the possibility of distinguishing between successful termination and error, such that an appropriate release of resources can be executed.

The `bracket` operation is the equivalent of the `try {} finally {}` statements from mainstream languages, installing the necessary exception handler to release the resource in the event of an exception being raised during the computation. If an exception is raised, then `bracket` will re-raise the exception after performing the `release`.

The `release` function receives as input:

• `Left(error)` in case `use` terminated with an error
• `Right(b)` in case of success

NOTE on error handling: one big difference versus `try {} finally {}` is that, in case both the `release` function and the `use` function throws, the error raised by `use` gets signaled and the error raised by `release` gets reported with `System.err` for Coeval or with Scheduler.reportFailure for Task.

For example:

```Coeval("resource").bracket { _ =>
// use
Coeval.raiseError(new RuntimeException("Foo"))
} { _ =>
// release
Coeval.raiseError(new RuntimeException("Bar"))
}```

In this case the error signaled downstream is `"Foo"`, while the `"Bar"` error gets reported. This is consistent with the behavior of Haskell's `bracket` operation and NOT with `try {} finally {}` from Scala, Java or JavaScript.

use

is a function that evaluates the resource yielded by the source, yielding a result that will get generated by this function on evaluation

release

is a function that gets called after `use` terminates, either normally or in error, receiving as input the resource that needs that needs release, along with the result of `use`

Definition Classes
Coeval
11. def clone()
Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.CloneNotSupportedException]) @native()
12. final def dematerialize[B](implicit ev: <:<[A, Try[B]]): Coeval[B]

Dematerializes the source's result from a `Try`.

Dematerializes the source's result from a `Try`.

This equivalence always holds:

`fa.materialize.dematerialize <-> fa`

Definition Classes
Coeval
13. final def doOnFinish(f: (Option[Throwable]) => Coeval[Unit]): Coeval[A]

Returns a new `Coeval` in which `f` is scheduled to be run on completion.

Returns a new `Coeval` in which `f` is scheduled to be run on completion. This would typically be used to release any resources acquired by this `Coeval`.

Definition Classes
Coeval
14. final def eq(arg0: AnyRef)
Definition Classes
AnyRef
15. val f: () => A
16. final def failed: Coeval[Throwable]

Returns a failed projection of this coeval.

Returns a failed projection of this coeval.

The failed projection is a `Coeval` holding a value of type `Throwable`, emitting the error yielded by the source, in case the source fails, otherwise if the source succeeds the result will fail with a `NoSuchElementException`.

Definition Classes
Coeval
17. def finalize(): Unit
Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.Throwable])
18. final def flatMap[B](f: (A) => Coeval[B]): Coeval[B]

Creates a new `Coeval` by applying a function to the successful result of the source, and returns a new instance equivalent to the result of the function.

Creates a new `Coeval` by applying a function to the successful result of the source, and returns a new instance equivalent to the result of the function.

The application of `flatMap` is always lazy and because of the implementation it is memory safe and thus it can be used in recursive loops.

Sample:

```import scala.util.Random

def randomEven: Coeval[Int] =
Coeval(Random.nextInt()).flatMap { x =>
if (x < 0 || x % 2 == 1)
randomEven // retry
else
Coeval.now(x)
}```
Definition Classes
Coeval
19. final def flatMapLoop[S](seed: S)(f: (A, S, (S) => Coeval[S]) => Coeval[S]): Coeval[S]

Describes flatMap-driven loops, as an alternative to recursive functions.

Describes flatMap-driven loops, as an alternative to recursive functions.

Sample:

```import scala.util.Random

val random = Coeval(Random.nextInt())
val loop = random.flatMapLoop(Vector.empty[Int]) { (a, list, continue) =>
val newList = list :+ a
if (newList.length < 5)
continue(newList)
else
Coeval.now(newList)
}```
seed

initializes the result of the loop

f

is the function that updates the result on each iteration, returning a `Coeval`.

returns

a new Coeval that contains the result of the loop.

Definition Classes
Coeval
20. final def flatten[B](implicit ev: <:<[A, Coeval[B]]): Coeval[B]

Given a source Coeval that emits another Coeval, this function flattens the result, returning a Coeval equivalent to the emitted Coeval by the source.

Given a source Coeval that emits another Coeval, this function flattens the result, returning a Coeval equivalent to the emitted Coeval by the source.

This equivalence with flatMap always holds:

`fa.flatten <-> fa.flatMap(x => x)`

Definition Classes
Coeval
21. final def foreach(f: (A) => Unit): Unit

Triggers the evaluation of the source, executing the given function for the generated element.

Triggers the evaluation of the source, executing the given function for the generated element.

The application of this function has strict behavior, as the coeval is immediately executed.

Definition Classes
Coeval
22. final def foreachL(f: (A) => Unit): Coeval[Unit]

Returns a new task that upon evaluation will execute the given function for the generated element, transforming the source into a `Coeval[Unit]`.

Returns a new task that upon evaluation will execute the given function for the generated element, transforming the source into a `Coeval[Unit]`.

Similar in spirit with normal foreach, but lazy, as obviously nothing gets executed at this point.

Definition Classes
Coeval
23. final def getClass(): Class[_ <: AnyRef]
Definition Classes
AnyRef → Any
Annotations
@native()
24. final def guarantee(finalizer: Coeval[Unit]): Coeval[A]

Executes the given `finalizer` when the source is finished, either in success or in error, or if canceled.

Executes the given `finalizer` when the source is finished, either in success or in error, or if canceled.

This variant of guaranteeCase evaluates the given `finalizer` regardless of how the source gets terminated:

• normal completion
• completion in error
• cancellation

As best practice, it's not a good idea to release resources via `guaranteeCase` in polymorphic code. Prefer bracket for the acquisition and release of resources.

Definition Classes
Coeval

guaranteeCase for the version that can discriminate between termination conditions

bracket for the more general operation

25. final def guaranteeCase(finalizer: (ExitCase[Throwable]) => Coeval[Unit]): Coeval[A]

Executes the given `finalizer` when the source is finished, either in success or in error, or if canceled, allowing for differentiating between exit conditions.

Executes the given `finalizer` when the source is finished, either in success or in error, or if canceled, allowing for differentiating between exit conditions.

This variant of guarantee injects an ExitCase in the provided function, allowing one to make a difference between:

• normal completion
• completion in error
• cancellation

As best practice, it's not a good idea to release resources via `guaranteeCase` in polymorphic code. Prefer bracketCase for the acquisition and release of resources.

Definition Classes
Coeval

guarantee for the simpler version

bracketCase for the more general operation

26. final def isInstanceOf[T0]
Definition Classes
Any
27. final def map[B](f: (A) => B): Coeval[B]

Returns a new `Coeval` that applies the mapping function to the element emitted by the source.

Returns a new `Coeval` that applies the mapping function to the element emitted by the source.

Can be used for specifying a (lazy) transformation to the result of the source.

This equivalence with flatMap always holds:

`fa.map(f) <-> fa.flatMap(x => Coeval.pure(f(x)))`

Definition Classes
Coeval
28. final def materialize: Coeval[Try[A]]

Creates a new Coeval that will expose any triggered error from the source.

Creates a new Coeval that will expose any triggered error from the source.

Also see attempt for working with Scala's Either or redeemWith for an alternative.

Definition Classes
Coeval
29. final def memoize: Coeval[A]

Memoizes (caches) the result of the source and reuses it on subsequent invocations of `value`.

Memoizes (caches) the result of the source and reuses it on subsequent invocations of `value`.

The resulting coeval will be idempotent, meaning that evaluating the resulting coeval multiple times will have the same effect as evaluating it once.

UNSAFE — this operation allocates a shared, mutable reference, which can break in certain cases referential transparency, even if this operation guarantees idempotency (i.e. referential transparency implies idempotency, but idempotency does not imply referential transparency).

The allocation of a mutable reference is known to be a side effect, thus breaking referential transparency, even if calling this method does not trigger the evaluation of side effects suspended by the source.

Use with care. Sometimes it's easier to just keep a shared, memoized reference to some connection, but keep in mind it might be better to pass such a reference around as a parameter.

Definition Classes
Coeval
Annotations
()

memoizeOnSuccess for a version that only caches successful results

30. final def memoizeOnSuccess: Coeval[A]

Memoizes (cache) the successful result of the source and reuses it on subsequent invocations of `value`.

Memoizes (cache) the successful result of the source and reuses it on subsequent invocations of `value`. Thrown exceptions are not cached.

The resulting coeval will be idempotent, but only if the result is successful.

UNSAFE — this operation allocates a shared, mutable reference, which can break in certain cases referential transparency, even if this operation guarantees idempotency (i.e. referential transparency implies idempotency, but idempotency does not imply referential transparency).

The allocation of a mutable reference is known to be a side effect, thus breaking referential transparency, even if calling this method does not trigger the evaluation of side effects suspended by the source.

Use with care. Sometimes it's easier to just keep a shared, memoized reference to some connection, but keep in mind it might be better to pass such a reference around as a parameter.

Definition Classes
Coeval
Annotations
()

memoize for a version that caches both successful results and failures

31. final def ne(arg0: AnyRef)
Definition Classes
AnyRef
32. final def notify(): Unit
Definition Classes
AnyRef
Annotations
@native()
33. final def notifyAll(): Unit
Definition Classes
AnyRef
Annotations
@native()
34. final def onErrorFallbackTo[B >: A](that: Coeval[B]): Coeval[B]

Creates a new coeval that in case of error will fallback to the given backup coeval.

Creates a new coeval that in case of error will fallback to the given backup coeval.

Definition Classes
Coeval
35. final def onErrorHandle[U >: A](f: (Throwable) => U): Coeval[U]

Creates a new coeval that will handle any matching throwable that this coeval might emit.

Creates a new coeval that will handle any matching throwable that this coeval might emit.

See onErrorRecover for the version that takes a partial function.

Definition Classes
Coeval
36. final def onErrorHandleWith[B >: A](f: (Throwable) => Coeval[B]): Coeval[B]

Creates a new coeval that will handle any matching throwable that this coeval might emit by executing another coeval.

Creates a new coeval that will handle any matching throwable that this coeval might emit by executing another coeval.

See onErrorRecoverWith for the version that takes a partial function.

Definition Classes
Coeval
37. final def onErrorRecover[U >: A](pf: PartialFunction[Throwable, U]): Coeval[U]

Creates a new coeval that on error will try to map the error to another value using the provided partial function.

Creates a new coeval that on error will try to map the error to another value using the provided partial function.

See onErrorHandle for the version that takes a total function.

Definition Classes
Coeval
38. final def onErrorRecoverWith[B >: A](pf: PartialFunction[Throwable, Coeval[B]]): Coeval[B]

Creates a new coeval that will try recovering from an error by matching it with another coeval using the given partial function.

Creates a new coeval that will try recovering from an error by matching it with another coeval using the given partial function.

See onErrorHandleWith for the version that takes a total function.

Definition Classes
Coeval
39. final def onErrorRestart(maxRetries: Long): Coeval[A]

Creates a new coeval that in case of error will retry executing the source again and again, until it succeeds.

Creates a new coeval that in case of error will retry executing the source again and again, until it succeeds.

In case of continuous failure the total number of executions will be `maxRetries + 1`.

Definition Classes
Coeval
40. final def onErrorRestartIf(p: (Throwable) => Boolean): Coeval[A]

Creates a new coeval that in case of error will retry executing the source again and again, until it succeeds.

Creates a new coeval that in case of error will retry executing the source again and again, until it succeeds.

In case of continuous failure the total number of executions will be `maxRetries + 1`.

Definition Classes
Coeval
41. final def onErrorRestartLoop[S, B >: A](initial: S)(f: (Throwable, S, (S) => Coeval[B]) => Coeval[B]): Coeval[B]

On error restarts the source with a customizable restart loop.

On error restarts the source with a customizable restart loop.

This operation keeps an internal `state`, with a start value, an internal state that gets evolved and based on which the next step gets decided, e.g. should it restart, or should it give up and rethrow the current error.

Example that implements a simple retry policy that retries for a maximum of 10 times before giving up:

```import scala.util.Random

val fa = Coeval {
if (Random.nextInt(20) > 10)
throw new RuntimeException("boo")
else 78
}

fa.onErrorRestartLoop(10) { (err, maxRetries, retry) =>
if (maxRetries > 0)
retry(maxRetries - 1)
else
// No retries left, rethrow the error
Coeval.raiseError(err)
}```

The given function injects the following parameters:

1. `error` reference that was thrown 2. the current `state`, based on which a decision for the retry is made 3. `retry: S => Task[B]` function that schedules the next retry
initial

is the initial state used to determine the next on error retry cycle

f

is a function that injects the current error, state, a function that can signal a retry is to be made and returns the next coeval

Definition Classes
Coeval
42. def productElementNames: Iterator[String]
Definition Classes
Product
43. def redeem[B](recover: (Throwable) => B, map: (A) => B): Coeval[B]

Returns a new value that transforms the result of the source, given the `recover` or `map` functions, which get executed depending on whether the result is successful or if it ends in error.

Returns a new value that transforms the result of the source, given the `recover` or `map` functions, which get executed depending on whether the result is successful or if it ends in error.

This is an optimization on usage of attempt and map, this equivalence being true:

`coeval.redeem(recover, map) <-> coeval.attempt.map(_.fold(recover, map))`

Usage of `redeem` subsumes onErrorHandle because:

`coeval.redeem(fe, id) <-> coeval.onErrorHandle(fe)`

recover

is a function used for error recover in case the source ends in error

map

is a function used for mapping the result of the source in case it ends in success

Definition Classes
Coeval
44. def redeemWith[B](recover: (Throwable) => Coeval[B], bind: (A) => Coeval[B]): Coeval[B]

Returns a new value that transforms the result of the source, given the `recover` or `bind` functions, which get executed depending on whether the result is successful or if it ends in error.

Returns a new value that transforms the result of the source, given the `recover` or `bind` functions, which get executed depending on whether the result is successful or if it ends in error.

This is an optimization on usage of attempt and flatMap, this equivalence being available:

`coeval.redeemWith(recover, bind) <-> coeval.attempt.flatMap(_.fold(recover, bind))`

Usage of `redeemWith` subsumes onErrorHandleWith because:

`coeval.redeemWith(fe, F.pure) <-> coeval.onErrorHandleWith(fe)`

Usage of `redeemWith` also subsumes flatMap because:

`coeval.redeemWith(Coeval.raiseError, fs) <-> coeval.flatMap(fs)`

recover

is the function that gets called to recover the source in case of error

bind

is the function that gets to transform the source in case of success

Definition Classes
Coeval
45. final def restartUntil(p: (A) => Boolean): Coeval[A]

Given a predicate function, keep retrying the coeval until the function returns true.

Given a predicate function, keep retrying the coeval until the function returns true.

Definition Classes
Coeval
46. def run(): Eager[A]

Evaluates the underlying computation, reducing this `Coeval` to a Coeval.Eager value, with successful results being signaled with Coeval.Now and failures with Coeval.Error.

Evaluates the underlying computation, reducing this `Coeval` to a Coeval.Eager value, with successful results being signaled with Coeval.Now and failures with Coeval.Error.

```val fa = Coeval.eval(10 * 2)

fa.run match {
case Coeval.Now(value) =>
println("Success: " + value)
case Coeval.Error(e) =>
e.printStackTrace()
}```

See runAttempt for working with Either values and runTry for working with Try values. See apply for a partial function (that may throw exceptions in case of failure).

UNSAFE — this operation can trigger the execution of side effects, which break referential transparency and is thus not a pure function.

In FP code use with care, suspended in another `Coeval` or Task, or at the edge of the FP program.

Definition Classes
AlwaysCoeval
47. def runAttempt(): Either[Throwable, A]

Evaluates the underlying computation and returns the result or any triggered errors as a Scala `Either`, where `Right(_)` is for successful values and `Left(_)` is for thrown errors.

Evaluates the underlying computation and returns the result or any triggered errors as a Scala `Either`, where `Right(_)` is for successful values and `Left(_)` is for thrown errors.

```val fa = Coeval(10 * 2)

fa.runAttempt match {
case Right(value) =>
println("Success: " + value)
case Left(e) =>
e.printStackTrace()
}```

See run for working with Coeval.Eager values and runTry for working with Try values. See apply for a partial function (that may throw exceptions in case of failure).

UNSAFE — this operation can trigger the execution of side effects, which break referential transparency and is thus not a pure function.

In FP code use with care, suspended in another `Coeval` or Task, or at the edge of the FP program.

Definition Classes
AlwaysCoeval
48. def runTry(): Try[A]

Evaluates the underlying computation and returns the result or any triggered errors as a `scala.util.Try`.

Evaluates the underlying computation and returns the result or any triggered errors as a `scala.util.Try`.

```import scala.util._

val fa = Coeval(10 * 2)

fa.runTry match {
case Success(value) =>
println("Success: " + value)
case Failure(e) =>
e.printStackTrace()
}```

See run for working with Coeval.Eager values and runAttempt for working with Either values. See apply for a partial function (that may throw exceptions in case of failure).

UNSAFE — this operation can trigger the execution of side effects, which break referential transparency and is thus not a pure function.

In FP code use with care, suspended in another `Coeval` or Task, or at the edge of the FP program.

Definition Classes
AlwaysCoeval
49. final def synchronized[T0](arg0: => T0): T0
Definition Classes
AnyRef
50. final def to[F[_]](implicit F: CoevalLift[F]): F[A]

Converts the source Coeval into any `F[_]` that implements `cats.effect.Sync`.

Converts the source Coeval into any `F[_]` that implements `cats.effect.Sync`.

For example it can work with `cats.effect.IO`:

```import cats._
import cats.effect._

val source = Coeval { 1 + 1 }

val asIO: IO[Int]     = source.to[IO]
val asEval: Eval[Int] = source.to[Eval]
Definition Classes
Coeval
51. def toString(): String
Definition Classes
Coeval → Function0 → AnyRef → Any
52. final def toSync[F[_]](implicit F: Sync[F]): F[A]

Converts the source to any value that implements `cats.effect.Sync`.

Converts the source to any value that implements `cats.effect.Sync`.

Prefer to use to, this method is provided in order to force the usage of `cats.effect.Sync` instances (instead of CoevalLift).

Definition Classes
Coeval
53. def value(): A

Evaluates the underlying computation and returns the result.

Evaluates the underlying computation and returns the result.

NOTE: this can throw exceptions.

Alias for apply.

UNSAFE — this operation can trigger the execution of side effects, which break referential transparency and is thus not a pure function.

In FP code use with care, suspended in another `Coeval` or Task, or at the edge of the FP program.

Definition Classes
Coeval
Annotations
()
54. final def void: Coeval[Unit]

Returns this coeval mapped to unit

Returns this coeval mapped to unit

Definition Classes
Coeval
55. final def wait(): Unit
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.InterruptedException])
56. final def wait(arg0: Long, arg1: Int): Unit
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.InterruptedException])
57. final def wait(arg0: Long): Unit
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.InterruptedException]) @native()
58. final def zip[B](that: Coeval[B]): Coeval[(A, B)]

Zips the values of `this` and `that` coeval, and creates a new coeval that will emit the tuple of their results.

Zips the values of `this` and `that` coeval, and creates a new coeval that will emit the tuple of their results.

Definition Classes
Coeval
59. final def zipMap[B, C](that: Coeval[B])(f: (A, B) => C): Coeval[C]

Zips the values of `this` and `that` and applies the given mapping function on their results.

Zips the values of `this` and `that` and applies the given mapping function on their results.

Definition Classes
Coeval

Deprecated Value Members

1. final def transform[R](fa: (A) => R, fe: (Throwable) => R): Coeval[R]

Coeval.redeem is the same operation, but with a different name and the function parameters in an inverted order, to make it consistent with `fold` on `Either` and others (i.e. the function for error recovery is at the left).

Definition Classes
Coeval
Annotations
@deprecated
Deprecated

(Since version 3.0.0-RC2) Please use `Coeval.redeem`

2. final def transformWith[R](fa: (A) => Coeval[R], fe: (Throwable) => Coeval[R]): Coeval[R]

Coeval.redeemWith is the same operation, but with a different name and the function parameters in an inverted order, to make it consistent with `fold` on `Either` and others (i.e. the function for error recovery is at the left).

Definition Classes
Coeval
Annotations
@deprecated
Deprecated

(Since version 3.0.0-RC2) Please use `Coeval.redeemWith`