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

def asFutureUnsafe[T](value: async.Task[T])(implicit sc: async.Scheduler): async.CancellableFuture[T]

!!! USE WITH CARE !!!

The moment you call this, the side-effects suspended in this IO start being executed.

Annotations: @inline()

def asIO[T](value: async.Task[T])(implicit sc: async.Scheduler): async.IO[T]

No gotchas.

No gotchas. Pure functional programming = <3

Annotations: @inline()

final def asInstanceOf[T0]: T0

Definition Classes: Any

def attemptResult[T](value: async.Task[T]): async.Task[sync.Result[T]]

Makes the failure, and non-failure part of this effect explicit in a busymachines.effects.sync.Result type.

This transforms any failed effect, into a pure one with and busymachines.effects.sync.Incorrect value.

Annotations: @inline()

def bimap[T, R](value: async.Task[T], result: (sync.Result[T]) ⇒ sync.Result[R]): async.Task[R]

Similar to the overload, but the busymachines.effects.sync.Correct branch of the result is used to change the "pure" branch of this effect, and busymachines.effects.sync.Incorrect branch is used to change the "fail" branch of the effect.

Annotations: @inline()

def bimap[T, R](value: async.Task[T], good: (T) ⇒ R, bad: (Throwable) ⇒ Anomaly): async.Task[R]

Used to transform both the "pure" part of the effect, and the "fail" part.

Used to transform both the "pure" part of the effect, and the "fail" part. Hence the name "bi" map, because it also allows you to change both branches of the effect, not just the happy path.

Annotations: @inline()

def bimapThr[T, R](value: async.Task[T], good: (T) ⇒ R, bad: (Throwable) ⇒ Throwable): async.Task[R]

Similar to the overload, but the busymachines.effects.sync.Correct branch of the result is used to change the "pure" branch of this effect, and busymachines.effects.sync.Incorrect branch is used to change the "fail" branch of the effect.

The overload that uses java.lang.Throwable instead of busymachines.core.Anomaly

Annotations: @inline()

def clone(): AnyRef

Attributes: protected[java.lang]
Definition Classes: AnyRef
Annotations: @native() @throws( ... )

def cond[T](test: Boolean, good: ⇒ T, bad: ⇒ Anomaly): async.Task[T]

returns: pure effect from good if the boolean is true failed effect with bad busymachines.core.Anomaly if boolean is false

Annotations: @inline()

def condThr[T](test: Boolean, good: ⇒ T, bad: ⇒ Throwable): async.Task[T]

returns: pure effect from good if the boolean is true failed effect with bad java.lang.Throwable if boolean is false

Annotations: @inline()

def condWith[T](test: Boolean, good: ⇒ async.Task[T], bad: ⇒ Anomaly): async.Task[T]

returns: effect from good if the boolean is true failed effect with bad busymachines.core.Anomaly if boolean is false

Annotations: @inline()

def condWithThr[T](test: Boolean, good: ⇒ async.Task[T], bad: ⇒ Throwable): async.Task[T]

returns: effect from good if the boolean is true failed effect with bad java.lang.Throwable if boolean is false

Annotations: @inline()

def discardContent(value: async.Task[_]): async.Task[Unit]

Explicitely discard the contents of this effect, and return Unit instead.

N.B. computation, and side-effects captured within this effect are still executed, it's just the final value that is discarded

Annotations: @inline()

def effectOnFail[T](value: sync.Result[T], effect: (Anomaly) ⇒ async.Task[_]): async.Task[Unit]

value: Runs the given effect when the value of this busymachines.effects.sync.Result is busymachines.effects.sync.Incorrect
effect: The effect to run
returns: Does not return anything, this method is inherently imperative, and relies on side-effects to achieve something.

Annotations: @inline()

def effectOnFail[T](value: Option[T], effect: ⇒ async.Task[_]): async.Task[Unit]

