Merge pull request #15 from gossie/feature/issue#14_new-operators

resolved #14

README.md

@@ -66,6 +66,33 @@ Some works similar to the `first`-operator except that not the element is return
 `every` also applies the passed function to each element. As soon as one element does not evaluate to `true` the pipe immediately returns `false`. 
 * __none__<br />
 `none` also applies the passed function to each element. As soon as one element evaluates to `true` the pipe immediately returns `false`. 
+* __reduceToSome__<br />
+Checks if there are two consecutive elements that fullfill the constraint passed. If a pair is found `true` is returned immediately.
+```typescript
+const result: boolean = [1, 2, 4, 5]
+    .pipe(
+        reduceToSome((n1: number, n2: number) => (n1+n2)%2 === 0)
+    )
+```
+`result` would be `true` because `(2+4)%2 === 0` is `true`. The pair of 4 and 5 would not be checked.
+* __reduceToEvery__<br />
+Checks if every two consecutive elements fullfill the constraint passed. If a pair is found that does not, `false` is returned immediately.
+```typescript
+const result: boolean = [1, 3, 4, 6]
+    .pipe(
+        reduceToEvery((n1: number, n2: number) => (n1+n2)%2 === 0)
+    )
+```
+`result` would be `false` because `(3+4)%2 === 0` is `false`. The pair of 4 and 6 would not be checked.
+* __reduceToNone__<br />
+Checks if no two consecutive elements fullfill the constraint passed. If a pair is found that does, `false` is returned immediately.
+```typescript
+const result: boolean = [1, 2, 4, 5]
+    .pipe(
+        reduceToNone((n1: number, n2: number) => (n1+n2)%2 === 0)
+    )
+```
+`result` would be `false` because `(2+4)%2 === 0` is `true`. The pair of 4 and 5 would not be checked.
 
 <a name="customoperator"></a>
 ## Write your own operator

src/distinct.spec.ts → __test__/distinct.spec.ts

