Object/Trait

monix.reactive

Observable

Related Docs: trait Observable | package reactive

Permalink

object Observable extends Serializable

Observable builders.

Source
Observable.scala
Linear Supertypes
Serializable, Serializable, AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Observable
  2. Serializable
  3. Serializable
  4. AnyRef
  5. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Value Members

  1. final def !=(arg0: Any): Boolean

    Permalink
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int

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

    Permalink
    Definition Classes
    AnyRef → Any
  4. def apply[A](elems: A*): Observable[A]

    Permalink

    Given a sequence of elements, builds an observable from it.

  5. final def asInstanceOf[T0]: T0

    Permalink
    Definition Classes
    Any
  6. def clone(): AnyRef

    Permalink
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  7. def coeval[A](value: Coeval[A]): Observable[A]

    Permalink

    Transforms a non-strict Coeval value into an Observable that emits a single element.

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

    Permalink

    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).

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

    Permalink

    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).

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

    Permalink

    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).

  11. 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)]

    Permalink

    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).

  12. 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)]

    Permalink

    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).

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

    Permalink

    Given an observable sequence, it combines them together (using combineLatest) returning a new observable that generates sequences.

  14. def combineLatestMap2[A1, A2, R](oa1: Observable[A1], oa2: Observable[A2])(f: (A1, A2) ⇒ R): Observable[R]

    Permalink

    Creates a combined observable from 2 source observables.

    Creates a combined observable from 2 source observables.

    This operator behaves in a similar way to zipMap2, 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).

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

    Permalink

    Creates a combined observable from 3 source observables.

    Creates a combined observable from 3 source observables.

    This operator behaves in a similar way to zipMap3, 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).

  16. def combineLatestMap4[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]

    Permalink

    Creates a combined observable from 4 source observables.

    Creates a combined observable from 4 source observables.

    This operator behaves in a similar way to zipMap4, 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).

  17. def combineLatestMap5[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]

    Permalink

    Creates a combined observable from 5 source observables.

    Creates a combined observable from 5 source observables.

    This operator behaves in a similar way to zipMap5, 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).

  18. def combineLatestMap6[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]

    Permalink

    Creates a combined observable from 6 source observables.

    Creates a combined observable from 6 source observables.

    This operator behaves in a similar way to zipMap6, 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).

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

    Permalink

    Concatenates the given list of observables into a single observable.

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

    Permalink

    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.

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

    Permalink

    Builds a new observable from a strict head and a lazily evaluated head.

  22. def create[A](overflowStrategy: Synchronous[A])(f: (Sync[A]) ⇒ Cancelable): Observable[A]

    Permalink

    Creates an observable from a function that receives a concurrent and safe Subscriber.Sync.

    Creates an observable from a function that receives a concurrent and safe Subscriber.Sync.

    This builder represents the safe way of building observables from data-sources that cannot be back-pressured.

  23. def defer[A](fa: ⇒ Observable[A]): Observable[A]

    Permalink

    Returns a new observable that creates a sequence from the given factory on each subscription.

  24. def delay[A](a: ⇒ A): Observable[A]

    Permalink

    Alias for eval.

  25. def empty[A]: Observable[A]

    Permalink

    Creates an observable that doesn't emit anything, but immediately calls onComplete instead.

  26. final def eq(arg0: AnyRef): Boolean

    Permalink
    Definition Classes
    AnyRef
  27. def equals(arg0: Any): Boolean

    Permalink
    Definition Classes
    AnyRef → Any
  28. def eval[A](a: ⇒ A): Observable[A]

    Permalink

    Given a non-strict value, converts it into an Observable that upon subscription, evaluates the expression and emits a single element.

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

    Permalink

    Lifts a non-strict value into an observable that emits a single element, but upon subscription delay its evaluation by the specified timespan

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

    Permalink

    Given a non-strict value, converts it into an Observable that emits a single element and that memoizes the value for subsequent invocations.

  31. def finalize(): Unit

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

    Permalink

    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.

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

    Permalink

    Concatenates the given list of observables into a single observable.

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

    Permalink

    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.

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

    Permalink

    Forks a logical thread on executing the subscription.

  36. def fromAsyncStateAction[S, A](f: (S) ⇒ Task[(A, S)])(initialState: ⇒ S): Observable[A]

    Permalink

    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.

  37. def fromCharsReader(in: Reader, chunkSize: Int): Observable[Array[Char]]

    Permalink

    Converts a java.io.Reader into an observable that will emit Array[Char] elements.

    Converts a java.io.Reader into an observable that will emit Array[Char] elements.

    WARNING: reading from a reader is a destructive process. Therefore only a single subscriber is supported, the result being a single-subscriber observable. If multiple subscribers are attempted, all subscribers, except for the first one, will be terminated with a MultipleSubscribersException.

    Therefore, if you need a factory of data sources, from a cold source such as a java.io.File from which you can open how many file handles you want, you can use Observable.defer to build such a factory. Or you can share the resulting observable by converting it into a ConnectableObservable by means of multicast.

    in

    is the Reader to convert into an observable

    chunkSize

    is the maximum length of the emitted arrays of chars. It's also used when reading from the reader.

  38. def fromCharsReader(in: Reader): Observable[Array[Char]]

    Permalink

    Converts a java.io.Reader into an observable that will emit Array[Char] elements.

    Converts a java.io.Reader into an observable that will emit Array[Char] elements.

    WARNING: reading from a reader is a destructive process. Therefore only a single subscriber is supported, the result being a single-subscriber observable. If multiple subscribers are attempted, all subscribers, except for the first one, will be terminated with a MultipleSubscribersException.

    Therefore, if you need a factory of data sources, from a cold source such as a java.io.File from which you can open how many file handles you want, you can use Observable.defer to build such a factory. Or you can share the resulting observable by converting it into a ConnectableObservable by means of multicast.

    in

    is the Reader to convert into an observable

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

    Permalink

    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.

  40. def fromInputStream(in: InputStream, chunkSize: Int): Observable[Array[Byte]]

    Permalink

    Converts a java.io.InputStream into an observable that will emit Array[Byte] elements.

    Converts a java.io.InputStream into an observable that will emit Array[Byte] elements.

    WARNING: reading from the input stream is a destructive process. Therefore only a single subscriber is supported, the result being a single-subscriber observable. If multiple subscribers are attempted, all subscribers, except for the first one, will be terminated with a MultipleSubscribersException.

    Therefore, if you need a factory of data sources, from a cold source such as a java.io.File from which you can open how many file handles you want, you can use Observable.defer to build such a factory. Or you can share the resulting observable by converting it into a ConnectableObservable by means of multicast.

    in

    is the InputStream to convert into an observable

    chunkSize

    is the maximum length of the emitted arrays of bytes. It's also used when reading from the input stream.

  41. def fromInputStream(in: InputStream): Observable[Array[Byte]]

    Permalink

    Converts a java.io.InputStream into an observable that will emit Array[Byte] elements.

    Converts a java.io.InputStream into an observable that will emit Array[Byte] elements.

    WARNING: reading from the input stream is a destructive process. Therefore only a single subscriber is supported, the result being a single-subscriber observable. If multiple subscribers are attempted, all subscribers, except for the first one, will be terminated with a MultipleSubscribersException.

    Therefore, if you need a factory of data sources, from a cold source such as a java.io.File from which you can open how many file handles you want, you can use Observable.defer to build such a factory. Or you can share the resulting observable by converting it into a ConnectableObservable by means of multicast.

    in

    is the InputStream to convert into an observable

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

    Permalink

    Converts any Iterable into an Observable.

  43. def fromIterator[A](iterator: Iterator[A], onFinish: () ⇒ Unit): Observable[A]

    Permalink

    Converts any Iterator into an observable.

    Converts any Iterator into an observable.

    WARNING: reading from an Iterator is a destructive process. Therefore only a single subscriber is supported, the result being a single-subscriber observable. If multiple subscribers are attempted, all subscribers, except for the first one, will be terminated with a MultipleSubscribersException.

    Therefore, if you need a factory of data sources, from a cold source from which you can open how many iterators you want, you can use Observable.defer to build such a factory. Or you can share the resulting observable by converting it into a ConnectableObservable by means of multicast.

    This variant of fromIterator takes an onFinish callback that will be called when the streaming is finished, either with onComplete, onError, when the downstream signals a Stop or when the subscription gets canceled.

    This onFinish callback is guaranteed to be called only once.

    Useful for controlling resource deallocation (e.g. closing file handles).

    iterator

    to transform into an observable

    onFinish

    a callback that will be called for resource deallocation whenever the iterator is complete, or when the stream is canceled

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

    Permalink

    Converts any Iterator into an observable.

    Converts any Iterator into an observable.

    WARNING: reading from an Iterator is a destructive process. Therefore only a single subscriber is supported, the result being a single-subscriber observable. If multiple subscribers are attempted, all subscribers, except for the first one, will be terminated with a MultipleSubscribersException.

    Therefore, if you need a factory of data sources, from a cold source from which you can open how many iterators you want, you can use Observable.defer to build such a factory. Or you can share the resulting observable by converting it into a ConnectableObservable by means of multicast.

    iterator

    to transform into an observable

  45. def fromLinesReader(in: BufferedReader): Observable[String]

    Permalink

    Converts a java.io.BufferedReader into an observable that will emit String text lines from the input.

    Converts a java.io.BufferedReader into an observable that will emit String text lines from the input.

    Note that according to the specification of BufferedReader, a line is considered to be terminated by any one of a line feed (\n), a carriage return (\r), or a carriage return followed immediately by a linefeed.

    WARNING: reading from a reader is a destructive process. Therefore only a single subscriber is supported, the result being a single-subscriber observable. If multiple subscribers are attempted, all subscribers, except for the first one, will be terminated with a MultipleSubscribersException.

    Therefore, if you need a factory of data sources, from a cold source such as a java.io.File from which you can open how many file handles you want, you can use Observable.defer to build such a factory. Or you can share the resulting observable by converting it into a ConnectableObservable by means of multicast.

    in

    is the Reader to convert into an observable

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

    Permalink

    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.

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

    Permalink

    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.

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

    Permalink

    Converts any Task into an Observable.

  49. final def getClass(): Class[_]

    Permalink
    Definition Classes
    AnyRef → Any
  50. def hashCode(): Int

    Permalink
    Definition Classes
    AnyRef → Any
  51. def interleave2[A](oa1: Observable[A], oa2: Observable[A]): Observable[A]

    Permalink

    Creates a new observable from this observable and another given observable by interleaving their items into a strictly alternating sequence.

    Creates a new observable from this observable and another given observable by interleaving their items into a strictly alternating sequence.

    So the first item emitted by the new observable will be the item emitted by self, the second item will be emitted by the other observable, and so forth; when either self or other calls onCompletes, the items will then be directly coming from the observable that has not completed; when onError is called by either self or other, the new observable will call onError and halt.

    See merge for a more relaxed alternative that doesn't emit items in strict alternating sequence.

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

    Permalink

    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

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

    Permalink

    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

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

    Permalink

    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

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

    Permalink

    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

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

    Permalink

    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

  57. final def isInstanceOf[T0]: Boolean

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

    Permalink

    Merges the given list of observables into a single observable.

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

    Permalink

    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.

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

    Permalink

    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 Observable.create when possible.

    multicast

    is the multicast strategy to use (e.g. publish, behavior, reply, async)

    overflow

    is the overflow strategy for the buffer that gets placed in front (since this will be a hot data-source that cannot be back-pressured)

  61. def multicast[A](multicast: MulticastStrategy[A])(implicit s: Scheduler): (Sync[A], Observable[A])

    Permalink

    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 Observable.create when possible.

    multicast

    is the multicast strategy to use (e.g. publish, behavior, reply, async)

  62. final def ne(arg0: AnyRef): Boolean

    Permalink
    Definition Classes
    AnyRef
  63. def never: Observable[Nothing]

    Permalink

    Creates an Observable that doesn't emit anything and that never completes.

  64. final def notify(): Unit

    Permalink
    Definition Classes
    AnyRef
  65. final def notifyAll(): Unit

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

    Permalink

    Returns an Observable that on execution emits the given strict value.

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

    Permalink

    Lifts an element into the Observable context.

    Lifts an element into the Observable context.

    Alias for now.

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

    Permalink

    Creates an Observable that emits an error.

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

    Permalink

    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

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

    Permalink

    Creates an Observable that continuously emits the given item repeatedly.

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

    Permalink

    Repeats the execution of the given task, emitting the results indefinitely.

  72. def suspend[A](fa: ⇒ Observable[A]): Observable[A]

    Permalink

    Alias for defer.

  73. def switch[A](sources: Observable[A]*): Observable[A]

    Permalink

    Given a sequence of observables, builds an observable that emits the elements of the most recently emitted observable.

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

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

    Permalink

    Create an Observable that repeatedly emits the given item, until the underlying Observer cancels.

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

    Permalink

    Wraps this Observable into a org.reactivestreams.Publisher.

    Wraps this Observable into a org.reactivestreams.Publisher. See the Reactive Streams protocol that Monix implements.

  77. def toString(): String

    Permalink
    Definition Classes
    AnyRef → Any
  78. implicit val typeClassInstances: TypeClassInstances

    Permalink

    Implicit type-class instances for Observable.

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

    Permalink

    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.

  80. final def wait(): Unit

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  81. final def wait(arg0: Long, arg1: Int): Unit

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  82. final def wait(arg0: Long): Unit

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  83. def zip2[A1, A2](oa1: Observable[A1], oa2: Observable[A2]): Observable[(A1, A2)]

    Permalink

    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 combineLatestMap2 for a more relaxed alternative that doesn't combine items in strict sequence.

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

    Permalink

    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 combineLatestMap3 for a more relaxed alternative that doesn't combine items in strict sequence.

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

    Permalink

    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 combineLatestMap4 for a more relaxed alternative that doesn't combine items in strict sequence.

  86. 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)]

    Permalink

    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 combineLatestMap5 for a more relaxed alternative that doesn't combine items in strict sequence.

  87. 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)]

    Permalink

    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 combineLatestMap5 for a more relaxed alternative that doesn't combine items in strict sequence.

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

    Permalink

    Given an observable sequence, it zips them together returning a new observable that generates sequences.

  89. def zipMap2[A1, A2, R](oa1: Observable[A1], oa2: Observable[A2])(f: (A1, A2) ⇒ R): Observable[R]

    Permalink

    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 combineLatestMap2 for a more relaxed alternative that doesn't combine items in strict sequence.

    f

    is the mapping function applied over the generated pairs

  90. def zipMap3[A1, A2, A3, R](oa1: Observable[A1], oa2: Observable[A2], oa3: Observable[A3])(f: (A1, A2, A3) ⇒ R): Observable[R]

    Permalink

    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 combineLatestMap3 for a more relaxed alternative that doesn't combine items in strict sequence.

    f

    is the mapping function applied over the generated pairs

  91. def zipMap4[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]

    Permalink

    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 combineLatestMap4 for a more relaxed alternative that doesn't combine items in strict sequence.

    f

    is the mapping function applied over the generated pairs

  92. def zipMap5[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]

    Permalink

    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 combineLatestMap5 for a more relaxed alternative that doesn't combine items in strict sequence.

    f

    is the mapping function applied over the generated pairs

  93. def zipMap6[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]

    Permalink

    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 combineLatestMap5 for a more relaxed alternative that doesn't combine items in strict sequence.

    f

    is the mapping function applied over the generated pairs

