feat(startWith): implement startWith operator

Add implementation for startWith
Fix this.proxy compiler error in RememberOperator

src/Stream.ts

@@ -8,6 +8,7 @@ import {DebugOperator} from './operator/DebugOperator';
 import {FoldOperator} from './operator/FoldOperator';
 import {LastOperator} from './operator/LastOperator';
 import {RememberOperator} from './operator/RememberOperator';
+import {StartWithOperator} from './operator/StartWithOperator';
 import {
   CombineProducer,
   CombineInstanceSignature,
@@ -92,10 +93,6 @@ export class Stream<T> implements Observer<T> {
       return new Stream<R>(new CombineProducer<R>(project, streams));
     };
 
-  static Stream<T>(): Stream<T> {
-    return new Stream<T>({start: noop, stop: noop});
-  }
-
   static MemoryStream<T>(): MemoryStream<T> {
     return new MemoryStream<T>({start: noop, stop: noop});
   }
@@ -150,6 +147,10 @@ export class Stream<T> implements Observer<T> {
     return new MemoryStream<T>(new RememberOperator(this));
   }
 
+  startWith(x: T): Stream<T> {
+    return new Stream<T>(new StartWithOperator(this, x));
+  }
+
   merge(other: Stream<T>): Stream<T> {
     return Stream.merge(this, other);
   }

src/operator/RememberOperator.ts

@@ -1,17 +1,20 @@
-import {Operator} from '../Operator';
 import {Stream, MemoryStream} from '../Stream';
+import {Operator} from '../Operator';
+import {Observer} from '../Observer';
+import {emptyObserver} from '../utils/emptyObserver';
 
 export class RememberOperator<T> implements Operator<T, T> {
-  public value: any;
+  public out: Observer<T> = emptyObserver;
 
   constructor(public ins: Stream<T>) {
   }
 
   start(out: MemoryStream<T>): void {
+    this.out = out;
     this.ins.subscribe(out);
   }
 
   stop(): void {
-    this.ins.unsubscribe(this.proxy);
+    this.ins.unsubscribe(this.out);
   }
 }

src/operator/StartWithOperator.ts

@@ -0,0 +1,20 @@
+import {Stream} from '../Stream';
+import {Observer} from '../Observer';
+import {Operator} from '../Operator';
+import {emptyObserver} from '../utils/emptyObserver';
+
+export class StartWithOperator<T> implements Operator<T, T> {
+  public out: Observer<T> = emptyObserver;
+  constructor(public ins: Stream<T>, public value: T) {
+  }
+
+  start(out: Observer<T>): void {
+    this.out = out;
+    this.out.next(this.value);
+    this.ins.subscribe(out);
+  }
+
+  stop(): void {
+    this.ins.unsubscribe(this.out);
+  }
+}