Coeval

Type Members

final case class Always[+A](f: () ⇒ A) extends Coeval[A] with Product with Serializable

Constructs a lazy Coeval instance.
Constructs a lazy Coeval instance.
This type can be used for "lazy" values. In some sense it is equivalent to using a Function0 value.
sealed abstract class Attempt[+A] extends Coeval[A] with Product

The Attempt represents a strict, already evaluated result of a Coeval that either resulted in success, wrapped in a Now, or in an error, wrapped in a Error.
The Attempt represents a strict, already evaluated result of a Coeval that either resulted in success, wrapped in a Now, or in an error, wrapped in a Error.
It's the moral equivalent of scala.util.Try.
final case class Error(ex: Throwable) extends Attempt[Nothing] with Product with Serializable

Constructs an eager Coeval instance for a result that represents an error.
final case class Now[+A](value: A) extends Attempt[A] with Product with Serializable

Constructs an eager Coeval instance from a strict value that's already known.
final class Once[+A] extends Coeval[A] with () ⇒ A

Constructs a lazy Coeval instance that gets evaluated only once.
Constructs a lazy Coeval instance that gets evaluated only once.
In some sense it is equivalent to using a lazy val. When caching is not required or desired, prefer Always or Now.
class TypeClassInstances extends DeferrableClass[Coeval] with MemoizableClass[Coeval] with RecoverableClass[Coeval, Throwable] with ComonadClass[Coeval] with MonadRecClass[Coeval]

Groups the implementation for the type-classes defined in monix.types.
type EvalAlways[+A] = Always[A]

Annotations
@deprecated
Deprecated
(Since version 2.0-RC12) Type renamed, use Eval.Always
type EvalOnce[+A] = Once[A]

Annotations
@deprecated
Deprecated
(Since version 2.0-RC12) Type renamed, use Eval.Once

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
object Attempt extends Serializable
object Once extends Serializable
def apply[A](f: ⇒ A): Coeval[A]

Promotes a non-strict value to a Coeval.
Promotes a non-strict value to a Coeval.
Alias of eval.
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def defer[A](fa: ⇒ Coeval[A]): Coeval[A]

Promote a non-strict value representing a Coeval to a Coeval of the same type.
def delay[A](a: ⇒ A): Coeval[A]

Alias for eval.
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
def eval[A](a: ⇒ A): Coeval[A]

Promote a non-strict value to an Coeval, catching exceptions in the process.
Promote a non-strict value to an Coeval, catching exceptions in the process.
Note that since Coeval is not memoized, this will recompute the value each time the Coeval is executed.
def evalOnce[A](a: ⇒ A): Coeval[A]

Promote a non-strict value to a Coeval that is memoized on the first evaluation, the result being then available on subsequent evaluations.
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def fromTry[A](a: Try[A]): Coeval[A]

Builds a Coeval out of a Scala Try value.
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def now[A](a: A): Coeval[A]

Returns an Coeval that on execution is always successful, emitting the given strict value.
def pure[A](a: A): Coeval[A]

Lifts a value into the coeval context.
Lifts a value into the coeval context. Alias for now.
def raiseError[A](ex: Throwable): Coeval[A]

Returns an Coeval that on execution is always finishing in error emitting the specified exception.
def sequence[A, M[X] <: TraversableOnce[X]](sources: M[Coeval[A]])(implicit cbf: CanBuildFrom[M[Coeval[A]], A, M[A]]): Coeval[M[A]]

Transforms a TraversableOnce of coevals into a coeval producing the same collection of gathered results.
Transforms a TraversableOnce of coevals into a coeval producing the same collection of gathered results.
It's a simple version of traverse.
def suspend[A](fa: ⇒ Coeval[A]): Coeval[A]

Alias for defer.
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
def traverse[A, B, M[X] <: TraversableOnce[X]](sources: M[A])(f: (A) ⇒ Coeval[B])(implicit cbf: CanBuildFrom[M[A], B, M[B]]): Coeval[M[B]]

Transforms a TraversableOnce[A] into a coeval of the same collection using the provided function A => Coeval[B].
Transforms a TraversableOnce[A] into a coeval of the same collection using the provided function A => Coeval[B].
It's a generalized version of sequence.
implicit val typeClassInstances: TypeClassInstances

Implicit type-class instances of Coeval.
val unit: Coeval[Unit]

A Coeval[Unit] provided for convenience.
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( ... )
def zip2[A1, A2, R](fa1: Coeval[A1], fa2: Coeval[A2]): Coeval[(A1, A2)]

Pairs two Coeval instances.
def zip3[A1, A2, A3](fa1: Coeval[A1], fa2: Coeval[A2], fa3: Coeval[A3]): Coeval[(A1, A2, A3)]

Pairs three Coeval instances.
def zip4[A1, A2, A3, A4](fa1: Coeval[A1], fa2: Coeval[A2], fa3: Coeval[A3], fa4: Coeval[A4]): Coeval[(A1, A2, A3, A4)]

Pairs four Coeval instances.
def zip5[A1, A2, A3, A4, A5](fa1: Coeval[A1], fa2: Coeval[A2], fa3: Coeval[A3], fa4: Coeval[A4], fa5: Coeval[A5]): Coeval[(A1, A2, A3, A4, A5)]