@@ -1,4 +1,4 @@
-import { Operator, distinct } from './operators';
+import { Operator, distinct } from '../src/operators';
 
 describe('distinct', () => {
 

__test__/every-reduce.spec.ts

@@ -0,0 +1,41 @@
+import { Operator, TerminalOperator, reduceToEvery } from '../src/operators';
+
+describe('everyReduce', () => {
+
+    it('should be terminal', () => {
+        const operator: Operator<number, boolean> = reduceToEvery((n1: number, n2: number) => (n1+n2)%2 === 0);
+        expect(operator.isTerminal()).toBeTruthy();
+    });
+
+    it('should have fallback value', () => {
+        const operator: TerminalOperator<number, boolean> = reduceToEvery((n1: number, n2: number) => (n1+n2)%2 === 0);
+        expect(operator.getFallbackValue()).toBeTruthy();
+    });
+
+    it('should match criteria', () => {
+        const operator: Operator<number, boolean> = reduceToEvery((n1: number, n2: number) => (n1+n2)%2 === 0);
+        expect(operator.perform(1)).toEqual({
+            value: true,
+            done: false
+        });
+
+        expect(operator.perform(3)).toEqual({
+            value: true,
+            done: false
+        });
+    });
+
+    it('should not match criteria', () => {
+        const operator: Operator<number, boolean> = reduceToEvery((n1: number, n2: number) => (n1+n2)%2 === 0);
+        expect(operator.perform(1)).toEqual({
+            value: true,
+            done: false
+        });
+
+        expect(operator.perform(4)).toEqual({
+            value: false,
+            done: true
+        });
+    });
+
+});

src/every.spec.ts → __test__/every.spec.ts

@@ -1,4 +1,4 @@
-import { Operator, TerminalOperator, every } from "./operators";
+import { Operator, TerminalOperator, every } from "../src/operators";
 
 describe('every', () => {
 

src/filter.spec.ts → __test__/filter.spec.ts

@@ -1,4 +1,4 @@
-import { Operator, filter } from './operators';
+import { Operator, filter } from '../src/operators';
 
 describe('filter', () => {
 

src/find.spec.ts → __test__/find.spec.ts

@@ -1,4 +1,4 @@
-import { Operator, TerminalOperator, find } from './operators';
+import { Operator, TerminalOperator, find } from '../src/operators';
 
 describe('find', () => {
 

src/flat-map.spec.ts → __test__/flat-map.spec.ts

@@ -1,4 +1,4 @@
-import { IntermediateOperator, flatMap } from './operators';
+import { IntermediateOperator, flatMap } from '../src/operators';
 
 describe('flatMap', () => {
 

src/index-no-overwrite.spec.ts → __test__/index-no-overwrite.spec.ts

@@ -1,5 +1,5 @@
 import './polyfill.mock';
-import './index';
+import '../src/index';
 
 describe('pipe already exists', () => {
     it('should not override pipe when already set', () => {

src/index.spec.ts → __test__/index.spec.ts

@@ -1,5 +1,5 @@
-import './index';
-import { filter, map, flatMap, distinct, find, some, every, none } from './operators';
+import '../src/index';
+import { filter, map, flatMap, distinct, find, some, every, none, reduceToEvery, reduceToSome, reduceToNone } from '../src/operators';
 
 describe('pipe', () => {
 
@@ -32,7 +32,7 @@ describe('pipe', () => {
         });
 
         it('should filter', () => {
-            const result: Array<string> = [0, 1, 1, 2, 3, 4, 2, 5, 6, 7, 2, 8, 9]
+            const result: Array<number> = [0, 1, 1, 2, 3, 4, 2, 5, 6, 7, 2, 8, 9]
                 .pipe(
                     filter((n: number) => n%2 == 0)
                 );
@@ -72,7 +72,7 @@ describe('pipe', () => {
         });
 
         it('should pipe and return true because some elements match criteria', () => {
-            const result: number = ['1', '2', '3', '4', '5', '6', '7', '8', '9']
+            const result: boolean = ['1', '2', '3', '4', '5', '6', '7', '8', '9']
                 .pipe(
                     map((n: string) => parseInt(n)),
                     some((n: number) => n > 5 && n < 10)
@@ -82,7 +82,7 @@ describe('pipe', () => {
         });
 
         it('should pipe and return false because no element matches criteria', () => {
-            const result: number = ['1', '2', '3', '4', '5', '6', '7', '8', '9']
+            const result: boolean = ['1', '2', '3', '4', '5', '6', '7', '8', '9']
                 .pipe(
                     map((n: string) => parseInt(n)),
                     some((n: number) => n >= 10)
@@ -92,7 +92,7 @@ describe('pipe', () => {
         });
 
         it('should pipe and return true because all elements match criteria', () => {
-            const result: number = ['2', '4', '6', '8', '10', '12', '14', '16', '18', '20']
+            const result: boolean = ['2', '4', '6', '8', '10', '12', '14', '16', '18', '20']
                 .pipe(
                     map((n: string) => parseInt(n)),
                     every((n: number) => n%2 === 0)
@@ -102,7 +102,7 @@ describe('pipe', () => {
         });
 
         it('should pipe and return false because not all elements match criteria', () => {
-            const result: number = ['2', '4', '6', '8', '11', '12', '14', '16', '18', '20']
+            const result: boolean = ['2', '4', '6', '8', '11', '12', '14', '16', '18', '20']
                 .pipe(
                     map((n: string) => parseInt(n)),
                     every((n: number) => n%2 === 0)
@@ -112,7 +112,7 @@ describe('pipe', () => {
         });
 
         it('should pipe and return true because all elements do not match criteria', () => {
-            const result: number = ['3', '5', '7', '9', '11', '13', '15', '17', '19', '21']
+            const result: boolean = ['3', '5', '7', '9', '11', '13', '15', '17', '19', '21']
                 .pipe(
                     map((n: string) => parseInt(n)),
                     none((n: number) => n%2 === 0)
@@ -122,7 +122,7 @@ describe('pipe', () => {
         });
 
         it('should pipe and return false because not all elements match criteria', () => {
-            const result: number = ['3', '5', '7', '9', '12', '13', '15', '17', '19', '21']
+            const result: boolean = ['3', '5', '7', '9', '12', '13', '15', '17', '19', '21']
                 .pipe(
                     map((n: string) => parseInt(n)),
                     none((n: number) => n%2 === 0)
@@ -151,7 +151,7 @@ describe('pipe', () => {
 
         describe('flatMap', () => {
             it('should pipe with flatMap as last operator', () => {
-                const result: number = ['1', '3', '5', '7', '9']
+                const result: Array<number> = ['1', '3', '5', '7', '9']
                     .pipe(
                         map((s: string) => parseInt(s)),
                         flatMap((n: number) => [n, n+1])
@@ -161,7 +161,7 @@ describe('pipe', () => {
             });
 
             it('should pipe with flatMap as intermediate operator', () => {
-                const result: number = ['1', '3', '5', '7', '9']
+                const result: Array<number> = ['1', '3', '5', '7', '9']
                     .pipe(
                         map((s: string) => parseInt(s)),
                         flatMap((n: number) => [n, n+1]),
@@ -184,7 +184,7 @@ describe('pipe', () => {
             });
 
             it('should pipe with flatMap as intermediate operator and filter in the end', () => {
-                const result: boolean = ['1', '3', '5', '7', '9']
+                const result: Array<number> = ['1', '3', '5', '7', '9']
                     .pipe(
                         map((s: string) => parseInt(s)),
                         flatMap((n: number) => [n, n+1]),
@@ -196,6 +196,70 @@ describe('pipe', () => {
 
         });
 
+        describe('reducer', () => {
+
+            it('should successfully reduce to every', () => {
+                const result: boolean = ['1', '3', '5', '7', '9']
+                    .pipe(
+                        map((s: string) => parseInt(s)),
+                        reduceToEvery((n1: number, n2: number) => (n1+n2)%2 === 0)
+                    );
+
+                expect(result).toBeTruthy();
+            });
+
+            it('should fail to reduce to every', () => {
+                const result: boolean = ['1', '3', '5', '6', '9']
+                    .pipe(
+                        map((s: string) => parseInt(s)),
+                        reduceToEvery((n1: number, n2: number) => (n1+n2)%2 === 0)
+                    );
+
+                expect(result).toBeFalsy();
+            });
+
+            it('should successfully reduce to some', () => {
+                const result: boolean = ['1', '2', '5', '7', '9']
+                    .pipe(
+                        map((s: string) => parseInt(s)),
+                        reduceToSome((n1: number, n2: number) => (n1+n2)%2 === 0)
+                    );
+
+                expect(result).toBeTruthy();
+            });
+
+            it('should fail to reduce to some', () => {
+                const result: boolean = ['1', '2', '5', '6', '9']
+                    .pipe(
+                        map((s: string) => parseInt(s)),
+                        reduceToSome((n1: number, n2: number) => (n1+n2)%2 === 0)
+                    );
+
+                expect(result).toBeFalsy();
+            });
+
+            it('should successfully reduce to none', () => {
+                const result: boolean = ['1', '2', '5', '6', '9']
+                    .pipe(
+                        map((s: string) => parseInt(s)),
+                        reduceToNone((n1: number, n2: number) => (n1+n2)%2 === 0)
+                    );
+
+                expect(result).toBeTruthy();
+            });
+
+            it('should fail to reduce to none', () => {
+                const result: boolean = ['1', '2', '5', '7', '9']
+                    .pipe(
+                        map((s: string) => parseInt(s)),
+                        reduceToNone((n1: number, n2: number) => (n1+n2)%2 === 0)
+                    );
+
+                expect(result).toBeFalsy();
+            });
+
+        })
+
     });
 
 })

src/map.spec.ts → __test__/map.spec.ts

@@ -1,4 +1,4 @@
-import { Operator, map } from './operators';
+import { Operator, map } from '../src/operators';
 
 describe('map', () => {
 

__test__/none-reduce.spec.ts

@@ -0,0 +1,45 @@
+import { Operator, TerminalOperator, reduceToNone } from '../src/operators';
+
+describe('someReduce', () => {
+
+    it('should be terminal', () => {
+        const operator: Operator<number, boolean> = reduceToNone((n1: number, n2: number) => (n1+n2)%2 === 0);
+        expect(operator.isTerminal()).toBeTruthy();
+    });
+
+    it('should have fallback value', () => {
+        const operator: TerminalOperator<number, boolean> = reduceToNone((n1: number, n2: number) => (n1+n2)%2 === 0);
+        expect(operator.getFallbackValue()).toBeTruthy();
+    });
+
+    it('should match criteria', () => {
+        const operator: Operator<number, boolean> = reduceToNone((n1: number, n2: number) => (n1+n2)%2 === 0);
+        expect(operator.perform(1)).toEqual({
+            value: true,
+            done: false
+        });
+
+        expect(operator.perform(3)).toEqual({
+            value: false,
+            done: true
+        });
+    });
+
+    it('should not match criteria', () => {
+        interface Item {
+            value: number;
+        }
+
+        const operator: Operator<Item, boolean> = reduceToNone((n1: Item, n2: Item) => (n1.value+n2.value)%2 === 0);
+        expect(operator.perform({value: 1})).toEqual({
+            value: true,
+            done: false
+        });
+
+        expect(operator.perform({value: 4})).toEqual({
+            value: true,
+            done: false
+        });
+    });
+
+});

src/none.spec.ts → __test__/none.spec.ts

@@ -1,4 +1,4 @@
-import { TerminalOperator, none } from './operators';
+import { TerminalOperator, none } from '../src/operators';
 
 describe('none', () => {
 

__test__/some-reduce.spec.ts

@@ -0,0 +1,45 @@
+import { Operator, TerminalOperator, reduceToSome } from '../src/operators';
+
+describe('someReduce', () => {
+
+    it('should be terminal', () => {
+        const operator: Operator<number, boolean> = reduceToSome((n1: number, n2: number) => (n1+n2)%2 === 0);
+        expect(operator.isTerminal()).toBeTruthy();
+    });
+
+    it('should have fallback value', () => {
+        const operator: TerminalOperator<number, boolean> = reduceToSome((n1: number, n2: number) => (n1+n2)%2 === 0);
+        expect(operator.getFallbackValue()).toBe(false)
+    });
+
+    it('should match criteria', () => {
+        const operator: Operator<number, boolean> = reduceToSome((n1: number, n2: number) => (n1+n2)%2 === 0);
+        expect(operator.perform(1)).toEqual({
+            value: false,
+            done: false
+        });
+
+        expect(operator.perform(3)).toEqual({
+            value: true,
+            done: true
+        });
+    });
+
+    it('should not match criteria', () => {
+        interface Item {
+            value: number;
+        }
+
+        const operator: Operator<Item, boolean> = reduceToSome((n1: Item, n2: Item) => (n1.value+n2.value)%2 === 0);
+        expect(operator.perform({value: 1})).toEqual({
+            value: false,
+            done: false
+        });
+
+        expect(operator.perform({value: 4})).toEqual({
+            value: false,
+            done: false
+        });
+    });
+
+});

src/some.spec.ts → __test__/some.spec.ts

@@ -1,4 +1,4 @@
-import { Operator, TerminalOperator, some } from './operators';
+import { Operator, TerminalOperator, some } from '../src/operators';
 
 describe('some', () => {