Coeval

Type Members

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

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 EvalAlways[+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.
final class EvalOnce[+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 EvalAlways or Now.
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.
class TypeClassInstances extends Evaluable[Coeval] with Bimonad[Coeval]

Groups the implementation for the type-classes defined in monix.types.

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 EvalOnce 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 evalAlways.
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

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

Promote a non-strict value representing a Coeval to a Coeval of the same type.
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
def evalAlways[A](f: ⇒ 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](f: ⇒ 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] )
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](sources: Seq[Coeval[A]]): Coeval[List[A]]

Transforms a sequence of coevals into a coeval producing a list of gathered results.
Transforms a sequence of coevals into a coeval producing a list of gathered results.
For Coeval this has the same behavior as zipList.
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
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: Seq[Coeval[A]]): Coeval[List[A]]

Zips together multiple Coeval instances.
def zipWith2[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 zipWith3[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 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]

Pairs four Coeval instances, applying the given mapping function to the result.
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]

Pairs five Coeval instances, applying the given mapping function to the result.
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]

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

Related Docs: class Coeval | package eval

object Coeval extends Serializable

Type Members

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

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

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

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

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

class TypeClassInstances extends Evaluable[Coeval] with Bimonad[Coeval]

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

object Attempt extends Serializable

object EvalOnce extends Serializable

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

final def asInstanceOf[T0]: T0

def clone(): AnyRef

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

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

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

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

def finalize(): Unit

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](sources: Seq[Coeval[A]]): Coeval[List[A]]

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

def toString(): String

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: Seq[Coeval[A]]): Coeval[List[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