From 5789894638a62ac17b5276053e3bea8bdd570580 Mon Sep 17 00:00:00 2001
From: Bob Cotton <bob.cotton@rallydev.com>
Date: Sun, 1 Sep 2013 22:14:41 -0600
Subject: [PATCH 1/5] Merge window operator commit to master

This is from commit http://github.com/RallySoftware/RxJava/commit/71335e4ed1531b1542c7b304a6d3337145e0b2df
---
 rxjava-core/src/main/java/rx/Observable.java  | 695 ++++++++--------
 .../java/rx/operators/ChunkedOperation.java   | 587 ++++++++++++++
 .../java/rx/operators/OperationBuffer.java    | 754 +++---------------
 .../java/rx/operators/OperationWindow.java    | 660 +++++++++++++++
 .../util/{BufferClosing.java => Closing.java} |   2 +-
 .../{BufferClosings.java => Closings.java}    |   8 +-
 .../util/{BufferOpening.java => Opening.java} |   2 +-
 .../{BufferOpenings.java => Openings.java}    |   8 +-
 8 files changed, 1715 insertions(+), 1001 deletions(-)
 create mode 100644 rxjava-core/src/main/java/rx/operators/ChunkedOperation.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperationWindow.java
 rename rxjava-core/src/main/java/rx/util/{BufferClosing.java => Closing.java} (95%)
 rename rxjava-core/src/main/java/rx/util/{BufferClosings.java => Closings.java} (82%)
 rename rxjava-core/src/main/java/rx/util/{BufferOpening.java => Opening.java} (95%)
 rename rxjava-core/src/main/java/rx/util/{BufferOpenings.java => Openings.java} (82%)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index dad2ca7286..17b54c7039 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -61,6 +61,7 @@
 import rx.operators.OperationToObservableIterable;
 import rx.operators.OperationToObservableList;
 import rx.operators.OperationToObservableSortedList;
+import rx.operators.OperationWindow;
 import rx.operators.OperationZip;
 import rx.operators.SafeObservableSubscription;
 import rx.operators.SafeObserver;
@@ -71,8 +72,8 @@
 import rx.subjects.ReplaySubject;
 import rx.subjects.Subject;
 import rx.subscriptions.Subscriptions;
-import rx.util.BufferClosing;
-import rx.util.BufferOpening;
+import rx.util.Closing;
+import rx.util.Opening;
 import rx.util.OnErrorNotImplementedException;
 import rx.util.Range;
 import rx.util.Timestamped;
@@ -83,11 +84,6 @@
 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;
 
@@ -102,27 +98,18 @@
  * <p>
  * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/legend.png">
  * <p>
