Fixed a typo, added missing error and completion handling

Author: jmhofer

rxjava-core/src/main/java/rx/operators/OperationScan.java

@@ -26,6 +26,7 @@
 import rx.Observer;
 import rx.Subscription;
 import rx.util.AtomicObservableSubscription;
+import rx.util.functions.Action0;
 import rx.util.functions.Action1;
 import rx.util.functions.Func1;
 import rx.util.functions.Func2;
@@ -65,12 +66,12 @@ public static <T> Func1<Observer<T>, Subscription> scan(Observable<T> sequence,
 
     private static class AccuWithoutInitialValue<T> implements Func1<Observer<T>, Subscription> {
         private final Observable<T> sequence;
-        private final Func2<T, T, T> accumlatorFunction;
+        private final Func2<T, T, T> accumulatorFunction;
         private T initialValue;
 
         private AccuWithoutInitialValue(Observable<T> sequence, Func2<T, T, T> accumulator) {
             this.sequence = sequence;
-            this.accumlatorFunction = accumulator;
+            this.accumulatorFunction = accumulator;
         }
 
         @Override
@@ -80,22 +81,32 @@ public Subscription call(final Observer<T> observer) {
                 public void call(T value) {
                     initialValue = value;
                 }
+            }, new Action1<Exception>() {
+                @Override
+                public void call(Exception e) {
+                    observer.onError(e);
+                }
+            }, new Action0() {
+                @Override
+                public void call() {
+                    observer.onCompleted();
+                }
             });
-            Accumulator<T, T> scan = new Accumulator<T, T>(sequence.skip(1), initialValue, accumlatorFunction);
+            Accumulator<T, T> scan = new Accumulator<T, T>(sequence.skip(1), initialValue, accumulatorFunction);
             return scan.call(observer);
         }
     }
 
     private static class Accumulator<T, R> implements Func1<Observer<R>, Subscription> {
         private final Observable<T> sequence;
         private final R initialValue;
-        private final Func2<R, T, R> accumlatorFunction;
+        private final Func2<R, T, R> accumulatorFunction;
         private final AtomicObservableSubscription subscription = new AtomicObservableSubscription();
 
         private Accumulator(Observable<T> sequence, R initialValue, Func2<R, T, R> accumulator) {
             this.sequence = sequence;
             this.initialValue = initialValue;
-            this.accumlatorFunction = accumulator;
+            this.accumulatorFunction = accumulator;
         }
 
         @Override
@@ -115,7 +126,7 @@ public Subscription call(final Observer<R> observer) {
                 @Override
                 public synchronized void onNext(T value) {
                     try {
-                        acc = accumlatorFunction.call(acc, value);
+                        acc = accumulatorFunction.call(acc, value);
                         observer.onNext(acc);
                     } catch (Exception ex) {
                         observer.onError(ex);