value: Runs the given effect when the value of this Option is scala.None
effect: The effect to run
returns: Does not return anything, this method is inherently imperative, and relies on side-effects to achieve something.

Annotations: @inline()

def effectOnFalse(test: Boolean, effect: ⇒ async.Task[_]): async.Task[Unit]

effect: The effect to run
returns: Does not return anything, this method is inherently imperative, and relies on side-effects to achieve something.

Annotations: @inline()

def effectOnPure[T](value: sync.Result[T], effect: (T) ⇒ async.Task[_]): async.Task[Unit]

value: Runs the given effect when the value of this busymachines.effects.sync.Result is busymachines.effects.sync.Correct
effect: The effect to run
returns: Does not return anything, this method is inherently imperative, and relies on side-effects to achieve something.

Annotations: @inline()

def effectOnPure[T](value: Option[T], effect: (T) ⇒ async.Task[_]): async.Task[Unit]

value: Runs the given effect when the value of this Option is Some
effect: The effect to run
returns: Does not return anything, this method is inherently imperative, and relies on side-effects to achieve something.

Annotations: @inline()

def effectOnTrue(test: Boolean, effect: ⇒ async.Task[_]): async.Task[Unit]

effect: The effect to run
returns: Does not return anything, this method is inherently imperative, and relies on side-effects to achieve something.

Annotations: @inline()

final def eq(arg0: AnyRef): Boolean

Definition Classes: AnyRef

def equals(arg0: Any): Boolean

Definition Classes: AnyRef → Any

def fail[T](bad: Anomaly): async.Task[T]

Failed effect but with an busymachines.core.Anomaly

Annotations: @inline()

def failOnFalse(test: Boolean, bad: ⇒ Anomaly): async.Task[Unit]

returns: Failed effect, if the boolean is false

Annotations: @inline()

def failOnFalseThr(test: Boolean, bad: ⇒ Throwable): async.Task[Unit]

returns: Failed effect, if the boolean is false

Annotations: @inline()

def failOnTrue(test: Boolean, bad: ⇒ Anomaly): async.Task[Unit]

returns: Failed effect, if the boolean is true

Annotations: @inline()

def failOnTrueThr(test: Boolean, bad: ⇒ Throwable): async.Task[Unit]

returns: Failed effect, if the boolean is true

Annotations: @inline()

def failThr[T](bad: Throwable): async.Task[T]

Failed effect but with a java.lang.Throwable

Annotations: @inline()

def finalize(): Unit

Attributes: protected[java.lang]
Definition Classes: AnyRef
Annotations: @throws( classOf[java.lang.Throwable] )

def flatCond[T](test: async.Task[Boolean], good: ⇒ T, bad: ⇒ Anomaly): async.Task[T]

returns: pure effect from good if the boolean is true failed effect with bad busymachines.core.Anomaly if boolean is false failed effect if the effect wrapping the boolean is already failed

Annotations: @inline()

def flatCondThr[T](test: async.Task[Boolean], good: ⇒ T, bad: ⇒ Throwable): async.Task[T]

returns: pure effect from good if the boolean is true failed effect with bad java.lang.Throwable if boolean is false failed effect if the effect wrapping the boolean is already failed

Annotations: @inline()

def flatCondWith[T](test: async.Task[Boolean], good: ⇒ async.Task[T], bad: ⇒ Anomaly): async.Task[T]

returns: effect resulted from good if the boolean is true failed effect with bad busymachines.core.Anomaly if boolean is false failed effect if the effect wrapping the boolean is already failed

Annotations: @inline()

def flatCondWithThr[T](test: async.Task[Boolean], good: ⇒ async.Task[T], bad: ⇒ Throwable): async.Task[T]

returns: effect resulted from good if the boolean is true failed effect with bad java.lang.Throwable if boolean is false failed effect if the effect wrapping the boolean is already failed

Annotations: @inline()

def flatEffectOnCorrect[T](value: async.Task[sync.Result[T]], effect: (T) ⇒ async.Task[_]): async.Task[Unit]

