This is a Scala adapter to RxJava.
Example usage:
val o = Observable.interval(200 millis).take(5)
o.subscribe(n => println("n = " + n))
Observable.just(1, 2, 3, 4).reduce(_ + _)For-comprehensions are also supported:
val first = Observable.just(10, 11, 12)
val second = Observable.just(10, 11, 12)
val booleans = for ((n1, n2) <- (first zip second)) yield (n1 == n2)Further, this adaptor attempts to expose an API which is as Scala-idiomatic as possible. This means that certain methods have been renamed, their signature was changed, or static methods were changed to instance methods. Some examples:
// instead of concat:
def ++[U >: T](that: Observable[U]): Observable[U]
// instance method instead of static:
def zip[U](that: Observable[U]): Observable[(T, U)]
// the implicit evidence argument ensures that dematerialize can only be called on Observables of Notifications:
def dematerialize[U](implicit evidence: T <:< Notification[U]): Observable[U]
// additional type parameter U with lower bound to get covariance right:
def onErrorResumeNext[U >: T](resumeFunction: Throwable => Observable[U]): Observable[U]
// curried in Scala collections, so curry fold also here:
def fold[R](initialValue: R)(accumulator: (R, T) => R): Observable[R]
// using Duration instead of (long timepan, TimeUnit duration):
def sample(duration: Duration): Observable[T]
// called skip in Java, but drop in Scala
def drop(n: Int): Observable[T]
// there's only mapWithIndex in Java, because Java doesn't have tuples:
def zipWithIndex: Observable[(T, Int)]
// corresponds to Java's toList:
def toSeq: Observable[Seq[T]]
// the implicit evidence argument ensures that switch can only be called on Observables of Observables:
def switch[U](implicit evidence: Observable[T] <:< Observable[Observable[U]]): Observable[U]
// Java's from becomes apply, and we use Scala Range
def apply(range: Range): Observable[Int]
// use Bottom type:
def never: Observable[Nothing] Also, the Scala Observable is fully covariant in its type parameter, whereas the Java Observable only achieves partial covariance due to limitations of Java's type system (or if you can fix this, your suggestions are very welcome).
For more examples, see RxScalaDemo.scala.
Scala code using Rx should only import members from rx.lang.scala and below.
Since RxScala is part of the RxJava family the communication channels are similar:
- Google Group: RxJava
- Twitter: @RxJava
- GitHub Issues
RxScala 0.x is based on RxJava 0.x. RxScala 1.0 will be released when RxJava 1.0 is released.
As of 1.0.0 semantic versioning will be used.
RxScala:
- The API documentation can be found here.
Note that starting from version 0.15, rx.lang.scala.Observable is not a value class any more. ./Rationale.md explains why.
You can build the API documentation yourself by running ./gradlew scaladoc in the RxJava root directory.
Then navigate to RxJava/language-adaptors/rxjava-scala/build/docs/scaladoc/index.html to display it.
RxJava:
Binaries and dependency information for Maven, Ivy, Gradle and others can be found at http://search.maven.org.
Example for Maven:
<dependency>
<groupId>io.reactivex</groupId>
<artifactId>rxscala_${scala.compat.version}</artifactId>
<version>x.y.z</version>
</dependency>and for Ivy:
<dependency org="io.reactivex" name="rxscala_${scala.compat.version}" rev="x.y.z" />and for sbt:
libraryDependencies ++= Seq(
"io.reactivex" %% "rxscala" % "x.y.z"
)To build (you need sbt):
$ git clone [email protected]:ReactiveX/RxScala.git
$ cd RxScala/
$ sbt package
You can also run the examples from within sbt:
$ sbt examples/run
For bugs, questions and discussions please use the Github Issues.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at
https://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.