refactor: replace take to spread syntax

packages/python/src/built-in/zip.test.ts

@@ -1,28 +1,27 @@
 import { describe, expect, it } from "vitest";
-import { take } from "../more-itertools/take";
 import { zip } from "./zip";
 
 describe("zip", () => {
   it("zips an iterable correctly", () => {
-    const result = take(Number.POSITIVE_INFINITY, zip([1, 2], [3, 4]));
+    const result = [...zip([1, 2], [3, 4])];
     expect(result).toEqual([
       [1, 3],
       [2, 4],
     ]);
   });
 
   it("return an empty iterables when pass empty iterables", () => {
-    const result = take(Number.POSITIVE_INFINITY, zip([], []));
+    const result = [...zip([], [])];
     expect(result).toEqual([]);
   });
 
   it("throw Error pass different length iterables when strict option is true", () => {
     expect(() => {
-      take(Number.POSITIVE_INFINITY, zip([1, 2], [1, 2, 3], { strict: true }));
+      [...zip([1, 2], [1, 2, 3], { strict: true })];
     }).toThrow("zip() argument 2 is longer than argument 1");
 
     expect(() => {
-      take(Number.POSITIVE_INFINITY, zip([1, 2, 3], [1, 2], { strict: true }));
+      [...zip([1, 2, 3], [1, 2], { strict: true })];
     }).toThrow("zip() argument 1 is longer than argument 2");
   });
 });

packages/python/src/itertools/accumulate.test.ts

@@ -1,19 +1,16 @@
 import { describe, expect, it } from "vitest";
-import { take } from "../more-itertools";
 import { accumulate } from "./accumulate";
 
 describe("accumulate", () => {
   it("should accumulate values from iterator", () => {
     const iterable = accumulate([1, 2, 3], (x, y) => x + y);
 
-    expect(take(Number.POSITIVE_INFINITY, iterable)).toEqual([1, 3, 6]);
+    expect([...iterable]).toEqual([1, 3, 6]);
   });
 
   it("should accumulate values from iterator with initial value", () => {
     const iterable = accumulate([1, 2, 3, 4, 5], (a, b) => a + b, 100);
 
-    expect(take(Number.POSITIVE_INFINITY, iterable)).toEqual([
-      100, 101, 103, 106, 110, 115,
-    ]);
+    expect([...iterable]).toEqual([100, 101, 103, 106, 110, 115]);
   });
 });

packages/python/src/itertools/batched.test.ts

@@ -1,13 +1,9 @@
 import { describe, expect, it } from "vitest";
