feat: add fx

src/Lazy/index.ts

@@ -15,6 +15,7 @@ import entries from "./entries";
 import filter from "./filter";
 import flat from "./flat";
 import flatMap from "./flatMap";
+import fx from "./fx";
 import intersection from "./intersection";
 import intersectionBy from "./intersectionBy";
 import keys from "./keys";
@@ -60,6 +61,7 @@ export {
   filter,
   flat,
   flatMap,
+  fx,
   intersection,
   intersectionBy,
   keys,

test/Lazy/append.spec.ts

@@ -2,6 +2,7 @@ import {
   append,
   concurrent,
   delay,
+  fx,
   map,
   pipe,
   range,
@@ -25,6 +26,11 @@ describe("append", function () {
       const res = pipe(range(1, 4), append(4), append(5), append(6), toArray);
       expect(res).toEqual([1, 2, 3, 4, 5, 6]);
     });
+
+    it("should be able to be used chaining method with chain in the `fx`", function () {
+      const res = fx(range(1, 4)).chain(append(4)).chain(append(5)).toArray();
+      expect(res).toEqual([1, 2, 3, 4, 5]);
+    });
   });
 
   describe("async", function () {
@@ -42,6 +48,15 @@ describe("append", function () {
       expect(res).toEqual([1, 2, 3, 4]);
     });
 
+    it("should be able to be used chaining method with chain in the `fx`", async function () {
+      const res = await fx(range(1, 4))
+        .toAsync()
+        .chain(append(4))
+        .chain(append(5))
+        .toArray();
+      expect(res).toEqual([1, 2, 3, 4, 5]);
+    });
+
     it("should be appended sequentially", async function () {
       const fn = jest.fn();
       callFuncAfterTime(fn, 3000);

test/Lazy/concurrent.spec.ts

@@ -2,6 +2,7 @@ import {
   concurrent,
   delay,
   filter,
+  fx,
   map,
   peek,
   pipe,
@@ -60,6 +61,18 @@ describe("concurrent", function () {
     expect(arr).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
   }, 550);
 
+  it("should be able to be used as a chaining method in the `fx`", async function () {
+    const fn = jest.fn();
+    callFuncAfterTime(fn, 500);
+
+    const arr = await fx(toAsync(range(1, 11)))
+      .map((a) => delay(100, a))
+      .concurrent(2)
+      .toArray();
+    expect(fn).toBeCalled();
+    expect(arr).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+  }, 550);
+
   it("should be affected only one concurrent below it, when nested concurrent", async function () {
     let fn: jest.Mock<any, any>;
     fn = jest.fn();

test/Lazy/drop.spec.ts

@@ -3,6 +3,7 @@ import {
   delay,
   drop,
   filter,
+  fx,
   map,
   pipe,
   toArray,
@@ -33,6 +34,16 @@ describe("drop", function () {
 
       expect(res).toEqual([16, 18]);
     });
+
+    it("should be able to be used as a chaining method in the `fx`", function () {
+      const res = fx([1, 2, 3, 4, 5, 6, 7, 8])
+        .map((a) => a + 10)
+        .filter((a) => a % 2 === 0)
+        .drop(2)
+        .toArray();
+
+      expect(res).toEqual([16, 18]);
+    });
   });
 
   describe("async", function () {
@@ -60,6 +71,16 @@ describe("drop", function () {
       expect(res).toEqual([16, 18]);
     });
 
+    it("should be able to be used as a chaining method in the `fx`", async function () {
+      const res = await fx(toAsync([1, 2, 3, 4, 5, 6, 7, 8]))
+        .map((a) => a + 10)
+        .filter((a) => a % 2 === 0)
+        .drop(2)
+        .toArray();
+
+      expect(res).toEqual([16, 18]);
+    });
+
     it("should be discarded elements by length concurrently", async function () {
       const fn = jest.fn();
       callFuncAfterTime(fn, 400);

test/Lazy/filter.spec.ts

@@ -3,6 +3,7 @@ import {
   concurrent,
   delay,
   filter,
+  fx,
   map,
   pipe,
   range,
@@ -54,6 +55,14 @@ describe("filter", function () {
 
       expect(res).toEqual([2, 4]);
     });
+
+    it("should be able to be used as a chaining method in the `fx`", function () {
+      const res = fx([1, 2, 3, 4])
+        .filter((a) => a % 2 === 0)
+        .toArray();
+
+      expect(res).toEqual([2, 4]);
+    });
   });
 
   describe("async", function () {
@@ -283,6 +292,14 @@ describe("filter", function () {
       expect(res).toEqual([2, 4]);
     });
 
+    it("should be able to be used as a chaining method in the `fx`", async function () {
+      const res = await fx(toAsync([1, 2, 3, 4]))
+        .filter((a) => a % 2 === 0)
+        .toArray();
+
+      expect(res).toEqual([2, 4]);
+    });
+
     it("should be consumed 'AsyncIterable' as many times as called with 'next'", async function () {
       const fn = jest.fn();
       callFuncAfterTime(fn, 2000);

test/Lazy/flat.spec.ts

@@ -4,6 +4,7 @@ import {
   delay,
   filter,
   flat,
+  fx,
   map,
   pipe,
   range,
@@ -37,6 +38,15 @@ describe("flat", function () {
 
       expect(res).toEqual([11, 12, 13, 14, 15]);
     });
+
+    it("should be able to be used as a chaining method in the `fx`", function () {
+      const res = fx([1, 2, 3, [4, 5]])
+        .flat()
+        .map((a) => a + 10)
+        .toArray();
+
+      expect(res).toEqual([11, 12, 13, 14, 15]);
+    });
   });
 
   describe("async", function () {
@@ -64,6 +74,15 @@ describe("flat", function () {
       expect(res).toEqual([11, 12, 13, 14, 15]);
     });
 
+    it("should be able to be used as a chaining method in the `fx`", async function () {
+      const res = await fx(toAsync([1, 2, 3, [4, 5]]))
+        .flat()
+        .map((a) => a + 10)
+        .toArray();
+
+      expect(res).toEqual([11, 12, 13, 14, 15]);
+    });
+
     it("should be flattened concurrently", async function () {
       const fn = jest.fn();
       callFuncAfterTime(fn, 1000);

test/Lazy/flatMap.spec.ts

@@ -1,4 +1,4 @@
-import { flatMap, map, pipe, toArray, toAsync } from "../../src/index";
+import { flatMap, fx, map, pipe, toArray, toAsync } from "../../src/index";
 import { Concurrent } from "../../src/Lazy/concurrent";
 import { generatorMock } from "../utils";
 
@@ -25,6 +25,15 @@ describe("flatMap", function () {
 
       expect(res).toEqual(["IT", "IS", "A", "GOOD", "DAY"]);
     });
+
+    it("should be able to be used as a chaining method in the `fx`", function () {
+      const res = fx(["It is", "a good", "day"])
+        .flatMap((s) => s.split(" "))
+        .map((a) => a.toUpperCase())
+        .toArray();
+
+      expect(res).toEqual(["IT", "IS", "A", "GOOD", "DAY"]);
+    });
   });
 
   describe("async", function () {
@@ -48,6 +57,15 @@ describe("flatMap", function () {
       expect(res).toEqual(["IT", "IS", "A", "GOOD", "DAY"]);
     });
 
+    it("should be able to be used as a chaining method in the `fx`", async function () {
+      const res = await fx(toAsync(["It is", "a good", "day"]))
+        .flatMap((s) => s.split(" "))
+        .map((a) => a.toUpperCase())
+        .toArray();
+
+      expect(res).toEqual(["IT", "IS", "A", "GOOD", "DAY"]);
+    });
+
     it("should be passed concurrent object when job works concurrently", async function () {
       const mock = generatorMock();
       const iter = flatMap((a) => a, mock);

test/Lazy/fx.spec.ts

@@ -0,0 +1,27 @@
+import { fx, toAsync } from "../../src";
+
+describe("fx", function () {
+  describe("sync", function () {
+    it("handle fx iterable", function () {
+      const res = fx([1, 2, 3, 4, 5])
+        .map((a) => a + 10)
+        .toArray();
+      expect(res).toEqual([11, 12, 13, 14, 15]);
+    });
+  });
+
+  describe("async", () => {
+    it("handle fx asyncIterable", async function () {
+      const res1 = await fx(toAsync([1, 2, 3, 4, 5]))
+        .map(async (a) => a + 10)
+        .toArray();
+      expect(res1).toEqual([11, 12, 13, 14, 15]);
+
+      const res2 = await fx([1, 2, 3, 4, 5])
+        .toAsync()
+        .map(async (a) => a + 10)
+        .toArray();
+      expect(res2).toEqual([11, 12, 13, 14, 15]);
+    });
+  });
+});

test/Lazy/map.spec.ts

@@ -1,5 +1,5 @@
 import { AsyncFunctionException } from "../../src/_internal/error";
-import { map, pipe, range, toArray, toAsync } from "../../src/index";
+import { fx, map, pipe, range, toArray, toAsync } from "../../src/index";
 import { Concurrent } from "../../src/Lazy/concurrent";
 import { generatorMock } from "../utils";
 
@@ -32,6 +32,16 @@ describe("map", function () {
 
       expect(res).toEqual(["1", "2", "3", "4"]);
     });
+
+    it("should be able to be used as a chaining method in the `fx`", function () {
+      const res = fx([1, 2, 3, 4])
+        .map((a) => a)
+        .map((a) => String(a))
+        .map((a) => a)
+        .toArray();
+
+      expect(res).toEqual(["1", "2", "3", "4"]);
+    });
   });
 
   describe("async", function () {
@@ -83,6 +93,15 @@ describe("map", function () {
       expect(res).toEqual(["1", "2", "3", "4"]);
     });
 
+    it("should be able to be used as a chaining method in the `fx`", async function () {
+      const res = await fx(toAsync([1, 2, 3, 4]))
+        .map((a) => Promise.resolve(a))
+        .map((a) => String(a))
+        .toArray();
+
+      expect(res).toEqual(["1", "2", "3", "4"]);
+    });
+
     it("should be passed concurrent object when job works concurrently", async function () {
       const mock = generatorMock();
       const iter = map((a) => a, mock);

test/Lazy/peek.spec.ts

@@ -1,4 +1,4 @@
-import { map, peek, pipe, toArray, toAsync } from "../../src/index";
+import { fx, map, peek, pipe, toArray, toAsync } from "../../src/index";
 import { Concurrent } from "../../src/Lazy/concurrent";
 import { generatorMock } from "../utils";
 
@@ -27,6 +27,18 @@ describe("peek", function () {
       expect(res).toEqual([21, 22, 23, 24]);
     });
 
+    it("should be able to be used as a chaining method in the `fx`", function () {
+      let sum = 0;
+      const res = fx([1, 2, 3, 4])
+        .map((a) => a + 10)
+        .peek((a) => (sum = sum + a))
+        .map((a) => a + 10)
+        .toArray();
+
+      expect(sum).toEqual(50);
+      expect(res).toEqual([21, 22, 23, 24]);
+    });
+
     it("should be able to handle an error", function () {
       const res: number[] = [];
       expect(() =>
@@ -70,6 +82,18 @@ describe("peek", function () {
       expect(res).toEqual([21, 22, 23, 24]);
     });
 
+    it("should be able to be used as a chaining method in the `fx`", async function () {
+      let sum = 0;
+      const res = await fx(toAsync([1, 2, 3, 4]))
+        .map((a) => a + 10)
+        .peek((a) => (sum = sum + a))
+        .map((a) => a + 10)
+        .toArray();
+
+      expect(sum).toEqual(50);
+      expect(res).toEqual([21, 22, 23, 24]);
+    });
+
     it("should be able to handle an error", async function () {
       const res: number[] = [];
 

test/Lazy/slice.spec.ts

@@ -1,4 +1,4 @@
-import { pipe, slice, toArray, toAsync } from "../../src";
+import { fx, pipe, slice, toArray, toAsync } from "../../src";
 import { Concurrent } from "../../src/Lazy/concurrent";
 import { generatorMock } from "../utils";
 
@@ -41,6 +41,14 @@ describe("slice", function () {
       const res2 = pipe([1, 2, 3, 4, 5], slice(1, 3), toArray);
       expect(res2).toEqual([2, 3]);
     });
+
+    it("should be able to be used as a chaining method in the `fx`", function () {
+      const res1 = fx([1, 2, 3, 4, 5]).slice(2).toArray();
+      expect(res1).toEqual([3, 4, 5]);
+
+      const res2 = fx([1, 2, 3, 4, 5]).slice(1, 3).toArray();
+      expect(res2).toEqual([2, 3]);
+    });
   });
 
   describe("async", function () {
@@ -84,6 +92,14 @@ describe("slice", function () {
       expect(res2).toEqual([2, 3]);
     });
 
+    it("should be able to be used as a chaining method in the `fx`", async function () {
+      const res1 = await fx([1, 2, 3, 4, 5]).toAsync().slice(2).toArray();
+      expect(res1).toEqual([3, 4, 5]);
+
+      const res2 = await fx([1, 2, 3, 4, 5]).toAsync().slice(1, 3).toArray();
+      expect(res2).toEqual([2, 3]);
+    });
+
     it("should be passed concurrent object when job works concurrently", async function () {
       const mock = generatorMock();
       const iter = slice(1, 2, mock);