value: Runs the given effect when the boxed value of this busymachines.effects.sync.Result is busymachines.effects.sync.Correct Does not run the side-effect if the value is also a failed effect.
effect: The effect to run
returns: Does not return anything, this method is inherently imperative, and relies on side-effects to achieve something.

Annotations: @inline()

def flatEffectOnFalse(test: async.Task[Boolean], effect: ⇒ async.Task[_]): async.Task[Unit]

effect: The effect to run
returns: Does not return anything, this method is inherently imperative, and relies on side-effects to achieve something.

Annotations: @inline()

def flatEffectOnIncorrect[T](value: async.Task[sync.Result[T]], effect: (Anomaly) ⇒ async.Task[_]): async.Task[Unit]

value: Runs the given effect when the boxed value of this busymachines.effects.sync.Result is busymachines.effects.sync.Incorrect Does not run the side-effect if the value is also a failed effect.
effect: The effect to run
returns: Does not return anything, this method is inherently imperative, and relies on side-effects to achieve something.

Annotations: @inline()

def flatEffectOnNone[T](value: async.Task[Option[T]], effect: ⇒ async.Task[_]): async.Task[Unit]

value: Runs the given effect when the value of this Option is scala.None Does not run the side-effect if the value is also a failed effect.
effect: The effect to run
returns: Does not return anything, this method is inherently imperative, and relies on side-effects to achieve something.

Annotations: @inline()

def flatEffectOnSome[T](value: async.Task[Option[T]], effect: (T) ⇒ async.Task[_]): async.Task[Unit]

value: Runs the given effect when the value of this Option is Some Does not run the side-effect if the value is also a failed effect.
effect: The effect to run
returns: Does not return anything, this method is inherently imperative, and relies on side-effects to achieve something.

Annotations: @inline()

def flatEffectOnTrue(test: async.Task[Boolean], effect: ⇒ async.Task[_]): async.Task[Unit]

effect: The effect to run
returns: Does not return anything, this method is inherently imperative, and relies on side-effects to achieve something.

Annotations: @inline()

def flatFailOnFalse(test: async.Task[Boolean], bad: ⇒ Anomaly): async.Task[Unit]

returns: Failed effect, if the boxed boolean is false, or if the original effect is failed

Annotations: @inline()

def flatFailOnFalseThr(test: async.Task[Boolean], bad: ⇒ Throwable): async.Task[Unit]

returns: Failed effect, if the boxed boolean is false, or if the original effect is failed

Annotations: @inline()

def flatFailOnTrue(test: async.Task[Boolean], bad: ⇒ Anomaly): async.Task[Unit]

returns: Failed effect, if the boxed boolean is true, or if the original effect is failed

Annotations: @inline()

def flatFailOnTrueThr(test: async.Task[Boolean], bad: ⇒ Throwable): async.Task[Unit]

returns: Failed effect, if the boxed boolean is true, or if the original effect is failed

Annotations: @inline()

def fromEither[L, R](either: Either[L, R], transformLeft: (L) ⇒ Anomaly): async.Task[R]

Lift this Either and transform its left-hand side into a busymachines.core.Anomaly and sequence it within this effect, yielding a failed effect.

Annotations: @inline()

def fromEitherThr[L, R](either: Either[L, R], transformLeft: (L) ⇒ Throwable): async.Task[R]

Lift this Either and transform its left-hand side into a java.lang.Throwable and sequence it within this effect, yielding a failed effect.

Annotations: @inline()

def fromEitherThr[L, R](either: Either[L, R])(implicit ev: <:<[L, Throwable]): async.Task[R]

Lift this Either and sequence its left-hand-side java.lang.Throwable within this effect if it is a java.lang.Throwable.

Annotations: @inline()

def fromFuturePure[T](value: async.Future[T]): async.Task[T]

!!! USE WITH CARE !!!

In 99% of the cases you actually want to use suspendFuture

