Observable

Value Members

final def !=(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def !=(arg0: Any): Boolean

Definition Classes
Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def ==(arg0: Any): Boolean

Definition Classes
Any
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def combineLatest2[A1, A2](oa1: Observable[A1], oa2: Observable[A2]): Observable[(A1, A2)]

Creates a combined observable from 2 source observables.
Creates a combined observable from 2 source observables.
This operator behaves in a similar way to zip2, but while zip emits items only when all of the zipped source observables have emitted a previously unzipped item, combine emits an item whenever any of the source Observables emits an item (so long as each of the source Observables has emitted at least one item).
def combineLatest3[A1, A2, A3](oa1: Observable[A1], oa2: Observable[A2], oa3: Observable[A3]): Observable[(A1, A2, A3)]

Creates a combined observable from 3 source observables.
Creates a combined observable from 3 source observables.
This operator behaves in a similar way to zip3, but while zip emits items only when all of the zipped source observables have emitted a previously unzipped item, combine emits an item whenever any of the source Observables emits an item (so long as each of the source Observables has emitted at least one item).
def combineLatest4[A1, A2, A3, A4](oa1: Observable[A1], oa2: Observable[A2], oa3: Observable[A3], oa4: Observable[A4]): Observable[(A1, A2, A3, A4)]

Creates a combined observable from 4 source observables.
Creates a combined observable from 4 source observables.
This operator behaves in a similar way to zip4, but while zip emits items only when all of the zipped source observables have emitted a previously unzipped item, combine emits an item whenever any of the source Observables emits an item (so long as each of the source Observables has emitted at least one item).
def combineLatest5[A1, A2, A3, A4, A5](oa1: Observable[A1], oa2: Observable[A2], oa3: Observable[A3], oa4: Observable[A4], oa5: Observable[A5]): Observable[(A1, A2, A3, A4, A5)]

Creates a combined observable from 5 source observables.
Creates a combined observable from 5 source observables.
This operator behaves in a similar way to zip5, but while zip emits items only when all of the zipped source observables have emitted a previously unzipped item, combine emits an item whenever any of the source Observables emits an item (so long as each of the source Observables has emitted at least one item).
def combineLatest6[A1, A2, A3, A4, A5, A6](oa1: Observable[A1], oa2: Observable[A2], oa3: Observable[A3], oa4: Observable[A4], oa5: Observable[A5], oa6: Observable[A6]): Observable[(A1, A2, A3, A4, A5, A6)]

Creates a combined observable from 6 source observables.
Creates a combined observable from 6 source observables.
This operator behaves in a similar way to zip6, but while zip emits items only when all of the zipped source observables have emitted a previously unzipped item, combine emits an item whenever any of the source Observables emits an item (so long as each of the source Observables has emitted at least one item).
def combineLatestList[A](sources: Observable[A]*): Observable[Seq[A]]

Given an observable sequence, it combines them together (using combineLatest) returning a new observable that generates sequences.
def combineLatestWith2[A1, A2, R](oa1: Observable[A1], oa2: Observable[A2])(f: (A1, A2) ⇒ R): Observable[R]

Creates a combined observable from 2 source observables.
Creates a combined observable from 2 source observables.
This operator behaves in a similar way to zipWith2, but while zip emits items only when all of the zipped source observables have emitted a previously unzipped item, combine emits an item whenever any of the source Observables emits an item (so long as each of the source Observables has emitted at least one item).
def combineLatestWith3[A1, A2, A3, R](a1: Observable[A1], a2: Observable[A2], a3: Observable[A3])(f: (A1, A2, A3) ⇒ R): Observable[R]

Creates a combined observable from 3 source observables.
Creates a combined observable from 3 source observables.
This operator behaves in a similar way to zipWith3, but while zip emits items only when all of the zipped source observables have emitted a previously unzipped item, combine emits an item whenever any of the source Observables emits an item (so long as each of the source Observables has emitted at least one item).
def combineLatestWith4[A1, A2, A3, A4, R](a1: Observable[A1], a2: Observable[A2], a3: Observable[A3], a4: Observable[A4])(f: (A1, A2, A3, A4) ⇒ R): Observable[R]

Creates a combined observable from 4 source observables.
Creates a combined observable from 4 source observables.
This operator behaves in a similar way to zipWith4, but while zip emits items only when all of the zipped source observables have emitted a previously unzipped item, combine emits an item whenever any of the source Observables emits an item (so long as each of the source Observables has emitted at least one item).
def combineLatestWith5[A1, A2, A3, A4, A5, R](a1: Observable[A1], a2: Observable[A2], a3: Observable[A3], a4: Observable[A4], a5: Observable[A5])(f: (A1, A2, A3, A4, A5) ⇒ R): Observable[R]

Creates a combined observable from 5 source observables.
Creates a combined observable from 5 source observables.
This operator behaves in a similar way to zipWith5, but while zip emits items only when all of the zipped source observables have emitted a previously unzipped item, combine emits an item whenever any of the source Observables emits an item (so long as each of the source Observables has emitted at least one item).
def combineLatestWith6[A1, A2, A3, A4, A5, A6, R](a1: Observable[A1], a2: Observable[A2], a3: Observable[A3], a4: Observable[A4], a5: Observable[A5], a6: Observable[A6])(f: (A1, A2, A3, A4, A5, A6) ⇒ R): Observable[R]

Creates a combined observable from 6 source observables.
Creates a combined observable from 6 source observables.
This operator behaves in a similar way to zipWith6, but while zip emits items only when all of the zipped source observables have emitted a previously unzipped item, combine emits an item whenever any of the source Observables emits an item (so long as each of the source Observables has emitted at least one item).
def concat[A](sources: Observable[A]*): Observable[A]

Concatenates the given list of observables into a single observable.
def concatDelayError[A](sources: Observable[A]*): Observable[A]

Concatenates the given list of observables into a single observable.
Concatenates the given list of observables into a single observable. Delays errors until the end.
def cons[A](head: A, tail: Observable[A]): Observable[A]

Builds a new observable from a strict head and a lazily evaluated head.
def create[A](overflowStrategy: Synchronous[A])(f: (SyncSubscriber[A]) ⇒ Cancelable): Observable[A]

Creates an observable from a function that receives a concurrent and safe SyncSubscriber.
Creates an observable from a function that receives a concurrent and safe SyncSubscriber.
This builder represents the safe way of building observables from data-sources that cannot be back-pressured.
def defer[A](factory: ⇒ Observable[A]): Observable[A]

Returns a new observable that creates a sequence from the given factory on each subscription.
def empty[A]: Observable[A]

Creates an observable that doesn't emit anything, but immediately calls onComplete instead.
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def evalAlways[A](a: ⇒ A): Observable[A]

Given a non-strict value, converts it into an Observable that emits a single element.
def evalDelayed[A](delay: FiniteDuration, a: ⇒ A): Observable[A]

Lifts a non-strict value into an observable that emits a single element, but upon subscription delay its evaluation by the specified timespan
def evalOnce[A](f: ⇒ A): Observable[A]

Given a non-strict value, converts it into an Observable that emits a single element and that memoizes the value for subsequent invocations.
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def firstStartedOf[A](source: Observable[A]*): Observable[A]

Given a list of source Observables, emits all of the items from the first of these Observables to emit an item or to complete, and cancel the rest.
def flatten[A](sources: Observable[A]*): Observable[A]

Concatenates the given list of observables into a single observable.
def flattenDelayError[A](sources: Observable[A]*): Observable[A]

Concatenates the given list of observables into a single observable.
Concatenates the given list of observables into a single observable. Delays errors until the end.
def fork[A](fa: Observable[A]): Observable[A]

Forks a logical thread on executing the subscription.
def fromFuture[A](factory: ⇒ Future[A]): Observable[A]

Converts a Scala Future provided into an Observable.
Converts a Scala Future provided into an Observable.
If the created instance is a CancelableFuture, then it will be used for the returned Cancelable on subscribe.
def fromIterable[A](iterable: Iterable[A]): Observable[A]

Converts any Iterable into an Observable.
def fromIterator[A](iterator: Iterator[A]): Observable[A]

Converts any Iterator into an Observable.
def fromReactivePublisher[A](publisher: Publisher[A]): Observable[A]

Given a org.reactivestreams.Publisher, converts it into a Monix / Rx Observable.
Given a org.reactivestreams.Publisher, converts it into a Monix / Rx Observable.
See the Reactive Streams protocol that Monix implements.

See also
Observable.toReactive for converting an Observable to a reactive publisher.
def fromStateAction[S, A](f: (S) ⇒ (A, S))(initialState: S): Observable[A]

Given an initial state and a generator function that produces the next state and the next element in the sequence, creates an observable that keeps generating elements produced by our generator function.
def fromTask[A](task: Task[A]): Observable[A]

Converts any Task into an Observable.
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
implicit val instances: Asynchronous[Observable] with Restartable[Observable]

Type-class instances for Observable.
def interval(delay: FiniteDuration): Observable[Long]

Creates an Observable that emits auto-incremented natural numbers (longs) spaced by a given time interval.
Creates an Observable that emits auto-incremented natural numbers (longs) spaced by a given time interval. Starts from 0 with no delay, after which it emits incremented numbers spaced by the period of time. The given period of time acts as a fixed delay between successive events.
delay
the delay between 2 successive events
def intervalAtFixedRate(initialDelay: FiniteDuration, period: FiniteDuration): Observable[Long]

Creates an Observable that emits auto-incremented natural numbers (longs) at a fixed rate, as given by the specified period.
Creates an Observable that emits auto-incremented natural numbers (longs) at a fixed rate, as given by the specified period. The time it takes to process an onNext event gets subtracted from the specified period and thus the created observable tries to emit events spaced by the given time interval, regardless of how long the processing of onNext takes.
This version of the intervalAtFixedRate allows specifying an initialDelay before events start being emitted.
initialDelay
is the initial delay before emitting the first event
period
the period between 2 successive onNext events
def intervalAtFixedRate(period: FiniteDuration): Observable[Long]

Creates an Observable that emits auto-incremented natural numbers (longs) at a fixed rate, as given by the specified period.
Creates an Observable that emits auto-incremented natural numbers (longs) at a fixed rate, as given by the specified period. The time it takes to process an onNext event gets subtracted from the specified period and thus the created observable tries to emit events spaced by the given time interval, regardless of how long the processing of onNext takes.
period
the period between 2 successive onNext events
def intervalWithFixedDelay(initialDelay: FiniteDuration, delay: FiniteDuration): Observable[Long]

Creates an Observable that emits auto-incremented natural numbers (longs) spaced by a given time interval.
Creates an Observable that emits auto-incremented natural numbers (longs) spaced by a given time interval. Starts from 0 with no delay, after which it emits incremented numbers spaced by the period of time. The given period of time acts as a fixed delay between successive events.
initialDelay
is the delay to wait before emitting the first event
delay
the time to wait between 2 successive events
def intervalWithFixedDelay(delay: FiniteDuration): Observable[Long]

Creates an Observable that emits auto-incremented natural numbers (longs) spaced by a given time interval.
Creates an Observable that emits auto-incremented natural numbers (longs) spaced by a given time interval. Starts from 0 with no delay, after which it emits incremented numbers spaced by the period of time. The given period of time acts as a fixed delay between successive events.
delay
the delay between 2 successive events
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def merge[A](sources: Observable[A]*)(implicit os: OverflowStrategy[A] = OverflowStrategy.Default): Observable[A]

Merges the given list of observables into a single observable.
def mergeDelayError[A](sources: Observable[A]*)(implicit os: OverflowStrategy[A] = OverflowStrategy.Default): Observable[A]

Merges the given list of observables into a single observable.
Merges the given list of observables into a single observable. Delays errors until the end.
def multicast[A](multicast: MulticastStrategy[A], overflow: Synchronous[A])(implicit s: Scheduler): (SyncObserver[A], Observable[A])

Creates an input channel and an output observable pair for building a multicast data-source.
Creates an input channel and an output observable pair for building a multicast data-source.
Useful for building multicast observables from data-sources that cannot be back-pressured.
Prefer create when possible.
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def never: Observable[Nothing]

Creates an Observable that doesn't emit anything and that never completes.
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def now[A](elem: A): Observable[A]

Returns an Observable that on execution emits the given strict value.
def pure[A](elem: A): Observable[A]

Lifts an element into the Observable context.
Lifts an element into the Observable context.
Alias for now.
def raiseError(ex: Throwable): Observable[Nothing]

Creates an Observable that emits an error.
def range(from: Long, until: Long, step: Long = 1L): Observable[Long]

Creates an Observable that emits items in the given range.
Creates an Observable that emits items in the given range.
from
the range start
until
the range end
step
increment step, either positive or negative
def repeat[A](elems: A*): Observable[A]

Creates an Observable that continuously emits the given item repeatedly.
def repeatEval[A](task: ⇒ A): Observable[A]

Repeats the execution of the given task, emitting the results indefinitely.
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def timerRepeated[A](initialDelay: FiniteDuration, period: FiniteDuration, unit: A): Observable[A]

Create an Observable that repeatedly emits the given item, until the underlying Observer cancels.
def toReactive[A](source: Observable[A])(implicit s: Scheduler): Publisher[A]

Wraps this Observable into a org.reactivestreams.Publisher.
Wraps this Observable into a org.reactivestreams.Publisher. See the Reactive Streams protocol that Monix implements.
def toString(): String

Definition Classes
AnyRef → Any
def unsafeCreate[A](f: (Subscriber[A]) ⇒ Cancelable): Observable[A]

Given a subscribe function, lifts it into an Observable.
Given a subscribe function, lifts it into an Observable.
This function is unsafe to use because users have to know and apply the Monix communication contract, related to thread-safety, communicating demand (back-pressure) and error handling.
Only use if you know what you're doing. Otherwise prefer create.
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
@throws( ... )
def zip2[A1, A2](oa1: Observable[A1], oa2: Observable[A2]): Observable[(A1, A2)]

Creates a new observable from two observable sequences by combining their items in pairs in a strict sequence.
Creates a new observable from two observable sequences by combining their items in pairs in a strict sequence.
So the first item emitted by the new observable will be the result of the function applied to the first items emitted by each of the source observables; the second item emitted by the new observable will be the result of the function applied to the second items emitted by each of those observables; and so forth.
See combineLatestWith2 for a more relaxed alternative that doesn't combine items in strict sequence.
def zip3[A1, A2, A3](oa1: Observable[A1], oa2: Observable[A2], oa3: Observable[A3]): Observable[(A1, A2, A3)]

Creates a new observable from three observable sequences by combining their items in pairs in a strict sequence.
Creates a new observable from three observable sequences by combining their items in pairs in a strict sequence.
So the first item emitted by the new observable will be the result of the function applied to the first items emitted by each of the source observables; the second item emitted by the new observable will be the result of the function applied to the second items emitted by each of those observables; and so forth.
See combineLatestWith3 for a more relaxed alternative that doesn't combine items in strict sequence.
def zip4[A1, A2, A3, A4](oa1: Observable[A1], oa2: Observable[A2], oa3: Observable[A3], oa4: Observable[A4]): Observable[(A1, A2, A3, A4)]

Creates a new observable from four observable sequences by combining their items in pairs in a strict sequence.
Creates a new observable from four observable sequences by combining their items in pairs in a strict sequence.
So the first item emitted by the new observable will be the result of the function applied to the first items emitted by each of the source observables; the second item emitted by the new observable will be the result of the function applied to the second items emitted by each of those observables; and so forth.
See combineLatestWith4 for a more relaxed alternative that doesn't combine items in strict sequence.
def zip5[A1, A2, A3, A4, A5](oa1: Observable[A1], oa2: Observable[A2], oa3: Observable[A3], oa4: Observable[A4], oa5: Observable[A5]): Observable[(A1, A2, A3, A4, A5)]

Creates a new observable from five observable sequences by combining their items in pairs in a strict sequence.
Creates a new observable from five observable sequences by combining their items in pairs in a strict sequence.
So the first item emitted by the new observable will be the result of the function applied to the first items emitted by each of the source observables; the second item emitted by the new observable will be the result of the function applied to the second items emitted by each of those observables; and so forth.
See combineLatestWith5 for a more relaxed alternative that doesn't combine items in strict sequence.
def zip6[A1, A2, A3, A4, A5, A6](oa1: Observable[A1], oa2: Observable[A2], oa3: Observable[A3], oa4: Observable[A4], oa5: Observable[A5], oa6: Observable[A6]): Observable[(A1, A2, A3, A4, A5, A6)]

Creates a new observable from five observable sequences by combining their items in pairs in a strict sequence.
Creates a new observable from five observable sequences by combining their items in pairs in a strict sequence.
So the first item emitted by the new observable will be the result of the function applied to the first items emitted by each of the source observables; the second item emitted by the new observable will be the result of the function applied to the second items emitted by each of those observables; and so forth.
See combineLatestWith5 for a more relaxed alternative that doesn't combine items in strict sequence.
def zipList[A](sources: Observable[A]*): Observable[Seq[A]]

Given an observable sequence, it zips them together returning a new observable that generates sequences.
def zipWith2[A1, A2, R](oa1: Observable[A1], oa2: Observable[A2])(f: (A1, A2) ⇒ R): Observable[R]

Creates a new observable from two observable sequences by combining their items in pairs in a strict sequence.
Creates a new observable from two observable sequences by combining their items in pairs in a strict sequence.
So the first item emitted by the new observable will be the result of the function applied to the first items emitted by each of the source observables; the second item emitted by the new observable will be the result of the function applied to the second items emitted by each of those observables; and so forth.
See combineLatestWith2 for a more relaxed alternative that doesn't combine items in strict sequence.
f
is the mapping function applied over the generated pairs
def zipWith3[A1, A2, A3, R](oa1: Observable[A1], oa2: Observable[A2], oa3: Observable[A3])(f: (A1, A2, A3) ⇒ R): Observable[R]

Creates a new observable from three observable sequences by combining their items in pairs in a strict sequence.
Creates a new observable from three observable sequences by combining their items in pairs in a strict sequence.
So the first item emitted by the new observable will be the result of the function applied to the first items emitted by each of the source observables; the second item emitted by the new observable will be the result of the function applied to the second items emitted by each of those observables; and so forth.
See combineLatestWith3 for a more relaxed alternative that doesn't combine items in strict sequence.
f
is the mapping function applied over the generated pairs
def zipWith4[A1, A2, A3, A4, R](oa1: Observable[A1], oa2: Observable[A2], oa3: Observable[A3], oa4: Observable[A4])(f: (A1, A2, A3, A4) ⇒ R): Observable[R]

Creates a new observable from four observable sequences by combining their items in pairs in a strict sequence.
Creates a new observable from four observable sequences by combining their items in pairs in a strict sequence.
So the first item emitted by the new observable will be the result of the function applied to the first items emitted by each of the source observables; the second item emitted by the new observable will be the result of the function applied to the second items emitted by each of those observables; and so forth.
See combineLatestWith4 for a more relaxed alternative that doesn't combine items in strict sequence.
f
is the mapping function applied over the generated pairs
def zipWith5[A1, A2, A3, A4, A5, R](oa1: Observable[A1], oa2: Observable[A2], oa3: Observable[A3], oa4: Observable[A4], oa5: Observable[A5])(f: (A1, A2, A3, A4, A5) ⇒ R): Observable[R]

Creates a new observable from five observable sequences by combining their items in pairs in a strict sequence.
Creates a new observable from five observable sequences by combining their items in pairs in a strict sequence.
So the first item emitted by the new observable will be the result of the function applied to the first items emitted by each of the source observables; the second item emitted by the new observable will be the result of the function applied to the second items emitted by each of those observables; and so forth.
See combineLatestWith5 for a more relaxed alternative that doesn't combine items in strict sequence.
f
is the mapping function applied over the generated pairs
def zipWith6[A1, A2, A3, A4, A5, A6, R](oa1: Observable[A1], oa2: Observable[A2], oa3: Observable[A3], oa4: Observable[A4], oa5: Observable[A5], oa6: Observable[A6])(f: (A1, A2, A3, A4, A5, A6) ⇒ R): Observable[R]

Creates a new observable from five observable sequences by combining their items in pairs in a strict sequence.
Creates a new observable from five observable sequences by combining their items in pairs in a strict sequence.
So the first item emitted by the new observable will be the result of the function applied to the first items emitted by each of the source observables; the second item emitted by the new observable will be the result of the function applied to the second items emitted by each of those observables; and so forth.
See combineLatestWith5 for a more relaxed alternative that doesn't combine items in strict sequence.
f
is the mapping function applied over the generated pairs

object Observable

Value Members

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def combineLatest2[A1, A2](oa1: Observable[A1], oa2: Observable[A2]): Observable[(A1, A2)]

def combineLatest3[A1, A2, A3](oa1: Observable[A1], oa2: Observable[A2], oa3: Observable[A3]): Observable[(A1, A2, A3)]

def combineLatest4[A1, A2, A3, A4](oa1: Observable[A1], oa2: Observable[A2], oa3: Observable[A3], oa4: Observable[A4]): Observable[(A1, A2, A3, A4)]

def combineLatest5[A1, A2, A3, A4, A5](oa1: Observable[A1], oa2: Observable[A2], oa3: Observable[A3], oa4: Observable[A4], oa5: Observable[A5]): Observable[(A1, A2, A3, A4, A5)]

def combineLatest6[A1, A2, A3, A4, A5, A6](oa1: Observable[A1], oa2: Observable[A2], oa3: Observable[A3], oa4: Observable[A4], oa5: Observable[A5], oa6: Observable[A6]): Observable[(A1, A2, A3, A4, A5, A6)]

def combineLatestList[A](sources: Observable[A]*): Observable[Seq[A]]

def combineLatestWith2[A1, A2, R](oa1: Observable[A1], oa2: Observable[A2])(f: (A1, A2) ⇒ R): Observable[R]

def combineLatestWith3[A1, A2, A3, R](a1: Observable[A1], a2: Observable[A2], a3: Observable[A3])(f: (A1, A2, A3) ⇒ R): Observable[R]

def combineLatestWith4[A1, A2, A3, A4, R](a1: Observable[A1], a2: Observable[A2], a3: Observable[A3], a4: Observable[A4])(f: (A1, A2, A3, A4) ⇒ R): Observable[R]

def combineLatestWith5[A1, A2, A3, A4, A5, R](a1: Observable[A1], a2: Observable[A2], a3: Observable[A3], a4: Observable[A4], a5: Observable[A5])(f: (A1, A2, A3, A4, A5) ⇒ R): Observable[R]

def combineLatestWith6[A1, A2, A3, A4, A5, A6, R](a1: Observable[A1], a2: Observable[A2], a3: Observable[A3], a4: Observable[A4], a5: Observable[A5], a6: Observable[A6])(f: (A1, A2, A3, A4, A5, A6) ⇒ R): Observable[R]

def concat[A](sources: Observable[A]*): Observable[A]

def concatDelayError[A](sources: Observable[A]*): Observable[A]

def cons[A](head: A, tail: Observable[A]): Observable[A]

def create[A](overflowStrategy: Synchronous[A])(f: (SyncSubscriber[A]) ⇒ Cancelable): Observable[A]

def defer[A](factory: ⇒ Observable[A]): Observable[A]

def empty[A]: Observable[A]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def evalAlways[A](a: ⇒ A): Observable[A]

def evalDelayed[A](delay: FiniteDuration, a: ⇒ A): Observable[A]

def evalOnce[A](f: ⇒ A): Observable[A]

def finalize(): Unit

def firstStartedOf[A](source: Observable[A]*): Observable[A]

def flatten[A](sources: Observable[A]*): Observable[A]

def flattenDelayError[A](sources: Observable[A]*): Observable[A]

def fork[A](fa: Observable[A]): Observable[A]

def fromFuture[A](factory: ⇒ Future[A]): Observable[A]

def fromIterable[A](iterable: Iterable[A]): Observable[A]

def fromIterator[A](iterator: Iterator[A]): Observable[A]

def fromReactivePublisher[A](publisher: Publisher[A]): Observable[A]

def fromStateAction[S, A](f: (S) ⇒ (A, S))(initialState: S): Observable[A]

def fromTask[A](task: Task[A]): Observable[A]

final def getClass(): Class[_]

def hashCode(): Int

implicit val instances: Asynchronous[Observable] with Restartable[Observable]

def interval(delay: FiniteDuration): Observable[Long]

def intervalAtFixedRate(initialDelay: FiniteDuration, period: FiniteDuration): Observable[Long]

def intervalAtFixedRate(period: FiniteDuration): Observable[Long]

def intervalWithFixedDelay(initialDelay: FiniteDuration, delay: FiniteDuration): Observable[Long]

def intervalWithFixedDelay(delay: FiniteDuration): Observable[Long]

final def isInstanceOf[T0]: Boolean

def merge[A](sources: Observable[A]*)(implicit os: OverflowStrategy[A] = OverflowStrategy.Default): Observable[A]

def mergeDelayError[A](sources: Observable[A]*)(implicit os: OverflowStrategy[A] = OverflowStrategy.Default): Observable[A]

def multicast[A](multicast: MulticastStrategy[A], overflow: Synchronous[A])(implicit s: Scheduler): (SyncObserver[A], Observable[A])

final def ne(arg0: AnyRef): Boolean

def never: Observable[Nothing]

final def notify(): Unit

final def notifyAll(): Unit

def now[A](elem: A): Observable[A]

def pure[A](elem: A): Observable[A]

def raiseError(ex: Throwable): Observable[Nothing]

def range(from: Long, until: Long, step: Long = 1L): Observable[Long]

def repeat[A](elems: A*): Observable[A]

def repeatEval[A](task: ⇒ A): Observable[A]

final def synchronized[T0](arg0: ⇒ T0): T0

def timerRepeated[A](initialDelay: FiniteDuration, period: FiniteDuration, unit: A): Observable[A]

def toReactive[A](source: Observable[A])(implicit s: Scheduler): Publisher[A]

def toString(): String

def unsafeCreate[A](f: (Subscriber[A]) ⇒ Cancelable): Observable[A]

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def zip2[A1, A2](oa1: Observable[A1], oa2: Observable[A2]): Observable[(A1, A2)]

def zip3[A1, A2, A3](oa1: Observable[A1], oa2: Observable[A2], oa3: Observable[A3]): Observable[(A1, A2, A3)]

def zip4[A1, A2, A3, A4](oa1: Observable[A1], oa2: Observable[A2], oa3: Observable[A3], oa4: Observable[A4]): Observable[(A1, A2, A3, A4)]

def zip5[A1, A2, A3, A4, A5](oa1: Observable[A1], oa2: Observable[A2], oa3: Observable[A3], oa4: Observable[A4], oa5: Observable[A5]): Observable[(A1, A2, A3, A4, A5)]

def zip6[A1, A2, A3, A4, A5, A6](oa1: Observable[A1], oa2: Observable[A2], oa3: Observable[A3], oa4: Observable[A4], oa5: Observable[A5], oa6: Observable[A6]): Observable[(A1, A2, A3, A4, A5, A6)]

def zipList[A](sources: Observable[A]*): Observable[Seq[A]]

def zipWith2[A1, A2, R](oa1: Observable[A1], oa2: Observable[A2])(f: (A1, A2) ⇒ R): Observable[R]