Pairs five Coeval instances.
def zip6[A1, A2, A3, A4, A5, A6](fa1: Coeval[A1], fa2: Coeval[A2], fa3: Coeval[A3], fa4: Coeval[A4], fa5: Coeval[A5], fa6: Coeval[A6]): Coeval[(A1, A2, A3, A4, A5, A6)]

Pairs six Coeval instances.
def zipList[A](sources: Coeval[A]*): Coeval[List[A]]

Zips together multiple Coeval instances.
def zipMap2[A1, A2, R](fa1: Coeval[A1], fa2: Coeval[A2])(f: (A1, A2) ⇒ R): Coeval[R]

Pairs two Coeval instances, creating a new instance that will apply the given mapping function to the resulting pair.
def zipMap3[A1, A2, A3, R](fa1: Coeval[A1], fa2: Coeval[A2], fa3: Coeval[A3])(f: (A1, A2, A3) ⇒ R): Coeval[R]

Pairs three Coeval instances, applying the given mapping function to the result.
def zipMap4[A1, A2, A3, A4, R](fa1: Coeval[A1], fa2: Coeval[A2], fa3: Coeval[A3], fa4: Coeval[A4])(f: (A1, A2, A3, A4) ⇒ R): Coeval[R]

Pairs four Coeval instances, applying the given mapping function to the result.
def zipMap5[A1, A2, A3, A4, A5, R](fa1: Coeval[A1], fa2: Coeval[A2], fa3: Coeval[A3], fa4: Coeval[A4], fa5: Coeval[A5])(f: (A1, A2, A3, A4, A5) ⇒ R): Coeval[R]

Pairs five Coeval instances, applying the given mapping function to the result.
def zipMap6[A1, A2, A3, A4, A5, A6, R](fa1: Coeval[A1], fa2: Coeval[A2], fa3: Coeval[A3], fa4: Coeval[A4], fa5: Coeval[A5], fa6: Coeval[A6])(f: (A1, A2, A3, A4, A5, A6) ⇒ R): Coeval[R]

Pairs six Coeval instances, applying the given mapping function to the result.

Deprecated Value Members

def evalAlways[A](a: ⇒ A): Coeval[A]

Alias for eval.
Alias for eval. Deprecated.

Annotations
@deprecated
Deprecated
(Since version 2.0-RC12) Renamed, please use Coeval.apply or Coeval.eval
def zipWith2[A1, A2, R](fa1: Coeval[A1], fa2: Coeval[A2])(f: (A1, A2) ⇒ R): Coeval[R]

Annotations
@deprecated
Deprecated
(Since version 2.0-RC12) Renamed to Coeval.zipMap2
def zipWith3[A1, A2, A3, R](fa1: Coeval[A1], fa2: Coeval[A2], fa3: Coeval[A3])(f: (A1, A2, A3) ⇒ R): Coeval[R]

Annotations
@deprecated
Deprecated
(Since version 2.0-RC12) Renamed to Coeval.zipMap3
def zipWith4[A1, A2, A3, A4, R](fa1: Coeval[A1], fa2: Coeval[A2], fa3: Coeval[A3], fa4: Coeval[A4])(f: (A1, A2, A3, A4) ⇒ R): Coeval[R]

Annotations
@deprecated
Deprecated
(Since version 2.0-RC12) Renamed to Coeval.zipMap4
def zipWith5[A1, A2, A3, A4, A5, R](fa1: Coeval[A1], fa2: Coeval[A2], fa3: Coeval[A3], fa4: Coeval[A4], fa5: Coeval[A5])(f: (A1, A2, A3, A4, A5) ⇒ R): Coeval[R]

Annotations
@deprecated
Deprecated
(Since version 2.0-RC12) Renamed to Coeval.zipMap5
def zipWith6[A1, A2, A3, A4, A5, A6, R](fa1: Coeval[A1], fa2: Coeval[A2], fa3: Coeval[A3], fa4: Coeval[A4], fa5: Coeval[A5], fa6: Coeval[A6])(f: (A1, A2, A3, A4, A5, A6) ⇒ R): Coeval[R]

Annotations
@deprecated
Deprecated
(Since version 2.0-RC12) Renamed to Coeval.zipMap6

Related Docs: class Coeval | package eval

object Coeval extends Serializable

Type Members

final case class Always[+A](f: () ⇒ A) extends Coeval[A] with Product with Serializable

sealed abstract class Attempt[+A] extends Coeval[A] with Product

final case class Error(ex: Throwable) extends Attempt[Nothing] with Product with Serializable

final case class Now[+A](value: A) extends Attempt[A] with Product with Serializable

final class Once[+A] extends Coeval[A] with () ⇒ A

class TypeClassInstances extends DeferrableClass[Coeval] with MemoizableClass[Coeval] with RecoverableClass[Coeval, Throwable] with ComonadClass[Coeval] with MonadRecClass[Coeval]

type EvalAlways[+A] = Always[A]

type EvalOnce[+A] = Once[A]

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

