implicit final class Operations[A] extends AnyVal
- Annotations
- @inline()
- Alphabetic
- By Inheritance
- Operations
- AnyVal
- Any
- Hide All
- Show All
- Public
- Protected
Instance Constructors
- new Operations(source: Observable[A])
Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- Any
- final def ##: Int
- Definition Classes
- Any
- final def ==(arg0: Any): Boolean
- Definition Classes
- Any
- def as[B](value: B): Observable[B]
- def asDelay[B](value: => B): Observable[B]
- def asEffect[F[_], B](value: F[B])(implicit arg0: RunEffect[F]): Observable[B]
- def asFuture[B](value: Future[B]): Observable[B]
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def async: Observable[A]
- Annotations
- @inline()
- def asyncMacro: Observable[A]
- def asyncMicro: Observable[A]
- def attempt: Observable[Either[Throwable, A]]
- def behavior(value: A): Connectable[Value[A]]
- Annotations
- @inline()
- def behaviorSelector[B](value: A)(f: (Value[A]) => Observable[B]): Observable[B]
- Annotations
- @inline()
- def collect[B](f: PartialFunction[A, B]): Observable[B]
- def combineLatest[B, C, D, E, F](sourceB: Observable[B], sourceC: Observable[C], sourceD: Observable[D], sourceE: Observable[E], sourceF: Observable[F]): Observable[(A, B, C, D, E, F)]
- Annotations
- @inline()
- def combineLatest[B, C, D, E](sourceB: Observable[B], sourceC: Observable[C], sourceD: Observable[D], sourceE: Observable[E]): Observable[(A, B, C, D, E)]
- Annotations
- @inline()
- def combineLatest[B, C, D](sourceB: Observable[B], sourceC: Observable[C], sourceD: Observable[D]): Observable[(A, B, C, D)]
- Annotations
- @inline()
- def combineLatest[B, C](sourceB: Observable[B], sourceC: Observable[C]): Observable[(A, B, C)]
- Annotations
- @inline()
- def combineLatest[B](sourceB: Observable[B]): Observable[(A, B)]
- Annotations
- @inline()
- def combineLatestMap[B, C, D, E, F, R](sourceB: Observable[B], sourceC: Observable[C], sourceD: Observable[D], sourceE: Observable[E], sourceF: Observable[F])(f: (A, B, C, D, E, F) => R): Observable[R]
- def combineLatestMap[B, C, D, E, R](sourceB: Observable[B], sourceC: Observable[C], sourceD: Observable[D], sourceE: Observable[E])(f: (A, B, C, D, E) => R): Observable[R]
- def combineLatestMap[B, C, D, R](sourceB: Observable[B], sourceC: Observable[C], sourceD: Observable[D])(f: (A, B, C, D) => R): Observable[R]
- def combineLatestMap[B, C, R](sourceB: Observable[B], sourceC: Observable[C])(f: (A, B, C) => R): Observable[R]
- def combineLatestMap[B, R](sourceB: Observable[B])(f: (A, B) => R): Observable[R]
- def debounce(duration: FiniteDuration): Observable[A]
- Annotations
- @inline()
- def debounceMillis(duration: Int): Observable[A]
- def delay(duration: FiniteDuration): Observable[A]
- Annotations
- @inline()
- def delayMillis(duration: Int): Observable[A]
- def discard: Observable[Nothing]
- def distinct(implicit equality: Eq[A]): Observable[A]
- Annotations
- @inline()
- def distinctBy[B](f: (A) => B)(implicit equality: Eq[B]): Observable[A]
- def distinctByOnEquals[B](f: (A) => B): Observable[A]
- Annotations
- @inline()
- def distinctOnEquals: Observable[A]
- Annotations
- @inline()
- def drop(num: Int): Observable[A]
- def dropUntil(until: Observable[Unit]): Observable[A]
- def dropWhile(predicate: (A) => Boolean): Observable[A]
- def evalOn(ec: ExecutionContext): Observable[A]
- def failed: Observable[Throwable]
- def filter(f: (A) => Boolean): Observable[A]
- def foreach_(f: (A) => Unit): Observable[Unit]
- def getClass(): Class[_ <: AnyVal]
- Definition Classes
- AnyVal → Any
- def head: Observable[A]
- Annotations
- @inline()
- def headF[F[_]](implicit arg0: Async[F]): F[A]
- def headIO: IO[A]
- Annotations
- @inline()
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def map[B](f: (A) => B): Observable[B]
- def mapEffect[F[_], B](f: (A) => F[B])(implicit arg0: RunEffect[F]): Observable[B]
- def mapEffectSingleOrDrop[F[_], B](f: (A) => F[B])(implicit arg0: RunEffect[F]): Observable[B]
- def mapEither[B](f: (A) => Either[Throwable, B]): Observable[B]
- def mapFilter[B](f: (A) => Option[B]): Observable[B]
- def mapFuture[B](f: (A) => Future[B]): Observable[B]
- Annotations
- @inline()
- def mapFutureSingleOrDrop[B](f: (A) => Future[B]): Observable[B]
- Annotations
- @inline()
- def mapIterable[B](f: (A) => Iterable[B]): Observable[B]
- def mapResource[F[_], B](f: (A) => Resource[F, B])(implicit arg0: RunEffect[F], arg1: Sync[F]): Observable[B]
- Annotations
- @inline()
- def merge(sources: Observable[A]*): Observable[A]
- def mergeMap[B](f: (A) => Observable[B]): Observable[B]
- Annotations
- @inline()
- def multicast(pipe: Subject[A]): Connectable[Observable[A]]
- def multicastMaybeValue(pipe: Subject.MaybeValue[A]): Connectable[MaybeValue[A]]
- def multicastValue(pipe: Subject.Value[A]): Connectable[Value[A]]
- def prepend(value: A): Observable[A]
- def prependDelay(value: => A): Observable[A]
- def prependEffect[F[_]](value: F[A])(implicit arg0: RunEffect[F]): Observable[A]
- Annotations
- @inline()
- def prependFuture(value: => Future[A]): Observable[A]
- Annotations
- @inline()
- def publish: Connectable[Observable[A]]
- Annotations
- @inline()
- def publishSelector[B](f: (Observable[A]) => Observable[B]): Observable[B]
- Annotations
- @inline()
- def recover(f: PartialFunction[Throwable, A]): Observable[A]
- def recoverOption(f: PartialFunction[Throwable, Option[A]]): Observable[A]
- def replayAll: Connectable[Observable[A]]
- Annotations
- @inline()
- def replayAllSelector[B](f: (Observable[A]) => Observable[B]): Observable[B]
- Annotations
- @inline()
- def replayLatest: Connectable[MaybeValue[A]]
- Annotations
- @inline()
- def replayLatestSelector[B](f: (MaybeValue[A]) => Observable[B]): Observable[B]
- Annotations
- @inline()
- def sample(duration: FiniteDuration): Observable[A]
- Annotations
- @inline()
- def sampleMillis(duration: Int): Observable[A]
- def scan[B](seed: B)(f: (B, A) => B): Observable[B]
- def scan0[B](seed: B)(f: (B, A) => B): Observable[B]
- def scan0ToList: Observable[List[A]]
- def scanToList: Observable[List[A]]
- val source: Observable[A]
- def startWith(values: Iterable[A]): Observable[A]
- def subscribeF[F[_]](implicit arg0: Sync[F]): F[Cancelable]
- Annotations
- @inline()
- def subscribeIO: IO[Cancelable]
- Annotations
- @inline()
- def subscribeSyncIO: SyncIO[Cancelable]
- Annotations
- @inline()
- def subscribing(f: Observable[Unit]): Observable[A]
- def switch(sources: Observable[A]*): Observable[A]
- def switchMap[B](f: (A) => Observable[B]): Observable[B]
- Annotations
- @inline()
- def switchMapResource[F[_], B](f: (A) => Resource[F, B])(implicit arg0: RunEffect[F], arg1: Sync[F]): Observable[B]
- Annotations
- @inline()
- def take(num: Int): Observable[A]
- def takeUntil(until: Observable[Unit]): Observable[A]
- def takeWhile(predicate: (A) => Boolean): Observable[A]
- def tap(f: (A) => Unit): Observable[A]
- def tapEffect[F[_]](f: (A) => F[Unit])(implicit arg0: RunEffect[F], arg1: Functor[F]): Observable[A]
- def tapFailed(f: (Throwable) => Unit): Observable[A]
- def tapFailedEffect[F[_]](f: (Throwable) => F[Unit])(implicit arg0: RunEffect[F], arg1: Applicative[F]): Observable[A]
- def tapSubscribe(f: () => Cancelable): Observable[A]
- def tapSubscribeEffect[F[_]](f: F[Cancelable])(implicit arg0: RunEffect[F]): Observable[A]
- def to(sink: Observer[A]): Observable[Unit]
- def toString(): String
- Definition Classes
- Any
- def transformSink[B](transform: (Observer[B]) => Observer[A]): Observable[B]
- Annotations
- @inline()
- def transformSource[B](transform: (Observable[A]) => Observable[B]): Observable[B]
- Annotations
- @inline()
- def unsafeForeach(f: (A) => Unit): Cancelable
- Annotations
- @inline()
- def unsafeSubscribe(): Cancelable
- Annotations
- @inline()
- def via(sink: Observer[A]): Observable[A]
- def void: Observable[Unit]
- def withLatest[B, C, D, E, F](latestB: Observable[B], latestC: Observable[C], latestD: Observable[D], latestE: Observable[E], latestF: Observable[F]): Observable[(A, B, C, D, E, F)]
- def withLatest[B, C, D, E](latestB: Observable[B], latestC: Observable[C], latestD: Observable[D], latestE: Observable[E]): Observable[(A, B, C, D, E)]
- def withLatest[B, C, D](latestB: Observable[B], latestC: Observable[C], latestD: Observable[D]): Observable[(A, B, C, D)]
- def withLatest[B, C](latestB: Observable[B], latestC: Observable[C]): Observable[(A, B, C)]
- def withLatest[B](latest: Observable[B]): Observable[(A, B)]
- def withLatestMap[B, C, D, E, F, G, R](latestB: Observable[B], latestC: Observable[C], latestD: Observable[D], latestE: Observable[E], latestF: Observable[F], latestG: Observable[G])(f: (A, B, C, D, E, F, G) => R): Observable[R]
- def withLatestMap[B, C, D, E, F, R](latestB: Observable[B], latestC: Observable[C], latestD: Observable[D], latestE: Observable[E], latestF: Observable[F])(f: (A, B, C, D, E, F) => R): Observable[R]
- def withLatestMap[B, C, D, E, R](latestB: Observable[B], latestC: Observable[C], latestD: Observable[D], latestE: Observable[E])(f: (A, B, C, D, E) => R): Observable[R]
- def withLatestMap[B, C, D, R](latestB: Observable[B], latestC: Observable[C], latestD: Observable[D])(f: (A, B, C, D) => R): Observable[R]
- def withLatestMap[B, C, R](latestB: Observable[B], latestC: Observable[C])(f: (A, B, C) => R): Observable[R]
- def withLatestMap[B, R](latest: Observable[B])(f: (A, B) => R): Observable[R]
- def zip[B, C, D, E, F](sourceB: Observable[B], sourceC: Observable[C], sourceD: Observable[D], sourceE: Observable[E], sourceF: Observable[F]): Observable[(A, B, C, D, E, F)]
- Annotations
- @inline()
- def zip[B, C, D, E](sourceB: Observable[B], sourceC: Observable[C], sourceD: Observable[D], sourceE: Observable[E]): Observable[(A, B, C, D, E)]
- Annotations
- @inline()
- def zip[B, C, D](sourceB: Observable[B], sourceC: Observable[C], sourceD: Observable[D]): Observable[(A, B, C, D)]
- Annotations
- @inline()
- def zip[B, C](sourceB: Observable[B], sourceC: Observable[C]): Observable[(A, B, C)]
- Annotations
- @inline()
- def zip[B](sourceB: Observable[B]): Observable[(A, B)]
- Annotations
- @inline()
- def zipMap[B, C, D, E, F, R](sourceB: Observable[B], sourceC: Observable[C], sourceD: Observable[D], sourceE: Observable[E], sourceF: Observable[F])(f: (A, B, C, D, E, F) => R): Observable[R]
- def zipMap[B, C, D, E, R](sourceB: Observable[B], sourceC: Observable[C], sourceD: Observable[D], sourceE: Observable[E])(f: (A, B, C, D, E) => R): Observable[R]
- def zipMap[B, C, D, R](sourceB: Observable[B], sourceC: Observable[C], sourceD: Observable[D])(f: (A, B, C, D) => R): Observable[R]
- def zipMap[B, C, R](sourceB: Observable[B], sourceC: Observable[C])(f: (A, B, C) => R): Observable[R]
- def zipMap[B, R](sourceB: Observable[B])(f: (A, B) => R): Observable[R]
- def zipWithIndex[R]: Observable[(A, Int)]
Deprecated Value Members
- def doOnError(f: (Throwable) => Unit): Observable[A]
- Annotations
- @deprecated
- Deprecated
(Since version 0.3.4) Use .tapFailed(f) instead
- def doOnNext(f: (A) => Unit): Observable[A]
- Annotations
- @deprecated
- Deprecated
(Since version 0.3.4) Use .tap(f) instead
- def doOnSubscribe(f: () => Cancelable): Observable[A]
- Annotations
- @deprecated
- Deprecated
(Since version 0.3.4) Use .tapSubscribe(f) instead
- def foreach(f: (A) => Unit): Cancelable
- Annotations
- @deprecated @inline()
- Deprecated
(Since version 0.3.0) Use unsafeForeach(f) or foreach_(f).unsafeSubscribe() instead
- def mapAsync[F[_], B](f: (A) => F[B])(implicit arg0: RunEffect[F]): Observable[B]
- Annotations
- @deprecated
- Deprecated
(Since version 0.3.0) Use mapEffect instead
- def mapAsyncSingleOrDrop[F[_], B](f: (A) => F[B])(implicit arg0: RunEffect[F]): Observable[B]
- Annotations
- @deprecated
- Deprecated
(Since version 0.3.0) Use mapEffectSingleOrDrop instead
- def mapSync[F[_], B](f: (A) => F[B])(implicit arg0: RunSyncEffect[F]): Observable[B]
- Annotations
- @deprecated @inline()
- Deprecated
(Since version 0.3.0) Use mapEffect instead
- def prependAsync[F[_]](value: F[A])(implicit arg0: RunEffect[F]): Observable[A]
- Annotations
- @deprecated @inline()
- Deprecated
(Since version 0.3.0) Use prependEffect instead
- def prependSync[F[_]](value: F[A])(implicit arg0: RunSyncEffect[F]): Observable[A]
- Annotations
- @deprecated @inline()
- Deprecated
(Since version 0.3.0) Use prependEffect instead
- def recoverToEither: Observable[Either[Throwable, A]]
- Annotations
- @deprecated
- Deprecated
(Since version 0.3.0) Use attempt instead
- def replay: Connectable[MaybeValue[A]]
- Annotations
- @deprecated @inline()
- Deprecated
(Since version 0.3.4) Use replayLatest instead
- def replaySelector[B](f: (MaybeValue[A]) => Observable[B]): Observable[B]
- Annotations
- @deprecated @inline()
- Deprecated
(Since version 0.3.4) Use replayLatestSelector instead
- def subscribe(): Cancelable
- Annotations
- @deprecated @inline()
- Deprecated
(Since version 0.3.0) Use unsafeSubscribe() or subscribeF[F] instead
- def subscribe(sink: Observer[A]): Cancelable
- Annotations
- @deprecated @inline()
- Deprecated
(Since version 0.3.0) Use unsafeSubscribe(sink) or to(sink).unsafeSubscribe() or to(sink).subscribeF[F] instead
- def withDefaultSubscription(sink: Observer[A]): Observable[A]
- Annotations
- @deprecated
- Deprecated
(Since version 0.4.3) Manage subscriptions directly with subscribe, to, via, etc.