Merge pull request #15 from ilteoood/feat/sum

Feat/sum

README.md

@@ -270,7 +270,9 @@ fromRange(1, 3)
 ```javascript
 import { greaterThan } from '@ilteoood/re-flusso/numbers/greaterThan';
 
-greaterThan(3)
+.pipeThrough(
+    greaterThan(3)
+)
 ```
 </details>
 <details>
@@ -279,7 +281,9 @@ greaterThan(3)
 ```javascript
 import { greaterThanEqual } from '@ilteoood/re-flusso/numbers/greaterThanEqual';
 
-greaterThanEqual(3)
+.pipeThrough(
+    greaterThanEqual(3)
+)
 ```
 </details>
 <details>
@@ -288,7 +292,21 @@ greaterThanEqual(3)
 ```javascript
 import { lessThan } from '@ilteoood/re-flusso/numbers/lessThan';
 
-lessThan(3)
+.pipeThrough(
+    lessThan(3)
+)
+```
+</details>
+<details>
+<summary>&nbsp;&nbsp;&nbsp;&nbsp;sum</summary>
+
+```javascript
+import { sum } from '@ilteoood/re-flusso/numbers/sum';
+
+.pipeThrough(
+    sum()
+)
+
 ```
 </details>
 <details>

src/numbers/sum.ts

@@ -0,0 +1,13 @@
+import { reduce } from "../reduce";
+
+export const sum = (
+	writableStrategy?: QueuingStrategy,
+	readableStrategy?: QueuingStrategy,
+) => {
+	return reduce<number, number>(
+		(accumulator: number, currentValue: number) => accumulator + currentValue,
+		0,
+		writableStrategy,
+		readableStrategy,
+	);
+};

src/reduce.ts

@@ -1,6 +1,6 @@
 export const reduce = <T, A>(
-	reducer: (accumulator: A | undefined, currentValue: T) => A | Promise<A>,
-	initialValue: A | undefined,
+	reducer: (accumulator: A, currentValue: T) => A | Promise<A>,
+	initialValue: A,
 	writableStrategy?: QueuingStrategy,
 	readableStrategy?: QueuingStrategy,
 ) => {

test/numbers/sum.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, test } from "vitest";
+import { fromRange } from "../../src/numbers/fromRange";
+import { pipeline } from "../../src/pipeline";
+import { toArray } from "../../src/toArray";
+import { fromIterable } from "../../src/fromIterable";
+import { sum } from "../../src/numbers/sum";
+
+describe("sum", () => {
+	test("should work with empty list", async () => {
+		const destinationArray = [];
+
+		await pipeline(fromIterable([]), sum(), toArray(destinationArray));
+
+		expect(destinationArray).toEqual([0]);
+	});
+
+	test("should correctly sum numbers", async () => {
+		const destinationArray = [];
+
+		await pipeline(fromRange(1, 3), sum(), toArray(destinationArray));
+
+		expect(destinationArray).toEqual([6]);
+	});
+});