object Attempt extends Serializable

object Once extends Serializable

def apply[A](f: ⇒ A): Coeval[A]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def defer[A](fa: ⇒ Coeval[A]): Coeval[A]

def delay[A](a: ⇒ A): Coeval[A]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def eval[A](a: ⇒ A): Coeval[A]

def evalOnce[A](a: ⇒ A): Coeval[A]

def finalize(): Unit

def fromTry[A](a: Try[A]): Coeval[A]

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def now[A](a: A): Coeval[A]

def pure[A](a: A): Coeval[A]

def raiseError[A](ex: Throwable): Coeval[A]

def sequence[A, M[X] <: TraversableOnce[X]](sources: M[Coeval[A]])(implicit cbf: CanBuildFrom[M[Coeval[A]], A, M[A]]): Coeval[M[A]]

def suspend[A](fa: ⇒ Coeval[A]): Coeval[A]

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

def toString(): String

def traverse[A, B, M[X] <: TraversableOnce[X]](sources: M[A])(f: (A) ⇒ Coeval[B])(implicit cbf: CanBuildFrom[M[A], B, M[B]]): Coeval[M[B]]

implicit val typeClassInstances: TypeClassInstances

val unit: Coeval[Unit]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def zip2[A1, A2, R](fa1: Coeval[A1], fa2: Coeval[A2]): Coeval[(A1, A2)]

def zip3[A1, A2, A3](fa1: Coeval[A1], fa2: Coeval[A2], fa3: Coeval[A3]): Coeval[(A1, A2, A3)]

def zip4[A1, A2, A3, A4](fa1: Coeval[A1], fa2: Coeval[A2], fa3: Coeval[A3], fa4: Coeval[A4]): Coeval[(A1, A2, A3, A4)]

def zip5[A1, A2, A3, A4, A5](fa1: Coeval[A1], fa2: Coeval[A2], fa3: Coeval[A3], fa4: Coeval[A4], fa5: Coeval[A5]): Coeval[(A1, A2, A3, A4, A5)]

def zip6[A1, A2, A3, A4, A5, A6](fa1: Coeval[A1], fa2: Coeval[A2], fa3: Coeval[A3], fa4: Coeval[A4], fa5: Coeval[A5], fa6: Coeval[A6]): Coeval[(A1, A2, A3, A4, A5, A6)]

def zipList[A](sources: Coeval[A]*): Coeval[List[A]]

def zipMap2[A1, A2, R](fa1: Coeval[A1], fa2: Coeval[A2])(f: (A1, A2) ⇒ R): Coeval[R]

def zipMap3[A1, A2, A3, R](fa1: Coeval[A1], fa2: Coeval[A2], fa3: Coeval[A3])(f: (A1, A2, A3) ⇒ R): Coeval[R]

def zipMap4[A1, A2, A3, A4, R](fa1: Coeval[A1], fa2: Coeval[A2], fa3: Coeval[A3], fa4: Coeval[A4])(f: (A1, A2, A3, A4) ⇒ R): Coeval[R]

def zipMap5[A1, A2, A3, A4, A5, R](fa1: Coeval[A1], fa2: Coeval[A2], fa3: Coeval[A3], fa4: Coeval[A4], fa5: Coeval[A5])(f: (A1, A2, A3, A4, A5) ⇒ R): Coeval[R]

def zipMap6[A1, A2, A3, A4, A5, A6, R](fa1: Coeval[A1], fa2: Coeval[A2], fa3: Coeval[A3], fa4: Coeval[A4], fa5: Coeval[A5], fa6: Coeval[A6])(f: (A1, A2, A3, A4, A5, A6) ⇒ R): Coeval[R]

Deprecated Value Members

def evalAlways[A](a: ⇒ A): Coeval[A]

def zipWith2[A1, A2, R](fa1: Coeval[A1], fa2: Coeval[A2])(f: (A1, A2) ⇒ R): Coeval[R]

def zipWith3[A1, A2, A3, R](fa1: Coeval[A1], fa2: Coeval[A2], fa3: Coeval[A3])(f: (A1, A2, A3) ⇒ R): Coeval[R]

def zipWith4[A1, A2, A3, A4, R](fa1: Coeval[A1], fa2: Coeval[A2], fa3: Coeval[A3], fa4: Coeval[A4])(f: (A1, A2, A3, A4) ⇒ R): Coeval[R]

def zipWith5[A1, A2, A3, A4, A5, R](fa1: Coeval[A1], fa2: Coeval[A2], fa3: Coeval[A3], fa4: Coeval[A4], fa5: Coeval[A5])(f: (A1, A2, A3, A4, A5) ⇒ R): Coeval[R]

def zipWith6[A1, A2, A3, A4, A5, A6, R](fa1: Coeval[A1], fa2: Coeval[A2], fa3: Coeval[A3], fa4: Coeval[A4], fa5: Coeval[A5], fa6: Coeval[A6])(f: (A1, A2, A3, A4, A5, A6) ⇒ R): Coeval[R]

Inherited from Serializable

Inherited from Serializable

Inherited from AnyRef

Inherited from Any

Ungrouped