colibri/colibri/Observable

Observable

trait Observable[+A]
Companion:
object
class Object
trait Matchable
class Any
object Empty.type
trait Hot[A]
trait MaybeValue[A]
trait HotMaybeValue[A]
trait Value[A]
trait HotValue[A]

Value members

Abstract methods

Concrete methods

def adaptError(f: PartialFunction[Throwable, Throwable]): Observable[A]
Implicitly added by Operations
def append(value: A): Observable[A]
Implicitly added by Operations
def appendEffect[F[_] : RunEffect](value: F[A]): Observable[A]
Implicitly added by Operations
def appendEval(value: => A): Observable[A]
Implicitly added by Operations
def appendFuture(value: => Future[A]): Observable[A]
Implicitly added by Operations
def as[B](value: B): Observable[B]
Implicitly added by Operations
def asEffect[F[_] : RunEffect, B](value: F[B]): Observable[B]
Implicitly added by Operations
def asEval[B](value: => B): Observable[B]
Implicitly added by Operations
def asFuture[B](value: => Future[B]): Observable[B]
Implicitly added by Operations
def async: Observable[A]
Implicitly added by Operations
def asyncMacro: Observable[A]
Implicitly added by Operations
def asyncMicro: Observable[A]
Implicitly added by Operations
def attempt: Observable[Either[Throwable, A]]
Implicitly added by Operations
def behavior(seed: A): Connectable[Value[A]]
Implicitly added by Operations
def behaviorSelector[B](value: A)(f: Value[A] => Observable[B]): Observable[B]
Implicitly added by Operations
def behaviorShare(seed: A): Value[A]
Implicitly added by Operations
def collect[B](f: PartialFunction[A, B]): Observable[B]
Implicitly added by Operations
def combineLatest[B](sourceB: Observable[B]): Observable[(A, B)]
Implicitly added by Operations
def combineLatest[B, C](sourceB: Observable[B], sourceC: Observable[C]): Observable[(A, B, C)]
Implicitly added by Operations
def combineLatest[B, C, D](sourceB: Observable[B], sourceC: Observable[C], sourceD: Observable[D]): Observable[(A, B, C, D)]
Implicitly added by Operations
def combineLatest[B, C, D, E](sourceB: Observable[B], sourceC: Observable[C], sourceD: Observable[D], sourceE: Observable[E]): Observable[(A, B, C, D, E)]
Implicitly added by Operations
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)]
Implicitly added by Operations
def combineLatestMap[B, R](sourceB: Observable[B])(f: (A, B) => R): Observable[R]
Implicitly added by Operations
def combineLatestMap[B, C, R](sourceB: Observable[B], sourceC: Observable[C])(f: (A, B, C) => R): Observable[R]
Implicitly added by Operations
def combineLatestMap[B, C, D, R](sourceB: Observable[B], sourceC: Observable[C], sourceD: Observable[D])(f: (A, B, C, D) => R): Observable[R]
Implicitly added by Operations
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]
Implicitly added by Operations
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]
Implicitly added by Operations
def concat(sources: Observable[A]*): Observable[A]
Implicitly added by Operations
def concatMap[B](f: A => Observable[B]): Observable[B]
Implicitly added by Operations
def concatMapEffect[F[_] : RunEffect, B](f: A => F[B]): Observable[B]
Implicitly added by Operations
def concatMapFuture[B](f: A => Future[B]): Observable[B]
Implicitly added by Operations
def debounce(duration: FiniteDuration): Observable[A]
Implicitly added by Operations
def debounceMillis(duration: Int): Observable[A]
Implicitly added by Operations
def debugLog: Observable[A]
Implicitly added by Operations
def debugLog(prefix: String): Observable[A]
Implicitly added by Operations
def delay(duration: FiniteDuration): Observable[A]
Implicitly added by Operations
def delayMillis(duration: Int): Observable[A]
Implicitly added by Operations
def discard: Observable[Nothing]
Implicitly added by Operations
def distinct(implicit equality: Eq[A]): Observable[A]
Implicitly added by Operations
def distinctBy[B](f: A => B)(implicit equality: Eq[B]): Observable[A]
Implicitly added by Operations
def distinctByOnEquals[B](f: A => B): Observable[A]
Implicitly added by Operations
def distinctOnEquals: Observable[A]
Implicitly added by Operations
def drop(num: Int): Observable[A]
Implicitly added by Operations
def dropFailed: Observable[A]
Implicitly added by Operations
def dropSyncAll: Observable[A]
Implicitly added by Operations
def dropSyncGlitches: Observable[A]
Implicitly added by Operations
def dropUntil(until: Observable[Unit]): Observable[A]
Implicitly added by Operations
def dropUntilSyncLatest: Observable[A]
Implicitly added by Operations
def dropWhile(predicate: A => Boolean): Observable[A]
Implicitly added by Operations
def endWith(values: Iterable[A]): Observable[A]
Implicitly added by Operations
def evalOn(ec: ExecutionContext): Observable[A]
Implicitly added by Operations
def failed: Observable[Throwable]
Implicitly added by Operations
def filter(f: A => Boolean): Observable[A]
Implicitly added by Operations
def flatMap[B](f: A => Observable[B]): Observable[B]
Implicitly added by Operations
def flattenEither: Observable[A]
Implicitly added by EitherOperations
def flattenIterable: Observable[A]
Implicitly added by IterableOperations
def flattenOption: Observable[A]
Implicitly added by OptionOperations
def fold[B](seed: B)(f: (B, A) => B): Observable[B]
Implicitly added by Operations
def foldF[F[_] : Async, B](seed: B)(f: (B, A) => B): F[B]
Implicitly added by Operations
def foldIO[B](seed: B)(f: (B, A) => B): IO[B]
Implicitly added by Operations
def foreach_(f: A => Unit): Observable[Unit]
Implicitly added by Operations
def head: Observable[A]
Implicitly added by Operations
def headF[F[_] : Async]: F[A]
Implicitly added by Operations
def headIO: IO[A]
Implicitly added by Operations
def last: Observable[A]
Implicitly added by Operations
def lastF[F[_] : Async]: F[A]
Implicitly added by Operations
def lastIO: IO[A]
Implicitly added by Operations
def liftSource[H[_] : LiftSource]: H[A]
Implicitly added by Operations
def map[B](f: A => B): Observable[B]
Implicitly added by Operations
def mapEffect[F[_] : RunEffect, B](f: A => F[B]): Observable[B]
Implicitly added by Operations
def mapEither[B](f: A => Either[Throwable, B]): Observable[B]
Implicitly added by Operations
def mapFilter[B](f: A => Option[B]): Observable[B]
Implicitly added by Operations
def mapFuture[B](f: A => Future[B]): Observable[B]
Implicitly added by Operations
def mapIterable[B](f: A => Iterable[B]): Observable[B]
Implicitly added by Operations
def mapResource[F[_] : Sync, B](f: A => Resource[F, B]): Observable[B]
Implicitly added by Operations
def merge(sources: Observable[A]*): Observable[A]
Implicitly added by Operations
def mergeFailed: Observable[Throwable]
Implicitly added by ThrowableOperations
def mergeMap[B](f: A => Observable[B]): Observable[B]
Implicitly added by Operations
def mergeMapEffect[F[_] : RunEffect, B](f: A => F[B]): Observable[B]
Implicitly added by Operations
def mergeMapFuture[B](f: A => Future[B]): Observable[B]
Implicitly added by Operations
def multicast(pipe: Subject[A]): Connectable[Observable[A]]
Implicitly added by Operations
def multicastMaybeValue(pipe: MaybeValue[A]): Connectable[MaybeValue[A]]
Implicitly added by Operations
def multicastValue(pipe: Value[A]): Connectable[Value[A]]
Implicitly added by Operations
def negated: Observable[Boolean]
Implicitly added by BooleanOperations
def parMapEffect[B, F[_] : RunEffect](f: A => F[B]): Observable[B]
Implicitly added by Operations
def parMapFuture[B](f: A => Future[B]): Observable[B]
Implicitly added by Operations
def prepend(value: A): Observable[A]
Implicitly added by Operations
def prependEffect[F[_] : RunEffect](value: F[A]): Observable[A]
Implicitly added by Operations
def prependEval(value: => A): Observable[A]
Implicitly added by Operations
def prependFuture(value: => Future[A]): Observable[A]
Implicitly added by Operations
def publish: Connectable[Observable[A]]
Implicitly added by Operations
def publishSelector[B](f: Observable[A] => Observable[B]): Observable[B]
Implicitly added by Operations
def publishShare: Observable[A]
Implicitly added by Operations
def recover(f: PartialFunction[Throwable, A]): Observable[A]
Implicitly added by Operations
def recoverMap(f: Throwable => A): Observable[A]
Implicitly added by Operations
def recoverOption(f: PartialFunction[Throwable, Option[A]]): Observable[A]
Implicitly added by Operations
def replayAll: Connectable[Observable[A]]
Implicitly added by Operations
def replayAllSelector[B](f: Observable[A] => Observable[B]): Observable[B]
Implicitly added by Operations
def replayAllShare: Observable[A]
Implicitly added by Operations
def replayLatest: Connectable[MaybeValue[A]]
Implicitly added by Operations
def replayLatestSelector[B](f: MaybeValue[A] => Observable[B]): Observable[B]
Implicitly added by Operations
def replayLatestShare: MaybeValue[A]
Implicitly added by Operations
def sample(duration: FiniteDuration): Observable[A]
Implicitly added by Operations
def sampleMillis(duration: Int): Observable[A]
Implicitly added by Operations
def scan[B](seed: B)(f: (B, A) => B): Observable[B]
Implicitly added by Operations
def scan0[B](seed: B)(f: (B, A) => B): Observable[B]
Implicitly added by Operations
def scan0ToList: Observable[List[A]]
Implicitly added by Operations
def scanToList: Observable[List[A]]
Implicitly added by Operations
def singleMapEffect[F[_] : RunEffect, B](f: A => F[B]): Observable[B]
Implicitly added by Operations
def singleMapEffect[B](f: A => Future[B]): Observable[B]
Implicitly added by Operations
def startWith(values: Iterable[A]): Observable[A]
Implicitly added by Operations
def subscribeF[F[_] : Sync]: F[Cancelable]
Implicitly added by Operations
def subscribeIO: IO[Cancelable]
Implicitly added by Operations
def subscribeSyncIO: SyncIO[Cancelable]
Implicitly added by Operations
def subscribing[B](f: Observable[B]): Observable[A]
Implicitly added by Operations
def switch(sources: Observable[A]*): Observable[A]
Implicitly added by Operations
def switchMap[B](f: A => Observable[B]): Observable[B]
Implicitly added by Operations
def switchMapEffect[F[_] : RunEffect, B](f: A => F[B]): Observable[B]
Implicitly added by Operations
def switchMapFuture[B](f: A => Future[B]): Observable[B]
Implicitly added by Operations
def switchMapResource[F[_] : Sync, B](f: A => Resource[F, B]): Observable[B]
Implicitly added by Operations
def switchScan[B](seed: B)(f: (B, A) => Observable[B]): Observable[B]
Implicitly added by Operations
def syncAll: Observable[A]
Implicitly added by Operations
def syncAllF[F[_] : Sync]: F[Seq[A]]
Implicitly added by Operations
def syncAllIO: IO[Seq[A]]
Implicitly added by Operations
def syncAllSyncIO: SyncIO[Seq[A]]
Implicitly added by Operations
def syncLatest: Observable[A]
Implicitly added by Operations
def syncLatestF[F[_] : Sync]: F[Option[A]]
Implicitly added by Operations
def syncLatestIO: IO[Option[A]]
Implicitly added by Operations
def syncLatestSyncIO: SyncIO[Option[A]]
Implicitly added by Operations
def tail: Observable[A]
Implicitly added by Operations
def take(num: Int): Observable[A]
Implicitly added by Operations
def takeUntil(until: Observable[Unit]): Observable[A]
Implicitly added by Operations
def takeWhile(predicate: A => Boolean): Observable[A]
Implicitly added by Operations
def takeWhileInclusive(predicate: A => Boolean): Observable[A]
Implicitly added by Operations
def tap(f: A => Unit): Observable[A]
Implicitly added by Operations
def tapCancel(f: () => Unit): Observable[A]
Implicitly added by Operations
def tapEffect[F[_] : Functor](f: A => F[Unit]): Observable[A]
Implicitly added by Operations
def tapFailed(f: Throwable => Unit): Observable[A]
Implicitly added by Operations
def tapFailedEffect[F[_] : Applicative](f: Throwable => F[Unit]): Observable[A]
Implicitly added by Operations
def tapSubscribe(f: () => Cancelable): Observable[A]
Implicitly added by Operations
def tapSubscribeEffect[F[_] : RunEffect](f: F[Cancelable]): Observable[A]
Implicitly added by Operations
def to(sink: Observer[A]): Observable[Unit]
Implicitly added by Operations
def toggle[A](ifTrue: => A, ifFalse: A): Observable[A]
Implicitly added by BooleanOperations
def toggle[A : Monoid](ifTrue: => A): Observable[A]
Implicitly added by BooleanOperations
def transformSink[B](transform: Observer[B] => Observer[A]): Observable[B]
Implicitly added by Operations
def transformSource[B](transform: Observable[A] => Observable[B]): Observable[B]
Implicitly added by Operations
def unsafeFoldFuture[B](seed: B)(f: (B, A) => B): Future[B]
Implicitly added by Operations
def unsafeForeach(f: A => Unit): Cancelable
Implicitly added by Operations
def unsafeHeadFuture(): Future[A]
Implicitly added by Operations
def unsafeLastFuture(): Future[A]
Implicitly added by Operations
def unsafeSubscribe(): Cancelable
Implicitly added by Operations
def via(sink: Observer[A]): Observable[A]
Implicitly added by Operations
def void: Observable[Unit]
Implicitly added by Operations
def withLatest[B](latest: Observable[B]): Observable[(A, B)]
Implicitly added by Operations
def withLatest[B, C](latestB: Observable[B], latestC: Observable[C]): Observable[(A, B, C)]
Implicitly added by Operations
def withLatest[B, C, D](latestB: Observable[B], latestC: Observable[C], latestD: Observable[D]): Observable[(A, B, C, D)]
Implicitly added by Operations
def withLatest[B, C, D, E](latestB: Observable[B], latestC: Observable[C], latestD: Observable[D], latestE: Observable[E]): Observable[(A, B, C, D, E)]
Implicitly added by Operations
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)]
Implicitly added by Operations
def withLatestMap[B, R](latest: Observable[B])(f: (A, B) => R): Observable[R]
Implicitly added by Operations
def withLatestMap[B, C, R](latestB: Observable[B], latestC: Observable[C])(f: (A, B, C) => R): Observable[R]
Implicitly added by Operations
def withLatestMap[B, C, D, R](latestB: Observable[B], latestC: Observable[C], latestD: Observable[D])(f: (A, B, C, D) => R): Observable[R]
Implicitly added by Operations
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]
Implicitly added by Operations
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]
Implicitly added by Operations
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]
Implicitly added by Operations
def zip[B](sourceB: Observable[B]): Observable[(A, B)]
Implicitly added by Operations
def zip[B, C](sourceB: Observable[B], sourceC: Observable[C]): Observable[(A, B, C)]
Implicitly added by Operations
def zip[B, C, D](sourceB: Observable[B], sourceC: Observable[C], sourceD: Observable[D]): Observable[(A, B, C, D)]
Implicitly added by Operations
def zip[B, C, D, E](sourceB: Observable[B], sourceC: Observable[C], sourceD: Observable[D], sourceE: Observable[E]): Observable[(A, B, C, D, E)]
Implicitly added by Operations
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)]
Implicitly added by Operations
def zipMap[B, R](sourceB: Observable[B])(f: (A, B) => R): Observable[R]
Implicitly added by Operations
def zipMap[B, C, R](sourceB: Observable[B], sourceC: Observable[C])(f: (A, B, C) => R): Observable[R]
Implicitly added by Operations
def zipMap[B, C, D, R](sourceB: Observable[B], sourceC: Observable[C], sourceD: Observable[D])(f: (A, B, C, D) => R): Observable[R]
Implicitly added by Operations
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]
Implicitly added by Operations
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]
Implicitly added by Operations
def zipWithIndex[R]: Observable[(A, Int)]
Implicitly added by Operations