If you are certain that this Future is pure, then you can use this method to lift it into Task.

Annotations: @inline()

def fromIO[T](value: async.IO[T]): async.Task[T]

Transform an IO into a Task.

Transform an IO into a Task. No gotchas because pure functional programming is awesome.

Annotations: @inline()

def fromOption[T](opt: Option[T], ifNone: ⇒ Anomaly): async.Task[T]

Lift this Option and transform it into a failed effect if it is scala.None

Annotations: @inline()

def fromOptionThr[T](opt: Option[T], ifNone: ⇒ Throwable): async.Task[T]

Lift this Option and transform it into a failed effect if it is scala.None

Annotations: @inline()

def fromResult[T](result: sync.Result[T]): async.Task[T]

Lift the busymachines.effects.sync.Result in this effect busymachines.effects.sync.Incorrect becomes a failed effect busymachines.effects.sync.Correct becomes a pure effect

Annotations: @inline()

def fromValidated[T](value: sync.validated.Validated[T], ctor: (Anomaly, List[Anomaly]) ⇒ Anomalies): async.Task[T]

Lift the Validated in this effect Validated.Invalid becomes a failed effect Validated.Valid becomes a pure effect

Provide the constructor for the specific busymachines.core.Anomalies into which the anomalies shall be stored.

e.g. Creating case classes like bellow, or constructors on companion objects makes using this method almost completely non-intrusive

case class TVFs(
  bad:  Anomaly,
  bads: List[Anomaly] = Nil
) extends AnomalousFailures(
      TVFsID,
      s"Test validation failed with ${bads.length + 1} anomalies",
      bad,
      bads
    )

case object TVFsID extends AnomalyID {
  override def name = "test_validation_001"
}

object Test {
  Task.fromValidated(
    Validated.pure(42),
    TVFs
  )
  //in validated postfix notation it's infinitely more concise
  Validated.pure(42).asTask(TVFs)
}

Annotations: @inline()

def fromValidated[T](value: sync.validated.Validated[T]): async.Task[T]

Lift the Validated in this effect Validated.Invalid becomes a failed effect Validated.Valid becomes a pure effect

Consider using the overload with an extra constructor parameter for a custom busymachines.core.Anomalies, otherwise your all failed cases will be wrapped in a: busymachines.effects.sync.validated.GenericValidationFailures

Annotations: @inline()

final def getClass(): Class[_]

Definition Classes: AnyRef → Any
Annotations: @native()

def hashCode(): Int

Definition Classes: AnyRef → Any
Annotations: @native()

final def isInstanceOf[T0]: Boolean

Definition Classes: Any

def morph[T, R](value: async.Task[T], result: (sync.Result[T]) ⇒ R): async.Task[R]

Semantically equivalent to the overload morph that accepts two functions, but those encoded as the corresponding branches of a Result type.

Undefined behavior if you throw exceptions in the method. DO NOT do that!

Annotations: @inline()

def morph[T, R](value: async.Task[T], good: (T) ⇒ R, bad: (Throwable) ⇒ R): async.Task[R]

Given the basic two-pronged nature of this effect.

Given the basic two-pronged nature of this effect. the good function transforms the underlying "pure" (correct, successful, etc) if that's the case. the bad function transforms the underlying "failure" part of the effect into a "pure" part.

Therefore, by using morph you are defining the rules by which to make the effect into a successful one that does not short-circuit monadic flatMap chains.

e.g:

val f: Future[Int] = Future.fail(InvalidInputFailure)
Future.morph(f, (i: Int) => i *2, (t: Throwable) => 42)

Undefined behavior if you throw exceptions in the method. DO NOT do that!

Annotations: @inline()

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()

def pure[T](value: T): async.Task[T]

N.B.

N.B. pass only pure values. If you have side effects, then use Task.apply to suspend them inside this future.

Annotations: @inline()

def sequence_[A, M[X] <: TraversableOnce[X]](in: M[async.Task[A]])(implicit cbf: CanBuildFrom[M[async.Task[A]], A, M[A]]): async.Task[Unit]

