fix(filter): consecutive filtering respects original order

When using muliple filter() operators consecutively, their respective passes() functions should be
called in the same order as they were declared and composed, not in reverse order.

Closes issue #85.

src/core.ts

@@ -1537,7 +1537,7 @@ export class Stream<T> implements InternalListener<T> {
     const p = this._prod;
     if (p instanceof FilterOperator) {
       return new Stream<T>(new FilterOperator(
-        and(passes, (<FilterOperator<T>> p).passes),
+        and((<FilterOperator<T>> p).passes, passes),
         (<FilterOperator<T>> p).ins
       ));
     }

tests/operator/filter.ts

@@ -101,6 +101,33 @@ describe('Stream.prototype.filter', () => {
     done();
   });
 
+  it('should call functions in correct order for filter+filter fusion', (done) => {
+    const object$ = xs.of<any>(
+      { foo: { a: 10 } },
+      { foo: { bar: { b: 20 } } },
+      { foo: true }
+    );
+
+    const filtered$ = object$
+      .filter(val => val.foo)
+      .filter(val => val.foo.bar)
+      .filter(val => val.foo.bar.b === 20)
+      .map(x => JSON.stringify(x));
+
+    const expected = ['{"foo":{"bar":{"b":20}}}'];
+
+    filtered$.addListener({
+      next(x: string) {
+        assert.strictEqual(x, expected.shift());
+      },
+      error: (err: any) => done(err),
+      complete() {
+        assert.strictEqual(expected.length, 0);
+        done();
+      }
+    });
+  });
+
   it('should return a Stream if input stream is a Stream', (done) => {
     const input = xs.of<number>(1, 2, 3);
     assert.strictEqual(input instanceof Stream, true);