DEPRECATED — renamed to Observable.count in an effort to unify the naming conventions with Iterant, Scala's standard library and Cats-Effect.

The F suffix now represents working with higher-kinded types, e.g. F[_], with restrictions like ObservableLike, TaskLike, cats.effect.Sync, etc.

DEPRECATED - renamed to delayExecution.

The reason for the deprecation is making the name more consistent with Task.

DEPRECATED - renamed to delayExecutionWith.

The reason for the deprecation is making the name more consistent with delayExecution.

DEPRECATED — signature changed to use Task.

Switch to:

• doAfterSubscribe
• doAfterSubscribeF

Note that via the magic of monix.eval.TaskLike which supports Function0 conversions, you can still use side effectful callbacks in doAfterSubscribeF, but it isn't recommended:

import monix.reactive._

Observable.range(0, 10).doAfterSubscribeF { () =>
  println("Look ma! Side-effectful callbacks!")
}

The switch to Task is to encourage referential transparency, so use it.

DEPRECATED — this function has no direct replacement.

Switching to Observable.guaranteeCase is recommended.

DEPRECATED — this function has no direct replacement.

Switching to Observable.guaranteeCaseF is recommended.

DEPRECATED — this function has no direct replacement.

Switching to Observable.guaranteeCase is recommended.

DEPRECATED - signature changed to usage of Task. You can switch to:

• doOnComplete
• doOnCompleteF

NOTE that you can still use side effectful functions with doOnCompleteF, via the magic of monix.eval.TaskLike, but it's no longer recommended:

 import monix.reactive._

// Needed for the Comonad[Function0] instance
Observable.range(0, 100)
  .doOnCompleteF(() => println("Completed!"))

DEPRECATED — renamed to doOnCompleteF.

DEPRECATED — renamed to doOnComplete.

DEPRECATED — signature changed, please see:

• doOnEarlyStop
• doOnEarlyStopF

NOTE you can still get the same behavior via doOnEarlyStopF, because Function0 implements cats.Comonad and Task conversions from Comonad are allowed, although frankly in this case doOnEarlyStop:

import monix.reactive._

// This is possible, but it's better to work with
// pure functions, so use Task or IO ;-)
Observable.range(0, 1000).take(10).doOnEarlyStopF {
  // Via the magic of `TaskLike`, we are allowed to use `Function0`
  () => println("Stopped!")
}

DEPRECATED — renamed to doOnEarlyStopF.

DEPRECATED — renamed to doOnEarlyStop.

DEPRECATED — Signature changed, see doOnError.

DEPRECATED — renamed to doOnErrorF.

DEPRECATED — renamed to doOnError.

DEPRECATED — signature for function changed to use monix.eval.Task.

import monix.eval._
import monix.reactive._

Observable.range(0, 100).doOnNext { a =>
  Task(println(s"Next: $$a"))
}

DEPRECATED — signature changed to use monix.eval.Task.

DEPRECATED — renamed to Observable.doOnNextAckF.

DEPRECATED — renamed to Observable.doOnNextAck.

DEPRECATED — renamed to Observable.doOnNextF.

DEPRECATED — renamed to Observable.doOnNext.

DEPRECATED — signature changed to use monix.eval.Task

DEPRECATED — renamed to Observable.doOnStartF

DEPRECATED — renamed to Observable.doOnStart

DEPRECATED — signature changed to use Task.

Switch to:

• doOnSubscribe
• doOnSubscribeF

Note that via the magic of monix.eval.TaskLike which supports Function0 conversions, you can still use side effectful callbacks in doOnSubscribeF, but it isn't recommended:

import monix.reactive._

Observable.range(0, 10).doOnSubscribeF { () =>
  println("Look ma! Side-effectful callbacks!")
}

The switch to Task is to encourage referential transparency, so use it.

DEPRECATED - you can switch to:

• doOnSubscriptionCancel
• doOnSubscriptionCancelF

NOTE that you can still use side effectful functions with doOnSubscriptionCancelF, via the magic of monix.eval.TaskLike, but it's no longer recommended:

import monix.reactive._

Observable.range(0, Int.MaxValue)
  .doOnEarlyStopF(() => println("Cancelled!"))

DEPRECATED — switch to:

• guaranteeCase
• guaranteeCaseF

DEPRECATED — a much better version of doOnTerminateEval is guaranteeCaseF.

Example:

import cats.effect.{ExitCase, IO}
import monix.reactive._

Observable.range(0, 1000).guaranteeCaseF {
  case ExitCase.Error(e) =>
    IO(println(s"Error raised: $$e"))
  case ExitCase.Completed =>
    IO(println("Stream completed normally"))
  case ExitCase.Canceled =>
    IO(println("Stream was cancelled"))
}

DEPRECATED — a much better version of doOnTerminateTask is guaranteeCase.

Example:

import cats.effect.ExitCase
import monix.eval._
import monix.reactive._

Observable.range(0, 1000).guaranteeCase {
  case ExitCase.Error(e) =>
    Task(println(s"Error raised: $$e"))
  case ExitCase.Completed =>
    Task(println("Stream completed normally"))
  case ExitCase.Canceled =>
    Task(println("Stream was cancelled"))
}

DEPRECATED - renamed to executeAsync.

The reason for the deprecation is the repurposing of the word "fork" in Task.

DEPRECATED — renamed to Observable.forall in an effort to unify the naming conventions with Iterant, Scala's standard library and Cats-Effect.

The F suffix now represents working with higher-kinded types, e.g. F[_], with restrictions like ObservableLike, TaskLike, cats.effect.Sync, etc.

