Update to using RxJava 1.0.11

build.sbt

@@ -17,7 +17,7 @@ scalaVersion in ThisBuild := "2.11.6"
 crossScalaVersions in ThisBuild := Seq("2.10.5", "2.11.6")
 
 libraryDependencies ++= Seq(
-  "io.reactivex" % "rxjava" % "1.0.8",
+  "io.reactivex" % "rxjava" % "1.0.11",
   "org.mockito" % "mockito-core" % "1.9.5" % "test",
   "junit" % "junit" % "4.11" % "test",
   "org.scalatest" %% "scalatest" % "2.2.2" % "test")

examples/src/test/scala/rx/lang/scala/examples/ExperimentalAPIExamples.scala

@@ -23,7 +23,6 @@ import org.junit.Test
 
 import rx.lang.scala._
 import rx.lang.scala.schedulers._
-import rx.lang.scala.ExperimentalAPIs._
 
 @Ignore
 object ExperimentalAPIExamples {
@@ -75,7 +74,7 @@ object ExperimentalAPIExamples {
   @Test def onBackpressureBufferWithCapacityExample(): Unit = {
     Observable[Int](subscriber => {
       (1 to 200).foreach(subscriber.onNext)
-    }).onBackpressureBufferWithCapacity(200).observeOn(IOScheduler()).subscribe {
+    }).onBackpressureBuffer(200).observeOn(IOScheduler()).subscribe {
       v =>
         Thread.sleep(10) // A slow consumer
         println(s"process $v")
@@ -85,7 +84,7 @@ object ExperimentalAPIExamples {
   @Test def onBackpressureBufferWithCapacityExample2(): Unit = {
     Observable[Int](subscriber => {
       (1 to 200).foreach(subscriber.onNext)
-    }).onBackpressureBufferWithCapacity(10, println("Overflow")).observeOn(IOScheduler()).subscribe(
+    }).onBackpressureBuffer(10, println("Overflow")).observeOn(IOScheduler()).subscribe(
       v => {
         Thread.sleep(10)
         // A slow consumer
@@ -129,25 +128,36 @@ object ExperimentalAPIExamples {
   @Test def flatMapWithMaxConcurrentExample(): Unit = {
     (1 to 1000000).toObservable
       .doOnNext(v => println(s"Emitted Value: $v"))
-      .flatMapWithMaxConcurrent((v: Int) => Observable.just(v).doOnNext(_ => Thread.sleep(1)).subscribeOn(IOScheduler()), 10)
+      .flatMap(maxConcurrent = 10, v => Observable.just(v).doOnNext(_ => Thread.sleep(1)).subscribeOn(IOScheduler()))
       .toBlocking.foreach(v => System.out.println("Received: " + v))
   }
 
   @Test def flatMapWithMaxConcurrentExample2(): Unit = {
     (1 to 1000000).toObservable
       .doOnNext(v => println(s"Emitted Value: $v"))
-      .flatMapWithMaxConcurrent(
-        (v: Int) => Observable.just(v).doOnNext(_ => Thread.sleep(1)).subscribeOn(IOScheduler()),
+      .flatMap(
+        maxConcurrent = 10,
+        v => Observable.just(v).doOnNext(_ => Thread.sleep(1)).subscribeOn(IOScheduler()),
         e => Observable.just(-1).doOnNext(_ => Thread.sleep(1)).subscribeOn(IOScheduler()),
-        () => Observable.just(Int.MaxValue).doOnNext(_ => Thread.sleep(1)).subscribeOn(IOScheduler()),
-        10)
+        () => Observable.just(Int.MaxValue).doOnNext(_ => Thread.sleep(1)).subscribeOn(IOScheduler())
+      )
+      .toBlocking.foreach(v => System.out.println("Received: " + v))
+  }
+
+  @Test def flatMapWithMaxConcurrentExample3() {
+    (1 to 1000000).toObservable
+      .doOnNext(v => println(s"Emitted Value: $v"))
+      .flatMapWith(
+        maxConcurrent = 10,
+        v => Observable.just(v).doOnNext(_ => Thread.sleep(1)).subscribeOn(IOScheduler())
+      )(_ * _).subscribeOn(IOScheduler())
       .toBlocking.foreach(v => System.out.println("Received: " + v))
   }
 
   @Test def onBackpressureDropDoExample(): Unit = {
     Observable[Int](subscriber => {
       (1 to 200).foreach(subscriber.onNext)
-    }).onBackpressureDropDo {
+    }).onBackpressureDrop {
       t => println(s"Dropping $t")
     }.observeOn(IOScheduler()).subscribe {
       v =>

src/main/scala/rx/lang/scala/ExperimentalAPIs.scala

@@ -28,6 +28,7 @@ import JavaConversions._
  *
  * `import rx.lang.scala.ExperimentalAPIs._` to enable them.
  */
+@deprecated("Use new methods in [[Observable]] instead. This is kept here only for backward compatibility.", "0.25.0")
 class ExperimentalObservable[+T](private val o: Observable[T]) {
 
   /**
@@ -49,6 +50,7 @@ class ExperimentalObservable[+T](private val o: Observable[T]) {
    * @return an [[Observable]] that will block the producer thread if the source emits items faster than its [[Observer]] can consume them
    * @see <a href="http://reactivex.io/documentation/operators/backpressure.html">ReactiveX operators documentation: backpressure operators</a>
    */
+  @deprecated("Use [[[Observable.onBackpressureBlock(maxQueueLength:Int)*]]] instead. This is kept here only for backward compatibility.", "0.25.0")
   def onBackpressureBlock(maxQueueLength: Int): Observable[T] = {
     o.asJavaObservable.onBackpressureBlock(maxQueueLength)
   }
@@ -70,6 +72,7 @@ class ExperimentalObservable[+T](private val o: Observable[T]) {
    * @return an [[Observable]] that will block the producer thread if the source emits items faster than its [[Observer]] can consume them
    * @see <a href="http://reactivex.io/documentation/operators/backpressure.html">ReactiveX operators documentation: backpressure operators</a>
    */
+  @deprecated("Use [[[Observable.onBackpressureBlock:*]]] instead. This is kept here only for backward compatibility.", "0.25.0")
   def onBackpressureBlock: Observable[T] = {
     o.asJavaObservable.onBackpressureBlock()
   }
@@ -83,6 +86,7 @@ class ExperimentalObservable[+T](private val o: Observable[T]) {
    * @return an [[Observable]] that will call `onRequest` when appropriate
    * @see <a href="http://reactivex.io/documentation/operators/do.html">ReactiveX operators documentation: Do</a>
    */
+  @deprecated("Use [[Observable.doOnRequest]] instead. This is kept here only for backward compatibility.", "0.25.0")
   def doOnRequest(onRequest: Long => Unit): Observable[T] = {
     o.asJavaObservable.doOnRequest(new Action1[java.lang.Long] {
       override def call(request: java.lang.Long): Unit = onRequest(request)
@@ -103,6 +107,7 @@ class ExperimentalObservable[+T](private val o: Observable[T]) {
    * @return an [[Observable]] that will buffer items up to the given capacity
    * @see <a href="http://reactivex.io/documentation/operators/backpressure.html">ReactiveX operators documentation: backpressure operators</a>
    */
+  @deprecated("Use [[[Observable.onBackpressureBuffer(capacity:Long)*]]] instead. This is kept here only for backward compatibility.", "0.25.0")
   def onBackpressureBufferWithCapacity(capacity: Long): Observable[T] = {
     // Use `onBackpressureBufferWithCapacity` because if not, it will conflict with `Observable.onBackpressureBuffer`
     o.asJavaObservable.onBackpressureBuffer(capacity)
@@ -124,6 +129,7 @@ class ExperimentalObservable[+T](private val o: Observable[T]) {
    * @see <a href="http://reactivex.io/documentation/operators/backpressure.html">ReactiveX operators documentation: backpressure operators</a>
    * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
    */
+  @deprecated("Use [[[Observable.onBackpressureBuffer(capacity:Long,onOverflow:=>Unit)*]]] instead. This is kept here only for backward compatibility.", "0.25.0")
   def onBackpressureBufferWithCapacity(capacity: Long, onOverflow: => Unit): Observable[T] = {
     // Use `onBackpressureBufferWithCapacity` because if not, it will conflict with `Observable.onBackpressureBuffer`
     o.asJavaObservable.onBackpressureBuffer(capacity, new Action0 {
@@ -141,6 +147,7 @@ class ExperimentalObservable[+T](private val o: Observable[T]) {
    * @return an [[Observable]] that emits the items emitted by the source [[Observable]] or the items of an
    *         alternate [[Observable]] if the source [[Observable]] is empty.
    */
+  @deprecated("Use [[Observable.switchIfEmpty]] instead. This is kept here only for backward compatibility.", "0.25.0")
   def switchIfEmpty[U >: T](alternate: Observable[U]): Observable[U] = {
     val jo = o.asJavaObservable.asInstanceOf[rx.Observable[U]]
     toScalaObservable[U](jo.switchIfEmpty(alternate.asJavaObservable))
@@ -161,6 +168,7 @@ class ExperimentalObservable[+T](private val o: Observable[T]) {
    *         `resultSelector` function only when the source [[Observable]] sequence (this instance) emits an item
    * @see <a href="http://reactivex.io/documentation/operators/combinelatest.html">ReactiveX operators documentation: CombineLatest</a>
    */
+  @deprecated("Use [[Observable.withLatestFrom]] instead. This is kept here only for backward compatibility.", "0.25.0")
   def withLatestFrom[U, R](other: Observable[U])(resultSelector: (T, U) => R): Observable[R] = {
     val func = new Func2[T, U, R] {
       override def call(t1: T, t2: U): R = resultSelector(t1, t2)
@@ -185,6 +193,7 @@ class ExperimentalObservable[+T](private val o: Observable[T]) {
    * @see <a href="http://reactivex.io/documentation/operators/takeuntil.html">ReactiveX operators documentation: TakeUntil</a>
    * @see [[Observable.takeWhile]]
    */
+  @deprecated("Use [[[Observable.takeUntil(stopPredicate:T=>Boolean)*]]] instead. This is kept here only for backward compatibility.", "0.25.0")
   def takeUntil(stopPredicate: T => Boolean): Observable[T] = {
     val func = new Func1[T, java.lang.Boolean] {
       override def call(t: T): java.lang.Boolean = stopPredicate(t)
@@ -206,6 +215,7 @@ class ExperimentalObservable[+T](private val o: Observable[T]) {
    *         by the source [[Observable]] and merging the results of the [[Observable]]s obtained from this transformation
    * @see <a href="http://reactivex.io/documentation/operators/flatmap.html">ReactiveX operators documentation: FlatMap</a>
    */
+  @deprecated("Use [[[Observable.flatMap[R](maxConcurrent:Int,f:T=>rx\\.lang\\.scala\\.Observable[R])*]]] instead. This is kept here only for backward compatibility.", "0.25.0")
   def flatMapWithMaxConcurrent[R](f: T => Observable[R], maxConcurrent: Int): Observable[R] = {
     toScalaObservable[R](o.asJavaObservable.flatMap[R](new Func1[T, rx.Observable[_ <: R]] {
       def call(t1: T): rx.Observable[_ <: R] = {
@@ -229,6 +239,7 @@ class ExperimentalObservable[+T](private val o: Observable[T]) {
    *         specified functions to the emissions and notifications of the source [[Observable]]
    * @see <a href="http://reactivex.io/documentation/operators/flatmap.html">ReactiveX operators documentation: FlatMap</a>
    */
+  @deprecated("Use [[[Observable.flatMap[R](maxConcurrent:Int,onNext:T=>rx\\.lang\\.scala\\.Observable[R],onError:Throwable=>rx\\.lang\\.scala\\.Observable[R],onCompleted:()=>rx\\.lang\\.scala\\.Observable[R])*]]] instead. This is kept here only for backward compatibility.", "0.25.0")
   def flatMapWithMaxConcurrent[R](onNext: T => Observable[R], onError: Throwable => Observable[R], onCompleted: () => Observable[R], maxConcurrent: Int): Observable[R] = {
     val jOnNext = new Func1[T, rx.Observable[_ <: R]] {
       override def call(t: T): rx.Observable[_ <: R] = onNext(t).asJavaObservable
@@ -257,13 +268,16 @@ class ExperimentalObservable[+T](private val o: Observable[T]) {
    * @return an new [[Observable]] that will drop `onNext` notifications on overflow
    * @see <a href="http://reactivex.io/documentation/operators/backpressure.html">ReactiveX operators documentation: backpressure operators</a>
    */
+  @deprecated("Use [[Observable.onBackpressureDrop(onDrop:T=>Unit)*]] instead. This is kept here only for backward compatibility.", "0.25.0")
   def onBackpressureDropDo(onDrop: T => Unit): Observable[T] = {
     toScalaObservable[T](o.asJavaObservable.onBackpressureDrop(new Action1[T] {
       override def call(t: T) = onDrop(t)
     }))
   }
 }
 
+@deprecated("Use new methods in [[Observable]] instead. This is kept here only for backward compatibility.", "0.25.0")
 object ExperimentalAPIs {
-  implicit def toExperimentalObservable[T](o: Observable[T]): ExperimentalObservable[T] = new ExperimentalObservable(o)
+  @deprecated("Use new methods in [[Observable]] instead. This is kept here only for backward compatibility.", "0.25.0")
+  def toExperimentalObservable[T](o: Observable[T]): ExperimentalObservable[T] = new ExperimentalObservable(o)
 }