update scala README

Author: samuelgruetter

language-adaptors/rxjava-scala/README.md

@@ -1,8 +1,71 @@
 # Scala Adaptor for RxJava
 
-There's an old Scala adaptor ( `rx.lang.scala.RxImplicits` with test `rx.lang.scala.RxImplicitsTest` ), which is deprecated. All other classes in `rx.lang.scala` belong to the new adaptor.
+This adaptor allows to use RxJava in Scala with anonymous functions, e.g.
 
-# Binaries
+```scala
+val o = Observable.interval(200 millis).take(5)
+o.subscribe(n => println("n = " + n))
+Observable(1, 2, 3, 4).reduce(_ + _)
+```
+
+For-comprehensions are also supported:
+
+```scala
+val first = Observable(10, 11, 12)
+val second = Observable(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:
+
+```scala
+ // 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](https://github.com/Netflix/RxJava/blob/master/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/examples/RxScalaDemo.scala).
+
+Scala code using Rx should only import members from `rx.lang.scala` and below.
+
+Work on this adaptor is still in progress, and for the moment, the best source of documentation are the comments in the source code of [`rx.lang.scala.Observable`](https://github.com/Netflix/RxJava/blob/master/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala).
+
+
+## Binaries
 
 Binaries and dependency information for Maven, Ivy, Gradle and others can be found at [http://search.maven.org](http://search.maven.org/#search%7Cga%7C1%7Ca%3A%22rxjava-scala%22).