DEPRECATED — renamed to Observable.find in an effort to unify the naming conventions with Iterant, Scala's standard library and Cats-Effect.

The F suffix now represents working with higher-kinded types, e.g. F[_], with restrictions like ObservableLike, TaskLike, cats.effect.Sync, etc.

DEPRECATED — renamed to Observable.firstOrElse in an effort to unify the naming conventions with Iterant, Scala's standard library and Cats-Effect.

The F suffix now represents working with higher-kinded types, e.g. F[_], with restrictions like ObservableLike, TaskLike, cats.effect.Sync, etc.

DEPRECATED — renamed to Observable.fold in an effort to unify the naming conventions with Iterant, Scala's standard library and Cats-Effect.

The F suffix now represents working with higher-kinded types, e.g. F[_], with restrictions like ObservableLike, TaskLike, cats.effect.Sync, etc.

DEPRECATED — renamed to Observable.foldLeft in an effort to unify the naming conventions with Iterant, Scala's standard library and Cats-Effect.

The F suffix now represents working with higher-kinded types, e.g. F[_], with restrictions like ObservableLike, TaskLike, cats.effect.Sync, etc.

DEPRECATED — renamed to Observable.foldWhileLeft in an effort to unify the naming conventions with Iterant, Scala's standard library and Cats-Effect.

The F suffix now represents working with higher-kinded types, e.g. F[_], with restrictions like ObservableLike, TaskLike, cats.effect.Sync, etc.

DEPRECATED — renamed to Observable.forall in an effort to unify the naming conventions with Iterant, Scala's standard library and Cats-Effect.

The F suffix now represents working with higher-kinded types, e.g. F[_], with restrictions like ObservableLike, TaskLike, cats.effect.Sync, etc.

DEPRECATED — renamed to Observable.forallL in an effort to unify the naming conventions with Iterant and Scala's standard library.

DEPRECATED — renamed to Observable.head in an effort to unify the naming conventions with Iterant, Scala's standard library and Cats-Effect.

The F suffix now represents working with higher-kinded types, e.g. F[_], with restrictions like ObservableLike, TaskLike, cats.effect.Sync, etc.

DEPRECATED — renamed to Observable.headOrElse in an effort to unify the naming conventions with Iterant, Scala's standard library and Cats-Effect.

The F suffix now represents working with higher-kinded types, e.g. F[_], with restrictions like ObservableLike, TaskLike, cats.effect.Sync, etc.

DEPRECATED — renamed to Observable.isEmpty in an effort to unify the naming conventions with Iterant, Scala's standard library and Cats-Effect.

The F suffix now represents working with higher-kinded types, e.g. F[_], with restrictions like ObservableLike, TaskLike, cats.effect.Sync, etc.

DEPRECATED — renamed to Observable.forall in an effort to unify the naming conventions with Iterant, Scala's standard library and Cats-Effect.

The F suffix now represents working with higher-kinded types, e.g. F[_], with restrictions like ObservableLike, TaskLike, cats.effect.Sync, etc.

DEPRECATED — switch to Observable.mapEvalF, which is the generic version that supports usage with Future via the magic of monix.eval.TaskLike.

The replacement is direct, a simple rename:

import scala.concurrent._
import scala.concurrent.duration._
import monix.execution.FutureUtils.extensions._
import monix.reactive._

Observable.range(0, 100).mapEvalF { a =>
  import monix.execution.Scheduler.Implicits.global
  Future.delayedResult(1.second)(a)
}

DEPRECATED — renamed to Observable.mapEval.

DEPRECATED — renamed to Observable.maxBy in an effort to unify the naming conventions with Iterant, Scala's standard library and Cats-Effect.

The F suffix now represents working with higher-kinded types, e.g. F[_], with restrictions like ObservableLike, TaskLike, cats.effect.Sync, etc.

DEPRECATED — renamed to Observable.max in an effort to unify the naming conventions with Iterant, Scala's standard library and Cats-Effect.

The F suffix now represents working with higher-kinded types, e.g. F[_], with restrictions like ObservableLike, TaskLike, cats.effect.Sync, etc.

DEPRECATED — renamed to Observable.minBy in an effort to unify the naming conventions with Iterant, Scala's standard library and Cats-Effect.

The F suffix now represents working with higher-kinded types, e.g. F[_], with restrictions like ObservableLike, TaskLike, cats.effect.Sync, etc.

DEPRECATED — renamed to Observable.min in an effort to unify the naming conventions with Iterant, Scala's standard library and Cats-Effect.

The F suffix now represents working with higher-kinded types, e.g. F[_], with restrictions like ObservableLike, TaskLike, cats.effect.Sync, etc.

DEPRECATED — renamed to Observable.nonEmpty in an effort to unify the naming conventions with Iterant, Scala's standard library and Cats-Effect.

The F suffix now represents working with higher-kinded types, e.g. F[_], with restrictions like ObservableLike, TaskLike, cats.effect.Sync, etc.

DEPRECATED — renamed to Observable.scanEval.

Renaming was done for naming consistency. Functions that use Task parameters in Observable no longer have a Task suffix.

DEPRECATED — renamed to Observable.scanEval0.

Renaming was done for naming consistency. Functions that use Task parameters in Observable no longer have a Task suffix.

DEPRECATED — renamed to Observable.sum in an effort to unify the naming conventions with Iterant, Scala's standard library and Cats-Effect.

The F suffix now represents working with higher-kinded types, e.g. F[_], with restrictions like ObservableLike, TaskLike, cats.effect.Sync, etc.