-import { take } from "../more-itertools/take";
 import { batched } from "./batched";
 
 describe("batched", () => {
   it("returns remainder in final batch", () => {
-    const result = take(
-      Number.POSITIVE_INFINITY,
-      batched([1, 1, 1, 1, 1, 1, 2, 2], 3),
-    );
+    const result = [...batched([1, 1, 1, 1, 1, 1, 2, 2], 3)];
     expect(result).toEqual([
       [1, 1, 1],
       [1, 1, 1],
@@ -17,16 +13,13 @@ describe("batched", () => {
 
   it("throw error when batch length does not matched n with strict option", () => {
     expect(() => {
-      take(
-        Number.POSITIVE_INFINITY,
-        batched([1, 1, 1, 1, 1, 1, 2, 2], 3, { strict: true }),
-      );
+      [...batched([1, 1, 1, 1, 1, 1, 2, 2], 3, { strict: true })];
     }).toThrow("batched(): incomplete batch");
   });
 
   it("throw error when n is less than 1", () => {
     expect(() => {
-      take(Number.POSITIVE_INFINITY, batched([1, 1, 1, 1, 1, 1, 2, 2], 0));
+      [...batched([1, 1, 1, 1, 1, 1, 2, 2], 0)];
     }).toThrow("n must be at least one");
   });
 });

packages/python/src/itertools/chain.test.ts

@@ -1,10 +1,9 @@
 import { describe, expect, it } from "vitest";
-import { take } from "../more-itertools";
 import { chain } from "./chain";
 
 describe("concat", () => {
   it("concat two iterables", () => {
-    const result = take(Number.POSITIVE_INFINITY, chain("ABC", "DEF"));
+    const result = [...chain("ABC", "DEF")];
 
     expect(result).toEqual(["A", "B", "C", "D", "E", "F"]);
   });

packages/python/src/itertools/compress.test.ts

@@ -1,22 +1,21 @@
 import { describe, expect, it } from "vitest";
-import { take } from "../more-itertools";
 import { compress } from "./compress";
 
 describe("compress", () => {
   it("compress on empty list", () => {
-    expect(take(Number.POSITIVE_INFINITY, compress([], []))).toEqual([]);
+    expect([...compress([], [])]).toEqual([]);
   });
 
   it("compress removes selected items", () => {
-    expect(
-      take(Number.POSITIVE_INFINITY, compress("ABCDEF", [1, 0, 1, 0, 1, 1])),
-    ).toEqual(["A", "C", "E", "F"]);
+    expect([...compress("ABCDEF", [1, 0, 1, 0, 1, 1])]).toEqual([
+      "A",
+      "C",
+      "E",
+      "F",
+    ]);
 
-    expect(
-      take(
-        Number.POSITIVE_INFINITY,
-        compress("ABCDEF", [true, false, true, false, true, true]),
-      ),
-    ).toEqual(["A", "C", "E", "F"]);
+    expect([
+      ...compress("ABCDEF", [true, false, true, false, true, true]),
+    ]).toEqual(["A", "C", "E", "F"]);
   });
 });

packages/python/src/itertools/dropwhile.test.ts

@@ -1,35 +1,15 @@
 import { describe, expect, it } from "vitest";
-import { take } from "../more-itertools";
+
 import { dropwhile } from "./dropwhile";
 
 describe("dropwhile", () => {
   it("dropwhile on empty list", () => {
-    expect(
-      take(
-        Number.POSITIVE_INFINITY,
-        dropwhile((x) => x < 2, []),
-      ),
-    ).toEqual([]);
+    expect([...dropwhile((x) => x < 2, [])]).toEqual([]);
   });
 
   it("dropwhile on list", () => {
-    expect(
-      take(
-        Number.POSITIVE_INFINITY,
-        dropwhile((x) => x % 2 === 0, [1]),
-      ),
-    ).toEqual([1]);
-    expect(
-      take(
-        Number.POSITIVE_INFINITY,
-        dropwhile((x) => x % 2 === 1, [1]),
-      ),
-    ).toEqual([]);
-    expect(
-      take(
-        Number.POSITIVE_INFINITY,
-        dropwhile((x) => x < 5, [1, 4, 6, 3, 8]),
-      ),
-    ).toEqual([6, 3, 8]);
+    expect([...dropwhile((x) => x % 2 === 0, [1])]).toEqual([1]);
+    expect([...dropwhile((x) => x % 2 === 1, [1])]).toEqual([]);
+    expect([...dropwhile((x) => x < 5, [1, 4, 6, 3, 8])]).toEqual([6, 3, 8]);
   });
 });

packages/python/src/itertools/filterfalse.test.ts

@@ -1,23 +1,18 @@
 import { describe, expect, it } from "vitest";
-import { take } from "../more-itertools";
+
 import { filterfalse } from "./filterfalse";
 
 describe("filterfalse", () => {
   it("should filter elements predicate return true", () => {
-    expect(
-      take(
-        Number.POSITIVE_INFINITY,
-        filterfalse([1, 4, 6, 3, 8], (x) => x < 5),
-      ),
-    ).toEqual([6, 8]);
+    expect([...filterfalse([1, 4, 6, 3, 8], (x) => x < 5)]).toEqual([6, 8]);
   });
 
   it("should filter truthy value if predicate did not specify", () => {
-    expect(
-      take(
-        Number.POSITIVE_INFINITY,
-        filterfalse([1, undefined, 2, null, 3, "", 4, 0, 5]),
-      ),
-    ).toEqual([undefined, null, "", 0]);
+    expect([...filterfalse([1, undefined, 2, null, 3, "", 4, 0, 5])]).toEqual([
+      undefined,
+      null,
+      "",
+      0,
+    ]);
   });
 });

packages/python/src/itertools/starmap.test.ts

@@ -1,17 +1,15 @@
 import { describe, expect, it } from "vitest";
-import { take } from "../more-itertools";
 import { starmap } from "./starmap";
 
 describe("starmap", () => {
   it("starmap with pre-zipped tuple", () => {
-    const result = take(
-      Number.POSITIVE_INFINITY,
-      starmap(Math.pow, [
+    const result = [
+      ...starmap(Math.pow, [
         [2, 5],
         [3, 2],
         [10, 3],
       ]),
-    );
+    ];
 
     expect(result).toEqual([32, 9, 1000]);
   });

packages/python/src/more-itertools/flatten.test.ts

@@ -1,25 +1,20 @@
 import { describe, expect, it } from "vitest";
-import { take } from "../more-itertools";
 import { flatten } from "./flatten";
 
 describe("flatten", () => {
   it("return flatten iterables in iterables of iterables", () => {
-    const result = take(
-      Number.POSITIVE_INFINITY,
-      flatten([
+    const result = [
+      ...flatten([
         [1, 2],
         [3, 4],
       ]),
-    );
+    ];
 
     expect(result).toEqual([1, 2, 3, 4]);
   });
 
   it("only one level flatten", () => {
-    const result = take(
-      Number.POSITIVE_INFINITY,
-      flatten([[[1, 2]], [[3, 4]]]),
-    );
+    const result = [...flatten([[[1, 2]], [[3, 4]]])];
 
     expect(result).toEqual([
       [1, 2],