Similar to monix.eval.Task.sequence, but discards all content.

Similar to monix.eval.Task.sequence, but discards all content. i.e. used only for the combined effects.

Annotations: @inline()
See also: monix.eval.Task.sequence

def serialize[A, B, C[X] <: TraversableOnce[X]](col: C[A])(fn: (A) ⇒ async.Task[B])(implicit cbf: CanBuildFrom[C[A], B, C[B]]): async.Task[C[B]]

Syntactically inspired from Future.traverse.

See FutureOps.serialize for semantics.

Usage:

import busymachines.effects.async._
val patches: Seq[Patch] = //...

//this ensures that no two changes will be applied in parallel.
val allPatches: Task[Seq[Patch]] = Task.serialize(patches){ patch: Patch =>
  Task {
    //apply patch
  }
}
//... and so on, and so on!

Annotations: @inline()

def serialize_[A, B, C[X] <: TraversableOnce[X]](col: C[A])(fn: (A) ⇒ async.Task[B])(implicit cbf: CanBuildFrom[C[A], B, C[B]]): async.Task[Unit]

Similar to serialize, but discards all content.

Similar to serialize, but discards all content. i.e. used only for the combined effects.

Annotations: @inline()
See also: serialize

def suspendEither[L, R](either: ⇒ Either[L, R], transformLeft: (L) ⇒ Anomaly): async.Task[R]

Suspend any side-effects that might happen during the creation of this Either.

Suspend any side-effects that might happen during the creation of this Either. And transform its left-hand side into a busymachines.core.Anomaly and sequence it within this effect, yielding a failed effect.

N.B. this is useless if the Either was previously assigned to a "val". You might as well use TaskOps.fromEither

Annotations: @inline()

def suspendEitherThr[L, R](either: ⇒ Either[L, R], transformLeft: (L) ⇒ Throwable): async.Task[R]

Suspend any side-effects that might happen during the creation of this Either.

Suspend any side-effects that might happen during the creation of this Either. And transform its left-hand side into a java.lang.Throwable and sequence it within this effect, yielding a failed effect.

N.B. this is useless if the Either was previously assigned to a "val". You might as well use TaskOps.fromEither

Annotations: @inline()

def suspendEitherThr[L, R](either: ⇒ Either[L, R])(implicit ev: <:<[L, Throwable]): async.Task[R]

Suspend any side-effects that might happen during the creation of this Either.

Suspend any side-effects that might happen during the creation of this Either. And sequence its left-hand-side java.lang.Throwable within this effect if it is a java.lang.Throwable

N.B. this is useless if the Either was previously assigned to a "val". You might as well use TaskOps.fromEither

Annotations: @inline()

def suspendFuture[T](value: ⇒ async.Future[T]): async.Task[T]

Suspend the side-effects of this Future into a Task.

Suspend the side-effects of this Future into a Task. This is the most important operation when it comes to inter-op between the two effects.

Usage. N.B. that this only makes sense if the creation of the Future itself is also suspended in the Task.

@inline def  writeToDB(v: Int, s: String): Future[Long] = ???
  //...
  val task = Task.suspendFuture(writeToDB(42, "string"))
  //no database writes happened yet, since the future did
  //not do its annoying running of side-effects immediately!

  //when we want side-effects:
  task.unsafeGetSync()

This is almost useless unless you are certain that ??? is a pure computation might as well use Task.fromFuturePure(???)

val f: Future[Int] = Future.apply(???)
Task.suspendFuture(f)

Annotations: @inline()

def suspendOption[T](opt: ⇒ Option[T], ifNone: ⇒ Anomaly): async.Task[T]

Suspend any side-effects that might happen during the creation of this Option.

Suspend any side-effects that might happen during the creation of this Option. If the option is scala.None then we get back a failed effect with the given busymachines.core.Anomaly

