colibri/colibri/Observable/Operations

Operations

@inline
final implicit implicit class Operations[A](val source: Observable[A]) extends AnyVal
class AnyVal
trait Matchable
class Any

Value members

Concrete methods

@inline
def async: Observable[A]
@inline
def behavior(value: A): Connectable[Value[A]]
@inline
def behaviorSelector[B](value: A)(f: Value[A] => Observable[B]): Observable[B]
def collect[B](f: PartialFunction[A, B]): Observable[B]
@inline
def combineLatest[B](sourceB: Observable[B]): Observable[(A, B)]
@inline
def combineLatest[B, C](sourceB: Observable[B], sourceC: Observable[C]): Observable[(A, B, C)]
@inline
def combineLatest[B, C, D](sourceB: Observable[B], sourceC: Observable[C], sourceD: Observable[D]): Observable[(A, B, C, D)]
@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)]
@inline
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)]
def combineLatestMap[B, R](sourceB: Observable[B])(f: (A, B) => R): Observable[R]
def combineLatestMap[B, C, R](sourceB: Observable[B], sourceC: Observable[C])(f: (A, B, C) => 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, 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, 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]
@inline
def debounce(duration: FiniteDuration): Observable[A]
def debounceMillis(duration: Int): Observable[A]
@inline
def delay(duration: FiniteDuration): Observable[A]
def delayMillis(duration: Int): Observable[A]
@inline
def distinct(implicit equality: Eq[A]): Observable[A]
def distinctBy[B](f: A => B)(implicit equality: Eq[B]): Observable[A]
@inline
def distinctByOnEquals[B](f: A => B): Observable[A]
def doOnError(f: Throwable => Unit): Observable[A]
def doOnNext(f: A => Unit): Observable[A]
def drop(num: Int): Observable[A]
def dropUntil(until: Observable[Unit]): Observable[A]
def dropWhile(predicate: A => Boolean): Observable[A]
def failed: Observable[Throwable]
def filter(f: A => Boolean): Observable[A]
@inline
def foreach(f: A => Unit): Cancelable
@inline
def head: Observable[A]
def headIO: IO[A]
def map[B](f: A => B): Observable[B]
def mapAsync[F[_] : Effect, B](f: A => F[B]): Observable[B]
def mapAsyncSingleOrDrop[F[_] : Effect, B](f: A => F[B]): Observable[B]
def mapEither[B](f: A => Either[Throwable, B]): Observable[B]
def mapFilter[B](f: A => Option[B]): Observable[B]
@inline
def mapFuture[B](f: A => Future[B])(implicit ec: ExecutionContext): Observable[B]
@inline
def mapFutureSingleOrDrop[B](f: A => Future[B])(implicit ec: ExecutionContext): Observable[B]
def mapIterable[B](f: A => Iterable[B]): Observable[B]
@inline
def mapSync[F[_] : RunSyncEffect, B](f: A => F[B]): Observable[B]
def mergeMap[B](f: A => Observable[B]): Observable[B]
def prepend(value: A): Observable[A]
@inline
def prependAsync[F[_] : Effect](value: F[A]): Observable[A]
@inline
def prependFuture(value: Future[A])(implicit ec: ExecutionContext): Observable[A]
@inline
def prependSync[F[_] : RunSyncEffect](value: F[A]): Observable[A]
@inline
def publish: Connectable[Observable[A]]
@inline
def publishSelector[B](f: Observable[A] => Observable[B]): Observable[B]
def recover(f: PartialFunction[Throwable, A]): Observable[A]
def recoverOption(f: PartialFunction[Throwable, Option[A]]): Observable[A]
def recoverToEither: Observable[Either[Throwable, A]]
@inline
def replay: Connectable[MaybeValue[A]]
@inline
def replaySelector[B](f: MaybeValue[A] => Observable[B]): Observable[B]
@inline
def sample(duration: FiniteDuration): Observable[A]
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]]
def startWith(values: Iterable[A]): Observable[A]
@inline
def subscribe(): Cancelable
def switchMap[B](f: A => Observable[B]): Observable[B]
def take(num: Int): Observable[A]
def takeUntil(until: Observable[Unit]): Observable[A]
def takeWhile(predicate: A => Boolean): Observable[A]
@inline
def transformSink[B](transform: Observer[B] => Observer[A]): Observable[B]
@inline
def transformSource[B](transform: Observable[A] => Observable[B]): Observable[B]
def via(sink: Observer[A]): Observable[A]
def withLatest[B](latest: Observable[B]): Observable[(A, B)]
def withLatest[B, C](latestB: Observable[B], latestC: Observable[C]): Observable[(A, B, C)]
def withLatest[B, C, D](latestB: Observable[B], latestC: Observable[C], latestD: Observable[D]): Observable[(A, B, C, D)]
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, 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 withLatestMap[B, R](latest: Observable[B])(f: (A, B) => R): Observable[R]
def withLatestMap[B, C, R](latestB: Observable[B], latestC: Observable[C])(f: (A, B, C) => 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, 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, 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, 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]
@inline
def zip[B](sourceB: Observable[B]): Observable[(A, B)]
@inline
def zip[B, C](sourceB: Observable[B], sourceC: Observable[C]): Observable[(A, B, C)]
@inline
def zip[B, C, D](sourceB: Observable[B], sourceC: Observable[C], sourceD: Observable[D]): Observable[(A, B, C, D)]
@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)]
@inline
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)]
def zipMap[B, R](sourceB: Observable[B])(f: (A, B) => R): Observable[R]
def zipMap[B, C, R](sourceB: Observable[B], sourceC: Observable[C])(f: (A, B, C) => 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, 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, 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 zipWithIndex[R]: Observable[(A, Int)]

Concrete fields