diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/RxImplicits.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/RxImplicits.scala
index 67fd4ec0f1..72e07a1315 100644
--- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/RxImplicits.scala
+++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/RxImplicits.scala
@@ -106,7 +106,7 @@ object RxImplicits {
      * type never escapes the for-comprehension
      */
     implicit class ScalaObservable[A](wrapped: Observable[A]) {
-        def map[B](f: A => B): Observable[B] = wrapped.map(f)
+        def map[B](f: A => B): Observable[B] = wrapped.map[B](f)
         def flatMap[B](f: A => Observable[B]): Observable[B] = wrapped.mapMany(f)
         def foreach(f: A => Unit): Unit = wrapped.toBlockingObservable.forEach(f)
         def withFilter(p: A => Boolean): WithFilter = new WithFilter(p)
@@ -147,7 +147,7 @@ class UnitTestSuite extends JUnitSuite {
     class ObservableWithException(s: Subscription, values: String*) extends Observable[String] {
         var t: Thread = null
         
-        override def subscribe(observer: Observer[String]): Subscription = {
+        override def subscribe(observer: Observer[_ >: String]): Subscription = {
             println("ObservableWithException subscribed to ...")
             t = new Thread(new Runnable() {
                 override def run() {
@@ -248,7 +248,7 @@ class UnitTestSuite extends JUnitSuite {
     
     @Test def testFlattenMerge {
         val observable = Observable.from(Observable.from(1, 2, 3))
-        val merged = Observable.merge(observable)
+        val merged = Observable.merge[Int](observable)
         assertSubscribeReceives(merged)(1, 2, 3)
     }
     
@@ -272,6 +272,18 @@ class UnitTestSuite extends JUnitSuite {
         assertSubscribeReceives(synchronized)(1, 2, 3)
     }
     
+    @Test def testZip2() {
+        val colors: Observable[String] = Observable.from("red", "green", "blue")
+        val names: Observable[String] = Observable.from("lion-o", "cheetara", "panthro")
+        
+        case class Character(color: String, name: String)
+        
+        val cheetara = Character("green", "cheetara")
+        val panthro = Character("blue", "panthro")
+        val characters = Observable.zip[String, String, Character](colors, names, Character.apply _)
+        assertSubscribeReceives(characters)(cheetara, panthro)
+    }
+    
     @Test def testZip3() {
         val numbers = Observable.from(1, 2, 3)
         val colors = Observable.from("red", "green", "blue")
@@ -283,7 +295,7 @@ class UnitTestSuite extends JUnitSuite {
         val cheetara = Character(2, "green", "cheetara")
         val panthro = Character(3, "blue", "panthro")
         
-        val characters = Observable.zip(numbers, colors, names, Character.apply _)
+        val characters = Observable.zip[Int, String, String, Character](numbers, colors, names, Character.apply _)
         assertSubscribeReceives(characters)(liono, cheetara, panthro)
     }
     
@@ -299,7 +311,7 @@ class UnitTestSuite extends JUnitSuite {
         val cheetara = Character(2, "green", "cheetara", false)
         val panthro = Character(3, "blue", "panthro", false)
         
-        val characters = Observable.zip(numbers, colors, names, isLeader, Character.apply _)
+        val characters = Observable.zip[Int, String, String, Boolean, Character](numbers, colors, names, isLeader, Character.apply _)
         assertSubscribeReceives(characters)(liono, cheetara, panthro)
     }
     
@@ -338,7 +350,8 @@ class UnitTestSuite extends JUnitSuite {
     @Test def testMap {
         val numbers = Observable.from(1, 2, 3, 4, 5, 6, 7, 8, 9)
         val mappedNumbers = ArrayBuffer.empty[Int]
-        numbers.map((x: Int) => x * x).subscribe((squareVal: Int) => {
+        val mapped: Observable[Int] = numbers map ((x: Int) => x * x)
+        mapped.subscribe((squareVal: Int) => {
             mappedNumbers.append(squareVal)
         })
         assertEquals(List(1, 4, 9, 16, 25, 36, 49, 64, 81), mappedNumbers.toList)
@@ -458,18 +471,9 @@ class UnitTestSuite extends JUnitSuite {
         assertSubscribeReceives(skipped)(3, 4)
     }
     
-    /**
-     * Both testTake and testTakeWhileWithIndex exposed a bug with unsubscribes not properly propagating.
-     * observable.take(2) produces onNext(first), onNext(second), and 4 onCompleteds
-     * it should produce onNext(first), onNext(second), and 1 onCompleted
-     *
-     * Switching to Observable.create(OperationTake.take(observable, 2)) works as expected
-     */
     @Test def testTake {
-        import rx.operators._
-        
         val observable = Observable.from(1, 2, 3, 4, 5)
-        val took = Observable.create(OperationTake.take(observable, 2))
+        val took = observable.take(2)
         assertSubscribeReceives(took)(1, 2)
     }
     
@@ -479,11 +483,11 @@ class UnitTestSuite extends JUnitSuite {
         assertSubscribeReceives(took)(1, 3, 5)
     }
     
-    /*@Test def testTakeWhileWithIndex {
-     val observable = Observable.from(1, 3, 5, 6, 7, 9, 11, 12, 13, 15, 17)
-     val took = observable.takeWhileWithIndex((i: Int, idx: Int) => isOdd(i) && idx > 4)
-     assertSubscribeReceives(took)(9, 11)
-     }*/
+    @Test def testTakeWhileWithIndex {
+        val observable = Observable.from(1, 3, 5, 7, 9, 11, 12, 13, 15, 17)
+        val took = observable.takeWhileWithIndex((i: Int, idx: Int) => isOdd(i) && idx < 8)
+        assertSubscribeReceives(took)(1, 3, 5, 7, 9, 11)
+    }
     
     @Test def testTakeLast {
         val observable = Observable.from(1, 2, 3, 4, 5, 6, 7, 8, 9)
@@ -559,7 +563,7 @@ class UnitTestSuite extends JUnitSuite {
     
     @Test def testFilterInForComprehension {
         val doubler = (i: Int) => Observable.from(i, i)
-        val filteredObservable = for {
+        val filteredObservable: Observable[Int] = for {
             i: Int <- Observable.from(1, 2, 3, 4)
             j: Int <- doubler(i) if isOdd(i)
         } yield j
diff --git a/rxjava-contrib/rxjava-android/src/main/java/rx/android/concurrency/HandlerThreadScheduler.java b/rxjava-contrib/rxjava-android/src/main/java/rx/android/concurrency/HandlerThreadScheduler.java
index a9cfb55fc9..cd1af987ae 100644
--- a/rxjava-contrib/rxjava-android/src/main/java/rx/android/concurrency/HandlerThreadScheduler.java
+++ b/rxjava-contrib/rxjava-android/src/main/java/rx/android/concurrency/HandlerThreadScheduler.java
@@ -1,11 +1,13 @@
 package rx.android.concurrency;
 
 import android.os.Handler;
+
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.ArgumentCaptor;
 import org.robolectric.RobolectricTestRunner;
 import org.robolectric.annotation.Config;
+
 import rx.Scheduler;
 import rx.Subscription;
 import rx.operators.SafeObservableSubscription;
@@ -39,7 +41,7 @@ public HandlerThreadScheduler(Handler handler) {
      * See {@link #schedule(Object, rx.util.functions.Func2, long, java.util.concurrent.TimeUnit)}
      */
     @Override
-    public <T> Subscription schedule(final T state, final Func2<Scheduler, T, Subscription> action) {
+    public <T> Subscription schedule(final T state, final Func2<? super Scheduler, ? super T, ? extends Subscription> action) {
         return schedule(state, action, 0L, TimeUnit.MILLISECONDS);
     }
 
@@ -56,7 +58,7 @@ public <T> Subscription schedule(final T state, final Func2<Scheduler, T, Subscr
      * @return A Subscription from which one can unsubscribe from.
      */
     @Override
-    public <T> Subscription schedule(final T state, final Func2<Scheduler, T, Subscription> action, long delayTime, TimeUnit unit) {
+    public <T> Subscription schedule(final T state, final Func2<? super Scheduler, ? super T, ? extends Subscription> action, long delayTime, TimeUnit unit) {
         final SafeObservableSubscription subscription = new SafeObservableSubscription();
         final Scheduler _scheduler = this;
         handler.postDelayed(new Runnable() {
@@ -76,6 +78,7 @@ public static final class UnitTest {
         public void shouldScheduleImmediateActionOnHandlerThread() {
             final Handler handler = mock(Handler.class);
             final Object state = new Object();
+            @SuppressWarnings("unchecked")
             final Func2<Scheduler, Object, Subscription> action = mock(Func2.class);
 
             Scheduler scheduler = new HandlerThreadScheduler(handler);
@@ -94,6 +97,7 @@ public void shouldScheduleImmediateActionOnHandlerThread() {
         public void shouldScheduleDelayedActionOnHandlerThread() {
             final Handler handler = mock(Handler.class);
             final Object state = new Object();
+            @SuppressWarnings("unchecked")
             final Func2<Scheduler, Object, Subscription> action = mock(Func2.class);
 
             Scheduler scheduler = new HandlerThreadScheduler(handler);
diff --git a/rxjava-contrib/rxjava-swing/src/main/java/rx/concurrency/SwingScheduler.java b/rxjava-contrib/rxjava-swing/src/main/java/rx/concurrency/SwingScheduler.java
index 2ce298c590..f2d10d69b0 100644
--- a/rxjava-contrib/rxjava-swing/src/main/java/rx/concurrency/SwingScheduler.java
+++ b/rxjava-contrib/rxjava-swing/src/main/java/rx/concurrency/SwingScheduler.java
@@ -55,7 +55,7 @@ private SwingScheduler() {
     }
 
     @Override
-    public <T> Subscription schedule(final T state, final Func2<Scheduler, T, Subscription> action) {
+    public <T> Subscription schedule(final T state, final Func2<? super Scheduler, ? super T, ? extends Subscription> action) {
         final AtomicReference<Subscription> sub = new AtomicReference<Subscription>();
         EventQueue.invokeLater(new Runnable() {
             @Override
@@ -75,7 +75,7 @@ public void call() {
     }
 
     @Override
-    public <T> Subscription schedule(final T state, final Func2<Scheduler, T, Subscription> action, long dueTime, TimeUnit unit) {
+    public <T> Subscription schedule(final T state, final Func2<? super Scheduler, ? super T, ? extends Subscription> action, long dueTime, TimeUnit unit) {
         final AtomicReference<Subscription> sub = new AtomicReference<Subscription>();
         long delay = unit.toMillis(dueTime);
         assertThatTheDelayIsValidForTheSwingTimer(delay);
@@ -113,7 +113,7 @@ public void call() {
     }
 
     @Override
-    public <T> Subscription schedulePeriodically(T state, final Func2<Scheduler, T, Subscription> action, long initialDelay, long period, TimeUnit unit) {
+    public <T> Subscription schedulePeriodically(T state, final Func2<? super Scheduler, ? super T, ? extends Subscription> action, long initialDelay, long period, TimeUnit unit) {
         final AtomicReference<Timer> timer = new AtomicReference<Timer>();
 
         final long delay = unit.toMillis(period);
diff --git a/rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/AbstractButtonSource.java b/rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/AbstractButtonSource.java
index ef3612b080..b51bb60b16 100644
--- a/rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/AbstractButtonSource.java
+++ b/rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/AbstractButtonSource.java
@@ -42,9 +42,9 @@ public enum AbstractButtonSource { ; // no instances
      * @see SwingObservable.fromButtonAction
      */
     public static Observable<ActionEvent> fromActionOf(final AbstractButton button) {
-        return Observable.create(new Func1<Observer<ActionEvent>, Subscription>() {
+        return Observable.create(new Func1<Observer<? super ActionEvent>, Subscription>() {
             @Override
-            public Subscription call(final Observer<ActionEvent> observer) {
+            public Subscription call(final Observer<? super ActionEvent> observer) {
                 final ActionListener listener = new ActionListener() {
                     @Override
                     public void actionPerformed(ActionEvent e) {
diff --git a/rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/ComponentEventSource.java b/rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/ComponentEventSource.java
index 4b1917454a..cbb0008b5f 100644
--- a/rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/ComponentEventSource.java
+++ b/rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/ComponentEventSource.java
@@ -36,9 +36,9 @@ public enum ComponentEventSource { ; // no instances
      * @see SwingObservable.fromComponentEvents
      */
     public static Observable<ComponentEvent> fromComponentEventsOf(final Component component) {
-        return Observable.create(new Func1<Observer<ComponentEvent>, Subscription>() {
+        return Observable.create(new Func1<Observer<? super ComponentEvent>, Subscription>() {
             @Override
-            public Subscription call(final Observer<ComponentEvent> observer) {
+            public Subscription call(final Observer<? super ComponentEvent> observer) {
                 final ComponentListener listener = new ComponentListener() {
                     @Override
                     public void componentHidden(ComponentEvent event) {
diff --git a/rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/KeyEventSource.java b/rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/KeyEventSource.java
index 291e0202aa..eba7406331 100644
--- a/rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/KeyEventSource.java
+++ b/rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/KeyEventSource.java
@@ -50,9 +50,9 @@ public enum KeyEventSource { ; // no instances
      * @see SwingObservable.fromKeyEvents(Component)
      */
     public static Observable<KeyEvent> fromKeyEventsOf(final Component component) {
-        return Observable.create(new Func1<Observer<KeyEvent>, Subscription>() {
+        return Observable.create(new Func1<Observer<? super KeyEvent>, Subscription>() {
             @Override
-            public Subscription call(final Observer<KeyEvent> observer) {
+            public Subscription call(final Observer<? super KeyEvent> observer) {
                 final KeyListener listener = new KeyListener() {
                     @Override
                     public void keyPressed(KeyEvent event) {
diff --git a/rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/MouseEventSource.java b/rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/MouseEventSource.java
index 7bfe4efa3e..32a12bd206 100644
--- a/rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/MouseEventSource.java
+++ b/rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/MouseEventSource.java
@@ -33,9 +33,9 @@ public enum MouseEventSource { ; // no instances
      * @see SwingObservable.fromMouseEvents
      */
     public static Observable<MouseEvent> fromMouseEventsOf(final Component component) {
-        return Observable.create(new Func1<Observer<MouseEvent>, Subscription>() {
+        return Observable.create(new Func1<Observer<? super MouseEvent>, Subscription>() {
             @Override
-            public Subscription call(final Observer<MouseEvent> observer) {
+            public Subscription call(final Observer<? super MouseEvent> observer) {
                 final MouseListener listener = new MouseListener() {
                     @Override
                     public void mouseClicked(MouseEvent event) {
@@ -78,9 +78,9 @@ public void call() {
      * @see SwingObservable.fromMouseMotionEvents
      */
     public static Observable<MouseEvent> fromMouseMotionEventsOf(final Component component) {
-        return Observable.create(new Func1<Observer<MouseEvent>, Subscription>() {
+        return Observable.create(new Func1<Observer<? super MouseEvent>, Subscription>() {
             @Override
-            public Subscription call(final Observer<MouseEvent> observer) {
+            public Subscription call(final Observer<? super MouseEvent> observer) {
                 final MouseMotionListener listener = new MouseMotionListener() {
                     @Override
                     public void mouseDragged(MouseEvent event) {
diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 50aef90ce9..c21b62b300 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -83,6 +83,11 @@
 import rx.util.functions.Func2;
 import rx.util.functions.Func3;
 import rx.util.functions.Func4;
+import rx.util.functions.Func5;
+import rx.util.functions.Func6;
+import rx.util.functions.Func7;
+import rx.util.functions.Func8;
+import rx.util.functions.Func9;
 import rx.util.functions.FuncN;
 import rx.util.functions.Function;
 
@@ -108,7 +113,7 @@ public class Observable<T> {
 
     private final static RxJavaObservableExecutionHook hook = RxJavaPlugins.getInstance().getObservableExecutionHook();
 
-    private final Func1<Observer<T>, Subscription> onSubscribe;
+    private final Func1<? super Observer<? super T>, ? extends Subscription> onSubscribe;
 
     /**
      * Observable with Function to execute when subscribed to.
@@ -119,7 +124,7 @@ public class Observable<T> {
      * @param onSubscribe
      *            {@link Func1} to be executed when {@link #subscribe(Observer)} is called.
      */
-    protected Observable(Func1<Observer<T>, Subscription> onSubscribe) {
+    protected Observable(Func1<? super Observer<? super T>, ? extends Subscription> onSubscribe) {
         this.onSubscribe = onSubscribe;
     }
 
@@ -155,9 +160,9 @@ protected Observable() {
      * @throws IllegalArgumentException
      *             if the {@link Observer} provided as the argument to {@code subscribe()} is {@code null}
      */
-    public Subscription subscribe(Observer<T> observer) {
+    public Subscription subscribe(Observer<? super T> observer) {
         // allow the hook to intercept and/or decorate
-        Func1<Observer<T>, Subscription> onSubscribeFunction = hook.onSubscribeStart(this, onSubscribe);
+        Func1<? super Observer<? super T>, ? extends Subscription> onSubscribeFunction = hook.onSubscribeStart(this, onSubscribe);
         // validate and proceed
         if (observer == null) {
             throw new IllegalArgumentException("observer can not be null");
@@ -233,7 +238,7 @@ public Subscription subscribe(Observer<T> observer) {
      * @throws IllegalArgumentException
      *             if an argument to {@code subscribe()} is {@code null}
      */
-    public Subscription subscribe(Observer<T> observer, Scheduler scheduler) {
+    public Subscription subscribe(Observer<? super T> observer, Scheduler scheduler) {
         return subscribeOn(scheduler).subscribe(observer);
     }
 
@@ -242,12 +247,12 @@ public Subscription subscribe(Observer<T> observer, Scheduler scheduler) {
      * <p>
      * See https://github.com/Netflix/RxJava/issues/216 for discussion on "Guideline 6.4: Protect calls to user code from within an operator"
      */
-    private Subscription protectivelyWrapAndSubscribe(Observer<T> o) {
+    private Subscription protectivelyWrapAndSubscribe(Observer<? super T> o) {
         SafeObservableSubscription subscription = new SafeObservableSubscription();
         return subscription.wrap(subscribe(new SafeObserver<T>(subscription, o)));
     }
 
-    public Subscription subscribe(final Action1<T> onNext) {
+    public Subscription subscribe(final Action1<? super T> onNext) {
         if (onNext == null) {
             throw new IllegalArgumentException("onNext can not be null");
         }
@@ -278,11 +283,11 @@ public void onNext(T args) {
         });
     }
 
-    public Subscription subscribe(final Action1<T> onNext, Scheduler scheduler) {
+    public Subscription subscribe(final Action1<? super T> onNext, Scheduler scheduler) {
         return subscribeOn(scheduler).subscribe(onNext);
     }
 
-    public Subscription subscribe(final Action1<T> onNext, final Action1<Throwable> onError) {
+    public Subscription subscribe(final Action1<? super T> onNext, final Action1<Throwable> onError) {
         if (onNext == null) {
             throw new IllegalArgumentException("onNext can not be null");
         }
@@ -316,11 +321,11 @@ public void onNext(T args) {
         });
     }
 
-    public Subscription subscribe(final Action1<T> onNext, final Action1<Throwable> onError, Scheduler scheduler) {
+    public Subscription subscribe(final Action1<? super T> onNext, final Action1<Throwable> onError, Scheduler scheduler) {
         return subscribeOn(scheduler).subscribe(onNext, onError);
     }
 
-    public Subscription subscribe(final Action1<T> onNext, final Action1<Throwable> onError, final Action0 onComplete) {
+    public Subscription subscribe(final Action1<? super T> onNext, final Action1<Throwable> onError, final Action0 onComplete) {
         if (onNext == null) {
             throw new IllegalArgumentException("onNext can not be null");
         }
@@ -357,7 +362,7 @@ public void onNext(T args) {
         });
     }
 
-    public Subscription subscribe(final Action1<T> onNext, final Action1<Throwable> onError, final Action0 onComplete, Scheduler scheduler) {
+    public Subscription subscribe(final Action1<? super T> onNext, final Action1<Throwable> onError, final Action0 onComplete, Scheduler scheduler) {
         return subscribeOn(scheduler).subscribe(onNext, onError, onComplete);
     }
 
@@ -397,10 +402,10 @@ private void handleError(Throwable e) {
      */
     private static class NeverObservable<T> extends Observable<T> {
         public NeverObservable() {
-            super(new Func1<Observer<T>, Subscription>() {
+            super(new Func1<Observer<? super T>, Subscription>() {
 
                 @Override
-                public Subscription call(Observer<T> t1) {
+                public Subscription call(Observer<? super T> t1) {
                     return Subscriptions.empty();
                 }
 
@@ -417,7 +422,7 @@ public Subscription call(Observer<T> t1) {
     private static class ThrowObservable<T> extends Observable<T> {
 
         public ThrowObservable(final Throwable exception) {
-            super(new Func1<Observer<T>, Subscription>() {
+            super(new Func1<Observer<? super T>, Subscription>() {
 
                 /**
                  * Accepts an {@link Observer} and calls its {@link Observer#onError onError} method.
@@ -427,7 +432,7 @@ public ThrowObservable(final Throwable exception) {
                  * @return a reference to the subscription
                  */
                 @Override
-                public Subscription call(Observer<T> observer) {
+                public Subscription call(Observer<? super T> observer) {
                     observer.onError(exception);
                     return Subscriptions.empty();
                 }
@@ -461,7 +466,7 @@ public Subscription call(Observer<T> observer) {
      * @return an Observable that, when an {@link Observer} subscribes to it, will execute the given
      *         function
      */
-    public static <T> Observable<T> create(Func1<Observer<T>, Subscription> func) {
+    public static <T> Observable<T> create(Func1<? super Observer<? super T>, ? extends Subscription> func) {
         return new Observable<T>(func);
     }
 
@@ -510,7 +515,7 @@ public static <T> Observable<T> error(Throwable exception) {
      *            emitted by the resulting Observable
      * @return an Observable that emits each item in the source {@link Iterable} sequence
      */
-    public static <T> Observable<T> from(Iterable<T> iterable) {
+    public static <T> Observable<T> from(Iterable<? extends T> iterable) {
         return create(OperationToObservableIterable.toObservableIterable(iterable));
     }
 
@@ -574,7 +579,7 @@ public static Observable<Integer> range(int start, int count) {
      * @return an Observable whose {@link Observer}s trigger an invocation of the given Observable
      *         factory function
      */
-    public static <T> Observable<T> defer(Func0<Observable<T>> observableFactory) {
+    public static <T> Observable<T> defer(Func0<? extends Observable<? extends T>> observableFactory) {
         return create(OperationDefer.defer(observableFactory));
     }
 
@@ -617,7 +622,7 @@ public static <T> Observable<T> just(T value) {
      * @return an Observable that emits items that are the result of flattening the {@code source} list of Observables
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099(v=vs.103).aspx">MSDN: Observable.Merge</a>
      */
-    public static <T> Observable<T> merge(List<Observable<T>> source) {
+    public static <T> Observable<T> merge(List<? extends Observable<? extends T>> source) {
         return create(OperationMerge.merge(source));
     }
 
@@ -636,7 +641,7 @@ public static <T> Observable<T> merge(List<Observable<T>> source) {
      *         by the Observables emitted by the {@code source} Observable
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099(v=vs.103).aspx">MSDN: Observable.Merge Method</a>
      */
-    public static <T> Observable<T> merge(Observable<Observable<T>> source) {
+    public static <T> Observable<T> merge(Observable<? extends Observable<? extends T>> source) {
         return create(OperationMerge.merge(source));
     }
 
@@ -654,7 +659,7 @@ public static <T> Observable<T> merge(Observable<Observable<T>> source) {
      *         by the {@code source} Observables
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099(v=vs.103).aspx">MSDN: Observable.Merge Method</a>
      */
-    public static <T> Observable<T> merge(Observable<T>... source) {
+    public static <T> Observable<T> merge(Observable<? extends T>... source) {
         return create(OperationMerge.merge(source));
     }
 
@@ -670,7 +675,7 @@ public static <T> Observable<T> merge(Observable<T>... source) {
      *         the {@code source} Observables, one after the other
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.concat(v=vs.103).aspx">MSDN: Observable.Concat Method</a>
      */
-    public static <T> Observable<T> concat(Observable<T>... source) {
+    public static <T> Observable<T> concat(Observable<? extends T>... source) {
         return create(OperationConcat.concat(source));
     }
 
@@ -694,7 +699,7 @@ public static <T> Observable<T> concat(Observable<T>... source) {
      *         the {@code source} list of Observables
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099(v=vs.103).aspx">MSDN: Observable.Merge Method</a>
      */
-    public static <T> Observable<T> mergeDelayError(List<Observable<T>> source) {
+    public static <T> Observable<T> mergeDelayError(List<? extends Observable<? extends T>> source) {
         return create(OperationMergeDelayError.mergeDelayError(source));
     }
 
@@ -718,7 +723,7 @@ public static <T> Observable<T> mergeDelayError(List<Observable<T>> source) {
      *         the Observables emitted by the {@code source} Observable
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099(v=vs.103).aspx">MSDN: Observable.Merge Method</a>
      */
-    public static <T> Observable<T> mergeDelayError(Observable<Observable<T>> source) {
+    public static <T> Observable<T> mergeDelayError(Observable<? extends Observable<? extends T>> source) {
         return create(OperationMergeDelayError.mergeDelayError(source));
     }
 
@@ -742,7 +747,7 @@ public static <T> Observable<T> mergeDelayError(Observable<Observable<T>> source
      *         the {@code source} Observables
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099(v=vs.103).aspx">MSDN: Observable.Merge Method</a>
      */
-    public static <T> Observable<T> mergeDelayError(Observable<T>... source) {
+    public static <T> Observable<T> mergeDelayError(Observable<? extends T>... source) {
         return create(OperationMergeDelayError.mergeDelayError(source));
     }
 
@@ -772,7 +777,7 @@ public static <T> Observable<T> never() {
      * @return an Observable that emits only the items emitted by the most recently published
      *         Observable
      */
-    public static <T> Observable<T> switchDo(Observable<Observable<T>> sequenceOfSequences) {
+    public static <T> Observable<T> switchDo(Observable<? extends Observable<? extends T>> sequenceOfSequences) {
         // TODO should this static remain? I have left it because it is an Observable<Observable>
         return create(OperationSwitch.switchDo(sequenceOfSequences));
     }
@@ -792,7 +797,7 @@ public static <T> Observable<T> switchDo(Observable<Observable<T>> sequenceOfSeq
     public Observable<T> switchDo() {
         // TODO can we come up with a better name than this? It should be 'switch' but that is reserved.
         // Perhaps 'switchOnNext'?
-        return create(OperationSwitch.switchDo((Observable<Observable<T>>) this));
+        return create(OperationSwitch.switchDo((Observable<? extends Observable<? extends T>>) this));
     }
 
     /**
@@ -812,7 +817,7 @@ public Observable<T> switchDo() {
      * @return an Observable that is a chronologically well-behaved version of the source
      *         Observable, and that synchronously notifies its {@link Observer}s
      */
-    public static <T> Observable<T> synchronize(Observable<T> observable) {
+    public static <T> Observable<T> synchronize(Observable<? extends T> observable) {
         return create(OperationSynchronize.synchronize(observable));
     }
 
@@ -845,7 +850,7 @@ public Observable<Timestamped<T>> timestamp() {
      *            be emitted by the resulting Observable
      * @return an Observable that emits the item from the source Future
      */
-    public static <T> Observable<T> from(Future<T> future) {
+    public static <T> Observable<T> from(Future<? extends T> future) {
         return create(OperationToObservableFuture.toObservableFuture(future));
     }
 
@@ -868,7 +873,7 @@ public static <T> Observable<T> from(Future<T> future) {
      *            be emitted by the resulting Observable
      * @return an Observable that emits the item from the source Future
      */
-    public static <T> Observable<T> from(Future<T> future, Scheduler scheduler) {
+    public static <T> Observable<T> from(Future<? extends T> future, Scheduler scheduler) {
         return create(OperationToObservableFuture.toObservableFuture(future)).subscribeOn(scheduler);
     }
 
@@ -894,7 +899,7 @@ public static <T> Observable<T> from(Future<T> future, Scheduler scheduler) {
      *            be emitted by the resulting Observable
      * @return an Observable that emits the item from the source {@link Future}
      */
-    public static <T> Observable<T> from(Future<T> future, long timeout, TimeUnit unit) {
+    public static <T> Observable<T> from(Future<? extends T> future, long timeout, TimeUnit unit) {
         return create(OperationToObservableFuture.toObservableFuture(future, timeout, unit));
     }
 
@@ -908,18 +913,17 @@ public static <T> Observable<T> from(Future<T> future, long timeout, TimeUnit un
      * The resulting {@code Observable<R>} returned from {@code zip} will invoke {@link Observer#onNext onNext} as many times as the number of {@code onNext} invocations
      * of the source Observable that emits the fewest items.
      * 
-     * @param w0
+     * @param o1
      *            one source Observable
-     * @param w1
+     * @param o2
      *            another source Observable
-     * @param reduceFunction
-     *            a function that, when applied to a pair of items, each emitted by one of the two
-     *            source Observables, results in an item that will be emitted by the resulting
-     *            Observable
+     * @param zipFunction
+     *            a function that, when applied to an item emitted by each of the source
+     *            Observables, results in an item that will be emitted by the resulting Observable
      * @return an Observable that emits the zipped results
      */
-    public static <R, T0, T1> Observable<R> zip(Observable<T0> w0, Observable<T1> w1, Func2<T0, T1, R> reduceFunction) {
-        return create(OperationZip.zip(w0, w1, reduceFunction));
+    public static <T1, T2, R> Observable<R> zip(Observable<? extends T1> o1, Observable<? extends T2> o2, Func2<? super T1, ? super T2, ? extends R> zipFunction) {
+        return create(OperationZip.zip(o1, o2, zipFunction));
     }
 
     /**
@@ -937,7 +941,7 @@ public static <R, T0, T1> Observable<R> zip(Observable<T0> w0, Observable<T1> w1
      * @return an Observable that emits Booleans that indicate whether the corresponding items
      *         emitted by the source Observables are equal
      */
-    public static <T> Observable<Boolean> sequenceEqual(Observable<T> first, Observable<T> second) {
+    public static <T> Observable<Boolean> sequenceEqual(Observable<? extends T> first, Observable<? extends T> second) {
         return sequenceEqual(first, second, new Func2<T, T, Boolean>() {
             @Override
             public Boolean call(T first, T second) {
@@ -964,7 +968,7 @@ public Boolean call(T first, T second) {
      * @return an Observable that emits Booleans that indicate whether the corresponding items
      *         emitted by the source Observables are equal
      */
-    public static <T> Observable<Boolean> sequenceEqual(Observable<T> first, Observable<T> second, Func2<T, T, Boolean> equality) {
+    public static <T> Observable<Boolean> sequenceEqual(Observable<? extends T> first, Observable<? extends T> second, Func2<? super T, ? super T, Boolean> equality) {
         return zip(first, second, equality);
     }
 
@@ -981,19 +985,19 @@ public static <T> Observable<Boolean> sequenceEqual(Observable<T> first, Observa
      * The resulting {@code Observable<R>} returned from {@code zip} will invoke {@link Observer#onNext onNext} as many times as the number of {@code onNext} invocations
      * of the source Observable that emits the fewest items.
      * 
-     * @param w0
+     * @param o1
      *            one source Observable
-     * @param w1
-     *            another source Observable
-     * @param w2
+     * @param o2
+     *            a second source Observable
+     * @param o3
      *            a third source Observable
-     * @param function
+     * @param zipFunction
      *            a function that, when applied to an item emitted by each of the source
      *            Observables, results in an item that will be emitted by the resulting Observable
      * @return an Observable that emits the zipped results
      */
-    public static <R, T0, T1, T2> Observable<R> zip(Observable<T0> w0, Observable<T1> w1, Observable<T2> w2, Func3<T0, T1, T2, R> function) {
-        return create(OperationZip.zip(w0, w1, w2, function));
+    public static <T1, T2, T3, R> Observable<R> zip(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Func3<? super T1, ? super T2, ? super T3, ? extends R> zipFunction) {
+        return create(OperationZip.zip(o1, o2, o3, zipFunction));
     }
 
     /**
@@ -1010,21 +1014,210 @@ public static <R, T0, T1, T2> Observable<R> zip(Observable<T0> w0, Observable<T1
      * The resulting {@code Observable<R>} returned from {@code zip} will invoke {@link Observer#onNext onNext} as many times as the number of {@code onNext} invocations
      * of the source Observable that emits the fewest items.
      * 
-     * @param w0
+     * @param o1
      *            one source Observable
-     * @param w1
-     *            another source Observable
-     * @param w2
+     * @param o2
+     *            a second source Observable
+     * @param o3
+     *            a third source Observable
+     * @param o4
+     *            a fourth source Observable
+     * @param zipFunction
+     *            a function that, when applied to an item emitted by each of the source
+     *            Observables, results in an item that will be emitted by the resulting Observable
+     * @return an Observable that emits the zipped results
+     */
+    public static <T1, T2, T3, T4, R> Observable<R> zip(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Func4<? super T1, ? super T2, ? super T3, ? super T4, ? extends R> zipFunction) {
+        return create(OperationZip.zip(o1, o2, o3, o4, zipFunction));
+    }
+    
+    /**
+     * Returns an Observable that emits the results of a function of your choosing applied to
+     * combinations of four items emitted, in sequence, by four other Observables.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/zip.png">
+     * <p> {@code zip} applies this function in strict sequence, so the first item emitted by the
+     * new Observable will be the result of the function applied to the first item emitted by {@code w0}, the first item emitted by {@code w1}, the first item emitted by {@code w2}, and the first item
+     * emitted by {@code w3}; the second item emitted by
+     * the new Observable will be the result of the function applied to the second item emitted by
+     * each of those Observables; and so forth.
+     * <p>
+     * The resulting {@code Observable<R>} returned from {@code zip} will invoke {@link Observer#onNext onNext} as many times as the number of {@code onNext} invocations
+     * of the source Observable that emits the fewest items.
+     * 
+     * @param o1
+     *            one source Observable
+     * @param o2
+     *            a second source Observable
+     * @param o3
+     *            a third source Observable
+     * @param o4
+     *            a fourth source Observable
+     * @param o5
+     *            a fifth source Observable
+     * @param zipFunction
+     *            a function that, when applied to an item emitted by each of the source
+     *            Observables, results in an item that will be emitted by the resulting Observable
+     * @return an Observable that emits the zipped results
+     */
+    public static <T1, T2, T3, T4, T5, R> Observable<R> zip(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5, Func5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? extends R> zipFunction) {
+        return create(OperationZip.zip(o1, o2, o3, o4, o5, zipFunction));
+    }
+    
+    /**
+     * Returns an Observable that emits the results of a function of your choosing applied to
+     * combinations of four items emitted, in sequence, by four other Observables.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/zip.png">
+     * <p> {@code zip} applies this function in strict sequence, so the first item emitted by the
+     * new Observable will be the result of the function applied to the first item emitted by {@code w0}, the first item emitted by {@code w1}, the first item emitted by {@code w2}, and the first item
+     * emitted by {@code w3}; the second item emitted by
+     * the new Observable will be the result of the function applied to the second item emitted by
+     * each of those Observables; and so forth.
+     * <p>
+     * The resulting {@code Observable<R>} returned from {@code zip} will invoke {@link Observer#onNext onNext} as many times as the number of {@code onNext} invocations
+     * of the source Observable that emits the fewest items.
+     * 
+     * @param o1
+     *            one source Observable
+     * @param o2
+     *            a second source Observable
+     * @param o3
+     *            a third source Observable
+     * @param o4
+     *            a fourth source Observable
+     * @param o5
+     *            a fifth source Observable
+     * @param o6
+     *            a sixth source Observable
+     * @param zipFunction
+     *            a function that, when applied to an item emitted by each of the source
+     *            Observables, results in an item that will be emitted by the resulting Observable
+     * @return an Observable that emits the zipped results
+     */
+    public static <T1, T2, T3, T4, T5, T6, R> Observable<R> zip(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5, Observable<? extends T6> o6,
+            Func6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? extends R> zipFunction) {
+        return create(OperationZip.zip(o1, o2, o3, o4, o5, o6, zipFunction));
+    }
+    
+    /**
+     * Returns an Observable that emits the results of a function of your choosing applied to
+     * combinations of four items emitted, in sequence, by four other Observables.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/zip.png">
+     * <p> {@code zip} applies this function in strict sequence, so the first item emitted by the
+     * new Observable will be the result of the function applied to the first item emitted by {@code w0}, the first item emitted by {@code w1}, the first item emitted by {@code w2}, and the first item
+     * emitted by {@code w3}; the second item emitted by
+     * the new Observable will be the result of the function applied to the second item emitted by
+     * each of those Observables; and so forth.
+     * <p>
+     * The resulting {@code Observable<R>} returned from {@code zip} will invoke {@link Observer#onNext onNext} as many times as the number of {@code onNext} invocations
+     * of the source Observable that emits the fewest items.
+     * 
+     * @param o1
+     *            one source Observable
+     * @param o2
+     *            a second source Observable
+     * @param o3
+     *            a third source Observable
+     * @param o4
+     *            a fourth source Observable
+     * @param o5
+     *            a fifth source Observable
+     * @param o6
+     *            a sixth source Observable
+     * @param o7
+     *            a seventh source Observable
+     * @param zipFunction
+     *            a function that, when applied to an item emitted by each of the source
+     *            Observables, results in an item that will be emitted by the resulting Observable
+     * @return an Observable that emits the zipped results
+     */
+    public static <T1, T2, T3, T4, T5, T6, T7, R> Observable<R> zip(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5, Observable<? extends T6> o6, Observable<? extends T7> o7,
+            Func7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? extends R> zipFunction) {
+        return create(OperationZip.zip(o1, o2, o3, o4, o5, o6, o7, zipFunction));
+    }
+    
+    /**
+     * Returns an Observable that emits the results of a function of your choosing applied to
+     * combinations of four items emitted, in sequence, by four other Observables.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/zip.png">
+     * <p> {@code zip} applies this function in strict sequence, so the first item emitted by the
+     * new Observable will be the result of the function applied to the first item emitted by {@code w0}, the first item emitted by {@code w1}, the first item emitted by {@code w2}, and the first item
+     * emitted by {@code w3}; the second item emitted by
+     * the new Observable will be the result of the function applied to the second item emitted by
+     * each of those Observables; and so forth.
+     * <p>
+     * The resulting {@code Observable<R>} returned from {@code zip} will invoke {@link Observer#onNext onNext} as many times as the number of {@code onNext} invocations
+     * of the source Observable that emits the fewest items.
+     * 
+     * @param o1
+     *            one source Observable
+     * @param o2
+     *            a second source Observable
+     * @param o3
+     *            a third source Observable
+     * @param o4
+     *            a fourth source Observable
+     * @param o5
+     *            a fifth source Observable
+     * @param o6
+     *            a sixth source Observable
+     * @param o7
+     *            a seventh source Observable
+     * @param o8
+     *            an eighth source Observable
+     * @param zipFunction
+     *            a function that, when applied to an item emitted by each of the source
+     *            Observables, results in an item that will be emitted by the resulting Observable
+     * @return an Observable that emits the zipped results
+     */
+    public static <T1, T2, T3, T4, T5, T6, T7, T8, R> Observable<R> zip(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5, Observable<? extends T6> o6, Observable<? extends T7> o7, Observable<? extends T8> o8,
+            Func8<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? extends R> zipFunction) {
+        return create(OperationZip.zip(o1, o2, o3, o4, o5, o6, o7, o8, zipFunction));
+    }
+    
+    /**
+     * Returns an Observable that emits the results of a function of your choosing applied to
+     * combinations of four items emitted, in sequence, by four other Observables.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/zip.png">
+     * <p> {@code zip} applies this function in strict sequence, so the first item emitted by the
+     * new Observable will be the result of the function applied to the first item emitted by {@code w0}, the first item emitted by {@code w1}, the first item emitted by {@code w2}, and the first item
+     * emitted by {@code w3}; the second item emitted by
+     * the new Observable will be the result of the function applied to the second item emitted by
+     * each of those Observables; and so forth.
+     * <p>
+     * The resulting {@code Observable<R>} returned from {@code zip} will invoke {@link Observer#onNext onNext} as many times as the number of {@code onNext} invocations
+     * of the source Observable that emits the fewest items.
+     * 
+     * @param o1
+     *            one source Observable
+     * @param o2
+     *            a second source Observable
+     * @param o3
      *            a third source Observable
-     * @param w3
+     * @param o4
      *            a fourth source Observable
-     * @param reduceFunction
+     * @param o5
+     *            a fifth source Observable
+     * @param o6
+     *            a sixth source Observable
+     * @param o7
+     *            a seventh source Observable
+     * @param o8
+     *            an eighth source Observable
+     * @param o9
+     *            a ninth source Observable
+     * @param zipFunction
      *            a function that, when applied to an item emitted by each of the source
      *            Observables, results in an item that will be emitted by the resulting Observable
      * @return an Observable that emits the zipped results
      */
-    public static <R, T0, T1, T2, T3> Observable<R> zip(Observable<T0> w0, Observable<T1> w1, Observable<T2> w2, Observable<T3> w3, Func4<T0, T1, T2, T3, R> reduceFunction) {
-        return create(OperationZip.zip(w0, w1, w2, w3, reduceFunction));
+    public static <T1, T2, T3, T4, T5, T6, T7, T8, T9, R> Observable<R> zip(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5, Observable<? extends T6> o6, Observable<? extends T7> o7, Observable<? extends T8> o8,
+            Observable<? extends T9> o9, Func9<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? super T9, ? extends R> zipFunction) {
+        return create(OperationZip.zip(o1, o2, o3, o4, o5, o6, o7, o8, o9, zipFunction));
     }
 
     /**
@@ -1033,30 +1226,71 @@ public static <R, T0, T1, T2, T3> Observable<R> zip(Observable<T0> w0, Observabl
      * <p>
      * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/combineLatest.png">
      * 
-     * @param w0
+     * @param o1
      *            The first source observable.
-     * @param w1
+     * @param o2
      *            The second source observable.
      * @param combineFunction
      *            The aggregation function used to combine the source observable values.
      * @return An Observable that combines the source Observables with the given combine function
      */
-    public static <R, T0, T1> Observable<R> combineLatest(Observable<T0> w0, Observable<T1> w1, Func2<T0, T1, R> combineFunction) {
-        return create(OperationCombineLatest.combineLatest(w0, w1, combineFunction));
+    public static <T1, T2, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Func2<? super T1, ? super T2, ? extends R> combineFunction) {
+        return create(OperationCombineLatest.combineLatest(o1, o2, combineFunction));
+    }
+
+    /**
+     * @see #combineLatest(Observable, Observable, Func2)
+     */
+    public static <T1, T2, T3, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Func3<? super T1, ? super T2, ? super T3, ? extends R> combineFunction) {
+        return create(OperationCombineLatest.combineLatest(o1, o2, o3, combineFunction));
+    }
+
+    /**
+     * @see #combineLatest(Observable, Observable, Func2)
+     */
+    public static <T1, T2, T3, T4, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, 
+            Func4<? super T1, ? super T2, ? super T3, ? super T4, ? extends R> combineFunction) {
+        return create(OperationCombineLatest.combineLatest(o1, o2, o3, o4, combineFunction));
+    }
+
+    /**
+     * @see #combineLatest(Observable, Observable, Func2)
+     */
+    public static <T1, T2, T3, T4, T5, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5, 
+            Func5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? extends R> combineFunction) {
+        return create(OperationCombineLatest.combineLatest(o1, o2, o3, o4, o5, combineFunction));
+    }
+
+    /**
+     * @see #combineLatest(Observable, Observable, Func2)
+     */
+    public static <T1, T2, T3, T4, T5, T6, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5, Observable<? extends T6> o6, 
+            Func6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? extends R> combineFunction) {
+        return create(OperationCombineLatest.combineLatest(o1, o2, o3, o4, o5, o6, combineFunction));
+    }
+
+    /**
+     * @see #combineLatest(Observable, Observable, Func2)
+     */
+    public static <T1, T2, T3, T4, T5, T6, T7, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5, Observable<? extends T6> o6, Observable<? extends T7> o7, 
+            Func7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? extends R> combineFunction) {
+        return create(OperationCombineLatest.combineLatest(o1, o2, o3, o4, o5, o6, o7, combineFunction));
     }
 
     /**
      * @see #combineLatest(Observable, Observable, Func2)
      */
-    public static <R, T0, T1, T2> Observable<R> combineLatest(Observable<T0> w0, Observable<T1> w1, Observable<T2> w2, Func3<T0, T1, T2, R> combineFunction) {
-        return create(OperationCombineLatest.combineLatest(w0, w1, w2, combineFunction));
+    public static <T1, T2, T3, T4, T5, T6, T7, T8, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5, Observable<? extends T6> o6, Observable<? extends T7> o7, Observable<? extends T8> o8, 
+            Func8<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? extends R> combineFunction) {
+        return create(OperationCombineLatest.combineLatest(o1, o2, o3, o4, o5, o6, o7, o8, combineFunction));
     }
 
     /**
      * @see #combineLatest(Observable, Observable, Func2)
      */
-    public static <R, T0, T1, T2, T3> Observable<R> combineLatest(Observable<T0> w0, Observable<T1> w1, Observable<T2> w2, Observable<T3> w3, Func4<T0, T1, T2, T3, R> combineFunction) {
-        return create(OperationCombineLatest.combineLatest(w0, w1, w2, w3, combineFunction));
+    public static <T1, T2, T3, T4, T5, T6, T7, T8, T9, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5, Observable<? extends T6> o6, Observable<? extends T7> o7, Observable<? extends T8> o8, Observable<? extends T9> o9, 
+            Func9<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? super T9, ? extends R> combineFunction) {
+        return create(OperationCombineLatest.combineLatest(o1, o2, o3, o4, o5, o6, o7, o8, o9, combineFunction));
     }
 
     /**
@@ -1074,7 +1308,7 @@ public static <R, T0, T1, T2, T3> Observable<R> combineLatest(Observable<T0> w0,
      *         An {@link Observable} which produces connected non-overlapping buffers, which are emitted
      *         when the current {@link Observable} created with the {@link Func0} argument produces a {@link BufferClosing} object.
      */
-    public Observable<List<T>> buffer(Func0<Observable<BufferClosing>> bufferClosingSelector) {
+    public Observable<List<T>> buffer(Func0<? extends Observable<? extends BufferClosing>> bufferClosingSelector) {
         return create(OperationBuffer.buffer(this, bufferClosingSelector));
     }
 
@@ -1096,7 +1330,7 @@ public Observable<List<T>> buffer(Func0<Observable<BufferClosing>> bufferClosing
      * @return
      *         An {@link Observable} which produces buffers which are created and emitted when the specified {@link Observable}s publish certain objects.
      */
-    public Observable<List<T>> buffer(Observable<BufferOpening> bufferOpenings, Func1<BufferOpening, Observable<BufferClosing>> bufferClosingSelector) {
+    public Observable<List<T>> buffer(Observable<? extends BufferOpening> bufferOpenings, Func1<? super BufferOpening, ? extends Observable<? extends BufferClosing>> bufferClosingSelector) {
         return create(OperationBuffer.buffer(this, bufferOpenings, bufferClosingSelector));
     }
 
@@ -1278,16 +1512,16 @@ public Observable<List<T>> buffer(long timespan, long timeshift, TimeUnit unit,
      * 
      * @param ws
      *            An Observable of source Observables
-     * @param reduceFunction
+     * @param zipFunction
      *            a function that, when applied to an item emitted by each of the source
      *            Observables, results in an item that will be emitted by the resulting Observable
      * @return an Observable that emits the zipped results
      */
-    public static <R> Observable<R> zip(Observable<Observable<?>> ws, final FuncN<R> reduceFunction) {
-        return ws.toList().mapMany(new Func1<List<Observable<?>>, Observable<R>>() {
+    public static <R> Observable<R> zip(Observable<? extends Observable<?>> ws, final FuncN<? extends R> zipFunction) {
+        return ws.toList().mapMany(new Func1<List<? extends Observable<?>>, Observable<? extends R>>() {
             @Override
-            public Observable<R> call(List<Observable<?>> wsList) {
-                return create(OperationZip.zip(wsList, reduceFunction));
+            public Observable<R> call(List<? extends Observable<?>> wsList) {
+                return create(OperationZip.zip(wsList, zipFunction));
             }
         });
     }
@@ -1307,13 +1541,13 @@ public Observable<R> call(List<Observable<?>> wsList) {
      * 
      * @param ws
      *            A collection of source Observables
-     * @param reduceFunction
+     * @param zipFunction
      *            a function that, when applied to an item emitted by each of the source
      *            Observables, results in an item that will be emitted by the resulting Observable
      * @return an Observable that emits the zipped results
      */
-    public static <R> Observable<R> zip(Collection<Observable<?>> ws, FuncN<R> reduceFunction) {
-        return create(OperationZip.zip(ws, reduceFunction));
+    public static <R> Observable<R> zip(Collection<? extends Observable<?>> ws, FuncN<? extends R> zipFunction) {
+        return create(OperationZip.zip(ws, zipFunction));
     }
 
     /**
@@ -1325,7 +1559,7 @@ public static <R> Observable<R> zip(Collection<Observable<?>> ws, FuncN<R> reduc
      * @return an Observable that emits only those items in the original Observable that the filter
      *         evaluates as {@code true}
      */
-    public Observable<T> filter(Func1<T, Boolean> predicate) {
+    public Observable<T> filter(Func1<? super T, Boolean> predicate) {
         return create(OperationFilter.filter(this, predicate));
     }
 
@@ -1360,7 +1594,7 @@ public Observable<T> finallyDo(Action0 action) {
      *         obtained from this transformation.
      * @see #mapMany(Func1)
      */
-    public <R> Observable<R> flatMap(Func1<T, Observable<R>> func) {
+    public <R> Observable<R> flatMap(Func1<? super T, ? extends Observable<? extends R>> func) {
         return mapMany(func);
     }
 
@@ -1374,7 +1608,7 @@ public <R> Observable<R> flatMap(Func1<T, Observable<R>> func) {
      *         evaluates as {@code true}
      * @see #filter(Func1)
      */
-    public Observable<T> where(Func1<T, Boolean> predicate) {
+    public Observable<T> where(Func1<? super T, Boolean> predicate) {
         return filter(predicate);
     }
 
@@ -1389,7 +1623,7 @@ public Observable<T> where(Func1<T, Boolean> predicate) {
      * @return an Observable that emits the items from the source Observable, transformed by the
      *         given function
      */
-    public <R> Observable<R> map(Func1<T, R> func) {
+    public <R> Observable<R> map(Func1<? super T, ? extends R> func) {
         return create(OperationMap.map(this, func));
     }
 
@@ -1410,7 +1644,7 @@ public <R> Observable<R> map(Func1<T, R> func) {
      *         obtained from this transformation.
      * @see #flatMap(Func1)
      */
-    public <R> Observable<R> mapMany(Func1<T, Observable<R>> func) {
+    public <R> Observable<R> mapMany(Func1<? super T, ? extends Observable<? extends R>> func) {
         return create(OperationMap.mapMany(this, func));
     }
 
@@ -1469,7 +1703,7 @@ public Observable<T> observeOn(Scheduler scheduler) {
      */
     @SuppressWarnings("unchecked")
     public <T2> Observable<T2> dematerialize() {
-        return create(OperationDematerialize.dematerialize((Observable<Notification<T2>>) this));
+        return create(OperationDematerialize.dematerialize((Observable<? extends Notification<? extends T2>>) this));
     }
 
     /**
@@ -1496,7 +1730,7 @@ public <T2> Observable<T2> dematerialize() {
      *            encounters an error
      * @return the original Observable, with appropriately modified behavior
      */
-    public Observable<T> onErrorResumeNext(final Func1<Throwable, Observable<T>> resumeFunction) {
+    public Observable<T> onErrorResumeNext(final Func1<Throwable, ? extends Observable<? extends T>> resumeFunction) {
         return create(OperationOnErrorResumeNextViaFunction.onErrorResumeNextViaFunction(this, resumeFunction));
     }
 
@@ -1524,7 +1758,7 @@ public Observable<T> onErrorResumeNext(final Func1<Throwable, Observable<T>> res
      *            encounters an error
      * @return the original Observable, with appropriately modified behavior
      */
-    public Observable<T> onErrorResumeNext(final Observable<T> resumeSequence) {
+    public Observable<T> onErrorResumeNext(final Observable<? extends T> resumeSequence) {
         return create(OperationOnErrorResumeNextViaObservable.onErrorResumeNextViaObservable(this, resumeSequence));
     }
 
@@ -1554,7 +1788,7 @@ public Observable<T> onErrorResumeNext(final Observable<T> resumeSequence) {
      *            encounters an error
      * @return the original Observable, with appropriately modified behavior
      */
-    public Observable<T> onExceptionResumeNext(final Observable<T> resumeSequence) {
+    public Observable<T> onExceptionResumeNext(final Observable<? extends T> resumeSequence) {
         return create(OperationOnExceptionResumeNextViaObservable.onExceptionResumeNextViaObservable(this, resumeSequence));
     }
 
@@ -1581,7 +1815,7 @@ public Observable<T> onExceptionResumeNext(final Observable<T> resumeSequence) {
      *            Observable encounters an error
      * @return the original Observable with appropriately modified behavior
      */
-    public Observable<T> onErrorReturn(Func1<Throwable, T> resumeFunction) {
+    public Observable<T> onErrorReturn(Func1<Throwable, ? extends T> resumeFunction) {
         return create(OperationOnErrorReturn.onErrorReturn(this, resumeFunction));
     }
 
@@ -1606,7 +1840,7 @@ public Observable<T> onErrorReturn(Func1<Throwable, T> resumeFunction) {
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229154(v%3Dvs.103).aspx">MSDN: Observable.Aggregate</a>
      * @see <a href="http://en.wikipedia.org/wiki/Fold_(higher-order_function)">Wikipedia: Fold (higher-order function)</a>
      */
-    public Observable<T> reduce(Func2<T, T, T> accumulator) {
+    public Observable<T> reduce(Func2<? super T, ? super T, ? extends T> accumulator) {
         return create(OperationScan.scan(this, accumulator)).takeLast(1);
     }
 
@@ -1663,7 +1897,7 @@ public ConnectableObservable<T> publish() {
      * 
      * @see #reduce(Func2)
      */
-    public Observable<T> aggregate(Func2<T, T, T> accumulator) {
+    public Observable<T> aggregate(Func2<? super T, ? super T, ? extends T> accumulator) {
         return reduce(accumulator);
     }
 
@@ -1690,7 +1924,7 @@ public Observable<T> aggregate(Func2<T, T, T> accumulator) {
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229154(v%3Dvs.103).aspx">MSDN: Observable.Aggregate</a>
      * @see <a href="http://en.wikipedia.org/wiki/Fold_(higher-order_function)">Wikipedia: Fold (higher-order function)</a>
      */
-    public <R> Observable<R> reduce(R initialValue, Func2<R, T, R> accumulator) {
+    public <R> Observable<R> reduce(R initialValue, Func2<? super R, ? super T, ? extends R> accumulator) {
         return create(OperationScan.scan(this, initialValue, accumulator)).takeLast(1);
     }
 
@@ -1701,7 +1935,7 @@ public <R> Observable<R> reduce(R initialValue, Func2<R, T, R> accumulator) {
      * 
      * @see #reduce(Object, Func2)
      */
-    public <R> Observable<R> aggregate(R initialValue, Func2<R, T, R> accumulator) {
+    public <R> Observable<R> aggregate(R initialValue, Func2<? super R, ? super T, ? extends R> accumulator) {
         return reduce(initialValue, accumulator);
     }
 
@@ -1724,7 +1958,7 @@ public <R> Observable<R> aggregate(R initialValue, Func2<R, T, R> accumulator) {
      * @return an Observable that emits the results of each call to the accumulator function
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh211665(v%3Dvs.103).aspx">MSDN: Observable.Scan</a>
      */
-    public Observable<T> scan(Func2<T, T, T> accumulator) {
+    public Observable<T> scan(Func2<? super T, ? super T, ? extends T> accumulator) {
         return create(OperationScan.scan(this, accumulator));
     }
 
@@ -1785,7 +2019,7 @@ public Observable<T> sample(long period, TimeUnit unit, Scheduler scheduler) {
      * @return an Observable that emits the results of each call to the accumulator function
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh211665(v%3Dvs.103).aspx">MSDN: Observable.Scan</a>
      */
-    public <R> Observable<R> scan(R initialValue, Func2<R, T, R> accumulator) {
+    public <R> Observable<R> scan(R initialValue, Func2<? super R, ? super T, ? extends R> accumulator) {
         return create(OperationScan.scan(this, initialValue, accumulator));
     }
 
@@ -1800,7 +2034,7 @@ public <R> Observable<R> scan(R initialValue, Func2<R, T, R> accumulator) {
      * @return an Observable that emits <code>true</code> if all items emitted by the source
      *         Observable satisfy the predicate; otherwise, <code>false</code>
      */
-    public Observable<Boolean> all(Func1<T, Boolean> predicate) {
+    public Observable<Boolean> all(Func1<? super T, Boolean> predicate) {
         return create(OperationAll.all(this, predicate));
     }
 
@@ -1853,7 +2087,7 @@ public Observable<T> take(final int num) {
      * @return an Observable that emits the items from the source Observable so long as each item
      *         satisfies the condition defined by <code>predicate</code>
      */
-    public Observable<T> takeWhile(final Func1<T, Boolean> predicate) {
+    public Observable<T> takeWhile(final Func1<? super T, Boolean> predicate) {
         return create(OperationTakeWhile.takeWhile(this, predicate));
     }
 
@@ -1870,7 +2104,7 @@ public Observable<T> takeWhile(final Func1<T, Boolean> predicate) {
      * @return an Observable that emits items from the source Observable so long as the predicate
      *         continues to return <code>true</code> for each item, then completes
      */
-    public Observable<T> takeWhileWithIndex(final Func2<T, Integer, Boolean> predicate) {
+    public Observable<T> takeWhileWithIndex(final Func2<? super T, ? super Integer, Boolean> predicate) {
         return create(OperationTakeWhile.takeWhileWithIndex(this, predicate));
     }
 
@@ -1904,7 +2138,7 @@ public Observable<T> takeLast(final int count) {
      * @return an Observable that emits the items of the source Observable until such time as
      *         <code>other</code> emits its first item
      */
-    public <E> Observable<T> takeUntil(Observable<E> other) {
+    public <E> Observable<T> takeUntil(Observable<? extends E> other) {
         return OperationTakeUntil.takeUntil(this, other);
     }
 
@@ -1956,7 +2190,7 @@ public Observable<List<T>> toSortedList() {
      *            an Integer that indicates their sort order
      * @return an Observable that emits the items from the source Observable in sorted order
      */
-    public Observable<List<T>> toSortedList(Func2<T, T, Integer> sortFunction) {
+    public Observable<List<T>> toSortedList(Func2<? super T, ? super T, Integer> sortFunction) {
         return create(OperationToObservableSortedList.toSortedList(this, sortFunction));
     }
 
@@ -1992,7 +2226,7 @@ public Observable<T> startWith(T... values) {
      *         unique key value and emits items representing items from the source Observable that
      *         share that key value
      */
-    public <K, R> Observable<GroupedObservable<K, R>> groupBy(final Func1<T, K> keySelector, final Func1<T, R> elementSelector) {
+    public <K, R> Observable<GroupedObservable<K, R>> groupBy(final Func1<? super T, ? extends K> keySelector, final Func1<? super T, ? extends R> elementSelector) {
         return create(OperationGroupBy.groupBy(this, keySelector, elementSelector));
     }
 
@@ -2010,7 +2244,7 @@ public <K, R> Observable<GroupedObservable<K, R>> groupBy(final Func1<T, K> keyS
      *         unique key value and emits items representing items from the source Observable that
      *         share that key value
      */
-    public <K> Observable<GroupedObservable<K, T>> groupBy(final Func1<T, K> keySelector) {
+    public <K> Observable<GroupedObservable<K, T>> groupBy(final Func1<? super T, ? extends K> keySelector) {
         return create(OperationGroupBy.groupBy(this, keySelector));
     }
 
diff --git a/rxjava-core/src/main/java/rx/Scheduler.java b/rxjava-core/src/main/java/rx/Scheduler.java
index 4af62d0d83..06a708d4d4 100644
--- a/rxjava-core/src/main/java/rx/Scheduler.java
+++ b/rxjava-core/src/main/java/rx/Scheduler.java
@@ -62,7 +62,7 @@ public abstract class Scheduler {
      *            Action to schedule.
      * @return a subscription to be able to unsubscribe from action.
      */
-    public abstract <T> Subscription schedule(T state, Func2<Scheduler, T, Subscription> action);
+    public abstract <T> Subscription schedule(T state, Func2<? super Scheduler, ? super T, ? extends Subscription> action);
 
     /**
      * Schedules a cancelable action to be executed in delayTime.
@@ -77,7 +77,7 @@ public abstract class Scheduler {
      *            Time unit of the delay time.
      * @return a subscription to be able to unsubscribe from action.
      */
-    public abstract <T> Subscription schedule(T state, Func2<Scheduler, T, Subscription> action, long delayTime, TimeUnit unit);
+    public abstract <T> Subscription schedule(T state, Func2<? super Scheduler, ? super T, ? extends Subscription> action, long delayTime, TimeUnit unit);
 
     /**
      * Schedules a cancelable action to be executed periodically.
@@ -96,7 +96,7 @@ public abstract class Scheduler {
      *            The time unit the interval above is given in.
      * @return A subscription to be able to unsubscribe from action.
      */
-    public <T> Subscription schedulePeriodically(T state, final Func2<Scheduler, T, Subscription> action, long initialDelay, long period, TimeUnit unit) {
+    public <T> Subscription schedulePeriodically(T state, final Func2<? super Scheduler, ? super T, ? extends Subscription> action, long initialDelay, long period, TimeUnit unit) {
         final long periodInNanos = unit.toNanos(period);
         final AtomicBoolean complete = new AtomicBoolean();
   
@@ -140,7 +140,7 @@ public void call() {
      *            Time the action is to be executed. If in the past it will be executed immediately.
      * @return a subscription to be able to unsubscribe from action.
      */
-    public <T> Subscription schedule(T state, Func2<Scheduler, T, Subscription> action, Date dueTime) {
+    public <T> Subscription schedule(T state, Func2<? super Scheduler, ? super T, ? extends Subscription> action, Date dueTime) {
         long scheduledTime = dueTime.getTime();
         long timeInFuture = scheduledTime - now();
         if (timeInFuture <= 0) {
@@ -162,7 +162,7 @@ public Subscription schedule(final Action0 action) {
         return schedule(null, new Func2<Scheduler, Void, Subscription>() {
 
             @Override
-            public Subscription call(@SuppressWarnings("unused") Scheduler scheduler, @SuppressWarnings("unused") Void state) {
+            public Subscription call(Scheduler scheduler, Void state) {
                 action.call();
                 return Subscriptions.empty();
             }
@@ -180,7 +180,7 @@ public Subscription schedule(final Action0 action, long delayTime, TimeUnit unit
         return schedule(null, new Func2<Scheduler, Void, Subscription>() {
 
             @Override
-            public Subscription call(@SuppressWarnings("unused") Scheduler scheduler, @SuppressWarnings("unused") Void state) {
+            public Subscription call(Scheduler scheduler, Void state) {
                 action.call();
                 return Subscriptions.empty();
             }
@@ -204,7 +204,7 @@ public Subscription call(@SuppressWarnings("unused") Scheduler scheduler, @Suppr
     public Subscription schedulePeriodically(final Action0 action, long initialDelay, long period, TimeUnit unit) {
         return schedulePeriodically(null, new Func2<Scheduler, Void, Subscription>() {
             @Override
-            public Subscription call(@SuppressWarnings("unused") Scheduler scheduler, @SuppressWarnings("unused") Void state) {
+            public Subscription call(Scheduler scheduler, Void state) {
                 action.call();
                 return Subscriptions.empty();
             }
diff --git a/rxjava-core/src/main/java/rx/concurrency/CurrentThreadScheduler.java b/rxjava-core/src/main/java/rx/concurrency/CurrentThreadScheduler.java
index dd45102fd1..455b49d04c 100644
--- a/rxjava-core/src/main/java/rx/concurrency/CurrentThreadScheduler.java
+++ b/rxjava-core/src/main/java/rx/concurrency/CurrentThreadScheduler.java
@@ -47,14 +47,14 @@ private CurrentThreadScheduler() {
     private final AtomicInteger counter = new AtomicInteger(0);
 
     @Override
-    public <T> Subscription schedule(T state, Func2<Scheduler, T, Subscription> action) {
+    public <T> Subscription schedule(T state, Func2<? super Scheduler, ? super T, ? extends Subscription> action) {
         DiscardableAction<T> discardableAction = new DiscardableAction<T>(state, action);
         enqueue(discardableAction, now());
         return discardableAction;
     }
 
     @Override
-    public <T> Subscription schedule(T state, Func2<Scheduler, T, Subscription> action, long dueTime, TimeUnit unit) {
+    public <T> Subscription schedule(T state, Func2<? super Scheduler, ? super T, ? extends Subscription> action, long dueTime, TimeUnit unit) {
         long execTime = now() + unit.toMillis(dueTime);
 
         DiscardableAction<T> discardableAction = new DiscardableAction<T>(state, new SleepingAction<T>(action, this, execTime));
diff --git a/rxjava-core/src/main/java/rx/concurrency/DiscardableAction.java b/rxjava-core/src/main/java/rx/concurrency/DiscardableAction.java
index c0c7402455..94d04075c5 100644
--- a/rxjava-core/src/main/java/rx/concurrency/DiscardableAction.java
+++ b/rxjava-core/src/main/java/rx/concurrency/DiscardableAction.java
@@ -27,13 +27,13 @@
  * Combines standard {@link Subscription#unsubscribe()} functionality with ability to skip execution if an unsubscribe occurs before the {@link #call()} method is invoked.
  */
 /* package */class DiscardableAction<T> implements Func1<Scheduler, Subscription>, Subscription {
-    private final Func2<Scheduler, T, Subscription> underlying;
+    private final Func2<? super Scheduler, ? super T, ? extends Subscription> underlying;
     private final T state;
 
     private final SafeObservableSubscription wrapper = new SafeObservableSubscription();
     private final AtomicBoolean ready = new AtomicBoolean(true);
 
-    public DiscardableAction(T state, Func2<Scheduler, T, Subscription> underlying) {
+    public DiscardableAction(T state, Func2<? super Scheduler, ? super T, ? extends Subscription> underlying) {
         this.state = state;
         this.underlying = underlying;
     }
diff --git a/rxjava-core/src/main/java/rx/concurrency/ExecutorScheduler.java b/rxjava-core/src/main/java/rx/concurrency/ExecutorScheduler.java
index a2522a2900..a1fd36179e 100644
--- a/rxjava-core/src/main/java/rx/concurrency/ExecutorScheduler.java
+++ b/rxjava-core/src/main/java/rx/concurrency/ExecutorScheduler.java
@@ -45,7 +45,7 @@ public ExecutorScheduler(ScheduledExecutorService executor) {
     }
 
     @Override
-    public <T> Subscription schedulePeriodically(final T state, final Func2<Scheduler, T, Subscription> action, long initialDelay, long period, TimeUnit unit) {
+    public <T> Subscription schedulePeriodically(final T state, final Func2<? super Scheduler, ? super T, ? extends Subscription> action, long initialDelay, long period, TimeUnit unit) {
         if (executor instanceof ScheduledExecutorService) {
             final CompositeSubscription subscriptions = new CompositeSubscription();
             
@@ -66,7 +66,7 @@ public void run() {
     }
     
     @Override
-    public <T> Subscription schedule(final T state, final Func2<Scheduler, T, Subscription> action, long delayTime, TimeUnit unit) {
+    public <T> Subscription schedule(final T state, final Func2<? super Scheduler, ? super T, ? extends Subscription> action, long delayTime, TimeUnit unit) {
         final DiscardableAction<T> discardableAction = new DiscardableAction<T>(state, action);
         final Scheduler _scheduler = this;
         // all subscriptions that may need to be unsubscribed
@@ -113,7 +113,7 @@ public void run() {
     }
 
     @Override
-    public <T> Subscription schedule(T state, Func2<Scheduler, T, Subscription> action) {
+    public <T> Subscription schedule(T state, Func2<? super Scheduler, ? super T, ? extends Subscription> action) {
         final DiscardableAction<T> discardableAction = new DiscardableAction<T>(state, action);
         final Scheduler _scheduler = this;
         // all subscriptions that may need to be unsubscribed
diff --git a/rxjava-core/src/main/java/rx/concurrency/ImmediateScheduler.java b/rxjava-core/src/main/java/rx/concurrency/ImmediateScheduler.java
index 198073b960..f3f4353bb7 100644
--- a/rxjava-core/src/main/java/rx/concurrency/ImmediateScheduler.java
+++ b/rxjava-core/src/main/java/rx/concurrency/ImmediateScheduler.java
@@ -41,12 +41,12 @@ private ImmediateScheduler() {
     }
 
     @Override
-    public <T> Subscription schedule(T state, Func2<Scheduler, T, Subscription> action) {
+    public <T> Subscription schedule(T state, Func2<? super Scheduler, ? super T, ? extends Subscription> action) {
         return action.call(this, state);
     }
 
     @Override
-    public <T> Subscription schedule(T state, Func2<Scheduler, T, Subscription> action, long dueTime, TimeUnit unit) {
+    public <T> Subscription schedule(T state, Func2<? super Scheduler, ? super T, ? extends Subscription> action, long dueTime, TimeUnit unit) {
         // since we are executing immediately on this thread we must cause this thread to sleep
         long execTime = now() + unit.toMillis(dueTime);
 
diff --git a/rxjava-core/src/main/java/rx/concurrency/NewThreadScheduler.java b/rxjava-core/src/main/java/rx/concurrency/NewThreadScheduler.java
index caf4e5a51d..d8e178bc0d 100644
--- a/rxjava-core/src/main/java/rx/concurrency/NewThreadScheduler.java
+++ b/rxjava-core/src/main/java/rx/concurrency/NewThreadScheduler.java
@@ -36,7 +36,7 @@ public static NewThreadScheduler getInstance() {
     }
 
     @Override
-    public <T> Subscription schedule(final T state, final Func2<Scheduler, T, Subscription> action) {
+    public <T> Subscription schedule(final T state, final Func2<? super Scheduler, ? super T, ? extends Subscription> action) {
         final SafeObservableSubscription subscription = new SafeObservableSubscription();
         final Scheduler _scheduler = this;
 
@@ -53,7 +53,7 @@ public void run() {
     }
 
     @Override
-    public <T> Subscription schedule(final T state, final Func2<Scheduler, T, Subscription> action, long delay, TimeUnit unit) {
+    public <T> Subscription schedule(final T state, final Func2<? super Scheduler, ? super T, ? extends Subscription> action, long delay, TimeUnit unit) {
         // we will use the system scheduler since it doesn't make sense to launch a new Thread and then sleep
         // we will instead schedule the event then launch the thread after the delay has passed
         final Scheduler _scheduler = this;
diff --git a/rxjava-core/src/main/java/rx/concurrency/SleepingAction.java b/rxjava-core/src/main/java/rx/concurrency/SleepingAction.java
index d3c2f82cbb..eea75639b8 100644
--- a/rxjava-core/src/main/java/rx/concurrency/SleepingAction.java
+++ b/rxjava-core/src/main/java/rx/concurrency/SleepingAction.java
@@ -20,11 +20,11 @@
 import rx.util.functions.Func2;
 
 /* package */class SleepingAction<T> implements Func2<Scheduler, T, Subscription> {
-    private final Func2<Scheduler, T, Subscription> underlying;
+    private final Func2<? super Scheduler, ? super T, ? extends Subscription> underlying;
     private final Scheduler scheduler;
     private final long execTime;
 
-    public SleepingAction(Func2<Scheduler, T, Subscription> underlying, Scheduler scheduler, long execTime) {
+    public SleepingAction(Func2<? super Scheduler, ? super T, ? extends Subscription> underlying, Scheduler scheduler, long execTime) {
         this.underlying = underlying;
         this.scheduler = scheduler;
         this.execTime = execTime;
diff --git a/rxjava-core/src/main/java/rx/concurrency/TestScheduler.java b/rxjava-core/src/main/java/rx/concurrency/TestScheduler.java
index 739c6cb6b4..7afab7ec42 100644
--- a/rxjava-core/src/main/java/rx/concurrency/TestScheduler.java
+++ b/rxjava-core/src/main/java/rx/concurrency/TestScheduler.java
@@ -30,11 +30,11 @@ public class TestScheduler extends Scheduler {
 
     private static class TimedAction<T> {
         private final long time;
-        private final Func2<Scheduler, T, Subscription> action;
+        private final Func2<? super Scheduler, ? super T, ? extends Subscription> action;
         private final T state;
         private final TestScheduler scheduler;
 
-        private TimedAction(TestScheduler scheduler, long time, Func2<Scheduler, T, Subscription> action, T state) {
+        private TimedAction(TestScheduler scheduler, long time, Func2<? super Scheduler, ? super T, ? extends Subscription> action, T state) {
             this.time = time;
             this.action = action;
             this.state = state;
@@ -91,12 +91,12 @@ private void triggerActions(long targetTimeInNanos) {
     }
 
     @Override
-    public <T> Subscription schedule(T state, Func2<Scheduler, T, Subscription> action) {
+    public <T> Subscription schedule(T state, Func2<? super Scheduler, ? super T, ? extends Subscription> action) {
         return schedule(state, action, 0, TimeUnit.MILLISECONDS);
     }
 
     @Override
-    public <T> Subscription schedule(T state, Func2<Scheduler, T, Subscription> action, long delayTime, TimeUnit unit) {
+    public <T> Subscription schedule(T state, Func2<? super Scheduler, ? super T, ? extends Subscription> action, long delayTime, TimeUnit unit) {
         queue.add(new TimedAction<T>(this, time + unit.toNanos(delayTime), action, state));
         return Subscriptions.empty();
     }
diff --git a/rxjava-core/src/main/java/rx/observables/BlockingObservable.java b/rxjava-core/src/main/java/rx/observables/BlockingObservable.java
index 41d141afa4..40bda27d52 100644
--- a/rxjava-core/src/main/java/rx/observables/BlockingObservable.java
+++ b/rxjava-core/src/main/java/rx/observables/BlockingObservable.java
@@ -60,7 +60,7 @@
  */
 public class BlockingObservable<T> extends Observable<T> {
 
-    protected BlockingObservable(Func1<Observer<T>, Subscription> onSubscribe) {
+    protected BlockingObservable(Func1<? super Observer<? super T>, ? extends Subscription> onSubscribe) {
         super(onSubscribe);
     }
     
@@ -75,11 +75,11 @@ private BlockingObservable() {
     /**
      * Convert an Observable into a BlockingObservable.
      */
-    public static <T> BlockingObservable<T> from(final Observable<T> o) {
-        return new BlockingObservable<T>(new Func1<Observer<T>, Subscription>() {
+    public static <T> BlockingObservable<T> from(final Observable<? extends T> o) {
+        return new BlockingObservable<T>(new Func1<Observer<? super T>, Subscription>() {
 
             @Override
-            public Subscription call(Observer<T> observer) {
+            public Subscription call(Observer<? super T> observer) {
                 return o.subscribe(observer);
             }
         });
@@ -97,7 +97,7 @@ public Subscription call(Observer<T> observer) {
      *            the type of items emitted by the source {@link Observable}
      * @return an {@link Iterator} that can iterate over the items emitted by the {@link Observable}
      */
-    public static <T> Iterator<T> toIterator(Observable<T> source) {
+    public static <T> Iterator<T> toIterator(Observable<? extends T> source) {
         return OperationToIterator.toIterator(source);
     }
 
@@ -110,7 +110,7 @@ public static <T> Iterator<T> toIterator(Observable<T> source) {
      *            the source {@link Observable}
      * @return the last item emitted by the source {@link Observable}
      */
-    public static <T> T last(final Observable<T> source) {
+    public static <T> T last(final Observable<? extends T> source) {
         return from(source).last();
     }
 
@@ -126,7 +126,7 @@ public static <T> T last(final Observable<T> source) {
      * @return the last item emitted by the {@link Observable} for which the predicate function
      *         returns <code>true</code>
      */
-    public static <T> T last(final Observable<T> source, final Func1<T, Boolean> predicate) {
+    public static <T> T last(final Observable<? extends T> source, final Func1<? super T, Boolean> predicate) {
         return last(source.filter(predicate));
     }
 
@@ -145,7 +145,7 @@ public static <T> T last(final Observable<T> source, final Func1<T, Boolean> pre
      * @return the last item emitted by an {@link Observable}, or the default value if no item is
      *         emitted
      */
-    public static <T> T lastOrDefault(Observable<T> source, T defaultValue) {
+    public static <T> T lastOrDefault(Observable<? extends T> source, T defaultValue) {
         return from(source).lastOrDefault(defaultValue);
     }
 
@@ -166,7 +166,7 @@ public static <T> T lastOrDefault(Observable<T> source, T defaultValue) {
      * @return the last item emitted by an {@link Observable} that matches the predicate, or the
      *         default value if no matching item is emitted
      */
-    public static <T> T lastOrDefault(Observable<T> source, T defaultValue, Func1<T, Boolean> predicate) {
+    public static <T> T lastOrDefault(Observable<? extends T> source, T defaultValue, Func1<? super T, Boolean> predicate) {
         return lastOrDefault(source.filter(predicate), defaultValue);
     }
 
@@ -186,7 +186,7 @@ public static <T> T lastOrDefault(Observable<T> source, T defaultValue, Func1<T,
      * @return an {@link Iterable} that on each iteration returns the item that the
      *         {@link Observable} has most recently emitted
      */
-    public static <T> Iterable<T> mostRecent(Observable<T> source, T initialValue) {
+    public static <T> Iterable<T> mostRecent(Observable<? extends T> source, T initialValue) {
         return OperationMostRecent.mostRecent(source, initialValue);
     }
 
@@ -203,12 +203,12 @@ public static <T> Iterable<T> mostRecent(Observable<T> source, T initialValue) {
      * @return an {@link Iterable} that blocks upon each iteration until the {@link Observable}
      *         emits a new item, whereupon the Iterable returns that item
      */
-    public static <T> Iterable<T> next(Observable<T> items) {
+    public static <T> Iterable<T> next(Observable<? extends T> items) {
         return OperationNext.next(items);
     }
 
-    private static <T> T _singleOrDefault(BlockingObservable<T> source, boolean hasDefault, T defaultValue) {
-        Iterator<T> it = source.toIterable().iterator();
+    private static <T> T _singleOrDefault(BlockingObservable<? extends T> source, boolean hasDefault, T defaultValue) {
+        Iterator<? extends T> it = source.toIterable().iterator();
 
         if (!it.hasNext()) {
             if (hasDefault) {
@@ -238,7 +238,7 @@ private static <T> T _singleOrDefault(BlockingObservable<T> source, boolean hasD
      * @throws IllegalStateException
      *             if the {@link Observable} does not emit exactly one item
      */
-    public static <T> T single(Observable<T> source) {
+    public static <T> T single(Observable<? extends T> source) {
         return from(source).single();
     }
 
@@ -257,7 +257,7 @@ public static <T> T single(Observable<T> source) {
      *             if the {@link Observable} does not emit exactly one item that matches the
      *             predicate
      */
-    public static <T> T single(Observable<T> source, Func1<T, Boolean> predicate) {
+    public static <T> T single(Observable<? extends T> source, Func1<? super T, Boolean> predicate) {
         return from(source).single(predicate);
     }
 
@@ -274,7 +274,7 @@ public static <T> T single(Observable<T> source, Func1<T, Boolean> predicate) {
      * @return the single item emitted by the source {@link Observable}, or a default value if no
      *         value is emitted
      */
-    public static <T> T singleOrDefault(Observable<T> source, T defaultValue) {
+    public static <T> T singleOrDefault(Observable<? extends T> source, T defaultValue) {
         return from(source).singleOrDefault(defaultValue);
     }
 
@@ -293,7 +293,7 @@ public static <T> T singleOrDefault(Observable<T> source, T defaultValue) {
      * @return the single item emitted by the source {@link Observable} that matches the predicate,
      *         or a default value if no such value is emitted
      */
-    public static <T> T singleOrDefault(Observable<T> source, T defaultValue, Func1<T, Boolean> predicate) {
+    public static <T> T singleOrDefault(Observable<? extends T> source, T defaultValue, Func1<? super T, Boolean> predicate) {
         return from(source).singleOrDefault(defaultValue, predicate);
     }
 
@@ -310,7 +310,7 @@ public static <T> T singleOrDefault(Observable<T> source, T defaultValue, Func1<
      *            the source {@link Observable}
      * @return a Future that expects a single item to be emitted by the source {@link Observable}
      */
-    public static <T> Future<T> toFuture(final Observable<T> source) {
+    public static <T> Future<T> toFuture(final Observable<? extends T> source) {
         return OperationToFuture.toFuture(source);
     }
 
@@ -323,7 +323,7 @@ public static <T> Future<T> toFuture(final Observable<T> source) {
      *            the source {@link Observable}
      * @return an {@link Iterable} version of the underlying {@link Observable}
      */
-    public static <T> Iterable<T> toIterable(final Observable<T> source) {
+    public static <T> Iterable<T> toIterable(final Observable<? extends T> source) {
         return from(source).toIterable();
     }
 
@@ -334,7 +334,7 @@ public static <T> Iterable<T> toIterable(final Observable<T> source) {
      * See https://github.com/Netflix/RxJava/issues/216 for discussion on "Guideline 6.4: Protect
      * calls to user code from within an operator"
      */
-    private Subscription protectivelyWrapAndSubscribe(Observer<T> o) {
+    private Subscription protectivelyWrapAndSubscribe(Observer<? super T> o) {
         SafeObservableSubscription subscription = new SafeObservableSubscription();
         return subscription.wrap(subscribe(new SafeObserver<T>(subscription, o)));
     }
@@ -355,7 +355,7 @@ private Subscription protectivelyWrapAndSubscribe(Observer<T> o) {
      * @throws RuntimeException
      *             if an error occurs
      */
-    public void forEach(final Action1<T> onNext) {
+    public void forEach(final Action1<? super T> onNext) {
         final CountDownLatch latch = new CountDownLatch(1);
         final AtomicReference<Throwable> exceptionFromOnError = new AtomicReference<Throwable>();
 
@@ -443,7 +443,7 @@ public T last() {
      *            a predicate function to evaluate items emitted by the {@link Observable}
      * @return the last item emitted by the {@link Observable} that matches the predicate
      */
-    public T last(final Func1<T, Boolean> predicate) {
+    public T last(final Func1<? super T, Boolean> predicate) {
         return last(this, predicate);
     }
 
@@ -487,7 +487,7 @@ public T lastOrDefault(T defaultValue) {
      * @return the last item emitted by the {@link Observable} that matches the predicate, or the
      *         default value if no matching items are emitted
      */
-    public T lastOrDefault(T defaultValue, Func1<T, Boolean> predicate) {
+    public T lastOrDefault(T defaultValue, Func1<? super T, Boolean> predicate) {
         return lastOrDefault(this, defaultValue, predicate);
     }
 
@@ -542,7 +542,7 @@ public T single() {
      *            a predicate function to evaluate items emitted by the {@link Observable}
      * @return the single item emitted by the source {@link Observable} that matches the predicate
      */
-    public T single(Func1<T, Boolean> predicate) {
+    public T single(Func1<? super T, Boolean> predicate) {
         return _singleOrDefault(from(this.filter(predicate)), false, null);
     }
 
@@ -575,7 +575,7 @@ public T singleOrDefault(T defaultValue) {
      * @return the single item emitted by the {@link Observable} that matches the predicate, or the
      *         default value if no such items are emitted
      */
-    public T singleOrDefault(T defaultValue, Func1<T, Boolean> predicate) {
+    public T singleOrDefault(T defaultValue, Func1<? super T, Boolean> predicate) {
         return _singleOrDefault(from(this.filter(predicate)), true, defaultValue);
     }
 
@@ -784,10 +784,10 @@ public void testToIterable() {
 
         @Test(expected = TestException.class)
         public void testToIterableWithException() {
-            BlockingObservable<String> obs = BlockingObservable.from(create(new Func1<Observer<String>, Subscription>() {
+            BlockingObservable<String> obs = BlockingObservable.from(create(new Func1<Observer<? super String>, Subscription>() {
 
                 @Override
-                public Subscription call(Observer<String> observer) {
+                public Subscription call(Observer<? super String> observer) {
                     observer.onNext("one");
                     observer.onError(new TestException());
                     return Subscriptions.empty();
@@ -807,10 +807,10 @@ public Subscription call(Observer<String> observer) {
         @Test
         public void testForEachWithError() {
             try {
-                BlockingObservable.from(Observable.create(new Func1<Observer<String>, Subscription>() {
+                BlockingObservable.from(Observable.create(new Func1<Observer<? super String>, Subscription>() {
 
                     @Override
-                    public Subscription call(final Observer<String> observer) {
+                    public Subscription call(final Observer<? super String> observer) {
                         final BooleanSubscription subscription = new BooleanSubscription();
                         new Thread(new Runnable() {
 
diff --git a/rxjava-core/src/main/java/rx/observables/ConnectableObservable.java b/rxjava-core/src/main/java/rx/observables/ConnectableObservable.java
index de0fdba643..b229681522 100644
--- a/rxjava-core/src/main/java/rx/observables/ConnectableObservable.java
+++ b/rxjava-core/src/main/java/rx/observables/ConnectableObservable.java
@@ -37,7 +37,7 @@
 
 public abstract class ConnectableObservable<T> extends Observable<T> {
 
-    protected ConnectableObservable(Func1<Observer<T>, Subscription> onSubscribe) {
+    protected ConnectableObservable(Func1<? super Observer<? super T>, ? extends Subscription> onSubscribe) {
         super(onSubscribe);
     }
 
diff --git a/rxjava-core/src/main/java/rx/observables/GroupedObservable.java b/rxjava-core/src/main/java/rx/observables/GroupedObservable.java
index 28019382f7..f7e2183635 100644
--- a/rxjava-core/src/main/java/rx/observables/GroupedObservable.java
+++ b/rxjava-core/src/main/java/rx/observables/GroupedObservable.java
@@ -32,7 +32,7 @@
 public class GroupedObservable<K, T> extends Observable<T> {
     private final K key;
 
-    public GroupedObservable(K key, Func1<Observer<T>, Subscription> onSubscribe) {
+    public GroupedObservable(K key, Func1<? super Observer<? super T>, ? extends Subscription> onSubscribe) {
         super(onSubscribe);
         this.key = key;
     }
diff --git a/rxjava-core/src/main/java/rx/operators/OperationAll.java b/rxjava-core/src/main/java/rx/operators/OperationAll.java
index d504651eaa..862999b743 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationAll.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationAll.java
@@ -34,35 +34,35 @@
  */
 public class OperationAll {
 
-    public static <T> Func1<Observer<Boolean>, Subscription> all(Observable<T> sequence, Func1<T, Boolean> predicate) {
+    public static <T> Func1<Observer<? super Boolean>, Subscription> all(Observable<? extends T> sequence, Func1<? super T, Boolean> predicate) {
         return new AllObservable<T>(sequence, predicate);
     }
 
-    private static class AllObservable<T> implements Func1<Observer<Boolean>, Subscription> {
-        private final Observable<T> sequence;
-        private final Func1<T, Boolean> predicate;
+    private static class AllObservable<T> implements Func1<Observer<? super Boolean>, Subscription> {
+        private final Observable<? extends T> sequence;
+        private final Func1<? super T, Boolean> predicate;
 
         private final SafeObservableSubscription subscription = new SafeObservableSubscription();
 
 
-        private AllObservable(Observable<T> sequence, Func1<T, Boolean> predicate) {
+        private AllObservable(Observable<? extends T> sequence, Func1<? super T, Boolean> predicate) {
             this.sequence = sequence;
             this.predicate = predicate;
         }
 
 
         @Override
-        public Subscription call(final Observer<Boolean> observer) {
+        public Subscription call(final Observer<? super Boolean> observer) {
             return subscription.wrap(sequence.subscribe(new AllObserver(observer)));
 
         }
 
         private class AllObserver implements Observer<T> {
-            private final Observer<Boolean> underlying;
+            private final Observer<? super Boolean> underlying;
 
             private final AtomicBoolean status = new AtomicBoolean(true);
 
-            public AllObserver(Observer<Boolean> underlying) {
+            public AllObserver(Observer<? super Boolean> underlying) {
                 this.underlying = underlying;
             }
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperationBuffer.java b/rxjava-core/src/main/java/rx/operators/OperationBuffer.java
index f5e6a692a5..43ba46f137 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationBuffer.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationBuffer.java
@@ -69,10 +69,10 @@ public final class OperationBuffer {
      * @return
      *            the {@link Func1} object representing the specified buffer operation.
      */
-    public static <T> Func1<Observer<List<T>>, Subscription> buffer(final Observable<T> source, final Func0<Observable<BufferClosing>> bufferClosingSelector) {
-        return new Func1<Observer<List<T>>, Subscription>() {
+    public static <T> Func1<Observer<? super List<T>>, Subscription> buffer(final Observable<? extends T> source, final Func0<? extends Observable<? extends BufferClosing>> bufferClosingSelector) {
+        return new Func1<Observer<? super List<T>>, Subscription>() {
             @Override
-            public Subscription call(final Observer<List<T>> observer) {
+            public Subscription call(final Observer<? super List<T>> observer) {
                 NonOverlappingBuffers<T> buffers = new NonOverlappingBuffers<T>(observer);
                 BufferCreator<T> creator = new ObservableBasedSingleBufferCreator<T>(buffers, bufferClosingSelector);
                 return source.subscribe(new BufferObserver<T>(buffers, observer, creator));
@@ -107,10 +107,10 @@ public Subscription call(final Observer<List<T>> observer) {
      * @return
      *            the {@link Func1} object representing the specified buffer operation.
      */
-    public static <T> Func1<Observer<List<T>>, Subscription> buffer(final Observable<T> source, final Observable<BufferOpening> bufferOpenings, final Func1<BufferOpening, Observable<BufferClosing>> bufferClosingSelector) {
-        return new Func1<Observer<List<T>>, Subscription>() {
+    public static <T> Func1<Observer<? super List<T>>, Subscription> buffer(final Observable<? extends T> source, final Observable<? extends BufferOpening> bufferOpenings, final Func1<? super BufferOpening, ? extends Observable<? extends BufferClosing>> bufferClosingSelector) {
+        return new Func1<Observer<? super List<T>>, Subscription>() {
             @Override
-            public Subscription call(final Observer<List<T>> observer) {
+            public Subscription call(final Observer<? super List<T>> observer) {
                 OverlappingBuffers<T> buffers = new OverlappingBuffers<T>(observer);
                 BufferCreator<T> creator = new ObservableBasedMultiBufferCreator<T>(buffers, bufferOpenings, bufferClosingSelector);
                 return source.subscribe(new BufferObserver<T>(buffers, observer, creator));
@@ -135,7 +135,7 @@ public Subscription call(final Observer<List<T>> observer) {
      * @return
      *            the {@link Func1} object representing the specified buffer operation.
      */
-    public static <T> Func1<Observer<List<T>>, Subscription> buffer(Observable<T> source, int count) {
+    public static <T> Func1<Observer<? super List<T>>, Subscription> buffer(Observable<? extends T> source, int count) {
         return buffer(source, count, count);
     }
 
@@ -162,10 +162,10 @@ public static <T> Func1<Observer<List<T>>, Subscription> buffer(Observable<T> so
      * @return
      *            the {@link Func1} object representing the specified buffer operation.
      */
-    public static <T> Func1<Observer<List<T>>, Subscription> buffer(final Observable<T> source, final int count, final int skip) {
-        return new Func1<Observer<List<T>>, Subscription>() {
+    public static <T> Func1<Observer<? super List<T>>, Subscription> buffer(final Observable<? extends T> source, final int count, final int skip) {
+        return new Func1<Observer<? super List<T>>, Subscription>() {
             @Override
-            public Subscription call(final Observer<List<T>> observer) {
+            public Subscription call(final Observer<? super List<T>> observer) {
                 Buffers<T> buffers = new SizeBasedBuffers<T>(observer, count);
                 BufferCreator<T> creator = new SkippingBufferCreator<T>(buffers, skip);
                 return source.subscribe(new BufferObserver<T>(buffers, observer, creator));
@@ -192,7 +192,7 @@ public Subscription call(final Observer<List<T>> observer) {
      * @return
      *            the {@link Func1} object representing the specified buffer operation.
      */
-    public static <T> Func1<Observer<List<T>>, Subscription> buffer(Observable<T> source, long timespan, TimeUnit unit) {
+    public static <T> Func1<Observer<? super List<T>>, Subscription> buffer(Observable<? extends T> source, long timespan, TimeUnit unit) {
         return buffer(source, timespan, unit, Schedulers.threadPoolForComputation());
     }
 
@@ -217,10 +217,10 @@ public static <T> Func1<Observer<List<T>>, Subscription> buffer(Observable<T> so
      * @return
      *            the {@link Func1} object representing the specified buffer operation.
      */
-    public static <T> Func1<Observer<List<T>>, Subscription> buffer(final Observable<T> source, final long timespan, final TimeUnit unit, final Scheduler scheduler) {
-        return new Func1<Observer<List<T>>, Subscription>() {
+    public static <T> Func1<Observer<? super List<T>>, Subscription> buffer(final Observable<? extends T> source, final long timespan, final TimeUnit unit, final Scheduler scheduler) {
+        return new Func1<Observer<? super List<T>>, Subscription>() {
             @Override
-            public Subscription call(final Observer<List<T>> observer) {
+            public Subscription call(final Observer<? super List<T>> observer) {
                 NonOverlappingBuffers<T> buffers = new NonOverlappingBuffers<T>(observer);
                 BufferCreator<T> creator = new TimeBasedBufferCreator<T>(buffers, timespan, unit, scheduler);
                 return source.subscribe(new BufferObserver<T>(buffers, observer, creator));
@@ -250,7 +250,7 @@ public Subscription call(final Observer<List<T>> observer) {
      * @return
      *            the {@link Func1} object representing the specified buffer operation.
      */
-    public static <T> Func1<Observer<List<T>>, Subscription> buffer(Observable<T> source, long timespan, TimeUnit unit, int count) {
+    public static <T> Func1<Observer<? super List<T>>, Subscription> buffer(Observable<? extends T> source, long timespan, TimeUnit unit, int count) {
         return buffer(source, timespan, unit, count, Schedulers.threadPoolForComputation());
     }
 
@@ -278,10 +278,10 @@ public static <T> Func1<Observer<List<T>>, Subscription> buffer(Observable<T> so
      * @return
      *            the {@link Func1} object representing the specified buffer operation.
      */
-    public static <T> Func1<Observer<List<T>>, Subscription> buffer(final Observable<T> source, final long timespan, final TimeUnit unit, final int count, final Scheduler scheduler) {
-        return new Func1<Observer<List<T>>, Subscription>() {
+    public static <T> Func1<Observer<? super List<T>>, Subscription> buffer(final Observable<? extends T> source, final long timespan, final TimeUnit unit, final int count, final Scheduler scheduler) {
+        return new Func1<Observer<? super List<T>>, Subscription>() {
             @Override
-            public Subscription call(final Observer<List<T>> observer) {
+            public Subscription call(final Observer<? super List<T>> observer) {
                 Buffers<T> buffers = new TimeAndSizeBasedBuffers<T>(observer, count, timespan, unit, scheduler);
                 BufferCreator<T> creator = new SingleBufferCreator<T>(buffers);
                 return source.subscribe(new BufferObserver<T>(buffers, observer, creator));
@@ -311,7 +311,7 @@ public Subscription call(final Observer<List<T>> observer) {
      * @return
      *            the {@link Func1} object representing the specified buffer operation.
      */
-    public static <T> Func1<Observer<List<T>>, Subscription> buffer(Observable<T> source, long timespan, long timeshift, TimeUnit unit) {
+    public static <T> Func1<Observer<? super List<T>>, Subscription> buffer(Observable<? extends T> source, long timespan, long timeshift, TimeUnit unit) {
         return buffer(source, timespan, timeshift, unit, Schedulers.threadPoolForComputation());
     }
 
@@ -339,10 +339,10 @@ public static <T> Func1<Observer<List<T>>, Subscription> buffer(Observable<T> so
      * @return
      *            the {@link Func1} object representing the specified buffer operation.
      */
-    public static <T> Func1<Observer<List<T>>, Subscription> buffer(final Observable<T> source, final long timespan, final long timeshift, final TimeUnit unit, final Scheduler scheduler) {
-        return new Func1<Observer<List<T>>, Subscription>() {
+    public static <T> Func1<Observer<? super List<T>>, Subscription> buffer(final Observable<? extends T> source, final long timespan, final long timeshift, final TimeUnit unit, final Scheduler scheduler) {
+        return new Func1<Observer<? super List<T>>, Subscription>() {
             @Override
-            public Subscription call(final Observer<List<T>> observer) {
+            public Subscription call(final Observer<? super List<T>> observer) {
                 OverlappingBuffers<T> buffers = new TimeBasedBuffers<T>(observer, timespan, unit, scheduler);
                 BufferCreator<T> creator = new TimeBasedBufferCreator<T>(buffers, timeshift, unit, scheduler);
                 return source.subscribe(new BufferObserver<T>(buffers, observer, creator));
@@ -362,10 +362,10 @@ public Subscription call(final Observer<List<T>> observer) {
     private static class BufferObserver<T> implements Observer<T> {
 
         private final Buffers<T> buffers;
-        private final Observer<List<T>> observer;
+        private final Observer<? super List<T>> observer;
         private final BufferCreator<T> creator;
 
-        public BufferObserver(Buffers<T> buffers, Observer<List<T>> observer, BufferCreator<T> creator) {
+        public BufferObserver(Buffers<T> buffers, Observer<? super List<T>> observer, BufferCreator<T> creator) {
             this.observer = observer;
             this.creator = creator;
             this.buffers = buffers;
@@ -444,10 +444,10 @@ public void stop() {
     private static class ObservableBasedSingleBufferCreator<T> implements BufferCreator<T> {
 
         private final SafeObservableSubscription subscription = new SafeObservableSubscription();
-        private final Func0<Observable<BufferClosing>> bufferClosingSelector;
+        private final Func0<? extends Observable<? extends BufferClosing>> bufferClosingSelector;
         private final NonOverlappingBuffers<T> buffers;
 
-        public ObservableBasedSingleBufferCreator(NonOverlappingBuffers<T> buffers, Func0<Observable<BufferClosing>> bufferClosingSelector) {
+        public ObservableBasedSingleBufferCreator(NonOverlappingBuffers<T> buffers, Func0<? extends Observable<? extends BufferClosing>> bufferClosingSelector) {
             this.buffers = buffers;
             this.bufferClosingSelector = bufferClosingSelector;
 
@@ -456,7 +456,7 @@ public ObservableBasedSingleBufferCreator(NonOverlappingBuffers<T> buffers, Func
         }
 
         private void listenForBufferEnd() {
-            Observable<BufferClosing> closingObservable = bufferClosingSelector.call();
+            Observable<? extends BufferClosing> closingObservable = bufferClosingSelector.call();
             closingObservable.subscribe(new Action1<BufferClosing>() {
                 @Override
                 public void call(BufferClosing closing) {
@@ -489,12 +489,12 @@ private static class ObservableBasedMultiBufferCreator<T> implements BufferCreat
 
         private final SafeObservableSubscription subscription = new SafeObservableSubscription();
 
-        public ObservableBasedMultiBufferCreator(final OverlappingBuffers<T> buffers, Observable<BufferOpening> bufferOpenings, final Func1<BufferOpening, Observable<BufferClosing>> bufferClosingSelector) {
+        public ObservableBasedMultiBufferCreator(final OverlappingBuffers<T> buffers, Observable<? extends BufferOpening> bufferOpenings, final Func1<? super BufferOpening, ? extends Observable<? extends BufferClosing>> bufferClosingSelector) {
             subscription.wrap(bufferOpenings.subscribe(new Action1<BufferOpening>() {
                 @Override
                 public void call(BufferOpening opening) {
                     final Buffer<T> buffer = buffers.createBuffer();
-                    Observable<BufferClosing> closingObservable = bufferClosingSelector.call(opening);
+                    Observable<? extends BufferClosing> closingObservable = bufferClosingSelector.call(opening);
 
                     closingObservable.subscribe(new Action1<BufferClosing>() {
                         @Override
@@ -597,7 +597,7 @@ private static class NonOverlappingBuffers<T> extends Buffers<T> {
 
         private final Object lock = new Object();
 
-        public NonOverlappingBuffers(Observer<List<T>> observer) {
+        public NonOverlappingBuffers(Observer<? super List<T>> observer) {
             super(observer);
         }
 
@@ -624,7 +624,7 @@ public void pushValue(T value) {
      * @param <T> The type of object all internal {@link Buffer} objects record.
      */
     private static class OverlappingBuffers<T> extends Buffers<T> {
-        public OverlappingBuffers(Observer<List<T>> observer) {
+        public OverlappingBuffers(Observer<? super List<T>> observer) {
             super(observer);
         }
     }
@@ -646,7 +646,7 @@ private static class TimeAndSizeBasedBuffers<T> extends Buffers<T> {
         private final TimeUnit unit;
         private final int maxSize;
 
-        public TimeAndSizeBasedBuffers(Observer<List<T>> observer, int maxSize, long maxTime, TimeUnit unit, Scheduler scheduler) {
+        public TimeAndSizeBasedBuffers(Observer<? super List<T>> observer, int maxSize, long maxTime, TimeUnit unit, Scheduler scheduler) {
             super(observer);
             this.maxSize = maxSize;
             this.maxTime = maxTime;
@@ -710,7 +710,7 @@ private static class TimeBasedBuffers<T> extends OverlappingBuffers<T> {
         private final long time;
         private final TimeUnit unit;
 
-        public TimeBasedBuffers(Observer<List<T>> observer, long time, TimeUnit unit, Scheduler scheduler) {
+        public TimeBasedBuffers(Observer<? super List<T>> observer, long time, TimeUnit unit, Scheduler scheduler) {
             super(observer);
             this.time = time;
             this.unit = unit;
@@ -747,7 +747,7 @@ private static class SizeBasedBuffers<T> extends Buffers<T> {
 
         private final int size;
 
-        public SizeBasedBuffers(Observer<List<T>> observer, int size) {
+        public SizeBasedBuffers(Observer<? super List<T>> observer, int size) {
             super(observer);
             this.size = size;
         }
@@ -776,7 +776,7 @@ public void pushValue(T value) {
     private static class Buffers<T> {
 
         private final Queue<Buffer<T>> buffers = new ConcurrentLinkedQueue<Buffer<T>>();
-        private final Observer<List<T>> observer;
+        private final Observer<? super List<T>> observer;
 
         /**
          * Constructs a new {@link Buffers} object for the specified {@link Observer}.
@@ -785,7 +785,7 @@ private static class Buffers<T> {
          *            The {@link Observer} to which this object will emit its internal
          *            {@link Buffer} objects to when requested.
          */
-        public Buffers(Observer<List<T>> observer) {
+        public Buffers(Observer<? super List<T>> observer) {
             this.observer = observer;
         }
 
@@ -889,9 +889,9 @@ public void before() {
 
         @Test
         public void testComplete() {
-            Observable<String> source = Observable.create(new Func1<Observer<String>, Subscription>() {
+            Observable<String> source = Observable.create(new Func1<Observer<? super String>, Subscription>() {
                 @Override
-                public Subscription call(Observer<String> observer) {
+                public Subscription call(Observer<? super String> observer) {
                     observer.onCompleted();
                     return Subscriptions.empty();
                 }
@@ -907,9 +907,9 @@ public Subscription call(Observer<String> observer) {
 
         @Test
         public void testSkipAndCountOverlappingBuffers() {
-            Observable<String> source = Observable.create(new Func1<Observer<String>, Subscription>() {
+            Observable<String> source = Observable.create(new Func1<Observer<? super String>, Subscription>() {
                 @Override
-                public Subscription call(Observer<String> observer) {
+                public Subscription call(Observer<? super String> observer) {
                     observer.onNext("one");
                     observer.onNext("two");
                     observer.onNext("three");
@@ -933,9 +933,9 @@ public Subscription call(Observer<String> observer) {
 
         @Test
         public void testSkipAndCountGaplessBuffers() {
-            Observable<String> source = Observable.create(new Func1<Observer<String>, Subscription>() {
+            Observable<String> source = Observable.create(new Func1<Observer<? super String>, Subscription>() {
                 @Override
-                public Subscription call(Observer<String> observer) {
+                public Subscription call(Observer<? super String> observer) {
                     observer.onNext("one");
                     observer.onNext("two");
                     observer.onNext("three");
@@ -959,9 +959,9 @@ public Subscription call(Observer<String> observer) {
 
         @Test
         public void testSkipAndCountBuffersWithGaps() {
-            Observable<String> source = Observable.create(new Func1<Observer<String>, Subscription>() {
+            Observable<String> source = Observable.create(new Func1<Observer<? super String>, Subscription>() {
                 @Override
-                public Subscription call(Observer<String> observer) {
+                public Subscription call(Observer<? super String> observer) {
                     observer.onNext("one");
                     observer.onNext("two");
                     observer.onNext("three");
@@ -985,9 +985,9 @@ public Subscription call(Observer<String> observer) {
 
         @Test
         public void testTimedAndCount() {
-            Observable<String> source = Observable.create(new Func1<Observer<String>, Subscription>() {
+            Observable<String> source = Observable.create(new Func1<Observer<? super String>, Subscription>() {
                 @Override
-                public Subscription call(Observer<String> observer) {
+                public Subscription call(Observer<? super String> observer) {
                     push(observer, "one", 10);
                     push(observer, "two", 90);
                     push(observer, "three", 110);
@@ -1017,9 +1017,9 @@ public Subscription call(Observer<String> observer) {
 
         @Test
         public void testTimed() {
-            Observable<String> source = Observable.create(new Func1<Observer<String>, Subscription>() {
+            Observable<String> source = Observable.create(new Func1<Observer<? super String>, Subscription>() {
                 @Override
-                public Subscription call(Observer<String> observer) {
+                public Subscription call(Observer<? super String> observer) {
                     push(observer, "one", 98);
                     push(observer, "two", 99);
                     push(observer, "three", 100);
@@ -1046,9 +1046,9 @@ public Subscription call(Observer<String> observer) {
 
         @Test
         public void testObservableBasedOpenerAndCloser() {
-            Observable<String> source = Observable.create(new Func1<Observer<String>, Subscription>() {
+            Observable<String> source = Observable.create(new Func1<Observer<? super String>, Subscription>() {
                 @Override
-                public Subscription call(Observer<String> observer) {
+                public Subscription call(Observer<? super String> observer) {
                     push(observer, "one", 10);
                     push(observer, "two", 60);
                     push(observer, "three", 110);
@@ -1059,9 +1059,9 @@ public Subscription call(Observer<String> observer) {
                 }
             });
 
-            Observable<BufferOpening> openings = Observable.create(new Func1<Observer<BufferOpening>, Subscription>() {
+            Observable<BufferOpening> openings = Observable.create(new Func1<Observer<? super BufferOpening>, Subscription>() {
                 @Override
-                public Subscription call(Observer<BufferOpening> observer) {
+                public Subscription call(Observer<? super BufferOpening> observer) {
                     push(observer, BufferOpenings.create(), 50);
                     push(observer, BufferOpenings.create(), 200);
                     complete(observer, 250);
@@ -1072,9 +1072,9 @@ public Subscription call(Observer<BufferOpening> observer) {
             Func1<BufferOpening, Observable<BufferClosing>> closer = new Func1<BufferOpening, Observable<BufferClosing>>() {
                 @Override
                 public Observable<BufferClosing> call(BufferOpening opening) {
-                    return Observable.create(new Func1<Observer<BufferClosing>, Subscription>() {
+                    return Observable.create(new Func1<Observer<? super BufferClosing>, Subscription>() {
                         @Override
-                        public Subscription call(Observer<BufferClosing> observer) {
+                        public Subscription call(Observer<? super BufferClosing> observer) {
                             push(observer, BufferClosings.create(), 100);
                             complete(observer, 101);
                             return Subscriptions.empty();
@@ -1097,9 +1097,9 @@ public Subscription call(Observer<BufferClosing> observer) {
 
         @Test
         public void testObservableBasedCloser() {
-            Observable<String> source = Observable.create(new Func1<Observer<String>, Subscription>() {
+            Observable<String> source = Observable.create(new Func1<Observer<? super String>, Subscription>() {
                 @Override
-                public Subscription call(Observer<String> observer) {
+                public Subscription call(Observer<? super String> observer) {
                     push(observer, "one", 10);
                     push(observer, "two", 60);
                     push(observer, "three", 110);
@@ -1113,9 +1113,9 @@ public Subscription call(Observer<String> observer) {
             Func0<Observable<BufferClosing>> closer = new Func0<Observable<BufferClosing>>() {
                 @Override
                 public Observable<BufferClosing> call() {
-                    return Observable.create(new Func1<Observer<BufferClosing>, Subscription>() {
+                    return Observable.create(new Func1<Observer<? super BufferClosing>, Subscription>() {
                         @Override
-                        public Subscription call(Observer<BufferClosing> observer) {
+                        public Subscription call(Observer<? super BufferClosing> observer) {
                             push(observer, BufferClosings.create(), 100);
                             complete(observer, 101);
                             return Subscriptions.empty();
diff --git a/rxjava-core/src/main/java/rx/operators/OperationCache.java b/rxjava-core/src/main/java/rx/operators/OperationCache.java
index 92707ba4d8..c6aa62af38 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationCache.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationCache.java
@@ -47,14 +47,14 @@
  */
 public class OperationCache {
 
-    public static <T> Func1<Observer<T>, Subscription> cache(final Observable<T> source) {
-        return new Func1<Observer<T>, Subscription>() {
+    public static <T> Func1<Observer<? super T>, Subscription> cache(final Observable<? extends T> source) {
+        return new Func1<Observer<? super T>, Subscription>() {
 
             final AtomicBoolean subscribed = new AtomicBoolean(false);
             private final ReplaySubject<T> cache = ReplaySubject.create();
 
             @Override
-            public Subscription call(Observer<T> observer) {
+            public Subscription call(Observer<? super T> observer) {
                 if (subscribed.compareAndSet(false, true)) {
                     // subscribe to the source once
                     source.subscribe(cache);
@@ -76,10 +76,10 @@ public static class UnitTest {
         @Test
         public void testCache() throws InterruptedException {
             final AtomicInteger counter = new AtomicInteger();
-            Observable<String> o = Observable.create(cache(Observable.create(new Func1<Observer<String>, Subscription>() {
+            Observable<String> o = Observable.create(cache(Observable.create(new Func1<Observer<? super String>, Subscription>() {
 
                 @Override
-                public Subscription call(final Observer<String> observer) {
+                public Subscription call(final Observer<? super String> observer) {
                     final BooleanSubscription subscription = new BooleanSubscription();
                     new Thread(new Runnable() {
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperationCombineLatest.java b/rxjava-core/src/main/java/rx/operators/OperationCombineLatest.java
index f11af77898..d53f764566 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationCombineLatest.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationCombineLatest.java
@@ -38,6 +38,11 @@
 import rx.util.functions.Func2;
 import rx.util.functions.Func3;
 import rx.util.functions.Func4;
+import rx.util.functions.Func5;
+import rx.util.functions.Func6;
+import rx.util.functions.Func7;
+import rx.util.functions.Func8;
+import rx.util.functions.Func9;
 import rx.util.functions.FuncN;
 import rx.util.functions.Functions;
 
@@ -62,7 +67,7 @@ public class OperationCombineLatest {
      *          The aggregation function used to combine the source observable values.
      * @return A function from an observer to a subscription. This can be used to create an observable from.
      */
-    public static <T0, T1, R> Func1<Observer<R>, Subscription> combineLatest(Observable<T0> w0, Observable<T1> w1, Func2<T0, T1, ? extends R> combineLatestFunction) {
+    public static <T0, T1, R> Func1<Observer<? super R>, Subscription> combineLatest(Observable<? extends T0> w0, Observable<T1> w1, Func2<? super T0, ? super T1, ? extends R> combineLatestFunction) {
         Aggregator<R> a = new Aggregator<R>(Functions.fromFunc(combineLatestFunction));
         a.addObserver(new CombineObserver<R, T0>(a, w0));
         a.addObserver(new CombineObserver<R, T1>(a, w1));
@@ -72,7 +77,8 @@ public static <T0, T1, R> Func1<Observer<R>, Subscription> combineLatest(Observa
     /**
      * @see #combineLatest(Observable w0, Observable w1, Func2 combineLatestFunction)
      */
-    public static <T0, T1, T2, R> Func1<Observer<R>, Subscription> combineLatest(Observable<T0> w0, Observable<T1> w1, Observable<T2> w2, Func3<T0, T1, T2, ? extends R> combineLatestFunction) {
+    public static <T0, T1, T2, R> Func1<Observer<? super R>, Subscription> combineLatest(Observable<? extends T0> w0, Observable<? extends T1> w1, Observable<? extends T2> w2, 
+            Func3<? super T0, ? super T1, ? super T2, ? extends R> combineLatestFunction) {
         Aggregator<R> a = new Aggregator<R>(Functions.fromFunc(combineLatestFunction));
         a.addObserver(new CombineObserver<R, T0>(a, w0));
         a.addObserver(new CombineObserver<R, T1>(a, w1));
@@ -83,7 +89,8 @@ public static <T0, T1, T2, R> Func1<Observer<R>, Subscription> combineLatest(Obs
     /**
      * @see #combineLatest(Observable w0, Observable w1, Func2 combineLatestFunction)
      */
-    public static <T0, T1, T2, T3, R> Func1<Observer<R>, Subscription> combineLatest(Observable<T0> w0, Observable<T1> w1, Observable<T2> w2, Observable<T3> w3, Func4<T0, T1, T2, T3, ? extends R> combineLatestFunction) {
+    public static <T0, T1, T2, T3, R> Func1<Observer<? super R>, Subscription> combineLatest(Observable<? extends T0> w0, Observable<? extends T1> w1, Observable<? extends T2> w2, Observable<? extends T3> w3, 
+            Func4<? super T0, ? super T1, ? super T2, ? super T3, ? extends R> combineLatestFunction) {
         Aggregator<R> a = new Aggregator<R>(Functions.fromFunc(combineLatestFunction));
         a.addObserver(new CombineObserver<R, T0>(a, w0));
         a.addObserver(new CombineObserver<R, T1>(a, w1));
@@ -92,12 +99,92 @@ public static <T0, T1, T2, T3, R> Func1<Observer<R>, Subscription> combineLatest
         return a;
     }
 
+    /**
+     * @see #combineLatest(Observable w0, Observable w1, Func2 combineLatestFunction)
+     */
+    public static <T0, T1, T2, T3, T4, R> Func1<Observer<? super R>, Subscription> combineLatest(Observable<? extends T0> w0, Observable<? extends T1> w1, Observable<? extends T2> w2, Observable<? extends T3> w3, Observable<? extends T4> w4, 
+            Func5<? super T0, ? super T1, ? super T2, ? super T3, ? super T4, ? extends R> combineLatestFunction) {
+        Aggregator<R> a = new Aggregator<R>(Functions.fromFunc(combineLatestFunction));
+        a.addObserver(new CombineObserver<R, T0>(a, w0));
+        a.addObserver(new CombineObserver<R, T1>(a, w1));
+        a.addObserver(new CombineObserver<R, T2>(a, w2));
+        a.addObserver(new CombineObserver<R, T3>(a, w3));
+        a.addObserver(new CombineObserver<R, T4>(a, w4));
+        return a;
+    }
+
+    /**
+     * @see #combineLatest(Observable w0, Observable w1, Func2 combineLatestFunction)
+     */
+    public static <T0, T1, T2, T3, T4, T5, R> Func1<Observer<? super R>, Subscription> combineLatest(Observable<? extends T0> w0, Observable<? extends T1> w1, Observable<? extends T2> w2, Observable<? extends T3> w3, Observable<? extends T4> w4, Observable<? extends T5> w5, 
+            Func6<? super T0, ? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? extends R> combineLatestFunction) {
+        Aggregator<R> a = new Aggregator<R>(Functions.fromFunc(combineLatestFunction));
+        a.addObserver(new CombineObserver<R, T0>(a, w0));
+        a.addObserver(new CombineObserver<R, T1>(a, w1));
+        a.addObserver(new CombineObserver<R, T2>(a, w2));
+        a.addObserver(new CombineObserver<R, T3>(a, w3));
+        a.addObserver(new CombineObserver<R, T4>(a, w4));
+        a.addObserver(new CombineObserver<R, T5>(a, w5));
+        return a;
+    }
+
+    /**
+     * @see #combineLatest(Observable w0, Observable w1, Func2 combineLatestFunction)
+     */
+    public static <T0, T1, T2, T3, T4, T5, T6, R> Func1<Observer<? super R>, Subscription> combineLatest(Observable<? extends T0> w0, Observable<? extends T1> w1, Observable<? extends T2> w2, Observable<? extends T3> w3, Observable<? extends T4> w4, Observable<? extends T5> w5, Observable<? extends T6> w6, 
+            Func7<? super T0, ? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? extends R> combineLatestFunction) {
+        Aggregator<R> a = new Aggregator<R>(Functions.fromFunc(combineLatestFunction));
+        a.addObserver(new CombineObserver<R, T0>(a, w0));
+        a.addObserver(new CombineObserver<R, T1>(a, w1));
+        a.addObserver(new CombineObserver<R, T2>(a, w2));
+        a.addObserver(new CombineObserver<R, T3>(a, w3));
+        a.addObserver(new CombineObserver<R, T4>(a, w4));
+        a.addObserver(new CombineObserver<R, T5>(a, w5));
+        a.addObserver(new CombineObserver<R, T6>(a, w6));
+        return a;
+    }
+
+    /**
+     * @see #combineLatest(Observable w0, Observable w1, Func2 combineLatestFunction)
+     */
+    public static <T0, T1, T2, T3, T4, T5, T6, T7, R> Func1<Observer<? super R>, Subscription> combineLatest(Observable<? extends T0> w0, Observable<? extends T1> w1, Observable<? extends T2> w2, Observable<? extends T3> w3, Observable<? extends T4> w4, Observable<? extends T5> w5, Observable<? extends T6> w6, Observable<? extends T7> w7, 
+            Func8<? super T0, ? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? extends R> combineLatestFunction) {
+        Aggregator<R> a = new Aggregator<R>(Functions.fromFunc(combineLatestFunction));
+        a.addObserver(new CombineObserver<R, T0>(a, w0));
+        a.addObserver(new CombineObserver<R, T1>(a, w1));
+        a.addObserver(new CombineObserver<R, T2>(a, w2));
+        a.addObserver(new CombineObserver<R, T3>(a, w3));
+        a.addObserver(new CombineObserver<R, T4>(a, w4));
+        a.addObserver(new CombineObserver<R, T5>(a, w5));
+        a.addObserver(new CombineObserver<R, T6>(a, w6));
+        a.addObserver(new CombineObserver<R, T7>(a, w7));
+        return a;
+    }
+
+    /**
+     * @see #combineLatest(Observable w0, Observable w1, Func2 combineLatestFunction)
+     */
+    public static <T0, T1, T2, T3, T4, T5, T6, T7, T8, R> Func1<Observer<? super R>, Subscription> combineLatest(Observable<? extends T0> w0, Observable<? extends T1> w1, Observable<? extends T2> w2, Observable<? extends T3> w3, Observable<? extends T4> w4, Observable<? extends T5> w5, Observable<? extends T6> w6, Observable<? extends T7> w7, Observable<? extends T8> w8, 
+            Func9<? super T0, ? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? extends R> combineLatestFunction) {
+        Aggregator<R> a = new Aggregator<R>(Functions.fromFunc(combineLatestFunction));
+        a.addObserver(new CombineObserver<R, T0>(a, w0));
+        a.addObserver(new CombineObserver<R, T1>(a, w1));
+        a.addObserver(new CombineObserver<R, T2>(a, w2));
+        a.addObserver(new CombineObserver<R, T3>(a, w3));
+        a.addObserver(new CombineObserver<R, T4>(a, w4));
+        a.addObserver(new CombineObserver<R, T5>(a, w5));
+        a.addObserver(new CombineObserver<R, T6>(a, w6));
+        a.addObserver(new CombineObserver<R, T7>(a, w7));
+        a.addObserver(new CombineObserver<R, T8>(a, w8));
+        return a;
+    }
+
     private static class CombineObserver<R, T> implements Observer<T> {
-        final Observable<T> w;
+        final Observable<? extends T> w;
         final Aggregator<R> a;
         private Subscription subscription;
 
-        public CombineObserver(Aggregator<R> a, Observable<T> w) {
+        public CombineObserver(Aggregator<R> a, Observable<? extends T> w) {
             this.a = a;
             this.w = w;
         }
@@ -130,7 +217,7 @@ public void onNext(T args) {
      * whenever we have received an event from one of the observables, as soon as each Observable has received 
      * at least one event.
      */
-    private static class Aggregator<R> implements Func1<Observer<R>, Subscription> {
+    private static class Aggregator<R> implements Func1<Observer<? super R>, Subscription> {
 
         private volatile Observer<R> observer;
 
@@ -232,7 +319,7 @@ <T> void next(CombineObserver<? extends R, T> w, T arg) {
         }
 
         @Override
-        public Subscription call(Observer<R> observer) {
+        public Subscription call(Observer<? super R> observer) {
             if (this.observer != null) {
                 throw new IllegalStateException("Only one Observer can subscribe to this Observable.");
             }
@@ -283,8 +370,8 @@ public String call(String v1, String v2) {
             }));
             combined.subscribe(w);
             
-            w1.Observer.onNext("first value of w1");
-            w2.Observer.onNext("first value of w2");
+            w1.observer.onNext("first value of w1");
+            w2.observer.onNext("first value of w2");
             
             verify(w, never()).onNext(anyString());
             verify(w, never()).onCompleted();
@@ -305,18 +392,18 @@ public void testCombineLatestDifferentLengthObservableSequences1() {
 
             /* simulate sending data */
             // once for w1
-            w1.Observer.onNext("1a");
-            w2.Observer.onNext("2a");
-            w3.Observer.onNext("3a");
-            w1.Observer.onCompleted();
+            w1.observer.onNext("1a");
+            w2.observer.onNext("2a");
+            w3.observer.onNext("3a");
+            w1.observer.onCompleted();
             // twice for w2
-            w2.Observer.onNext("2b");
-            w2.Observer.onCompleted();
+            w2.observer.onNext("2b");
+            w2.observer.onCompleted();
             // 4 times for w3
-            w3.Observer.onNext("3b");
-            w3.Observer.onNext("3c");
-            w3.Observer.onNext("3d");
-            w3.Observer.onCompleted();
+            w3.observer.onNext("3b");
+            w3.observer.onNext("3c");
+            w3.observer.onNext("3d");
+            w3.observer.onCompleted();
 
             /* we should have been called 4 times on the Observer */
             InOrder inOrder = inOrder(w);
@@ -343,18 +430,18 @@ public void testCombineLatestDifferentLengthObservableSequences2() {
 
             /* simulate sending data */
             // 4 times for w1
-            w1.Observer.onNext("1a");
-            w1.Observer.onNext("1b");
-            w1.Observer.onNext("1c");
-            w1.Observer.onNext("1d");
-            w1.Observer.onCompleted();
+            w1.observer.onNext("1a");
+            w1.observer.onNext("1b");
+            w1.observer.onNext("1c");
+            w1.observer.onNext("1d");
+            w1.observer.onCompleted();
             // twice for w2
-            w2.Observer.onNext("2a");
-            w2.Observer.onNext("2b");
-            w2.Observer.onCompleted();
+            w2.observer.onNext("2a");
+            w2.observer.onNext("2b");
+            w2.observer.onCompleted();
             // 1 times for w3
-            w3.Observer.onNext("3a");
-            w3.Observer.onCompleted();
+            w3.observer.onNext("3a");
+            w3.observer.onCompleted();
 
             /* we should have been called 1 time only on the Observer since we only combine the "latest" we don't go back and loop through others once completed */
             InOrder inOrder = inOrder(w);
@@ -378,19 +465,19 @@ public void testCombineLatestWithInterleavingSequences() {
             combineLatestW.subscribe(w);
 
             /* simulate sending data */
-            w1.Observer.onNext("1a");
-            w2.Observer.onNext("2a");
-            w2.Observer.onNext("2b");
-            w3.Observer.onNext("3a");
-
-            w1.Observer.onNext("1b");
-            w2.Observer.onNext("2c");
-            w2.Observer.onNext("2d");
-            w3.Observer.onNext("3b");
+            w1.observer.onNext("1a");
+            w2.observer.onNext("2a");
+            w2.observer.onNext("2b");
+            w3.observer.onNext("3a");
+
+            w1.observer.onNext("1b");
+            w2.observer.onNext("2c");
+            w2.observer.onNext("2d");
+            w3.observer.onNext("3b");
             
-            w1.Observer.onCompleted();
-            w2.Observer.onCompleted();
-            w3.Observer.onCompleted();
+            w1.observer.onCompleted();
+            w2.observer.onCompleted();
+            w3.observer.onCompleted();
 
             /* we should have been called 5 times on the Observer */
             InOrder inOrder = inOrder(w);
@@ -851,12 +938,12 @@ private static String getStringValue(Object o) {
 
         private static class TestObservable extends Observable<String> {
 
-            Observer<String> Observer;
+            Observer<? super String> observer;
 
             @Override
-            public Subscription subscribe(Observer<String> Observer) {
+            public Subscription subscribe(Observer<? super String> observer) {
                 // just store the variable where it can be accessed so we can manually trigger it
-                this.Observer = Observer;
+                this.observer = observer;
                 return Subscriptions.empty();
             }
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperationConcat.java b/rxjava-core/src/main/java/rx/operators/OperationConcat.java
index af15ee83cc..36f06992cc 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationConcat.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationConcat.java
@@ -56,30 +56,30 @@ public final class OperationConcat {
      *            An observable sequence of elements to project.
      * @return An observable sequence whose elements are the result of combining the output from the list of Observables.
      */
-    public static <T> Func1<Observer<T>, Subscription> concat(final Observable<T>... sequences) {
+    public static <T> Func1<Observer<? super T>, Subscription> concat(final Observable<? extends T>... sequences) {
         return concat(Observable.from(sequences));
     }
 
-    public static <T> Func1<Observer<T>, Subscription> concat(final List<Observable<T>> sequences) {
+    public static <T> Func1<Observer<? super T>, Subscription> concat(final List<? extends Observable<? extends T>> sequences) {
         return concat(Observable.from(sequences));
     }
 
-    public static <T> Func1<Observer<T>, Subscription> concat(final Observable<Observable<T>> sequences) {
+    public static <T> Func1<Observer<? super T>, Subscription> concat(final Observable<? extends Observable<? extends T>> sequences) {
         return new Concat<T>(sequences);
     }
 
-    private static class Concat<T> implements Func1<Observer<T>, Subscription> {
-        private Observable<Observable<T>> sequences;
+    private static class Concat<T> implements Func1<Observer<? super T>, Subscription> {
+        private Observable<? extends Observable<? extends T>> sequences;
         private SafeObservableSubscription innerSubscription = null;
 
-        public Concat(Observable<Observable<T>> sequences) {
+        public Concat(Observable<? extends Observable<? extends T>> sequences) {
             this.sequences = sequences;
         }
 
-        public Subscription call(final Observer<T> observer) {
+        public Subscription call(final Observer<? super T> observer) {
             final AtomicBoolean completedOrErred = new AtomicBoolean(false);
             final AtomicBoolean allSequencesReceived = new AtomicBoolean(false);
-            final Queue<Observable<T>> nextSequences = new ConcurrentLinkedQueue<Observable<T>>();
+            final Queue<Observable<? extends T>> nextSequences = new ConcurrentLinkedQueue<Observable<? extends T>>();
             final SafeObservableSubscription outerSubscription = new SafeObservableSubscription();
 
             final Observer<T> reusableObserver = new Observer<T>() {
@@ -117,9 +117,9 @@ public void onCompleted() {
                 }
             };
 
-            outerSubscription.wrap(sequences.subscribe(new Observer<Observable<T>>() {
+            outerSubscription.wrap(sequences.subscribe(new Observer<Observable<? extends T>>() {
                 @Override
-                public void onNext(Observable<T> nextSequence) {
+                public void onNext(Observable<? extends T> nextSequence) {
                     synchronized (nextSequences) {
                         if (innerSubscription == null) {
                             // We are currently not subscribed to any sequence
@@ -217,10 +217,10 @@ public void testConcatObservableOfObservables() {
             final Observable<String> odds = Observable.from(o);
             final Observable<String> even = Observable.from(e);
 
-            Observable<Observable<String>> observableOfObservables = Observable.create(new Func1<Observer<Observable<String>>, Subscription>() {
+            Observable<Observable<String>> observableOfObservables = Observable.create(new Func1<Observer<? super Observable<String>>, Subscription>() {
 
                 @Override
-                public Subscription call(Observer<Observable<String>> observer) {
+                public Subscription call(Observer<? super Observable<String>> observer) {
                     // simulate what would happen in an observable
                     observer.onNext(odds);
                     observer.onNext(even);
@@ -288,10 +288,10 @@ public void testNestedAsyncConcat() throws Throwable {
             final CountDownLatch allowThird = new CountDownLatch(1);
 
             final AtomicReference<Thread> parent = new AtomicReference<Thread>();
-            Observable<Observable<String>> observableOfObservables = Observable.create(new Func1<Observer<Observable<String>>, Subscription>() {
+            Observable<Observable<String>> observableOfObservables = Observable.create(new Func1<Observer<? super Observable<String>>, Subscription>() {
 
                 @Override
-                public Subscription call(final Observer<Observable<String>> observer) {
+                public Subscription call(final Observer<? super Observable<String>> observer) {
                     final BooleanSubscription s = new BooleanSubscription();
                     parent.set(new Thread(new Runnable() {
 
@@ -404,7 +404,7 @@ public void testBlockedObservableOfObservables() {
             final CountDownLatch callOnce = new CountDownLatch(1);
             final CountDownLatch okToContinue = new CountDownLatch(1);
             TestObservable<Observable<String>> observableOfObservables = new TestObservable<Observable<String>>(callOnce, okToContinue, odds, even);
-            Func1<Observer<String>, Subscription> concatF = concat(observableOfObservables);
+            Func1<Observer<? super String>, Subscription> concatF = concat(observableOfObservables);
             Observable<String> concat = Observable.create(concatF);
             concat.subscribe(observer);
             try {
@@ -444,7 +444,7 @@ public void testConcatConcurrentWithInfinity() {
             Observer<String> aObserver = mock(Observer.class);
             @SuppressWarnings("unchecked")
             TestObservable<Observable<String>> observableOfObservables = new TestObservable<Observable<String>>(w1, w2);
-            Func1<Observer<String>, Subscription> concatF = concat(observableOfObservables);
+            Func1<Observer<? super String>, Subscription> concatF = concat(observableOfObservables);
 
             Observable<String> concat = Observable.create(concatF);
 
@@ -480,10 +480,10 @@ public void testConcatNonBlockingObservables() {
 
             @SuppressWarnings("unchecked")
             Observer<String> aObserver = mock(Observer.class);
-            Observable<Observable<String>> observableOfObservables = Observable.create(new Func1<Observer<Observable<String>>, Subscription>() {
+            Observable<Observable<String>> observableOfObservables = Observable.create(new Func1<Observer<? super Observable<String>>, Subscription>() {
 
                 @Override
-                public Subscription call(Observer<Observable<String>> observer) {
+                public Subscription call(Observer<? super Observable<String>> observer) {
                     // simulate what would happen in an observable
                     observer.onNext(w1);
                     observer.onNext(w2);
@@ -584,7 +584,7 @@ public void testConcatUnsubscribeConcurrent() {
             Observer<String> aObserver = mock(Observer.class);
             @SuppressWarnings("unchecked")
             TestObservable<Observable<String>> observableOfObservables = new TestObservable<Observable<String>>(w1, w2);
-            Func1<Observer<String>, Subscription> concatF = concat(observableOfObservables);
+            Func1<Observer<? super String>, Subscription> concatF = concat(observableOfObservables);
 
             Observable<String> concat = Observable.create(concatF);
 
@@ -656,7 +656,7 @@ public TestObservable(T seed, int size) {
             }
 
             @Override
-            public Subscription subscribe(final Observer<T> observer) {
+            public Subscription subscribe(final Observer<? super T> observer) {
                 t = new Thread(new Runnable() {
 
                     @Override
diff --git a/rxjava-core/src/main/java/rx/operators/OperationDefer.java b/rxjava-core/src/main/java/rx/operators/OperationDefer.java
index 169227f17c..c258b36398 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationDefer.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationDefer.java
@@ -37,12 +37,12 @@
  */
 public final class OperationDefer {
 
-    public static <T> Func1<Observer<T>, Subscription> defer(final Func0<Observable<T>> observableFactory) {
+    public static <T> Func1<Observer<? super T>, Subscription> defer(final Func0<? extends Observable<? extends T>> observableFactory) {
 
-        return new Func1<Observer<T>, Subscription>() {
+        return new Func1<Observer<? super T>, Subscription>() {
             @Override
-            public Subscription call(Observer<T> observer) {
-                Observable<T> obs = observableFactory.call();
+            public Subscription call(Observer<? super T> observer) {
+                Observable<? extends T> obs = observableFactory.call();
                 return obs.subscribe(observer);
             }
         };
diff --git a/rxjava-core/src/main/java/rx/operators/OperationDematerialize.java b/rxjava-core/src/main/java/rx/operators/OperationDematerialize.java
index 14ac8748b6..52a817a23e 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationDematerialize.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationDematerialize.java
@@ -45,21 +45,21 @@ public final class OperationDematerialize {
      * @return An observable sequence exhibiting the behavior corresponding to the source sequence's notification values.
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229047(v=vs.103).aspx">Observable.Dematerialize(TSource) Method </a>
      */
-    public static <T> Func1<Observer<T>, Subscription> dematerialize(final Observable<Notification<T>> sequence) {
+    public static <T> Func1<Observer<? super T>, Subscription> dematerialize(final Observable<? extends Notification<? extends T>> sequence) {
         return new DematerializeObservable<T>(sequence);
     }
 
-    private static class DematerializeObservable<T> implements Func1<Observer<T>, Subscription> {
+    private static class DematerializeObservable<T> implements Func1<Observer<? super T>, Subscription> {
 
-        private final Observable<Notification<T>> sequence;
+        private final Observable<? extends Notification<? extends T>> sequence;
 
-        public DematerializeObservable(Observable<Notification<T>> sequence) {
+        public DematerializeObservable(Observable<? extends Notification<? extends T>> sequence) {
             this.sequence = sequence;
         }
 
         @Override
-        public Subscription call(final Observer<T> observer) {
-            return sequence.subscribe(new Observer<Notification<T>>() {
+        public Subscription call(final Observer<? super T> observer) {
+            return sequence.subscribe(new Observer<Notification<? extends T>>() {
                 @Override
                 public void onCompleted() {
                 }
@@ -69,7 +69,7 @@ public void onError(Throwable e) {
                 }
 
                 @Override
-                public void onNext(Notification<T> value) {
+                public void onNext(Notification<? extends T> value) {
                     switch (value.getKind()) {
                     case OnNext:
                         observer.onNext(value.getValue());
diff --git a/rxjava-core/src/main/java/rx/operators/OperationFilter.java b/rxjava-core/src/main/java/rx/operators/OperationFilter.java
index 1e0b7d6fd9..35654f5761 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationFilter.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationFilter.java
@@ -33,21 +33,21 @@
  */
 public final class OperationFilter<T> {
 
-    public static <T> Func1<Observer<T>, Subscription> filter(Observable<T> that, Func1<T, Boolean> predicate) {
+    public static <T> Func1<Observer<? super T>, Subscription> filter(Observable<? extends T> that, Func1<? super T, Boolean> predicate) {
         return new Filter<T>(that, predicate);
     }
 
-    private static class Filter<T> implements Func1<Observer<T>, Subscription> {
+    private static class Filter<T> implements Func1<Observer<? super T>, Subscription> {
 
-        private final Observable<T> that;
-        private final Func1<T, Boolean> predicate;
+        private final Observable<? extends T> that;
+        private final Func1<? super T, Boolean> predicate;
 
-        public Filter(Observable<T> that, Func1<T, Boolean> predicate) {
+        public Filter(Observable<? extends T> that, Func1<? super T, Boolean> predicate) {
             this.that = that;
             this.predicate = predicate;
         }
 
-        public Subscription call(final Observer<T> observer) {
+        public Subscription call(final Observer<? super T> observer) {
             final SafeObservableSubscription subscription = new SafeObservableSubscription();
             return subscription.wrap(that.subscribe(new Observer<T>() {
                 public void onNext(T value) {
diff --git a/rxjava-core/src/main/java/rx/operators/OperationFinally.java b/rxjava-core/src/main/java/rx/operators/OperationFinally.java
index 82fcfd4686..b07ae5c234 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationFinally.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationFinally.java
@@ -52,32 +52,32 @@ public final class OperationFinally {
      *         the given action will be called.
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh212133(v=vs.103).aspx">MSDN Observable.Finally method</a>
      */
-    public static <T> Func1<Observer<T>, Subscription> finallyDo(final Observable<T> sequence, final Action0 action) {
-        return new Func1<Observer<T>, Subscription>() {
+    public static <T> Func1<Observer<? super T>, Subscription> finallyDo(final Observable<? extends T> sequence, final Action0 action) {
+        return new Func1<Observer<? super T>, Subscription>() {
             @Override
-            public Subscription call(Observer<T> observer) {
+            public Subscription call(Observer<? super T> observer) {
                 return new Finally<T>(sequence, action).call(observer);
             }
         };
     }
 
-    private static class Finally<T> implements Func1<Observer<T>, Subscription> {
-        private final Observable<T> sequence;
+    private static class Finally<T> implements Func1<Observer<? super T>, Subscription> {
+        private final Observable<? extends T> sequence;
         private final Action0 finalAction;
 
-        Finally(final Observable<T> sequence, Action0 finalAction) {
+        Finally(final Observable<? extends T> sequence, Action0 finalAction) {
             this.sequence = sequence;
             this.finalAction = finalAction;
         }
 
-        public Subscription call(Observer<T> observer) {
+        public Subscription call(Observer<? super T> observer) {
             return sequence.subscribe(new FinallyObserver(observer));
         }
 
         private class FinallyObserver implements Observer<T> {
-            private final Observer<T> observer;
+            private final Observer<? super T> observer;
 
-            FinallyObserver(Observer<T> observer) {
+            FinallyObserver(Observer<? super T> observer) {
                 this.observer = observer;
             }
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperationGroupBy.java b/rxjava-core/src/main/java/rx/operators/OperationGroupBy.java
index 77e04324b0..c26d1b431d 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationGroupBy.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationGroupBy.java
@@ -48,7 +48,7 @@
  */
 public final class OperationGroupBy {
 
-    public static <K, T, R> Func1<Observer<GroupedObservable<K, R>>, Subscription> groupBy(Observable<T> source, final Func1<T, K> keySelector, final Func1<T, R> elementSelector) {
+    public static <K, T, R> Func1<Observer<? super GroupedObservable<K, R>>, Subscription> groupBy(Observable<? extends T> source, final Func1<? super T, ? extends K> keySelector, final Func1<? super T, ? extends R> elementSelector) {
 
         final Observable<KeyValue<K, R>> keyval = source.map(new Func1<T, KeyValue<K, R>>() {
             @Override
@@ -63,11 +63,11 @@ public KeyValue<K, R> call(T t) {
         return new GroupBy<K, R>(keyval);
     }
 
-    public static <K, T> Func1<Observer<GroupedObservable<K, T>>, Subscription> groupBy(Observable<T> source, final Func1<T, K> keySelector) {
+    public static <K, T> Func1<Observer<? super GroupedObservable<K, T>>, Subscription> groupBy(Observable<? extends T> source, final Func1<? super T, ? extends K> keySelector) {
         return groupBy(source, keySelector, Functions.<T> identity());
     }
 
-    private static class GroupBy<K, V> implements Func1<Observer<GroupedObservable<K, V>>, Subscription> {
+    private static class GroupBy<K, V> implements Func1<Observer<? super GroupedObservable<K, V>>, Subscription> {
 
         private final Observable<KeyValue<K, V>> source;
         private final ConcurrentHashMap<K, GroupedSubject<K, V>> groupedObservables = new ConcurrentHashMap<K, GroupedSubject<K, V>>();
@@ -80,7 +80,7 @@ private GroupBy(Observable<KeyValue<K, V>> source) {
         }
 
         @Override
-        public Subscription call(final Observer<GroupedObservable<K, V>> observer) {
+        public Subscription call(final Observer<? super GroupedObservable<K, V>> observer) {
             final GroupBy<K, V> _this = this;
             actualParentSubscription.wrap(source.subscribe(new Observer<KeyValue<K, V>>() {
 
@@ -173,27 +173,23 @@ private void unsubscribeKey(K key) {
     private static class GroupedSubject<K, T> extends GroupedObservable<K, T> implements Observer<T> {
 
         static <K, T> GroupedSubject<K, T> create(final K key, final GroupBy<K, T> parent) {
-            @SuppressWarnings("unchecked")
-            final AtomicReference<Observer<T>> subscribedObserver = new AtomicReference<Observer<T>>(EMPTY_OBSERVER);
-
-            return new GroupedSubject<K, T>(key, new Func1<Observer<T>, Subscription>() {
+            final AtomicReference<Observer<? super T>> subscribedObserver = new AtomicReference<Observer<? super T>>(OperationGroupBy.<T>emptyObserver());
+            return new GroupedSubject<K, T>(key, new Func1<Observer<? super T>, Subscription>() {
 
                 private final SafeObservableSubscription subscription = new SafeObservableSubscription();
 
                 @Override
-                public Subscription call(Observer<T> observer) {
+                public Subscription call(Observer<? super T> observer) {
                     // register Observer
                     subscribedObserver.set(observer);
 
                     parent.subscribeKey(key);
 
                     return subscription.wrap(new Subscription() {
-
-                        @SuppressWarnings("unchecked")
                         @Override
                         public void unsubscribe() {
                             // we remove the Observer so we stop emitting further events (they will be ignored if parent continues to send)
-                            subscribedObserver.set(EMPTY_OBSERVER);
+                            subscribedObserver.set(OperationGroupBy.<T>emptyObserver());
                             // now we need to notify the parent that we're unsubscribed
                             parent.unsubscribeKey(key);
                         }
@@ -202,9 +198,9 @@ public void unsubscribe() {
             }, subscribedObserver);
         }
 
-        private final AtomicReference<Observer<T>> subscribedObserver;
+        private final AtomicReference<Observer<? super T>> subscribedObserver;
 
-        public GroupedSubject(K key, Func1<Observer<T>, Subscription> onSubscribe, AtomicReference<Observer<T>> subscribedObserver) {
+        public GroupedSubject(K key, Func1<? super Observer<? super T>, ? extends Subscription> onSubscribe, AtomicReference<Observer<? super T>> subscribedObserver) {
             super(key, onSubscribe);
             this.subscribedObserver = subscribedObserver;
         }
@@ -226,25 +222,24 @@ public void onNext(T v) {
 
     }
 
-    @SuppressWarnings("rawtypes")
-    private static Observer EMPTY_OBSERVER = new Observer() {
-
-        @Override
-        public void onCompleted() {
-            // do nothing            
-        }
-
-        @Override
-        public void onError(Throwable e) {
-            // do nothing            
-        }
-
-        @Override
-        public void onNext(Object args) {
-            // do nothing
-        }
-
-    };
+    private static <T> Observer<T> emptyObserver() { 
+        return new Observer<T>() {
+            @Override
+            public void onCompleted() {
+                // do nothing            
+            }
+    
+            @Override
+            public void onError(Throwable e) {
+                // do nothing            
+            }
+    
+            @Override
+            public void onNext(T t) {
+                // do nothing
+            }
+        };
+    }
 
     private static class KeyValue<K, V> {
         private final K key;
@@ -377,10 +372,10 @@ public void testGroupedEventStream() throws Throwable {
             final int count = 100;
             final int groupCount = 2;
 
-            Observable<Event> es = Observable.create(new Func1<Observer<Event>, Subscription>() {
+            Observable<Event> es = Observable.create(new Func1<Observer<? super Event>, Subscription>() {
 
                 @Override
-                public Subscription call(final Observer<Event> observer) {
+                public Subscription call(final Observer<? super Event> observer) {
                     System.out.println("*** Subscribing to EventStream ***");
                     subscribeCounter.incrementAndGet();
                     new Thread(new Runnable() {
@@ -423,7 +418,7 @@ public String call(Event event) {
                         }
                     });
 
-                };
+                }
             }).subscribe(new Observer<String>() {
 
                 @Override
@@ -465,10 +460,10 @@ public void testUnsubscribe() throws InterruptedException {
             final int count = 100;
             final int groupCount = 2;
 
-            Observable<Event> es = Observable.create(new Func1<Observer<Event>, Subscription>() {
+            Observable<Event> es = Observable.create(new Func1<Observer<? super Event>, Subscription>() {
 
                 @Override
-                public Subscription call(final Observer<Event> observer) {
+                public Subscription call(final Observer<? super Event> observer) {
                     final BooleanSubscription s = new BooleanSubscription();
                     System.out.println("testUnsubscribe => *** Subscribing to EventStream ***");
                     subscribeCounter.incrementAndGet();
@@ -520,7 +515,7 @@ public String call(Event event) {
                                         }
                                     });
 
-                        };
+                        }
                     }).subscribe(new Observer<String>() {
 
                         @Override
diff --git a/rxjava-core/src/main/java/rx/operators/OperationInterval.java b/rxjava-core/src/main/java/rx/operators/OperationInterval.java
index 3b0b00ca15..6cef0c5215 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationInterval.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationInterval.java
@@ -44,18 +44,18 @@ public final class OperationInterval {
     /**
      * Creates an event each time interval.
      */
-    public static Func1<Observer<Long>, Subscription> interval(long interval, TimeUnit unit) {
+    public static Func1<Observer<? super Long>, Subscription> interval(long interval, TimeUnit unit) {
         return new Interval(interval, unit, Schedulers.executor(Executors.newSingleThreadScheduledExecutor()));
     }
 
     /**
      * Creates an event each time interval.
      */
-    public static Func1<Observer<Long>, Subscription> interval(long interval, TimeUnit unit, Scheduler scheduler) {
+    public static Func1<Observer<? super Long>, Subscription> interval(long interval, TimeUnit unit, Scheduler scheduler) {
         return new Interval(interval, unit, scheduler);
     }
 
-    private static class Interval implements Func1<Observer<Long>, Subscription> {
+    private static class Interval implements Func1<Observer<? super Long>, Subscription> {
         private final long period;
         private final TimeUnit unit;
         private final Scheduler scheduler;
@@ -69,7 +69,7 @@ private Interval(long period, TimeUnit unit, Scheduler scheduler) {
         }
 
         @Override
-        public Subscription call(final Observer<Long> observer) {
+        public Subscription call(final Observer<? super Long> observer) {
             final Subscription wrapped = scheduler.schedulePeriodically(new Action0() {
                 @Override
                 public void call() {
diff --git a/rxjava-core/src/main/java/rx/operators/OperationMap.java b/rxjava-core/src/main/java/rx/operators/OperationMap.java
index 85ec5b38b3..8c0554b878 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationMap.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationMap.java
@@ -55,7 +55,7 @@ public final class OperationMap {
      *            the type of the output sequence.
      * @return a sequence that is the result of applying the transformation function to each item in the input sequence.
      */
-    public static <T, R> Func1<Observer<R>, Subscription> map(Observable<T> sequence, Func1<T, R> func) {
+    public static <T, R> Func1<Observer<? super R>, Subscription> map(Observable<? extends T> sequence, Func1<? super T, ? extends R> func) {
         return new MapObservable<T, R>(sequence, func);
     }
 
@@ -75,7 +75,7 @@ public static <T, R> Func1<Observer<R>, Subscription> map(Observable<T> sequence
      *            the type of the output sequence.
      * @return a sequence that is the result of applying the transformation function to each item in the input sequence.
      */
-    public static <T, R> Func1<Observer<R>, Subscription> mapMany(Observable<T> sequence, Func1<T, Observable<R>> func) {
+    public static <T, R> Func1<Observer<? super R>, Subscription> mapMany(Observable<? extends T> sequence, Func1<? super T, ? extends Observable<? extends R>> func) {
         return OperationMerge.merge(Observable.create(map(sequence, func)));
     }
 
@@ -87,17 +87,17 @@ public static <T, R> Func1<Observer<R>, Subscription> mapMany(Observable<T> sequ
      * @param <R>
      *            the type of the output sequence.
      */
-    private static class MapObservable<T, R> implements Func1<Observer<R>, Subscription> {
-        public MapObservable(Observable<T> sequence, Func1<T, R> func) {
+    private static class MapObservable<T, R> implements Func1<Observer<? super R>, Subscription> {
+        public MapObservable(Observable<? extends T> sequence, Func1<? super T, ? extends R> func) {
             this.sequence = sequence;
             this.func = func;
         }
 
-        private Observable<T> sequence;
+        private Observable<? extends T> sequence;
 
-        private Func1<T, R> func;
+        private Func1<? super T, ? extends R> func;
 
-        public Subscription call(Observer<R> observer) {
+        public Subscription call(Observer<? super R> observer) {
             return sequence.subscribe(new MapObserver<T, R>(observer, func));
         }
     }
@@ -111,14 +111,14 @@ public Subscription call(Observer<R> observer) {
      *            the type of the inner observer items.
      */
     private static class MapObserver<T, R> implements Observer<T> {
-        public MapObserver(Observer<R> observer, Func1<T, R> func) {
+        public MapObserver(Observer<? super R> observer, Func1<? super T, ? extends R> func) {
             this.observer = observer;
             this.func = func;
         }
 
-        Observer<R> observer;
+        Observer<? super R> observer;
 
-        Func1<T, R> func;
+        Func1<? super T, ? extends R> func;
 
         public void onNext(T value) {
             // let the exception be thrown if func fails as a SafeObserver wrapping this will handle it
diff --git a/rxjava-core/src/main/java/rx/operators/OperationMaterialize.java b/rxjava-core/src/main/java/rx/operators/OperationMaterialize.java
index 279bff006a..39cc1606d1 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationMaterialize.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationMaterialize.java
@@ -48,20 +48,20 @@ public final class OperationMaterialize {
      * @return An observable sequence whose elements are the result of materializing the notifications of the given sequence.
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229453(v=VS.103).aspx">Observable.Materialize(TSource) Method </a>
      */
-    public static <T> Func1<Observer<Notification<T>>, Subscription> materialize(final Observable<T> sequence) {
+    public static <T> Func1<Observer<? super Notification<T>>, Subscription> materialize(final Observable<? extends T> sequence) {
         return new MaterializeObservable<T>(sequence);
     }
 
-    private static class MaterializeObservable<T> implements Func1<Observer<Notification<T>>, Subscription> {
+    private static class MaterializeObservable<T> implements Func1<Observer<? super Notification<T>>, Subscription> {
 
-        private final Observable<T> sequence;
+        private final Observable<? extends T> sequence;
 
-        public MaterializeObservable(Observable<T> sequence) {
+        public MaterializeObservable(Observable<? extends T> sequence) {
             this.sequence = sequence;
         }
 
         @Override
-        public Subscription call(final Observer<Notification<T>> observer) {
+        public Subscription call(final Observer<? super Notification<T>> observer) {
             return sequence.subscribe(new Observer<T>() {
 
                 @Override
@@ -185,7 +185,7 @@ private static class TestAsyncErrorObservable extends Observable<String> {
         volatile Thread t;
 
         @Override
-        public Subscription subscribe(final Observer<String> observer) {
+        public Subscription subscribe(final Observer<? super String> observer) {
             t = new Thread(new Runnable() {
 
                 @Override
diff --git a/rxjava-core/src/main/java/rx/operators/OperationMerge.java b/rxjava-core/src/main/java/rx/operators/OperationMerge.java
index c183fe957e..a26cad2fd9 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationMerge.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationMerge.java
@@ -55,29 +55,29 @@ public final class OperationMerge {
      * @return An observable sequence whose elements are the result of flattening the output from the list of Observables.
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099(v=vs.103).aspx">Observable.Merge(TSource) Method (IObservable(TSource)[])</a>
      */
-    public static <T> Func1<Observer<T>, Subscription> merge(final Observable<Observable<T>> o) {
+    public static <T> Func1<Observer<? super T>, Subscription> merge(final Observable<? extends Observable<? extends T>> o) {
         // wrap in a Func so that if a chain is built up, then asynchronously subscribed to twice we will have 2 instances of Take<T> rather than 1 handing both, which is not thread-safe.
-        return new Func1<Observer<T>, Subscription>() {
+        return new Func1<Observer<? super T>, Subscription>() {
 
             @Override
-            public Subscription call(Observer<T> observer) {
+            public Subscription call(Observer<? super T> observer) {
                 return new MergeObservable<T>(o).call(observer);
             }
         };
     }
 
-    public static <T> Func1<Observer<T>, Subscription> merge(final Observable<T>... sequences) {
+    public static <T> Func1<Observer<? super T>, Subscription> merge(final Observable<? extends T>... sequences) {
         return merge(Arrays.asList(sequences));
     }
 
-    public static <T> Func1<Observer<T>, Subscription> merge(final List<Observable<T>> sequences) {
-        return merge(Observable.create(new Func1<Observer<Observable<T>>, Subscription>() {
+    public static <T> Func1<Observer<? super T>, Subscription> merge(final List<? extends Observable<? extends T>> sequences) {
+        return merge(Observable.create(new Func1<Observer<? super Observable<? extends T>>, Subscription>() {
 
             private volatile boolean unsubscribed = false;
 
             @Override
-            public Subscription call(Observer<Observable<T>> observer) {
-                for (Observable<T> o : sequences) {
+            public Subscription call(Observer<? super Observable<? extends T>> observer) {
+                for (Observable<? extends T> o : sequences) {
                     if (!unsubscribed) {
                         observer.onNext(o);
                     } else {
@@ -112,19 +112,19 @@ public void unsubscribe() {
      * 
      * @param <T>
      */
-    private static final class MergeObservable<T> implements Func1<Observer<T>, Subscription> {
-        private final Observable<Observable<T>> sequences;
+    private static final class MergeObservable<T> implements Func1<Observer<? super T>, Subscription> {
+        private final Observable<? extends Observable<? extends T>> sequences;
         private final MergeSubscription ourSubscription = new MergeSubscription();
         private AtomicBoolean stopped = new AtomicBoolean(false);
         private volatile boolean parentCompleted = false;
         private final ConcurrentHashMap<ChildObserver, ChildObserver> childObservers = new ConcurrentHashMap<ChildObserver, ChildObserver>();
         private final ConcurrentHashMap<ChildObserver, Subscription> childSubscriptions = new ConcurrentHashMap<ChildObserver, Subscription>();
 
-        private MergeObservable(Observable<Observable<T>> sequences) {
+        private MergeObservable(Observable<? extends Observable<? extends T>> sequences) {
             this.sequences = sequences;
         }
 
-        public Subscription call(Observer<T> actualObserver) {
+        public Subscription call(Observer<? super T> actualObserver) {
 
             /**
              * We must synchronize a merge because we subscribe to multiple sequences in parallel that will each be emitting.
@@ -178,7 +178,7 @@ public boolean stop() {
          * 
          * @param <T>
          */
-        private class ParentObserver implements Observer<Observable<T>> {
+        private class ParentObserver implements Observer<Observable<? extends T>> {
             private final Observer<T> actualObserver;
 
             public ParentObserver(Observer<T> actualObserver) {
@@ -207,7 +207,7 @@ public void onError(Throwable e) {
             }
 
             @Override
-            public void onNext(Observable<T> childObservable) {
+            public void onNext(Observable<? extends T> childObservable) {
                 if (stopped.get()) {
                     // we won't act on any further items
                     return;
@@ -295,10 +295,10 @@ public void testMergeObservableOfObservables() {
             final Observable<String> o1 = new TestSynchronousObservable();
             final Observable<String> o2 = new TestSynchronousObservable();
 
-            Observable<Observable<String>> observableOfObservables = Observable.create(new Func1<Observer<Observable<String>>, Subscription>() {
+            Observable<Observable<String>> observableOfObservables = Observable.create(new Func1<Observer<? super Observable<String>>, Subscription>() {
 
                 @Override
-                public Subscription call(Observer<Observable<String>> observer) {
+                public Subscription call(Observer<? super Observable<String>> observer) {
                     // simulate what would happen in an observable
                     observer.onNext(o1);
                     observer.onNext(o2);
@@ -528,7 +528,7 @@ public void testError2() {
         private static class TestSynchronousObservable extends Observable<String> {
 
             @Override
-            public Subscription subscribe(Observer<String> observer) {
+            public Subscription subscribe(Observer<? super String> observer) {
 
                 observer.onNext("hello");
                 observer.onCompleted();
@@ -549,7 +549,7 @@ private static class TestASynchronousObservable extends Observable<String> {
             final CountDownLatch onNextBeingSent = new CountDownLatch(1);
 
             @Override
-            public Subscription subscribe(final Observer<String> observer) {
+            public Subscription subscribe(final Observer<? super String> observer) {
                 t = new Thread(new Runnable() {
 
                     @Override
@@ -580,7 +580,7 @@ public void unsubscribe() {
          */
         private static class TestObservable extends Observable<String> {
 
-            Observer<String> observer = null;
+            Observer<? super String> observer = null;
             volatile boolean unsubscribed = false;
             Subscription s = new Subscription() {
 
@@ -609,7 +609,7 @@ public void sendOnError(Throwable e) {
             }
 
             @Override
-            public Subscription subscribe(final Observer<String> observer) {
+            public Subscription subscribe(final Observer<? super String> observer) {
                 this.observer = observer;
                 return s;
             }
@@ -624,7 +624,7 @@ private static class TestErrorObservable extends Observable<String> {
             }
 
             @Override
-            public Subscription subscribe(Observer<String> observer) {
+            public Subscription subscribe(Observer<? super String> observer) {
 
                 for (String s : valuesToReturn) {
                     if (s == null) {
diff --git a/rxjava-core/src/main/java/rx/operators/OperationMergeDelayError.java b/rxjava-core/src/main/java/rx/operators/OperationMergeDelayError.java
index a54f193a2f..12341e6367 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationMergeDelayError.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationMergeDelayError.java
@@ -64,24 +64,24 @@ public final class OperationMergeDelayError {
      * @return An observable sequence whose elements are the result of flattening the output from the list of Observables.
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099(v=vs.103).aspx">Observable.Merge(TSource) Method (IObservable(TSource)[])</a>
      */
-    public static <T> Func1<Observer<T>, Subscription> mergeDelayError(final Observable<Observable<T>> sequences) {
+    public static <T> Func1<Observer<? super T>, Subscription> mergeDelayError(final Observable<? extends Observable<? extends T>> sequences) {
         // wrap in a Func so that if a chain is built up, then asynchronously subscribed to twice we will have 2 instances of Take<T> rather than 1 handing both, which is not thread-safe.
-        return new Func1<Observer<T>, Subscription>() {
+        return new Func1<Observer<? super T>, Subscription>() {
 
             @Override
-            public Subscription call(Observer<T> observer) {
+            public Subscription call(Observer<? super T> observer) {
                 return new MergeDelayErrorObservable<T>(sequences).call(observer);
             }
         };
     }
 
-    public static <T> Func1<Observer<T>, Subscription> mergeDelayError(final Observable<T>... sequences) {
-        return mergeDelayError(Observable.create(new Func1<Observer<Observable<T>>, Subscription>() {
+    public static <T> Func1<Observer<? super T>, Subscription> mergeDelayError(final Observable<? extends T>... sequences) {
+        return mergeDelayError(Observable.create(new Func1<Observer<? super Observable<? extends T>>, Subscription>() {
             private volatile boolean unsubscribed = false;
 
             @Override
-            public Subscription call(Observer<Observable<T>> observer) {
-                for (Observable<T> o : sequences) {
+            public Subscription call(Observer<? super Observable<? extends T>> observer) {
+                for (Observable<? extends T> o : sequences) {
                     if (!unsubscribed) {
                         observer.onNext(o);
                     } else {
@@ -104,14 +104,14 @@ public void unsubscribe() {
         }));
     }
 
-    public static <T> Func1<Observer<T>, Subscription> mergeDelayError(final List<Observable<T>> sequences) {
-        return mergeDelayError(Observable.create(new Func1<Observer<Observable<T>>, Subscription>() {
+    public static <T> Func1<Observer<? super T>, Subscription> mergeDelayError(final List<? extends Observable<? extends T>> sequences) {
+        return mergeDelayError(Observable.create(new Func1<Observer<? super Observable<? extends T>>, Subscription>() {
 
             private volatile boolean unsubscribed = false;
 
             @Override
-            public Subscription call(Observer<Observable<T>> observer) {
-                for (Observable<T> o : sequences) {
+            public Subscription call(Observer<? super Observable<? extends T>> observer) {
+                for (Observable<? extends T> o : sequences) {
                     if (!unsubscribed) {
                         observer.onNext(o);
                     } else {
@@ -146,8 +146,8 @@ public void unsubscribe() {
      * 
      * @param <T>
      */
-    private static final class MergeDelayErrorObservable<T> implements Func1<Observer<T>, Subscription> {
-        private final Observable<Observable<T>> sequences;
+    private static final class MergeDelayErrorObservable<T> implements Func1<Observer<? super T>, Subscription> {
+        private final Observable<? extends Observable<? extends T>> sequences;
         private final MergeSubscription ourSubscription = new MergeSubscription();
         private AtomicBoolean stopped = new AtomicBoolean(false);
         private volatile boolean parentCompleted = false;
@@ -156,11 +156,11 @@ private static final class MergeDelayErrorObservable<T> implements Func1<Observe
         // onErrors we received that will be delayed until everything is completed and then sent
         private ConcurrentLinkedQueue<Throwable> onErrorReceived = new ConcurrentLinkedQueue<Throwable>();
 
-        private MergeDelayErrorObservable(Observable<Observable<T>> sequences) {
+        private MergeDelayErrorObservable(Observable<? extends Observable<? extends T>> sequences) {
             this.sequences = sequences;
         }
 
-        public Subscription call(Observer<T> actualObserver) {
+        public Subscription call(Observer<? super T> actualObserver) {
             /**
              * Subscribe to the parent Observable to get to the children Observables
              */
@@ -203,10 +203,10 @@ public boolean stop() {
          * 
          * @param <T>
          */
-        private class ParentObserver implements Observer<Observable<T>> {
-            private final Observer<T> actualObserver;
+        private class ParentObserver implements Observer<Observable<? extends T>> {
+            private final Observer<? super T> actualObserver;
 
-            public ParentObserver(Observer<T> actualObserver) {
+            public ParentObserver(Observer<? super T> actualObserver) {
                 this.actualObserver = actualObserver;
             }
 
@@ -241,7 +241,7 @@ public void onError(Throwable e) {
             }
 
             @Override
-            public void onNext(Observable<T> childObservable) {
+            public void onNext(Observable<? extends T> childObservable) {
                 if (stopped.get()) {
                     // we won't act on any further items
                     return;
@@ -271,10 +271,10 @@ public void onNext(Observable<T> childObservable) {
          */
         private class ChildObserver implements Observer<T> {
 
-            private final Observer<T> actualObserver;
+            private final Observer<? super T> actualObserver;
             private volatile boolean finished = false;
 
-            public ChildObserver(Observer<T> actualObserver) {
+            public ChildObserver(Observer<? super T> actualObserver) {
                 this.actualObserver = actualObserver;
             }
 
@@ -525,10 +525,10 @@ public void testMergeObservableOfObservables() {
             final Observable<String> o1 = new TestSynchronousObservable();
             final Observable<String> o2 = new TestSynchronousObservable();
 
-            Observable<Observable<String>> observableOfObservables = Observable.create(new Func1<Observer<Observable<String>>, Subscription>() {
+            Observable<Observable<String>> observableOfObservables = Observable.create(new Func1<Observer<? super Observable<String>>, Subscription>() {
 
                 @Override
-                public Subscription call(Observer<Observable<String>> observer) {
+                public Subscription call(Observer<? super Observable<String>> observer) {
                     // simulate what would happen in an observable
                     observer.onNext(o1);
                     observer.onNext(o2);
@@ -634,7 +634,7 @@ public void testMergeArrayWithThreading() {
         private static class TestSynchronousObservable extends Observable<String> {
 
             @Override
-            public Subscription subscribe(Observer<String> observer) {
+            public Subscription subscribe(Observer<? super String> observer) {
 
                 observer.onNext("hello");
                 observer.onCompleted();
@@ -654,7 +654,7 @@ private static class TestASynchronousObservable extends Observable<String> {
             Thread t;
 
             @Override
-            public Subscription subscribe(final Observer<String> observer) {
+            public Subscription subscribe(final Observer<? super String> observer) {
                 t = new Thread(new Runnable() {
 
                     @Override
@@ -682,7 +682,7 @@ public void unsubscribe() {
          */
         private static class TestObservable extends Observable<String> {
 
-            Observer<String> observer = null;
+            Observer<? super String> observer = null;
             volatile boolean unsubscribed = false;
             Subscription s = new Subscription() {
 
@@ -711,7 +711,7 @@ public void sendOnError(Throwable e) {
             }
 
             @Override
-            public Subscription subscribe(final Observer<String> observer) {
+            public Subscription subscribe(final Observer<? super String> observer) {
                 this.observer = observer;
                 return s;
             }
@@ -726,7 +726,7 @@ private static class TestErrorObservable extends Observable<String> {
             }
 
             @Override
-            public Subscription subscribe(Observer<String> observer) {
+            public Subscription subscribe(Observer<? super String> observer) {
                 boolean errorThrown = false;
                 for (String s : valuesToReturn) {
                     if (s == null) {
@@ -765,7 +765,7 @@ private static class TestAsyncErrorObservable extends Observable<String> {
             Thread t;
 
             @Override
-            public Subscription subscribe(final Observer<String> observer) {
+            public Subscription subscribe(final Observer<? super String> observer) {
                 t = new Thread(new Runnable() {
 
                     @Override
diff --git a/rxjava-core/src/main/java/rx/operators/OperationMostRecent.java b/rxjava-core/src/main/java/rx/operators/OperationMostRecent.java
index ce7e3dbbcc..0522234e0a 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationMostRecent.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationMostRecent.java
@@ -37,7 +37,7 @@
  */
 public final class OperationMostRecent {
 
-    public static <T> Iterable<T> mostRecent(final Observable<T> source, T initialValue) {
+    public static <T> Iterable<T> mostRecent(final Observable<? extends T> source, T initialValue) {
 
         MostRecentObserver<T> mostRecentObserver = new MostRecentObserver<T>(initialValue);
         final MostRecentIterator<T> nextIterator = new MostRecentIterator<T>(mostRecentObserver);
@@ -164,7 +164,7 @@ public void testMostRecentWithException() {
 
         private static class TestObservable extends Observable<String> {
 
-            Observer<String> observer = null;
+            Observer<? super String> observer = null;
             Subscription s;
 
             public TestObservable(Subscription s) {
@@ -187,7 +187,7 @@ public void sendOnError(Throwable e) {
             }
 
             @Override
-            public Subscription subscribe(final Observer<String> observer) {
+            public Subscription subscribe(final Observer<? super String> observer) {
                 this.observer = observer;
                 return s;
             }
diff --git a/rxjava-core/src/main/java/rx/operators/OperationMulticast.java b/rxjava-core/src/main/java/rx/operators/OperationMulticast.java
index 1961bd712c..7452819d99 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationMulticast.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationMulticast.java
@@ -28,22 +28,22 @@
 import rx.util.functions.Func1;
 
 public class OperationMulticast {
-    public static <T, R> ConnectableObservable<R> multicast(Observable<T> source, final Subject<T, R> subject) {
+    public static <T, R> ConnectableObservable<R> multicast(Observable<? extends T> source, final Subject<T, R> subject) {
         return new MulticastConnectableObservable<T, R>(source, subject);
     }
 
     private static class MulticastConnectableObservable<T, R> extends ConnectableObservable<R> {
         private final Object lock = new Object();
 
-        private final Observable<T> source;
+        private final Observable<? extends T> source;
         private final Subject<T, R> subject;
 
         private Subscription subscription;
 
-        public MulticastConnectableObservable(Observable<T> source, final Subject<T, R> subject) {
-            super(new Func1<Observer<R>, Subscription>() {
+        public MulticastConnectableObservable(Observable<? extends T> source, final Subject<T, R> subject) {
+            super(new Func1<Observer<? super R>, Subscription>() {
                 @Override
-                public Subscription call(Observer<R> observer) {
+                public Subscription call(Observer<? super R> observer) {
                     return subject.subscribe(observer);
                 }
             });
@@ -179,7 +179,7 @@ public void testMulticastDisconnect() {
 
         private static class TestObservable extends Observable<String> {
 
-            Observer<String> observer = new Observer<String>() {
+            Observer<? super String> observer = new Observer<String>() {
                 @Override
                 public void onCompleted() {
                     // Do nothing
@@ -231,7 +231,7 @@ public void sendOnNext(String value) {
             }
 
             @Override
-            public Subscription subscribe(final Observer<String> observer) {
+            public Subscription subscribe(final Observer<? super String> observer) {
                 this.observer = observer;
                 return s;
             }
diff --git a/rxjava-core/src/main/java/rx/operators/OperationNext.java b/rxjava-core/src/main/java/rx/operators/OperationNext.java
index 5c0a8a7553..bcb684ac85 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationNext.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationNext.java
@@ -48,7 +48,7 @@
  */
 public final class OperationNext {
 
-    public static <T> Iterable<T> next(final Observable<T> items) {
+    public static <T> Iterable<T> next(final Observable<? extends T> items) {
 
         NextObserver<T> nextObserver = new NextObserver<T>();
         final NextIterator<T> nextIterator = new NextIterator<T>(nextObserver);
@@ -66,9 +66,9 @@ public Iterator<T> iterator() {
 
     private static class NextIterator<T> implements Iterator<T> {
 
-        private final NextObserver<T> observer;
+        private final NextObserver<? extends T> observer;
 
-        private NextIterator(NextObserver<T> observer) {
+        private NextIterator(NextObserver<? extends T> observer) {
             this.observer = observer;
         }
 
@@ -100,8 +100,8 @@ public void remove() {
         }
     }
 
-    private static class NextObserver<T> implements Observer<Notification<T>> {
-        private final BlockingQueue<Notification<T>> buf = new ArrayBlockingQueue<Notification<T>>(1);
+    private static class NextObserver<T> implements Observer<Notification<? extends T>> {
+        private final BlockingQueue<Notification<? extends T>> buf = new ArrayBlockingQueue<Notification<? extends T>>(1);
         private final AtomicBoolean waiting = new AtomicBoolean(false);
 
         @Override
@@ -115,12 +115,12 @@ public void onError(Throwable e) {
         }
 
         @Override
-        public void onNext(Notification<T> args) {
+        public void onNext(Notification<? extends T> args) {
 
             if (waiting.getAndSet(false) || !args.isOnNext()) {
-                Notification<T> toOffer = args;
+                Notification<? extends T> toOffer = args;
                 while (!buf.offer(toOffer)) {
-                    Notification<T> concurrentItem = buf.poll();
+                    Notification<? extends T> concurrentItem = buf.poll();
 
                     // in case if we won race condition with onComplete/onError method
                     if (!concurrentItem.isOnNext()) {
@@ -136,7 +136,7 @@ public void await() {
         }
 
         public boolean isCompleted(boolean rethrowExceptionIfExists) {
-            Notification<T> lastItem = buf.peek();
+            Notification<? extends T> lastItem = buf.peek();
             if (lastItem == null) {
                 return false;
             }
@@ -153,7 +153,7 @@ public boolean isCompleted(boolean rethrowExceptionIfExists) {
         }
 
         public T takeNext() throws InterruptedException {
-            Notification<T> next = buf.take();
+            Notification<? extends T> next = buf.take();
 
             if (next.isOnError()) {
                 throw Exceptions.propagate(next.getThrowable());
@@ -269,7 +269,7 @@ public String call() throws Exception {
 
         private static class TestObservable extends Observable<String> {
 
-            Observer<String> observer = null;
+            Observer<? super String> observer = null;
             Subscription s;
 
             public TestObservable(Subscription s) {
@@ -292,7 +292,7 @@ public void sendOnError(Throwable e) {
             }
 
             @Override
-            public Subscription subscribe(final Observer<String> observer) {
+            public Subscription subscribe(final Observer<? super String> observer) {
                 this.observer = observer;
                 return s;
             }
@@ -318,10 +318,10 @@ public void testNoBufferingOrBlockingOfSequence() throws Throwable {
             final CountDownLatch timeHasPassed = new CountDownLatch(COUNT);
             final AtomicBoolean running = new AtomicBoolean(true);
             final AtomicInteger count = new AtomicInteger(0);
-            final Observable<Integer> obs = Observable.create(new Func1<Observer<Integer>, Subscription>() {
+            final Observable<Integer> obs = Observable.create(new Func1<Observer<? super Integer>, Subscription>() {
 
                 @Override
-                public Subscription call(final Observer<Integer> o) {
+                public Subscription call(final Observer<? super Integer> o) {
                     new Thread(new Runnable() {
 
                         @Override
diff --git a/rxjava-core/src/main/java/rx/operators/OperationObserveOn.java b/rxjava-core/src/main/java/rx/operators/OperationObserveOn.java
index 080773c32f..a36e342f75 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationObserveOn.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationObserveOn.java
@@ -41,21 +41,21 @@
  */
 public class OperationObserveOn {
 
-    public static <T> Func1<Observer<T>, Subscription> observeOn(Observable<T> source, Scheduler scheduler) {
+    public static <T> Func1<Observer<? super T>, Subscription> observeOn(Observable<? extends T> source, Scheduler scheduler) {
         return new ObserveOn<T>(source, scheduler);
     }
 
-    private static class ObserveOn<T> implements Func1<Observer<T>, Subscription> {
-        private final Observable<T> source;
+    private static class ObserveOn<T> implements Func1<Observer<? super T>, Subscription> {
+        private final Observable<? extends T> source;
         private final Scheduler scheduler;
 
-        public ObserveOn(Observable<T> source, Scheduler scheduler) {
+        public ObserveOn(Observable<? extends T> source, Scheduler scheduler) {
             this.source = source;
             this.scheduler = scheduler;
         }
 
         @Override
-        public Subscription call(final Observer<T> observer) {
+        public Subscription call(final Observer<? super T> observer) {
             if (scheduler instanceof ImmediateScheduler) {
                 // do nothing if we request ImmediateScheduler so we don't invoke overhead
                 return source.subscribe(observer);
diff --git a/rxjava-core/src/main/java/rx/operators/OperationOnErrorResumeNextViaFunction.java b/rxjava-core/src/main/java/rx/operators/OperationOnErrorResumeNextViaFunction.java
index 7110804dd9..12821d970b 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationOnErrorResumeNextViaFunction.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationOnErrorResumeNextViaFunction.java
@@ -53,21 +53,21 @@
  */
 public final class OperationOnErrorResumeNextViaFunction<T> {
 
-    public static <T> Func1<Observer<T>, Subscription> onErrorResumeNextViaFunction(Observable<T> originalSequence, Func1<Throwable, Observable<T>> resumeFunction) {
+    public static <T> Func1<Observer<? super T>, Subscription> onErrorResumeNextViaFunction(Observable<? extends T> originalSequence, Func1<Throwable, ? extends Observable<? extends T>> resumeFunction) {
         return new OnErrorResumeNextViaFunction<T>(originalSequence, resumeFunction);
     }
 
-    private static class OnErrorResumeNextViaFunction<T> implements Func1<Observer<T>, Subscription> {
+    private static class OnErrorResumeNextViaFunction<T> implements Func1<Observer<? super T>, Subscription> {
 
-        private final Func1<Throwable, Observable<T>> resumeFunction;
-        private final Observable<T> originalSequence;
+        private final Func1<Throwable, ? extends Observable<? extends T>> resumeFunction;
+        private final Observable<? extends T> originalSequence;
 
-        public OnErrorResumeNextViaFunction(Observable<T> originalSequence, Func1<Throwable, Observable<T>> resumeFunction) {
+        public OnErrorResumeNextViaFunction(Observable<? extends T> originalSequence, Func1<Throwable, ? extends Observable<? extends T>> resumeFunction) {
             this.resumeFunction = resumeFunction;
             this.originalSequence = originalSequence;
         }
 
-        public Subscription call(final Observer<T> observer) {
+        public Subscription call(final Observer<? super T> observer) {
             // AtomicReference since we'll be accessing/modifying this across threads so we can switch it if needed
             final AtomicReference<SafeObservableSubscription> subscriptionRef = new AtomicReference<SafeObservableSubscription>(new SafeObservableSubscription());
 
@@ -87,7 +87,7 @@ public void onError(Throwable ex) {
                     // check that we have not been unsubscribed before we can process the error
                     if (currentSubscription != null) {
                         try {
-                            Observable<T> resumeSequence = resumeFunction.call(ex);
+                            Observable<? extends T> resumeSequence = resumeFunction.call(ex);
                             /* error occurred, so switch subscription to the 'resumeSequence' */
                             SafeObservableSubscription innerSubscription = new SafeObservableSubscription(resumeSequence.subscribe(observer));
                             /* we changed the sequence, so also change the subscription to the one of the 'resumeSequence' instead */
@@ -127,10 +127,10 @@ public static class UnitTest {
         @Test
         public void testResumeNextWithSynchronousExecution() {
             final AtomicReference<Throwable> receivedException = new AtomicReference<Throwable>();
-            Observable<String> w = Observable.create(new Func1<Observer<String>, Subscription>() {
+            Observable<String> w = Observable.create(new Func1<Observer<? super String>, Subscription>() {
 
                 @Override
-                public Subscription call(Observer<String> observer) {
+                public Subscription call(Observer<? super String> observer) {
                     observer.onNext("one");
                     observer.onError(new Throwable("injected failure"));
                     return Subscriptions.empty();
@@ -245,7 +245,7 @@ public TestObservable(Subscription s, String... values) {
             }
 
             @Override
-            public Subscription subscribe(final Observer<String> observer) {
+            public Subscription subscribe(final Observer<? super String> observer) {
                 System.out.println("TestObservable subscribed to ...");
                 t = new Thread(new Runnable() {
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperationOnErrorResumeNextViaObservable.java b/rxjava-core/src/main/java/rx/operators/OperationOnErrorResumeNextViaObservable.java
index 4ea879bdb9..187f0bdd17 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationOnErrorResumeNextViaObservable.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationOnErrorResumeNextViaObservable.java
@@ -50,21 +50,21 @@
  */
 public final class OperationOnErrorResumeNextViaObservable<T> {
 
-    public static <T> Func1<Observer<T>, Subscription> onErrorResumeNextViaObservable(Observable<T> originalSequence, Observable<T> resumeSequence) {
+    public static <T> Func1<Observer<? super T>, Subscription> onErrorResumeNextViaObservable(Observable<? extends T> originalSequence, Observable<? extends T> resumeSequence) {
         return new OnErrorResumeNextViaObservable<T>(originalSequence, resumeSequence);
     }
 
-    private static class OnErrorResumeNextViaObservable<T> implements Func1<Observer<T>, Subscription> {
+    private static class OnErrorResumeNextViaObservable<T> implements Func1<Observer<? super T>, Subscription> {
 
-        private final Observable<T> resumeSequence;
-        private final Observable<T> originalSequence;
+        private final Observable<? extends T> resumeSequence;
+        private final Observable<? extends T> originalSequence;
 
-        public OnErrorResumeNextViaObservable(Observable<T> originalSequence, Observable<T> resumeSequence) {
+        public OnErrorResumeNextViaObservable(Observable<? extends T> originalSequence, Observable<? extends T> resumeSequence) {
             this.resumeSequence = resumeSequence;
             this.originalSequence = originalSequence;
         }
 
-        public Subscription call(final Observer<T> observer) {
+        public Subscription call(final Observer<? super T> observer) {
             final SafeObservableSubscription subscription = new SafeObservableSubscription();
 
             // AtomicReference since we'll be accessing/modifying this across threads so we can switch it if needed
@@ -197,7 +197,7 @@ public TestObservable(Subscription s, String... values) {
             }
 
             @Override
-            public Subscription subscribe(final Observer<String> observer) {
+            public Subscription subscribe(final Observer<? super String> observer) {
                 System.out.println("TestObservable subscribed to ...");
                 t = new Thread(new Runnable() {
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperationOnErrorReturn.java b/rxjava-core/src/main/java/rx/operators/OperationOnErrorReturn.java
index 81a242ec25..f4f6454e19 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationOnErrorReturn.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationOnErrorReturn.java
@@ -50,20 +50,20 @@
  */
 public final class OperationOnErrorReturn<T> {
 
-    public static <T> Func1<Observer<T>, Subscription> onErrorReturn(Observable<T> originalSequence, Func1<Throwable, T> resumeFunction) {
+    public static <T> Func1<Observer<? super T>, Subscription> onErrorReturn(Observable<? extends T> originalSequence, Func1<Throwable, ? extends T> resumeFunction) {
         return new OnErrorReturn<T>(originalSequence, resumeFunction);
     }
 
-    private static class OnErrorReturn<T> implements Func1<Observer<T>, Subscription> {
-        private final Func1<Throwable, T> resumeFunction;
-        private final Observable<T> originalSequence;
+    private static class OnErrorReturn<T> implements Func1<Observer<? super T>, Subscription> {
+        private final Func1<Throwable, ? extends T> resumeFunction;
+        private final Observable<? extends T> originalSequence;
 
-        public OnErrorReturn(Observable<T> originalSequence, Func1<Throwable, T> resumeFunction) {
+        public OnErrorReturn(Observable<? extends T> originalSequence, Func1<Throwable, ? extends T> resumeFunction) {
             this.resumeFunction = resumeFunction;
             this.originalSequence = originalSequence;
         }
 
-        public Subscription call(final Observer<T> observer) {
+        public Subscription call(final Observer<? super T> observer) {
             final SafeObservableSubscription subscription = new SafeObservableSubscription();
 
             // AtomicReference since we'll be accessing/modifying this across threads so we can switch it if needed
@@ -210,7 +210,7 @@ public TestObservable(Subscription s, String... values) {
             }
 
             @Override
-            public Subscription subscribe(final Observer<String> observer) {
+            public Subscription subscribe(final Observer<? super String> observer) {
                 System.out.println("TestObservable subscribed to ...");
                 t = new Thread(new Runnable() {
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperationOnExceptionResumeNextViaObservable.java b/rxjava-core/src/main/java/rx/operators/OperationOnExceptionResumeNextViaObservable.java
index 9f633d0a2f..53b72b474f 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationOnExceptionResumeNextViaObservable.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationOnExceptionResumeNextViaObservable.java
@@ -52,21 +52,21 @@
  */
 public final class OperationOnExceptionResumeNextViaObservable<T> {
 
-    public static <T> Func1<Observer<T>, Subscription> onExceptionResumeNextViaObservable(Observable<T> originalSequence, Observable<T> resumeSequence) {
+    public static <T> Func1<Observer<? super T>, Subscription> onExceptionResumeNextViaObservable(Observable<? extends T> originalSequence, Observable<? extends T> resumeSequence) {
         return new OnExceptionResumeNextViaObservable<T>(originalSequence, resumeSequence);
     }
 
-    private static class OnExceptionResumeNextViaObservable<T> implements Func1<Observer<T>, Subscription> {
+    private static class OnExceptionResumeNextViaObservable<T> implements Func1<Observer<? super T>, Subscription> {
 
-        private final Observable<T> resumeSequence;
-        private final Observable<T> originalSequence;
+        private final Observable<? extends T> resumeSequence;
+        private final Observable<? extends T> originalSequence;
 
-        public OnExceptionResumeNextViaObservable(Observable<T> originalSequence, Observable<T> resumeSequence) {
+        public OnExceptionResumeNextViaObservable(Observable<? extends T> originalSequence, Observable<? extends T> resumeSequence) {
             this.resumeSequence = resumeSequence;
             this.originalSequence = originalSequence;
         }
 
-        public Subscription call(final Observer<T> observer) {
+        public Subscription call(final Observer<? super T> observer) {
             final SafeObservableSubscription subscription = new SafeObservableSubscription();
 
             // AtomicReference since we'll be accessing/modifying this across threads so we can switch it if needed
@@ -292,7 +292,7 @@ public TestObservable(Subscription s, String... values) {
             }
 
             @Override
-            public Subscription subscribe(final Observer<String> observer) {
+            public Subscription subscribe(final Observer<? super String> observer) {
                 System.out.println("TestObservable subscribed to ...");
                 t = new Thread(new Runnable() {
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSample.java b/rxjava-core/src/main/java/rx/operators/OperationSample.java
index b389fed150..f980815550 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationSample.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationSample.java
@@ -48,19 +48,19 @@ public final class OperationSample {
     /**
      * Samples the observable sequence at each interval.
      */
-    public static <T> Func1<Observer<T>, Subscription> sample(final Observable<T> source, long period, TimeUnit unit) {
+    public static <T> Func1<Observer<? super T>, Subscription> sample(final Observable<? extends T> source, long period, TimeUnit unit) {
         return new Sample<T>(source, period, unit, Schedulers.executor(Executors.newSingleThreadScheduledExecutor()));
     }
 
     /**
      * Samples the observable sequence at each interval.
      */
-    public static <T> Func1<Observer<T>, Subscription> sample(final Observable<T> source, long period, TimeUnit unit, Scheduler scheduler) {
+    public static <T> Func1<Observer<? super T>, Subscription> sample(final Observable<? extends T> source, long period, TimeUnit unit, Scheduler scheduler) {
         return new Sample<T>(source, period, unit, scheduler);
     }
     
-    private static class Sample<T> implements Func1<Observer<T>, Subscription> {
-        private final Observable<T> source;
+    private static class Sample<T> implements Func1<Observer<? super T>, Subscription> {
+        private final Observable<? extends T> source;
         private final long period;
         private final TimeUnit unit;
         private final Scheduler scheduler;
@@ -68,7 +68,7 @@ private static class Sample<T> implements Func1<Observer<T>, Subscription> {
         private final AtomicBoolean hasValue = new AtomicBoolean();
         private final AtomicReference<T> latestValue = new AtomicReference<T>();
         
-        private Sample(Observable<T> source, long interval, TimeUnit unit, Scheduler scheduler) {
+        private Sample(Observable<? extends T> source, long interval, TimeUnit unit, Scheduler scheduler) {
             this.source = source;
             this.period = interval;
             this.unit = unit;
@@ -76,7 +76,7 @@ private Sample(Observable<T> source, long interval, TimeUnit unit, Scheduler sch
         }
 
         @Override
-        public Subscription call(final Observer<T> observer) {
+        public Subscription call(final Observer<? super T> observer) {
             Observable<Long> clock = Observable.create(OperationInterval.interval(period, unit, scheduler));
             final Subscription clockSubscription = clock.subscribe(new Observer<Long>() {
                 @Override
@@ -136,9 +136,9 @@ public void before() {
         
         @Test
         public void testSample() {
-            Observable<Long> source = Observable.create(new Func1<Observer<Long>, Subscription>() {
+            Observable<Long> source = Observable.create(new Func1<Observer<? super Long>, Subscription>() {
                 @Override
-                public Subscription call(final Observer<Long> observer1) {
+                public Subscription call(final Observer<? super Long> observer1) {
                     scheduler.schedule(new Action0() {
                         @Override
                         public void call() {
diff --git a/rxjava-core/src/main/java/rx/operators/OperationScan.java b/rxjava-core/src/main/java/rx/operators/OperationScan.java
index 24cb6ea66f..b2d0bd3037 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationScan.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationScan.java
@@ -55,7 +55,7 @@ public final class OperationScan {
      * @return An observable sequence whose elements are the result of accumulating the output from the list of Observables.
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh212007%28v=vs.103%29.aspx">Observable.Scan(TSource, TAccumulate) Method (IObservable(TSource), TAccumulate, Func(TAccumulate, TSource, TAccumulate))</a>
      */
-    public static <T, R> Func1<Observer<R>, Subscription> scan(Observable<T> sequence, R initialValue, Func2<R, T, R> accumulator) {
+    public static <T, R> Func1<Observer<? super R>, Subscription> scan(Observable<? extends T> sequence, R initialValue, Func2<? super R, ? super T, ? extends R> accumulator) {
         return new Accumulator<T, R>(sequence, initialValue, accumulator);
     }
 
@@ -70,23 +70,23 @@ public static <T, R> Func1<Observer<R>, Subscription> scan(Observable<T> sequenc
      * @return An observable sequence whose elements are the result of accumulating the output from the list of Observables.
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh211665(v=vs.103).aspx">Observable.Scan(TSource) Method (IObservable(TSource), Func(TSource, TSource, TSource))</a>
      */
-    public static <T> Func1<Observer<T>, Subscription> scan(Observable<T> sequence, Func2<T, T, T> accumulator) {
+    public static <T> Func1<Observer<? super T>, Subscription> scan(Observable<? extends T> sequence, Func2<? super T, ? super T, ? extends T> accumulator) {
         return new AccuWithoutInitialValue<T>(sequence, accumulator);
     }
 
-    private static class AccuWithoutInitialValue<T> implements Func1<Observer<T>, Subscription> {
-        private final Observable<T> sequence;
-        private final Func2<T, T, T> accumulatorFunction;
+    private static class AccuWithoutInitialValue<T> implements Func1<Observer<? super T>, Subscription> {
+        private final Observable<? extends T> sequence;
+        private final Func2<? super T, ? super T, ? extends T> accumulatorFunction;
         
         private AccumulatingObserver<T, T> accumulatingObserver;
         
-        private AccuWithoutInitialValue(Observable<T> sequence, Func2<T, T, T> accumulator) {
+        private AccuWithoutInitialValue(Observable<? extends T> sequence, Func2<? super T, ? super T, ? extends T> accumulator) {
             this.sequence = sequence;
             this.accumulatorFunction = accumulator;
         }
         
         @Override
-        public Subscription call(final Observer<T> observer) {
+        public Subscription call(final Observer<? super T> observer) {
             return sequence.subscribe(new Observer<T>() {
                 
                 // has to be synchronized so that the initial value is always sent only once.
@@ -113,31 +113,31 @@ public void onCompleted() {
         }
     }
     
-    private static class Accumulator<T, R> implements Func1<Observer<R>, Subscription> {
-        private final Observable<T> sequence;
+    private static class Accumulator<T, R> implements Func1<Observer<? super R>, Subscription> {
+        private final Observable<? extends T> sequence;
         private final R initialValue;
-        private final Func2<R, T, R> accumulatorFunction;
+        private final Func2<? super R, ? super T, ? extends R> accumulatorFunction;
 
-        private Accumulator(Observable<T> sequence, R initialValue, Func2<R, T, R> accumulator) {
+        private Accumulator(Observable<? extends T> sequence, R initialValue, Func2<? super R, ? super T, ? extends R> accumulator) {
             this.sequence = sequence;
             this.initialValue = initialValue;
             this.accumulatorFunction = accumulator;
         }
 
         @Override
-        public Subscription call(final Observer<R> observer) {
+        public Subscription call(final Observer<? super R> observer) {
             observer.onNext(initialValue);
             return sequence.subscribe(new AccumulatingObserver<T, R>(observer, initialValue, accumulatorFunction));
         }
     }
 
     private static class AccumulatingObserver<T, R> implements Observer<T> {
-        private final Observer<R> observer;
-        private final Func2<R, T, R> accumulatorFunction;
+        private final Observer<? super R> observer;
+        private final Func2<? super R, ? super T, ? extends R> accumulatorFunction;
 
         private R acc;
 
-        private AccumulatingObserver(Observer<R> observer, R initialValue, Func2<R, T, R> accumulator) {
+        private AccumulatingObserver(Observer<? super R> observer, R initialValue, Func2<? super R, ? super T, ? extends R> accumulator) {
             this.observer = observer;
             this.accumulatorFunction = accumulator;
             
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSkip.java b/rxjava-core/src/main/java/rx/operators/OperationSkip.java
index c238b2d2ae..3be0c3a705 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationSkip.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationSkip.java
@@ -47,12 +47,12 @@ public final class OperationSkip {
      * 
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229847(v=vs.103).aspx">Observable.Skip(TSource) Method</a>
      */
-    public static <T> Func1<Observer<T>, Subscription> skip(final Observable<T> items, final int num) {
+    public static <T> Func1<Observer<? super T>, Subscription> skip(final Observable<? extends T> items, final int num) {
         // wrap in a Observable so that if a chain is built up, then asynchronously subscribed to twice we will have 2 instances of Take<T> rather than 1 handing both, which is not thread-safe.
-        return new Func1<Observer<T>, Subscription>() {
+        return new Func1<Observer<? super T>, Subscription>() {
 
             @Override
-            public Subscription call(Observer<T> observer) {
+            public Subscription call(Observer<? super T> observer) {
                 return new Skip<T>(items, num).call(observer);
             }
 
@@ -66,16 +66,16 @@ public Subscription call(Observer<T> observer) {
      * 
      * @param <T>
      */
-    private static class Skip<T> implements Func1<Observer<T>, Subscription> {
+    private static class Skip<T> implements Func1<Observer<? super T>, Subscription> {
         private final int num;
-        private final Observable<T> items;
+        private final Observable<? extends T> items;
 
-        Skip(final Observable<T> items, final int num) {
+        Skip(final Observable<? extends T> items, final int num) {
             this.num = num;
             this.items = items;
         }
 
-        public Subscription call(Observer<T> observer) {
+        public Subscription call(Observer<? super T> observer) {
             return items.subscribe(new ItemObserver(observer));
         }
 
@@ -85,9 +85,9 @@ public Subscription call(Observer<T> observer) {
         private class ItemObserver implements Observer<T> {
 
             private AtomicInteger counter = new AtomicInteger();
-            private final Observer<T> observer;
+            private final Observer<? super T> observer;
 
-            public ItemObserver(Observer<T> observer) {
+            public ItemObserver(Observer<? super T> observer) {
                 this.observer = observer;
             }
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSubscribeOn.java b/rxjava-core/src/main/java/rx/operators/OperationSubscribeOn.java
index 6cf73580aa..a197de7a3c 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationSubscribeOn.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationSubscribeOn.java
@@ -36,21 +36,21 @@
  */
 public class OperationSubscribeOn {
 
-    public static <T> Func1<Observer<T>, Subscription> subscribeOn(Observable<T> source, Scheduler scheduler) {
+    public static <T> Func1<Observer<? super T>, Subscription> subscribeOn(Observable<? extends T> source, Scheduler scheduler) {
         return new SubscribeOn<T>(source, scheduler);
     }
 
-    private static class SubscribeOn<T> implements Func1<Observer<T>, Subscription> {
-        private final Observable<T> source;
+    private static class SubscribeOn<T> implements Func1<Observer<? super T>, Subscription> {
+        private final Observable<? extends T> source;
         private final Scheduler scheduler;
 
-        public SubscribeOn(Observable<T> source, Scheduler scheduler) {
+        public SubscribeOn(Observable<? extends T> source, Scheduler scheduler) {
             this.source = source;
             this.scheduler = scheduler;
         }
 
         @Override
-        public Subscription call(final Observer<T> observer) {
+        public Subscription call(final Observer<? super T> observer) {
             return scheduler.schedule(null, new Func2<Scheduler, T, Subscription>() {
                 @Override
                 public Subscription call(Scheduler s, T t) {
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSwitch.java b/rxjava-core/src/main/java/rx/operators/OperationSwitch.java
index 55d7b94a29..b59ed3cdf2 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationSwitch.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationSwitch.java
@@ -49,38 +49,38 @@ public final class OperationSwitch {
      *            The {@link Observable} sequence consisting of {@link Observable} sequences.
      * @return A {@link Func1} which does this transformation.
      */
-    public static <T> Func1<Observer<T>, Subscription> switchDo(final Observable<Observable<T>> sequences) {
-        return new Func1<Observer<T>, Subscription>() {
+    public static <T> Func1<Observer<? super T>, Subscription> switchDo(final Observable<? extends Observable<? extends T>> sequences) {
+        return new Func1<Observer<? super T>, Subscription>() {
             @Override
-            public Subscription call(Observer<T> observer) {
+            public Subscription call(Observer<? super T> observer) {
                 return new Switch<T>(sequences).call(observer);
             }
         };
     }
 
-    private static class Switch<T> implements Func1<Observer<T>, Subscription> {
+    private static class Switch<T> implements Func1<Observer<? super T>, Subscription> {
 
-        private final Observable<Observable<T>> sequences;
+        private final Observable<? extends Observable<? extends T>> sequences;
 
-        public Switch(Observable<Observable<T>> sequences) {
+        public Switch(Observable<? extends Observable<? extends T>> sequences) {
             this.sequences = sequences;
         }
 
         @Override
-        public Subscription call(Observer<T> observer) {
+        public Subscription call(Observer<? super T> observer) {
             SafeObservableSubscription subscription = new SafeObservableSubscription();
             subscription.wrap(sequences.subscribe(new SwitchObserver<T>(observer, subscription)));
             return subscription;
         }
     }
 
-    private static class SwitchObserver<T> implements Observer<Observable<T>> {
+    private static class SwitchObserver<T> implements Observer<Observable<? extends T>> {
 
-        private final Observer<T> observer;
+        private final Observer<? super T> observer;
         private final SafeObservableSubscription parent;
         private final AtomicReference<Subscription> subsequence = new AtomicReference<Subscription>();
 
-        public SwitchObserver(Observer<T> observer, SafeObservableSubscription parent) {
+        public SwitchObserver(Observer<? super T> observer, SafeObservableSubscription parent) {
             this.observer = observer;
             this.parent = parent;
         }
@@ -98,7 +98,7 @@ public void onError(Throwable e) {
         }
 
         @Override
-        public void onNext(Observable<T> args) {
+        public void onNext(Observable<? extends T> args) {
             unsubscribeFromSubSequence();
 
             subsequence.set(args.subscribe(new Observer<T>() {
@@ -142,21 +142,21 @@ public void before() {
 
         @Test
         public void testSwitchWithComplete() {
-            Observable<Observable<String>> source = Observable.create(new Func1<Observer<Observable<String>>, Subscription>() {
+            Observable<Observable<String>> source = Observable.create(new Func1<Observer<? super Observable<String>>, Subscription>() {
                 @Override
-                public Subscription call(Observer<Observable<String>> observer) {
-                    publishNext(observer, 50, Observable.create(new Func1<Observer<String>, Subscription>() {
+                public Subscription call(Observer<? super Observable<String>> observer) {
+                    publishNext(observer, 50, Observable.create(new Func1<Observer<? super String>, Subscription>() {
                         @Override
-                        public Subscription call(Observer<String> observer) {
+                        public Subscription call(Observer<? super String> observer) {
                             publishNext(observer, 50, "one");
                             publishNext(observer, 100, "two");
                             return Subscriptions.empty();
                         }
                     }));
 
-                    publishNext(observer, 200, Observable.create(new Func1<Observer<String>, Subscription>() {
+                    publishNext(observer, 200, Observable.create(new Func1<Observer<? super String>, Subscription>() {
                         @Override
-                        public Subscription call(Observer<String> observer) {
+                        public Subscription call(Observer<? super String> observer) {
                             publishNext(observer, 0, "three");
                             publishNext(observer, 100, "four");
                             return Subscriptions.empty();
@@ -202,21 +202,21 @@ public Subscription call(Observer<String> observer) {
 
         @Test
         public void testSwitchWithError() {
-            Observable<Observable<String>> source = Observable.create(new Func1<Observer<Observable<String>>, Subscription>() {
+            Observable<Observable<String>> source = Observable.create(new Func1<Observer<? super Observable<String>>, Subscription>() {
                 @Override
-                public Subscription call(Observer<Observable<String>> observer) {
-                    publishNext(observer, 50, Observable.create(new Func1<Observer<String>, Subscription>() {
+                public Subscription call(Observer<? super Observable<String>> observer) {
+                    publishNext(observer, 50, Observable.create(new Func1<Observer<? super String>, Subscription>() {
                         @Override
-                        public Subscription call(Observer<String> observer) {
+                        public Subscription call(Observer<? super String> observer) {
                             publishNext(observer, 50, "one");
                             publishNext(observer, 100, "two");
                             return Subscriptions.empty();
                         }
                     }));
 
-                    publishNext(observer, 200, Observable.create(new Func1<Observer<String>, Subscription>() {
+                    publishNext(observer, 200, Observable.create(new Func1<Observer<? super String>, Subscription>() {
                         @Override
-                        public Subscription call(Observer<String> observer) {
+                        public Subscription call(Observer<? super String> observer) {
                             publishNext(observer, 0, "three");
                             publishNext(observer, 100, "four");
                             return Subscriptions.empty();
@@ -262,29 +262,29 @@ public Subscription call(Observer<String> observer) {
 
         @Test
         public void testSwitchWithSubsequenceComplete() {
-            Observable<Observable<String>> source = Observable.create(new Func1<Observer<Observable<String>>, Subscription>() {
+            Observable<Observable<String>> source = Observable.create(new Func1<Observer<? super Observable<String>>, Subscription>() {
                 @Override
-                public Subscription call(Observer<Observable<String>> observer) {
-                    publishNext(observer, 50, Observable.create(new Func1<Observer<String>, Subscription>() {
+                public Subscription call(Observer<? super Observable<String>> observer) {
+                    publishNext(observer, 50, Observable.create(new Func1<Observer<? super String>, Subscription>() {
                         @Override
-                        public Subscription call(Observer<String> observer) {
+                        public Subscription call(Observer<? super String> observer) {
                             publishNext(observer, 50, "one");
                             publishNext(observer, 100, "two");
                             return Subscriptions.empty();
                         }
                     }));
 
-                    publishNext(observer, 130, Observable.create(new Func1<Observer<String>, Subscription>() {
+                    publishNext(observer, 130, Observable.create(new Func1<Observer<? super String>, Subscription>() {
                         @Override
-                        public Subscription call(Observer<String> observer) {
+                        public Subscription call(Observer<? super String> observer) {
                             publishCompleted(observer, 0);
                             return Subscriptions.empty();
                         }
                     }));
 
-                    publishNext(observer, 150, Observable.create(new Func1<Observer<String>, Subscription>() {
+                    publishNext(observer, 150, Observable.create(new Func1<Observer<? super String>, Subscription>() {
                         @Override
-                        public Subscription call(Observer<String> observer) {
+                        public Subscription call(Observer<? super String> observer) {
                             publishNext(observer, 50, "three");
                             return Subscriptions.empty();
                         }
@@ -317,29 +317,29 @@ public Subscription call(Observer<String> observer) {
 
         @Test
         public void testSwitchWithSubsequenceError() {
-            Observable<Observable<String>> source = Observable.create(new Func1<Observer<Observable<String>>, Subscription>() {
+            Observable<Observable<String>> source = Observable.create(new Func1<Observer<? super Observable<String>>, Subscription>() {
                 @Override
-                public Subscription call(Observer<Observable<String>> observer) {
-                    publishNext(observer, 50, Observable.create(new Func1<Observer<String>, Subscription>() {
+                public Subscription call(Observer<? super Observable<String>> observer) {
+                    publishNext(observer, 50, Observable.create(new Func1<Observer<? super String>, Subscription>() {
                         @Override
-                        public Subscription call(Observer<String> observer) {
+                        public Subscription call(Observer<? super String> observer) {
                             publishNext(observer, 50, "one");
                             publishNext(observer, 100, "two");
                             return Subscriptions.empty();
                         }
                     }));
 
-                    publishNext(observer, 130, Observable.create(new Func1<Observer<String>, Subscription>() {
+                    publishNext(observer, 130, Observable.create(new Func1<Observer<? super String>, Subscription>() {
                         @Override
-                        public Subscription call(Observer<String> observer) {
+                        public Subscription call(Observer<? super String> observer) {
                             publishError(observer, 0, new TestException());
                             return Subscriptions.empty();
                         }
                     }));
 
-                    publishNext(observer, 150, Observable.create(new Func1<Observer<String>, Subscription>() {
+                    publishNext(observer, 150, Observable.create(new Func1<Observer<? super String>, Subscription>() {
                         @Override
-                        public Subscription call(Observer<String> observer) {
+                        public Subscription call(Observer<? super String> observer) {
                             publishNext(observer, 50, "three");
                             return Subscriptions.empty();
                         }
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSynchronize.java b/rxjava-core/src/main/java/rx/operators/OperationSynchronize.java
index b182063038..d559576552 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationSynchronize.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationSynchronize.java
@@ -57,20 +57,20 @@ public final class OperationSynchronize<T> {
      * @param <T>
      * @return the wrapped synchronized observable sequence
      */
-    public static <T> Func1<Observer<T>, Subscription> synchronize(Observable<T> observable) {
+    public static <T> Func1<Observer<? super T>, Subscription> synchronize(Observable<? extends T> observable) {
         return new Synchronize<T>(observable);
     }
 
-    private static class Synchronize<T> implements Func1<Observer<T>, Subscription> {
+    private static class Synchronize<T> implements Func1<Observer<? super T>, Subscription> {
 
-        public Synchronize(Observable<T> innerObservable) {
+        public Synchronize(Observable<? extends T> innerObservable) {
             this.innerObservable = innerObservable;
         }
 
-        private Observable<T> innerObservable;
+        private Observable<? extends T> innerObservable;
         private SynchronizedObserver<T> atomicObserver;
 
-        public Subscription call(Observer<T> observer) {
+        public Subscription call(Observer<? super T> observer) {
             SafeObservableSubscription subscription = new SafeObservableSubscription();
             atomicObserver = new SynchronizedObserver<T>(observer, subscription);
             return subscription.wrap(innerObservable.subscribe(atomicObserver));
@@ -234,7 +234,7 @@ public void testOnErrorAfterOnCompleted() {
          */
         private static class TestObservable extends Observable<String> {
 
-            Observer<String> observer = null;
+            Observer<? super String> observer = null;
 
             public TestObservable(Subscription s) {
             }
@@ -255,7 +255,7 @@ public void sendOnError(Throwable e) {
             }
 
             @Override
-            public Subscription subscribe(final Observer<String> observer) {
+            public Subscription subscribe(final Observer<? super String> observer) {
                 this.observer = observer;
                 return new Subscription() {
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperationTake.java b/rxjava-core/src/main/java/rx/operators/OperationTake.java
index 5359688e02..637fa15658 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationTake.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationTake.java
@@ -50,12 +50,12 @@ public final class OperationTake {
      * @param num
      * @return the specified number of contiguous values from the start of the given observable sequence
      */
-    public static <T> Func1<Observer<T>, Subscription> take(final Observable<T> items, final int num) {
+    public static <T> Func1<Observer<? super T>, Subscription> take(final Observable<? extends T> items, final int num) {
         // wrap in a Func so that if a chain is built up, then asynchronously subscribed to twice we will have 2 instances of Take<T> rather than 1 handing both, which is not thread-safe.
-        return new Func1<Observer<T>, Subscription>() {
+        return new Func1<Observer<? super T>, Subscription>() {
 
             @Override
-            public Subscription call(Observer<T> observer) {
+            public Subscription call(Observer<? super T> observer) {
                 return new Take<T>(items, num).call(observer);
             }
 
@@ -73,18 +73,18 @@ public Subscription call(Observer<T> observer) {
      * 
      * @param <T>
      */
-    private static class Take<T> implements Func1<Observer<T>, Subscription> {
-        private final Observable<T> items;
+    private static class Take<T> implements Func1<Observer<? super T>, Subscription> {
+        private final Observable<? extends T> items;
         private final int num;
         private final SafeObservableSubscription subscription = new SafeObservableSubscription();
 
-        private Take(Observable<T> items, int num) {
+        private Take(Observable<? extends T> items, int num) {
             this.items = items;
             this.num = num;
         }
 
         @Override
-        public Subscription call(Observer<T> observer) {
+        public Subscription call(Observer<? super T> observer) {
             if (num < 1) {
                 items.subscribe(new Observer<T>()
                 {
@@ -111,11 +111,11 @@ public void onNext(T args)
         }
 
         private class ItemObserver implements Observer<T> {
-            private final Observer<T> observer;
+            private final Observer<? super T> observer;
 
             private final AtomicInteger counter = new AtomicInteger();
 
-            public ItemObserver(Observer<T> observer) {
+            public ItemObserver(Observer<? super T> observer) {
                 this.observer = observer;
             }
 
@@ -186,10 +186,10 @@ public void testTake2() {
 
         @Test
         public void testTakeDoesntLeakErrors() {
-            Observable<String> source = Observable.create(new Func1<Observer<String>, Subscription>()
+            Observable<String> source = Observable.create(new Func1<Observer<? super String>, Subscription>()
             {
                 @Override
-                public Subscription call(Observer<String> observer)
+                public Subscription call(Observer<? super String> observer)
                 {
                     observer.onNext("one");
                     observer.onError(new Throwable("test failed"));
@@ -213,10 +213,10 @@ public Subscription call(Observer<String> observer)
         public void testTakeZeroDoesntLeakError() {
             final AtomicBoolean subscribed = new AtomicBoolean(false);
             final AtomicBoolean unSubscribed = new AtomicBoolean(false);
-            Observable<String> source = Observable.create(new Func1<Observer<String>, Subscription>()
+            Observable<String> source = Observable.create(new Func1<Observer<? super String>, Subscription>()
             {
                 @Override
-                public Subscription call(Observer<String> observer)
+                public Subscription call(Observer<? super String> observer)
                 {
                     subscribed.set(true);
                     observer.onError(new Throwable("test failed"));
@@ -284,7 +284,7 @@ public TestObservable(Subscription s, String... values) {
             }
 
             @Override
-            public Subscription subscribe(final Observer<String> observer) {
+            public Subscription subscribe(final Observer<? super String> observer) {
                 System.out.println("TestObservable subscribed to ...");
                 t = new Thread(new Runnable() {
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperationTakeLast.java b/rxjava-core/src/main/java/rx/operators/OperationTakeLast.java
index 2abe8381b7..eb4ee4ba0f 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationTakeLast.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationTakeLast.java
@@ -37,37 +37,37 @@
  */
 public final class OperationTakeLast {
 
-    public static <T> Func1<Observer<T>, Subscription> takeLast(final Observable<T> items, final int count) {
-        return new Func1<Observer<T>, Subscription>() {
+    public static <T> Func1<Observer<? super T>, Subscription> takeLast(final Observable<? extends T> items, final int count) {
+        return new Func1<Observer<? super T>, Subscription>() {
 
             @Override
-            public Subscription call(Observer<T> observer) {
+            public Subscription call(Observer<? super T> observer) {
                 return new TakeLast<T>(items, count).call(observer);
             }
 
         };
     }
 
-    private static class TakeLast<T> implements Func1<Observer<T>, Subscription> {
+    private static class TakeLast<T> implements Func1<Observer<? super T>, Subscription> {
         private final int count;
-        private final Observable<T> items;
+        private final Observable<? extends T> items;
         private final SafeObservableSubscription subscription = new SafeObservableSubscription();
 
-        TakeLast(final Observable<T> items, final int count) {
+        TakeLast(final Observable<? extends T> items, final int count) {
             this.count = count;
             this.items = items;
         }
 
-        public Subscription call(Observer<T> observer) {
+        public Subscription call(Observer<? super T> observer) {
             return subscription.wrap(items.subscribe(new ItemObserver(observer)));
         }
 
         private class ItemObserver implements Observer<T> {
 
             private LinkedBlockingDeque<T> deque = new LinkedBlockingDeque<T>(count);
-            private final Observer<T> observer;
+            private final Observer<? super T> observer;
 
-            public ItemObserver(Observer<T> observer) {
+            public ItemObserver(Observer<? super T> observer) {
                 this.observer = observer;
             }
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperationTakeUntil.java b/rxjava-core/src/main/java/rx/operators/OperationTakeUntil.java
index fb33a08642..3f36053fb3 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationTakeUntil.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationTakeUntil.java
@@ -45,7 +45,7 @@ public class OperationTakeUntil {
      *            the other type.
      * @return An observable sequence containing the elements of the source sequence up to the point the other sequence interrupted further propagation.
      */
-    public static <T, E> Observable<T> takeUntil(final Observable<T> source, final Observable<E> other) {
+    public static <T, E> Observable<T> takeUntil(final Observable<? extends T> source, final Observable<? extends E> other) {
         Observable<Notification<T>> s = Observable.create(new SourceObservable<T>(source));
         Observable<Notification<T>> o = Observable.create(new OtherObservable<T, E>(other));
 
@@ -89,15 +89,15 @@ private Notification(boolean halt, T value) {
 
     }
 
-    private static class SourceObservable<T> implements Func1<Observer<Notification<T>>, Subscription> {
-        private final Observable<T> sequence;
+    private static class SourceObservable<T> implements Func1<Observer<? super Notification<T>>, Subscription> {
+        private final Observable<? extends T> sequence;
 
-        private SourceObservable(Observable<T> sequence) {
+        private SourceObservable(Observable<? extends T> sequence) {
             this.sequence = sequence;
         }
 
         @Override
-        public Subscription call(final Observer<Notification<T>> notificationObserver) {
+        public Subscription call(final Observer<? super Notification<T>> notificationObserver) {
             return sequence.subscribe(new Observer<T>() {
                 @Override
                 public void onCompleted() {
@@ -117,15 +117,15 @@ public void onNext(T args) {
         }
     }
 
-    private static class OtherObservable<T, E> implements Func1<Observer<Notification<T>>, Subscription> {
-        private final Observable<E> sequence;
+    private static class OtherObservable<T, E> implements Func1<Observer<? super Notification<T>>, Subscription> {
+        private final Observable<? extends E> sequence;
 
-        private OtherObservable(Observable<E> sequence) {
+        private OtherObservable(Observable<? extends E> sequence) {
             this.sequence = sequence;
         }
 
         @Override
-        public Subscription call(final Observer<Notification<T>> notificationObserver) {
+        public Subscription call(final Observer<? super Notification<T>> notificationObserver) {
             return sequence.subscribe(new Observer<E>() {
                 @Override
                 public void onCompleted() {
@@ -270,7 +270,7 @@ public void testTakeUntilOtherCompleted() {
 
         private static class TestObservable extends Observable<String> {
 
-            Observer<String> observer = null;
+            Observer<? super String> observer = null;
             Subscription s;
 
             public TestObservable(Subscription s) {
@@ -293,7 +293,7 @@ public void sendOnError(Throwable e) {
             }
 
             @Override
-            public Subscription subscribe(final Observer<String> observer) {
+            public Subscription subscribe(final Observer<? super String> observer) {
                 this.observer = observer;
                 return s;
             }
diff --git a/rxjava-core/src/main/java/rx/operators/OperationTakeWhile.java b/rxjava-core/src/main/java/rx/operators/OperationTakeWhile.java
index 12038e72b0..f33dd69e7e 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationTakeWhile.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationTakeWhile.java
@@ -48,7 +48,7 @@ public final class OperationTakeWhile {
      *            a function to test each source element for a condition
      * @return sequence of observable values from the start as long as the predicate is true
      */
-    public static <T> Func1<Observer<T>, Subscription> takeWhile(final Observable<T> items, final Func1<T, Boolean> predicate) {
+    public static <T> Func1<Observer<? super T>, Subscription> takeWhile(final Observable<? extends T> items, final Func1<? super T, Boolean> predicate) {
         return takeWhileWithIndex(items, OperationTakeWhile.<T> skipIndex(predicate));
     }
 
@@ -60,19 +60,19 @@ public static <T> Func1<Observer<T>, Subscription> takeWhile(final Observable<T>
      *            a function to test each element for a condition; the second parameter of the function represents the index of the source element; otherwise, false.
      * @return sequence of observable values from the start as long as the predicate is true
      */
-    public static <T> Func1<Observer<T>, Subscription> takeWhileWithIndex(final Observable<T> items, final Func2<T, Integer, Boolean> predicate) {
+    public static <T> Func1<Observer<? super T>, Subscription> takeWhileWithIndex(final Observable<? extends T> items, final Func2<? super T, ? super Integer, Boolean> predicate) {
         // wrap in a Func so that if a chain is built up, then asynchronously subscribed to twice we will have 2 instances of Take<T> rather than 1 handing both, which is not thread-safe.
-        return new Func1<Observer<T>, Subscription>() {
+        return new Func1<Observer<? super T>, Subscription>() {
 
             @Override
-            public Subscription call(Observer<T> observer) {
+            public Subscription call(Observer<? super T> observer) {
                 return new TakeWhile<T>(items, predicate).call(observer);
             }
 
         };
     }
 
-    private static <T> Func2<T, Integer, Boolean> skipIndex(final Func1<T, Boolean> underlying) {
+    private static <T> Func2<T, Integer, Boolean> skipIndex(final Func1<? super T, Boolean> underlying) {
         return new Func2<T, Integer, Boolean>() {
             @Override
             public Boolean call(T input, Integer index) {
@@ -92,27 +92,27 @@ public Boolean call(T input, Integer index) {
      * 
      * @param <T>
      */
-    private static class TakeWhile<T> implements Func1<Observer<T>, Subscription> {
-        private final Observable<T> items;
-        private final Func2<T, Integer, Boolean> predicate;
+    private static class TakeWhile<T> implements Func1<Observer<? super T>, Subscription> {
+        private final Observable<? extends T> items;
+        private final Func2<? super T, ? super Integer, Boolean> predicate;
         private final SafeObservableSubscription subscription = new SafeObservableSubscription();
 
-        private TakeWhile(Observable<T> items, Func2<T, Integer, Boolean> predicate) {
+        private TakeWhile(Observable<? extends T> items, Func2<? super T, ? super Integer, Boolean> predicate) {
             this.items = items;
             this.predicate = predicate;
         }
 
         @Override
-        public Subscription call(Observer<T> observer) {
+        public Subscription call(Observer<? super T> observer) {
             return subscription.wrap(items.subscribe(new ItemObserver(observer)));
         }
 
         private class ItemObserver implements Observer<T> {
-            private final Observer<T> observer;
+            private final Observer<? super T> observer;
 
             private final AtomicInteger counter = new AtomicInteger();
 
-            public ItemObserver(Observer<T> observer) {
+            public ItemObserver(Observer<? super T> observer) {
                 // Using AtomicObserver because the unsubscribe, onCompleted, onError and error handling behavior
                 // needs "isFinished" logic to not send duplicated events
                 // The 'testTakeWhile1' and 'testTakeWhile2' tests fail without this.
@@ -231,10 +231,10 @@ public Boolean call(String input, Integer index)
 
         @Test
         public void testTakeWhileDoesntLeakErrors() {
-            Observable<String> source = Observable.create(new Func1<Observer<String>, Subscription>()
+            Observable<String> source = Observable.create(new Func1<Observer<? super String>, Subscription>()
             {
                 @Override
-                public Subscription call(Observer<String> observer)
+                public Subscription call(Observer<? super String> observer)
                 {
                     observer.onNext("one");
                     observer.onError(new Throwable("test failed"));
@@ -325,7 +325,7 @@ public TestObservable(Subscription s, String... values) {
             }
 
             @Override
-            public Subscription subscribe(final Observer<String> observer) {
+            public Subscription subscribe(final Observer<? super String> observer) {
                 System.out.println("TestObservable subscribed to ...");
                 t = new Thread(new Runnable() {
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperationTimestamp.java b/rxjava-core/src/main/java/rx/operators/OperationTimestamp.java
index 0b3dc7536c..5072801b82 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationTimestamp.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationTimestamp.java
@@ -37,7 +37,7 @@ public final class OperationTimestamp {
      *            the type of the input sequence.
      * @return a sequence of timestamped values created by adding timestamps to each item in the input sequence.
      */
-    public static <T> Func1<Observer<Timestamped<T>>, Subscription> timestamp(Observable<T> sequence) {
+    public static <T> Func1<Observer<? super Timestamped<T>>, Subscription> timestamp(Observable<? extends T> sequence) {
         return OperationMap.map(sequence, new Func1<T, Timestamped<T>>() {
             @Override
             public Timestamped<T> call(T value) {
diff --git a/rxjava-core/src/main/java/rx/operators/OperationToFuture.java b/rxjava-core/src/main/java/rx/operators/OperationToFuture.java
index 3af8435d76..5f80baf44a 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationToFuture.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationToFuture.java
@@ -52,7 +52,7 @@ public class OperationToFuture {
      *            the type of source.
      * @return the Future to retrieve a single elements from an Observable
      */
-    public static <T> Future<T> toFuture(Observable<T> that) {
+    public static <T> Future<T> toFuture(Observable<? extends T> that) {
 
         final CountDownLatch finished = new CountDownLatch(1);
         final AtomicReference<T> value = new AtomicReference<T>();
@@ -162,10 +162,10 @@ public void testExceptionWithMoreThanOneElement() throws InterruptedException, E
 
     @Test
     public void testToFutureWithException() {
-        Observable<String> obs = Observable.create(new Func1<Observer<String>, Subscription>() {
+        Observable<String> obs = Observable.create(new Func1<Observer<? super String>, Subscription>() {
 
             @Override
-            public Subscription call(Observer<String> observer) {
+            public Subscription call(Observer<? super String> observer) {
                 observer.onNext("one");
                 observer.onError(new TestException());
                 return Subscriptions.empty();
diff --git a/rxjava-core/src/main/java/rx/operators/OperationToIterator.java b/rxjava-core/src/main/java/rx/operators/OperationToIterator.java
index f48f56be4f..b8ee47c51a 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationToIterator.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationToIterator.java
@@ -47,10 +47,10 @@ public class OperationToIterator {
      *            the type of source.
      * @return the iterator that could be used to iterate over the elements of the observable.
      */
-    public static <T> Iterator<T> toIterator(Observable<T> source) {
-        final BlockingQueue<Notification<T>> notifications = new LinkedBlockingQueue<Notification<T>>();
+    public static <T> Iterator<T> toIterator(Observable<? extends T> source) {
+        final BlockingQueue<Notification<? extends T>> notifications = new LinkedBlockingQueue<Notification<? extends T>>();
 
-        source.materialize().subscribe(new Observer<Notification<T>>() {
+        source.materialize().subscribe(new Observer<Notification<? extends T>>() {
             @Override
             public void onCompleted() {
                 // ignore
@@ -62,13 +62,13 @@ public void onError(Throwable e) {
             }
 
             @Override
-            public void onNext(Notification<T> args) {
+            public void onNext(Notification<? extends T> args) {
                 notifications.offer(args);
             }
         });
 
         return new Iterator<T>() {
-            private Notification<T> buf;
+            private Notification<? extends T> buf;
 
             @Override
             public boolean hasNext() {
@@ -92,7 +92,7 @@ public T next() {
                 return result;
             }
 
-            private Notification<T> take() {
+            private Notification<? extends T> take() {
                 try {
                     return notifications.take();
                 } catch (InterruptedException e) {
@@ -128,10 +128,10 @@ public void testToIterator() {
 
     @Test(expected = TestException.class)
     public void testToIteratorWithException() {
-        Observable<String> obs = Observable.create(new Func1<Observer<String>, Subscription>() {
+        Observable<String> obs = Observable.create(new Func1<Observer<? super String>, Subscription>() {
 
             @Override
-            public Subscription call(Observer<String> observer) {
+            public Subscription call(Observer<? super String> observer) {
                 observer.onNext("one");
                 observer.onError(new TestException());
                 return Subscriptions.empty();
diff --git a/rxjava-core/src/main/java/rx/operators/OperationToObservableFuture.java b/rxjava-core/src/main/java/rx/operators/OperationToObservableFuture.java
index 33c22639d6..c2ef17f312 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationToObservableFuture.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationToObservableFuture.java
@@ -39,27 +39,27 @@
  * <code>Observable.subscribe(Observer)</code> does nothing.
  */
 public class OperationToObservableFuture {
-    private static class ToObservableFuture<T> implements Func1<Observer<T>, Subscription> {
-        private final Future<T> that;
+    private static class ToObservableFuture<T> implements Func1<Observer<? super T>, Subscription> {
+        private final Future<? extends T> that;
         private final Long time;
         private final TimeUnit unit;
 
-        public ToObservableFuture(Future<T> that) {
+        public ToObservableFuture(Future<? extends T> that) {
             this.that = that;
             this.time = null;
             this.unit = null;
         }
 
-        public ToObservableFuture(Future<T> that, long time, TimeUnit unit) {
+        public ToObservableFuture(Future<? extends T> that, long time, TimeUnit unit) {
             this.that = that;
             this.time = time;
             this.unit = unit;
         }
 
         @Override
-        public Subscription call(Observer<T> observer) {
+        public Subscription call(Observer<? super T> observer) {
             try {
-                T value = (time == null) ? that.get() : that.get(time, unit);
+                T value = (time == null) ? (T) that.get() : (T) that.get(time, unit);
 
                 if (!that.isCancelled()) {
                     observer.onNext(value);
@@ -75,11 +75,11 @@ public Subscription call(Observer<T> observer) {
         }
     }
 
-    public static <T> Func1<Observer<T>, Subscription> toObservableFuture(final Future<T> that) {
+    public static <T> Func1<Observer<? super T>, Subscription> toObservableFuture(final Future<? extends T> that) {
         return new ToObservableFuture<T>(that);
     }
 
-    public static <T> Func1<Observer<T>, Subscription> toObservableFuture(final Future<T> that, long time, TimeUnit unit) {
+    public static <T> Func1<Observer<? super T>, Subscription> toObservableFuture(final Future<? extends T> that, long time, TimeUnit unit) {
         return new ToObservableFuture<T>(that, time, unit);
     }
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperationToObservableIterable.java b/rxjava-core/src/main/java/rx/operators/OperationToObservableIterable.java
index 0976f9113c..58dae4db11 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationToObservableIterable.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationToObservableIterable.java
@@ -39,18 +39,18 @@
  */
 public final class OperationToObservableIterable<T> {
 
-    public static <T> Func1<Observer<T>, Subscription> toObservableIterable(Iterable<T> list) {
+    public static <T> Func1<Observer<? super T>, Subscription> toObservableIterable(Iterable<? extends T> list) {
         return new ToObservableIterable<T>(list);
     }
 
-    private static class ToObservableIterable<T> implements Func1<Observer<T>, Subscription> {
-        public ToObservableIterable(Iterable<T> list) {
+    private static class ToObservableIterable<T> implements Func1<Observer<? super T>, Subscription> {
+        public ToObservableIterable(Iterable<? extends T> list) {
             this.iterable = list;
         }
 
-        public Iterable<T> iterable;
+        public Iterable<? extends T> iterable;
 
-        public Subscription call(Observer<T> observer) {
+        public Subscription call(Observer<? super T> observer) {
             for (T item : iterable) {
                 observer.onNext(item);
             }
diff --git a/rxjava-core/src/main/java/rx/operators/OperationToObservableList.java b/rxjava-core/src/main/java/rx/operators/OperationToObservableList.java
index 7258938d11..8117edaebc 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationToObservableList.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationToObservableList.java
@@ -47,19 +47,19 @@
  */
 public final class OperationToObservableList<T> {
 
-    public static <T> Func1<Observer<List<T>>, Subscription> toObservableList(Observable<T> that) {
+    public static <T> Func1<Observer<? super List<T>>, Subscription> toObservableList(Observable<? extends T> that) {
         return new ToObservableList<T>(that);
     }
 
-    private static class ToObservableList<T> implements Func1<Observer<List<T>>, Subscription> {
+    private static class ToObservableList<T> implements Func1<Observer<? super List<T>>, Subscription> {
 
-        private final Observable<T> that;
+        private final Observable<? extends T> that;
 
-        public ToObservableList(Observable<T> that) {
+        public ToObservableList(Observable<? extends T> that) {
             this.that = that;
         }
 
-        public Subscription call(final Observer<List<T>> observer) {
+        public Subscription call(final Observer<? super List<T>> observer) {
 
             return that.subscribe(new Observer<T>() {
                 final ConcurrentLinkedQueue<T> list = new ConcurrentLinkedQueue<T>();
diff --git a/rxjava-core/src/main/java/rx/operators/OperationToObservableSortedList.java b/rxjava-core/src/main/java/rx/operators/OperationToObservableSortedList.java
index 536def4cd2..7d34ea335e 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationToObservableSortedList.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationToObservableSortedList.java
@@ -53,7 +53,7 @@ public final class OperationToObservableSortedList<T> {
      *             if T objects do not implement Comparable
      * @return an observable containing the sorted list
      */
-    public static <T> Func1<Observer<List<T>>, Subscription> toSortedList(Observable<T> sequence) {
+    public static <T> Func1<Observer<? super List<T>>, Subscription> toSortedList(Observable<? extends T> sequence) {
         return new ToObservableSortedList<T>(sequence);
     }
 
@@ -64,28 +64,28 @@ public static <T> Func1<Observer<List<T>>, Subscription> toSortedList(Observable
      * @param sortFunction
      * @return an observable containing the sorted list
      */
-    public static <T> Func1<Observer<List<T>>, Subscription> toSortedList(Observable<T> sequence, Func2<T, T, Integer> sortFunction) {
+    public static <T> Func1<Observer<? super List<T>>, Subscription> toSortedList(Observable<? extends T> sequence, Func2<? super T, ? super T, Integer> sortFunction) {
         return new ToObservableSortedList<T>(sequence, sortFunction);
     }
 
-    private static class ToObservableSortedList<T> implements Func1<Observer<List<T>>, Subscription> {
+    private static class ToObservableSortedList<T> implements Func1<Observer<? super List<T>>, Subscription> {
 
-        private final Observable<T> that;
+        private final Observable<? extends T> that;
         private final ConcurrentLinkedQueue<T> list = new ConcurrentLinkedQueue<T>();
-        private final Func2<T, T, Integer> sortFunction;
+        private final Func2<? super T, ? super T, Integer> sortFunction;
 
         // unchecked as we're support Object for the default
         @SuppressWarnings("unchecked")
-        private ToObservableSortedList(Observable<T> that) {
+        private ToObservableSortedList(Observable<? extends T> that) {
             this(that, defaultSortFunction);
         }
 
-        private ToObservableSortedList(Observable<T> that, Func2<T, T, Integer> sortFunction) {
+        private ToObservableSortedList(Observable<? extends T> that, Func2<? super T, ? super T, Integer> sortFunction) {
             this.that = that;
             this.sortFunction = sortFunction;
         }
 
-        public Subscription call(final Observer<List<T>> observer) {
+        public Subscription call(final Observer<? super List<T>> observer) {
             return that.subscribe(new Observer<T>() {
                 public void onNext(T value) {
                     // onNext can be concurrently executed so list must be thread-safe
diff --git a/rxjava-core/src/main/java/rx/operators/OperationZip.java b/rxjava-core/src/main/java/rx/operators/OperationZip.java
index 92d987ffa7..4bcee8854a 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationZip.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationZip.java
@@ -35,6 +35,11 @@
 import rx.util.functions.Func2;
 import rx.util.functions.Func3;
 import rx.util.functions.Func4;
+import rx.util.functions.Func5;
+import rx.util.functions.Func6;
+import rx.util.functions.Func7;
+import rx.util.functions.Func8;
+import rx.util.functions.Func9;
 import rx.util.functions.FuncN;
 import rx.util.functions.Functions;
 
@@ -54,35 +59,98 @@
  */
 public final class OperationZip {
 
-    public static <T0, T1, R> Func1<Observer<R>, Subscription> zip(Observable<T0> w0, Observable<T1> w1, Func2<T0, T1, R> zipFunction) {
+    public static <T1, T2, R> Func1<Observer<? super R>, Subscription> zip(Observable<? extends T1> o1, Observable<? extends T2> o2, Func2<? super T1, ? super T2, ? extends R> zipFunction) {
         Aggregator<R> a = new Aggregator<R>(Functions.fromFunc(zipFunction));
-        a.addObserver(new ZipObserver<R, T0>(a, w0));
-        a.addObserver(new ZipObserver<R, T1>(a, w1));
+        a.addObserver(new ZipObserver<R, T1>(a, o1));
+        a.addObserver(new ZipObserver<R, T2>(a, o2));
         return a;
     }
 
-    public static <T0, T1, T2, R> Func1<Observer<R>, Subscription> zip(Observable<T0> w0, Observable<T1> w1, Observable<T2> w2, Func3<T0, T1, T2, R> zipFunction) {
+    public static <T1, T2, T3, R> Func1<Observer<? super R>, Subscription> zip(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Func3<? super T1, ? super T2, ? super T3, ? extends R> zipFunction) {
         Aggregator<R> a = new Aggregator<R>(Functions.fromFunc(zipFunction));
-        a.addObserver(new ZipObserver<R, T0>(a, w0));
-        a.addObserver(new ZipObserver<R, T1>(a, w1));
-        a.addObserver(new ZipObserver<R, T2>(a, w2));
+        a.addObserver(new ZipObserver<R, T1>(a, o1));
+        a.addObserver(new ZipObserver<R, T2>(a, o2));
+        a.addObserver(new ZipObserver<R, T3>(a, o3));
         return a;
     }
 
-    public static <T0, T1, T2, T3, R> Func1<Observer<R>, Subscription> zip(Observable<T0> w0, Observable<T1> w1, Observable<T2> w2, Observable<T3> w3, Func4<T0, T1, T2, T3, R> zipFunction) {
+    public static <T1, T2, T3, T4, R> Func1<Observer<? super R>, Subscription> zip(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Func4<? super T1, ? super T2, ? super T3, ? super T4, ? extends R> zipFunction) {
         Aggregator<R> a = new Aggregator<R>(Functions.fromFunc(zipFunction));
-        a.addObserver(new ZipObserver<R, T0>(a, w0));
-        a.addObserver(new ZipObserver<R, T1>(a, w1));
-        a.addObserver(new ZipObserver<R, T2>(a, w2));
-        a.addObserver(new ZipObserver<R, T3>(a, w3));
+        a.addObserver(new ZipObserver<R, T1>(a, o1));
+        a.addObserver(new ZipObserver<R, T2>(a, o2));
+        a.addObserver(new ZipObserver<R, T3>(a, o3));
+        a.addObserver(new ZipObserver<R, T4>(a, o4));
         return a;
     }
 
-    @SuppressWarnings("unchecked")
-    public static <R> Func1<Observer<R>, Subscription> zip(Collection<Observable<?>> ws, FuncN<R> zipFunction) {
-        Aggregator a = new Aggregator(zipFunction);
-        for (Observable w : ws) {
-            ZipObserver zipObserver = new ZipObserver(a, w);
+    public static <T1, T2, T3, T4, T5, R> Func1<Observer<? super R>, Subscription> zip(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5, Func5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? extends R> zipFunction) {
+        Aggregator<R> a = new Aggregator<R>(Functions.fromFunc(zipFunction));
+        a.addObserver(new ZipObserver<R, T1>(a, o1));
+        a.addObserver(new ZipObserver<R, T2>(a, o2));
+        a.addObserver(new ZipObserver<R, T3>(a, o3));
+        a.addObserver(new ZipObserver<R, T4>(a, o4));
+        a.addObserver(new ZipObserver<R, T5>(a, o5));
+        return a;
+    }
+
+    public static <T1, T2, T3, T4, T5, T6, R> Func1<Observer<? super R>, Subscription> zip(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5, Observable<? extends T6> o6,
+            Func6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? extends R> zipFunction) {
+        Aggregator<R> a = new Aggregator<R>(Functions.fromFunc(zipFunction));
+        a.addObserver(new ZipObserver<R, T1>(a, o1));
+        a.addObserver(new ZipObserver<R, T2>(a, o2));
+        a.addObserver(new ZipObserver<R, T3>(a, o3));
+        a.addObserver(new ZipObserver<R, T4>(a, o4));
+        a.addObserver(new ZipObserver<R, T5>(a, o5));
+        a.addObserver(new ZipObserver<R, T6>(a, o6));
+        return a;
+    }
+
+    public static <T1, T2, T3, T4, T5, T6, T7, R> Func1<Observer<? super R>, Subscription> zip(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5, Observable<? extends T6> o6, Observable<? extends T7> o7,
+            Func7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? extends R> zipFunction) {
+        Aggregator<R> a = new Aggregator<R>(Functions.fromFunc(zipFunction));
+        a.addObserver(new ZipObserver<R, T1>(a, o1));
+        a.addObserver(new ZipObserver<R, T2>(a, o2));
+        a.addObserver(new ZipObserver<R, T3>(a, o3));
+        a.addObserver(new ZipObserver<R, T4>(a, o4));
+        a.addObserver(new ZipObserver<R, T5>(a, o5));
+        a.addObserver(new ZipObserver<R, T6>(a, o6));
+        a.addObserver(new ZipObserver<R, T7>(a, o7));
+        return a;
+    }
+
+    public static <T1, T2, T3, T4, T5, T6, T7, T8, R> Func1<Observer<? super R>, Subscription> zip(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5, Observable<? extends T6> o6, Observable<? extends T7> o7, Observable<? extends T8> o8,
+            Func8<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? extends R> zipFunction) {
+        Aggregator<R> a = new Aggregator<R>(Functions.fromFunc(zipFunction));
+        a.addObserver(new ZipObserver<R, T1>(a, o1));
+        a.addObserver(new ZipObserver<R, T2>(a, o2));
+        a.addObserver(new ZipObserver<R, T3>(a, o3));
+        a.addObserver(new ZipObserver<R, T4>(a, o4));
+        a.addObserver(new ZipObserver<R, T5>(a, o5));
+        a.addObserver(new ZipObserver<R, T6>(a, o6));
+        a.addObserver(new ZipObserver<R, T7>(a, o7));
+        a.addObserver(new ZipObserver<R, T8>(a, o8));
+        return a;
+    }
+
+    public static <T1, T2, T3, T4, T5, T6, T7, T8, T9, R> Func1<Observer<? super R>, Subscription> zip(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5, Observable<? extends T6> o6, Observable<? extends T7> o7, Observable<? extends T8> o8,
+            Observable<? extends T9> o9, Func9<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? super T9, ? extends R> zipFunction) {
+        Aggregator<R> a = new Aggregator<R>(Functions.fromFunc(zipFunction));
+        a.addObserver(new ZipObserver<R, T1>(a, o1));
+        a.addObserver(new ZipObserver<R, T2>(a, o2));
+        a.addObserver(new ZipObserver<R, T3>(a, o3));
+        a.addObserver(new ZipObserver<R, T4>(a, o4));
+        a.addObserver(new ZipObserver<R, T5>(a, o5));
+        a.addObserver(new ZipObserver<R, T6>(a, o6));
+        a.addObserver(new ZipObserver<R, T7>(a, o7));
+        a.addObserver(new ZipObserver<R, T8>(a, o8));
+        a.addObserver(new ZipObserver<R, T9>(a, o9));
+        return a;
+    }
+
+    public static <R> Func1<Observer<? super R>, Subscription> zip(Collection<? extends Observable<?>> ws, FuncN<? extends R> zipFunction) {
+        Aggregator<R> a = new Aggregator<R>(zipFunction);
+        for (Observable<?> w : ws) {
+            ZipObserver<R, Object> zipObserver = new ZipObserver<R, Object>(a, w);
             a.addObserver(zipObserver);
         }
         return a;
@@ -92,12 +160,12 @@ public static <R> Func1<Observer<R>, Subscription> zip(Collection<Observable<?>>
      * ThreadSafe
      */
     private static class ZipObserver<R, T> implements Observer<T> {
-        final Observable<T> w;
+        final Observable<? extends T> w;
         final Aggregator<R> a;
         private final SafeObservableSubscription subscription = new SafeObservableSubscription();
         private final AtomicBoolean subscribed = new AtomicBoolean(false);
 
-        public ZipObserver(Aggregator<R> a, Observable<T> w) {
+        public ZipObserver(Aggregator<R> a, Observable<? extends T> w) {
             this.a = a;
             this.w = w;
         }
@@ -136,10 +204,10 @@ public void onNext(T args) {
      * 
      * @param <T>
      */
-    private static class Aggregator<T> implements Func1<Observer<T>, Subscription> {
+    private static class Aggregator<T> implements Func1<Observer<? super T>, Subscription> {
 
         private volatile SynchronizedObserver<T> observer;
-        private final FuncN<T> zipFunction;
+        private final FuncN<? extends T> zipFunction;
         private final AtomicBoolean started = new AtomicBoolean(false);
         private final AtomicBoolean running = new AtomicBoolean(true);
         private final ConcurrentHashMap<ZipObserver<T, ?>, Boolean> completed = new ConcurrentHashMap<ZipObserver<T, ?>, Boolean>();
@@ -149,13 +217,13 @@ private static class Aggregator<T> implements Func1<Observer<T>, Subscription> {
         /* we use a ConcurrentLinkedQueue to retain ordering (I'd like to just use a ConcurrentLinkedHashMap for 'receivedValuesPerObserver' but that doesn't exist in standard java */
         private ConcurrentLinkedQueue<ZipObserver<T, ?>> observers = new ConcurrentLinkedQueue<ZipObserver<T, ?>>();
 
-        public Aggregator(FuncN<T> zipFunction) {
+        public Aggregator(FuncN<? extends T> zipFunction) {
             this.zipFunction = zipFunction;
         }
 
         /**
          * Receive notification of a Observer starting (meaning we should require it for aggregation)
-         *
+         * 
          * Thread Safety => Invoke ONLY from the static factory methods at top of this class which are always an atomic execution by a single thread.
          * 
          * @param w
@@ -244,7 +312,7 @@ void next(ZipObserver<T, ?> w, Object arg) {
         }
 
         @Override
-        public Subscription call(Observer<T> observer) {
+        public Subscription call(Observer<? super T> observer) {
             if (started.compareAndSet(false, true)) {
                 SafeObservableSubscription subscription = new SafeObservableSubscription();
                 this.observer = new SynchronizedObserver<T>(observer, subscription);
@@ -295,15 +363,17 @@ private void stop() {
     }
 
     public static class UnitTest {
-        
+
         @SuppressWarnings("unchecked")
         @Test
         public void testCollectionSizeDifferentThanFunction() {
-            FuncN<String> zipr = Functions.from(getConcatStringIntegerIntArrayZipr());
+            FuncN<String> zipr = Functions.fromFunc(getConcatStringIntegerIntArrayZipr());
+            //Func3<String, Integer, int[], String>
 
             /* define a Observer to receive aggregated events */
             Observer<String> aObserver = mock(Observer.class);
 
+            @SuppressWarnings("rawtypes")
             Collection ws = java.util.Collections.singleton(Observable.from("one", "two"));
             Observable<String> w = Observable.create(zip(ws, zipr));
             w.subscribe(aObserver);
@@ -328,18 +398,18 @@ public void testZippingDifferentLengthObservableSequences1() {
 
             /* simulate sending data */
             // once for w1
-            w1.Observer.onNext("1a");
-            w1.Observer.onCompleted();
+            w1.observer.onNext("1a");
+            w1.observer.onCompleted();
             // twice for w2
-            w2.Observer.onNext("2a");
-            w2.Observer.onNext("2b");
-            w2.Observer.onCompleted();
+            w2.observer.onNext("2a");
+            w2.observer.onNext("2b");
+            w2.observer.onCompleted();
             // 4 times for w3
-            w3.Observer.onNext("3a");
-            w3.Observer.onNext("3b");
-            w3.Observer.onNext("3c");
-            w3.Observer.onNext("3d");
-            w3.Observer.onCompleted();
+            w3.observer.onNext("3a");
+            w3.observer.onNext("3b");
+            w3.observer.onNext("3c");
+            w3.observer.onNext("3d");
+            w3.observer.onCompleted();
 
             /* we should have been called 1 time on the Observer */
             InOrder inOrder = inOrder(w);
@@ -362,18 +432,18 @@ public void testZippingDifferentLengthObservableSequences2() {
 
             /* simulate sending data */
             // 4 times for w1
-            w1.Observer.onNext("1a");
-            w1.Observer.onNext("1b");
-            w1.Observer.onNext("1c");
-            w1.Observer.onNext("1d");
-            w1.Observer.onCompleted();
+            w1.observer.onNext("1a");
+            w1.observer.onNext("1b");
+            w1.observer.onNext("1c");
+            w1.observer.onNext("1d");
+            w1.observer.onCompleted();
             // twice for w2
-            w2.Observer.onNext("2a");
-            w2.Observer.onNext("2b");
-            w2.Observer.onCompleted();
+            w2.observer.onNext("2a");
+            w2.observer.onNext("2b");
+            w2.observer.onCompleted();
             // 1 times for w3
-            w3.Observer.onNext("3a");
-            w3.Observer.onCompleted();
+            w3.observer.onNext("3a");
+            w3.observer.onCompleted();
 
             /* we should have been called 1 time on the Observer */
             InOrder inOrder = inOrder(w);
@@ -841,12 +911,12 @@ private static String getStringValue(Object o) {
 
         private static class TestObservable extends Observable<String> {
 
-            Observer<String> Observer;
+            Observer<? super String> observer;
 
             @Override
-            public Subscription subscribe(Observer<String> Observer) {
+            public Subscription subscribe(Observer<? super String> Observer) {
                 // just store the variable where it can be accessed so we can manually trigger it
-                this.Observer = Observer;
+                this.observer = Observer;
                 return Subscriptions.empty();
             }
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorTester.java b/rxjava-core/src/main/java/rx/operators/OperatorTester.java
index 664dd37cc8..62b41a0567 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorTester.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorTester.java
@@ -64,7 +64,7 @@ public Subscription schedule(Action0 action) {
             }
 
             @Override
-            public <T> Subscription schedule(T state, Func2<Scheduler, T, Subscription> action) {
+            public <T> Subscription schedule(T state, Func2<? super Scheduler, ? super T, ? extends Subscription> action) {
                 return underlying.schedule(state, action);
             }
 
@@ -74,7 +74,7 @@ public Subscription schedule(Action0 action, long dueTime, TimeUnit unit) {
             }
 
             @Override
-            public <T> Subscription schedule(T state, Func2<Scheduler, T, Subscription> action, long dueTime, TimeUnit unit) {
+            public <T> Subscription schedule(T state, Func2<? super Scheduler, ? super T, ? extends Subscription> action, long dueTime, TimeUnit unit) {
                 return underlying.schedule(state, action, dueTime, unit);
             }
 
@@ -84,7 +84,7 @@ public Subscription schedulePeriodically(Action0 action, long initialDelay, long
             }
 
             @Override
-            public <T> Subscription schedulePeriodically(T state, Func2<Scheduler, T, Subscription> action, long initialDelay, long period, TimeUnit unit) {
+            public <T> Subscription schedulePeriodically(T state, Func2<? super Scheduler, ? super T, ? extends Subscription> action, long initialDelay, long period, TimeUnit unit) {
                 return underlying.schedulePeriodically(state, action, initialDelay, period, unit);
             }
 
diff --git a/rxjava-core/src/main/java/rx/operators/SafeObserver.java b/rxjava-core/src/main/java/rx/operators/SafeObserver.java
index d0c56ad110..3e6508dac9 100644
--- a/rxjava-core/src/main/java/rx/operators/SafeObserver.java
+++ b/rxjava-core/src/main/java/rx/operators/SafeObserver.java
@@ -57,11 +57,11 @@
  */
 public class SafeObserver<T> implements Observer<T> {
 
-    private final Observer<T> actual;
+    private final Observer<? super T> actual;
     private final AtomicBoolean isFinished = new AtomicBoolean(false);
     private final SafeObservableSubscription subscription;
 
-    public SafeObserver(SafeObservableSubscription subscription, Observer<T> actual) {
+    public SafeObserver(SafeObservableSubscription subscription, Observer<? super T> actual) {
         this.subscription = subscription;
         this.actual = actual;
     }
diff --git a/rxjava-core/src/main/java/rx/operators/ScheduledObserver.java b/rxjava-core/src/main/java/rx/operators/ScheduledObserver.java
index 205dfb0ca7..a5eff1b852 100644
--- a/rxjava-core/src/main/java/rx/operators/ScheduledObserver.java
+++ b/rxjava-core/src/main/java/rx/operators/ScheduledObserver.java
@@ -24,13 +24,13 @@
 import rx.util.functions.Action0;
 
 /* package */class ScheduledObserver<T> implements Observer<T> {
-    private final Observer<T> underlying;
+    private final Observer<? super T> underlying;
     private final Scheduler scheduler;
 
-    private final ConcurrentLinkedQueue<Notification<T>> queue = new ConcurrentLinkedQueue<Notification<T>>();
+    private final ConcurrentLinkedQueue<Notification<? extends T>> queue = new ConcurrentLinkedQueue<Notification<? extends T>>();
     private final AtomicInteger counter = new AtomicInteger(0);
 
-    public ScheduledObserver(Observer<T> underlying, Scheduler scheduler) {
+    public ScheduledObserver(Observer<? super T> underlying, Scheduler scheduler) {
         this.underlying = underlying;
         this.scheduler = scheduler;
     }
@@ -50,7 +50,7 @@ public void onNext(final T args) {
         enqueue(new Notification<T>(args));
     }
 
-    private void enqueue(Notification<T> notification) {
+    private void enqueue(Notification<? extends T> notification) {
         // this must happen before 'counter' is used to provide synchronization between threads
         queue.offer(notification);
 
@@ -66,7 +66,7 @@ private void processQueue() {
         scheduler.schedule(new Action0() {
             @Override
             public void call() {
-                Notification<T> not = queue.poll();
+                Notification<? extends T> not = queue.poll();
 
                 switch (not.getKind()) {
                 case OnNext:
diff --git a/rxjava-core/src/main/java/rx/operators/SynchronizedObserver.java b/rxjava-core/src/main/java/rx/operators/SynchronizedObserver.java
index 37b36f2c27..d4cd28a849 100644
--- a/rxjava-core/src/main/java/rx/operators/SynchronizedObserver.java
+++ b/rxjava-core/src/main/java/rx/operators/SynchronizedObserver.java
@@ -464,7 +464,7 @@ public int assertEvents(TestConcurrencyObserverEvent expectedEndingEvent) throws
          * This spawns a single thread for the subscribe execution
          * 
          */
-        private static class TestSingleThreadedObservable implements Func1<Observer<String>, Subscription> {
+        private static class TestSingleThreadedObservable implements Func1<Observer<? super String>, Subscription> {
 
             final Subscription s;
             final String[] values;
@@ -476,7 +476,7 @@ public TestSingleThreadedObservable(final Subscription s, final String... values
 
             }
 
-            public Subscription call(final Observer<String> observer) {
+            public Subscription call(final Observer<? super String> observer) {
                 System.out.println("TestSingleThreadedObservable subscribed to ...");
                 t = new Thread(new Runnable() {
 
@@ -515,7 +515,7 @@ public void waitToFinish() {
          * This spawns a thread for the subscription, then a separate thread for each onNext call.
          * 
          */
-        private static class TestMultiThreadedObservable implements Func1<Observer<String>, Subscription> {
+        private static class TestMultiThreadedObservable implements Func1<Observer<? super String>, Subscription> {
 
             final Subscription s;
             final String[] values;
@@ -531,7 +531,7 @@ public TestMultiThreadedObservable(Subscription s, String... values) {
             }
 
             @Override
-            public Subscription call(final Observer<String> observer) {
+            public Subscription call(final Observer<? super String> observer) {
                 System.out.println("TestMultiThreadedObservable subscribed to ...");
                 t = new Thread(new Runnable() {
 
diff --git a/rxjava-core/src/main/java/rx/plugins/RxJavaObservableExecutionHook.java b/rxjava-core/src/main/java/rx/plugins/RxJavaObservableExecutionHook.java
index 2aba6edecd..0a275d0248 100644
--- a/rxjava-core/src/main/java/rx/plugins/RxJavaObservableExecutionHook.java
+++ b/rxjava-core/src/main/java/rx/plugins/RxJavaObservableExecutionHook.java
@@ -47,7 +47,7 @@ public abstract class RxJavaObservableExecutionHook {
      *            original {@link Func1}<{@link Observer}{@code <T>}, {@link Subscription}> to be executed
      * @return {@link Func1}<{@link Observer}{@code <T>}, {@link Subscription}> function that can be modified, decorated, replaced or just returned as a pass-thru.
      */
-    public <T> Func1<Observer<T>, Subscription> onSubscribeStart(Observable<T> observableInstance, Func1<Observer<T>, Subscription> onSubscribe) {
+    public <T> Func1<? super Observer<? super T>, ? extends Subscription> onSubscribeStart(Observable<? extends T> observableInstance, Func1<? super Observer<? super T>, ? extends Subscription> onSubscribe) {
         // pass-thru by default
         return onSubscribe;
     }
@@ -63,7 +63,7 @@ public <T> Func1<Observer<T>, Subscription> onSubscribeStart(Observable<T> obser
      *            original {@link Subscription}
      * @return {@link Subscription} subscription that can be modified, decorated, replaced or just returned as a pass-thru.
      */
-    public <T> Subscription onSubscribeReturn(Observable<T> observableInstance, Subscription subscription) {
+    public <T> Subscription onSubscribeReturn(Observable<? extends T> observableInstance, Subscription subscription) {
         // pass-thru by default
         return subscription;
     }
@@ -80,7 +80,7 @@ public <T> Subscription onSubscribeReturn(Observable<T> observableInstance, Subs
      *            Throwable thrown by {@link Observable#subscribe(Observer)}
      * @return Throwable that can be decorated, replaced or just returned as a pass-thru.
      */
-    public <T> Throwable onSubscribeError(Observable<T> observableInstance, Throwable e) {
+    public <T> Throwable onSubscribeError(Observable<? extends T> observableInstance, Throwable e) {
         // pass-thru by default
         return e;
     }
diff --git a/rxjava-core/src/main/java/rx/subjects/AsyncSubject.java b/rxjava-core/src/main/java/rx/subjects/AsyncSubject.java
index c25ea56dee..6ff5e2f66a 100644
--- a/rxjava-core/src/main/java/rx/subjects/AsyncSubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/AsyncSubject.java
@@ -68,11 +68,11 @@ public class AsyncSubject<T> extends Subject<T, T> {
      * @return a new AsyncSubject
      */
     public static <T> AsyncSubject<T> create() {
-        final ConcurrentHashMap<Subscription, Observer<T>> observers = new ConcurrentHashMap<Subscription, Observer<T>>();
+        final ConcurrentHashMap<Subscription, Observer<? super T>> observers = new ConcurrentHashMap<Subscription, Observer<? super T>>();
 
-        Func1<Observer<T>, Subscription> onSubscribe = new Func1<Observer<T>, Subscription>() {
+        Func1<Observer<? super T>, Subscription> onSubscribe = new Func1<Observer<? super T>, Subscription>() {
             @Override
-            public Subscription call(Observer<T> observer) {
+            public Subscription call(Observer<? super T> observer) {
                 final SafeObservableSubscription subscription = new SafeObservableSubscription();
 
                 subscription.wrap(new Subscription() {
@@ -92,10 +92,10 @@ public void unsubscribe() {
         return new AsyncSubject<T>(onSubscribe, observers);
     }
 
-    private final ConcurrentHashMap<Subscription, Observer<T>> observers;
+    private final ConcurrentHashMap<Subscription, Observer<? super T>> observers;
     private final AtomicReference<T> currentValue;
 
-    protected AsyncSubject(Func1<Observer<T>, Subscription> onSubscribe, ConcurrentHashMap<Subscription, Observer<T>> observers) {
+    protected AsyncSubject(Func1<? super Observer<? super T>, ? extends Subscription> onSubscribe, ConcurrentHashMap<Subscription, Observer<? super T>> observers) {
         super(onSubscribe);
         this.observers = observers;
         this.currentValue = new AtomicReference<T>();
@@ -104,17 +104,17 @@ protected AsyncSubject(Func1<Observer<T>, Subscription> onSubscribe, ConcurrentH
     @Override
     public void onCompleted() {
         T finalValue = currentValue.get();
-        for (Observer<T> observer : observers.values()) {
+        for (Observer<? super T> observer : observers.values()) {
             observer.onNext(finalValue);
         }
-        for (Observer<T> observer : observers.values()) {
+        for (Observer<? super T> observer : observers.values()) {
             observer.onCompleted();
         }
     }
 
     @Override
     public void onError(Throwable e) {
-        for (Observer<T> observer : observers.values()) {
+        for (Observer<? super T> observer : observers.values()) {
             observer.onError(e);
         }
     }
@@ -132,6 +132,7 @@ public static class UnitTest {
         public void testNeverCompleted() {
         	AsyncSubject<String> subject = AsyncSubject.create();
 
+            @SuppressWarnings("unchecked")
             Observer<String> aObserver = mock(Observer.class);
             subject.subscribe(aObserver);
 
@@ -153,6 +154,7 @@ private void assertNeverCompletedObserver(Observer<String> aObserver)
         public void testCompleted() {
         	AsyncSubject<String> subject = AsyncSubject.create();
 
+            @SuppressWarnings("unchecked")
             Observer<String> aObserver = mock(Observer.class);
             subject.subscribe(aObserver);
 
@@ -175,6 +177,7 @@ private void assertCompletedObserver(Observer<String> aObserver)
         public void testError() {
         	AsyncSubject<String> subject = AsyncSubject.create();
 
+            @SuppressWarnings("unchecked")
             Observer<String> aObserver = mock(Observer.class);
             subject.subscribe(aObserver);
 
diff --git a/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java b/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java
index bed456b5ba..9fcb38edb5 100644
--- a/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java
@@ -70,13 +70,13 @@ public class BehaviorSubject<T> extends Subject<T, T> {
      * @return the constructed {@link BehaviorSubject}.
      */
     public static <T> BehaviorSubject<T> createWithDefaultValue(T defaultValue) {
-        final ConcurrentHashMap<Subscription, Observer<T>> observers = new ConcurrentHashMap<Subscription, Observer<T>>();
+        final ConcurrentHashMap<Subscription, Observer<? super T>> observers = new ConcurrentHashMap<Subscription, Observer<? super T>>();
 
         final AtomicReference<T> currentValue = new AtomicReference<T>(defaultValue);
 
-        Func1<Observer<T>, Subscription> onSubscribe = new Func1<Observer<T>, Subscription>() {
+        Func1<Observer<? super T>, Subscription> onSubscribe = new Func1<Observer<? super T>, Subscription>() {
             @Override
-            public Subscription call(Observer<T> observer) {
+            public Subscription call(Observer<? super T> observer) {
                 final SafeObservableSubscription subscription = new SafeObservableSubscription();
 
                 subscription.wrap(new Subscription() {
@@ -98,10 +98,10 @@ public void unsubscribe() {
         return new BehaviorSubject<T>(currentValue, onSubscribe, observers);
     }
 
-    private final ConcurrentHashMap<Subscription, Observer<T>> observers;
+    private final ConcurrentHashMap<Subscription, Observer<? super T>> observers;
     private final AtomicReference<T> currentValue;
 
-    protected BehaviorSubject(AtomicReference<T> currentValue, Func1<Observer<T>, Subscription> onSubscribe, ConcurrentHashMap<Subscription, Observer<T>> observers) {
+    protected BehaviorSubject(AtomicReference<T> currentValue, Func1<? super Observer<? super T>, ? extends Subscription> onSubscribe, ConcurrentHashMap<Subscription, Observer<? super T>> observers) {
         super(onSubscribe);
         this.currentValue = currentValue;
         this.observers = observers;
@@ -109,14 +109,14 @@ protected BehaviorSubject(AtomicReference<T> currentValue, Func1<Observer<T>, Su
 
     @Override
     public void onCompleted() {
-        for (Observer<T> observer : observers.values()) {
+        for (Observer<? super T> observer : observers.values()) {
             observer.onCompleted();
         }
     }
 
     @Override
     public void onError(Throwable e) {
-        for (Observer<T> observer : observers.values()) {
+        for (Observer<? super T> observer : observers.values()) {
             observer.onError(e);
         }
     }
@@ -124,7 +124,7 @@ public void onError(Throwable e) {
     @Override
     public void onNext(T args) {
         currentValue.set(args);
-        for (Observer<T> observer : observers.values()) {
+        for (Observer<? super T> observer : observers.values()) {
             observer.onNext(args);
         }
     }
diff --git a/rxjava-core/src/main/java/rx/subjects/PublishSubject.java b/rxjava-core/src/main/java/rx/subjects/PublishSubject.java
index 467771758d..506639346f 100644
--- a/rxjava-core/src/main/java/rx/subjects/PublishSubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/PublishSubject.java
@@ -67,12 +67,12 @@
  */
 public class PublishSubject<T> extends Subject<T, T> {
     public static <T> PublishSubject<T> create() {
-        final ConcurrentHashMap<Subscription, Observer<T>> observers = new ConcurrentHashMap<Subscription, Observer<T>>();
-        final AtomicReference<Notification<T>> terminalState = new AtomicReference<Notification<T>>();
+        final ConcurrentHashMap<Subscription, Observer<? super T>> observers = new ConcurrentHashMap<Subscription, Observer<? super T>>();
+        final AtomicReference<Notification<? extends T>> terminalState = new AtomicReference<Notification<? extends T>>();
 
-        Func1<Observer<T>, Subscription> onSubscribe = new Func1<Observer<T>, Subscription>() {
+        Func1<Observer<? super T>, Subscription> onSubscribe = new Func1<Observer<? super T>, Subscription>() {
             @Override
-            public Subscription call(Observer<T> observer) {
+            public Subscription call(Observer<? super T> observer) {
                 // shortcut check if terminal state exists already
                 Subscription s = checkTerminalState(observer);
                 if(s != null) return s;
@@ -110,8 +110,8 @@ public void unsubscribe() {
                 }
             }
 
-            private Subscription checkTerminalState(Observer<T> observer) {
-                Notification<T> n = terminalState.get();
+            private Subscription checkTerminalState(Observer<? super T> observer) {
+                Notification<? extends T> n = terminalState.get();
                 if (n != null) {
                     // we are terminated to immediately emit and don't continue with subscription
                     if (n.isOnCompleted()) {
@@ -129,10 +129,10 @@ private Subscription checkTerminalState(Observer<T> observer) {
         return new PublishSubject<T>(onSubscribe, observers, terminalState);
     }
 
-    private final ConcurrentHashMap<Subscription, Observer<T>> observers;
-    private final AtomicReference<Notification<T>> terminalState;
+    private final ConcurrentHashMap<Subscription, Observer<? super T>> observers;
+    private final AtomicReference<Notification<? extends T>> terminalState;
 
-    protected PublishSubject(Func1<Observer<T>, Subscription> onSubscribe, ConcurrentHashMap<Subscription, Observer<T>> observers, AtomicReference<Notification<T>> terminalState) {
+    protected PublishSubject(Func1<? super Observer<? super T>, ? extends Subscription> onSubscribe, ConcurrentHashMap<Subscription, Observer<? super T>> observers, AtomicReference<Notification<? extends T>> terminalState) {
         super(onSubscribe);
         this.observers = observers;
         this.terminalState = terminalState;
@@ -148,7 +148,7 @@ public void onCompleted() {
         synchronized (terminalState) {
             terminalState.set(new Notification<T>());
         }
-        for (Observer<T> observer : snapshotOfValues()) {
+        for (Observer<? super T> observer : snapshotOfValues()) {
             observer.onCompleted();
         }
         observers.clear();
@@ -164,7 +164,7 @@ public void onError(Throwable e) {
         synchronized (terminalState) {
             terminalState.set(new Notification<T>(e));
         }
-        for (Observer<T> observer : snapshotOfValues()) {
+        for (Observer<? super T> observer : snapshotOfValues()) {
             observer.onError(e);
         }
         observers.clear();
@@ -172,7 +172,7 @@ public void onError(Throwable e) {
 
     @Override
     public void onNext(T args) {
-        for (Observer<T> observer : snapshotOfValues()) {
+        for (Observer<? super T> observer : snapshotOfValues()) {
             observer.onNext(args);
         }
     }
@@ -187,8 +187,8 @@ public void onNext(T args) {
      *
      * @return List<Observer<T>>
      */
-    private Collection<Observer<T>> snapshotOfValues() {
-        return new ArrayList<Observer<T>>(observers.values());
+    private Collection<Observer<? super T>> snapshotOfValues() {
+        return new ArrayList<Observer<? super T>>(observers.values());
     }
 
     public static class UnitTest {
@@ -205,9 +205,9 @@ public void call(List<Notification<Integer>> actual) {
                 }
             });
 
-            Subscription sub = Observable.create(new Func1<Observer<Integer>, Subscription>() {
+            Subscription sub = Observable.create(new Func1<Observer<? super Integer>, Subscription>() {
                 @Override
-                public Subscription call(final Observer<Integer> observer) {
+                public Subscription call(final Observer<? super Integer> observer) {
                     final AtomicBoolean stop = new AtomicBoolean(false);
                     new Thread() {
                         @Override
@@ -247,6 +247,7 @@ public void unsubscribe() {
         public void testCompleted() {
             PublishSubject<String> subject = PublishSubject.create();
 
+            @SuppressWarnings("unchecked")
             Observer<String> aObserver = mock(Observer.class);
             subject.subscribe(aObserver);
 
@@ -255,6 +256,7 @@ public void testCompleted() {
             subject.onNext("three");
             subject.onCompleted();
 
+            @SuppressWarnings("unchecked")
             Observer<String> anotherObserver = mock(Observer.class);
             subject.subscribe(anotherObserver);
 
@@ -275,17 +277,11 @@ private void assertCompletedObserver(Observer<String> aObserver)
             verify(aObserver, times(1)).onCompleted();
         }
 
-        private void assertNeverObserver(Observer<String> aObserver)
-        {
-            verify(aObserver, Mockito.never()).onNext(any(String.class));
-            verify(aObserver, Mockito.never()).onError(any(Throwable.class));
-            verify(aObserver, Mockito.never()).onCompleted();
-        }
-
         @Test
         public void testError() {
             PublishSubject<String> subject = PublishSubject.create();
 
+            @SuppressWarnings("unchecked")
             Observer<String> aObserver = mock(Observer.class);
             subject.subscribe(aObserver);
 
@@ -294,6 +290,7 @@ public void testError() {
             subject.onNext("three");
             subject.onError(testException);
 
+            @SuppressWarnings("unchecked")
             Observer<String> anotherObserver = mock(Observer.class);
             subject.subscribe(anotherObserver);
 
@@ -318,6 +315,7 @@ private void assertErrorObserver(Observer<String> aObserver)
         public void testSubscribeMidSequence() {
             PublishSubject<String> subject = PublishSubject.create();
 
+            @SuppressWarnings("unchecked")
             Observer<String> aObserver = mock(Observer.class);
             subject.subscribe(aObserver);
 
@@ -326,6 +324,7 @@ public void testSubscribeMidSequence() {
 
             assertObservedUntilTwo(aObserver);
 
+            @SuppressWarnings("unchecked")
             Observer<String> anotherObserver = mock(Observer.class);
             subject.subscribe(anotherObserver);
 
@@ -349,6 +348,7 @@ private void assertCompletedStartingWithThreeObserver(Observer<String> aObserver
         public void testUnsubscribeFirstObserver() {
             PublishSubject<String> subject = PublishSubject.create();
 
+            @SuppressWarnings("unchecked")
             Observer<String> aObserver = mock(Observer.class);
             Subscription subscription = subject.subscribe(aObserver);
 
@@ -358,6 +358,7 @@ public void testUnsubscribeFirstObserver() {
             subscription.unsubscribe();
             assertObservedUntilTwo(aObserver);
 
+            @SuppressWarnings("unchecked")
             Observer<String> anotherObserver = mock(Observer.class);
             subject.subscribe(anotherObserver);
 
@@ -391,6 +392,7 @@ private void assertObservedUntilTwo(Observer<String> aObserver)
         public void testUnsubscribeAfterOnCompleted() {
             PublishSubject<String> subject = PublishSubject.create();
 
+            @SuppressWarnings("unchecked")
             Observer<String> anObserver = mock(Observer.class);
             subject.subscribe(anObserver);
 
diff --git a/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java b/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java
index 2d852f5bb0..73c921bb04 100644
--- a/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java
@@ -62,7 +62,7 @@ public final class ReplaySubject<T> extends Subject<T, T>
 
     private boolean isDone = false;
     private Throwable exception = null;
-    private final Map<Subscription, Observer<T>> subscriptions = new HashMap<Subscription, Observer<T>>();
+    private final Map<Subscription, Observer<? super T>> subscriptions = new HashMap<Subscription, Observer<? super T>>();
     private final List<T> history = Collections.synchronizedList(new ArrayList<T>());
 
     public static <T> ReplaySubject<T> create() {
@@ -74,11 +74,11 @@ private ReplaySubject(DelegateSubscriptionFunc<T> onSubscribe) {
         onSubscribe.wrap(new SubscriptionFunc());
     }
 
-    private static final class DelegateSubscriptionFunc<T> implements Func1<Observer<T>, Subscription>
+    private static final class DelegateSubscriptionFunc<T> implements Func1<Observer<? super T>, Subscription>
     {
-        private Func1<Observer<T>, Subscription> delegate = null;
+        private Func1<? super Observer<? super T>, ? extends Subscription> delegate = null;
 
-        public void wrap(Func1<Observer<T>, Subscription> delegate)
+        public void wrap(Func1<? super Observer<? super T>, ? extends Subscription> delegate)
         {
             if (this.delegate != null) {
                 throw new UnsupportedOperationException("delegate already set");
@@ -87,16 +87,16 @@ public void wrap(Func1<Observer<T>, Subscription> delegate)
         }
 
         @Override
-        public Subscription call(Observer<T> observer)
+        public Subscription call(Observer<? super T> observer)
         {
             return delegate.call(observer);
         }
     }
 
-    private class SubscriptionFunc implements Func1<Observer<T>, Subscription>
+    private class SubscriptionFunc implements Func1<Observer<? super T>, Subscription>
     {
         @Override
-        public Subscription call(Observer<T> observer) {
+        public Subscription call(Observer<? super T> observer) {
             int item = 0;
             Subscription subscription;
 
@@ -145,7 +145,7 @@ public void onCompleted()
     {
         synchronized (subscriptions) {
             isDone = true;
-            for (Observer<T> observer : new ArrayList<Observer<T>>(subscriptions.values())) {
+            for (Observer<? super T> observer : new ArrayList<Observer<? super T>>(subscriptions.values())) {
                 observer.onCompleted();
             }
             subscriptions.clear();
@@ -161,7 +161,7 @@ public void onError(Throwable e)
             }
             isDone = true;
             exception = e;
-            for (Observer<T> observer : new ArrayList<Observer<T>>(subscriptions.values())) {
+            for (Observer<? super T> observer : new ArrayList<Observer<? super T>>(subscriptions.values())) {
                 observer.onError(e);
             }
             subscriptions.clear();
@@ -173,7 +173,7 @@ public void onNext(T args)
     {
         synchronized (subscriptions) {
             history.add(args);
-            for (Observer<T> observer : new ArrayList<Observer<T>>(subscriptions.values())) {
+            for (Observer<? super T> observer : new ArrayList<Observer<? super T>>(subscriptions.values())) {
                 observer.onNext(args);
             }
         }
diff --git a/rxjava-core/src/main/java/rx/subjects/Subject.java b/rxjava-core/src/main/java/rx/subjects/Subject.java
index 21f83cc7b7..a706b8fc82 100644
--- a/rxjava-core/src/main/java/rx/subjects/Subject.java
+++ b/rxjava-core/src/main/java/rx/subjects/Subject.java
@@ -21,7 +21,7 @@
 import rx.util.functions.Func1;
 
 public abstract class Subject<T, R> extends Observable<R> implements Observer<T> {
-    protected Subject(Func1<Observer<R>, Subscription> onSubscribe) {
+    protected Subject(Func1<? super Observer<? super R>, ? extends Subscription> onSubscribe) {
         super(onSubscribe);
     }
 }
diff --git a/rxjava-core/src/main/java/rx/subjects/UnsubscribeTester.java b/rxjava-core/src/main/java/rx/subjects/UnsubscribeTester.java
index c895f7aa43..6ff50d39ee 100644
--- a/rxjava-core/src/main/java/rx/subjects/UnsubscribeTester.java
+++ b/rxjava-core/src/main/java/rx/subjects/UnsubscribeTester.java
@@ -54,7 +54,7 @@ public UnsubscribeTester() {
      * @param <T>
      *            The type of object passed by the Observable
      */
-    public static <T, O extends Observable<T>> void test(Func0<O> provider, Action1<? super O> generateOnCompleted, Action1<? super O> generateOnError, Action1<? super O> generateOnNext)
+    public static <T, O extends Observable<T>> void test(Func0<? extends O> provider, Action1<? super O> generateOnCompleted, Action1<? super O> generateOnError, Action1<? super O> generateOnNext)
     {
         if (generateOnCompleted != null) {
             O observable = provider.call();
diff --git a/rxjava-core/src/main/java/rx/util/functions/Action.java b/rxjava-core/src/main/java/rx/util/functions/Action.java
index 3821d84e25..9c73496b67 100644
--- a/rxjava-core/src/main/java/rx/util/functions/Action.java
+++ b/rxjava-core/src/main/java/rx/util/functions/Action.java
@@ -20,6 +20,6 @@
  * <p>
  * Marker interface to allow instanceof checks.
  */
-public interface Action extends Function {
+public interface Action extends Function<Void> {
 
 }
diff --git a/rxjava-core/src/main/java/rx/util/functions/Action0.java b/rxjava-core/src/main/java/rx/util/functions/Action0.java
index 7b6e742699..832b78dd52 100644
--- a/rxjava-core/src/main/java/rx/util/functions/Action0.java
+++ b/rxjava-core/src/main/java/rx/util/functions/Action0.java
@@ -15,6 +15,6 @@
  */
 package rx.util.functions;
 
-public interface Action0 extends Function, Action {
+public interface Action0 extends Action {
     public void call();
 }
\ No newline at end of file
diff --git a/rxjava-core/src/main/java/rx/util/functions/Action1.java b/rxjava-core/src/main/java/rx/util/functions/Action1.java
index e21fd4e38b..68c1b804ed 100644
--- a/rxjava-core/src/main/java/rx/util/functions/Action1.java
+++ b/rxjava-core/src/main/java/rx/util/functions/Action1.java
@@ -15,6 +15,6 @@
  */
 package rx.util.functions;
 
-public interface Action1<T1> extends Function, Action {
+public interface Action1<T1> extends Action {
     public void call(T1 t1);
 }
\ No newline at end of file
diff --git a/rxjava-core/src/main/java/rx/util/functions/Action2.java b/rxjava-core/src/main/java/rx/util/functions/Action2.java
index 76c48d3eaf..ba4826bdca 100644
--- a/rxjava-core/src/main/java/rx/util/functions/Action2.java
+++ b/rxjava-core/src/main/java/rx/util/functions/Action2.java
@@ -15,6 +15,6 @@
  */
 package rx.util.functions;
 
-public interface Action2<T1, T2> extends Function, Action {
+public interface Action2<T1, T2> extends Action {
     public void call(T1 t1, T2 t2);
 }
\ No newline at end of file
diff --git a/rxjava-core/src/main/java/rx/util/functions/Action3.java b/rxjava-core/src/main/java/rx/util/functions/Action3.java
index 0bb6932792..3c2b083c6f 100644
--- a/rxjava-core/src/main/java/rx/util/functions/Action3.java
+++ b/rxjava-core/src/main/java/rx/util/functions/Action3.java
@@ -15,6 +15,6 @@
  */
 package rx.util.functions;
 
-public interface Action3<T1, T2, T3> extends Function, Action {
+public interface Action3<T1, T2, T3> extends Action {
     public void call(T1 t1, T2 t2, T3 t3);
 }
\ No newline at end of file
diff --git a/rxjava-core/src/main/java/rx/util/functions/Func0.java b/rxjava-core/src/main/java/rx/util/functions/Func0.java
index 4e7d397037..f4cefaa26f 100644
--- a/rxjava-core/src/main/java/rx/util/functions/Func0.java
+++ b/rxjava-core/src/main/java/rx/util/functions/Func0.java
@@ -15,6 +15,6 @@
  */
 package rx.util.functions;
 
-public interface Func0<R> extends Function {
+public interface Func0<R> extends Function<R> {
     public R call();
 }
\ No newline at end of file
diff --git a/rxjava-core/src/main/java/rx/util/functions/Func1.java b/rxjava-core/src/main/java/rx/util/functions/Func1.java
index 3eb17e625c..e0aff573bc 100644
--- a/rxjava-core/src/main/java/rx/util/functions/Func1.java
+++ b/rxjava-core/src/main/java/rx/util/functions/Func1.java
@@ -15,6 +15,6 @@
  */
 package rx.util.functions;
 
-public interface Func1<T1, R> extends Function {
+public interface Func1<T1, R> extends Function<R> {
     public R call(T1 t1);
 }
\ No newline at end of file
diff --git a/rxjava-core/src/main/java/rx/util/functions/Func2.java b/rxjava-core/src/main/java/rx/util/functions/Func2.java
index ab2a04442d..dc27b83620 100644
--- a/rxjava-core/src/main/java/rx/util/functions/Func2.java
+++ b/rxjava-core/src/main/java/rx/util/functions/Func2.java
@@ -15,6 +15,6 @@
  */
 package rx.util.functions;
 
-public interface Func2<T1, T2, R> extends Function {
+public interface Func2<T1, T2, R> extends Function<R> {
     public R call(T1 t1, T2 t2);
 }
\ No newline at end of file
diff --git a/rxjava-core/src/main/java/rx/util/functions/Func3.java b/rxjava-core/src/main/java/rx/util/functions/Func3.java
index fc1dfb49b0..228f1bb8de 100644
--- a/rxjava-core/src/main/java/rx/util/functions/Func3.java
+++ b/rxjava-core/src/main/java/rx/util/functions/Func3.java
@@ -15,6 +15,6 @@
  */
 package rx.util.functions;
 
-public interface Func3<T1, T2, T3, R> extends Function {
+public interface Func3<T1, T2, T3, R> extends Function<R> {
     public R call(T1 t1, T2 t2, T3 t3);
 }
\ No newline at end of file
diff --git a/rxjava-core/src/main/java/rx/util/functions/Func4.java b/rxjava-core/src/main/java/rx/util/functions/Func4.java
index 09d738ff72..dff6549aae 100644
--- a/rxjava-core/src/main/java/rx/util/functions/Func4.java
+++ b/rxjava-core/src/main/java/rx/util/functions/Func4.java
@@ -15,6 +15,6 @@
  */
 package rx.util.functions;
 
-public interface Func4<T1, T2, T3, T4, R> extends Function {
+public interface Func4<T1, T2, T3, T4, R> extends Function<R> {
     public R call(T1 t1, T2 t2, T3 t3, T4 t4);
 }
\ No newline at end of file
diff --git a/rxjava-core/src/main/java/rx/util/functions/Func5.java b/rxjava-core/src/main/java/rx/util/functions/Func5.java
index b6550ef0b9..5b675df6da 100644
--- a/rxjava-core/src/main/java/rx/util/functions/Func5.java
+++ b/rxjava-core/src/main/java/rx/util/functions/Func5.java
@@ -15,6 +15,6 @@
  */
 package rx.util.functions;
 
-public interface Func5<T1, T2, T3, T4, T5, R> extends Function {
+public interface Func5<T1, T2, T3, T4, T5, R> extends Function<R> {
     public R call(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5);
 }
\ No newline at end of file
diff --git a/rxjava-core/src/main/java/rx/util/functions/Func6.java b/rxjava-core/src/main/java/rx/util/functions/Func6.java
index a241d55538..f6b2dba526 100644
--- a/rxjava-core/src/main/java/rx/util/functions/Func6.java
+++ b/rxjava-core/src/main/java/rx/util/functions/Func6.java
@@ -15,6 +15,6 @@
  */
 package rx.util.functions;
 
-public interface Func6<T1, T2, T3, T4, T5, T6, R> extends Function {
+public interface Func6<T1, T2, T3, T4, T5, T6, R> extends Function<R> {
     public R call(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6);
 }
\ No newline at end of file
diff --git a/rxjava-core/src/main/java/rx/util/functions/Func7.java b/rxjava-core/src/main/java/rx/util/functions/Func7.java
index 972cc405de..2ee972edd5 100644
--- a/rxjava-core/src/main/java/rx/util/functions/Func7.java
+++ b/rxjava-core/src/main/java/rx/util/functions/Func7.java
@@ -15,6 +15,6 @@
  */
 package rx.util.functions;
 
-public interface Func7<T1, T2, T3, T4, T5, T6, T7, R> extends Function {
+public interface Func7<T1, T2, T3, T4, T5, T6, T7, R> extends Function<R> {
     public R call(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7);
 }
\ No newline at end of file
diff --git a/rxjava-core/src/main/java/rx/util/functions/Func8.java b/rxjava-core/src/main/java/rx/util/functions/Func8.java
index 5cbd10c1f7..991881aab1 100644
--- a/rxjava-core/src/main/java/rx/util/functions/Func8.java
+++ b/rxjava-core/src/main/java/rx/util/functions/Func8.java
@@ -15,6 +15,6 @@
  */
 package rx.util.functions;
 
-public interface Func8<T1, T2, T3, T4, T5, T6, T7, T8, R> extends Function {
+public interface Func8<T1, T2, T3, T4, T5, T6, T7, T8, R> extends Function<R> {
     public R call(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8);
 }
\ No newline at end of file
diff --git a/rxjava-core/src/main/java/rx/util/functions/Func9.java b/rxjava-core/src/main/java/rx/util/functions/Func9.java
index 8f2e546e4a..e3413109ae 100644
--- a/rxjava-core/src/main/java/rx/util/functions/Func9.java
+++ b/rxjava-core/src/main/java/rx/util/functions/Func9.java
@@ -15,6 +15,6 @@
  */
 package rx.util.functions;
 
-public interface Func9<T1, T2, T3, T4, T5, T6, T7, T8, T9, R> extends Function {
+public interface Func9<T1, T2, T3, T4, T5, T6, T7, T8, T9, R> extends Function<R> {
     public R call(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9);
 }
\ No newline at end of file
diff --git a/rxjava-core/src/main/java/rx/util/functions/FuncN.java b/rxjava-core/src/main/java/rx/util/functions/FuncN.java
index 721702afbe..769d5098c5 100644
--- a/rxjava-core/src/main/java/rx/util/functions/FuncN.java
+++ b/rxjava-core/src/main/java/rx/util/functions/FuncN.java
@@ -15,6 +15,6 @@
  */
 package rx.util.functions;
 
-public interface FuncN<R> extends Function {
+public interface FuncN<R> extends Function<R> {
     public R call(Object... args);
 }
diff --git a/rxjava-core/src/main/java/rx/util/functions/Function.java b/rxjava-core/src/main/java/rx/util/functions/Function.java
index ed63ca525e..a2b0fa46b1 100644
--- a/rxjava-core/src/main/java/rx/util/functions/Function.java
+++ b/rxjava-core/src/main/java/rx/util/functions/Function.java
@@ -20,6 +20,6 @@
  * <p>
  * Marker interface to allow instanceof checks.
  */
-public interface Function {
+public interface Function<T> {
 
 }
diff --git a/rxjava-core/src/main/java/rx/util/functions/Functions.java b/rxjava-core/src/main/java/rx/util/functions/Functions.java
index c66ca837e4..7809b3240d 100644
--- a/rxjava-core/src/main/java/rx/util/functions/Functions.java
+++ b/rxjava-core/src/main/java/rx/util/functions/Functions.java
@@ -17,64 +17,13 @@
 
 public class Functions {
 
-    /**
-     * Utility method for determining the type of closure/function and executing it.
-     * 
-     * @param function
-     */
-    @SuppressWarnings({ "rawtypes" })
-    public static FuncN from(final Function function) {
-        if (function == null) {
-            throw new RuntimeException("function is null. Can't send arguments to null function.");
-        }
-        return fromFunction(function);
-    }
-
-    @SuppressWarnings({ "unchecked", "rawtypes" })
-    private static FuncN fromFunction(Function function) {
-        // check Func* classes 
-        if (function instanceof Func0) {
-            return fromFunc((Func0) function);
-        } else if (function instanceof Func1) {
-            return fromFunc((Func1) function);
-        } else if (function instanceof Func2) {
-            return fromFunc((Func2) function);
-        } else if (function instanceof Func3) {
-            return fromFunc((Func3) function);
-        } else if (function instanceof Func4) {
-            return fromFunc((Func4) function);
-        } else if (function instanceof Func5) {
-            return fromFunc((Func5) function);
-        } else if (function instanceof Func6) {
-            return fromFunc((Func6) function);
-        } else if (function instanceof Func7) {
-            return fromFunc((Func7) function);
-        } else if (function instanceof Func8) {
-            return fromFunc((Func8) function);
-        } else if (function instanceof Func9) {
-            return fromFunc((Func9) function);
-        } else if (function instanceof FuncN) {
-            return (FuncN) function;
-        } else if (function instanceof Action0) {
-            return fromAction((Action0) function);
-        } else if (function instanceof Action1) {
-            return fromAction((Action1) function);
-        } else if (function instanceof Action2) {
-            return fromAction((Action2) function);
-        } else if (function instanceof Action3) {
-            return fromAction((Action3) function);
-        }
-
-        throw new RuntimeException("Unknown implementation of Function: " + function.getClass().getSimpleName());
-    }
-
     /**
      * Convert a function to FuncN to allow heterogeneous handling of functions with different arities.
      * 
      * @param f
      * @return {@link FuncN}
      */
-    public static <R> FuncN<R> fromFunc(final Func0<R> f) {
+    public static <R> FuncN<R> fromFunc(final Func0<? extends R> f) {
         return new FuncN<R>() {
 
             @Override
@@ -94,7 +43,7 @@ public R call(Object... args) {
      * @param f
      * @return {@link FuncN}
      */
-    public static <T0, R> FuncN<R> fromFunc(final Func1<T0, R> f) {
+    public static <T0, R> FuncN<R> fromFunc(final Func1<? super T0, ? extends R> f) {
         return new FuncN<R>() {
 
             @SuppressWarnings("unchecked")
@@ -115,7 +64,7 @@ public R call(Object... args) {
      * @param f
      * @return {@link FuncN}
      */
-    public static <T0, T1, R> FuncN<R> fromFunc(final Func2<T0, T1, R> f) {
+    public static <T0, T1, R> FuncN<R> fromFunc(final Func2<? super T0, ? super T1, ? extends R> f) {
         return new FuncN<R>() {
 
             @SuppressWarnings("unchecked")
@@ -136,7 +85,7 @@ public R call(Object... args) {
      * @param f
      * @return {@link FuncN}
      */
-    public static <T0, T1, T2, R> FuncN<R> fromFunc(final Func3<T0, T1, T2, R> f) {
+    public static <T0, T1, T2, R> FuncN<R> fromFunc(final Func3<? super T0, ? super T1, ? super T2, ? extends R> f) {
         return new FuncN<R>() {
 
             @SuppressWarnings("unchecked")
@@ -157,7 +106,7 @@ public R call(Object... args) {
      * @param f
      * @return {@link FuncN}
      */
-    public static <T0, T1, T2, T3, R> FuncN<R> fromFunc(final Func4<T0, T1, T2, T3, R> f) {
+    public static <T0, T1, T2, T3, R> FuncN<R> fromFunc(final Func4<? super T0, ? super T1, ? super T2, ? super T3, ? extends R> f) {
         return new FuncN<R>() {
 
             @SuppressWarnings("unchecked")
@@ -178,7 +127,7 @@ public R call(Object... args) {
      * @param f
      * @return {@link FuncN}
      */
-    public static <T0, T1, T2, T3, T4, R> FuncN<R> fromFunc(final Func5<T0, T1, T2, T3, T4, R> f) {
+    public static <T0, T1, T2, T3, T4, R> FuncN<R> fromFunc(final Func5<? super T0, ? super T1, ? super T2, ? super T3, ? super T4, ? extends R> f) {
         return new FuncN<R>() {
 
             @SuppressWarnings("unchecked")
@@ -199,7 +148,7 @@ public R call(Object... args) {
      * @param f
      * @return {@link FuncN}
      */
-    public static <T0, T1, T2, T3, T4, T5, R> FuncN<R> fromFunc(final Func6<T0, T1, T2, T3, T4, T5, R> f) {
+    public static <T0, T1, T2, T3, T4, T5, R> FuncN<R> fromFunc(final Func6<? super T0, ? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? extends R> f) {
         return new FuncN<R>() {
 
             @SuppressWarnings("unchecked")
@@ -220,7 +169,7 @@ public R call(Object... args) {
      * @param f
      * @return {@link FuncN}
      */
-    public static <T0, T1, T2, T3, T4, T5, T6, R> FuncN<R> fromFunc(final Func7<T0, T1, T2, T3, T4, T5, T6, R> f) {
+    public static <T0, T1, T2, T3, T4, T5, T6, R> FuncN<R> fromFunc(final Func7<? super T0, ? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? extends R> f) {
         return new FuncN<R>() {
 
             @SuppressWarnings("unchecked")
@@ -241,7 +190,7 @@ public R call(Object... args) {
      * @param f
      * @return {@link FuncN}
      */
-    public static <T0, T1, T2, T3, T4, T5, T6, T7, R> FuncN<R> fromFunc(final Func8<T0, T1, T2, T3, T4, T5, T6, T7, R> f) {
+    public static <T0, T1, T2, T3, T4, T5, T6, T7, R> FuncN<R> fromFunc(final Func8<? super T0, ? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? extends R> f) {
         return new FuncN<R>() {
 
             @SuppressWarnings("unchecked")
@@ -262,7 +211,7 @@ public R call(Object... args) {
      * @param f
      * @return {@link FuncN}
      */
-    public static <T0, T1, T2, T3, T4, T5, T6, T7, T8, R> FuncN<R> fromFunc(final Func9<T0, T1, T2, T3, T4, T5, T6, T7, T8, R> f) {
+    public static <T0, T1, T2, T3, T4, T5, T6, T7, T8, R> FuncN<R> fromFunc(final Func9<? super T0, ? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? extends R> f) {
         return new FuncN<R>() {
 
             @SuppressWarnings("unchecked")
@@ -304,7 +253,7 @@ public Void call(Object... args) {
      * @param f
      * @return {@link FuncN}
      */
-    public static <T0> FuncN<Void> fromAction(final Action1<T0> f) {
+    public static <T0> FuncN<Void> fromAction(final Action1<? super T0> f) {
         return new FuncN<Void>() {
 
             @SuppressWarnings("unchecked")
@@ -326,7 +275,7 @@ public Void call(Object... args) {
      * @param f
      * @return {@link FuncN}
      */
-    public static <T0, T1> FuncN<Void> fromAction(final Action2<T0, T1> f) {
+    public static <T0, T1> FuncN<Void> fromAction(final Action2<? super T0, ? super T1> f) {
         return new FuncN<Void>() {
 
             @SuppressWarnings("unchecked")
@@ -348,7 +297,7 @@ public Void call(Object... args) {
      * @param f
      * @return {@link FuncN}
      */
-    public static <T0, T1, T2> FuncN<Void> fromAction(final Action3<T0, T1, T2> f) {
+    public static <T0, T1, T2> FuncN<Void> fromAction(final Action3<? super T0, ? super T1, ? super T2> f) {
         return new FuncN<Void>() {
 
             @SuppressWarnings("unchecked")
@@ -364,14 +313,17 @@ public Void call(Object... args) {
         };
     }
 
-    @SuppressWarnings("unchecked")
-    public static <T> Func1<T, Boolean> alwaysTrue() {
-        return (Func1<T, Boolean>) AlwaysTrue.INSTANCE;
+    public static <T> Func1<? super T, Boolean> alwaysTrue() {
+        return AlwaysTrue.INSTANCE;
     }
 
-    @SuppressWarnings("unchecked")
     public static <T> Func1<T, T> identity() {
-        return (Func1<T, T>) Identity.INSTANCE;
+        return new Func1<T, T>() {
+            @Override
+            public T call(T o) {
+                return o;
+            }
+        };
     }
 
     private enum AlwaysTrue implements Func1<Object, Boolean> {
@@ -382,14 +334,4 @@ public Boolean call(Object o) {
             return true;
         }
     }
-
-    private enum Identity implements Func1<Object, Object> {
-        INSTANCE;
-
-        @Override
-        public Object call(Object o) {
-            return o;
-        }
-    }
-
 }
diff --git a/rxjava-core/src/test/java/rx/CovarianceTest.java b/rxjava-core/src/test/java/rx/CovarianceTest.java
new file mode 100644
index 0000000000..2594f27677
--- /dev/null
+++ b/rxjava-core/src/test/java/rx/CovarianceTest.java
@@ -0,0 +1,112 @@
+package rx;
+
+import java.util.ArrayList;
+
+import org.junit.Test;
+
+import rx.util.functions.Action1;
+import rx.util.functions.Func2;
+
+/**
+ * Test super/extends of generics.
+ * 
+ * See https://github.com/Netflix/RxJava/pull/331
+ */
+public class CovarianceTest {
+
+    /**
+     * This won't compile if super/extends isn't done correctly on generics
+     */
+    @Test
+    public void testCovarianceOfFrom() {
+        Observable.<Movie>from(new HorrorMovie());
+        Observable.<Movie>from(new ArrayList<HorrorMovie>());
+        // Observable.<HorrorMovie>from(new Movie()); // may not compile
+    }
+    
+    /**
+     * This won't compile if super/extends isn't done correctly on generics
+     */
+    @Test
+    public void testCovarianceOfMerge() {
+        Observable<HorrorMovie> horrors = Observable.from(new HorrorMovie());
+        Observable<Observable<HorrorMovie>> metaHorrors = Observable.just(horrors);
+        Observable.<Media>merge(metaHorrors);
+    }
+    
+    /**
+     * This won't compile if super/extends isn't done correctly on generics
+     */
+    @Test
+    public void testCovarianceOfZip() {
+        Observable<HorrorMovie> horrors = Observable.from(new HorrorMovie());
+        Observable<CoolRating> ratings = Observable.from(new CoolRating());
+
+        Observable.<Movie, CoolRating, Result> zip(horrors, ratings, combine).toBlockingObservable().forEach(action);
+        Observable.<Movie, CoolRating, Result> zip(horrors, ratings, combine).toBlockingObservable().forEach(action);
+        Observable.<Media, Rating, ExtendedResult> zip(horrors, ratings, combine).toBlockingObservable().forEach(extendedAction);
+        Observable.<Media, Rating, Result> zip(horrors, ratings, combine).toBlockingObservable().forEach(action);
+        Observable.<Media, Rating, ExtendedResult> zip(horrors, ratings, combine).toBlockingObservable().forEach(action);
+        
+        Observable.<Movie, CoolRating, Result> zip(horrors, ratings, combine);
+    }
+
+    /**
+     * This won't compile if super/extends isn't done correctly on generics
+     */
+    @Test
+    public void testCovarianceOfCombineLatest() {
+        Observable<HorrorMovie> horrors = Observable.from(new HorrorMovie());
+        Observable<CoolRating> ratings = Observable.from(new CoolRating());
+
+        Observable.<Movie, CoolRating, Result> combineLatest(horrors, ratings, combine).toBlockingObservable().forEach(action);
+        Observable.<Movie, CoolRating, Result> combineLatest(horrors, ratings, combine).toBlockingObservable().forEach(action);
+        Observable.<Media, Rating, ExtendedResult> combineLatest(horrors, ratings, combine).toBlockingObservable().forEach(extendedAction);
+        Observable.<Media, Rating, Result> combineLatest(horrors, ratings, combine).toBlockingObservable().forEach(action);
+        Observable.<Media, Rating, ExtendedResult> combineLatest(horrors, ratings, combine).toBlockingObservable().forEach(action);
+        
+        Observable.<Movie, CoolRating, Result> combineLatest(horrors, ratings, combine);
+    }
+
+    Func2<Media, Rating, ExtendedResult> combine = new Func2<Media, Rating, ExtendedResult>() {
+        @Override
+        public ExtendedResult call(Media m, Rating r) {
+            return new ExtendedResult();
+        }
+    };
+
+    Action1<Result> action = new Action1<Result>() {
+        @Override
+        public void call(Result t1) {
+            System.out.println("Result: " + t1);
+        }
+    };
+    
+    Action1<ExtendedResult> extendedAction = new Action1<ExtendedResult>() {
+        @Override
+        public void call(ExtendedResult t1) {
+            System.out.println("Result: " + t1);
+        }
+    };
+    
+    static class Media {
+    }
+
+    static class Movie extends Media {
+    }
+
+    static class HorrorMovie extends Movie {
+    }
+
+    static class Rating {
+    }
+
+    static class CoolRating extends Rating {
+    }
+
+    static class Result {
+    }
+
+    static class ExtendedResult extends Result {
+    }
+}
diff --git a/rxjava-core/src/test/java/rx/ObservableTests.java b/rxjava-core/src/test/java/rx/ObservableTests.java
index 2967a2c626..12e2657a8e 100644
--- a/rxjava-core/src/test/java/rx/ObservableTests.java
+++ b/rxjava-core/src/test/java/rx/ObservableTests.java
@@ -50,10 +50,10 @@ public void before() {
     @Test
     public void testCreate() {
 
-        Observable<String> observable = Observable.create(new Func1<Observer<String>, Subscription>() {
+        Observable<String> observable = Observable.create(new Func1<Observer<? super String>, Subscription>() {
 
             @Override
-            public Subscription call(Observer<String> Observer) {
+            public Subscription call(Observer<? super String> Observer) {
                 Observer.onNext("one");
                 Observer.onNext("two");
                 Observer.onNext("three");
@@ -121,10 +121,10 @@ public void testOnSubscribeFails() {
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
         final RuntimeException re = new RuntimeException("bad impl");
-        Observable<String> o = Observable.create(new Func1<Observer<String>, Subscription>() {
+        Observable<String> o = Observable.create(new Func1<Observer<? super String>, Subscription>() {
 
             @Override
-            public Subscription call(Observer<String> t1) {
+            public Subscription call(Observer<? super String> t1) {
                 throw re;
             }
 
@@ -161,10 +161,10 @@ public void testCustomObservableWithErrorInObserverAsynchronous() throws Interru
         final CountDownLatch latch = new CountDownLatch(1);
         final AtomicInteger count = new AtomicInteger();
         final AtomicReference<Throwable> error = new AtomicReference<Throwable>();
-        Observable.create(new Func1<Observer<String>, Subscription>() {
+        Observable.create(new Func1<Observer<? super String>, Subscription>() {
 
             @Override
-            public Subscription call(final Observer<String> observer) {
+            public Subscription call(final Observer<? super String> observer) {
                 final BooleanSubscription s = new BooleanSubscription();
                 new Thread(new Runnable() {
 
@@ -227,10 +227,10 @@ public void onNext(String v) {
     public void testCustomObservableWithErrorInObserverSynchronous() {
         final AtomicInteger count = new AtomicInteger();
         final AtomicReference<Throwable> error = new AtomicReference<Throwable>();
-        Observable.create(new Func1<Observer<String>, Subscription>() {
+        Observable.create(new Func1<Observer<? super String>, Subscription>() {
 
             @Override
-            public Subscription call(Observer<String> observer) {
+            public Subscription call(Observer<? super String> observer) {
                 observer.onNext("1");
                 observer.onNext("2");
                 observer.onNext("three");
@@ -278,10 +278,10 @@ public void onNext(String v) {
     public void testCustomObservableWithErrorInObservableSynchronous() {
         final AtomicInteger count = new AtomicInteger();
         final AtomicReference<Throwable> error = new AtomicReference<Throwable>();
-        Observable.create(new Func1<Observer<String>, Subscription>() {
+        Observable.create(new Func1<Observer<? super String>, Subscription>() {
 
             @Override
-            public Subscription call(Observer<String> observer) {
+            public Subscription call(Observer<? super String> observer) {
                 observer.onNext("1");
                 observer.onNext("2");
                 throw new NumberFormatException();
@@ -317,10 +317,10 @@ public void onNext(String v) {
     @Test
     public void testPublish() throws InterruptedException {
         final AtomicInteger counter = new AtomicInteger();
-        ConnectableObservable<String> o = Observable.create(new Func1<Observer<String>, Subscription>() {
+        ConnectableObservable<String> o = Observable.create(new Func1<Observer<? super String>, Subscription>() {
 
             @Override
-            public Subscription call(final Observer<String> observer) {
+            public Subscription call(final Observer<? super String> observer) {
                 final BooleanSubscription subscription = new BooleanSubscription();
                 new Thread(new Runnable() {
 
@@ -371,10 +371,10 @@ public void call(String v) {
     @Test
     public void testReplay() throws InterruptedException {
         final AtomicInteger counter = new AtomicInteger();
-        ConnectableObservable<String> o = Observable.create(new Func1<Observer<String>, Subscription>() {
+        ConnectableObservable<String> o = Observable.create(new Func1<Observer<? super String>, Subscription>() {
 
             @Override
-            public Subscription call(final Observer<String> observer) {
+            public Subscription call(final Observer<? super String> observer) {
                 final BooleanSubscription subscription = new BooleanSubscription();
                 new Thread(new Runnable() {
 
@@ -428,10 +428,10 @@ public void call(String v) {
     @Test
     public void testCache() throws InterruptedException {
         final AtomicInteger counter = new AtomicInteger();
-        Observable<String> o = Observable.create(new Func1<Observer<String>, Subscription>() {
+        Observable<String> o = Observable.create(new Func1<Observer<? super String>, Subscription>() {
 
             @Override
-            public Subscription call(final Observer<String> observer) {
+            public Subscription call(final Observer<? super String> observer) {
                 final BooleanSubscription subscription = new BooleanSubscription();
                 new Thread(new Runnable() {
 
@@ -516,10 +516,10 @@ public void call(Object t1) {
     public void testErrorThrownWithoutErrorHandlerAsynchronous() throws InterruptedException {
         final CountDownLatch latch = new CountDownLatch(1);
         final AtomicReference<Throwable> exception = new AtomicReference<Throwable>();
-        Observable.create(new Func1<Observer<String>, Subscription>() {
+        Observable.create(new Func1<Observer<? super String>, Subscription>() {
 
             @Override
-            public Subscription call(final Observer<String> observer) {
+            public Subscription call(final Observer<? super String> observer) {
                 new Thread(new Runnable() {
 
                     @Override
diff --git a/rxjava-core/src/test/java/rx/concurrency/TestSchedulers.java b/rxjava-core/src/test/java/rx/concurrency/TestSchedulers.java
index 4bc8fe993b..b91479a14d 100644
--- a/rxjava-core/src/test/java/rx/concurrency/TestSchedulers.java
+++ b/rxjava-core/src/test/java/rx/concurrency/TestSchedulers.java
@@ -252,9 +252,9 @@ public void call(Integer t) {
 
     @Test
     public void testRecursiveScheduler1() {
-        Observable<Integer> obs = Observable.create(new Func1<Observer<Integer>, Subscription>() {
+        Observable<Integer> obs = Observable.create(new Func1<Observer<? super Integer>, Subscription>() {
             @Override
-            public Subscription call(final Observer<Integer> observer) {
+            public Subscription call(final Observer<? super Integer> observer) {
                 return Schedulers.currentThread().schedule(0, new Func2<Scheduler, Integer, Subscription>() {
                     @Override
                     public Subscription call(Scheduler scheduler, Integer i) {
@@ -290,9 +290,9 @@ public void testRecursiveScheduler2() throws InterruptedException {
         final CountDownLatch latch = new CountDownLatch(10);
         final CountDownLatch completionLatch = new CountDownLatch(1);
 
-        Observable<Integer> obs = Observable.create(new Func1<Observer<Integer>, Subscription>() {
+        Observable<Integer> obs = Observable.create(new Func1<Observer<? super Integer>, Subscription>() {
             @Override
-            public Subscription call(final Observer<Integer> observer) {
+            public Subscription call(final Observer<? super Integer> observer) {
 
                 return Schedulers.threadPoolForComputation().schedule(new BooleanSubscription(), new Func2<Scheduler, BooleanSubscription, Subscription>() {
                     @Override
@@ -393,10 +393,10 @@ public void testConcurrentOnNextFailsValidation() throws InterruptedException {
 
         final int count = 10;
         final CountDownLatch latch = new CountDownLatch(count);
-        Observable<String> o = Observable.create(new Func1<Observer<String>, Subscription>() {
+        Observable<String> o = Observable.create(new Func1<Observer<? super String>, Subscription>() {
 
             @Override
-            public Subscription call(final Observer<String> observer) {
+            public Subscription call(final Observer<? super String> observer) {
                 for (int i = 0; i < count; i++) {
                     final int v = i;
                     new Thread(new Runnable() {
@@ -453,10 +453,10 @@ public void testSubscribeOnNestedConcurrency() throws InterruptedException {
 
                     @Override
                     public Observable<String> call(final String v) {
-                        return Observable.create(new Func1<Observer<String>, Subscription>() {
+                        return Observable.create(new Func1<Observer<? super String>, Subscription>() {
 
                             @Override
-                            public Subscription call(final Observer<String> observer) {
+                            public Subscription call(final Observer<? super String> observer) {
                                 observer.onNext("value_after_map-" + v);
                                 observer.onCompleted();
                                 return Subscriptions.empty();
diff --git a/rxjava-core/src/test/java/rx/performance/PerformanceTest.java b/rxjava-core/src/test/java/rx/performance/PerformanceTest.java
index 846efb5771..73dcf8c25b 100644
--- a/rxjava-core/src/test/java/rx/performance/PerformanceTest.java
+++ b/rxjava-core/src/test/java/rx/performance/PerformanceTest.java
@@ -207,15 +207,13 @@ public void runNonCompositionalTestWithArrayOfFunctions(AtomicLong aggregateTime
         final AtomicInteger onNextSum = new AtomicInteger(0);
         final long start = System.nanoTime();
         final MathFunction m = new MathFunction();
-        @SuppressWarnings("rawtypes")
-        final Func1[] functionCalls = new Func1<?, ?>[50];
+        final Func1<Integer, Integer>[] functionCalls = new MathFunction[50];
         for (int i = 0; i < 50; i++) {
             functionCalls[i] = m;
         }
 
         Observable.from(values).map(new Func1<Integer, Integer>() {
 
-            @SuppressWarnings("unchecked")
             @Override
             public Integer call(Integer t1) {
                 // iterate the 50 times here in a loop rather than via composition