Deprecated methods

def doOnError(f: Throwable => Unit): Observable[A]
Implicitly added by Operations
Deprecated
def doOnNext(f: A => Unit): Observable[A]
Implicitly added by Operations
Deprecated
def doOnSubscribe(f: () => Cancelable): Observable[A]
Implicitly added by Operations
Deprecated
def foreach(f: A => Unit): Cancelable
Implicitly added by Operations
Deprecated
def mapAsync[F[_] : RunEffect, B](f: A => F[B]): Observable[B]
Implicitly added by Operations
Deprecated
def mapAsyncSingleOrDrop[F[_] : RunEffect, B](f: A => F[B]): Observable[B]
Implicitly added by Operations
Deprecated
def mapEffectSingleOrDrop[F[_] : RunEffect, B](f: A => F[B]): Observable[B]
Implicitly added by Operations
Deprecated
def mapFutureSingleOrDrop[B](f: A => Future[B]): Observable[B]
Implicitly added by Operations
Deprecated
def mapSync[F[_] : RunSyncEffect, B](f: A => F[B]): Observable[B]
Implicitly added by Operations
Deprecated
def prependAsync[F[_] : RunEffect](value: F[A]): Observable[A]
Implicitly added by Operations
Deprecated
def prependSync[F[_] : RunSyncEffect](value: F[A]): Observable[A]
Implicitly added by Operations
Deprecated
def recoverToEither: Observable[Either[Throwable, A]]
Implicitly added by Operations
Deprecated
def replay: Connectable[MaybeValue[A]]
Implicitly added by Operations
Deprecated
def replaySelector[B](f: MaybeValue[A] => Observable[B]): Observable[B]
Implicitly added by Operations
Deprecated
def subscribe(sink: Observer[A]): Cancelable
Implicitly added by Operations
Deprecated
def subscribe(): Cancelable
Implicitly added by Operations
Deprecated
def withDefaultSubscription(sink: Observer[A]): Observable[A]
Implicitly added by Operations
Deprecated