N.B. this is useless if the Option was previously assigned to a "val". You might as well use TaskOps.fromOption

Annotations: @inline()

def suspendOptionThr[T](opt: ⇒ Option[T], ifNone: ⇒ Throwable): async.Task[T]

Suspend any side-effects that might happen during the creation of this Option.

Suspend any side-effects that might happen during the creation of this Option. If the option is scala.None then we get back a failed effect with the given java.lang.Throwable

N.B. this is useless if the Option was previously assigned to a "val". You might as well use TaskOps.fromOption

Annotations: @inline()

def suspendResult[T](result: ⇒ sync.Result[T]): async.Task[T]

Suspend any side-effects that might happen during the creation of this busymachines.effects.sync.Result.

Suspend any side-effects that might happen during the creation of this busymachines.effects.sync.Result. Other than that it has the semantics of TaskOps.fromResult

N.B. this is useless if the busymachines.effects.sync.Result was previously assigned to a "val". You might as well use TaskOps.fromResult

Annotations: @inline()

def suspendTry[T](tr: ⇒ sync.Try[T]): async.Task[T]

Suspend any side-effects that might happen during the creation of this scala.util.Try.

Suspend any side-effects that might happen during the creation of this scala.util.Try. Failed Try yields a failed effect Successful Try yields a pure effect

N.B. this is useless if the scala.util.Try was previously assigned to a "val". You might as well use Task.fromTry

Annotations: @inline()

def suspendValidated[T](value: ⇒ sync.validated.Validated[T], ctor: (Anomaly, List[Anomaly]) ⇒ Anomalies): async.Task[T]

Suspend any side-effects that might happen during the creation of this Validated.

N.B. this is useless if the Validated was previously assigned to a "val". You might as well use FutureOps.fromValidated

Annotations: @inline()

def suspendValidated[T](value: ⇒ sync.validated.Validated[T]): async.Task[T]

Suspend any side-effects that might happen during the creation of this Validated.

N.B. this is useless if the Validated was previously assigned to a "val". You might as well use TaskOps.fromValidated

Annotations: @inline()

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]](col: M[A])(fn: (A) ⇒ async.Task[B])(implicit cbf: CanBuildFrom[M[A], B, M[B]]): async.Task[Unit]

Similar to monix.eval.Task.traverse, but discards all content.

Similar to monix.eval.Task.traverse, but discards all content. i.e. used only for the combined effects.

See also: monix.eval.Task.traverse

def unpackOption[T](nopt: async.Task[Option[T]], ifNone: ⇒ Anomaly): async.Task[T]

Sequences the given busymachines.core.Anomaly if Option is scala.None into this effect

The failure of this effect takes precedence over the given failure

Annotations: @inline()

def unpackOptionThr[T](nopt: async.Task[Option[T]], ifNone: ⇒ Throwable): async.Task[T]

Sequences the given java.lang.Throwable if Option is scala.None into this effect

The failure of this effect takes precedence over the given failure

Annotations: @inline()

def unpackResult[T](value: async.Task[sync.Result[T]]): async.Task[T]

Sequences the failure of the busymachines.effects.sync.Incorrect busymachines.effects.sync.Result into this effect.

The failure of this effect takes precedence over the failure of the busymachines.effects.sync.Incorrect value.

Annotations: @inline()

def unsafeSyncGet[T](value: async.Task[T], atMost: duration.FiniteDuration = ...)(implicit sc: async.Scheduler): T

!!! USE WITH CARE !!!

Mostly here for testing. There is almost no reason whatsover for you to explicitely call this in your code. You have libraries that do this for you "at the end of the world" parts of your program: e.g. akka-http when waiting for the response value to a request.

Annotations: @inline()

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( ... )

Packages

TaskOps

object TaskOps

Value Members

Inherited from AnyRef

Inherited from Any

Ungrouped

Packages

TaskOps 

object TaskOps

Value Members

Inherited from AnyRef

Inherited from Any

Ungrouped

TaskOps