Deprecated Value Members

  1. def combineLatestWith2[A1, A2, R](fa1: Observable[A1], fa2: Observable[A2])(f: (A1, A2) ⇒ R): Observable[R]

    Permalink
    Annotations
    @deprecated
    Deprecated

    (Since version 2.0-RC12) Renamed to Observable.combineLatestMap2

  2. def combineLatestWith3[A1, A2, A3, R](fa1: Observable[A1], fa2: Observable[A2], fa3: Observable[A3])(f: (A1, A2, A3) ⇒ R): Observable[R]

    Permalink
    Annotations
    @deprecated
    Deprecated

    (Since version 2.0-RC12) Renamed to Observable.combineLatestMap3

  3. def combineLatestWith4[A1, A2, A3, A4, R](fa1: Observable[A1], fa2: Observable[A2], fa3: Observable[A3], fa4: Observable[A4])(f: (A1, A2, A3, A4) ⇒ R): Observable[R]

    Permalink
    Annotations
    @deprecated
    Deprecated

    (Since version 2.0-RC12) Renamed to Observable.combineLatestMap4

  4. def combineLatestWith5[A1, A2, A3, A4, A5, R](fa1: Observable[A1], fa2: Observable[A2], fa3: Observable[A3], fa4: Observable[A4], fa5: Observable[A5])(f: (A1, A2, A3, A4, A5) ⇒ R): Observable[R]

    Permalink
    Annotations
    @deprecated
    Deprecated

    (Since version 2.0-RC12) Renamed to Observable.combineLatestMap5

  5. def combineLatestWith6[A1, A2, A3, A4, A5, A6, R](fa1: Observable[A1], fa2: Observable[A2], fa3: Observable[A3], fa4: Observable[A4], fa5: Observable[A5], fa6: Observable[A6])(f: (A1, A2, A3, A4, A5, A6) ⇒ R): Observable[R]

    Permalink
    Annotations
    @deprecated
    Deprecated

    (Since version 2.0-RC12) Renamed to Observable.combineLatestMap6

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

    Permalink

    Alias for eval.

    Alias for eval. Deprecated.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.0-RC12) Renamed, please use Observable.eval

  7. def zipWith2[A1, A2, R](fa1: Observable[A1], fa2: Observable[A2])(f: (A1, A2) ⇒ R): Observable[R]

    Permalink
    Annotations
    @deprecated
    Deprecated

    (Since version 2.0-RC12) Renamed to Observable.zipMap2

  8. def zipWith3[A1, A2, A3, R](fa1: Observable[A1], fa2: Observable[A2], fa3: Observable[A3])(f: (A1, A2, A3) ⇒ R): Observable[R]

    Permalink
    Annotations
    @deprecated
    Deprecated

    (Since version 2.0-RC12) Renamed to Observable.zipMap3

  9. def zipWith4[A1, A2, A3, A4, R](fa1: Observable[A1], fa2: Observable[A2], fa3: Observable[A3], fa4: Observable[A4])(f: (A1, A2, A3, A4) ⇒ R): Observable[R]

    Permalink
    Annotations
    @deprecated
    Deprecated

    (Since version 2.0-RC12) Renamed to Observable.zipMap4

  10. def zipWith5[A1, A2, A3, A4, A5, R](fa1: Observable[A1], fa2: Observable[A2], fa3: Observable[A3], fa4: Observable[A4], fa5: Observable[A5])(f: (A1, A2, A3, A4, A5) ⇒ R): Observable[R]

    Permalink
    Annotations
    @deprecated
    Deprecated

    (Since version 2.0-RC12) Renamed to Observable.zipMap5

  11. def zipWith6[A1, A2, A3, A4, A5, A6, R](fa1: Observable[A1], fa2: Observable[A2], fa3: Observable[A3], fa4: Observable[A4], fa5: Observable[A5], fa6: Observable[A6])(f: (A1, A2, A3, A4, A5, A6) ⇒ R): Observable[R]

    Permalink
    Annotations
    @deprecated
    Deprecated

    (Since version 2.0-RC12) Renamed to Observable.zipMap6

Inherited from Serializable

Inherited from Serializable

Inherited from AnyRef

Inherited from Any

Ungrouped