- * For more information see the <a href="https://github.com/Netflix/RxJava/wiki/Observable">RxJava Wiki</a>
+ * For more information see the <a href="https://github.com/Netflix/RxJava/wiki/Observable">RxJava
+ * Wiki</a>
  * 
  * @param <T>
  */
 public class Observable<T> {
 
-    /**
-     * Executed when 'subscribe' is invoked.
-     */
-    private final OnSubscribeFunc<T> onSubscribe;
-
-    /**
-     * Function interface for work to be performed when an {@link Observable} is subscribed to via {@link Observable#subscribe(Observer)}
-     * 
-     * @param <T>
-     */
-    public static interface OnSubscribeFunc<T> extends Function {
+    //TODO use a consistent parameter naming scheme (for example: for all operators that modify a source Observable, the parameter representing that source Observable should have the same name, e.g. "source" -- currently such parameters are named any of "sequence", "that", "source", "items", or "observable")
 
-        public Subscription onSubscribe(Observer<? super T> t1);
+    private final static RxJavaObservableExecutionHook hook = RxJavaPlugins.getInstance().getObservableExecutionHook();
 
-    }
+    private final Func1<Observer<T>, Subscription> onSubscribe;
 
     /**
      * Observable with Function to execute when subscribed to.
@@ -131,14 +118,16 @@ public static interface OnSubscribeFunc<T> extends Function {
      * specifically have a need for inheritance.
      * 
      * @param onSubscribe
-     *            {@link OnSubscribeFunc} to be executed when {@link #subscribe(Observer)} is called.
+     *            {@link Func1} to be executed when {@link #subscribe(Observer)} is called.
      */
-    protected Observable(OnSubscribeFunc<T> onSubscribe) {
+    protected Observable(Func1<Observer<T>, Subscription> onSubscribe) {
         this.onSubscribe = onSubscribe;
     }
 
-    private final static RxJavaObservableExecutionHook hook = RxJavaPlugins.getInstance().getObservableExecutionHook();
-
+    protected Observable() {
+        this(null);
+        //TODO should this be made private to prevent it? It really serves no good purpose and only confuses things. Unit tests are incorrectly using it today
+    }
 
     /**
      * An {@link Observer} must call an Observable's {@code subscribe} method in order to
@@ -167,9 +156,9 @@ protected Observable(OnSubscribeFunc<T> onSubscribe) {
      * @throws IllegalArgumentException
      *             if the {@link Observer} provided as the argument to {@code subscribe()} is {@code null}
      */
-    public Subscription subscribe(Observer<? super T> observer) {
+    public Subscription subscribe(Observer<T> observer) {
         // allow the hook to intercept and/or decorate
-        OnSubscribeFunc<T> onSubscribeFunction = hook.onSubscribeStart(this, onSubscribe);
+        Func1<Observer<T>, Subscription> onSubscribeFunction = hook.onSubscribeStart(this, onSubscribe);
         // validate and proceed
         if (observer == null) {
             throw new IllegalArgumentException("observer can not be null");
@@ -183,7 +172,7 @@ public Subscription subscribe(Observer<? super T> observer) {
              * See https://github.com/Netflix/RxJava/issues/216 for discussion on "Guideline 6.4: Protect calls to user code from within an operator"
              */
             if (isInternalImplementation(observer)) {
-                Subscription s = onSubscribeFunction.onSubscribe(observer);
+                Subscription s = onSubscribeFunction.call(observer);
                 if (s == null) {
                     // this generally shouldn't be the case on a 'trusted' onSubscribe but in case it happens
                     // we want to gracefully handle it the same as AtomicObservableSubscription does
@@ -193,7 +182,7 @@ public Subscription subscribe(Observer<? super T> observer) {
                 }
             } else {
                 SafeObservableSubscription subscription = new SafeObservableSubscription();
-                subscription.wrap(onSubscribeFunction.onSubscribe(new SafeObserver<T>(subscription, observer)));
+                subscription.wrap(onSubscribeFunction.call(new SafeObserver<T>(subscription, observer)));
                 return hook.onSubscribeReturn(this, subscription);
             }
         } catch (OnErrorNotImplementedException e) {
@@ -245,7 +234,7 @@ public Subscription subscribe(Observer<? super T> observer) {
      * @throws IllegalArgumentException
      *             if an argument to {@code subscribe()} is {@code null}
      */
-    public Subscription subscribe(Observer<? super T> observer, Scheduler scheduler) {
+    public Subscription subscribe(Observer<T> observer, Scheduler scheduler) {
         return subscribeOn(scheduler).subscribe(observer);
     }
 
@@ -254,12 +243,12 @@ public Subscription subscribe(Observer<? super 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<? super T> o) {
+    private Subscription protectivelyWrapAndSubscribe(Observer<T> o) {
         SafeObservableSubscription subscription = new SafeObservableSubscription();
         return subscription.wrap(subscribe(new SafeObserver<T>(subscription, o)));
     }
 
-    public Subscription subscribe(final Action1<? super T> onNext) {
+    public Subscription subscribe(final Action1<T> onNext) {
         if (onNext == null) {
             throw new IllegalArgumentException("onNext can not be null");
         }
@@ -290,11 +279,11 @@ public void onNext(T args) {
         });
     }
 
-    public Subscription subscribe(final Action1<? super T> onNext, Scheduler scheduler) {
+    public Subscription subscribe(final Action1<T> onNext, Scheduler scheduler) {
         return subscribeOn(scheduler).subscribe(onNext);
     }
 
-    public Subscription subscribe(final Action1<? super T> onNext, final Action1<Throwable> onError) {
+    public Subscription subscribe(final Action1<T> onNext, final Action1<Throwable> onError) {
         if (onNext == null) {
             throw new IllegalArgumentException("onNext can not be null");
         }
@@ -328,11 +317,11 @@ public void onNext(T args) {
         });
     }
 
-    public Subscription subscribe(final Action1<? super T> onNext, final Action1<Throwable> onError, Scheduler scheduler) {
+    public Subscription subscribe(final Action1<T> onNext, final Action1<Throwable> onError, Scheduler scheduler) {
         return subscribeOn(scheduler).subscribe(onNext, onError);
     }
 
-    public Subscription subscribe(final Action1<? super T> onNext, final Action1<Throwable> onError, final Action0 onComplete) {
+    public Subscription subscribe(final Action1<T> onNext, final Action1<Throwable> onError, final Action0 onComplete) {
         if (onNext == null) {
             throw new IllegalArgumentException("onNext can not be null");
         }
@@ -369,7 +358,7 @@ public void onNext(T args) {
         });
     }
 
-    public Subscription subscribe(final Action1<? super T> onNext, final Action1<Throwable> onError, final Action0 onComplete, Scheduler scheduler) {
+    public Subscription subscribe(final Action1<T> onNext, final Action1<Throwable> onError, final Action0 onComplete, Scheduler scheduler) {
         return subscribeOn(scheduler).subscribe(onNext, onError, onComplete);
     }
 
@@ -409,10 +398,10 @@ private void handleError(Throwable e) {
      */
     private static class NeverObservable<T> extends Observable<T> {
         public NeverObservable() {
-            super(new OnSubscribeFunc<T>() {
+            super(new Func1<Observer<T>, Subscription>() {
 
                 @Override
-                public Subscription onSubscribe(Observer<? super T> t1) {
+                public Subscription call(Observer<T> t1) {
                     return Subscriptions.empty();
                 }
 
@@ -429,7 +418,7 @@ public Subscription onSubscribe(Observer<? super T> t1) {
     private static class ThrowObservable<T> extends Observable<T> {
 
         public ThrowObservable(final Throwable exception) {
-            super(new OnSubscribeFunc<T>() {
+            super(new Func1<Observer<T>, Subscription>() {
 
                 /**
                  * Accepts an {@link Observer} and calls its {@link Observer#onError onError} method.
@@ -439,7 +428,7 @@ public ThrowObservable(final Throwable exception) {
                  * @return a reference to the subscription
                  */
                 @Override
-                public Subscription onSubscribe(Observer<? super T> observer) {
+                public Subscription call(Observer<T> observer) {
                     observer.onError(exception);
                     return Subscriptions.empty();
                 }
@@ -473,7 +462,7 @@ public Subscription onSubscribe(Observer<? super T> observer) {
      * @return an Observable that, when an {@link Observer} subscribes to it, will execute the given
      *         function
      */
-    public static <T> Observable<T> create(OnSubscribeFunc<T> func) {
+    public static <T> Observable<T> create(Func1<Observer<T>, Subscription> func) {
         return new Observable<T>(func);
     }
 
@@ -522,7 +511,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<? extends T> iterable) {
+    public static <T> Observable<T> from(Iterable<T> iterable) {
         return create(OperationToObservableIterable.toObservableIterable(iterable));
     }
 
@@ -586,7 +575,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<? extends Observable<? extends T>> observableFactory) {
+    public static <T> Observable<T> defer(Func0<Observable<T>> observableFactory) {
         return create(OperationDefer.defer(observableFactory));
     }
 
@@ -629,7 +618,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<? extends Observable<? extends T>> source) {
+    public static <T> Observable<T> merge(List<Observable<T>> source) {
         return create(OperationMerge.merge(source));
     }
 
@@ -648,7 +637,7 @@ public static <T> Observable<T> merge(List<? extends Observable<? extends T>> so
      *         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<? extends Observable<? extends T>> source) {
+    public static <T> Observable<T> merge(Observable<Observable<T>> source) {
         return create(OperationMerge.merge(source));
     }
 
@@ -666,7 +655,7 @@ public static <T> Observable<T> merge(Observable<? extends Observable<? extends
      *         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<? extends T>... source) {
+    public static <T> Observable<T> merge(Observable<T>... source) {
         return create(OperationMerge.merge(source));
     }
 
@@ -682,7 +671,7 @@ public static <T> Observable<T> merge(Observable<? extends 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<? extends T>... source) {
+    public static <T> Observable<T> concat(Observable<T>... source) {
         return create(OperationConcat.concat(source));
     }
 
@@ -706,7 +695,7 @@ public static <T> Observable<T> concat(Observable<? extends 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<? extends Observable<? extends T>> source) {
+    public static <T> Observable<T> mergeDelayError(List<Observable<T>> source) {
         return create(OperationMergeDelayError.mergeDelayError(source));
     }
 
@@ -730,7 +719,7 @@ public static <T> Observable<T> mergeDelayError(List<? extends Observable<? exte
      *         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<? extends Observable<? extends T>> source) {
+    public static <T> Observable<T> mergeDelayError(Observable<Observable<T>> source) {
         return create(OperationMergeDelayError.mergeDelayError(source));
     }
 
@@ -754,7 +743,7 @@ public static <T> Observable<T> mergeDelayError(Observable<? extends Observable<
      *         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<? extends T>... source) {
+    public static <T> Observable<T> mergeDelayError(Observable<T>... source) {
         return create(OperationMergeDelayError.mergeDelayError(source));
     }
 
@@ -784,7 +773,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<? extends Observable<? extends T>> sequenceOfSequences) {
+    public static <T> Observable<T> switchDo(Observable<Observable<T>> sequenceOfSequences) {
         // TODO should this static remain? I have left it because it is an Observable<Observable>
         return create(OperationSwitch.switchDo(sequenceOfSequences));
     }
@@ -804,7 +793,7 @@ public static <T> Observable<T> switchDo(Observable<? extends Observable<? exten
     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<? extends Observable<? extends T>>) this));
+        return create(OperationSwitch.switchDo((Observable<Observable<T>>) this));
     }
 
     /**
@@ -824,7 +813,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<? extends T> observable) {
+    public static <T> Observable<T> synchronize(Observable<T> observable) {
         return create(OperationSynchronize.synchronize(observable));
     }
 
@@ -857,7 +846,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<? extends T> future) {
+    public static <T> Observable<T> from(Future<T> future) {
         return create(OperationToObservableFuture.toObservableFuture(future));
     }
 
@@ -880,7 +869,7 @@ public static <T> Observable<T> from(Future<? extends 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<? extends T> future, Scheduler scheduler) {
+    public static <T> Observable<T> from(Future<T> future, Scheduler scheduler) {
         return create(OperationToObservableFuture.toObservableFuture(future)).subscribeOn(scheduler);
     }
 
@@ -906,7 +895,7 @@ public static <T> Observable<T> from(Future<? extends T> future, Scheduler sched
      *            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<? extends T> future, long timeout, TimeUnit unit) {
+    public static <T> Observable<T> from(Future<T> future, long timeout, TimeUnit unit) {
         return create(OperationToObservableFuture.toObservableFuture(future, timeout, unit));
     }
 
@@ -920,17 +909,18 @@ public static <T> Observable<T> from(Future<? extends T> future, long timeout, T
      * 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
+     * @param w0
      *            one source Observable
-     * @param o2
+     * @param w1
      *            another 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
+     * @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
      * @return an Observable that emits the zipped results
      */
-    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));
+    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));
     }
 
     /**
@@ -948,7 +938,7 @@ public static <T1, T2, R> Observable<R> zip(Observable<? extends T1> o1, Observa
      * @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<? extends T> first, Observable<? extends T> second) {
+    public static <T> Observable<Boolean> sequenceEqual(Observable<T> first, Observable<T> second) {
         return sequenceEqual(first, second, new Func2<T, T, Boolean>() {
             @Override
             public Boolean call(T first, T second) {
@@ -975,7 +965,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<? extends T> first, Observable<? extends T> second, Func2<? super T, ? super T, Boolean> equality) {
+    public static <T> Observable<Boolean> sequenceEqual(Observable<T> first, Observable<T> second, Func2<T, T, Boolean> equality) {
         return zip(first, second, equality);
     }
 
@@ -992,19 +982,19 @@ public static <T> Observable<Boolean> sequenceEqual(Observable<? extends T> firs
      * 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
+     * @param w0
      *            one source Observable
-     * @param o2
-     *            a second source Observable
-     * @param o3
+     * @param w1
+     *            another source Observable
+     * @param w2
      *            a third source Observable
-     * @param zipFunction
+     * @param function
      *            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, 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));
+    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));
     }
 
     /**
@@ -1021,210 +1011,21 @@ public static <T1, T2, T3, R> Observable<R> zip(Observable<? extends T1> o1, Obs
      * 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 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
+     * @param w0
      *            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
+     * @param w1
+     *            another source Observable
+     * @param w2
      *            a third source Observable
-     * @param o4
+     * @param w3
      *            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 o9
-     *            a ninth source Observable
-     * @param zipFunction
+     * @param reduceFunction
      *            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, 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));
+    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));
     }
 
     /**
@@ -1233,89 +1034,48 @@ public static <T1, T2, T3, T4, T5, T6, T7, T8, T9, R> Observable<R> zip(Observab
      * <p>
      * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/combineLatest.png">
      * 
-     * @param o1
+     * @param w0
      *            The first source observable.
-     * @param o2
+     * @param w1
      *            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 <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));
+    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));
     }
 
     /**
      * @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));
+    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));
     }
 
     /**
      * @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 <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 <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));
+    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));
     }
 
     /**
      * Creates an Observable which produces buffers of collected values.
      * 
      * <p>This Observable produces connected non-overlapping buffers. The current buffer is
-     * emitted and replaced with a new buffer when the Observable produced by the specified {@link Func0} produces a {@link BufferClosing} object. The * {@link Func0} will then
+     * emitted and replaced with a new buffer when the Observable produced by the specified {@link Func0} produces a {@link rx.util.Closing} object. The * {@link Func0} will then
      * be used to create a new Observable to listen for the end of the next buffer.
      * 
      * @param bufferClosingSelector
      *            The {@link Func0} which is used to produce an {@link Observable} for every buffer created.
-     *            When this {@link Observable} produces a {@link BufferClosing} object, the associated buffer
+     *            When this {@link Observable} produces a {@link rx.util.Closing} object, the associated buffer
      *            is emitted and replaced with a new one.
      * @return
      *         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.
+     *         when the current {@link Observable} created with the {@link Func0} argument produces a {@link rx.util.Closing} object.
      */
-    public Observable<List<T>> buffer(Func0<? extends Observable<? extends BufferClosing>> bufferClosingSelector) {
+    public Observable<List<T>> buffer(Func0<Observable<Closing>> bufferClosingSelector) {
         return create(OperationBuffer.buffer(this, bufferClosingSelector));
     }
 
@@ -1323,21 +1083,21 @@ public Observable<List<T>> buffer(Func0<? extends Observable<? extends BufferClo
      * Creates an Observable which produces buffers of collected values.
      * 
      * <p>This Observable produces buffers. Buffers are created when the specified "bufferOpenings"
-     * Observable produces a {@link BufferOpening} object. Additionally the {@link Func0} argument
-     * is used to create an Observable which produces {@link BufferClosing} objects. When this
+     * Observable produces a {@link rx.util.Opening} object. Additionally the {@link Func0} argument
+     * is used to create an Observable which produces {@link rx.util.Closing} objects. When this
      * Observable produces such an object, the associated buffer is emitted.
      * 
      * @param bufferOpenings
-     *            The {@link Observable} which, when it produces a {@link BufferOpening} object, will cause
+     *            The {@link Observable} which, when it produces a {@link rx.util.Opening} object, will cause
      *            another buffer to be created.
      * @param bufferClosingSelector
      *            The {@link Func0} which is used to produce an {@link Observable} for every buffer created.
-     *            When this {@link Observable} produces a {@link BufferClosing} object, the associated buffer
+     *            When this {@link Observable} produces a {@link rx.util.Closing} object, the associated buffer
      *            is emitted.
      * @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<? extends BufferOpening> bufferOpenings, Func1<? super BufferOpening, ? extends Observable<? extends BufferClosing>> bufferClosingSelector) {
+    public Observable<List<T>> buffer(Observable<Opening> bufferOpenings, Func1<Opening, Observable<Closing>> bufferClosingSelector) {
         return create(OperationBuffer.buffer(this, bufferOpenings, bufferClosingSelector));
     }
 
@@ -1503,7 +1263,222 @@ public Observable<List<T>> buffer(long timespan, long timeshift, TimeUnit unit)
     public Observable<List<T>> buffer(long timespan, long timeshift, TimeUnit unit, Scheduler scheduler) {
         return create(OperationBuffer.buffer(this, timespan, timeshift, unit, scheduler));
     }
+    
+    /**
+     * Creates an Observable which produces windows of collected values. This Observable produces connected
+     * non-overlapping windows. The current window is emitted and replaced with a new window when the
+     * Observable produced by the specified {@link Func0} produces a {@link rx.util.Closing} object. The
+     * {@link Func0} will then be used to create a new Observable to listen for the end of the next window.
+     *
+     * @param source
+     *            The source {@link Observable} which produces values.
+     * @param closingSelector
+     *            The {@link Func0} which is used to produce an {@link Observable} for every window created.
+     *            When this {@link Observable} produces a {@link rx.util.Closing} object, the associated window
+     *            is emitted and replaced with a new one.
+     * @return
+     *            An {@link Observable} which produces connected non-overlapping windows, which are emitted
+     *            when the current {@link Observable} created with the {@link Func0} argument produces a
+     *            {@link rx.util.Closing} object.
+     */
+    public Observable<Observable<T>> window(Observable<T> source, Func0<Observable<Closing>> closingSelector) {
+        return create(OperationWindow.window(source, closingSelector));
+    }
+
+    /**
+     * Creates an Observable which produces windows of collected values. This Observable produces windows.
+     * Chunks are created when the specified "windowOpenings" Observable produces a {@link rx.util.Opening} object.
+     * Additionally the {@link Func0} argument is used to create an Observable which produces {@link rx.util.Closing}
+     * objects. When this Observable produces such an object, the associated window is emitted.
+     *
+     * @param source
+     *            The source {@link Observable} which produces values.
+     * @param windowOpenings
+     *            The {@link Observable} which when it produces a {@link rx.util.Opening} object, will cause
+     *            another window to be created.
+     * @param closingSelector
+     *            The {@link Func0} which is used to produce an {@link Observable} for every window created.
+     *            When this {@link Observable} produces a {@link rx.util.Closing} object, the associated window
+     *            is emitted.
+     * @return
+     *            An {@link Observable} which produces windows which are created and emitted when the specified
+     *            {@link Observable}s publish certain objects.
+     */
+    public Observable<Observable<T>> window(Observable<T> source, Observable<Opening> windowOpenings, Func1<Opening, Observable<Closing>> closingSelector) {
+        return create(OperationWindow.window(source, windowOpenings, closingSelector));
+    }
 
+    /**
+     * Creates an Observable which produces windows of collected values. This Observable produces connected
+     * non-overlapping windows, each containing "count" elements. When the source Observable completes or
+     * encounters an error, the current window is emitted, and the event is propagated.
+     *
+     * @param source
+     *            The source {@link Observable} which produces values.
+     * @param count
+     *            The maximum size of each window before it should be emitted.
+     * @return
+     *            An {@link Observable} which produces connected non-overlapping windows containing at most
+     *            "count" produced values.
+     */
+    public Observable<Observable<T>> window(Observable<T> source, int count) {
+        return create(OperationWindow.window(source, count));
+    }
+
+    /**
+     * Creates an Observable which produces windows of collected values. This Observable produces windows every
+     * "skip" values, each containing "count" elements. When the source Observable completes or encounters an error,
+     * the current window is emitted and the event is propagated.
+     *
+     * @param source
+     *            The source {@link Observable} which produces values.
+     * @param count
+     *            The maximum size of each window before it should be emitted.
+     * @param skip
+     *            How many produced values need to be skipped before starting a new window. Note that when "skip" and
+     *            "count" are equals that this is the same operation as {@link Observable#window(Observable, int)}.
+     * @return
+     *            An {@link Observable} which produces windows every "skipped" values containing at most
+     *            "count" produced values.
+     */
+    public Observable<Observable<T>> window(Observable<T> source, int count, int skip) {
+        return create(OperationWindow.window(source, count, skip));
+    }
+
+    /**
+     * Creates an Observable which produces windows of collected values. This Observable produces connected
+     * non-overlapping windows, each of a fixed duration specified by the "timespan" argument. When the source
+     * Observable completes or encounters an error, the current window is emitted and the event is propagated.
+     *
+     * @param source
+     *            The source {@link Observable} which produces values.
+     * @param timespan
+     *            The period of time each window is collecting values before it should be emitted, and
+     *            replaced with a new window.
+     * @param unit
+     *            The unit of time which applies to the "timespan" argument.
+     * @return
+     *            An {@link Observable} which produces connected non-overlapping windows with a fixed duration.
+     */
+    public Observable<Observable<T>> window(Observable<T> source, long timespan, TimeUnit unit) {
+        return create(OperationWindow.window(source, timespan, unit));
+    }
+
+    /**
+     * Creates an Observable which produces windows of collected values. This Observable produces connected
+     * non-overlapping windows, each of a fixed duration specified by the "timespan" argument. When the source
+     * Observable completes or encounters an error, the current window is emitted and the event is propagated.
+     *
+     * @param source
+     *            The source {@link Observable} which produces values.
+     * @param timespan
+     *            The period of time each window is collecting values before it should be emitted, and
+     *            replaced with a new window.
+     * @param unit
+     *            The unit of time which applies to the "timespan" argument.
+     * @param scheduler
+     *            The {@link Scheduler} to use when determining the end and start of a window.
+     * @return
+     *            An {@link Observable} which produces connected non-overlapping windows with a fixed duration.
+     */
+    public Observable<Observable<T>> window(Observable<T> source, long timespan, TimeUnit unit, Scheduler scheduler) {
+        return create(OperationWindow.window(source, timespan, unit, scheduler));
+    }
+
+    /**
+     * Creates an Observable which produces windows of collected values. This Observable produces connected
+     * non-overlapping windows, each of a fixed duration specified by the "timespan" argument or a maximum size
+     * specified by the "count" argument (which ever is reached first). When the source Observable completes
+     * or encounters an error, the current window is emitted and the event is propagated.
+     *
+     * @param source
+     *            The source {@link Observable} which produces values.
+     * @param timespan
+     *            The period of time each window is collecting values before it should be emitted, and
+     *            replaced with a new window.
+     * @param unit
+     *            The unit of time which applies to the "timespan" argument.
+     * @param count
+     *            The maximum size of each window before it should be emitted.
+     * @return
+     *            An {@link Observable} which produces connected non-overlapping windows which are emitted after
+     *            a fixed duration or when the window has reached maximum capacity (which ever occurs first).
+     */
+    public Observable<Observable<T>> window(Observable<T> source, long timespan, TimeUnit unit, int count) {
+        return create(OperationWindow.window(source, timespan, unit, count));
+    }
+
+    /**
+     * Creates an Observable which produces windows of collected values. This Observable produces connected
+     * non-overlapping windows, each of a fixed duration specified by the "timespan" argument or a maximum size
+     * specified by the "count" argument (which ever is reached first). When the source Observable completes
+     * or encounters an error, the current window is emitted and the event is propagated.
+     *
+     * @param source
+     *            The source {@link Observable} which produces values.
+     * @param timespan
+     *            The period of time each window is collecting values before it should be emitted, and
+     *            replaced with a new window.
+     * @param unit
+     *            The unit of time which applies to the "timespan" argument.
+     * @param count
+     *            The maximum size of each window before it should be emitted.
+     * @param scheduler
+     *            The {@link Scheduler} to use when determining the end and start of a window.
+     * @return
+     *            An {@link Observable} which produces connected non-overlapping windows which are emitted after
+     *            a fixed duration or when the window has reached maximum capacity (which ever occurs first).
+     */
+    public Observable<Observable<T>> window(Observable<T> source, long timespan, TimeUnit unit, int count, Scheduler scheduler) {
+        return create(OperationWindow.window(source, timespan, unit, count, scheduler));
+    }
+
+    /**
+     * Creates an Observable which produces windows of collected values. This Observable starts a new window
+     * periodically, which is determined by the "timeshift" argument. Each window is emitted after a fixed timespan
+     * specified by the "timespan" argument. When the source Observable completes or encounters an error, the
+     * current window is emitted and the event is propagated.
+     *
+     * @param source
+     *            The source {@link Observable} which produces values.
+     * @param timespan
+     *            The period of time each window is collecting values before it should be emitted.
+     * @param timeshift
+     *            The period of time after which a new window will be created.
+     * @param unit
+     *            The unit of time which applies to the "timespan" and "timeshift" argument.
+     * @return
+     *            An {@link Observable} which produces new windows periodically, and these are emitted after
+     *            a fixed timespan has elapsed.
+     */
+    public Observable<Observable<T>> window(Observable<T> source, long timespan, long timeshift, TimeUnit unit) {
+        return create(OperationWindow.window(source, timespan, timeshift, unit));
+    }
+
+    /**
+     * Creates an Observable which produces windows of collected values. This Observable starts a new window
+     * periodically, which is determined by the "timeshift" argument. Each window is emitted after a fixed timespan
+     * specified by the "timespan" argument. When the source Observable completes or encounters an error, the
+     * current window is emitted and the event is propagated.
+     *
+     * @param source
+     *            The source {@link Observable} which produces values.
+     * @param timespan
+     *            The period of time each window is collecting values before it should be emitted.
+     * @param timeshift
+     *            The period of time after which a new window will be created.
+     * @param unit
+     *            The unit of time which applies to the "timespan" and "timeshift" argument.
+     * @param scheduler
+     *            The {@link Scheduler} to use when determining the end and start of a window.
+     * @return
+     *            An {@link Observable} which produces new windows periodically, and these are emitted after
+     *            a fixed timespan has elapsed.
+     */
+    public Observable<Observable<T>> window(Observable<T> source, long timespan, long timeshift, TimeUnit unit, Scheduler scheduler) {
+        return create(OperationWindow.window(source, timespan, timeshift, unit, scheduler));
+    }
+    
     /**
      * 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.
@@ -1519,16 +1494,16 @@ public Observable<List<T>> buffer(long timespan, long timeshift, TimeUnit unit,
      * 
      * @param ws
      *            An Observable of source Observables
-     * @param zipFunction
+     * @param reduceFunction
      *            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<? extends Observable<?>> ws, final FuncN<? extends R> zipFunction) {
-        return ws.toList().mapMany(new Func1<List<? extends Observable<?>>, Observable<? extends R>>() {
+    public static <R> Observable<R> zip(Observable<Observable<?>> ws, final FuncN<R> reduceFunction) {
+        return ws.toList().mapMany(new Func1<List<Observable<?>>, Observable<R>>() {
             @Override
-            public Observable<R> call(List<? extends Observable<?>> wsList) {
-                return create(OperationZip.zip(wsList, zipFunction));
+            public Observable<R> call(List<Observable<?>> wsList) {
+                return create(OperationZip.zip(wsList, reduceFunction));
             }
         });
     }
@@ -1548,13 +1523,13 @@ public Observable<R> call(List<? extends Observable<?>> wsList) {
      * 
      * @param ws
      *            A collection of source Observables
-     * @param zipFunction
+     * @param reduceFunction
      *            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<? extends Observable<?>> ws, FuncN<? extends R> zipFunction) {
-        return create(OperationZip.zip(ws, zipFunction));
+    public static <R> Observable<R> zip(Collection<Observable<?>> ws, FuncN<R> reduceFunction) {
+        return create(OperationZip.zip(ws, reduceFunction));
     }
 
     /**
@@ -1566,7 +1541,7 @@ public static <R> Observable<R> zip(Collection<? extends Observable<?>> ws, Func
      * @return an Observable that emits only those items in the original Observable that the filter
      *         evaluates as {@code true}
      */
-    public Observable<T> filter(Func1<? super T, Boolean> predicate) {
+    public Observable<T> filter(Func1<T, Boolean> predicate) {
         return create(OperationFilter.filter(this, predicate));
     }
 
@@ -1601,7 +1576,7 @@ public Observable<T> finallyDo(Action0 action) {
      *         obtained from this transformation.
      * @see #mapMany(Func1)
      */
-    public <R> Observable<R> flatMap(Func1<? super T, ? extends Observable<? extends R>> func) {
+    public <R> Observable<R> flatMap(Func1<T, Observable<R>> func) {
         return mapMany(func);
     }
 
@@ -1615,7 +1590,7 @@ public <R> Observable<R> flatMap(Func1<? super T, ? extends Observable<? extends
      *         evaluates as {@code true}
      * @see #filter(Func1)
      */
-    public Observable<T> where(Func1<? super T, Boolean> predicate) {
+    public Observable<T> where(Func1<T, Boolean> predicate) {
         return filter(predicate);
     }
 
@@ -1630,7 +1605,7 @@ public Observable<T> where(Func1<? super 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<? super T, ? extends R> func) {
+    public <R> Observable<R> map(Func1<T, R> func) {
         return create(OperationMap.map(this, func));
     }
 
@@ -1651,7 +1626,7 @@ public <R> Observable<R> map(Func1<? super T, ? extends R> func) {
      *         obtained from this transformation.
      * @see #flatMap(Func1)
      */
-    public <R> Observable<R> mapMany(Func1<? super T, ? extends Observable<? extends R>> func) {
+    public <R> Observable<R> mapMany(Func1<T, Observable<R>> func) {
         return create(OperationMap.mapMany(this, func));
     }
 
@@ -1710,7 +1685,7 @@ public Observable<T> observeOn(Scheduler scheduler) {
      */
     @SuppressWarnings("unchecked")
     public <T2> Observable<T2> dematerialize() {
-        return create(OperationDematerialize.dematerialize((Observable<? extends Notification<? extends T2>>) this));
+        return create(OperationDematerialize.dematerialize((Observable<Notification<T2>>) this));
     }
 
     /**
@@ -1737,7 +1712,7 @@ public <T2> Observable<T2> dematerialize() {
      *            encounters an error
      * @return the original Observable, with appropriately modified behavior
      */
-    public Observable<T> onErrorResumeNext(final Func1<Throwable, ? extends Observable<? extends T>> resumeFunction) {
+    public Observable<T> onErrorResumeNext(final Func1<Throwable, Observable<T>> resumeFunction) {
         return create(OperationOnErrorResumeNextViaFunction.onErrorResumeNextViaFunction(this, resumeFunction));
     }
 
@@ -1765,7 +1740,7 @@ public Observable<T> onErrorResumeNext(final Func1<Throwable, ? extends Observab
      *            encounters an error
      * @return the original Observable, with appropriately modified behavior
      */
-    public Observable<T> onErrorResumeNext(final Observable<? extends T> resumeSequence) {
+    public Observable<T> onErrorResumeNext(final Observable<T> resumeSequence) {
         return create(OperationOnErrorResumeNextViaObservable.onErrorResumeNextViaObservable(this, resumeSequence));
     }
 
@@ -1795,7 +1770,7 @@ public Observable<T> onErrorResumeNext(final Observable<? extends T> resumeSeque
      *            encounters an error
      * @return the original Observable, with appropriately modified behavior
      */
-    public Observable<T> onExceptionResumeNext(final Observable<? extends T> resumeSequence) {
+    public Observable<T> onExceptionResumeNext(final Observable<T> resumeSequence) {
         return create(OperationOnExceptionResumeNextViaObservable.onExceptionResumeNextViaObservable(this, resumeSequence));
     }
 
@@ -1822,7 +1797,7 @@ public Observable<T> onExceptionResumeNext(final Observable<? extends T> resumeS
      *            Observable encounters an error
      * @return the original Observable with appropriately modified behavior
      */
-    public Observable<T> onErrorReturn(Func1<Throwable, ? extends T> resumeFunction) {
+    public Observable<T> onErrorReturn(Func1<Throwable, T> resumeFunction) {
         return create(OperationOnErrorReturn.onErrorReturn(this, resumeFunction));
     }
 
@@ -1847,7 +1822,7 @@ public Observable<T> onErrorReturn(Func1<Throwable, ? extends 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<? super T, ? super T, ? extends T> accumulator) {
+    public Observable<T> reduce(Func2<T, T, T> accumulator) {
         return create(OperationScan.scan(this, accumulator)).takeLast(1);
     }
 
@@ -1904,7 +1879,7 @@ public ConnectableObservable<T> publish() {
      * 
      * @see #reduce(Func2)
      */
-    public Observable<T> aggregate(Func2<? super T, ? super T, ? extends T> accumulator) {
+    public Observable<T> aggregate(Func2<T, T, T> accumulator) {
         return reduce(accumulator);
     }
 
@@ -1931,7 +1906,7 @@ public Observable<T> aggregate(Func2<? super T, ? super T, ? extends T> accumula
      * @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<? super R, ? super T, ? extends R> accumulator) {
+    public <R> Observable<R> reduce(R initialValue, Func2<R, T, R> accumulator) {
         return create(OperationScan.scan(this, initialValue, accumulator)).takeLast(1);
     }
 
@@ -1942,7 +1917,7 @@ public <R> Observable<R> reduce(R initialValue, Func2<? super R, ? super T, ? ex
      * 
      * @see #reduce(Object, Func2)
      */
-    public <R> Observable<R> aggregate(R initialValue, Func2<? super R, ? super T, ? extends R> accumulator) {
+    public <R> Observable<R> aggregate(R initialValue, Func2<R, T, R> accumulator) {
         return reduce(initialValue, accumulator);
     }
 
@@ -1965,7 +1940,7 @@ public <R> Observable<R> aggregate(R initialValue, Func2<? super R, ? super T, ?
      * @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<? super T, ? super T, ? extends T> accumulator) {
+    public Observable<T> scan(Func2<T, T, T> accumulator) {
         return create(OperationScan.scan(this, accumulator));
     }
 
@@ -2026,7 +2001,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<? super R, ? super T, ? extends R> accumulator) {
+    public <R> Observable<R> scan(R initialValue, Func2<R, T, R> accumulator) {
         return create(OperationScan.scan(this, initialValue, accumulator));
     }
 
@@ -2041,7 +2016,7 @@ public <R> Observable<R> scan(R initialValue, Func2<? super R, ? super T, ? exte
      * @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<? super T, Boolean> predicate) {
+    public Observable<Boolean> all(Func1<T, Boolean> predicate) {
         return create(OperationAll.all(this, predicate));
     }
 
@@ -2094,7 +2069,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<? super T, Boolean> predicate) {
+    public Observable<T> takeWhile(final Func1<T, Boolean> predicate) {
         return create(OperationTakeWhile.takeWhile(this, predicate));
     }
 
@@ -2111,7 +2086,7 @@ public Observable<T> takeWhile(final Func1<? super 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<? super T, ? super Integer, Boolean> predicate) {
+    public Observable<T> takeWhileWithIndex(final Func2<T, Integer, Boolean> predicate) {
         return create(OperationTakeWhile.takeWhileWithIndex(this, predicate));
     }
 
@@ -2145,7 +2120,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<? extends E> other) {
+    public <E> Observable<T> takeUntil(Observable<E> other) {
         return OperationTakeUntil.takeUntil(this, other);
     }
 
@@ -2197,7 +2172,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<? super T, ? super T, Integer> sortFunction) {
+    public Observable<List<T>> toSortedList(Func2<T, T, Integer> sortFunction) {
         return create(OperationToObservableSortedList.toSortedList(this, sortFunction));
     }
 
@@ -2233,7 +2208,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<? super T, ? extends K> keySelector, final Func1<? super T, ? extends R> elementSelector) {
+    public <K, R> Observable<GroupedObservable<K, R>> groupBy(final Func1<T, K> keySelector, final Func1<T, R> elementSelector) {
         return create(OperationGroupBy.groupBy(this, keySelector, elementSelector));
     }
 
@@ -2251,7 +2226,7 @@ public <K, R> Observable<GroupedObservable<K, R>> groupBy(final Func1<? super T,
      *         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<? super T, ? extends K> keySelector) {
+    public <K> Observable<GroupedObservable<K, T>> groupBy(final Func1<T, K> keySelector) {
         return create(OperationGroupBy.groupBy(this, keySelector));
     }
 
@@ -2272,7 +2247,7 @@ public BlockingObservable<T> toBlockingObservable() {
      * 
      * NOTE: If strong reasons for not depending on package names comes up then the implementation of this method can change to looking for a marker interface.
      * 
-     * @param f
+     * @param o
      * @return {@code true} if the given function is an internal implementation, and {@code false} otherwise.
      */
     private boolean isInternalImplementation(Object o) {
diff --git a/rxjava-core/src/main/java/rx/operators/ChunkedOperation.java b/rxjava-core/src/main/java/rx/operators/ChunkedOperation.java
new file mode 100644
index 0000000000..c7bb5cddbb
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/ChunkedOperation.java
@@ -0,0 +1,587 @@
+/**
+ * Copyright 2013 Netflix, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package rx.operators;
+
+import rx.Observable;
+import rx.Observer;
+import rx.Scheduler;
+import rx.Subscription;
+import rx.util.Closing;
+import rx.util.Opening;
+import rx.util.functions.Action0;
+import rx.util.functions.Action1;
+import rx.util.functions.Func0;
+import rx.util.functions.Func1;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Queue;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * The base class for operations that break observables into "chunks". Currently buffers and windows.
+ */
+public class ChunkedOperation {
+    /**
+     * This interface defines a way which specifies when to create a new internal {@link rx.operators.ChunkedOperation.Chunk} object.
+     *
+     */
+    protected interface ChunkCreator {
+        /**
+         * Signifies a onNext event.
+         */
+        void onValuePushed();
+
+        /**
+         * Signifies a onCompleted or onError event. Should be used to clean up open
+         * subscriptions and other still running background tasks.
+         */
+        void stop();
+    }
+
+    /**
+     * This class represents a single chunk: A sequence of recorded values.
+     *
+     * @param <T> The type of objects which this {@link Chunk} can hold.
+     *        <C> The type of object being tracked by the {@link Chunk}
+     */
+    protected abstract static class Chunk<T,C>  {
+        protected final List<T> contents = new ArrayList<T>();
+
+        /**
+         * Appends a specified value to the {@link Chunk}.
+         *
+         * @param value
+         *            The value to append to the {@link Chunk}.
+         */
+        public void pushValue(T value) {
+            contents.add(value);
+        }
+
+        /**
+         * @return
+         *            The mutable underlying {@link C} which contains all the
+         *            recorded values in this {@link Chunk} object.
+         */
+        abstract public C getContents();
+
+        /**
+         * @return
+         *            The size of the underlying {@link List} which contains all the
+         *            recorded values in this {@link Chunk} object.
+         */
+        public int size() {
+            return contents.size();
+        }
+    }
+
+    /**
+     * This class is an extension on the {@link rx.operators.ChunkedOperation.Chunks} class which only supports one
+     * active (not yet emitted) internal {@link rx.operators.ChunkedOperation.Chunks} object.
+     *
+     * @param <T> The type of object all internal {@link rx.operators.ChunkedOperation.Chunks} objects record.
+     *        <C> The type of object being tracked by the {@link Chunk}
+     */
+    protected static class NonOverlappingChunks<T,C> extends Chunks<T,C> {
+
+        private final Object lock = new Object();
+
+        public NonOverlappingChunks(Observer<C> observer, Func0 chunkMaker) {
+            super(observer, chunkMaker);
+        }
+
+        public Chunk<T,C> emitAndReplaceChunk() {
+            synchronized (lock) {
+                emitChunk(getChunk());
+                return createChunk();
+            }
+        }
+
+        @Override
+        public void pushValue(T value) {
+            synchronized (lock) {
+                super.pushValue(value);
+            }
+        }
+    }
+
+    /**
+     * This class is an extension on the {@link rx.operators.ChunkedOperation.Chunks} class which actually has no additional
+     * behavior than its super class. Classes extending this class, are expected to support
+     * two or more active (not yet emitted) internal {@link rx.operators.ChunkedOperation.Chunks} objects.
+     *
+     * @param <T> The type of object all internal {@link rx.operators.ChunkedOperation.Chunks} objects record.
+     *        <C> The type of object being tracked by the {@link rx.operators.ChunkedOperation.Chunk}
+     */
+    protected static class OverlappingChunks<T, C> extends Chunks<T,C> {
+        public OverlappingChunks(Observer<C> observer, Func0 chunkMaker) {
+            super(observer, chunkMaker);
+        }
+    }
+
+    /**
+     * This class is an extension on the {@link rx.operators.ChunkedOperation.Chunks} class. Every internal chunk has
+     * a has a maximum time to live and a maximum internal capacity. When the chunk has
+     * reached the end of its life, or reached its maximum internal capacity it is
+     * automatically emitted.
+     *
+     * @param <T> The type of object all internal {@link rx.operators.ChunkedOperation.Chunk} objects record.
+     *        <C> The type of object being tracked by the {@link Chunk}
+     */
+    protected static class TimeAndSizeBasedChunks<T,C> extends Chunks<T,C> {
+
+        private final ConcurrentMap<Chunk<T,C>, Subscription> subscriptions = new ConcurrentHashMap<Chunk<T,C>, Subscription>();
+
+        private final Scheduler scheduler;
+        private final long maxTime;
+        private final TimeUnit unit;
+        private final int maxSize;
+
+        public TimeAndSizeBasedChunks(Observer<C> observer, Func0 chunkMaker, int maxSize, long maxTime, TimeUnit unit, Scheduler scheduler) {
+            super(observer, chunkMaker);
+            this.maxSize = maxSize;
+            this.maxTime = maxTime;
+            this.unit = unit;
+            this.scheduler = scheduler;
+        }
+
+        @Override
+        public Chunk<T,C> createChunk() {
+            final Chunk<T,C> chunk = super.createChunk();
+            subscriptions.put(chunk, scheduler.schedule(new Action0() {
+                @Override
+                public void call() {
+                    emitChunk(chunk);
+                }
+            }, maxTime, unit));
+            return chunk;
+        }
+
+        @Override
+        public void emitChunk(Chunk<T,C> chunk) {
+            Subscription subscription = subscriptions.remove(chunk);
+            if (subscription == null) {
+                // Chunk was already emitted.
+                return;
+            }
+
+            subscription.unsubscribe();
+            super.emitChunk(chunk);
+            createChunk();
+        }
+
+        @Override
+        public void pushValue(T value) {
+            super.pushValue(value);
+
+            Chunk<T,C> chunk;
+            while ((chunk = getChunk()) != null) {
+                if (chunk.size() >= maxSize) {
+                    emitChunk(chunk);
+                } else {
+                    // Chunk is not at full capacity yet, and neither will remaining chunks be so we can terminate.
+                    break;
+                }
+            }
+        }
+    }
+
+    /**
+     * This class is an extension on the {@link rx.operators.ChunkedOperation.Chunks} class. Every internal chunk has
+     * a has a maximum time to live. When the chunk has reached the end of its life it is
+     * automatically emitted.
+     *
+     * @param <T> The type of object all internal {@link rx.operators.ChunkedOperation.Chunk} objects record.
+     *        <C> The type of object being tracked by the {@link Chunk}
+     */
+    protected static class TimeBasedChunks<T,C> extends OverlappingChunks<T,C> {
+
+        private final ConcurrentMap<Chunk<T,C>, Subscription> subscriptions = new ConcurrentHashMap<Chunk<T,C>, Subscription>();
+
+        private final Scheduler scheduler;
+        private final long time;
+        private final TimeUnit unit;
+
+        public TimeBasedChunks(Observer<C> observer, Func0 chunkMaker, long time, TimeUnit unit, Scheduler scheduler) {
+            super(observer, chunkMaker);
+            this.time = time;
+            this.unit = unit;
+            this.scheduler = scheduler;
+        }
+
+        @Override
+        public Chunk<T,C> createChunk() {
+            final Chunk<T,C> chunk = super.createChunk();
+            subscriptions.put(chunk, scheduler.schedule(new Action0() {
+                @Override
+                public void call() {
+                    emitChunk(chunk);
+                }
+            }, time, unit));
+            return chunk;
+        }
+
+        @Override
+        public void emitChunk(Chunk<T,C> chunk) {
+            subscriptions.remove(chunk);
+            super.emitChunk(chunk);
+        }
+    }
+
+    /**
+     * This class is an extension on the {@link rx.operators.ChunkedOperation.Chunks} class. Every internal chunk has
+     * a fixed maximum capacity. When the chunk has reached its maximum capacity it is
+     * automatically emitted.
+     *
+     * @param <T> The type of object all internal {@link rx.operators.ChunkedOperation.Chunk} objects record.
+     *        <C> The type of object being tracked by the {@link Chunk}
+     */
+    protected static class SizeBasedChunks<T,C> extends Chunks<T,C> {
+
+        private final int size;
+
+        public SizeBasedChunks(Observer<C> observer, Func0 chunkMaker, int size) {
+            super(observer, chunkMaker);
+            this.size = size;
+        }
+
+        @Override
+        public void pushValue(T value) {
+            super.pushValue(value);
+
+            Chunk<T,C> chunk;
+            while ((chunk = getChunk()) != null) {
+                if (chunk.size() >= size) {
+                    emitChunk(chunk);
+                } else {
+                    // Chunk is not at full capacity yet, and neither will remaining chunks be so we can terminate.
+                    break;
+                }
+            }
+        }
+    }
+
+    /**
+     * This class represents an object which contains and manages multiple {@link rx.operators.ChunkedOperation.Chunk} objects.
+     *
+     * @param <T> The type of objects which the internal {@link rx.operators.ChunkedOperation.Chunk} objects record.
+     *        <C> The type of object being tracked by the {@link Chunk}
+     */
+    protected static class Chunks<T,C> {
+
+        private final Queue<Chunk<T,C>> chunks = new ConcurrentLinkedQueue<Chunk<T,C>>();
+        private final Observer<C> observer;
+        private final Func0<Chunk<T, C>> chunkMaker;
+
+        /**
+         * Constructs a new {@link ChunkedOperation.Chunks} object for the specified {@link rx.Observer}.
+         *
+         * @param observer
+         *            The {@link rx.Observer} to which this object will emit its internal
+         *            {@link rx.operators.ChunkedOperation.Chunk} objects to when requested.
+         */
+        public Chunks(Observer<C> observer, Func0 chunkMaker) {
+            this.observer = observer;
+            this.chunkMaker = chunkMaker;
+        }
+
+        /**
+         * This method will instantiate a new {@link rx.operators.ChunkedOperation.Chunk} object and register it internally.
+         *
+         * @return
+         *            The constructed empty {@link rx.operators.ChunkedOperation.Chunk} object.
+         */
+        public Chunk<T,C> createChunk() {
+            Chunk<T,C> chunk = chunkMaker.call();
+            chunks.add(chunk);
+            return chunk;
+        }
+
+        /**
+         * This method emits all not yet emitted {@link rx.operators.ChunkedOperation.Chunk} objects.
+         */
+        public void emitAllChunks() {
+            Chunk<T,C> chunk;
+            while ((chunk = chunks.poll()) != null) {
+                observer.onNext(chunk.getContents());
+            }
+        }
+
+        /**
+         * This method emits the specified {@link rx.operators.ChunkedOperation.Chunk} object.
+         *
+         * @param chunk
+         *            The {@link rx.operators.ChunkedOperation.Chunk} to emit.
+         */
+        public void emitChunk(Chunk<T,C> chunk) {
+            if (!chunks.remove(chunk)) {
+                // Concurrency issue: Chunk is already emitted!
+                return;
+            }
+            observer.onNext(chunk.getContents());
+        }
+
+        /**
+         * @return
+         *            The oldest (in case there are multiple) {@link rx.operators.ChunkedOperation.Chunk} object.
+         */
+        public Chunk<T,C> getChunk() {
+            return chunks.peek();
+        }
+
+        /**
+         * This method pushes a value to all not yet emitted {@link rx.operators.ChunkedOperation.Chunk} objects.
+         *
+         * @param value
+         *            The value to push to all not yet emitted {@link rx.operators.ChunkedOperation.Chunk} objects.
+         */
+        public void pushValue(T value) {
+            List<Chunk<T,C>> copy = new ArrayList<Chunk<T,C>>(chunks);
+            for (Chunk<T,C> chunk : copy) {
+                chunk.pushValue(value);
+            }
+        }
+    }
+
+    /**
+     * This {@link rx.operators.ChunkedOperation.ChunkObserver} object can be constructed using a {@link rx.operators.ChunkedOperation.Chunks} object,
+     * a {@link rx.Observer} object, and a {@link rx.operators.ChunkedOperation.ChunkCreator} object. The {@link rx.operators.ChunkedOperation.ChunkCreator}
+     * will manage the creation, and in some rare cases emission of internal {@link rx.operators.ChunkedOperation.Chunk} objects
+     * in the specified {@link rx.operators.ChunkedOperation.Chunks} object. Under normal circumstances the {@link rx.operators.ChunkedOperation.Chunks}
+     * object specifies when a created {@link rx.operators.ChunkedOperation.Chunk} is emitted.
+     *
+     * @param <T> The type of object all internal {@link rx.operators.ChunkedOperation.Chunk} objects record.
+     *        <C> The type of object being tracked by the {@link Chunk}
+     */
+    protected static class ChunkObserver<T,C> implements Observer<T> {
+
+        private final Chunks<T,C> chunks;
+        private final Observer<C> observer;
+        private final ChunkCreator creator;
+
+        public ChunkObserver(Chunks<T,C> chunks, Observer<C> observer, ChunkCreator creator) {
+            this.observer = observer;
+            this.creator = creator;
+            this.chunks = chunks;
+        }
+
+        @Override
+        public void onCompleted() {
+            creator.stop();
+            chunks.emitAllChunks();
+            observer.onCompleted();
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            creator.stop();
+            chunks.emitAllChunks();
+            observer.onError(e);
+        }
+
+        @Override
+        public void onNext(T args) {
+            creator.onValuePushed();
+            chunks.pushValue(args);
+        }
+    }
+
+    /**
+     * This {@link rx.operators.ChunkedOperation.ChunkCreator} creates a new {@link rx.operators.ChunkedOperation.Chunk} when it is initialized, but
+     * provides no additional functionality. This class should primarily be used when the
+     * internal {@link rx.operators.ChunkedOperation.Chunk} is closed externally.
+     *
+     * @param <T> The type of object all internal {@link rx.operators.ChunkedOperation.Chunk} objects record.
+     *        <C> The type of object being tracked by the {@link Chunk}
+     */
+    protected static class SingleChunkCreator<T,C> implements ChunkCreator {
+
+        public SingleChunkCreator(Chunks<T, C> chunks) {
+            chunks.createChunk();
+        }
+
+        @Override
+        public void onValuePushed() {
+            // Do nothing.
+        }
+
+        @Override
+        public void stop() {
+            // Do nothing.
+        }
+    }
+
+    /**
+     * This {@link rx.operators.ChunkedOperation.ChunkCreator} creates a new {@link rx.operators.ChunkedOperation.Chunk} whenever it receives an
+     * object from the provided {@link rx.Observable} created with the
+     * chunkClosingSelector {@link rx.util.functions.Func0}.
+     *
+     * @param <T> The type of object all internal {@link rx.operators.ChunkedOperation.Chunk} objects record.
+     *        <C> The type of object being tracked by the {@link Chunk}
+     */
+    protected static class ObservableBasedSingleChunkCreator<T,C> implements ChunkCreator {
+
+        private final SafeObservableSubscription subscription = new SafeObservableSubscription();
+        private final Func0<Observable<Closing>> chunkClosingSelector;
+        private final NonOverlappingChunks<T, C> chunks;
+
+        public ObservableBasedSingleChunkCreator(NonOverlappingChunks<T,C> chunks, Func0<Observable<Closing>> chunkClosingSelector) {
+            this.chunks = chunks;
+            this.chunkClosingSelector = chunkClosingSelector;
+
+            chunks.createChunk();
+            listenForChunkEnd();
+        }
+
+        private void listenForChunkEnd() {
+            Observable<Closing> closingObservable = chunkClosingSelector.call();
+            closingObservable.subscribe(new Action1<Closing>() {
+                @Override
+                public void call(Closing closing) {
+                    chunks.emitAndReplaceChunk();
+                    listenForChunkEnd();
+                }
+            });
+        }
+
+        @Override
+        public void onValuePushed() {
+            // Ignore value pushes.
+        }
+
+        @Override
+        public void stop() {
+            subscription.unsubscribe();
+        }
+    }
+
+    /**
+     * This {@link rx.operators.ChunkedOperation.ChunkCreator} creates a new {@link rx.operators.ChunkedOperation.Chunk} whenever it receives
+     * an object from the provided chunkOpenings {@link rx.Observable}, and closes the corresponding
+     * {@link rx.operators.ChunkedOperation.Chunk} object when it receives an object from the provided {@link rx.Observable} created
+     * with the chunkClosingSelector {@link rx.util.functions.Func1}.
+     *
+     * @param <T> The type of object all internal {@link rx.operators.ChunkedOperation.Chunk} objects record.
+     *        <C> The type of object being tracked by the {@link Chunk}
+     */
+    protected static class ObservableBasedMultiChunkCreator<T,C> implements ChunkCreator {
+
+        private final SafeObservableSubscription subscription = new SafeObservableSubscription();
+
+        public ObservableBasedMultiChunkCreator(final OverlappingChunks<T,C> chunks, Observable<Opening> openings, final Func1<Opening, Observable<Closing>> chunkClosingSelector) {
+            subscription.wrap(openings.subscribe(new Action1<Opening>() {
+                @Override
+                public void call(Opening opening) {
+                    final Chunk<T, C> chunk = chunks.createChunk();
+                    Observable<Closing> closingObservable = chunkClosingSelector.call(opening);
+
+                    closingObservable.subscribe(new Action1<Closing>() {
+                        @Override
+                        public void call(Closing closing) {
+                            chunks.emitChunk(chunk);
+                        }
+                    });
+                }
+            }));
+        }
+
+        @Override
+        public void onValuePushed() {
+            // Ignore value pushes.
+        }
+
+        @Override
+        public void stop() {
+            subscription.unsubscribe();
+        }
+    }
+
+    /**
+     * This {@link rx.operators.ChunkedOperation.ChunkCreator} creates a new {@link rx.operators.ChunkedOperation.Chunk} every time after a fixed
+     * period of time has elapsed.
+     *
+     * @param <T> The type of object all internal {@link rx.operators.ChunkedOperation.Chunk} objects record.
+     *        <C> The type of object being tracked by the {@link Chunk}
+     */
+    protected static class TimeBasedChunkCreator<T,C> implements ChunkCreator {
+
+        private final SafeObservableSubscription subscription = new SafeObservableSubscription();
+
+        public TimeBasedChunkCreator(final NonOverlappingChunks<T,C> chunks, long time, TimeUnit unit, Scheduler scheduler) {
+            this.subscription.wrap(scheduler.schedulePeriodically(new Action0() {
+                @Override
+                public void call() {
+                    chunks.emitAndReplaceChunk();
+                }
+            }, 0, time, unit));
+        }
+
+        public TimeBasedChunkCreator(final OverlappingChunks<T,C> chunks, long time, TimeUnit unit, Scheduler scheduler) {
+            this.subscription.wrap(scheduler.schedulePeriodically(new Action0() {
+                @Override
+                public void call() {
+                    chunks.createChunk();
+                }
+            }, 0, time, unit));
+        }
+
+        @Override
+        public void onValuePushed() {
+            // Do nothing: chunks are created periodically.
+        }
+
+        @Override
+        public void stop() {
+            subscription.unsubscribe();
+        }
+    }
+
+    /**
+     * This {@link rx.operators.ChunkedOperation.ChunkCreator} creates a new {@link rx.operators.ChunkedOperation.Chunk} every time after it has
+     * seen a certain amount of elements.
+     *
+     * @param <T> The type of object all internal {@link rx.operators.ChunkedOperation.Chunk} objects record.
+     *        <C> The type of object being tracked by the {@link Chunk}
+     */
+    protected static class SkippingChunkCreator<T,C> implements ChunkCreator {
+
+        private final AtomicInteger skipped = new AtomicInteger(1);
+        private final Chunks<T,C> chunks;
+        private final int skip;
+
+        public SkippingChunkCreator(Chunks<T,C> chunks, int skip) {
+            this.chunks = chunks;
+            this.skip = skip;
+        }
+
+        @Override
+        public void onValuePushed() {
+            if (skipped.decrementAndGet() == 0) {
+                skipped.set(skip);
+                chunks.createChunk();
+            }
+        }
+
+        @Override
+        public void stop() {
+            // Nothing to stop: we're not using a Scheduler.
+        }
+    }
+}
diff --git a/rxjava-core/src/main/java/rx/operators/OperationBuffer.java b/rxjava-core/src/main/java/rx/operators/OperationBuffer.java
index 05a009d715..2323f6478e 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationBuffer.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationBuffer.java
@@ -6,7 +6,7 @@
  * You may obtain a copy of the License at
  * 
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -17,12 +17,7 @@
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Queue;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentLinkedQueue;
-import java.util.concurrent.ConcurrentMap;
 import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicInteger;
 
 import org.junit.Before;
 import org.junit.Test;
@@ -30,35 +25,40 @@
 import org.mockito.Mockito;
 
 import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Scheduler;
 import rx.Subscription;
 import rx.concurrency.Schedulers;
 import rx.concurrency.TestScheduler;
 import rx.subscriptions.Subscriptions;
-import rx.util.BufferClosing;
-import rx.util.BufferClosings;
-import rx.util.BufferOpening;
-import rx.util.BufferOpenings;
+import rx.util.Closing;
+import rx.util.Closings;
+import rx.util.Opening;
+import rx.util.Openings;
 import rx.util.functions.Action0;
-import rx.util.functions.Action1;
 import rx.util.functions.Func0;
 import rx.util.functions.Func1;
 
 
-public final class OperationBuffer {
+public final class OperationBuffer extends ChunkedOperation {
+
+    public static final Func0 BUFFER_MAKER = new Func0() {
+        @Override
+        public Object call() {
+            return new Buffer();
+        }
+    };
 
     /**
      * <p>This method creates a {@link Func1} object which represents the buffer operation. This operation takes
      * values from the specified {@link Observable} source and stores them in a buffer until the {@link Observable}
-     * constructed using the {@link Func0} argument, produces a {@link BufferClosing} value. The buffer is then
+     * constructed using the {@link Func0} argument, produces a {@link rx.util.Closing} value. The buffer is then
      * emitted, and a new buffer is created to replace it. A new {@link Observable} will be constructed using the
      * provided {@link Func0} object, which will determine when this new buffer is emitted. When the source
      * {@link Observable} completes or produces an error, the current buffer is emitted, and the event is propagated
      * to all subscribed {@link Observer}s.</p>
      *
-     * <p>Note that this operation only produces <strong>non-overlapping buffers</strong>. At all times there is
+     * <p>Note that this operation only produces <strong>non-overlapping chunks</strong>. At all times there is
      * exactly one buffer actively storing values.</p>
      *
      * @param source
@@ -66,55 +66,55 @@ public final class OperationBuffer {
      * @param bufferClosingSelector
      *            A {@link Func0} object which produces {@link Observable}s. These
      *            {@link Observable}s determine when a buffer is emitted and replaced by simply
-     *            producing an {@link BufferClosing} object.
+     *            producing an {@link rx.util.Closing} object.
      * @return
      *            the {@link Func1} object representing the specified buffer operation.
      */
-    public static <T> OnSubscribeFunc<List<T>> buffer(final Observable<? extends T> source, final Func0<? extends Observable<? extends BufferClosing>> bufferClosingSelector) {
-        return new OnSubscribeFunc<List<T>>() {
+    public static <T> Func1<Observer<List<T>>, Subscription> buffer(final Observable<T> source, final Func0<Observable<Closing>> bufferClosingSelector) {
+        return new Func1<Observer<List<T>>, Subscription>() {
             @Override
-            public Subscription onSubscribe(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));
+            public Subscription call(final Observer<List<T>> observer) {
+                NonOverlappingChunks<T, List<T>> buffers = new NonOverlappingChunks<T, List<T>>(observer, BUFFER_MAKER);
+                ChunkCreator creator = new ObservableBasedSingleChunkCreator<T, List<T>>(buffers, bufferClosingSelector);
+                return source.subscribe(new ChunkObserver<T, List<T>>(buffers, observer, creator));
             }
         };
     }
 
     /**
      * <p>This method creates a {@link Func1} object which represents the buffer operation. This operation takes
-     * values from the specified {@link Observable} source and stores them in the currently active buffers. Initially
-     * there are no buffers active.</p>
+     * values from the specified {@link Observable} source and stores them in the currently active chunks. Initially
+     * there are no chunks active.</p>
      *
-     * <p>Buffers can be created by pushing a {@link BufferOpening} value to the "bufferOpenings" {@link Observable}.
+     * <p>Chunks can be created by pushing a {@link rx.util.Opening} value to the "bufferOpenings" {@link Observable}.
      * This creates a new buffer which will then start recording values which are produced by the "source"
      * {@link Observable}. Additionally the "bufferClosingSelector" will be used to construct an {@link Observable}
-     * which can produce {@link BufferClosing} values. When it does so it will close this (and only this) newly created
-     * buffer. When the source {@link Observable} completes or produces an error, all buffers are emitted, and the
+     * which can produce {@link rx.util.Closing} values. When it does so it will close this (and only this) newly created
+     * buffer. When the source {@link Observable} completes or produces an error, all chunks are emitted, and the
      * event is propagated to all subscribed {@link Observer}s.</p>
      *
-     * <p>Note that when using this operation <strong>multiple overlapping buffers</strong>
+     * <p>Note that when using this operation <strong>multiple overlapping chunks</strong>
      * could be active at any one point.</p>
      *
      * @param source
      *            The {@link Observable} which produces values.
      * @param bufferOpenings
-     *            An {@link Observable} which when it produces a {@link BufferOpening} value will
+     *            An {@link Observable} which when it produces a {@link rx.util.Opening} value will
      *            create a new buffer which instantly starts recording the "source" {@link Observable}.
      * @param bufferClosingSelector
      *            A {@link Func0} object which produces {@link Observable}s. These
      *            {@link Observable}s determine when a buffer is emitted and replaced by simply
-     *            producing an {@link BufferClosing} object.
+     *            producing an {@link rx.util.Closing} object.
      * @return
      *            the {@link Func1} object representing the specified buffer operation.
      */
-    public static <T> OnSubscribeFunc<List<T>> buffer(final Observable<? extends T> source, final Observable<? extends BufferOpening> bufferOpenings, final Func1<? super BufferOpening, ? extends Observable<? extends BufferClosing>> bufferClosingSelector) {
-        return new OnSubscribeFunc<List<T>>() {
+    public static <T> Func1<Observer<List<T>>, Subscription> buffer(final Observable<T> source, final Observable<Opening> bufferOpenings, final Func1<Opening, Observable<Closing>> bufferClosingSelector) {
+        return new Func1<Observer<List<T>>, Subscription>() {
             @Override
-            public Subscription onSubscribe(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));
+            public Subscription call(final Observer<List<T>> observer) {
+                OverlappingChunks<T, List<T>> buffers = new OverlappingChunks<T, List<T>>(observer, BUFFER_MAKER);
+                ChunkCreator creator = new ObservableBasedMultiChunkCreator<T, List<T>>(buffers, bufferOpenings, bufferClosingSelector);
+                return source.subscribe(new ChunkObserver<T, List<T>>(buffers, observer, creator));
             }
         };
     }
@@ -126,7 +126,7 @@ public Subscription onSubscribe(final Observer<? super List<T>> observer) {
      * When the source {@link Observable} completes or produces an error, the current buffer is emitted, and
      * the event is propagated to all subscribed {@link Observer}s.</p>
      *
-     * <p>Note that this operation only produces <strong>non-overlapping buffers</strong>. At all times there is
+     * <p>Note that this operation only produces <strong>non-overlapping chunks</strong>. At all times there is
      * exactly one buffer actively storing values.</p>
      *
      * @param source
@@ -136,40 +136,40 @@ public Subscription onSubscribe(final Observer<? super List<T>> observer) {
      * @return
      *            the {@link Func1} object representing the specified buffer operation.
      */
-    public static <T> OnSubscribeFunc<List<T>> buffer(Observable<? extends T> source, int count) {
+    public static <T> Func1<Observer<List<T>>, Subscription> buffer(Observable<T> source, int count) {
         return buffer(source, count, count);
     }
 
     /**
      * <p>This method creates a {@link Func1} object which represents the buffer operation. This operation takes
-     * values from the specified {@link Observable} source and stores them in all active buffers until the buffer
-     * contains a specified number of elements. The buffer is then emitted. Buffers are created after a certain
+     * values from the specified {@link Observable} source and stores them in all active chunks until the buffer
+     * contains a specified number of elements. The buffer is then emitted. Chunks are created after a certain
      * amount of values have been received. When the source {@link Observable} completes or produces an error, the
-     * currently active buffers are emitted, and the event is propagated to all subscribed {@link Observer}s.</p>
+     * currently active chunks are emitted, and the event is propagated to all subscribed {@link Observer}s.</p>
      *
      * <p>Note that this operation can produce <strong>non-connected, connected non-overlapping, or overlapping
-     * buffers</strong> depending on the input parameters.</p>
+     * chunks</strong> depending on the input parameters.</p>
      *
      * @param source
      *            The {@link Observable} which produces values.
      * @param count
      *            The number of elements a buffer should have before being emitted.
      * @param skip
-     *            The interval with which buffers have to be created. Note that when "skip" == "count"
+     *            The interval with which chunks have to be created. Note that when "skip" == "count"
      *            that this is the same as calling {@link OperationBuffer#buffer(Observable, int)}.
-     *            If "skip" < "count", this buffer operation will produce overlapping buffers and if "skip"
-     *            > "count" non-overlapping buffers will be created and some values will not be pushed
+     *            If "skip" < "count", this buffer operation will produce overlapping chunks and if "skip"
+     *            > "count" non-overlapping chunks will be created and some values will not be pushed
      *            into a buffer at all!
      * @return
      *            the {@link Func1} object representing the specified buffer operation.
      */
-    public static <T> OnSubscribeFunc<List<T>> buffer(final Observable<? extends T> source, final int count, final int skip) {
-        return new OnSubscribeFunc<List<T>>() {
+    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>() {
             @Override
-            public Subscription onSubscribe(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));
+            public Subscription call(final Observer<List<T>> observer) {
+                Chunks<T, List<T>> chunks = new SizeBasedChunks<T, List<T>>(observer, BUFFER_MAKER, count);
+                ChunkCreator creator = new SkippingChunkCreator<T, List<T>>(chunks, skip);
+                return source.subscribe(new ChunkObserver<T, List<T>>(chunks, observer, creator));
             }
         };
     }
@@ -181,19 +181,19 @@ public Subscription onSubscribe(final Observer<? super List<T>> observer) {
      * When the source {@link Observable} completes or produces an error, the current buffer is emitted, and
      * the event is propagated to all subscribed {@link Observer}s.</p>
      *
-     * <p>Note that this operation only produces <strong>non-overlapping buffers</strong>. At all times there is
+     * <p>Note that this operation only produces <strong>non-overlapping chunks</strong>. At all times there is
      * exactly one buffer actively storing values.</p>
      *
      * @param source
      *            The {@link Observable} which produces values.
      * @param timespan
-     *            The amount of time all buffers must be actively collect values before being emitted.
+     *            The amount of time all chunks must be actively collect values before being emitted.
      * @param unit
      *            The {@link TimeUnit} defining the unit of time for the timespan.
      * @return
      *            the {@link Func1} object representing the specified buffer operation.
      */
-    public static <T> OnSubscribeFunc<List<T>> buffer(Observable<? extends T> source, long timespan, TimeUnit unit) {
+    public static <T> Func1<Observer<List<T>>, Subscription> buffer(Observable<T> source, long timespan, TimeUnit unit) {
         return buffer(source, timespan, unit, Schedulers.threadPoolForComputation());
     }
 
@@ -204,27 +204,27 @@ public static <T> OnSubscribeFunc<List<T>> buffer(Observable<? extends T> source
      * When the source {@link Observable} completes or produces an error, the current buffer is emitted, and
      * the event is propagated to all subscribed {@link Observer}s.</p>
      *
-     * <p>Note that this operation only produces <strong>non-overlapping buffers</strong>. At all times there is
+     * <p>Note that this operation only produces <strong>non-overlapping chunks</strong>. At all times there is
      * exactly one buffer actively storing values.</p>
      *
      * @param source
      *            The {@link Observable} which produces values.
      * @param timespan
-     *            The amount of time all buffers must be actively collect values before being emitted.
+     *            The amount of time all chunks must be actively collect values before being emitted.
      * @param unit
      *            The {@link TimeUnit} defining the unit of time for the timespan.
      * @param scheduler
-     *            The {@link Scheduler} to use for timing buffers.
+     *            The {@link Scheduler} to use for timing chunks.
      * @return
      *            the {@link Func1} object representing the specified buffer operation.
      */
-    public static <T> OnSubscribeFunc<List<T>> buffer(final Observable<? extends T> source, final long timespan, final TimeUnit unit, final Scheduler scheduler) {
-        return new OnSubscribeFunc<List<T>>() {
+    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>() {
             @Override
-            public Subscription onSubscribe(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));
+            public Subscription call(final Observer<List<T>> observer) {
+                NonOverlappingChunks<T, List<T>> buffers = new NonOverlappingChunks<T, List<T>>(observer, BUFFER_MAKER);
+                ChunkCreator creator = new TimeBasedChunkCreator<T, List<T>>(buffers, timespan, unit, scheduler);
+                return source.subscribe(new ChunkObserver<T, List<T>>(buffers, observer, creator));
             }
         };
     }
@@ -237,13 +237,13 @@ public Subscription onSubscribe(final Observer<? super List<T>> observer) {
      * When the source {@link Observable} completes or produces an error, the current buffer is emitted, and
      * the event is propagated to all subscribed {@link Observer}s.</p>
      *
-     * <p>Note that this operation only produces <strong>non-overlapping buffers</strong>. At all times there is
+     * <p>Note that this operation only produces <strong>non-overlapping chunks</strong>. At all times there is
      * exactly one buffer actively storing values.</p>
      *
      * @param source
      *            The {@link Observable} which produces values.
      * @param timespan
-     *            The amount of time all buffers must be actively collect values before being emitted.
+     *            The amount of time all chunks must be actively collect values before being emitted.
      * @param unit
      *            The {@link TimeUnit} defining the unit of time for the timespan.
      * @param count
@@ -251,7 +251,7 @@ public Subscription onSubscribe(final Observer<? super List<T>> observer) {
      * @return
      *            the {@link Func1} object representing the specified buffer operation.
      */
-    public static <T> OnSubscribeFunc<List<T>> buffer(Observable<? extends T> source, long timespan, TimeUnit unit, int count) {
+    public static <T> Func1<Observer<List<T>>, Subscription> buffer(Observable<T> source, long timespan, TimeUnit unit, int count) {
         return buffer(source, timespan, unit, count, Schedulers.threadPoolForComputation());
     }
 
@@ -263,29 +263,29 @@ public static <T> OnSubscribeFunc<List<T>> buffer(Observable<? extends T> source
      * When the source {@link Observable} completes or produces an error, the current buffer is emitted, and
      * the event is propagated to all subscribed {@link Observer}s.</p>
      *
-     * <p>Note that this operation only produces <strong>non-overlapping buffers</strong>. At all times there is
+     * <p>Note that this operation only produces <strong>non-overlapping chunks</strong>. At all times there is
      * exactly one buffer actively storing values.</p>
      *
      * @param source
      *            The {@link Observable} which produces values.
      * @param timespan
-     *            The amount of time all buffers must be actively collect values before being emitted.
+     *            The amount of time all chunks must be actively collect values before being emitted.
      * @param unit
      *            The {@link TimeUnit} defining the unit of time for the timespan.
      * @param count
      *            The maximum size of the buffer. Once a buffer reaches this size, it is emitted.
      * @param scheduler
-     *            The {@link Scheduler} to use for timing buffers.
+     *            The {@link Scheduler} to use for timing chunks.
      * @return
      *            the {@link Func1} object representing the specified buffer operation.
      */
-    public static <T> OnSubscribeFunc<List<T>> buffer(final Observable<? extends T> source, final long timespan, final TimeUnit unit, final int count, final Scheduler scheduler) {
-        return new OnSubscribeFunc<List<T>>() {
+    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>() {
             @Override
-            public Subscription onSubscribe(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));
+            public Subscription call(final Observer<List<T>> observer) {
+                Chunks<T, List<T>> chunks = new TimeAndSizeBasedChunks<T, List<T>>(observer, BUFFER_MAKER, count, timespan, unit, scheduler);
+                ChunkCreator creator = new SingleChunkCreator<T, List<T>>(chunks);
+                return source.subscribe(new ChunkObserver<T, List<T>>(chunks, observer, creator));
             }
         };
     }
@@ -294,25 +294,25 @@ public Subscription onSubscribe(final Observer<? super List<T>> observer) {
      * <p>This method creates a {@link Func1} object which represents the buffer operation. This operation takes
      * values from the specified {@link Observable} source and stores them in a buffer. Periodically the buffer
      * is emitted and replaced with a new buffer. How often this is done depends on the specified timespan.
-     * The creation of buffers is also periodical. How often this is done depends on the specified timeshift.
+     * The creation of chunks is also periodical. How often this is done depends on the specified timeshift.
      * When the source {@link Observable} completes or produces an error, the current buffer is emitted, and
      * the event is propagated to all subscribed {@link Observer}s.</p>
      *
-     * <p>Note that this operation can produce <strong>non-connected, or overlapping buffers</strong> depending
+     * <p>Note that this operation can produce <strong>non-connected, or overlapping chunks</strong> depending
      * on the input parameters.</p>
      *
      * @param source
      *            The {@link Observable} which produces values.
      * @param timespan
-     *            The amount of time all buffers must be actively collect values before being emitted.
+     *            The amount of time all chunks must be actively collect values before being emitted.
      * @param timeshift
-     *            The amount of time between creating buffers.
+     *            The amount of time between creating chunks.
      * @param unit
      *            The {@link TimeUnit} defining the unit of time for the timespan.
      * @return
      *            the {@link Func1} object representing the specified buffer operation.
      */
-    public static <T> OnSubscribeFunc<List<T>> buffer(Observable<? extends T> source, long timespan, long timeshift, TimeUnit unit) {
+    public static <T> Func1<Observer<List<T>>, Subscription> buffer(Observable<T> source, long timespan, long timeshift, TimeUnit unit) {
         return buffer(source, timespan, timeshift, unit, Schedulers.threadPoolForComputation());
     }
 
@@ -320,557 +320,49 @@ public static <T> OnSubscribeFunc<List<T>> buffer(Observable<? extends T> source
      * <p>This method creates a {@link Func1} object which represents the buffer operation. This operation takes
      * values from the specified {@link Observable} source and stores them in a buffer. Periodically the buffer
      * is emitted and replaced with a new buffer. How often this is done depends on the specified timespan.
-     * The creation of buffers is also periodical. How often this is done depends on the specified timeshift.
+     * The creation of chunks is also periodical. How often this is done depends on the specified timeshift.
      * When the source {@link Observable} completes or produces an error, the current buffer is emitted, and
      * the event is propagated to all subscribed {@link Observer}s.</p>
      *
-     * <p>Note that this operation can produce <strong>non-connected, or overlapping buffers</strong> depending
+     * <p>Note that this operation can produce <strong>non-connected, or overlapping chunks</strong> depending
      * on the input parameters.</p>
      *
      * @param source
      *            The {@link Observable} which produces values.
      * @param timespan
-     *            The amount of time all buffers must be actively collect values before being emitted.
+     *            The amount of time all chunks must be actively collect values before being emitted.
      * @param timeshift
-     *            The amount of time between creating buffers.
+     *            The amount of time between creating chunks.
      * @param unit
      *            The {@link TimeUnit} defining the unit of time for the timespan.
      * @param scheduler
-     *            The {@link Scheduler} to use for timing buffers.
+     *            The {@link Scheduler} to use for timing chunks.
      * @return
      *            the {@link Func1} object representing the specified buffer operation.
      */
-    public static <T> OnSubscribeFunc<List<T>> buffer(final Observable<? extends T> source, final long timespan, final long timeshift, final TimeUnit unit, final Scheduler scheduler) {
-        return new OnSubscribeFunc<List<T>>() {
+    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>() {
             @Override
-            public Subscription onSubscribe(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));
+            public Subscription call(final Observer<List<T>> observer) {
+                OverlappingChunks<T, List<T>> buffers = new TimeBasedChunks<T, List<T>>(observer, BUFFER_MAKER, timespan, unit, scheduler);
+                ChunkCreator creator = new TimeBasedChunkCreator<T, List<T>>(buffers, timeshift, unit, scheduler);
+                return source.subscribe(new ChunkObserver<T, List<T>>(buffers, observer, creator));
             }
         };
     }
 
-    /**
-     * This {@link BufferObserver} object can be constructed using a {@link Buffers} object,
-     * a {@link Observer} object, and a {@link BufferCreator} object. The {@link BufferCreator}
-     * will manage the creation, and in some rare cases emission of internal {@link Buffer} objects
-     * in the specified {@link Buffers} object. Under normal circumstances the {@link Buffers}
-     * object specifies when a created {@link Buffer} is emitted.
-     *
-     * @param <T> The type of object all internal {@link Buffer} objects record.
-     */
-    private static class BufferObserver<T> implements Observer<T> {
-
-        private final Buffers<T> buffers;
-        private final Observer<? super List<T>> observer;
-        private final 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;
-        }
-
-        @Override
-        public void onCompleted() {
-            creator.stop();
-            buffers.emitAllBuffers();
-            observer.onCompleted();
-        }
-
-        @Override
-        public void onError(Throwable e) {
-            creator.stop();
-            buffers.emitAllBuffers();
-            observer.onError(e);
-        }
-
-        @Override
-        public void onNext(T args) {
-            creator.onValuePushed();
-            buffers.pushValue(args);
-        }
-    }
-
-    /**
-     * This interface defines a way which specifies when to create a new internal {@link Buffer} object.
-     *
-     * @param <T> The type of object all internal {@link Buffer} objects record.
-     */
-    private interface BufferCreator<T> {
-        /**
-         * Signifies a onNext event.
-         */
-        void onValuePushed();
-        
-        /**
-         * Signifies a onCompleted or onError event. Should be used to clean up open
-         * subscriptions and other still running background tasks.
-         */
-        void stop();
-    }
-
-    /**
-     * This {@link BufferCreator} creates a new {@link Buffer} when it is initialized, but
-     * provides no additional functionality. This class should primarily be used when the
-     * internal {@link Buffer} is closed externally.
-     *
-     * @param <T> The type of object all internal {@link Buffer} objects record.
-     */
-    private static class SingleBufferCreator<T> implements BufferCreator<T> {
-
-        public SingleBufferCreator(Buffers<T> buffers) {
-            buffers.createBuffer();
-        }
-
-        @Override
-        public void onValuePushed() {
-            // Do nothing.
-        }
-
-        @Override
-        public void stop() {
-            // Do nothing.
-        }
-    }
-
-    /**
-     * This {@link BufferCreator} creates a new {@link Buffer} whenever it receives an
-     * object from the provided {@link Observable} created with the
-     * bufferClosingSelector {@link Func0}.
-     *
-     * @param <T> The type of object all internal {@link Buffer} objects record.
-     */
-    private static class ObservableBasedSingleBufferCreator<T> implements BufferCreator<T> {
-
-        private final SafeObservableSubscription subscription = new SafeObservableSubscription();
-        private final Func0<? extends Observable<? extends BufferClosing>> bufferClosingSelector;
-        private final NonOverlappingBuffers<T> buffers;
-
-        public ObservableBasedSingleBufferCreator(NonOverlappingBuffers<T> buffers, Func0<? extends Observable<? extends BufferClosing>> bufferClosingSelector) {
-            this.buffers = buffers;
-            this.bufferClosingSelector = bufferClosingSelector;
-
-            buffers.createBuffer();
-            listenForBufferEnd();
-        }
-
-        private void listenForBufferEnd() {
-            Observable<? extends BufferClosing> closingObservable = bufferClosingSelector.call();
-            closingObservable.subscribe(new Action1<BufferClosing>() {
-                @Override
-                public void call(BufferClosing closing) {
-                    buffers.emitAndReplaceBuffer();
-                    listenForBufferEnd();
-                }
-            });
-        }
-
-        @Override
-        public void onValuePushed() {
-            // Ignore value pushes.
-        }
-
-        @Override
-        public void stop() {
-            subscription.unsubscribe();
-        }
-    }
-
-    /**
-     * This {@link BufferCreator} creates a new {@link Buffer} whenever it receives
-     * an object from the provided bufferOpenings {@link Observable}, and closes the corresponding
-     * {@link Buffer} object when it receives an object from the provided {@link Observable} created
-     * with the bufferClosingSelector {@link Func1}.
-     *
-     * @param <T> The type of object all internal {@link Buffer} objects record.
-     */
-    private static class ObservableBasedMultiBufferCreator<T> implements BufferCreator<T> {
-
-        private final SafeObservableSubscription subscription = new SafeObservableSubscription();
-
-        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<? extends BufferClosing> closingObservable = bufferClosingSelector.call(opening);
-
-                    closingObservable.subscribe(new Action1<BufferClosing>() {
-                        @Override
-                        public void call(BufferClosing closing) {
-                            buffers.emitBuffer(buffer);
-                        }
-                    });
-                }
-            }));
-        }
-
-        @Override
-        public void onValuePushed() {
-            // Ignore value pushes.
-        }
-
-        @Override
-        public void stop() {
-            subscription.unsubscribe();
-        }
-    }
-
-    /**
-     * This {@link BufferCreator} creates a new {@link Buffer} every time after a fixed
-     * period of time has elapsed.
-     *
-     * @param <T> The type of object all internal {@link Buffer} objects record.
-     */
-    private static class TimeBasedBufferCreator<T> implements BufferCreator<T> {
-
-        private final SafeObservableSubscription subscription = new SafeObservableSubscription();
-
-        public TimeBasedBufferCreator(final NonOverlappingBuffers<T> buffers, long time, TimeUnit unit, Scheduler scheduler) {
-            this.subscription.wrap(scheduler.schedulePeriodically(new Action0() {
-                @Override
-                public void call() {
-                    buffers.emitAndReplaceBuffer();
-                }
-            }, 0, time, unit));
-        }
-
-        public TimeBasedBufferCreator(final OverlappingBuffers<T> buffers, long time, TimeUnit unit, Scheduler scheduler) {
-            this.subscription.wrap(scheduler.schedulePeriodically(new Action0() {
-                @Override
-                public void call() {
-                    buffers.createBuffer();
-                }
-            }, 0, time, unit));
-        }
-
-        @Override
-        public void onValuePushed() {
-            // Do nothing: buffers are created periodically.
-        }
-
-        @Override
-        public void stop() {
-            subscription.unsubscribe();
-        }
-    }
-
-    /**
-     * This {@link BufferCreator} creates a new {@link Buffer} every time after it has
-     * seen a certain amount of elements.
-     *
-     * @param <T> The type of object all internal {@link Buffer} objects record.
-     */
-    private static class SkippingBufferCreator<T> implements BufferCreator<T> {
-
-        private final AtomicInteger skipped = new AtomicInteger(1);
-        private final Buffers<T> buffers;
-        private final int skip;
-
-        public SkippingBufferCreator(Buffers<T> buffers, int skip) {
-            this.buffers = buffers;
-            this.skip = skip;
-        }
-
-        @Override
-        public void onValuePushed() {
-            if (skipped.decrementAndGet() == 0) {
-                skipped.set(skip);
-                buffers.createBuffer();
-            }
-        }
-
-        @Override
-        public void stop() {
-            // Nothing to stop: we're not using a Scheduler.
-        }
-    }
-
-    /**
-     * This class is an extension on the {@link Buffers} class which only supports one
-     * active (not yet emitted) internal {@link Buffer} object.
-     *
-     * @param <T> The type of object all internal {@link Buffer} objects record.
-     */
-    private static class NonOverlappingBuffers<T> extends Buffers<T> {
-
-        private final Object lock = new Object();
-
-        public NonOverlappingBuffers(Observer<? super List<T>> observer) {
-            super(observer);
-        }
-
-        public Buffer<T> emitAndReplaceBuffer() {
-            synchronized (lock) {
-                emitBuffer(getBuffer());
-                return createBuffer();
-            }
-        }
-
-        @Override
-        public void pushValue(T value) {
-            synchronized (lock) {
-                super.pushValue(value);
-            }
-        }
-    }
-
-    /**
-     * This class is an extension on the {@link Buffers} class which actually has no additional
-     * behavior than its super class. Classes extending this class, are expected to support
-     * two or more active (not yet emitted) internal {@link Buffer} objects.
-     *
-     * @param <T> The type of object all internal {@link Buffer} objects record.
-     */
-    private static class OverlappingBuffers<T> extends Buffers<T> {
-        public OverlappingBuffers(Observer<? super List<T>> observer) {
-            super(observer);
-        }
-    }
-
-    /**
-     * This class is an extension on the {@link Buffers} class. Every internal buffer has
-     * a has a maximum time to live and a maximum internal capacity. When the buffer has
-     * reached the end of its life, or reached its maximum internal capacity it is
-     * automatically emitted.
-     *
-     * @param <T> The type of object all internal {@link Buffer} objects record.
-     */
-    private static class TimeAndSizeBasedBuffers<T> extends Buffers<T> {
-
-        private final ConcurrentMap<Buffer<T>, Subscription> subscriptions = new ConcurrentHashMap<Buffer<T>, Subscription>();
-
-        private final Scheduler scheduler;
-        private final long maxTime;
-        private final TimeUnit unit;
-        private final int maxSize;
-
-        public TimeAndSizeBasedBuffers(Observer<? super List<T>> observer, int maxSize, long maxTime, TimeUnit unit, Scheduler scheduler) {
-            super(observer);
-            this.maxSize = maxSize;
-            this.maxTime = maxTime;
-            this.unit = unit;
-            this.scheduler = scheduler;
-        }
-
-        @Override
-        public Buffer<T> createBuffer() {
-            final Buffer<T> buffer = super.createBuffer();
-            subscriptions.put(buffer, scheduler.schedule(new Action0() {
-                @Override
-                public void call() {
-                    emitBuffer(buffer);
-                }
-            }, maxTime, unit));
-            return buffer;
-        }
-
-        @Override
-        public void emitBuffer(Buffer<T> buffer) {
-            Subscription subscription = subscriptions.remove(buffer);
-            if (subscription == null) {
-                // Buffer was already emitted.
-                return;
-            }
-
-            subscription.unsubscribe();
-            super.emitBuffer(buffer);
-            createBuffer();
-        }
-
-        @Override
-        public void pushValue(T value) {
-            super.pushValue(value);
-
-            Buffer<T> buffer;
-            while ((buffer = getBuffer()) != null) {
-                if (buffer.contents.size() >= maxSize) {
-                    emitBuffer(buffer);
-                } else {
-                    // Buffer is not at full capacity yet, and neither will remaining buffers be so we can terminate.
-                    break;
-                }
-            }
-        }
-    }
-
-    /**
-     * This class is an extension on the {@link Buffers} class. Every internal buffer has
-     * a has a maximum time to live. When the buffer has reached the end of its life it is
-     * automatically emitted.
-     *
-     * @param <T> The type of object all internal {@link Buffer} objects record.
-     */
-    private static class TimeBasedBuffers<T> extends OverlappingBuffers<T> {
-
-        private final ConcurrentMap<Buffer<T>, Subscription> subscriptions = new ConcurrentHashMap<Buffer<T>, Subscription>();
-
-        private final Scheduler scheduler;
-        private final long time;
-        private final TimeUnit unit;
-
-        public TimeBasedBuffers(Observer<? super List<T>> observer, long time, TimeUnit unit, Scheduler scheduler) {
-            super(observer);
-            this.time = time;
-            this.unit = unit;
-            this.scheduler = scheduler;
-        }
-
-        @Override
-        public Buffer<T> createBuffer() {
-            final Buffer<T> buffer = super.createBuffer();
-            subscriptions.put(buffer, scheduler.schedule(new Action0() {
-                @Override
-                public void call() {
-                    emitBuffer(buffer);
-                }
-            }, time, unit));
-            return buffer;
-        }
-
-        @Override
-        public void emitBuffer(Buffer<T> buffer) {
-            subscriptions.remove(buffer);
-            super.emitBuffer(buffer);
-        }
-    }
-
-    /**
-     * This class is an extension on the {@link Buffers} class. Every internal buffer has
-     * a fixed maximum capacity. When the buffer has reached its maximum capacity it is
-     * automatically emitted.
-     *
-     * @param <T> The type of object all internal {@link Buffer} objects record.
-     */
-    private static class SizeBasedBuffers<T> extends Buffers<T> {
-
-        private final int size;
-
-        public SizeBasedBuffers(Observer<? super List<T>> observer, int size) {
-            super(observer);
-            this.size = size;
-        }
-
-        @Override
-        public void pushValue(T value) {
-            super.pushValue(value);
-
-            Buffer<T> buffer;
-            while ((buffer = getBuffer()) != null) {
-                if (buffer.contents.size() >= size) {
-                    emitBuffer(buffer);
-                } else {
-                    // Buffer is not at full capacity yet, and neither will remaining buffers be so we can terminate.
-                    break;
-                }
-            }
-        }
-    }
-
-    /**
-     * This class represents an object which contains and manages multiple {@link Buffer} objects.
-     * 
-     * @param <T> The type of objects which the internal {@link Buffer} objects record.
-     */
-    private static class Buffers<T> {
-
-        private final Queue<Buffer<T>> buffers = new ConcurrentLinkedQueue<Buffer<T>>();
-        private final Observer<? super List<T>> observer;
-
-        /**
-         * Constructs a new {@link Buffers} object for the specified {@link Observer}.
-         * 
-         * @param observer
-         *            The {@link Observer} to which this object will emit its internal
-         *            {@link Buffer} objects to when requested.
-         */
-        public Buffers(Observer<? super List<T>> observer) {
-            this.observer = observer;
-        }
-
-        /**
-         * This method will instantiate a new {@link Buffer} object and register it internally.
-         * 
-         * @return
-         *            The constructed empty {@link Buffer} object.
-         */
-        public Buffer<T> createBuffer() {
-            Buffer<T> buffer = new Buffer<T>();
-            buffers.add(buffer);
-            return buffer;
-        }
-
-        /**
-         * This method emits all not yet emitted {@link Buffer} objects.
-         */
-        public void emitAllBuffers() {
-            Buffer<T> buffer;
-            while ((buffer = buffers.poll()) != null) {
-                observer.onNext(buffer.getContents());
-            }
-        }
-
-        /**
-         * This method emits the specified {@link Buffer} object.
-         * 
-         * @param buffer
-         *            The {@link Buffer} to emit.
-         */
-        public void emitBuffer(Buffer<T> buffer) {
-            if (!buffers.remove(buffer)) {
-                // Concurrency issue: Buffer is already emitted!
-                return;
-            }
-            observer.onNext(buffer.getContents());
-        }
-
-        /**
-         * @return
-         *            The oldest (in case there are multiple) {@link Buffer} object.
-         */
-        public Buffer<T> getBuffer() {
-            return buffers.peek();
-        }
-
-        /**
-         * This method pushes a value to all not yet emitted {@link Buffer} objects.
-         * 
-         * @param value
-         *            The value to push to all not yet emitted {@link Buffer} objects.
-         */
-        public void pushValue(T value) {
-            List<Buffer<T>> copy = new ArrayList<Buffer<T>>(buffers);
-            for (Buffer<T> buffer : copy) {
-                buffer.pushValue(value);
-            }
-        }
-    }
-
     /**
      * This class represents a single buffer: A sequence of recorded values.
      * 
      * @param <T> The type of objects which this {@link Buffer} can hold.
      */
-    private static class Buffer<T> {
-        private final List<T> contents = new ArrayList<T>();
-
-        /**
-         * Appends a specified value to the {@link Buffer}.
-         * 
-         * @param value
-         *            The value to append to the {@link Buffer}.
-         */
-        public void pushValue(T value) {
-            contents.add(value);
-        }
-
+    protected static class Buffer<T> extends Chunk<T, List<T>> {
         /**
          * @return
          *            The mutable underlying {@link List} which contains all the
          *            recorded values in this {@link Buffer} object.
          */
+        @Override
         public List<T> getContents() {
             return contents;
         }
@@ -890,9 +382,9 @@ public void before() {
 
         @Test
         public void testComplete() {
-            Observable<String> source = Observable.create(new OnSubscribeFunc<String>() {
+            Observable<String> source = Observable.create(new Func1<Observer<String>, Subscription>() {
                 @Override
-                public Subscription onSubscribe(Observer<? super String> observer) {
+                public Subscription call(Observer<String> observer) {
                     observer.onCompleted();
                     return Subscriptions.empty();
                 }
@@ -908,9 +400,9 @@ public Subscription onSubscribe(Observer<? super String> observer) {
 
         @Test
         public void testSkipAndCountOverlappingBuffers() {
-            Observable<String> source = Observable.create(new OnSubscribeFunc<String>() {
+            Observable<String> source = Observable.create(new Func1<Observer<String>, Subscription>() {
                 @Override
-                public Subscription onSubscribe(Observer<? super String> observer) {
+                public Subscription call(Observer<String> observer) {
                     observer.onNext("one");
                     observer.onNext("two");
                     observer.onNext("three");
@@ -934,9 +426,9 @@ public Subscription onSubscribe(Observer<? super String> observer) {
 
         @Test
         public void testSkipAndCountGaplessBuffers() {
-            Observable<String> source = Observable.create(new OnSubscribeFunc<String>() {
+            Observable<String> source = Observable.create(new Func1<Observer<String>, Subscription>() {
                 @Override
-                public Subscription onSubscribe(Observer<? super String> observer) {
+                public Subscription call(Observer<String> observer) {
                     observer.onNext("one");
                     observer.onNext("two");
                     observer.onNext("three");
@@ -960,9 +452,9 @@ public Subscription onSubscribe(Observer<? super String> observer) {
 
         @Test
         public void testSkipAndCountBuffersWithGaps() {
-            Observable<String> source = Observable.create(new OnSubscribeFunc<String>() {
+            Observable<String> source = Observable.create(new Func1<Observer<String>, Subscription>() {
                 @Override
-                public Subscription onSubscribe(Observer<? super String> observer) {
+                public Subscription call(Observer<String> observer) {
                     observer.onNext("one");
                     observer.onNext("two");
                     observer.onNext("three");
@@ -986,9 +478,9 @@ public Subscription onSubscribe(Observer<? super String> observer) {
 
         @Test
         public void testTimedAndCount() {
-            Observable<String> source = Observable.create(new OnSubscribeFunc<String>() {
+            Observable<String> source = Observable.create(new Func1<Observer<String>, Subscription>() {
                 @Override
-                public Subscription onSubscribe(Observer<? super String> observer) {
+                public Subscription call(Observer<String> observer) {
                     push(observer, "one", 10);
                     push(observer, "two", 90);
                     push(observer, "three", 110);
@@ -1018,9 +510,9 @@ public Subscription onSubscribe(Observer<? super String> observer) {
 
         @Test
         public void testTimed() {
-            Observable<String> source = Observable.create(new OnSubscribeFunc<String>() {
+            Observable<String> source = Observable.create(new Func1<Observer<String>, Subscription>() {
                 @Override
-                public Subscription onSubscribe(Observer<? super String> observer) {
+                public Subscription call(Observer<String> observer) {
                     push(observer, "one", 98);
                     push(observer, "two", 99);
                     push(observer, "three", 100);
@@ -1047,9 +539,9 @@ public Subscription onSubscribe(Observer<? super String> observer) {
 
         @Test
         public void testObservableBasedOpenerAndCloser() {
-            Observable<String> source = Observable.create(new OnSubscribeFunc<String>() {
+            Observable<String> source = Observable.create(new Func1<Observer<String>, Subscription>() {
                 @Override
-                public Subscription onSubscribe(Observer<? super String> observer) {
+                public Subscription call(Observer<String> observer) {
                     push(observer, "one", 10);
                     push(observer, "two", 60);
                     push(observer, "three", 110);
@@ -1060,23 +552,23 @@ public Subscription onSubscribe(Observer<? super String> observer) {
                 }
             });
 
-            Observable<BufferOpening> openings = Observable.create(new OnSubscribeFunc<BufferOpening>() {
+            Observable<Opening> openings = Observable.create(new Func1<Observer<Opening>, Subscription>() {
                 @Override
-                public Subscription onSubscribe(Observer<? super BufferOpening> observer) {
-                    push(observer, BufferOpenings.create(), 50);
-                    push(observer, BufferOpenings.create(), 200);
+                public Subscription call(Observer<Opening> observer) {
+                    push(observer, Openings.create(), 50);
+                    push(observer, Openings.create(), 200);
                     complete(observer, 250);
                     return Subscriptions.empty();
                 }
             });
 
-            Func1<BufferOpening, Observable<BufferClosing>> closer = new Func1<BufferOpening, Observable<BufferClosing>>() {
+            Func1<Opening, Observable<Closing>> closer = new Func1<Opening, Observable<Closing>>() {
                 @Override
-                public Observable<BufferClosing> call(BufferOpening opening) {
-                    return Observable.create(new OnSubscribeFunc<BufferClosing>() {
+                public Observable<Closing> call(Opening opening) {
+                    return Observable.create(new Func1<Observer<Closing>, Subscription>() {
                         @Override
-                        public Subscription onSubscribe(Observer<? super BufferClosing> observer) {
-                            push(observer, BufferClosings.create(), 100);
+                        public Subscription call(Observer<Closing> observer) {
+                            push(observer, Closings.create(), 100);
                             complete(observer, 101);
                             return Subscriptions.empty();
                         }
@@ -1098,9 +590,9 @@ public Subscription onSubscribe(Observer<? super BufferClosing> observer) {
 
         @Test
         public void testObservableBasedCloser() {
-            Observable<String> source = Observable.create(new OnSubscribeFunc<String>() {
+            Observable<String> source = Observable.create(new Func1<Observer<String>, Subscription>() {
                 @Override
-                public Subscription onSubscribe(Observer<? super String> observer) {
+                public Subscription call(Observer<String> observer) {
                     push(observer, "one", 10);
                     push(observer, "two", 60);
                     push(observer, "three", 110);
@@ -1111,13 +603,13 @@ public Subscription onSubscribe(Observer<? super String> observer) {
                 }
             });
 
-            Func0<Observable<BufferClosing>> closer = new Func0<Observable<BufferClosing>>() {
+            Func0<Observable<Closing>> closer = new Func0<Observable<Closing>>() {
                 @Override
-                public Observable<BufferClosing> call() {
-                    return Observable.create(new OnSubscribeFunc<BufferClosing>() {
+                public Observable<Closing> call() {
+                    return Observable.create(new Func1<Observer<Closing>, Subscription>() {
                         @Override
-                        public Subscription onSubscribe(Observer<? super BufferClosing> observer) {
-                            push(observer, BufferClosings.create(), 100);
+                        public Subscription call(Observer<Closing> observer) {
+                            push(observer, Closings.create(), 100);
                             complete(observer, 101);
                             return Subscriptions.empty();
                         }
diff --git a/rxjava-core/src/main/java/rx/operators/OperationWindow.java b/rxjava-core/src/main/java/rx/operators/OperationWindow.java
new file mode 100644
index 0000000000..ce603de8cf
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperationWindow.java
@@ -0,0 +1,660 @@
+/**
+ * Copyright 2013 Netflix, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package rx.operators;
+
+import org.junit.Before;
+import org.junit.Test;
+import rx.Observable;
+import rx.Observer;
+import rx.Scheduler;
+import rx.Subscription;
+import rx.concurrency.Schedulers;
+import rx.concurrency.TestScheduler;
+import rx.subscriptions.Subscriptions;
+import rx.util.Closing;
+import rx.util.Closings;
+import rx.util.Opening;
+import rx.util.Openings;
+import rx.util.functions.*;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+
+public final class OperationWindow extends ChunkedOperation {
+
+    public static final Func0 WINDOW_MAKER = new Func0() {
+        @Override
+        public Object call() {
+            return new Window();
+        }
+    };
+
+    /**
+     * <p>This method creates a {@link rx.util.functions.Func1} object which represents the window operation. This operation takes
+     * values from the specified {@link rx.Observable} source and stores them in a window until the {@link rx.Observable}
+     * constructed using the {@link rx.util.functions.Func0} argument, produces a {@link rx.util.Closing} value. The window is then
+     * emitted, and a new window is created to replace it. A new {@link rx.Observable} will be constructed using the
+     * provided {@link rx.util.functions.Func0} object, which will determine when this new window is emitted. When the source
+     * {@link rx.Observable} completes or produces an error, the current window is emitted, and the event is propagated
+     * to all subscribed {@link rx.Observer}s.</p>
+     *
+     * <p>Note that this operation only produces <strong>non-overlapping windows</strong>. At all times there is
+     * exactly one window actively storing values.</p>
+     *
+     * @param source
+     *            The {@link rx.Observable} which produces values.
+     * @param windowClosingSelector
+     *            A {@link rx.util.functions.Func0} object which produces {@link rx.Observable}s. These
+     *            {@link rx.Observable}s determine when a window is emitted and replaced by simply
+     *            producing an {@link rx.util.Closing} object.
+     * @return
+     *            the {@link rx.util.functions.Func1} object representing the specified window operation.
+     */
+    public static <T> Func1<Observer<Observable<T>>, Subscription> window(final Observable<T> source, final Func0<Observable<Closing>> windowClosingSelector) {
+        return new Func1<Observer<Observable<T>>, Subscription>() {
+            @Override
+            public Subscription call(final Observer<Observable<T>> observer) {
+                NonOverlappingChunks<T, Observable<T>> windows = new NonOverlappingChunks<T, Observable<T>>(observer, WINDOW_MAKER);
+                ChunkCreator creator = new ObservableBasedSingleChunkCreator<T, Observable<T>>(windows, windowClosingSelector);
+                return source.subscribe(new ChunkObserver<T, Observable<T>>(windows, observer, creator));
+            }
+        };
+    }
+
+    /**
+     * <p>This method creates a {@link rx.util.functions.Func1} object which represents the window operation. This operation takes
+     * values from the specified {@link rx.Observable} source and stores them in the currently active window. Initially
+     * there are no windows active.</p>
+     *
+     * <p>Windows can be created by pushing a {@link rx.util.Opening} value to the "windowOpenings" {@link rx.Observable}.
+     * This creates a new window which will then start recording values which are produced by the "source"
+     * {@link rx.Observable}. Additionally the "windowClosingSelector" will be used to construct an {@link rx.Observable}
+     * which can produce {@link rx.util.Closing} values. When it does so it will close this (and only this) newly created
+     * window. When the source {@link rx.Observable} completes or produces an error, all windows are emitted, and the
+     * event is propagated to all subscribed {@link rx.Observer}s.</p>
+     *
+     * <p>Note that when using this operation <strong>multiple overlapping windows</strong>
+     * could be active at any one point.</p>
+     *
+     * @param source
+     *            The {@link rx.Observable} which produces values.
+     * @param windowOpenings
+     *            An {@link rx.Observable} which when it produces a {@link rx.util.Opening} value will
+     *            create a new window which instantly starts recording the "source" {@link rx.Observable}.
+     * @param windowClosingSelector
+     *            A {@link rx.util.functions.Func0} object which produces {@link rx.Observable}s. These
+     *            {@link rx.Observable}s determine when a window is emitted and replaced by simply
+     *            producing an {@link rx.util.Closing} object.
+     * @return
+     *            the {@link rx.util.functions.Func1} object representing the specified window operation.
+     */
+    public static <T> Func1<Observer<Observable<T>>, Subscription> window(final Observable<T> source, final Observable<Opening> windowOpenings, final Func1<Opening, Observable<Closing>> windowClosingSelector) {
+        return new Func1<Observer<Observable<T>>, Subscription>() {
+            @Override
+            public Subscription call(final Observer<Observable<T>> observer) {
+                OverlappingChunks<T, Observable<T>> windows = new OverlappingChunks<T, Observable<T>>(observer, WINDOW_MAKER);
+                ChunkCreator creator = new ObservableBasedMultiChunkCreator<T, Observable<T>>(windows, windowOpenings, windowClosingSelector);
+                return source.subscribe(new ChunkObserver<T, Observable<T>>(windows, observer, creator));
+            }
+        };
+    }
+
+    /**
+     * <p>This method creates a {@link rx.util.functions.Func1} object which represents the window operation. This operation takes
+     * values from the specified {@link rx.Observable} source and stores them in a window until the window contains
+     * a specified number of elements. The window is then emitted, and a new window is created to replace it.
+     * When the source {@link rx.Observable} completes or produces an error, the current window is emitted, and
+     * the event is propagated to all subscribed {@link rx.Observer}s.</p>
+     *
+     * <p>Note that this operation only produces <strong>non-overlapping windows</strong>. At all times there is
+     * exactly one window actively storing values.</p>
+     *
+     * @param source
+     *            The {@link rx.Observable} which produces values.
+     * @param count
+     *            The number of elements a window should have before being emitted and replaced.
+     * @return
+     *            the {@link rx.util.functions.Func1} object representing the specified window operation.
+     */
+    public static <T> Func1<Observer<Observable<T>>, Subscription> window(Observable<T> source, int count) {
+        return window(source, count, count);
+    }
+
+    /**
+     * <p>This method creates a {@link rx.util.functions.Func1} object which represents the window operation. This operation takes
+     * values from the specified {@link rx.Observable} source and stores them in all active windows until the window
+     * contains a specified number of elements. The window is then emitted. windows are created after a certain
+     * amount of values have been received. When the source {@link rx.Observable} completes or produces an error, the
+     * currently active windows are emitted, and the event is propagated to all subscribed {@link rx.Observer}s.</p>
+     *
+     * <p>Note that this operation can produce <strong>non-connected, connected non-overlapping, or overlapping
+     * windows</strong> depending on the input parameters.</p>
+     *
+     * @param source
+     *            The {@link rx.Observable} which produces values.
+     * @param count
+     *            The number of elements a window should have before being emitted.
+     * @param skip
+     *            The interval with which windows have to be created. Note that when "skip" == "count"
+     *            that this is the same as calling {@link rx.operators.OperationWindow#window(rx.Observable, int)}.
+     *            If "skip" < "count", this window operation will produce overlapping windows and if "skip"
+     *            > "count" non-overlapping windows will be created and some values will not be pushed
+     *            into a window at all!
+     * @return
+     *            the {@link rx.util.functions.Func1} object representing the specified window operation.
+     */
+    public static <T> Func1<Observer<Observable<T>>, Subscription> window(final Observable<T> source, final int count, final int skip) {
+        return new Func1<Observer<Observable<T>>, Subscription>() {
+            @Override
+            public Subscription call(final Observer<Observable<T>> observer) {
+                Chunks<T, Observable<T>> chunks = new SizeBasedChunks<T, Observable<T>>(observer, WINDOW_MAKER, count);
+                ChunkCreator creator = new SkippingChunkCreator<T, Observable<T>>(chunks, skip);
+                return source.subscribe(new ChunkObserver<T, Observable<T>>(chunks, observer, creator));
+            }
+        };
+    }
+
+    /**
+     * <p>This method creates a {@link rx.util.functions.Func1} object which represents the window operation. This operation takes
+     * values from the specified {@link rx.Observable} source and stores them in a window. Periodically the window
+     * is emitted and replaced with a new window. How often this is done depends on the specified timespan.
+     * When the source {@link rx.Observable} completes or produces an error, the current window is emitted, and
+     * the event is propagated to all subscribed {@link rx.Observer}s.</p>
+     *
+     * <p>Note that this operation only produces <strong>non-overlapping windows</strong>. At all times there is
+     * exactly one window actively storing values.</p>
+     *
+     * @param source
+     *            The {@link rx.Observable} which produces values.
+     * @param timespan
+     *            The amount of time all windows must be actively collect values before being emitted.
+     * @param unit
+     *            The {@link java.util.concurrent.TimeUnit} defining the unit of time for the timespan.
+     * @return
+     *            the {@link rx.util.functions.Func1} object representing the specified window operation.
+     */
+    public static <T> Func1<Observer<Observable<T>>, Subscription> window(Observable<T> source, long timespan, TimeUnit unit) {
+        return window(source, timespan, unit, Schedulers.threadPoolForComputation());
+    }
+
+    /**
+     * <p>This method creates a {@link rx.util.functions.Func1} object which represents the window operation. This operation takes
+     * values from the specified {@link rx.Observable} source and stores them in a window. Periodically the window
+     * is emitted and replaced with a new window. How often this is done depends on the specified timespan.
+     * When the source {@link rx.Observable} completes or produces an error, the current window is emitted, and
+     * the event is propagated to all subscribed {@link rx.Observer}s.</p>
+     *
+     * <p>Note that this operation only produces <strong>non-overlapping windows</strong>. At all times there is
+     * exactly one window actively storing values.</p>
+     *
+     * @param source
+     *            The {@link rx.Observable} which produces values.
+     * @param timespan
+     *            The amount of time all windows must be actively collect values before being emitted.
+     * @param unit
+     *            The {@link java.util.concurrent.TimeUnit} defining the unit of time for the timespan.
+     * @param scheduler
+     *            The {@link rx.Scheduler} to use for timing windows.
+     * @return
+     *            the {@link rx.util.functions.Func1} object representing the specified window operation.
+     */
+    public static <T> Func1<Observer<Observable<T>>, Subscription> window(final Observable<T> source, final long timespan, final TimeUnit unit, final Scheduler scheduler) {
+        return new Func1<Observer<Observable<T>>, Subscription>() {
+            @Override
+            public Subscription call(final Observer<Observable<T>> observer) {
+                NonOverlappingChunks<T, Observable<T>> windows = new NonOverlappingChunks<T, Observable<T>>(observer, WINDOW_MAKER);
+                ChunkCreator creator = new TimeBasedChunkCreator<T, Observable<T>>(windows, timespan, unit, scheduler);
+                return source.subscribe(new ChunkObserver<T, Observable<T>>(windows, observer, creator));
+            }
+        };
+    }
+
+    /**
+     * <p>This method creates a {@link rx.util.functions.Func1} object which represents the window operation. This operation takes
+     * values from the specified {@link rx.Observable} source and stores them in a window. Periodically the window
+     * is emitted and replaced with a new window. How often this is done depends on the specified timespan.
+     * Additionally the window is automatically emitted once it reaches a specified number of elements.
+     * When the source {@link rx.Observable} completes or produces an error, the current window is emitted, and
+     * the event is propagated to all subscribed {@link rx.Observer}s.</p>
+     *
+     * <p>Note that this operation only produces <strong>non-overlapping windows</strong>. At all times there is
+     * exactly one window actively storing values.</p>
+     *
+     * @param source
+     *            The {@link rx.Observable} which produces values.
+     * @param timespan
+     *            The amount of time all windows must be actively collect values before being emitted.
+     * @param unit
+     *            The {@link java.util.concurrent.TimeUnit} defining the unit of time for the timespan.
+     * @param count
+     *            The maximum size of the window. Once a window reaches this size, it is emitted.
+     * @return
+     *            the {@link rx.util.functions.Func1} object representing the specified window operation.
+     */
+    public static <T> Func1<Observer<Observable<T>>, Subscription> window(Observable<T> source, long timespan, TimeUnit unit, int count) {
+        return window(source, timespan, unit, count, Schedulers.threadPoolForComputation());
+    }
+
+    /**
+     * <p>This method creates a {@link rx.util.functions.Func1} object which represents the window operation. This operation takes
+     * values from the specified {@link rx.Observable} source and stores them in a window. Periodically the window
+     * is emitted and replaced with a new window. How often this is done depends on the specified timespan.
+     * Additionally the window is automatically emitted once it reaches a specified number of elements.
+     * When the source {@link rx.Observable} completes or produces an error, the current window is emitted, and
+     * the event is propagated to all subscribed {@link rx.Observer}s.</p>
+     *
+     * <p>Note that this operation only produces <strong>non-overlapping windows</strong>. At all times there is
+     * exactly one window actively storing values.</p>
+     *
+     * @param source
+     *            The {@link rx.Observable} which produces values.
+     * @param timespan
+     *            The amount of time all windows must be actively collect values before being emitted.
+     * @param unit
+     *            The {@link java.util.concurrent.TimeUnit} defining the unit of time for the timespan.
+     * @param count
+     *            The maximum size of the window. Once a window reaches this size, it is emitted.
+     * @param scheduler
+     *            The {@link rx.Scheduler} to use for timing windows.
+     * @return
+     *            the {@link rx.util.functions.Func1} object representing the specified window operation.
+     */
+    public static <T> Func1<Observer<Observable<T>>, Subscription> window(final Observable<T> source, final long timespan, final TimeUnit unit, final int count, final Scheduler scheduler) {
+        return new Func1<Observer<Observable<T>>, Subscription>() {
+            @Override
+            public Subscription call(final Observer<Observable<T>> observer) {
+                Chunks<T, Observable<T>> chunks = new TimeAndSizeBasedChunks<T, Observable<T>>(observer, WINDOW_MAKER, count, timespan, unit, scheduler);
+                ChunkCreator creator = new SingleChunkCreator<T, Observable<T>>(chunks);
+                return source.subscribe(new ChunkObserver<T, Observable<T>>(chunks, observer, creator));
+            }
+        };
+    }
+
+    /**
+     * <p>This method creates a {@link rx.util.functions.Func1} object which represents the window operation. This operation takes
+     * values from the specified {@link rx.Observable} source and stores them in a window. Periodically the window
+     * is emitted and replaced with a new window. How often this is done depends on the specified timespan.
+     * The creation of windows is also periodical. How often this is done depends on the specified timeshift.
+     * When the source {@link rx.Observable} completes or produces an error, the current window is emitted, and
+     * the event is propagated to all subscribed {@link rx.Observer}s.</p>
+     *
+     * <p>Note that this operation can produce <strong>non-connected, or overlapping windows</strong> depending
+     * on the input parameters.</p>
+     *
+     * @param source
+     *            The {@link rx.Observable} which produces values.
+     * @param timespan
+     *            The amount of time all windows must be actively collect values before being emitted.
+     * @param timeshift
+     *            The amount of time between creating windows.
+     * @param unit
+     *            The {@link java.util.concurrent.TimeUnit} defining the unit of time for the timespan.
+     * @return
+     *            the {@link rx.util.functions.Func1} object representing the specified window operation.
+     */
+    public static <T> Func1<Observer<Observable<T>>, Subscription> window(Observable<T> source, long timespan, long timeshift, TimeUnit unit) {
+        return window(source, timespan, timeshift, unit, Schedulers.threadPoolForComputation());
+    }
+
+    /**
+     * <p>This method creates a {@link rx.util.functions.Func1} object which represents the window operation. This operation takes
+     * values from the specified {@link rx.Observable} source and stores them in a window. Periodically the window
+     * is emitted and replaced with a new window. How often this is done depends on the specified timespan.
+     * The creation of windows is also periodical. How often this is done depends on the specified timeshift.
+     * When the source {@link rx.Observable} completes or produces an error, the current window is emitted, and
+     * the event is propagated to all subscribed {@link rx.Observer}s.</p>
+     *
+     * <p>Note that this operation can produce <strong>non-connected, or overlapping windows</strong> depending
+     * on the input parameters.</p>
+     *
+     * @param source
+     *            The {@link rx.Observable} which produces values.
+     * @param timespan
+     *            The amount of time all windows must be actively collect values before being emitted.
+     * @param timeshift
+     *            The amount of time between creating windows.
+     * @param unit
+     *            The {@link java.util.concurrent.TimeUnit} defining the unit of time for the timespan.
+     * @param scheduler
+     *            The {@link rx.Scheduler} to use for timing windows.
+     * @return
+     *            the {@link rx.util.functions.Func1} object representing the specified window operation.
+     */
+    public static <T> Func1<Observer<Observable<T>>, Subscription> window(final Observable<T> source, final long timespan, final long timeshift, final TimeUnit unit, final Scheduler scheduler) {
+        return new Func1<Observer<Observable<T>>, Subscription>() {
+            @Override
+            public Subscription call(final Observer<Observable<T>> observer) {
+                OverlappingChunks<T, Observable<T>> windows = new TimeBasedChunks<T, Observable<T>>(observer, WINDOW_MAKER, timespan, unit, scheduler);
+                ChunkCreator creator = new TimeBasedChunkCreator<T, Observable<T>>(windows, timeshift, unit, scheduler);
+                return source.subscribe(new ChunkObserver<T, Observable<T>>(windows, observer, creator));
+            }
+        };
+    }
+
+    /**
+     * This class represents a single window: A sequence of recorded values.
+     *
+     * @param <T> The type of objects which this {@link Window} can hold.
+     */
+    protected static class Window<T> extends Chunk<T, Observable<T>> {
+        /**
+         * @return
+         *            The mutable underlying {@link Observable} which contains all the
+         *            recorded values in this {@link Window} object.
+         */
+        @Override
+        public Observable<T> getContents() {
+            return Observable.from(contents);
+        }
+    }
+
+    public static class UnitTest {
+
+        private TestScheduler scheduler;
+
+        @Before
+        @SuppressWarnings("unchecked")
+        public void before() {
+            scheduler = new TestScheduler();
+        }
+
+        private static <T> List<List<T>> toLists(Observable<Observable<T>> observable) {
+            final List<T> list = new ArrayList<T>();
+            final List<List<T>> lists = new ArrayList<List<T>>();
+
+            observable.subscribe(new Action1<Observable<T>>() {
+                @Override
+                public void call(Observable<T> tObservable) {
+                    tObservable.subscribe(new Action1<T>() {
+                        @Override
+                        public void call(T t) {
+                            list.add(t);
+                        }
+                    });
+                    lists.add(new ArrayList<T>(list));
+                    list.clear();
+                }
+            });
+            return lists;
+        }
+
+        @Test
+        public void testNonOverlappingWindows() {
+            Observable<String> subject = Observable.from("one", "two", "three", "four", "five");
+            Observable<Observable<String>> windowed = Observable.create(window(subject, 3));
+
+            List<List<String>> windows = toLists(windowed);
+
+            assertEquals(2, windows.size());
+            assertEquals(list("one", "two", "three"), windows.get(0));
+            assertEquals(list("four", "five"), windows.get(1));
+        }
+
+        @Test
+        public void testSkipAndCountGaplessEindows() {
+            Observable<String> subject = Observable.from("one", "two", "three", "four", "five");
+            Observable<Observable<String>> windowed = Observable.create(window(subject, 3, 3));
+
+            List<List<String>> windows = toLists(windowed);
+
+            assertEquals(2, windows.size());
+            assertEquals(list("one", "two", "three"), windows.get(0));
+            assertEquals(list("four", "five"), windows.get(1));
+        }
+
+        @Test
+        public void testOverlappingWindows() {
+            Observable<String> subject = Observable.from("zero", "one", "two", "three", "four", "five");
+            Observable<Observable<String>> windowed = Observable.create(window(subject, 3, 1));
+
+            List<List<String>> windows = toLists(windowed);
+
+            assertEquals(6, windows.size());
+            assertEquals(list("zero", "one", "two"), windows.get(0));
+            assertEquals(list("one", "two", "three"), windows.get(1));
+            assertEquals(list("two", "three", "four"), windows.get(2));
+            assertEquals(list("three", "four", "five"), windows.get(3));
+            assertEquals(list("four", "five"), windows.get(4));
+            assertEquals(list("five"), windows.get(5));
+        }
+
+        @Test
+        public void testSkipAndCountWindowsWithGaps() {
+            Observable<String> subject = Observable.from("one", "two", "three", "four", "five");
+            Observable<Observable<String>> windowed = Observable.create(window(subject, 2, 3));
+
+            List<List<String>> windows = toLists(windowed);
+
+            assertEquals(2, windows.size());
+            assertEquals(list("one", "two"), windows.get(0));
+            assertEquals(list("four", "five"), windows.get(1));
+        }
+
+        @Test
+        public void testTimedAndCount() {
+            final List<String> list = new ArrayList<String>();
+            final List<List<String>> lists = new ArrayList<List<String>>();
+
+            Observable<String> source = Observable.create(new Func1<Observer<String>, Subscription>() {
+                @Override
+                public Subscription call(Observer<String> observer) {
+                    push(observer, "one", 10);
+                    push(observer, "two", 90);
+                    push(observer, "three", 110);
+                    push(observer, "four", 190);
+                    push(observer, "five", 210);
+                    complete(observer, 250);
+                    return Subscriptions.empty();
+                }
+            });
+
+            Observable<Observable<String>> windowed = Observable.create(window(source, 100, TimeUnit.MILLISECONDS, 2, scheduler));
+            windowed.subscribe(observeWindow(list, lists));
+
+            scheduler.advanceTimeTo(100, TimeUnit.MILLISECONDS);
+            assertEquals(1, lists.size());
+            assertEquals(lists.get(0), list("one", "two"));
+
+            scheduler.advanceTimeTo(200, TimeUnit.MILLISECONDS);
+            assertEquals(2, lists.size());
+            assertEquals(lists.get(1), list("three", "four"));
+
+            scheduler.advanceTimeTo(300, TimeUnit.MILLISECONDS);
+            assertEquals(3, lists.size());
+            assertEquals(lists.get(2), list("five"));
+        }
+
+        @Test
+        public void testTimed() {
+            final List<String> list = new ArrayList<String>();
+            final List<List<String>> lists = new ArrayList<List<String>>();
+
+            Observable<String> source = Observable.create(new Func1<Observer<String>, Subscription>() {
+                @Override
+                public Subscription call(Observer<String> observer) {
+                    push(observer, "one", 98);
+                    push(observer, "two", 99);
+                    push(observer, "three", 100);
+                    push(observer, "four", 101);
+                    push(observer, "five", 102);
+                    complete(observer, 150);
+                    return Subscriptions.empty();
+                }
+            });
+
+            Observable<Observable<String>> windowed = Observable.create(window(source, 100, TimeUnit.MILLISECONDS, scheduler));
+            windowed.subscribe(observeWindow(list, lists));
+
+            scheduler.advanceTimeTo(101, TimeUnit.MILLISECONDS);
+            assertEquals(1, lists.size());
+            assertEquals(lists.get(0), list("one", "two", "three"));
+
+            scheduler.advanceTimeTo(201, TimeUnit.MILLISECONDS);
+            assertEquals(2, lists.size());
+            assertEquals(lists.get(1), list("four", "five"));
+        }
+
+        @Test
+        public void testObservableBasedOpenerAndCloser() {
+            final List<String> list = new ArrayList<String>();
+            final List<List<String>> lists = new ArrayList<List<String>>();
+
+            Observable<String> source = Observable.create(new Func1<Observer<String>, Subscription>() {
+                @Override
+                public Subscription call(Observer<String> observer) {
+                    push(observer, "one", 10);
+                    push(observer, "two", 60);
+                    push(observer, "three", 110);
+                    push(observer, "four", 160);
+                    push(observer, "five", 210);
+                    complete(observer, 500);
+                    return Subscriptions.empty();
+                }
+            });
+
+            Observable<Opening> openings = Observable.create(new Func1<Observer<Opening>, Subscription>() {
+                @Override
+                public Subscription call(Observer<Opening> observer) {
+                    push(observer, Openings.create(), 50);
+                    push(observer, Openings.create(), 200);
+                    complete(observer, 250);
+                    return Subscriptions.empty();
+                }
+            });
+
+            Func1<Opening, Observable<Closing>> closer = new Func1<Opening, Observable<Closing>>() {
+                @Override
+                public Observable<Closing> call(Opening opening) {
+                    return Observable.create(new Func1<Observer<Closing>, Subscription>() {
+                        @Override
+                        public Subscription call(Observer<Closing> observer) {
+                            push(observer, Closings.create(), 100);
+                            complete(observer, 101);
+                            return Subscriptions.empty();
+                        }
+                    });
+                }
+            };
+
+            Observable<Observable<String>> windowed = Observable.create(window(source, openings, closer));
+            windowed.subscribe(observeWindow(list, lists));
+
+            scheduler.advanceTimeTo(500, TimeUnit.MILLISECONDS);
+            assertEquals(2, lists.size());
+            assertEquals(lists.get(0), list("two", "three"));
+            assertEquals(lists.get(1), list("five"));
+        }
+
+        @Test
+        public void testObservableBasedCloser() {
+            final List<String> list = new ArrayList<String>();
+            final List<List<String>> lists = new ArrayList<List<String>>();
+
+            Observable<String> source = Observable.create(new Func1<Observer<String>, Subscription>() {
+                @Override
+                public Subscription call(Observer<String> observer) {
+                    push(observer, "one", 10);
+                    push(observer, "two", 60);
+                    push(observer, "three", 110);
+                    push(observer, "four", 160);
+                    push(observer, "five", 210);
+                    complete(observer, 250);
+                    return Subscriptions.empty();
+                }
+            });
+
+            Func0<Observable<Closing>> closer = new Func0<Observable<Closing>>() {
+                @Override
+                public Observable<Closing> call() {
+                    return Observable.create(new Func1<Observer<Closing>, Subscription>() {
+                        @Override
+                        public Subscription call(Observer<Closing> observer) {
+                            push(observer, Closings.create(), 100);
+                            complete(observer, 101);
+                            return Subscriptions.empty();
+                        }
+                    });
+                }
+            };
+
+            Observable<Observable<String>> windowed = Observable.create(window(source, closer));
+            windowed.subscribe(observeWindow(list, lists));
+
+            scheduler.advanceTimeTo(500, TimeUnit.MILLISECONDS);
+            assertEquals(3, lists.size());
+            assertEquals(lists.get(0), list("one", "two"));
+            assertEquals(lists.get(1), list("three", "four"));
+            assertEquals(lists.get(2), list("five"));
+        }
+
+        private List<String> list(String... args) {
+            List<String> list = new ArrayList<String>();
+            for (String arg : args) {
+                list.add(arg);
+            }
+            return list;
+        }
+
+        private <T> void push(final Observer<T> observer, final T value, int delay) {
+            scheduler.schedule(new Action0() {
+                @Override
+                public void call() {
+                    observer.onNext(value);
+                }
+            }, delay, TimeUnit.MILLISECONDS);
+        }
+
+        private void complete(final Observer<?> observer, int delay) {
+            scheduler.schedule(new Action0() {
+                @Override
+                public void call() {
+                    observer.onCompleted();
+                }
+            }, delay, TimeUnit.MILLISECONDS);
+        }
+
+        private Action1<Observable<String>> observeWindow(final List<String> list, final List<List<String>> lists) {
+            return new Action1<Observable<String>>() {
+                @Override
+                public void call(Observable<String> stringObservable) {
+                    stringObservable.subscribe(new Observer<String>() {
+                        @Override
+                        public void onCompleted() {
+                            lists.add(new ArrayList<String>(list));
+                            list.clear();
+                        }
+
+                        @Override
+                        public void onError(Throwable e) {
+                            fail(e.getMessage());
+                        }
+
+                        @Override
+                        public void onNext(String args) {
+                            list.add(args);
+                        }
+                    });
+                }
+            };
+        }
+
+    }
+}
diff --git a/rxjava-core/src/main/java/rx/util/BufferClosing.java b/rxjava-core/src/main/java/rx/util/Closing.java
similarity index 95%
rename from rxjava-core/src/main/java/rx/util/BufferClosing.java
rename to rxjava-core/src/main/java/rx/util/Closing.java
index 8340e2f36d..987d7a9dbe 100644
--- a/rxjava-core/src/main/java/rx/util/BufferClosing.java
+++ b/rxjava-core/src/main/java/rx/util/Closing.java
@@ -15,6 +15,6 @@
  */
 package rx.util;
 
-public interface BufferClosing {
+public interface Closing {
     // Tagging interface for objects which can close buffers.
 }
\ No newline at end of file
diff --git a/rxjava-core/src/main/java/rx/util/BufferClosings.java b/rxjava-core/src/main/java/rx/util/Closings.java
similarity index 82%
rename from rxjava-core/src/main/java/rx/util/BufferClosings.java
rename to rxjava-core/src/main/java/rx/util/Closings.java
index 4a6891e917..cc6c589283 100644
--- a/rxjava-core/src/main/java/rx/util/BufferClosings.java
+++ b/rxjava-core/src/main/java/rx/util/Closings.java
@@ -15,13 +15,13 @@
  */
 package rx.util;
 
-public class BufferClosings {
+public class Closings {
 
-    public static BufferClosing create() {
-        return new BufferClosing() {};
+    public static Closing create() {
+        return new Closing() {};
     }
 
-    private BufferClosings() {
+    private Closings() {
         // Prevent instantation.
     }
 }
\ No newline at end of file
diff --git a/rxjava-core/src/main/java/rx/util/BufferOpening.java b/rxjava-core/src/main/java/rx/util/Opening.java
similarity index 95%
rename from rxjava-core/src/main/java/rx/util/BufferOpening.java
rename to rxjava-core/src/main/java/rx/util/Opening.java
index 847dbbb947..03a0bbcfb1 100644
--- a/rxjava-core/src/main/java/rx/util/BufferOpening.java
+++ b/rxjava-core/src/main/java/rx/util/Opening.java
@@ -15,6 +15,6 @@
  */
 package rx.util;
 
-public interface BufferOpening {
+public interface Opening {
     // Tagging interface for objects which can open buffers.
 }
\ No newline at end of file
diff --git a/rxjava-core/src/main/java/rx/util/BufferOpenings.java b/rxjava-core/src/main/java/rx/util/Openings.java
similarity index 82%
rename from rxjava-core/src/main/java/rx/util/BufferOpenings.java
rename to rxjava-core/src/main/java/rx/util/Openings.java
index 59482d0556..3f962ec163 100644
--- a/rxjava-core/src/main/java/rx/util/BufferOpenings.java
+++ b/rxjava-core/src/main/java/rx/util/Openings.java
@@ -15,13 +15,13 @@
  */
 package rx.util;
 
-public class BufferOpenings {
+public class Openings {
 
-    public static BufferOpening create() {
-        return new BufferOpening() {};
+    public static Opening create() {
+        return new Opening() {};
     }
 
-    private BufferOpenings() {
+    private Openings() {
         // Prevent instantation.
     }
 }
\ No newline at end of file

From 09cac8302d0bb6277e6bcbcb69ea677abe515684 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Wed, 4 Sep 2013 23:19:10 -0700
Subject: [PATCH 2/5] Merge branch 'OperationWindow' of
 https://github.com/RallySoftware/RxJava

- updated to use new OnSubscribeFunc
- updated to use super/extends generics
---
 rxjava-core/src/main/java/rx/Observable.java  | 528 +++++++++++++-----
 .../java/rx/operators/ChunkedOperation.java   | 256 +++++----
 .../java/rx/operators/OperationBuffer.java    | 183 +++---
 .../java/rx/operators/OperationWindow.java    | 190 +++----
 4 files changed, 704 insertions(+), 453 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 17b54c7039..25073ca729 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -73,8 +73,8 @@
 import rx.subjects.Subject;
 import rx.subscriptions.Subscriptions;
 import rx.util.Closing;
-import rx.util.Opening;
 import rx.util.OnErrorNotImplementedException;
+import rx.util.Opening;
 import rx.util.Range;
 import rx.util.Timestamped;
 import rx.util.functions.Action0;
@@ -84,6 +84,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;
 
@@ -98,18 +103,27 @@
  * <p>
  * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/legend.png">
  * <p>
- * For more information see the <a href="https://github.com/Netflix/RxJava/wiki/Observable">RxJava
- * Wiki</a>
+ * For more information see the <a href="https://github.com/Netflix/RxJava/wiki/Observable">RxJava Wiki</a>
  * 
  * @param <T>
  */
 public class Observable<T> {
 
-    //TODO use a consistent parameter naming scheme (for example: for all operators that modify a source Observable, the parameter representing that source Observable should have the same name, e.g. "source" -- currently such parameters are named any of "sequence", "that", "source", "items", or "observable")
+    /**
+     * Executed when 'subscribe' is invoked.
+     */
+    private final OnSubscribeFunc<T> onSubscribe;
 
-    private final static RxJavaObservableExecutionHook hook = RxJavaPlugins.getInstance().getObservableExecutionHook();
+    /**
+     * Function interface for work to be performed when an {@link Observable} is subscribed to via {@link Observable#subscribe(Observer)}
+     * 
+     * @param <T>
+     */
+    public static interface OnSubscribeFunc<T> extends Function {
 
-    private final Func1<Observer<T>, Subscription> onSubscribe;
+        public Subscription onSubscribe(Observer<? super T> t1);
+
+    }
 
     /**
      * Observable with Function to execute when subscribed to.
@@ -118,16 +132,13 @@ public class Observable<T> {
      * specifically have a need for inheritance.
      * 
      * @param onSubscribe
-     *            {@link Func1} to be executed when {@link #subscribe(Observer)} is called.
+     *            {@link OnSubscribeFunc} to be executed when {@link #subscribe(Observer)} is called.
      */
-    protected Observable(Func1<Observer<T>, Subscription> onSubscribe) {
+    protected Observable(OnSubscribeFunc<T> onSubscribe) {
         this.onSubscribe = onSubscribe;
     }
 
-    protected Observable() {
-        this(null);
-        //TODO should this be made private to prevent it? It really serves no good purpose and only confuses things. Unit tests are incorrectly using it today
-    }
+    private final static RxJavaObservableExecutionHook hook = RxJavaPlugins.getInstance().getObservableExecutionHook();
 
     /**
      * An {@link Observer} must call an Observable's {@code subscribe} method in order to
@@ -156,9 +167,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);
+        OnSubscribeFunc<T> onSubscribeFunction = hook.onSubscribeStart(this, onSubscribe);
         // validate and proceed
         if (observer == null) {
             throw new IllegalArgumentException("observer can not be null");
@@ -172,7 +183,7 @@ public Subscription subscribe(Observer<T> observer) {
              * See https://github.com/Netflix/RxJava/issues/216 for discussion on "Guideline 6.4: Protect calls to user code from within an operator"
              */
             if (isInternalImplementation(observer)) {
-                Subscription s = onSubscribeFunction.call(observer);
+                Subscription s = onSubscribeFunction.onSubscribe(observer);
                 if (s == null) {
                     // this generally shouldn't be the case on a 'trusted' onSubscribe but in case it happens
                     // we want to gracefully handle it the same as AtomicObservableSubscription does
@@ -182,7 +193,7 @@ public Subscription subscribe(Observer<T> observer) {
                 }
             } else {
                 SafeObservableSubscription subscription = new SafeObservableSubscription();
-                subscription.wrap(onSubscribeFunction.call(new SafeObserver<T>(subscription, observer)));
+                subscription.wrap(onSubscribeFunction.onSubscribe(new SafeObserver<T>(subscription, observer)));
                 return hook.onSubscribeReturn(this, subscription);
             }
         } catch (OnErrorNotImplementedException e) {
@@ -234,7 +245,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);
     }
 
@@ -243,12 +254,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");
         }
@@ -279,11 +290,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");
         }
@@ -317,11 +328,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");
         }
@@ -358,7 +369,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);
     }
 
@@ -398,10 +409,10 @@ private void handleError(Throwable e) {
      */
     private static class NeverObservable<T> extends Observable<T> {
         public NeverObservable() {
-            super(new Func1<Observer<T>, Subscription>() {
+            super(new OnSubscribeFunc<T>() {
 
                 @Override
-                public Subscription call(Observer<T> t1) {
+                public Subscription onSubscribe(Observer<? super T> t1) {
                     return Subscriptions.empty();
                 }
 
@@ -418,7 +429,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 OnSubscribeFunc<T>() {
 
                 /**
                  * Accepts an {@link Observer} and calls its {@link Observer#onError onError} method.
@@ -428,7 +439,7 @@ public ThrowObservable(final Throwable exception) {
                  * @return a reference to the subscription
                  */
                 @Override
-                public Subscription call(Observer<T> observer) {
+                public Subscription onSubscribe(Observer<? super T> observer) {
                     observer.onError(exception);
                     return Subscriptions.empty();
                 }
@@ -462,7 +473,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(OnSubscribeFunc<T> func) {
         return new Observable<T>(func);
     }
 
@@ -511,7 +522,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));
     }
 
@@ -575,7 +586,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));
     }
 
@@ -618,7 +629,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));
     }
 
@@ -637,7 +648,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));
     }
 
@@ -655,7 +666,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));
     }
 
@@ -671,7 +682,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));
     }
 
@@ -695,7 +706,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));
     }
 
@@ -719,7 +730,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));
     }
 
@@ -743,7 +754,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));
     }
 
@@ -773,7 +784,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));
     }
@@ -793,7 +804,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));
     }
 
     /**
@@ -813,7 +824,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));
     }
 
@@ -846,7 +857,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));
     }
 
@@ -869,7 +880,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);
     }
 
@@ -895,7 +906,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));
     }
 
@@ -909,18 +920,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));
     }
 
     /**
@@ -938,7 +948,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) {
@@ -965,7 +975,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);
     }
 
@@ -982,19 +992,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));
     }
 
     /**
@@ -1011,21 +1021,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 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 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, 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 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 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 <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));
     }
 
     /**
@@ -1034,30 +1233,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 <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, 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 <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, 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 <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 <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));
     }
 
     /**
@@ -1075,7 +1315,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 rx.util.Closing} object.
      */
-    public Observable<List<T>> buffer(Func0<Observable<Closing>> bufferClosingSelector) {
+    public Observable<List<T>> buffer(Func0<? extends Observable<? extends Closing>> bufferClosingSelector) {
         return create(OperationBuffer.buffer(this, bufferClosingSelector));
     }
 
@@ -1097,7 +1337,7 @@ public Observable<List<T>> buffer(Func0<Observable<Closing>> bufferClosingSelect
      * @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<Opening> bufferOpenings, Func1<Opening, Observable<Closing>> bufferClosingSelector) {
+    public Observable<List<T>> buffer(Observable<? extends Opening> bufferOpenings, Func1<? super Opening, ? extends Observable<? extends Closing>> bufferClosingSelector) {
         return create(OperationBuffer.buffer(this, bufferOpenings, bufferClosingSelector));
     }
 
@@ -1263,13 +1503,13 @@ public Observable<List<T>> buffer(long timespan, long timeshift, TimeUnit unit)
     public Observable<List<T>> buffer(long timespan, long timeshift, TimeUnit unit, Scheduler scheduler) {
         return create(OperationBuffer.buffer(this, timespan, timeshift, unit, scheduler));
     }
-    
+
     /**
      * Creates an Observable which produces windows of collected values. This Observable produces connected
      * non-overlapping windows. The current window is emitted and replaced with a new window when the
-     * Observable produced by the specified {@link Func0} produces a {@link rx.util.Closing} object. The
-     * {@link Func0} will then be used to create a new Observable to listen for the end of the next window.
-     *
+     * Observable produced by the specified {@link Func0} produces a {@link rx.util.Closing} object. The {@link Func0} will then be used to create a new Observable to listen for the end of the next
+     * window.
+     * 
      * @param source
      *            The source {@link Observable} which produces values.
      * @param closingSelector
@@ -1277,9 +1517,8 @@ public Observable<List<T>> buffer(long timespan, long timeshift, TimeUnit unit,
      *            When this {@link Observable} produces a {@link rx.util.Closing} object, the associated window
      *            is emitted and replaced with a new one.
      * @return
-     *            An {@link Observable} which produces connected non-overlapping windows, which are emitted
-     *            when the current {@link Observable} created with the {@link Func0} argument produces a
-     *            {@link rx.util.Closing} object.
+     *         An {@link Observable} which produces connected non-overlapping windows, which are emitted
+     *         when the current {@link Observable} created with the {@link Func0} argument produces a {@link rx.util.Closing} object.
      */
     public Observable<Observable<T>> window(Observable<T> source, Func0<Observable<Closing>> closingSelector) {
         return create(OperationWindow.window(source, closingSelector));
@@ -1288,9 +1527,9 @@ public Observable<Observable<T>> window(Observable<T> source, Func0<Observable<C
     /**
      * Creates an Observable which produces windows of collected values. This Observable produces windows.
      * Chunks are created when the specified "windowOpenings" Observable produces a {@link rx.util.Opening} object.
-     * Additionally the {@link Func0} argument is used to create an Observable which produces {@link rx.util.Closing}
-     * objects. When this Observable produces such an object, the associated window is emitted.
-     *
+     * Additionally the {@link Func0} argument is used to create an Observable which produces {@link rx.util.Closing} objects. When this Observable produces such an object, the associated window is
+     * emitted.
+     * 
      * @param source
      *            The source {@link Observable} which produces values.
      * @param windowOpenings
@@ -1301,8 +1540,7 @@ public Observable<Observable<T>> window(Observable<T> source, Func0<Observable<C
      *            When this {@link Observable} produces a {@link rx.util.Closing} object, the associated window
      *            is emitted.
      * @return
-     *            An {@link Observable} which produces windows which are created and emitted when the specified
-     *            {@link Observable}s publish certain objects.
+     *         An {@link Observable} which produces windows which are created and emitted when the specified {@link Observable}s publish certain objects.
      */
     public Observable<Observable<T>> window(Observable<T> source, Observable<Opening> windowOpenings, Func1<Opening, Observable<Closing>> closingSelector) {
         return create(OperationWindow.window(source, windowOpenings, closingSelector));
@@ -1312,14 +1550,14 @@ public Observable<Observable<T>> window(Observable<T> source, Observable<Opening
      * Creates an Observable which produces windows of collected values. This Observable produces connected
      * non-overlapping windows, each containing "count" elements. When the source Observable completes or
      * encounters an error, the current window is emitted, and the event is propagated.
-     *
+     * 
      * @param source
      *            The source {@link Observable} which produces values.
      * @param count
      *            The maximum size of each window before it should be emitted.
      * @return
-     *            An {@link Observable} which produces connected non-overlapping windows containing at most
-     *            "count" produced values.
+     *         An {@link Observable} which produces connected non-overlapping windows containing at most
+     *         "count" produced values.
      */
     public Observable<Observable<T>> window(Observable<T> source, int count) {
         return create(OperationWindow.window(source, count));
@@ -1329,7 +1567,7 @@ public Observable<Observable<T>> window(Observable<T> source, int count) {
      * Creates an Observable which produces windows of collected values. This Observable produces windows every
      * "skip" values, each containing "count" elements. When the source Observable completes or encounters an error,
      * the current window is emitted and the event is propagated.
-     *
+     * 
      * @param source
      *            The source {@link Observable} which produces values.
      * @param count
@@ -1338,8 +1576,8 @@ public Observable<Observable<T>> window(Observable<T> source, int count) {
      *            How many produced values need to be skipped before starting a new window. Note that when "skip" and
      *            "count" are equals that this is the same operation as {@link Observable#window(Observable, int)}.
      * @return
-     *            An {@link Observable} which produces windows every "skipped" values containing at most
-     *            "count" produced values.
+     *         An {@link Observable} which produces windows every "skipped" values containing at most
+     *         "count" produced values.
      */
     public Observable<Observable<T>> window(Observable<T> source, int count, int skip) {
         return create(OperationWindow.window(source, count, skip));
@@ -1349,7 +1587,7 @@ public Observable<Observable<T>> window(Observable<T> source, int count, int ski
      * Creates an Observable which produces windows of collected values. This Observable produces connected
      * non-overlapping windows, each of a fixed duration specified by the "timespan" argument. When the source
      * Observable completes or encounters an error, the current window is emitted and the event is propagated.
-     *
+     * 
      * @param source
      *            The source {@link Observable} which produces values.
      * @param timespan
@@ -1358,7 +1596,7 @@ public Observable<Observable<T>> window(Observable<T> source, int count, int ski
      * @param unit
      *            The unit of time which applies to the "timespan" argument.
      * @return
-     *            An {@link Observable} which produces connected non-overlapping windows with a fixed duration.
+     *         An {@link Observable} which produces connected non-overlapping windows with a fixed duration.
      */
     public Observable<Observable<T>> window(Observable<T> source, long timespan, TimeUnit unit) {
         return create(OperationWindow.window(source, timespan, unit));
@@ -1368,7 +1606,7 @@ public Observable<Observable<T>> window(Observable<T> source, long timespan, Tim
      * Creates an Observable which produces windows of collected values. This Observable produces connected
      * non-overlapping windows, each of a fixed duration specified by the "timespan" argument. When the source
      * Observable completes or encounters an error, the current window is emitted and the event is propagated.
-     *
+     * 
      * @param source
      *            The source {@link Observable} which produces values.
      * @param timespan
@@ -1379,7 +1617,7 @@ public Observable<Observable<T>> window(Observable<T> source, long timespan, Tim
      * @param scheduler
      *            The {@link Scheduler} to use when determining the end and start of a window.
      * @return
-     *            An {@link Observable} which produces connected non-overlapping windows with a fixed duration.
+     *         An {@link Observable} which produces connected non-overlapping windows with a fixed duration.
      */
     public Observable<Observable<T>> window(Observable<T> source, long timespan, TimeUnit unit, Scheduler scheduler) {
         return create(OperationWindow.window(source, timespan, unit, scheduler));
@@ -1390,7 +1628,7 @@ public Observable<Observable<T>> window(Observable<T> source, long timespan, Tim
      * non-overlapping windows, each of a fixed duration specified by the "timespan" argument or a maximum size
      * specified by the "count" argument (which ever is reached first). When the source Observable completes
      * or encounters an error, the current window is emitted and the event is propagated.
-     *
+     * 
      * @param source
      *            The source {@link Observable} which produces values.
      * @param timespan
@@ -1401,8 +1639,8 @@ public Observable<Observable<T>> window(Observable<T> source, long timespan, Tim
      * @param count
      *            The maximum size of each window before it should be emitted.
      * @return
-     *            An {@link Observable} which produces connected non-overlapping windows which are emitted after
-     *            a fixed duration or when the window has reached maximum capacity (which ever occurs first).
+     *         An {@link Observable} which produces connected non-overlapping windows which are emitted after
+     *         a fixed duration or when the window has reached maximum capacity (which ever occurs first).
      */
     public Observable<Observable<T>> window(Observable<T> source, long timespan, TimeUnit unit, int count) {
         return create(OperationWindow.window(source, timespan, unit, count));
@@ -1413,7 +1651,7 @@ public Observable<Observable<T>> window(Observable<T> source, long timespan, Tim
      * non-overlapping windows, each of a fixed duration specified by the "timespan" argument or a maximum size
      * specified by the "count" argument (which ever is reached first). When the source Observable completes
      * or encounters an error, the current window is emitted and the event is propagated.
-     *
+     * 
      * @param source
      *            The source {@link Observable} which produces values.
      * @param timespan
@@ -1426,8 +1664,8 @@ public Observable<Observable<T>> window(Observable<T> source, long timespan, Tim
      * @param scheduler
      *            The {@link Scheduler} to use when determining the end and start of a window.
      * @return
-     *            An {@link Observable} which produces connected non-overlapping windows which are emitted after
-     *            a fixed duration or when the window has reached maximum capacity (which ever occurs first).
+     *         An {@link Observable} which produces connected non-overlapping windows which are emitted after
+     *         a fixed duration or when the window has reached maximum capacity (which ever occurs first).
      */
     public Observable<Observable<T>> window(Observable<T> source, long timespan, TimeUnit unit, int count, Scheduler scheduler) {
         return create(OperationWindow.window(source, timespan, unit, count, scheduler));
@@ -1438,7 +1676,7 @@ public Observable<Observable<T>> window(Observable<T> source, long timespan, Tim
      * periodically, which is determined by the "timeshift" argument. Each window is emitted after a fixed timespan
      * specified by the "timespan" argument. When the source Observable completes or encounters an error, the
      * current window is emitted and the event is propagated.
-     *
+     * 
      * @param source
      *            The source {@link Observable} which produces values.
      * @param timespan
@@ -1448,8 +1686,8 @@ public Observable<Observable<T>> window(Observable<T> source, long timespan, Tim
      * @param unit
      *            The unit of time which applies to the "timespan" and "timeshift" argument.
      * @return
-     *            An {@link Observable} which produces new windows periodically, and these are emitted after
-     *            a fixed timespan has elapsed.
+     *         An {@link Observable} which produces new windows periodically, and these are emitted after
+     *         a fixed timespan has elapsed.
      */
     public Observable<Observable<T>> window(Observable<T> source, long timespan, long timeshift, TimeUnit unit) {
         return create(OperationWindow.window(source, timespan, timeshift, unit));
@@ -1460,7 +1698,7 @@ public Observable<Observable<T>> window(Observable<T> source, long timespan, lon
      * periodically, which is determined by the "timeshift" argument. Each window is emitted after a fixed timespan
      * specified by the "timespan" argument. When the source Observable completes or encounters an error, the
      * current window is emitted and the event is propagated.
-     *
+     * 
      * @param source
      *            The source {@link Observable} which produces values.
      * @param timespan
@@ -1472,13 +1710,13 @@ public Observable<Observable<T>> window(Observable<T> source, long timespan, lon
      * @param scheduler
      *            The {@link Scheduler} to use when determining the end and start of a window.
      * @return
-     *            An {@link Observable} which produces new windows periodically, and these are emitted after
-     *            a fixed timespan has elapsed.
+     *         An {@link Observable} which produces new windows periodically, and these are emitted after
+     *         a fixed timespan has elapsed.
      */
     public Observable<Observable<T>> window(Observable<T> source, long timespan, long timeshift, TimeUnit unit, Scheduler scheduler) {
         return create(OperationWindow.window(source, timespan, timeshift, unit, scheduler));
     }
-    
+
     /**
      * 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.
@@ -1494,16 +1732,16 @@ public Observable<Observable<T>> window(Observable<T> source, long timespan, lon
      * 
      * @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));
             }
         });
     }
@@ -1523,13 +1761,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));
     }
 
     /**
@@ -1541,7 +1779,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));
     }
 
@@ -1576,7 +1814,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);
     }
 
@@ -1590,7 +1828,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);
     }
 
@@ -1605,7 +1843,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));
     }
 
@@ -1626,7 +1864,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));
     }
 
@@ -1685,7 +1923,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));
     }
 
     /**
@@ -1712,7 +1950,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));
     }
 
@@ -1740,7 +1978,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));
     }
 
@@ -1770,7 +2008,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));
     }
 
@@ -1797,7 +2035,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));
     }
 
@@ -1822,7 +2060,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);
     }
 
@@ -1879,7 +2117,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);
     }
 
@@ -1906,7 +2144,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);
     }
 
@@ -1917,7 +2155,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);
     }
 
@@ -1940,7 +2178,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));
     }
 
@@ -2001,7 +2239,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));
     }
 
@@ -2016,7 +2254,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));
     }
 
@@ -2069,7 +2307,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));
     }
 
@@ -2086,7 +2324,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));
     }
 
@@ -2120,7 +2358,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);
     }
 
@@ -2172,7 +2410,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));
     }
 
@@ -2208,7 +2446,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));
     }
 
@@ -2226,7 +2464,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/operators/ChunkedOperation.java b/rxjava-core/src/main/java/rx/operators/ChunkedOperation.java
index c7bb5cddbb..5b5eb3344c 100644
--- a/rxjava-core/src/main/java/rx/operators/ChunkedOperation.java
+++ b/rxjava-core/src/main/java/rx/operators/ChunkedOperation.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2013 Netflix, Inc.
- *
+ * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- *
+ * 
  * http://www.apache.org/licenses/LICENSE-2.0
- *
+ * 
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -15,6 +15,15 @@
  */
 package rx.operators;
 
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Queue;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+
 import rx.Observable;
 import rx.Observer;
 import rx.Scheduler;
@@ -26,22 +35,13 @@
 import rx.util.functions.Func0;
 import rx.util.functions.Func1;
 
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Queue;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentLinkedQueue;
-import java.util.concurrent.ConcurrentMap;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicInteger;
-
 /**
  * The base class for operations that break observables into "chunks". Currently buffers and windows.
  */
 public class ChunkedOperation {
     /**
      * This interface defines a way which specifies when to create a new internal {@link rx.operators.ChunkedOperation.Chunk} object.
-     *
+     * 
      */
     protected interface ChunkCreator {
         /**
@@ -58,16 +58,17 @@ protected interface ChunkCreator {
 
     /**
      * This class represents a single chunk: A sequence of recorded values.
-     *
-     * @param <T> The type of objects which this {@link Chunk} can hold.
-     *        <C> The type of object being tracked by the {@link Chunk}
+     * 
+     * @param <T>
+     *            The type of objects which this {@link Chunk} can hold.
+     *            <C> The type of object being tracked by the {@link Chunk}
      */
-    protected abstract static class Chunk<T,C>  {
+    protected abstract static class Chunk<T, C> {
         protected final List<T> contents = new ArrayList<T>();
 
         /**
          * Appends a specified value to the {@link Chunk}.
-         *
+         * 
          * @param value
          *            The value to append to the {@link Chunk}.
          */
@@ -77,15 +78,15 @@ public void pushValue(T value) {
 
         /**
          * @return
-         *            The mutable underlying {@link C} which contains all the
-         *            recorded values in this {@link Chunk} object.
+         *         The mutable underlying {@link C} which contains all the
+         *         recorded values in this {@link Chunk} object.
          */
         abstract public C getContents();
 
         /**
          * @return
-         *            The size of the underlying {@link List} which contains all the
-         *            recorded values in this {@link Chunk} object.
+         *         The size of the underlying {@link List} which contains all the
+         *         recorded values in this {@link Chunk} object.
          */
         public int size() {
             return contents.size();
@@ -95,19 +96,20 @@ public int size() {
     /**
      * This class is an extension on the {@link rx.operators.ChunkedOperation.Chunks} class which only supports one
      * active (not yet emitted) internal {@link rx.operators.ChunkedOperation.Chunks} object.
-     *
-     * @param <T> The type of object all internal {@link rx.operators.ChunkedOperation.Chunks} objects record.
-     *        <C> The type of object being tracked by the {@link Chunk}
+     * 
+     * @param <T>
+     *            The type of object all internal {@link rx.operators.ChunkedOperation.Chunks} objects record.
+     *            <C> The type of object being tracked by the {@link Chunk}
      */
-    protected static class NonOverlappingChunks<T,C> extends Chunks<T,C> {
+    protected static class NonOverlappingChunks<T, C> extends Chunks<T, C> {
 
         private final Object lock = new Object();
 
-        public NonOverlappingChunks(Observer<C> observer, Func0 chunkMaker) {
+        public NonOverlappingChunks(Observer<? super C> observer, Func0 chunkMaker) {
             super(observer, chunkMaker);
         }
 
-        public Chunk<T,C> emitAndReplaceChunk() {
+        public Chunk<T, C> emitAndReplaceChunk() {
             synchronized (lock) {
                 emitChunk(getChunk());
                 return createChunk();
@@ -126,12 +128,13 @@ public void pushValue(T value) {
      * This class is an extension on the {@link rx.operators.ChunkedOperation.Chunks} class which actually has no additional
      * behavior than its super class. Classes extending this class, are expected to support
      * two or more active (not yet emitted) internal {@link rx.operators.ChunkedOperation.Chunks} objects.
-     *
-     * @param <T> The type of object all internal {@link rx.operators.ChunkedOperation.Chunks} objects record.
-     *        <C> The type of object being tracked by the {@link rx.operators.ChunkedOperation.Chunk}
+     * 
+     * @param <T>
+     *            The type of object all internal {@link rx.operators.ChunkedOperation.Chunks} objects record.
+     *            <C> The type of object being tracked by the {@link rx.operators.ChunkedOperation.Chunk}
      */
-    protected static class OverlappingChunks<T, C> extends Chunks<T,C> {
-        public OverlappingChunks(Observer<C> observer, Func0 chunkMaker) {
+    protected static class OverlappingChunks<T, C> extends Chunks<T, C> {
+        public OverlappingChunks(Observer<? super C> observer, Func0 chunkMaker) {
             super(observer, chunkMaker);
         }
     }
@@ -141,20 +144,21 @@ public OverlappingChunks(Observer<C> observer, Func0 chunkMaker) {
      * a has a maximum time to live and a maximum internal capacity. When the chunk has
      * reached the end of its life, or reached its maximum internal capacity it is
      * automatically emitted.
-     *
-     * @param <T> The type of object all internal {@link rx.operators.ChunkedOperation.Chunk} objects record.
-     *        <C> The type of object being tracked by the {@link Chunk}
+     * 
+     * @param <T>
+     *            The type of object all internal {@link rx.operators.ChunkedOperation.Chunk} objects record.
+     *            <C> The type of object being tracked by the {@link Chunk}
      */
-    protected static class TimeAndSizeBasedChunks<T,C> extends Chunks<T,C> {
+    protected static class TimeAndSizeBasedChunks<T, C> extends Chunks<T, C> {
 
-        private final ConcurrentMap<Chunk<T,C>, Subscription> subscriptions = new ConcurrentHashMap<Chunk<T,C>, Subscription>();
+        private final ConcurrentMap<Chunk<T, C>, Subscription> subscriptions = new ConcurrentHashMap<Chunk<T, C>, Subscription>();
 
         private final Scheduler scheduler;
         private final long maxTime;
         private final TimeUnit unit;
         private final int maxSize;
 
-        public TimeAndSizeBasedChunks(Observer<C> observer, Func0 chunkMaker, int maxSize, long maxTime, TimeUnit unit, Scheduler scheduler) {
+        public TimeAndSizeBasedChunks(Observer<? super C> observer, Func0 chunkMaker, int maxSize, long maxTime, TimeUnit unit, Scheduler scheduler) {
             super(observer, chunkMaker);
             this.maxSize = maxSize;
             this.maxTime = maxTime;
@@ -163,8 +167,8 @@ public TimeAndSizeBasedChunks(Observer<C> observer, Func0 chunkMaker, int maxSiz
         }
 
         @Override
-        public Chunk<T,C> createChunk() {
-            final Chunk<T,C> chunk = super.createChunk();
+        public Chunk<T, C> createChunk() {
+            final Chunk<T, C> chunk = super.createChunk();
             subscriptions.put(chunk, scheduler.schedule(new Action0() {
                 @Override
                 public void call() {
@@ -175,7 +179,7 @@ public void call() {
         }
 
         @Override
-        public void emitChunk(Chunk<T,C> chunk) {
+        public void emitChunk(Chunk<T, C> chunk) {
             Subscription subscription = subscriptions.remove(chunk);
             if (subscription == null) {
                 // Chunk was already emitted.
@@ -191,7 +195,7 @@ public void emitChunk(Chunk<T,C> chunk) {
         public void pushValue(T value) {
             super.pushValue(value);
 
-            Chunk<T,C> chunk;
+            Chunk<T, C> chunk;
             while ((chunk = getChunk()) != null) {
                 if (chunk.size() >= maxSize) {
                     emitChunk(chunk);
@@ -207,19 +211,20 @@ public void pushValue(T value) {
      * This class is an extension on the {@link rx.operators.ChunkedOperation.Chunks} class. Every internal chunk has
      * a has a maximum time to live. When the chunk has reached the end of its life it is
      * automatically emitted.
-     *
-     * @param <T> The type of object all internal {@link rx.operators.ChunkedOperation.Chunk} objects record.
-     *        <C> The type of object being tracked by the {@link Chunk}
+     * 
+     * @param <T>
+     *            The type of object all internal {@link rx.operators.ChunkedOperation.Chunk} objects record.
+     *            <C> The type of object being tracked by the {@link Chunk}
      */
-    protected static class TimeBasedChunks<T,C> extends OverlappingChunks<T,C> {
+    protected static class TimeBasedChunks<T, C> extends OverlappingChunks<T, C> {
 
-        private final ConcurrentMap<Chunk<T,C>, Subscription> subscriptions = new ConcurrentHashMap<Chunk<T,C>, Subscription>();
+        private final ConcurrentMap<Chunk<T, C>, Subscription> subscriptions = new ConcurrentHashMap<Chunk<T, C>, Subscription>();
 
         private final Scheduler scheduler;
         private final long time;
         private final TimeUnit unit;
 
-        public TimeBasedChunks(Observer<C> observer, Func0 chunkMaker, long time, TimeUnit unit, Scheduler scheduler) {
+        public TimeBasedChunks(Observer<? super C> observer, Func0 chunkMaker, long time, TimeUnit unit, Scheduler scheduler) {
             super(observer, chunkMaker);
             this.time = time;
             this.unit = unit;
@@ -227,8 +232,8 @@ public TimeBasedChunks(Observer<C> observer, Func0 chunkMaker, long time, TimeUn
         }
 
         @Override
-        public Chunk<T,C> createChunk() {
-            final Chunk<T,C> chunk = super.createChunk();
+        public Chunk<T, C> createChunk() {
+            final Chunk<T, C> chunk = super.createChunk();
             subscriptions.put(chunk, scheduler.schedule(new Action0() {
                 @Override
                 public void call() {
@@ -239,7 +244,7 @@ public void call() {
         }
 
         @Override
-        public void emitChunk(Chunk<T,C> chunk) {
+        public void emitChunk(Chunk<T, C> chunk) {
             subscriptions.remove(chunk);
             super.emitChunk(chunk);
         }
@@ -249,15 +254,16 @@ public void emitChunk(Chunk<T,C> chunk) {
      * This class is an extension on the {@link rx.operators.ChunkedOperation.Chunks} class. Every internal chunk has
      * a fixed maximum capacity. When the chunk has reached its maximum capacity it is
      * automatically emitted.
-     *
-     * @param <T> The type of object all internal {@link rx.operators.ChunkedOperation.Chunk} objects record.
-     *        <C> The type of object being tracked by the {@link Chunk}
+     * 
+     * @param <T>
+     *            The type of object all internal {@link rx.operators.ChunkedOperation.Chunk} objects record.
+     *            <C> The type of object being tracked by the {@link Chunk}
      */
-    protected static class SizeBasedChunks<T,C> extends Chunks<T,C> {
+    protected static class SizeBasedChunks<T, C> extends Chunks<T, C> {
 
         private final int size;
 
-        public SizeBasedChunks(Observer<C> observer, Func0 chunkMaker, int size) {
+        public SizeBasedChunks(Observer<? super C> observer, Func0 chunkMaker, int size) {
             super(observer, chunkMaker);
             this.size = size;
         }
@@ -266,7 +272,7 @@ public SizeBasedChunks(Observer<C> observer, Func0 chunkMaker, int size) {
         public void pushValue(T value) {
             super.pushValue(value);
 
-            Chunk<T,C> chunk;
+            Chunk<T, C> chunk;
             while ((chunk = getChunk()) != null) {
                 if (chunk.size() >= size) {
                     emitChunk(chunk);
@@ -280,36 +286,36 @@ public void pushValue(T value) {
 
     /**
      * This class represents an object which contains and manages multiple {@link rx.operators.ChunkedOperation.Chunk} objects.
-     *
-     * @param <T> The type of objects which the internal {@link rx.operators.ChunkedOperation.Chunk} objects record.
-     *        <C> The type of object being tracked by the {@link Chunk}
+     * 
+     * @param <T>
+     *            The type of objects which the internal {@link rx.operators.ChunkedOperation.Chunk} objects record.
+     *            <C> The type of object being tracked by the {@link Chunk}
      */
-    protected static class Chunks<T,C> {
+    protected static class Chunks<T, C> {
 
-        private final Queue<Chunk<T,C>> chunks = new ConcurrentLinkedQueue<Chunk<T,C>>();
-        private final Observer<C> observer;
+        private final Queue<Chunk<T, C>> chunks = new ConcurrentLinkedQueue<Chunk<T, C>>();
+        private final Observer<? super C> observer;
         private final Func0<Chunk<T, C>> chunkMaker;
 
         /**
          * Constructs a new {@link ChunkedOperation.Chunks} object for the specified {@link rx.Observer}.
-         *
+         * 
          * @param observer
-         *            The {@link rx.Observer} to which this object will emit its internal
-         *            {@link rx.operators.ChunkedOperation.Chunk} objects to when requested.
+         *            The {@link rx.Observer} to which this object will emit its internal {@link rx.operators.ChunkedOperation.Chunk} objects to when requested.
          */
-        public Chunks(Observer<C> observer, Func0 chunkMaker) {
+        public Chunks(Observer<? super C> observer, Func0 chunkMaker) {
             this.observer = observer;
             this.chunkMaker = chunkMaker;
         }
 
         /**
          * This method will instantiate a new {@link rx.operators.ChunkedOperation.Chunk} object and register it internally.
-         *
+         * 
          * @return
-         *            The constructed empty {@link rx.operators.ChunkedOperation.Chunk} object.
+         *         The constructed empty {@link rx.operators.ChunkedOperation.Chunk} object.
          */
-        public Chunk<T,C> createChunk() {
-            Chunk<T,C> chunk = chunkMaker.call();
+        public Chunk<T, C> createChunk() {
+            Chunk<T, C> chunk = chunkMaker.call();
             chunks.add(chunk);
             return chunk;
         }
@@ -318,7 +324,7 @@ public Chunk<T,C> createChunk() {
          * This method emits all not yet emitted {@link rx.operators.ChunkedOperation.Chunk} objects.
          */
         public void emitAllChunks() {
-            Chunk<T,C> chunk;
+            Chunk<T, C> chunk;
             while ((chunk = chunks.poll()) != null) {
                 observer.onNext(chunk.getContents());
             }
@@ -326,11 +332,11 @@ public void emitAllChunks() {
 
         /**
          * This method emits the specified {@link rx.operators.ChunkedOperation.Chunk} object.
-         *
+         * 
          * @param chunk
          *            The {@link rx.operators.ChunkedOperation.Chunk} to emit.
          */
-        public void emitChunk(Chunk<T,C> chunk) {
+        public void emitChunk(Chunk<T, C> chunk) {
             if (!chunks.remove(chunk)) {
                 // Concurrency issue: Chunk is already emitted!
                 return;
@@ -340,21 +346,21 @@ public void emitChunk(Chunk<T,C> chunk) {
 
         /**
          * @return
-         *            The oldest (in case there are multiple) {@link rx.operators.ChunkedOperation.Chunk} object.
+         *         The oldest (in case there are multiple) {@link rx.operators.ChunkedOperation.Chunk} object.
          */
-        public Chunk<T,C> getChunk() {
+        public Chunk<T, C> getChunk() {
             return chunks.peek();
         }
 
         /**
          * This method pushes a value to all not yet emitted {@link rx.operators.ChunkedOperation.Chunk} objects.
-         *
+         * 
          * @param value
          *            The value to push to all not yet emitted {@link rx.operators.ChunkedOperation.Chunk} objects.
          */
         public void pushValue(T value) {
-            List<Chunk<T,C>> copy = new ArrayList<Chunk<T,C>>(chunks);
-            for (Chunk<T,C> chunk : copy) {
+            List<Chunk<T, C>> copy = new ArrayList<Chunk<T, C>>(chunks);
+            for (Chunk<T, C> chunk : copy) {
                 chunk.pushValue(value);
             }
         }
@@ -362,21 +368,22 @@ public void pushValue(T value) {
 
     /**
      * This {@link rx.operators.ChunkedOperation.ChunkObserver} object can be constructed using a {@link rx.operators.ChunkedOperation.Chunks} object,
-     * a {@link rx.Observer} object, and a {@link rx.operators.ChunkedOperation.ChunkCreator} object. The {@link rx.operators.ChunkedOperation.ChunkCreator}
-     * will manage the creation, and in some rare cases emission of internal {@link rx.operators.ChunkedOperation.Chunk} objects
-     * in the specified {@link rx.operators.ChunkedOperation.Chunks} object. Under normal circumstances the {@link rx.operators.ChunkedOperation.Chunks}
-     * object specifies when a created {@link rx.operators.ChunkedOperation.Chunk} is emitted.
-     *
-     * @param <T> The type of object all internal {@link rx.operators.ChunkedOperation.Chunk} objects record.
-     *        <C> The type of object being tracked by the {@link Chunk}
+     * a {@link rx.Observer} object, and a {@link rx.operators.ChunkedOperation.ChunkCreator} object. The {@link rx.operators.ChunkedOperation.ChunkCreator} will manage the creation, and in some rare
+     * cases emission of internal {@link rx.operators.ChunkedOperation.Chunk} objects
+     * in the specified {@link rx.operators.ChunkedOperation.Chunks} object. Under normal circumstances the {@link rx.operators.ChunkedOperation.Chunks} object specifies when a created
+     * {@link rx.operators.ChunkedOperation.Chunk} is emitted.
+     * 
+     * @param <T>
+     *            The type of object all internal {@link rx.operators.ChunkedOperation.Chunk} objects record.
+     *            <C> The type of object being tracked by the {@link Chunk}
      */
-    protected static class ChunkObserver<T,C> implements Observer<T> {
+    protected static class ChunkObserver<T, C> implements Observer<T> {
 
-        private final Chunks<T,C> chunks;
-        private final Observer<C> observer;
+        private final Chunks<T, C> chunks;
+        private final Observer<? super C> observer;
         private final ChunkCreator creator;
 
-        public ChunkObserver(Chunks<T,C> chunks, Observer<C> observer, ChunkCreator creator) {
+        public ChunkObserver(Chunks<T, C> chunks, Observer<? super C> observer, ChunkCreator creator) {
             this.observer = observer;
             this.creator = creator;
             this.chunks = chunks;
@@ -407,11 +414,12 @@ public void onNext(T args) {
      * This {@link rx.operators.ChunkedOperation.ChunkCreator} creates a new {@link rx.operators.ChunkedOperation.Chunk} when it is initialized, but
      * provides no additional functionality. This class should primarily be used when the
      * internal {@link rx.operators.ChunkedOperation.Chunk} is closed externally.
-     *
-     * @param <T> The type of object all internal {@link rx.operators.ChunkedOperation.Chunk} objects record.
-     *        <C> The type of object being tracked by the {@link Chunk}
+     * 
+     * @param <T>
+     *            The type of object all internal {@link rx.operators.ChunkedOperation.Chunk} objects record.
+     *            <C> The type of object being tracked by the {@link Chunk}
      */
-    protected static class SingleChunkCreator<T,C> implements ChunkCreator {
+    protected static class SingleChunkCreator<T, C> implements ChunkCreator {
 
         public SingleChunkCreator(Chunks<T, C> chunks) {
             chunks.createChunk();
@@ -432,17 +440,18 @@ public void stop() {
      * This {@link rx.operators.ChunkedOperation.ChunkCreator} creates a new {@link rx.operators.ChunkedOperation.Chunk} whenever it receives an
      * object from the provided {@link rx.Observable} created with the
      * chunkClosingSelector {@link rx.util.functions.Func0}.
-     *
-     * @param <T> The type of object all internal {@link rx.operators.ChunkedOperation.Chunk} objects record.
-     *        <C> The type of object being tracked by the {@link Chunk}
+     * 
+     * @param <T>
+     *            The type of object all internal {@link rx.operators.ChunkedOperation.Chunk} objects record.
+     *            <C> The type of object being tracked by the {@link Chunk}
      */
-    protected static class ObservableBasedSingleChunkCreator<T,C> implements ChunkCreator {
+    protected static class ObservableBasedSingleChunkCreator<T, C> implements ChunkCreator {
 
         private final SafeObservableSubscription subscription = new SafeObservableSubscription();
-        private final Func0<Observable<Closing>> chunkClosingSelector;
+        private final Func0<? extends Observable<? extends Closing>> chunkClosingSelector;
         private final NonOverlappingChunks<T, C> chunks;
 
-        public ObservableBasedSingleChunkCreator(NonOverlappingChunks<T,C> chunks, Func0<Observable<Closing>> chunkClosingSelector) {
+        public ObservableBasedSingleChunkCreator(NonOverlappingChunks<T, C> chunks, Func0<? extends Observable<? extends Closing>> chunkClosingSelector) {
             this.chunks = chunks;
             this.chunkClosingSelector = chunkClosingSelector;
 
@@ -451,7 +460,7 @@ public ObservableBasedSingleChunkCreator(NonOverlappingChunks<T,C> chunks, Func0
         }
 
         private void listenForChunkEnd() {
-            Observable<Closing> closingObservable = chunkClosingSelector.call();
+            Observable<? extends Closing> closingObservable = chunkClosingSelector.call();
             closingObservable.subscribe(new Action1<Closing>() {
                 @Override
                 public void call(Closing closing) {
@@ -474,23 +483,24 @@ public void stop() {
 
     /**
      * This {@link rx.operators.ChunkedOperation.ChunkCreator} creates a new {@link rx.operators.ChunkedOperation.Chunk} whenever it receives
-     * an object from the provided chunkOpenings {@link rx.Observable}, and closes the corresponding
-     * {@link rx.operators.ChunkedOperation.Chunk} object when it receives an object from the provided {@link rx.Observable} created
+     * an object from the provided chunkOpenings {@link rx.Observable}, and closes the corresponding {@link rx.operators.ChunkedOperation.Chunk} object when it receives an object from the provided
+     * {@link rx.Observable} created
      * with the chunkClosingSelector {@link rx.util.functions.Func1}.
-     *
-     * @param <T> The type of object all internal {@link rx.operators.ChunkedOperation.Chunk} objects record.
-     *        <C> The type of object being tracked by the {@link Chunk}
+     * 
+     * @param <T>
+     *            The type of object all internal {@link rx.operators.ChunkedOperation.Chunk} objects record.
+     *            <C> The type of object being tracked by the {@link Chunk}
      */
-    protected static class ObservableBasedMultiChunkCreator<T,C> implements ChunkCreator {
+    protected static class ObservableBasedMultiChunkCreator<T, C> implements ChunkCreator {
 
         private final SafeObservableSubscription subscription = new SafeObservableSubscription();
 
-        public ObservableBasedMultiChunkCreator(final OverlappingChunks<T,C> chunks, Observable<Opening> openings, final Func1<Opening, Observable<Closing>> chunkClosingSelector) {
+        public ObservableBasedMultiChunkCreator(final OverlappingChunks<T, C> chunks, Observable<? extends Opening> openings, final Func1<? super Opening, ? extends Observable<? extends Closing>> chunkClosingSelector) {
             subscription.wrap(openings.subscribe(new Action1<Opening>() {
                 @Override
                 public void call(Opening opening) {
                     final Chunk<T, C> chunk = chunks.createChunk();
-                    Observable<Closing> closingObservable = chunkClosingSelector.call(opening);
+                    Observable<? extends Closing> closingObservable = chunkClosingSelector.call(opening);
 
                     closingObservable.subscribe(new Action1<Closing>() {
                         @Override
@@ -516,15 +526,16 @@ public void stop() {
     /**
      * This {@link rx.operators.ChunkedOperation.ChunkCreator} creates a new {@link rx.operators.ChunkedOperation.Chunk} every time after a fixed
      * period of time has elapsed.
-     *
-     * @param <T> The type of object all internal {@link rx.operators.ChunkedOperation.Chunk} objects record.
-     *        <C> The type of object being tracked by the {@link Chunk}
+     * 
+     * @param <T>
+     *            The type of object all internal {@link rx.operators.ChunkedOperation.Chunk} objects record.
+     *            <C> The type of object being tracked by the {@link Chunk}
      */
-    protected static class TimeBasedChunkCreator<T,C> implements ChunkCreator {
+    protected static class TimeBasedChunkCreator<T, C> implements ChunkCreator {
 
         private final SafeObservableSubscription subscription = new SafeObservableSubscription();
 
-        public TimeBasedChunkCreator(final NonOverlappingChunks<T,C> chunks, long time, TimeUnit unit, Scheduler scheduler) {
+        public TimeBasedChunkCreator(final NonOverlappingChunks<T, C> chunks, long time, TimeUnit unit, Scheduler scheduler) {
             this.subscription.wrap(scheduler.schedulePeriodically(new Action0() {
                 @Override
                 public void call() {
@@ -533,7 +544,7 @@ public void call() {
             }, 0, time, unit));
         }
 
-        public TimeBasedChunkCreator(final OverlappingChunks<T,C> chunks, long time, TimeUnit unit, Scheduler scheduler) {
+        public TimeBasedChunkCreator(final OverlappingChunks<T, C> chunks, long time, TimeUnit unit, Scheduler scheduler) {
             this.subscription.wrap(scheduler.schedulePeriodically(new Action0() {
                 @Override
                 public void call() {
@@ -556,17 +567,18 @@ public void stop() {
     /**
      * This {@link rx.operators.ChunkedOperation.ChunkCreator} creates a new {@link rx.operators.ChunkedOperation.Chunk} every time after it has
      * seen a certain amount of elements.
-     *
-     * @param <T> The type of object all internal {@link rx.operators.ChunkedOperation.Chunk} objects record.
-     *        <C> The type of object being tracked by the {@link Chunk}
+     * 
+     * @param <T>
+     *            The type of object all internal {@link rx.operators.ChunkedOperation.Chunk} objects record.
+     *            <C> The type of object being tracked by the {@link Chunk}
      */
-    protected static class SkippingChunkCreator<T,C> implements ChunkCreator {
+    protected static class SkippingChunkCreator<T, C> implements ChunkCreator {
 
         private final AtomicInteger skipped = new AtomicInteger(1);
-        private final Chunks<T,C> chunks;
+        private final Chunks<T, C> chunks;
         private final int skip;
 
-        public SkippingChunkCreator(Chunks<T,C> chunks, int skip) {
+        public SkippingChunkCreator(Chunks<T, C> chunks, int skip) {
             this.chunks = chunks;
             this.skip = skip;
         }
diff --git a/rxjava-core/src/main/java/rx/operators/OperationBuffer.java b/rxjava-core/src/main/java/rx/operators/OperationBuffer.java
index 2323f6478e..c692ed6cee 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationBuffer.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationBuffer.java
@@ -6,7 +6,7 @@
  * You may obtain a copy of the License at
  * 
  * http://www.apache.org/licenses/LICENSE-2.0
- *
+ * 
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -25,6 +25,7 @@
 import org.mockito.Mockito;
 
 import rx.Observable;
+import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Scheduler;
 import rx.Subscription;
@@ -39,10 +40,9 @@
 import rx.util.functions.Func0;
 import rx.util.functions.Func1;
 
-
 public final class OperationBuffer extends ChunkedOperation {
 
-    public static final Func0 BUFFER_MAKER = new Func0() {
+    private static final Func0 BUFFER_MAKER = new Func0() {
         @Override
         public Object call() {
             return new Buffer();
@@ -51,29 +51,29 @@ public Object call() {
 
     /**
      * <p>This method creates a {@link Func1} object which represents the buffer operation. This operation takes
-     * values from the specified {@link Observable} source and stores them in a buffer until the {@link Observable}
-     * constructed using the {@link Func0} argument, produces a {@link rx.util.Closing} value. The buffer is then
+     * values from the specified {@link Observable} source and stores them in a buffer until the {@link Observable} constructed using the {@link Func0} argument, produces a {@link rx.util.Closing}
+     * value. The buffer is then
      * emitted, and a new buffer is created to replace it. A new {@link Observable} will be constructed using the
-     * provided {@link Func0} object, which will determine when this new buffer is emitted. When the source
-     * {@link Observable} completes or produces an error, the current buffer is emitted, and the event is propagated
+     * provided {@link Func0} object, which will determine when this new buffer is emitted. When the source {@link Observable} completes or produces an error, the current buffer is emitted, and the
+     * event is propagated
      * to all subscribed {@link Observer}s.</p>
-     *
+     * 
      * <p>Note that this operation only produces <strong>non-overlapping chunks</strong>. At all times there is
      * exactly one buffer actively storing values.</p>
-     *
+     * 
      * @param source
      *            The {@link Observable} which produces values.
      * @param bufferClosingSelector
-     *            A {@link Func0} object which produces {@link Observable}s. These
-     *            {@link Observable}s determine when a buffer is emitted and replaced by simply
+     *            A {@link Func0} object which produces {@link Observable}s. These {@link Observable}s determine when a buffer is emitted and replaced by simply
      *            producing an {@link rx.util.Closing} object.
      * @return
-     *            the {@link Func1} object representing the specified buffer operation.
+     *         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<Closing>> bufferClosingSelector) {
-        return new Func1<Observer<List<T>>, Subscription>() {
+    public static <T> OnSubscribeFunc<List<T>> buffer(final Observable<T> source, final Func0<? extends Observable<? extends Closing>> bufferClosingSelector) {
+        return new OnSubscribeFunc<List<T>>() {
+
             @Override
-            public Subscription call(final Observer<List<T>> observer) {
+            public Subscription onSubscribe(Observer<? super List<T>> observer) {
                 NonOverlappingChunks<T, List<T>> buffers = new NonOverlappingChunks<T, List<T>>(observer, BUFFER_MAKER);
                 ChunkCreator creator = new ObservableBasedSingleChunkCreator<T, List<T>>(buffers, bufferClosingSelector);
                 return source.subscribe(new ChunkObserver<T, List<T>>(buffers, observer, creator));
@@ -85,33 +85,31 @@ public Subscription call(final Observer<List<T>> observer) {
      * <p>This method creates a {@link Func1} object which represents the buffer operation. This operation takes
      * values from the specified {@link Observable} source and stores them in the currently active chunks. Initially
      * there are no chunks active.</p>
-     *
+     * 
      * <p>Chunks can be created by pushing a {@link rx.util.Opening} value to the "bufferOpenings" {@link Observable}.
-     * This creates a new buffer which will then start recording values which are produced by the "source"
-     * {@link Observable}. Additionally the "bufferClosingSelector" will be used to construct an {@link Observable}
-     * which can produce {@link rx.util.Closing} values. When it does so it will close this (and only this) newly created
+     * This creates a new buffer which will then start recording values which are produced by the "source" {@link Observable}. Additionally the "bufferClosingSelector" will be used to construct an
+     * {@link Observable} which can produce {@link rx.util.Closing} values. When it does so it will close this (and only this) newly created
      * buffer. When the source {@link Observable} completes or produces an error, all chunks are emitted, and the
      * event is propagated to all subscribed {@link Observer}s.</p>
-     *
+     * 
      * <p>Note that when using this operation <strong>multiple overlapping chunks</strong>
      * could be active at any one point.</p>
-     *
+     * 
      * @param source
      *            The {@link Observable} which produces values.
      * @param bufferOpenings
      *            An {@link Observable} which when it produces a {@link rx.util.Opening} value will
      *            create a new buffer which instantly starts recording the "source" {@link Observable}.
      * @param bufferClosingSelector
-     *            A {@link Func0} object which produces {@link Observable}s. These
-     *            {@link Observable}s determine when a buffer is emitted and replaced by simply
+     *            A {@link Func0} object which produces {@link Observable}s. These {@link Observable}s determine when a buffer is emitted and replaced by simply
      *            producing an {@link rx.util.Closing} object.
      * @return
-     *            the {@link Func1} object representing the specified buffer operation.
+     *         the {@link Func1} object representing the specified buffer operation.
      */
-    public static <T> Func1<Observer<List<T>>, Subscription> buffer(final Observable<T> source, final Observable<Opening> bufferOpenings, final Func1<Opening, Observable<Closing>> bufferClosingSelector) {
-        return new Func1<Observer<List<T>>, Subscription>() {
+    public static <T> OnSubscribeFunc<List<T>> buffer(final Observable<T> source, final Observable<? extends Opening> bufferOpenings, final Func1<? super Opening, ? extends Observable<? extends Closing>> bufferClosingSelector) {
+        return new OnSubscribeFunc<List<T>>() {
             @Override
-            public Subscription call(final Observer<List<T>> observer) {
+            public Subscription onSubscribe(final Observer<? super List<T>> observer) {
                 OverlappingChunks<T, List<T>> buffers = new OverlappingChunks<T, List<T>>(observer, BUFFER_MAKER);
                 ChunkCreator creator = new ObservableBasedMultiChunkCreator<T, List<T>>(buffers, bufferOpenings, bufferClosingSelector);
                 return source.subscribe(new ChunkObserver<T, List<T>>(buffers, observer, creator));
@@ -125,18 +123,18 @@ public Subscription call(final Observer<List<T>> observer) {
      * a specified number of elements. The buffer is then emitted, and a new buffer is created to replace it.
      * When the source {@link Observable} completes or produces an error, the current buffer is emitted, and
      * the event is propagated to all subscribed {@link Observer}s.</p>
-     *
+     * 
      * <p>Note that this operation only produces <strong>non-overlapping chunks</strong>. At all times there is
      * exactly one buffer actively storing values.</p>
-     *
+     * 
      * @param source
      *            The {@link Observable} which produces values.
      * @param count
      *            The number of elements a buffer should have before being emitted and replaced.
      * @return
-     *            the {@link Func1} object representing the specified buffer operation.
+     *         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> OnSubscribeFunc<List<T>> buffer(Observable<T> source, int count) {
         return buffer(source, count, count);
     }
 
@@ -146,10 +144,10 @@ public static <T> Func1<Observer<List<T>>, Subscription> buffer(Observable<T> so
      * contains a specified number of elements. The buffer is then emitted. Chunks are created after a certain
      * amount of values have been received. When the source {@link Observable} completes or produces an error, the
      * currently active chunks are emitted, and the event is propagated to all subscribed {@link Observer}s.</p>
-     *
+     * 
      * <p>Note that this operation can produce <strong>non-connected, connected non-overlapping, or overlapping
      * chunks</strong> depending on the input parameters.</p>
-     *
+     * 
      * @param source
      *            The {@link Observable} which produces values.
      * @param count
@@ -161,12 +159,12 @@ public static <T> Func1<Observer<List<T>>, Subscription> buffer(Observable<T> so
      *            > "count" non-overlapping chunks will be created and some values will not be pushed
      *            into a buffer at all!
      * @return
-     *            the {@link Func1} object representing the specified buffer operation.
+     *         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> OnSubscribeFunc<List<T>> buffer(final Observable<T> source, final int count, final int skip) {
+        return new OnSubscribeFunc<List<T>>() {
             @Override
-            public Subscription call(final Observer<List<T>> observer) {
+            public Subscription onSubscribe(final Observer<? super List<T>> observer) {
                 Chunks<T, List<T>> chunks = new SizeBasedChunks<T, List<T>>(observer, BUFFER_MAKER, count);
                 ChunkCreator creator = new SkippingChunkCreator<T, List<T>>(chunks, skip);
                 return source.subscribe(new ChunkObserver<T, List<T>>(chunks, observer, creator));
@@ -180,10 +178,10 @@ public Subscription call(final Observer<List<T>> observer) {
      * is emitted and replaced with a new buffer. How often this is done depends on the specified timespan.
      * When the source {@link Observable} completes or produces an error, the current buffer is emitted, and
      * the event is propagated to all subscribed {@link Observer}s.</p>
-     *
+     * 
      * <p>Note that this operation only produces <strong>non-overlapping chunks</strong>. At all times there is
      * exactly one buffer actively storing values.</p>
-     *
+     * 
      * @param source
      *            The {@link Observable} which produces values.
      * @param timespan
@@ -191,9 +189,9 @@ public Subscription call(final Observer<List<T>> observer) {
      * @param unit
      *            The {@link TimeUnit} defining the unit of time for the timespan.
      * @return
-     *            the {@link Func1} object representing the specified buffer operation.
+     *         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> OnSubscribeFunc<List<T>> buffer(Observable<T> source, long timespan, TimeUnit unit) {
         return buffer(source, timespan, unit, Schedulers.threadPoolForComputation());
     }
 
@@ -203,10 +201,10 @@ public static <T> Func1<Observer<List<T>>, Subscription> buffer(Observable<T> so
      * is emitted and replaced with a new buffer. How often this is done depends on the specified timespan.
      * When the source {@link Observable} completes or produces an error, the current buffer is emitted, and
      * the event is propagated to all subscribed {@link Observer}s.</p>
-     *
+     * 
      * <p>Note that this operation only produces <strong>non-overlapping chunks</strong>. At all times there is
      * exactly one buffer actively storing values.</p>
-     *
+     * 
      * @param source
      *            The {@link Observable} which produces values.
      * @param timespan
@@ -216,12 +214,12 @@ public static <T> Func1<Observer<List<T>>, Subscription> buffer(Observable<T> so
      * @param scheduler
      *            The {@link Scheduler} to use for timing chunks.
      * @return
-     *            the {@link Func1} object representing the specified buffer operation.
+     *         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> OnSubscribeFunc<List<T>> buffer(final Observable<T> source, final long timespan, final TimeUnit unit, final Scheduler scheduler) {
+        return new OnSubscribeFunc<List<T>>() {
             @Override
-            public Subscription call(final Observer<List<T>> observer) {
+            public Subscription onSubscribe(final Observer<? super List<T>> observer) {
                 NonOverlappingChunks<T, List<T>> buffers = new NonOverlappingChunks<T, List<T>>(observer, BUFFER_MAKER);
                 ChunkCreator creator = new TimeBasedChunkCreator<T, List<T>>(buffers, timespan, unit, scheduler);
                 return source.subscribe(new ChunkObserver<T, List<T>>(buffers, observer, creator));
@@ -236,10 +234,10 @@ public Subscription call(final Observer<List<T>> observer) {
      * Additionally the buffer is automatically emitted once it reaches a specified number of elements.
      * When the source {@link Observable} completes or produces an error, the current buffer is emitted, and
      * the event is propagated to all subscribed {@link Observer}s.</p>
-     *
+     * 
      * <p>Note that this operation only produces <strong>non-overlapping chunks</strong>. At all times there is
      * exactly one buffer actively storing values.</p>
-     *
+     * 
      * @param source
      *            The {@link Observable} which produces values.
      * @param timespan
@@ -249,9 +247,9 @@ public Subscription call(final Observer<List<T>> observer) {
      * @param count
      *            The maximum size of the buffer. Once a buffer reaches this size, it is emitted.
      * @return
-     *            the {@link Func1} object representing the specified buffer operation.
+     *         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> OnSubscribeFunc<List<T>> buffer(Observable<T> source, long timespan, TimeUnit unit, int count) {
         return buffer(source, timespan, unit, count, Schedulers.threadPoolForComputation());
     }
 
@@ -262,10 +260,10 @@ public static <T> Func1<Observer<List<T>>, Subscription> buffer(Observable<T> so
      * Additionally the buffer is automatically emitted once it reaches a specified number of elements.
      * When the source {@link Observable} completes or produces an error, the current buffer is emitted, and
      * the event is propagated to all subscribed {@link Observer}s.</p>
-     *
+     * 
      * <p>Note that this operation only produces <strong>non-overlapping chunks</strong>. At all times there is
      * exactly one buffer actively storing values.</p>
-     *
+     * 
      * @param source
      *            The {@link Observable} which produces values.
      * @param timespan
@@ -277,12 +275,12 @@ public static <T> Func1<Observer<List<T>>, Subscription> buffer(Observable<T> so
      * @param scheduler
      *            The {@link Scheduler} to use for timing chunks.
      * @return
-     *            the {@link Func1} object representing the specified buffer operation.
+     *         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> OnSubscribeFunc<List<T>> buffer(final Observable<T> source, final long timespan, final TimeUnit unit, final int count, final Scheduler scheduler) {
+        return new OnSubscribeFunc<List<T>>() {
             @Override
-            public Subscription call(final Observer<List<T>> observer) {
+            public Subscription onSubscribe(final Observer<? super List<T>> observer) {
                 Chunks<T, List<T>> chunks = new TimeAndSizeBasedChunks<T, List<T>>(observer, BUFFER_MAKER, count, timespan, unit, scheduler);
                 ChunkCreator creator = new SingleChunkCreator<T, List<T>>(chunks);
                 return source.subscribe(new ChunkObserver<T, List<T>>(chunks, observer, creator));
@@ -297,10 +295,10 @@ public Subscription call(final Observer<List<T>> observer) {
      * The creation of chunks is also periodical. How often this is done depends on the specified timeshift.
      * When the source {@link Observable} completes or produces an error, the current buffer is emitted, and
      * the event is propagated to all subscribed {@link Observer}s.</p>
-     *
+     * 
      * <p>Note that this operation can produce <strong>non-connected, or overlapping chunks</strong> depending
      * on the input parameters.</p>
-     *
+     * 
      * @param source
      *            The {@link Observable} which produces values.
      * @param timespan
@@ -310,9 +308,9 @@ public Subscription call(final Observer<List<T>> observer) {
      * @param unit
      *            The {@link TimeUnit} defining the unit of time for the timespan.
      * @return
-     *            the {@link Func1} object representing the specified buffer operation.
+     *         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> OnSubscribeFunc<List<T>> buffer(Observable<T> source, long timespan, long timeshift, TimeUnit unit) {
         return buffer(source, timespan, timeshift, unit, Schedulers.threadPoolForComputation());
     }
 
@@ -323,10 +321,10 @@ public static <T> Func1<Observer<List<T>>, Subscription> buffer(Observable<T> so
      * The creation of chunks is also periodical. How often this is done depends on the specified timeshift.
      * When the source {@link Observable} completes or produces an error, the current buffer is emitted, and
      * the event is propagated to all subscribed {@link Observer}s.</p>
-     *
+     * 
      * <p>Note that this operation can produce <strong>non-connected, or overlapping chunks</strong> depending
      * on the input parameters.</p>
-     *
+     * 
      * @param source
      *            The {@link Observable} which produces values.
      * @param timespan
@@ -338,12 +336,12 @@ public static <T> Func1<Observer<List<T>>, Subscription> buffer(Observable<T> so
      * @param scheduler
      *            The {@link Scheduler} to use for timing chunks.
      * @return
-     *            the {@link Func1} object representing the specified buffer operation.
+     *         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> OnSubscribeFunc<List<T>> buffer(final Observable<T> source, final long timespan, final long timeshift, final TimeUnit unit, final Scheduler scheduler) {
+        return new OnSubscribeFunc<List<T>>() {
             @Override
-            public Subscription call(final Observer<List<T>> observer) {
+            public Subscription onSubscribe(final Observer<? super List<T>> observer) {
                 OverlappingChunks<T, List<T>> buffers = new TimeBasedChunks<T, List<T>>(observer, BUFFER_MAKER, timespan, unit, scheduler);
                 ChunkCreator creator = new TimeBasedChunkCreator<T, List<T>>(buffers, timeshift, unit, scheduler);
                 return source.subscribe(new ChunkObserver<T, List<T>>(buffers, observer, creator));
@@ -354,13 +352,14 @@ public Subscription call(final Observer<List<T>> observer) {
     /**
      * This class represents a single buffer: A sequence of recorded values.
      * 
-     * @param <T> The type of objects which this {@link Buffer} can hold.
+     * @param <T>
+     *            The type of objects which this {@link Buffer} can hold.
      */
     protected static class Buffer<T> extends Chunk<T, List<T>> {
         /**
          * @return
-         *            The mutable underlying {@link List} which contains all the
-         *            recorded values in this {@link Buffer} object.
+         *         The mutable underlying {@link List} which contains all the
+         *         recorded values in this {@link Buffer} object.
          */
         @Override
         public List<T> getContents() {
@@ -382,9 +381,9 @@ public void before() {
 
         @Test
         public void testComplete() {
-            Observable<String> source = Observable.create(new Func1<Observer<String>, Subscription>() {
+            Observable<String> source = Observable.create(new OnSubscribeFunc<String>() {
                 @Override
-                public Subscription call(Observer<String> observer) {
+                public Subscription onSubscribe(Observer<? super String> observer) {
                     observer.onCompleted();
                     return Subscriptions.empty();
                 }
@@ -400,9 +399,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 OnSubscribeFunc<String>() {
                 @Override
-                public Subscription call(Observer<String> observer) {
+                public Subscription onSubscribe(Observer<? super String> observer) {
                     observer.onNext("one");
                     observer.onNext("two");
                     observer.onNext("three");
@@ -426,9 +425,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 OnSubscribeFunc<String>() {
                 @Override
-                public Subscription call(Observer<String> observer) {
+                public Subscription onSubscribe(Observer<? super String> observer) {
                     observer.onNext("one");
                     observer.onNext("two");
                     observer.onNext("three");
@@ -452,9 +451,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 OnSubscribeFunc<String>() {
                 @Override
-                public Subscription call(Observer<String> observer) {
+                public Subscription onSubscribe(Observer<? super String> observer) {
                     observer.onNext("one");
                     observer.onNext("two");
                     observer.onNext("three");
@@ -478,9 +477,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 OnSubscribeFunc<String>() {
                 @Override
-                public Subscription call(Observer<String> observer) {
+                public Subscription onSubscribe(Observer<? super String> observer) {
                     push(observer, "one", 10);
                     push(observer, "two", 90);
                     push(observer, "three", 110);
@@ -510,9 +509,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 OnSubscribeFunc<String>() {
                 @Override
-                public Subscription call(Observer<String> observer) {
+                public Subscription onSubscribe(Observer<? super String> observer) {
                     push(observer, "one", 98);
                     push(observer, "two", 99);
                     push(observer, "three", 100);
@@ -539,9 +538,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 OnSubscribeFunc<String>() {
                 @Override
-                public Subscription call(Observer<String> observer) {
+                public Subscription onSubscribe(Observer<? super String> observer) {
                     push(observer, "one", 10);
                     push(observer, "two", 60);
                     push(observer, "three", 110);
@@ -552,9 +551,9 @@ public Subscription call(Observer<String> observer) {
                 }
             });
 
-            Observable<Opening> openings = Observable.create(new Func1<Observer<Opening>, Subscription>() {
+            Observable<Opening> openings = Observable.create(new OnSubscribeFunc<Opening>() {
                 @Override
-                public Subscription call(Observer<Opening> observer) {
+                public Subscription onSubscribe(Observer<? super Opening> observer) {
                     push(observer, Openings.create(), 50);
                     push(observer, Openings.create(), 200);
                     complete(observer, 250);
@@ -565,9 +564,9 @@ public Subscription call(Observer<Opening> observer) {
             Func1<Opening, Observable<Closing>> closer = new Func1<Opening, Observable<Closing>>() {
                 @Override
                 public Observable<Closing> call(Opening opening) {
-                    return Observable.create(new Func1<Observer<Closing>, Subscription>() {
+                    return Observable.create(new OnSubscribeFunc<Closing>() {
                         @Override
-                        public Subscription call(Observer<Closing> observer) {
+                        public Subscription onSubscribe(Observer<? super Closing> observer) {
                             push(observer, Closings.create(), 100);
                             complete(observer, 101);
                             return Subscriptions.empty();
@@ -590,9 +589,9 @@ public Subscription call(Observer<Closing> observer) {
 
         @Test
         public void testObservableBasedCloser() {
-            Observable<String> source = Observable.create(new Func1<Observer<String>, Subscription>() {
+            Observable<String> source = Observable.create(new OnSubscribeFunc<String>() {
                 @Override
-                public Subscription call(Observer<String> observer) {
+                public Subscription onSubscribe(Observer<? super String> observer) {
                     push(observer, "one", 10);
                     push(observer, "two", 60);
                     push(observer, "three", 110);
@@ -606,9 +605,9 @@ public Subscription call(Observer<String> observer) {
             Func0<Observable<Closing>> closer = new Func0<Observable<Closing>>() {
                 @Override
                 public Observable<Closing> call() {
-                    return Observable.create(new Func1<Observer<Closing>, Subscription>() {
+                    return Observable.create(new OnSubscribeFunc<Closing>() {
                         @Override
-                        public Subscription call(Observer<Closing> observer) {
+                        public Subscription onSubscribe(Observer<? super Closing> observer) {
                             push(observer, Closings.create(), 100);
                             complete(observer, 101);
                             return Subscriptions.empty();
diff --git a/rxjava-core/src/main/java/rx/operators/OperationWindow.java b/rxjava-core/src/main/java/rx/operators/OperationWindow.java
index ce603de8cf..0278fbb4d8 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationWindow.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationWindow.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2013 Netflix, Inc.
- *
+ * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- *
+ * 
  * http://www.apache.org/licenses/LICENSE-2.0
- *
+ * 
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -15,9 +15,17 @@
  */
 package rx.operators;
 
+import static org.junit.Assert.*;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+
 import org.junit.Before;
 import org.junit.Test;
+
 import rx.Observable;
+import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Scheduler;
 import rx.Subscription;
@@ -28,15 +36,10 @@
 import rx.util.Closings;
 import rx.util.Opening;
 import rx.util.Openings;
-import rx.util.functions.*;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.concurrent.TimeUnit;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
-
+import rx.util.functions.Action0;
+import rx.util.functions.Action1;
+import rx.util.functions.Func0;
+import rx.util.functions.Func1;
 
 public final class OperationWindow extends ChunkedOperation {
 
@@ -49,33 +52,33 @@ public Object call() {
 
     /**
      * <p>This method creates a {@link rx.util.functions.Func1} object which represents the window operation. This operation takes
-     * values from the specified {@link rx.Observable} source and stores them in a window until the {@link rx.Observable}
-     * constructed using the {@link rx.util.functions.Func0} argument, produces a {@link rx.util.Closing} value. The window is then
+     * values from the specified {@link rx.Observable} source and stores them in a window until the {@link rx.Observable} constructed using the {@link rx.util.functions.Func0} argument, produces a
+     * {@link rx.util.Closing} value. The window is then
      * emitted, and a new window is created to replace it. A new {@link rx.Observable} will be constructed using the
-     * provided {@link rx.util.functions.Func0} object, which will determine when this new window is emitted. When the source
-     * {@link rx.Observable} completes or produces an error, the current window is emitted, and the event is propagated
+     * provided {@link rx.util.functions.Func0} object, which will determine when this new window is emitted. When the source {@link rx.Observable} completes or produces an error, the current window
+     * is emitted, and the event is propagated
      * to all subscribed {@link rx.Observer}s.</p>
-     *
+     * 
      * <p>Note that this operation only produces <strong>non-overlapping windows</strong>. At all times there is
      * exactly one window actively storing values.</p>
-     *
+     * 
      * @param source
      *            The {@link rx.Observable} which produces values.
      * @param windowClosingSelector
-     *            A {@link rx.util.functions.Func0} object which produces {@link rx.Observable}s. These
-     *            {@link rx.Observable}s determine when a window is emitted and replaced by simply
+     *            A {@link rx.util.functions.Func0} object which produces {@link rx.Observable}s. These {@link rx.Observable}s determine when a window is emitted and replaced by simply
      *            producing an {@link rx.util.Closing} object.
      * @return
-     *            the {@link rx.util.functions.Func1} object representing the specified window operation.
+     *         the {@link rx.util.functions.Func1} object representing the specified window operation.
      */
-    public static <T> Func1<Observer<Observable<T>>, Subscription> window(final Observable<T> source, final Func0<Observable<Closing>> windowClosingSelector) {
-        return new Func1<Observer<Observable<T>>, Subscription>() {
+    public static <T> OnSubscribeFunc<Observable<T>> window(final Observable<T> source, final Func0<Observable<Closing>> windowClosingSelector) {
+        return new OnSubscribeFunc<Observable<T>>() {
             @Override
-            public Subscription call(final Observer<Observable<T>> observer) {
+            public Subscription onSubscribe(final Observer<? super Observable<T>> observer) {
                 NonOverlappingChunks<T, Observable<T>> windows = new NonOverlappingChunks<T, Observable<T>>(observer, WINDOW_MAKER);
                 ChunkCreator creator = new ObservableBasedSingleChunkCreator<T, Observable<T>>(windows, windowClosingSelector);
                 return source.subscribe(new ChunkObserver<T, Observable<T>>(windows, observer, creator));
             }
+
         };
     }
 
@@ -83,33 +86,31 @@ public Subscription call(final Observer<Observable<T>> observer) {
      * <p>This method creates a {@link rx.util.functions.Func1} object which represents the window operation. This operation takes
      * values from the specified {@link rx.Observable} source and stores them in the currently active window. Initially
      * there are no windows active.</p>
-     *
+     * 
      * <p>Windows can be created by pushing a {@link rx.util.Opening} value to the "windowOpenings" {@link rx.Observable}.
-     * This creates a new window which will then start recording values which are produced by the "source"
-     * {@link rx.Observable}. Additionally the "windowClosingSelector" will be used to construct an {@link rx.Observable}
-     * which can produce {@link rx.util.Closing} values. When it does so it will close this (and only this) newly created
+     * This creates a new window which will then start recording values which are produced by the "source" {@link rx.Observable}. Additionally the "windowClosingSelector" will be used to construct an
+     * {@link rx.Observable} which can produce {@link rx.util.Closing} values. When it does so it will close this (and only this) newly created
      * window. When the source {@link rx.Observable} completes or produces an error, all windows are emitted, and the
      * event is propagated to all subscribed {@link rx.Observer}s.</p>
-     *
+     * 
      * <p>Note that when using this operation <strong>multiple overlapping windows</strong>
      * could be active at any one point.</p>
-     *
+     * 
      * @param source
      *            The {@link rx.Observable} which produces values.
      * @param windowOpenings
      *            An {@link rx.Observable} which when it produces a {@link rx.util.Opening} value will
      *            create a new window which instantly starts recording the "source" {@link rx.Observable}.
      * @param windowClosingSelector
-     *            A {@link rx.util.functions.Func0} object which produces {@link rx.Observable}s. These
-     *            {@link rx.Observable}s determine when a window is emitted and replaced by simply
+     *            A {@link rx.util.functions.Func0} object which produces {@link rx.Observable}s. These {@link rx.Observable}s determine when a window is emitted and replaced by simply
      *            producing an {@link rx.util.Closing} object.
      * @return
-     *            the {@link rx.util.functions.Func1} object representing the specified window operation.
+     *         the {@link rx.util.functions.Func1} object representing the specified window operation.
      */
-    public static <T> Func1<Observer<Observable<T>>, Subscription> window(final Observable<T> source, final Observable<Opening> windowOpenings, final Func1<Opening, Observable<Closing>> windowClosingSelector) {
-        return new Func1<Observer<Observable<T>>, Subscription>() {
+    public static <T> OnSubscribeFunc<Observable<T>> window(final Observable<T> source, final Observable<Opening> windowOpenings, final Func1<Opening, Observable<Closing>> windowClosingSelector) {
+        return new OnSubscribeFunc<Observable<T>>() {
             @Override
-            public Subscription call(final Observer<Observable<T>> observer) {
+            public Subscription onSubscribe(final Observer<? super Observable<T>> observer) {
                 OverlappingChunks<T, Observable<T>> windows = new OverlappingChunks<T, Observable<T>>(observer, WINDOW_MAKER);
                 ChunkCreator creator = new ObservableBasedMultiChunkCreator<T, Observable<T>>(windows, windowOpenings, windowClosingSelector);
                 return source.subscribe(new ChunkObserver<T, Observable<T>>(windows, observer, creator));
@@ -123,18 +124,18 @@ public Subscription call(final Observer<Observable<T>> observer) {
      * a specified number of elements. The window is then emitted, and a new window is created to replace it.
      * When the source {@link rx.Observable} completes or produces an error, the current window is emitted, and
      * the event is propagated to all subscribed {@link rx.Observer}s.</p>
-     *
+     * 
      * <p>Note that this operation only produces <strong>non-overlapping windows</strong>. At all times there is
      * exactly one window actively storing values.</p>
-     *
+     * 
      * @param source
      *            The {@link rx.Observable} which produces values.
      * @param count
      *            The number of elements a window should have before being emitted and replaced.
      * @return
-     *            the {@link rx.util.functions.Func1} object representing the specified window operation.
+     *         the {@link rx.util.functions.Func1} object representing the specified window operation.
      */
-    public static <T> Func1<Observer<Observable<T>>, Subscription> window(Observable<T> source, int count) {
+    public static <T> OnSubscribeFunc<Observable<T>> window(Observable<T> source, int count) {
         return window(source, count, count);
     }
 
@@ -144,10 +145,10 @@ public static <T> Func1<Observer<Observable<T>>, Subscription> window(Observable
      * contains a specified number of elements. The window is then emitted. windows are created after a certain
      * amount of values have been received. When the source {@link rx.Observable} completes or produces an error, the
      * currently active windows are emitted, and the event is propagated to all subscribed {@link rx.Observer}s.</p>
-     *
+     * 
      * <p>Note that this operation can produce <strong>non-connected, connected non-overlapping, or overlapping
      * windows</strong> depending on the input parameters.</p>
-     *
+     * 
      * @param source
      *            The {@link rx.Observable} which produces values.
      * @param count
@@ -159,12 +160,12 @@ public static <T> Func1<Observer<Observable<T>>, Subscription> window(Observable
      *            > "count" non-overlapping windows will be created and some values will not be pushed
      *            into a window at all!
      * @return
-     *            the {@link rx.util.functions.Func1} object representing the specified window operation.
+     *         the {@link rx.util.functions.Func1} object representing the specified window operation.
      */
-    public static <T> Func1<Observer<Observable<T>>, Subscription> window(final Observable<T> source, final int count, final int skip) {
-        return new Func1<Observer<Observable<T>>, Subscription>() {
+    public static <T> OnSubscribeFunc<Observable<T>> window(final Observable<T> source, final int count, final int skip) {
+        return new OnSubscribeFunc<Observable<T>>() {
             @Override
-            public Subscription call(final Observer<Observable<T>> observer) {
+            public Subscription onSubscribe(final Observer<? super Observable<T>> observer) {
                 Chunks<T, Observable<T>> chunks = new SizeBasedChunks<T, Observable<T>>(observer, WINDOW_MAKER, count);
                 ChunkCreator creator = new SkippingChunkCreator<T, Observable<T>>(chunks, skip);
                 return source.subscribe(new ChunkObserver<T, Observable<T>>(chunks, observer, creator));
@@ -178,10 +179,10 @@ public Subscription call(final Observer<Observable<T>> observer) {
      * is emitted and replaced with a new window. How often this is done depends on the specified timespan.
      * When the source {@link rx.Observable} completes or produces an error, the current window is emitted, and
      * the event is propagated to all subscribed {@link rx.Observer}s.</p>
-     *
+     * 
      * <p>Note that this operation only produces <strong>non-overlapping windows</strong>. At all times there is
      * exactly one window actively storing values.</p>
-     *
+     * 
      * @param source
      *            The {@link rx.Observable} which produces values.
      * @param timespan
@@ -189,9 +190,9 @@ public Subscription call(final Observer<Observable<T>> observer) {
      * @param unit
      *            The {@link java.util.concurrent.TimeUnit} defining the unit of time for the timespan.
      * @return
-     *            the {@link rx.util.functions.Func1} object representing the specified window operation.
+     *         the {@link rx.util.functions.Func1} object representing the specified window operation.
      */
-    public static <T> Func1<Observer<Observable<T>>, Subscription> window(Observable<T> source, long timespan, TimeUnit unit) {
+    public static <T> OnSubscribeFunc<Observable<T>> window(Observable<T> source, long timespan, TimeUnit unit) {
         return window(source, timespan, unit, Schedulers.threadPoolForComputation());
     }
 
@@ -201,10 +202,10 @@ public static <T> Func1<Observer<Observable<T>>, Subscription> window(Observable
      * is emitted and replaced with a new window. How often this is done depends on the specified timespan.
      * When the source {@link rx.Observable} completes or produces an error, the current window is emitted, and
      * the event is propagated to all subscribed {@link rx.Observer}s.</p>
-     *
+     * 
      * <p>Note that this operation only produces <strong>non-overlapping windows</strong>. At all times there is
      * exactly one window actively storing values.</p>
-     *
+     * 
      * @param source
      *            The {@link rx.Observable} which produces values.
      * @param timespan
@@ -214,12 +215,12 @@ public static <T> Func1<Observer<Observable<T>>, Subscription> window(Observable
      * @param scheduler
      *            The {@link rx.Scheduler} to use for timing windows.
      * @return
-     *            the {@link rx.util.functions.Func1} object representing the specified window operation.
+     *         the {@link rx.util.functions.Func1} object representing the specified window operation.
      */
-    public static <T> Func1<Observer<Observable<T>>, Subscription> window(final Observable<T> source, final long timespan, final TimeUnit unit, final Scheduler scheduler) {
-        return new Func1<Observer<Observable<T>>, Subscription>() {
+    public static <T> OnSubscribeFunc<Observable<T>> window(final Observable<T> source, final long timespan, final TimeUnit unit, final Scheduler scheduler) {
+        return new OnSubscribeFunc<Observable<T>>() {
             @Override
-            public Subscription call(final Observer<Observable<T>> observer) {
+            public Subscription onSubscribe(final Observer<? super Observable<T>> observer) {
                 NonOverlappingChunks<T, Observable<T>> windows = new NonOverlappingChunks<T, Observable<T>>(observer, WINDOW_MAKER);
                 ChunkCreator creator = new TimeBasedChunkCreator<T, Observable<T>>(windows, timespan, unit, scheduler);
                 return source.subscribe(new ChunkObserver<T, Observable<T>>(windows, observer, creator));
@@ -234,10 +235,10 @@ public Subscription call(final Observer<Observable<T>> observer) {
      * Additionally the window is automatically emitted once it reaches a specified number of elements.
      * When the source {@link rx.Observable} completes or produces an error, the current window is emitted, and
      * the event is propagated to all subscribed {@link rx.Observer}s.</p>
-     *
+     * 
      * <p>Note that this operation only produces <strong>non-overlapping windows</strong>. At all times there is
      * exactly one window actively storing values.</p>
-     *
+     * 
      * @param source
      *            The {@link rx.Observable} which produces values.
      * @param timespan
@@ -247,9 +248,9 @@ public Subscription call(final Observer<Observable<T>> observer) {
      * @param count
      *            The maximum size of the window. Once a window reaches this size, it is emitted.
      * @return
-     *            the {@link rx.util.functions.Func1} object representing the specified window operation.
+     *         the {@link rx.util.functions.Func1} object representing the specified window operation.
      */
-    public static <T> Func1<Observer<Observable<T>>, Subscription> window(Observable<T> source, long timespan, TimeUnit unit, int count) {
+    public static <T> OnSubscribeFunc<Observable<T>> window(Observable<T> source, long timespan, TimeUnit unit, int count) {
         return window(source, timespan, unit, count, Schedulers.threadPoolForComputation());
     }
 
@@ -260,10 +261,10 @@ public static <T> Func1<Observer<Observable<T>>, Subscription> window(Observable
      * Additionally the window is automatically emitted once it reaches a specified number of elements.
      * When the source {@link rx.Observable} completes or produces an error, the current window is emitted, and
      * the event is propagated to all subscribed {@link rx.Observer}s.</p>
-     *
+     * 
      * <p>Note that this operation only produces <strong>non-overlapping windows</strong>. At all times there is
      * exactly one window actively storing values.</p>
-     *
+     * 
      * @param source
      *            The {@link rx.Observable} which produces values.
      * @param timespan
@@ -275,12 +276,12 @@ public static <T> Func1<Observer<Observable<T>>, Subscription> window(Observable
      * @param scheduler
      *            The {@link rx.Scheduler} to use for timing windows.
      * @return
-     *            the {@link rx.util.functions.Func1} object representing the specified window operation.
+     *         the {@link rx.util.functions.Func1} object representing the specified window operation.
      */
-    public static <T> Func1<Observer<Observable<T>>, Subscription> window(final Observable<T> source, final long timespan, final TimeUnit unit, final int count, final Scheduler scheduler) {
-        return new Func1<Observer<Observable<T>>, Subscription>() {
+    public static <T> OnSubscribeFunc<Observable<T>> window(final Observable<T> source, final long timespan, final TimeUnit unit, final int count, final Scheduler scheduler) {
+        return new OnSubscribeFunc<Observable<T>>() {
             @Override
-            public Subscription call(final Observer<Observable<T>> observer) {
+            public Subscription onSubscribe(final Observer<? super Observable<T>> observer) {
                 Chunks<T, Observable<T>> chunks = new TimeAndSizeBasedChunks<T, Observable<T>>(observer, WINDOW_MAKER, count, timespan, unit, scheduler);
                 ChunkCreator creator = new SingleChunkCreator<T, Observable<T>>(chunks);
                 return source.subscribe(new ChunkObserver<T, Observable<T>>(chunks, observer, creator));
@@ -295,10 +296,10 @@ public Subscription call(final Observer<Observable<T>> observer) {
      * The creation of windows is also periodical. How often this is done depends on the specified timeshift.
      * When the source {@link rx.Observable} completes or produces an error, the current window is emitted, and
      * the event is propagated to all subscribed {@link rx.Observer}s.</p>
-     *
+     * 
      * <p>Note that this operation can produce <strong>non-connected, or overlapping windows</strong> depending
      * on the input parameters.</p>
-     *
+     * 
      * @param source
      *            The {@link rx.Observable} which produces values.
      * @param timespan
@@ -308,9 +309,9 @@ public Subscription call(final Observer<Observable<T>> observer) {
      * @param unit
      *            The {@link java.util.concurrent.TimeUnit} defining the unit of time for the timespan.
      * @return
-     *            the {@link rx.util.functions.Func1} object representing the specified window operation.
+     *         the {@link rx.util.functions.Func1} object representing the specified window operation.
      */
-    public static <T> Func1<Observer<Observable<T>>, Subscription> window(Observable<T> source, long timespan, long timeshift, TimeUnit unit) {
+    public static <T> OnSubscribeFunc<Observable<T>> window(Observable<T> source, long timespan, long timeshift, TimeUnit unit) {
         return window(source, timespan, timeshift, unit, Schedulers.threadPoolForComputation());
     }
 
@@ -321,10 +322,10 @@ public static <T> Func1<Observer<Observable<T>>, Subscription> window(Observable
      * The creation of windows is also periodical. How often this is done depends on the specified timeshift.
      * When the source {@link rx.Observable} completes or produces an error, the current window is emitted, and
      * the event is propagated to all subscribed {@link rx.Observer}s.</p>
-     *
+     * 
      * <p>Note that this operation can produce <strong>non-connected, or overlapping windows</strong> depending
      * on the input parameters.</p>
-     *
+     * 
      * @param source
      *            The {@link rx.Observable} which produces values.
      * @param timespan
@@ -336,12 +337,12 @@ public static <T> Func1<Observer<Observable<T>>, Subscription> window(Observable
      * @param scheduler
      *            The {@link rx.Scheduler} to use for timing windows.
      * @return
-     *            the {@link rx.util.functions.Func1} object representing the specified window operation.
+     *         the {@link rx.util.functions.Func1} object representing the specified window operation.
      */
-    public static <T> Func1<Observer<Observable<T>>, Subscription> window(final Observable<T> source, final long timespan, final long timeshift, final TimeUnit unit, final Scheduler scheduler) {
-        return new Func1<Observer<Observable<T>>, Subscription>() {
+    public static <T> OnSubscribeFunc<Observable<T>> window(final Observable<T> source, final long timespan, final long timeshift, final TimeUnit unit, final Scheduler scheduler) {
+        return new OnSubscribeFunc<Observable<T>>() {
             @Override
-            public Subscription call(final Observer<Observable<T>> observer) {
+            public Subscription onSubscribe(final Observer<? super Observable<T>> observer) {
                 OverlappingChunks<T, Observable<T>> windows = new TimeBasedChunks<T, Observable<T>>(observer, WINDOW_MAKER, timespan, unit, scheduler);
                 ChunkCreator creator = new TimeBasedChunkCreator<T, Observable<T>>(windows, timeshift, unit, scheduler);
                 return source.subscribe(new ChunkObserver<T, Observable<T>>(windows, observer, creator));
@@ -351,14 +352,15 @@ public Subscription call(final Observer<Observable<T>> observer) {
 
     /**
      * This class represents a single window: A sequence of recorded values.
-     *
-     * @param <T> The type of objects which this {@link Window} can hold.
+     * 
+     * @param <T>
+     *            The type of objects which this {@link Window} can hold.
      */
     protected static class Window<T> extends Chunk<T, Observable<T>> {
         /**
          * @return
-         *            The mutable underlying {@link Observable} which contains all the
-         *            recorded values in this {@link Window} object.
+         *         The mutable underlying {@link Observable} which contains all the
+         *         recorded values in this {@link Window} object.
          */
         @Override
         public Observable<T> getContents() {
@@ -453,9 +455,9 @@ public void testTimedAndCount() {
             final List<String> list = new ArrayList<String>();
             final List<List<String>> lists = new ArrayList<List<String>>();
 
-            Observable<String> source = Observable.create(new Func1<Observer<String>, Subscription>() {
+            Observable<String> source = Observable.create(new OnSubscribeFunc<String>() {
                 @Override
-                public Subscription call(Observer<String> observer) {
+                public Subscription onSubscribe(Observer<? super String> observer) {
                     push(observer, "one", 10);
                     push(observer, "two", 90);
                     push(observer, "three", 110);
@@ -487,9 +489,9 @@ public void testTimed() {
             final List<String> list = new ArrayList<String>();
             final List<List<String>> lists = new ArrayList<List<String>>();
 
-            Observable<String> source = Observable.create(new Func1<Observer<String>, Subscription>() {
+            Observable<String> source = Observable.create(new OnSubscribeFunc<String>() {
                 @Override
-                public Subscription call(Observer<String> observer) {
+                public Subscription onSubscribe(Observer<? super String> observer) {
                     push(observer, "one", 98);
                     push(observer, "two", 99);
                     push(observer, "three", 100);
@@ -517,9 +519,9 @@ public void testObservableBasedOpenerAndCloser() {
             final List<String> list = new ArrayList<String>();
             final List<List<String>> lists = new ArrayList<List<String>>();
 
-            Observable<String> source = Observable.create(new Func1<Observer<String>, Subscription>() {
+            Observable<String> source = Observable.create(new OnSubscribeFunc<String>() {
                 @Override
-                public Subscription call(Observer<String> observer) {
+                public Subscription onSubscribe(Observer<? super String> observer) {
                     push(observer, "one", 10);
                     push(observer, "two", 60);
                     push(observer, "three", 110);
@@ -530,9 +532,9 @@ public Subscription call(Observer<String> observer) {
                 }
             });
 
-            Observable<Opening> openings = Observable.create(new Func1<Observer<Opening>, Subscription>() {
+            Observable<Opening> openings = Observable.create(new OnSubscribeFunc<Opening>() {
                 @Override
-                public Subscription call(Observer<Opening> observer) {
+                public Subscription onSubscribe(Observer<? super Opening> observer) {
                     push(observer, Openings.create(), 50);
                     push(observer, Openings.create(), 200);
                     complete(observer, 250);
@@ -543,9 +545,9 @@ public Subscription call(Observer<Opening> observer) {
             Func1<Opening, Observable<Closing>> closer = new Func1<Opening, Observable<Closing>>() {
                 @Override
                 public Observable<Closing> call(Opening opening) {
-                    return Observable.create(new Func1<Observer<Closing>, Subscription>() {
+                    return Observable.create(new OnSubscribeFunc<Closing>() {
                         @Override
-                        public Subscription call(Observer<Closing> observer) {
+                        public Subscription onSubscribe(Observer<? super Closing> observer) {
                             push(observer, Closings.create(), 100);
                             complete(observer, 101);
                             return Subscriptions.empty();
@@ -568,9 +570,9 @@ public void testObservableBasedCloser() {
             final List<String> list = new ArrayList<String>();
             final List<List<String>> lists = new ArrayList<List<String>>();
 
-            Observable<String> source = Observable.create(new Func1<Observer<String>, Subscription>() {
+            Observable<String> source = Observable.create(new OnSubscribeFunc<String>() {
                 @Override
-                public Subscription call(Observer<String> observer) {
+                public Subscription onSubscribe(Observer<? super String> observer) {
                     push(observer, "one", 10);
                     push(observer, "two", 60);
                     push(observer, "three", 110);
@@ -584,9 +586,9 @@ public Subscription call(Observer<String> observer) {
             Func0<Observable<Closing>> closer = new Func0<Observable<Closing>>() {
                 @Override
                 public Observable<Closing> call() {
-                    return Observable.create(new Func1<Observer<Closing>, Subscription>() {
+                    return Observable.create(new OnSubscribeFunc<Closing>() {
                         @Override
-                        public Subscription call(Observer<Closing> observer) {
+                        public Subscription onSubscribe(Observer<? super Closing> observer) {
                             push(observer, Closings.create(), 100);
                             complete(observer, 101);
                             return Subscriptions.empty();

From 959b0d84b4ee762461d47324cd2d4d00a3e49c0f Mon Sep 17 00:00:00 2001
From: jmhofer <jmhofer.github@johoop.de>
Date: Thu, 5 Sep 2013 18:51:47 +0200
Subject: [PATCH 3/5] made WINDOW_MAKER typed

---
 .../java/rx/operators/OperationWindow.java    | 27 ++++++++++---------
 1 file changed, 14 insertions(+), 13 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/operators/OperationWindow.java b/rxjava-core/src/main/java/rx/operators/OperationWindow.java
index 0278fbb4d8..0a24937f3b 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationWindow.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationWindow.java
@@ -43,12 +43,14 @@
 
 public final class OperationWindow extends ChunkedOperation {
 
-    public static final Func0 WINDOW_MAKER = new Func0() {
-        @Override
-        public Object call() {
-            return new Window();
-        }
-    };
+    public static <T> Func0<Window<T>> windowMaker() {
+        return new Func0<Window<T>>() {
+            @Override
+            public Window<T> call() {
+                return new Window<T>();
+            }
+        };
+     }
 
     /**
      * <p>This method creates a {@link rx.util.functions.Func1} object which represents the window operation. This operation takes
@@ -74,7 +76,7 @@ public static <T> OnSubscribeFunc<Observable<T>> window(final Observable<T> sour
         return new OnSubscribeFunc<Observable<T>>() {
             @Override
             public Subscription onSubscribe(final Observer<? super Observable<T>> observer) {
-                NonOverlappingChunks<T, Observable<T>> windows = new NonOverlappingChunks<T, Observable<T>>(observer, WINDOW_MAKER);
+                NonOverlappingChunks<T, Observable<T>> windows = new NonOverlappingChunks<T, Observable<T>>(observer, windowMaker());
                 ChunkCreator creator = new ObservableBasedSingleChunkCreator<T, Observable<T>>(windows, windowClosingSelector);
                 return source.subscribe(new ChunkObserver<T, Observable<T>>(windows, observer, creator));
             }
@@ -111,7 +113,7 @@ public static <T> OnSubscribeFunc<Observable<T>> window(final Observable<T> sour
         return new OnSubscribeFunc<Observable<T>>() {
             @Override
             public Subscription onSubscribe(final Observer<? super Observable<T>> observer) {
-                OverlappingChunks<T, Observable<T>> windows = new OverlappingChunks<T, Observable<T>>(observer, WINDOW_MAKER);
+                OverlappingChunks<T, Observable<T>> windows = new OverlappingChunks<T, Observable<T>>(observer, windowMaker());
                 ChunkCreator creator = new ObservableBasedMultiChunkCreator<T, Observable<T>>(windows, windowOpenings, windowClosingSelector);
                 return source.subscribe(new ChunkObserver<T, Observable<T>>(windows, observer, creator));
             }
@@ -166,7 +168,7 @@ public static <T> OnSubscribeFunc<Observable<T>> window(final Observable<T> sour
         return new OnSubscribeFunc<Observable<T>>() {
             @Override
             public Subscription onSubscribe(final Observer<? super Observable<T>> observer) {
-                Chunks<T, Observable<T>> chunks = new SizeBasedChunks<T, Observable<T>>(observer, WINDOW_MAKER, count);
+                Chunks<T, Observable<T>> chunks = new SizeBasedChunks<T, Observable<T>>(observer, windowMaker(), count);
                 ChunkCreator creator = new SkippingChunkCreator<T, Observable<T>>(chunks, skip);
                 return source.subscribe(new ChunkObserver<T, Observable<T>>(chunks, observer, creator));
             }
@@ -221,7 +223,7 @@ public static <T> OnSubscribeFunc<Observable<T>> window(final Observable<T> sour
         return new OnSubscribeFunc<Observable<T>>() {
             @Override
             public Subscription onSubscribe(final Observer<? super Observable<T>> observer) {
-                NonOverlappingChunks<T, Observable<T>> windows = new NonOverlappingChunks<T, Observable<T>>(observer, WINDOW_MAKER);
+                NonOverlappingChunks<T, Observable<T>> windows = new NonOverlappingChunks<T, Observable<T>>(observer, windowMaker());
                 ChunkCreator creator = new TimeBasedChunkCreator<T, Observable<T>>(windows, timespan, unit, scheduler);
                 return source.subscribe(new ChunkObserver<T, Observable<T>>(windows, observer, creator));
             }
@@ -282,7 +284,7 @@ public static <T> OnSubscribeFunc<Observable<T>> window(final Observable<T> sour
         return new OnSubscribeFunc<Observable<T>>() {
             @Override
             public Subscription onSubscribe(final Observer<? super Observable<T>> observer) {
-                Chunks<T, Observable<T>> chunks = new TimeAndSizeBasedChunks<T, Observable<T>>(observer, WINDOW_MAKER, count, timespan, unit, scheduler);
+                Chunks<T, Observable<T>> chunks = new TimeAndSizeBasedChunks<T, Observable<T>>(observer, windowMaker(), count, timespan, unit, scheduler);
                 ChunkCreator creator = new SingleChunkCreator<T, Observable<T>>(chunks);
                 return source.subscribe(new ChunkObserver<T, Observable<T>>(chunks, observer, creator));
             }
@@ -343,7 +345,7 @@ public static <T> OnSubscribeFunc<Observable<T>> window(final Observable<T> sour
         return new OnSubscribeFunc<Observable<T>>() {
             @Override
             public Subscription onSubscribe(final Observer<? super Observable<T>> observer) {
-                OverlappingChunks<T, Observable<T>> windows = new TimeBasedChunks<T, Observable<T>>(observer, WINDOW_MAKER, timespan, unit, scheduler);
+                OverlappingChunks<T, Observable<T>> windows = new TimeBasedChunks<T, Observable<T>>(observer, windowMaker(), timespan, unit, scheduler);
                 ChunkCreator creator = new TimeBasedChunkCreator<T, Observable<T>>(windows, timeshift, unit, scheduler);
                 return source.subscribe(new ChunkObserver<T, Observable<T>>(windows, observer, creator));
             }
@@ -373,7 +375,6 @@ public static class UnitTest {
         private TestScheduler scheduler;
 
         @Before
-        @SuppressWarnings("unchecked")
         public void before() {
             scheduler = new TestScheduler();
         }

From a7b40b3b5a0ec673694291f4aab9fa89a5750014 Mon Sep 17 00:00:00 2001
From: jmhofer <jmhofer.github@johoop.de>
Date: Thu, 5 Sep 2013 19:25:35 +0200
Subject: [PATCH 4/5] removed raw Func0s from the chunks

---
 .../main/java/rx/operators/ChunkedOperation.java   | 14 +++++++-------
 .../main/java/rx/operators/OperationWindow.java    | 12 ++++++------
 2 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/operators/ChunkedOperation.java b/rxjava-core/src/main/java/rx/operators/ChunkedOperation.java
index 5b5eb3344c..f0990425bb 100644
--- a/rxjava-core/src/main/java/rx/operators/ChunkedOperation.java
+++ b/rxjava-core/src/main/java/rx/operators/ChunkedOperation.java
@@ -105,7 +105,7 @@ protected static class NonOverlappingChunks<T, C> extends Chunks<T, C> {
 
         private final Object lock = new Object();
 
-        public NonOverlappingChunks(Observer<? super C> observer, Func0 chunkMaker) {
+        public NonOverlappingChunks(Observer<? super C> observer, Func0<? extends Chunk<T, C>> chunkMaker) {
             super(observer, chunkMaker);
         }
 
@@ -134,7 +134,7 @@ public void pushValue(T value) {
      *            <C> The type of object being tracked by the {@link rx.operators.ChunkedOperation.Chunk}
      */
     protected static class OverlappingChunks<T, C> extends Chunks<T, C> {
-        public OverlappingChunks(Observer<? super C> observer, Func0 chunkMaker) {
+        public OverlappingChunks(Observer<? super C> observer, Func0<? extends Chunk<T, C>> chunkMaker) {
             super(observer, chunkMaker);
         }
     }
@@ -158,7 +158,7 @@ protected static class TimeAndSizeBasedChunks<T, C> extends Chunks<T, C> {
         private final TimeUnit unit;
         private final int maxSize;
 
-        public TimeAndSizeBasedChunks(Observer<? super C> observer, Func0 chunkMaker, int maxSize, long maxTime, TimeUnit unit, Scheduler scheduler) {
+        public TimeAndSizeBasedChunks(Observer<? super C> observer, Func0<? extends Chunk<T, C>> chunkMaker, int maxSize, long maxTime, TimeUnit unit, Scheduler scheduler) {
             super(observer, chunkMaker);
             this.maxSize = maxSize;
             this.maxTime = maxTime;
@@ -224,7 +224,7 @@ protected static class TimeBasedChunks<T, C> extends OverlappingChunks<T, C> {
         private final long time;
         private final TimeUnit unit;
 
-        public TimeBasedChunks(Observer<? super C> observer, Func0 chunkMaker, long time, TimeUnit unit, Scheduler scheduler) {
+        public TimeBasedChunks(Observer<? super C> observer, Func0<? extends Chunk<T, C>> chunkMaker, long time, TimeUnit unit, Scheduler scheduler) {
             super(observer, chunkMaker);
             this.time = time;
             this.unit = unit;
@@ -263,7 +263,7 @@ protected static class SizeBasedChunks<T, C> extends Chunks<T, C> {
 
         private final int size;
 
-        public SizeBasedChunks(Observer<? super C> observer, Func0 chunkMaker, int size) {
+        public SizeBasedChunks(Observer<? super C> observer, Func0<? extends Chunk<T, C>> chunkMaker, int size) {
             super(observer, chunkMaker);
             this.size = size;
         }
@@ -295,7 +295,7 @@ protected static class Chunks<T, C> {
 
         private final Queue<Chunk<T, C>> chunks = new ConcurrentLinkedQueue<Chunk<T, C>>();
         private final Observer<? super C> observer;
-        private final Func0<Chunk<T, C>> chunkMaker;
+        private final Func0<? extends Chunk<T, C>> chunkMaker;
 
         /**
          * Constructs a new {@link ChunkedOperation.Chunks} object for the specified {@link rx.Observer}.
@@ -303,7 +303,7 @@ protected static class Chunks<T, C> {
          * @param observer
          *            The {@link rx.Observer} to which this object will emit its internal {@link rx.operators.ChunkedOperation.Chunk} objects to when requested.
          */
-        public Chunks(Observer<? super C> observer, Func0 chunkMaker) {
+        public Chunks(Observer<? super C> observer, Func0<? extends Chunk<T, C>> chunkMaker) {
             this.observer = observer;
             this.chunkMaker = chunkMaker;
         }
diff --git a/rxjava-core/src/main/java/rx/operators/OperationWindow.java b/rxjava-core/src/main/java/rx/operators/OperationWindow.java
index 0a24937f3b..ab15ed2352 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationWindow.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationWindow.java
@@ -76,7 +76,7 @@ public static <T> OnSubscribeFunc<Observable<T>> window(final Observable<T> sour
         return new OnSubscribeFunc<Observable<T>>() {
             @Override
             public Subscription onSubscribe(final Observer<? super Observable<T>> observer) {
-                NonOverlappingChunks<T, Observable<T>> windows = new NonOverlappingChunks<T, Observable<T>>(observer, windowMaker());
+                NonOverlappingChunks<T, Observable<T>> windows = new NonOverlappingChunks<T, Observable<T>>(observer, OperationWindow.<T>windowMaker());
                 ChunkCreator creator = new ObservableBasedSingleChunkCreator<T, Observable<T>>(windows, windowClosingSelector);
                 return source.subscribe(new ChunkObserver<T, Observable<T>>(windows, observer, creator));
             }
@@ -113,7 +113,7 @@ public static <T> OnSubscribeFunc<Observable<T>> window(final Observable<T> sour
         return new OnSubscribeFunc<Observable<T>>() {
             @Override
             public Subscription onSubscribe(final Observer<? super Observable<T>> observer) {
-                OverlappingChunks<T, Observable<T>> windows = new OverlappingChunks<T, Observable<T>>(observer, windowMaker());
+                OverlappingChunks<T, Observable<T>> windows = new OverlappingChunks<T, Observable<T>>(observer, OperationWindow.<T>windowMaker());
                 ChunkCreator creator = new ObservableBasedMultiChunkCreator<T, Observable<T>>(windows, windowOpenings, windowClosingSelector);
                 return source.subscribe(new ChunkObserver<T, Observable<T>>(windows, observer, creator));
             }
@@ -168,7 +168,7 @@ public static <T> OnSubscribeFunc<Observable<T>> window(final Observable<T> sour
         return new OnSubscribeFunc<Observable<T>>() {
             @Override
             public Subscription onSubscribe(final Observer<? super Observable<T>> observer) {
-                Chunks<T, Observable<T>> chunks = new SizeBasedChunks<T, Observable<T>>(observer, windowMaker(), count);
+                Chunks<T, Observable<T>> chunks = new SizeBasedChunks<T, Observable<T>>(observer, OperationWindow.<T>windowMaker(), count);
                 ChunkCreator creator = new SkippingChunkCreator<T, Observable<T>>(chunks, skip);
                 return source.subscribe(new ChunkObserver<T, Observable<T>>(chunks, observer, creator));
             }
@@ -223,7 +223,7 @@ public static <T> OnSubscribeFunc<Observable<T>> window(final Observable<T> sour
         return new OnSubscribeFunc<Observable<T>>() {
             @Override
             public Subscription onSubscribe(final Observer<? super Observable<T>> observer) {
-                NonOverlappingChunks<T, Observable<T>> windows = new NonOverlappingChunks<T, Observable<T>>(observer, windowMaker());
+                NonOverlappingChunks<T, Observable<T>> windows = new NonOverlappingChunks<T, Observable<T>>(observer, OperationWindow.<T>windowMaker());
                 ChunkCreator creator = new TimeBasedChunkCreator<T, Observable<T>>(windows, timespan, unit, scheduler);
                 return source.subscribe(new ChunkObserver<T, Observable<T>>(windows, observer, creator));
             }
@@ -284,7 +284,7 @@ public static <T> OnSubscribeFunc<Observable<T>> window(final Observable<T> sour
         return new OnSubscribeFunc<Observable<T>>() {
             @Override
             public Subscription onSubscribe(final Observer<? super Observable<T>> observer) {
-                Chunks<T, Observable<T>> chunks = new TimeAndSizeBasedChunks<T, Observable<T>>(observer, windowMaker(), count, timespan, unit, scheduler);
+                Chunks<T, Observable<T>> chunks = new TimeAndSizeBasedChunks<T, Observable<T>>(observer, OperationWindow.<T>windowMaker(), count, timespan, unit, scheduler);
                 ChunkCreator creator = new SingleChunkCreator<T, Observable<T>>(chunks);
                 return source.subscribe(new ChunkObserver<T, Observable<T>>(chunks, observer, creator));
             }
@@ -345,7 +345,7 @@ public static <T> OnSubscribeFunc<Observable<T>> window(final Observable<T> sour
         return new OnSubscribeFunc<Observable<T>>() {
             @Override
             public Subscription onSubscribe(final Observer<? super Observable<T>> observer) {
-                OverlappingChunks<T, Observable<T>> windows = new TimeBasedChunks<T, Observable<T>>(observer, windowMaker(), timespan, unit, scheduler);
+                OverlappingChunks<T, Observable<T>> windows = new TimeBasedChunks<T, Observable<T>>(observer, OperationWindow.<T>windowMaker(), timespan, unit, scheduler);
                 ChunkCreator creator = new TimeBasedChunkCreator<T, Observable<T>>(windows, timeshift, unit, scheduler);
                 return source.subscribe(new ChunkObserver<T, Observable<T>>(windows, observer, creator));
             }

From 92fe7f9d32f2c53767ecfea631aae79c9f3ac9d4 Mon Sep 17 00:00:00 2001
From: jmhofer <jmhofer.github@johoop.de>
Date: Thu, 5 Sep 2013 19:47:07 +0200
Subject: [PATCH 5/5] made the public window methods more generic via the basic
 (lol) super/extends fluff; also simplified api by removing a few useless
 super definitions (there's no super of Opening and Closing)

---
 rxjava-core/src/main/java/rx/Observable.java  | 22 +++++++--------
 .../java/rx/operators/ChunkedOperation.java   |  2 +-
 .../java/rx/operators/OperationBuffer.java    | 28 ++++++++++---------
 .../java/rx/operators/OperationWindow.java    | 20 ++++++-------
 4 files changed, 37 insertions(+), 35 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 25073ca729..e4b64fc28a 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -1337,7 +1337,7 @@ public Observable<List<T>> buffer(Func0<? extends Observable<? extends Closing>>
      * @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<? extends Opening> bufferOpenings, Func1<? super Opening, ? extends Observable<? extends Closing>> bufferClosingSelector) {
+    public Observable<List<T>> buffer(Observable<? extends Opening> bufferOpenings, Func1<Opening, ? extends Observable<? extends Closing>> bufferClosingSelector) {
         return create(OperationBuffer.buffer(this, bufferOpenings, bufferClosingSelector));
     }
 
@@ -1520,7 +1520,7 @@ public Observable<List<T>> buffer(long timespan, long timeshift, TimeUnit unit,
      *         An {@link Observable} which produces connected non-overlapping windows, which are emitted
      *         when the current {@link Observable} created with the {@link Func0} argument produces a {@link rx.util.Closing} object.
      */
-    public Observable<Observable<T>> window(Observable<T> source, Func0<Observable<Closing>> closingSelector) {
+    public Observable<Observable<T>> window(Observable<? extends T> source, Func0<? extends Observable<? extends Closing>> closingSelector) {
         return create(OperationWindow.window(source, closingSelector));
     }
 
@@ -1542,7 +1542,7 @@ public Observable<Observable<T>> window(Observable<T> source, Func0<Observable<C
      * @return
      *         An {@link Observable} which produces windows which are created and emitted when the specified {@link Observable}s publish certain objects.
      */
-    public Observable<Observable<T>> window(Observable<T> source, Observable<Opening> windowOpenings, Func1<Opening, Observable<Closing>> closingSelector) {
+    public Observable<Observable<T>> window(Observable<? extends T> source, Observable<? extends Opening> windowOpenings, Func1<Opening, ? extends Observable<? extends Closing>> closingSelector) {
         return create(OperationWindow.window(source, windowOpenings, closingSelector));
     }
 
@@ -1559,7 +1559,7 @@ public Observable<Observable<T>> window(Observable<T> source, Observable<Opening
      *         An {@link Observable} which produces connected non-overlapping windows containing at most
      *         "count" produced values.
      */
-    public Observable<Observable<T>> window(Observable<T> source, int count) {
+    public Observable<Observable<T>> window(Observable<? extends T> source, int count) {
         return create(OperationWindow.window(source, count));
     }
 
@@ -1579,7 +1579,7 @@ public Observable<Observable<T>> window(Observable<T> source, int count) {
      *         An {@link Observable} which produces windows every "skipped" values containing at most
      *         "count" produced values.
      */
-    public Observable<Observable<T>> window(Observable<T> source, int count, int skip) {
+    public Observable<Observable<T>> window(Observable<? extends T> source, int count, int skip) {
         return create(OperationWindow.window(source, count, skip));
     }
 
@@ -1598,7 +1598,7 @@ public Observable<Observable<T>> window(Observable<T> source, int count, int ski
      * @return
      *         An {@link Observable} which produces connected non-overlapping windows with a fixed duration.
      */
-    public Observable<Observable<T>> window(Observable<T> source, long timespan, TimeUnit unit) {
+    public Observable<Observable<T>> window(Observable<? extends T> source, long timespan, TimeUnit unit) {
         return create(OperationWindow.window(source, timespan, unit));
     }
 
@@ -1619,7 +1619,7 @@ public Observable<Observable<T>> window(Observable<T> source, long timespan, Tim
      * @return
      *         An {@link Observable} which produces connected non-overlapping windows with a fixed duration.
      */
-    public Observable<Observable<T>> window(Observable<T> source, long timespan, TimeUnit unit, Scheduler scheduler) {
+    public Observable<Observable<T>> window(Observable<? extends T> source, long timespan, TimeUnit unit, Scheduler scheduler) {
         return create(OperationWindow.window(source, timespan, unit, scheduler));
     }
 
@@ -1642,7 +1642,7 @@ public Observable<Observable<T>> window(Observable<T> source, long timespan, Tim
      *         An {@link Observable} which produces connected non-overlapping windows which are emitted after
      *         a fixed duration or when the window has reached maximum capacity (which ever occurs first).
      */
-    public Observable<Observable<T>> window(Observable<T> source, long timespan, TimeUnit unit, int count) {
+    public Observable<Observable<T>> window(Observable<? extends T> source, long timespan, TimeUnit unit, int count) {
         return create(OperationWindow.window(source, timespan, unit, count));
     }
 
@@ -1667,7 +1667,7 @@ public Observable<Observable<T>> window(Observable<T> source, long timespan, Tim
      *         An {@link Observable} which produces connected non-overlapping windows which are emitted after
      *         a fixed duration or when the window has reached maximum capacity (which ever occurs first).
      */
-    public Observable<Observable<T>> window(Observable<T> source, long timespan, TimeUnit unit, int count, Scheduler scheduler) {
+    public Observable<Observable<T>> window(Observable<? extends T> source, long timespan, TimeUnit unit, int count, Scheduler scheduler) {
         return create(OperationWindow.window(source, timespan, unit, count, scheduler));
     }
 
@@ -1689,7 +1689,7 @@ public Observable<Observable<T>> window(Observable<T> source, long timespan, Tim
      *         An {@link Observable} which produces new windows periodically, and these are emitted after
      *         a fixed timespan has elapsed.
      */
-    public Observable<Observable<T>> window(Observable<T> source, long timespan, long timeshift, TimeUnit unit) {
+    public Observable<Observable<T>> window(Observable<? extends T> source, long timespan, long timeshift, TimeUnit unit) {
         return create(OperationWindow.window(source, timespan, timeshift, unit));
     }
 
@@ -1713,7 +1713,7 @@ public Observable<Observable<T>> window(Observable<T> source, long timespan, lon
      *         An {@link Observable} which produces new windows periodically, and these are emitted after
      *         a fixed timespan has elapsed.
      */
-    public Observable<Observable<T>> window(Observable<T> source, long timespan, long timeshift, TimeUnit unit, Scheduler scheduler) {
+    public Observable<Observable<T>> window(Observable<? extends T> source, long timespan, long timeshift, TimeUnit unit, Scheduler scheduler) {
         return create(OperationWindow.window(source, timespan, timeshift, unit, scheduler));
     }
 
diff --git a/rxjava-core/src/main/java/rx/operators/ChunkedOperation.java b/rxjava-core/src/main/java/rx/operators/ChunkedOperation.java
index f0990425bb..1b5cf8d0d1 100644
--- a/rxjava-core/src/main/java/rx/operators/ChunkedOperation.java
+++ b/rxjava-core/src/main/java/rx/operators/ChunkedOperation.java
@@ -495,7 +495,7 @@ protected static class ObservableBasedMultiChunkCreator<T, C> implements ChunkCr
 
         private final SafeObservableSubscription subscription = new SafeObservableSubscription();
 
-        public ObservableBasedMultiChunkCreator(final OverlappingChunks<T, C> chunks, Observable<? extends Opening> openings, final Func1<? super Opening, ? extends Observable<? extends Closing>> chunkClosingSelector) {
+        public ObservableBasedMultiChunkCreator(final OverlappingChunks<T, C> chunks, Observable<? extends Opening> openings, final Func1<Opening, ? extends Observable<? extends Closing>> chunkClosingSelector) {
             subscription.wrap(openings.subscribe(new Action1<Opening>() {
                 @Override
                 public void call(Opening opening) {
diff --git a/rxjava-core/src/main/java/rx/operators/OperationBuffer.java b/rxjava-core/src/main/java/rx/operators/OperationBuffer.java
index c692ed6cee..1cc559fb57 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationBuffer.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationBuffer.java
@@ -42,12 +42,14 @@
 
 public final class OperationBuffer extends ChunkedOperation {
 
-    private static final Func0 BUFFER_MAKER = new Func0() {
-        @Override
-        public Object call() {
-            return new Buffer();
-        }
-    };
+    private static <T> Func0<Buffer<T>> bufferMaker() {
+        return new Func0<Buffer<T>>() {
+            @Override
+            public Buffer<T> call() {
+                return new Buffer<T>();
+            }
+        };
+    }
 
     /**
      * <p>This method creates a {@link Func1} object which represents the buffer operation. This operation takes
@@ -74,7 +76,7 @@ public static <T> OnSubscribeFunc<List<T>> buffer(final Observable<T> source, fi
 
             @Override
             public Subscription onSubscribe(Observer<? super List<T>> observer) {
-                NonOverlappingChunks<T, List<T>> buffers = new NonOverlappingChunks<T, List<T>>(observer, BUFFER_MAKER);
+                NonOverlappingChunks<T, List<T>> buffers = new NonOverlappingChunks<T, List<T>>(observer, OperationBuffer.<T>bufferMaker());
                 ChunkCreator creator = new ObservableBasedSingleChunkCreator<T, List<T>>(buffers, bufferClosingSelector);
                 return source.subscribe(new ChunkObserver<T, List<T>>(buffers, observer, creator));
             }
@@ -106,11 +108,11 @@ public Subscription onSubscribe(Observer<? super List<T>> observer) {
      * @return
      *         the {@link Func1} object representing the specified buffer operation.
      */
-    public static <T> OnSubscribeFunc<List<T>> buffer(final Observable<T> source, final Observable<? extends Opening> bufferOpenings, final Func1<? super Opening, ? extends Observable<? extends Closing>> bufferClosingSelector) {
+    public static <T> OnSubscribeFunc<List<T>> buffer(final Observable<T> source, final Observable<? extends Opening> bufferOpenings, final Func1<Opening, ? extends Observable<? extends Closing>> bufferClosingSelector) {
         return new OnSubscribeFunc<List<T>>() {
             @Override
             public Subscription onSubscribe(final Observer<? super List<T>> observer) {
-                OverlappingChunks<T, List<T>> buffers = new OverlappingChunks<T, List<T>>(observer, BUFFER_MAKER);
+                OverlappingChunks<T, List<T>> buffers = new OverlappingChunks<T, List<T>>(observer, OperationBuffer.<T>bufferMaker());
                 ChunkCreator creator = new ObservableBasedMultiChunkCreator<T, List<T>>(buffers, bufferOpenings, bufferClosingSelector);
                 return source.subscribe(new ChunkObserver<T, List<T>>(buffers, observer, creator));
             }
@@ -165,7 +167,7 @@ public static <T> OnSubscribeFunc<List<T>> buffer(final Observable<T> source, fi
         return new OnSubscribeFunc<List<T>>() {
             @Override
             public Subscription onSubscribe(final Observer<? super List<T>> observer) {
-                Chunks<T, List<T>> chunks = new SizeBasedChunks<T, List<T>>(observer, BUFFER_MAKER, count);
+                Chunks<T, List<T>> chunks = new SizeBasedChunks<T, List<T>>(observer, OperationBuffer.<T>bufferMaker(), count);
                 ChunkCreator creator = new SkippingChunkCreator<T, List<T>>(chunks, skip);
                 return source.subscribe(new ChunkObserver<T, List<T>>(chunks, observer, creator));
             }
@@ -220,7 +222,7 @@ public static <T> OnSubscribeFunc<List<T>> buffer(final Observable<T> source, fi
         return new OnSubscribeFunc<List<T>>() {
             @Override
             public Subscription onSubscribe(final Observer<? super List<T>> observer) {
-                NonOverlappingChunks<T, List<T>> buffers = new NonOverlappingChunks<T, List<T>>(observer, BUFFER_MAKER);
+                NonOverlappingChunks<T, List<T>> buffers = new NonOverlappingChunks<T, List<T>>(observer, OperationBuffer.<T>bufferMaker());
                 ChunkCreator creator = new TimeBasedChunkCreator<T, List<T>>(buffers, timespan, unit, scheduler);
                 return source.subscribe(new ChunkObserver<T, List<T>>(buffers, observer, creator));
             }
@@ -281,7 +283,7 @@ public static <T> OnSubscribeFunc<List<T>> buffer(final Observable<T> source, fi
         return new OnSubscribeFunc<List<T>>() {
             @Override
             public Subscription onSubscribe(final Observer<? super List<T>> observer) {
-                Chunks<T, List<T>> chunks = new TimeAndSizeBasedChunks<T, List<T>>(observer, BUFFER_MAKER, count, timespan, unit, scheduler);
+                Chunks<T, List<T>> chunks = new TimeAndSizeBasedChunks<T, List<T>>(observer, OperationBuffer.<T>bufferMaker(), count, timespan, unit, scheduler);
                 ChunkCreator creator = new SingleChunkCreator<T, List<T>>(chunks);
                 return source.subscribe(new ChunkObserver<T, List<T>>(chunks, observer, creator));
             }
@@ -342,7 +344,7 @@ public static <T> OnSubscribeFunc<List<T>> buffer(final Observable<T> source, fi
         return new OnSubscribeFunc<List<T>>() {
             @Override
             public Subscription onSubscribe(final Observer<? super List<T>> observer) {
-                OverlappingChunks<T, List<T>> buffers = new TimeBasedChunks<T, List<T>>(observer, BUFFER_MAKER, timespan, unit, scheduler);
+                OverlappingChunks<T, List<T>> buffers = new TimeBasedChunks<T, List<T>>(observer, OperationBuffer.<T>bufferMaker(), timespan, unit, scheduler);
                 ChunkCreator creator = new TimeBasedChunkCreator<T, List<T>>(buffers, timeshift, unit, scheduler);
                 return source.subscribe(new ChunkObserver<T, List<T>>(buffers, observer, creator));
             }
diff --git a/rxjava-core/src/main/java/rx/operators/OperationWindow.java b/rxjava-core/src/main/java/rx/operators/OperationWindow.java
index ab15ed2352..5cffda9661 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationWindow.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationWindow.java
@@ -72,7 +72,7 @@ public Window<T> call() {
      * @return
      *         the {@link rx.util.functions.Func1} object representing the specified window operation.
      */
-    public static <T> OnSubscribeFunc<Observable<T>> window(final Observable<T> source, final Func0<Observable<Closing>> windowClosingSelector) {
+    public static <T> OnSubscribeFunc<Observable<T>> window(final Observable<? extends T> source, final Func0<? extends Observable<? extends Closing>> windowClosingSelector) {
         return new OnSubscribeFunc<Observable<T>>() {
             @Override
             public Subscription onSubscribe(final Observer<? super Observable<T>> observer) {
@@ -109,7 +109,7 @@ public Subscription onSubscribe(final Observer<? super Observable<T>> observer)
      * @return
      *         the {@link rx.util.functions.Func1} object representing the specified window operation.
      */
-    public static <T> OnSubscribeFunc<Observable<T>> window(final Observable<T> source, final Observable<Opening> windowOpenings, final Func1<Opening, Observable<Closing>> windowClosingSelector) {
+    public static <T> OnSubscribeFunc<Observable<T>> window(final Observable<? extends T> source, final Observable<? extends Opening> windowOpenings, final Func1<Opening, ? extends Observable<? extends Closing>> windowClosingSelector) {
         return new OnSubscribeFunc<Observable<T>>() {
             @Override
             public Subscription onSubscribe(final Observer<? super Observable<T>> observer) {
@@ -137,7 +137,7 @@ public Subscription onSubscribe(final Observer<? super Observable<T>> observer)
      * @return
      *         the {@link rx.util.functions.Func1} object representing the specified window operation.
      */
-    public static <T> OnSubscribeFunc<Observable<T>> window(Observable<T> source, int count) {
+    public static <T> OnSubscribeFunc<Observable<T>> window(Observable<? extends T> source, int count) {
         return window(source, count, count);
     }
 
@@ -164,7 +164,7 @@ public static <T> OnSubscribeFunc<Observable<T>> window(Observable<T> source, in
      * @return
      *         the {@link rx.util.functions.Func1} object representing the specified window operation.
      */
-    public static <T> OnSubscribeFunc<Observable<T>> window(final Observable<T> source, final int count, final int skip) {
+    public static <T> OnSubscribeFunc<Observable<T>> window(final Observable<? extends T> source, final int count, final int skip) {
         return new OnSubscribeFunc<Observable<T>>() {
             @Override
             public Subscription onSubscribe(final Observer<? super Observable<T>> observer) {
@@ -194,7 +194,7 @@ public Subscription onSubscribe(final Observer<? super Observable<T>> observer)
      * @return
      *         the {@link rx.util.functions.Func1} object representing the specified window operation.
      */
-    public static <T> OnSubscribeFunc<Observable<T>> window(Observable<T> source, long timespan, TimeUnit unit) {
+    public static <T> OnSubscribeFunc<Observable<T>> window(Observable<? extends T> source, long timespan, TimeUnit unit) {
         return window(source, timespan, unit, Schedulers.threadPoolForComputation());
     }
 
@@ -219,7 +219,7 @@ public static <T> OnSubscribeFunc<Observable<T>> window(Observable<T> source, lo
      * @return
      *         the {@link rx.util.functions.Func1} object representing the specified window operation.
      */
-    public static <T> OnSubscribeFunc<Observable<T>> window(final Observable<T> source, final long timespan, final TimeUnit unit, final Scheduler scheduler) {
+    public static <T> OnSubscribeFunc<Observable<T>> window(final Observable<? extends T> source, final long timespan, final TimeUnit unit, final Scheduler scheduler) {
         return new OnSubscribeFunc<Observable<T>>() {
             @Override
             public Subscription onSubscribe(final Observer<? super Observable<T>> observer) {
@@ -252,7 +252,7 @@ public Subscription onSubscribe(final Observer<? super Observable<T>> observer)
      * @return
      *         the {@link rx.util.functions.Func1} object representing the specified window operation.
      */
-    public static <T> OnSubscribeFunc<Observable<T>> window(Observable<T> source, long timespan, TimeUnit unit, int count) {
+    public static <T> OnSubscribeFunc<Observable<T>> window(Observable<? extends T> source, long timespan, TimeUnit unit, int count) {
         return window(source, timespan, unit, count, Schedulers.threadPoolForComputation());
     }
 
@@ -280,7 +280,7 @@ public static <T> OnSubscribeFunc<Observable<T>> window(Observable<T> source, lo
      * @return
      *         the {@link rx.util.functions.Func1} object representing the specified window operation.
      */
-    public static <T> OnSubscribeFunc<Observable<T>> window(final Observable<T> source, final long timespan, final TimeUnit unit, final int count, final Scheduler scheduler) {
+    public static <T> OnSubscribeFunc<Observable<T>> window(final Observable<? extends T> source, final long timespan, final TimeUnit unit, final int count, final Scheduler scheduler) {
         return new OnSubscribeFunc<Observable<T>>() {
             @Override
             public Subscription onSubscribe(final Observer<? super Observable<T>> observer) {
@@ -313,7 +313,7 @@ public Subscription onSubscribe(final Observer<? super Observable<T>> observer)
      * @return
      *         the {@link rx.util.functions.Func1} object representing the specified window operation.
      */
-    public static <T> OnSubscribeFunc<Observable<T>> window(Observable<T> source, long timespan, long timeshift, TimeUnit unit) {
+    public static <T> OnSubscribeFunc<Observable<T>> window(Observable<? extends T> source, long timespan, long timeshift, TimeUnit unit) {
         return window(source, timespan, timeshift, unit, Schedulers.threadPoolForComputation());
     }
 
@@ -341,7 +341,7 @@ public static <T> OnSubscribeFunc<Observable<T>> window(Observable<T> source, lo
      * @return
      *         the {@link rx.util.functions.Func1} object representing the specified window operation.
      */
-    public static <T> OnSubscribeFunc<Observable<T>> window(final Observable<T> source, final long timespan, final long timeshift, final TimeUnit unit, final Scheduler scheduler) {
+    public static <T> OnSubscribeFunc<Observable<T>> window(final Observable<? extends T> source, final long timespan, final long timeshift, final TimeUnit unit, final Scheduler scheduler) {
         return new OnSubscribeFunc<Observable<T>>() {
             @Override
             public Subscription onSubscribe(final Observer<? super Observable<T>> observer) {