feat: add pipe module to support @core/pipe

Author: lambdalisue

deno.jsonc

@@ -52,6 +52,32 @@
     "./map": "./map.ts",
     "./pairwise": "./pairwise.ts",
     "./partition": "./partition.ts",
+    "./pipe": "./pipe/mod.ts",
+    "./pipe/chain": "./pipe/chain.ts",
+    "./pipe/chunked": "./pipe/chunked.ts",
+    "./pipe/compact": "./pipe/compact.ts",
+    "./pipe/compress": "./pipe/compress.ts",
+    "./pipe/cycle": "./pipe/cycle.ts",
+    "./pipe/drop": "./pipe/drop.ts",
+    "./pipe/drop-while": "./pipe/drop_while.ts",
+    "./pipe/enumerate": "./pipe/enumerate.ts",
+    "./pipe/every": "./pipe/every.ts",
+    "./pipe/filter": "./pipe/filter.ts",
+    "./pipe/find": "./pipe/find.ts",
+    "./pipe/first": "./pipe/first.ts",
+    "./pipe/flat-map": "./pipe/flat_map.ts",
+    "./pipe/flatten": "./pipe/flatten.ts",
+    "./pipe/for-each": "./pipe/for_each.ts",
+    "./pipe/last": "./pipe/last.ts",
+    "./pipe/map": "./pipe/map.ts",
+    "./pipe/pairwise": "./pipe/pairwise.ts",
+    "./pipe/partition": "./pipe/partition.ts",
+    "./pipe/reduce": "./pipe/reduce.ts",
+    "./pipe/some": "./pipe/some.ts",
+    "./pipe/take": "./pipe/take.ts",
+    "./pipe/take-while": "./pipe/take_while.ts",
+    "./pipe/uniq": "./pipe/uniq.ts",
+    "./pipe/zip": "./pipe/zip.ts",
     "./range": "./range.ts",
     "./reduce": "./reduce.ts",
     "./some": "./some.ts",
@@ -126,13 +152,41 @@
     "@core/iterutil/map": "./map.ts",
     "@core/iterutil/pairwise": "./pairwise.ts",
     "@core/iterutil/partition": "./partition.ts",
+    "@core/iterutil/pipe/chain": "./pipe/chain.ts",
+    "@core/iterutil/pipe/chunked": "./pipe/chunked.ts",
+    "@core/iterutil/pipe/compact": "./pipe/compact.ts",
+    "@core/iterutil/pipe/compress": "./pipe/compress.ts",
+    "@core/iterutil/pipe/count": "./pipe/count.ts",
+    "@core/iterutil/pipe/cycle": "./pipe/cycle.ts",
+    "@core/iterutil/pipe/drop": "./pipe/drop.ts",
+    "@core/iterutil/pipe/drop-while": "./pipe/drop_while.ts",
+    "@core/iterutil/pipe/enumerate": "./pipe/enumerate.ts",
+    "@core/iterutil/pipe/every": "./pipe/every.ts",
+    "@core/iterutil/pipe/filter": "./pipe/filter.ts",
+    "@core/iterutil/pipe/find": "./pipe/find.ts",
+    "@core/iterutil/pipe/first": "./pipe/first.ts",
+    "@core/iterutil/pipe/flat-map": "./pipe/flat_map.ts",
+    "@core/iterutil/pipe/flatten": "./pipe/flatten.ts",
+    "@core/iterutil/pipe/for-each": "./pipe/for_each.ts",
+    "@core/iterutil/pipe/iter": "./pipe/iter.ts",
+    "@core/iterutil/pipe/last": "./pipe/last.ts",
+    "@core/iterutil/pipe/map": "./pipe/map.ts",
+    "@core/iterutil/pipe/pairwise": "./pipe/pairwise.ts",
+    "@core/iterutil/pipe/partition": "./pipe/partition.ts",
+    "@core/iterutil/pipe/reduce": "./pipe/reduce.ts",
+    "@core/iterutil/pipe/some": "./pipe/some.ts",
+    "@core/iterutil/pipe/take": "./pipe/take.ts",
+    "@core/iterutil/pipe/take-while": "./pipe/take_while.ts",
+    "@core/iterutil/pipe/uniq": "./pipe/uniq.ts",
+    "@core/iterutil/pipe/zip": "./pipe/zip.ts",
     "@core/iterutil/range": "./range.ts",
     "@core/iterutil/reduce": "./reduce.ts",
     "@core/iterutil/some": "./some.ts",
     "@core/iterutil/take": "./take.ts",
     "@core/iterutil/take-while": "./take_while.ts",
     "@core/iterutil/uniq": "./uniq.ts",
     "@core/iterutil/zip": "./zip.ts",
+    "@core/pipe": "jsr:@core/pipe@^0.2.0",
     "@core/unknownutil": "jsr:@core/unknownutil@^4.0.1",
     "@std/assert": "jsr:@std/assert@^1.0.2",
     "@std/jsonc": "jsr:@std/jsonc@^1.0.0",

pipe/chain.ts

@@ -0,0 +1,33 @@
+import { type Chain, chain as base } from "@core/iterutil/chain";
+
+/**
+ * Returns an operator that chains multiple iterables to the iterable.
+ *
+ * See {@linkcode https://jsr.io/@core/iterutil/doc/chain/~/chain chain} for native chain.
+ *
+ * @param iterables The iterables to chain to the iterable.
+ * @returns An operator that chains multiple iterables to the iterable.
+ *
+ * @example
+ * ```ts
+ * import { pipe } from "@core/pipe";
+ * import { chain } from "@core/iterutil/pipe/chain";
+ *
+ * const iter = pipe(
+ *   [1, 2, 3],
+ *   chain(["a", "b"], [true]),
+ * );
+ * console.log(Array.from(iter)); // [1, 2, 3, "a", "b", true]
+ * ```
+ */
+export function chain<
+  U extends readonly [
+    Iterable<unknown>,
+    ...Iterable<unknown>[],
+  ],
+>(
+  ...iterables: U
+): <T>(iterable: Iterable<T>) => Iterable<T | Chain<U>> {
+  return <T>(iterable: Iterable<T>) =>
+    base(iterable, ...iterables) as Iterable<T | Chain<U>>;
+}

pipe/chain_test.ts

@@ -0,0 +1,18 @@
+import { assertEquals } from "@std/assert";
+import { assertType, type IsExact } from "@std/testing/types";
+import { pipe } from "@core/pipe";
+import { chain } from "./chain.ts";
+
+Deno.test("chain", async (t) => {
+  await t.step("usage", () => {
+    const result = pipe(
+      [1, 2, 3],
+      chain(["a", "b"], [true]),
+    );
+    const expected = [1, 2, 3, "a", "b", true];
+    assertEquals(Array.from(result), expected);
+    assertType<IsExact<typeof result, Iterable<number | string | boolean>>>(
+      true,
+    );
+  });
+});

pipe/chunked.ts

@@ -0,0 +1,27 @@
+import { chunked as base } from "@core/iterutil/chunked";
+
+/**
+ * Returns an operator that chunks the iterable into arrays of `size`.
+ *
+ * See {@linkcode https://jsr.io/@core/iterutil/doc/chunked/~/chunked chunked} for native chunked.
+ *
+ * @param size The size of each chunk.
+ * @return An operator that chunks the iterable into arrays of `size`.
+ *
+ * @example
+ * ```ts
+ * import { pipe } from "@core/pipe";
+ * import { chunked } from "@core/iterutil/pipe/chunked";
+ *
+ * const iter = pipe(
+ *   [1, 2, 3, 4, 5],
+ *   chunked(2),
+ * );
+ * console.log(Array.from(iter)); // [[1, 2], [3, 4], [5]]
+ * ```
+ */
+export function chunked(
+  size: number,
+): <T>(iterable: Iterable<T>) => Iterable<T[]> {
+  return (iterable) => base(iterable, size);
+}

pipe/chunked_test.ts

@@ -0,0 +1,13 @@
+import { assertEquals } from "@std/assert";
+import { assertType, type IsExact } from "@std/testing/types";
+import { pipe } from "@core/pipe";
+import { chunked } from "./chunked.ts";
+
+Deno.test("chunked", async (t) => {
+  await t.step("usage", () => {
+    const result = pipe([1, 2, 3, 4, 5, 6], chunked(2));
+    const expected = [[1, 2], [3, 4], [5, 6]];
+    assertEquals(Array.from(result), expected);
+    assertType<IsExact<typeof result, Iterable<number[]>>>(true);
+  });
+});

pipe/compact.ts

@@ -0,0 +1,22 @@
+import { compact } from "@core/iterutil/compact";
+
+export {
+  /**
+   * An operator to remove all nullish (`null` or `undefined`) values from an iterable.
+   *
+   * See {@linkcode https://jsr.io/@core/iterutil/doc/compact/~/compact compact} for native compact.
+   *
+   * @example
+   * ```ts
+   * import { pipe } from "@core/pipe";
+   * import { compact } from "@core/iterutil/pipe/compact";
+   *
+   * const iter = pipe(
+   *   [1, undefined, 2, null, 3],
+   *   compact,
+   * );
+   * console.log(Array.from(iter)); // [1, 2, 3]
+   * ```
+   */
+  compact,
+};

pipe/compact_test.ts

@@ -0,0 +1,13 @@
+import { assertEquals } from "@std/assert";
+import { assertType, type IsExact } from "@std/testing/types";
+import { pipe } from "@core/pipe";
+import { compact } from "./compact.ts";
+
+Deno.test("compact", async (t) => {
+  await t.step("usage", () => {
+    const result = pipe([1, undefined, 2, null, 3], compact);
+    const expected = [1, 2, 3];
+    assertEquals(Array.from(result), expected);
+    assertType<IsExact<typeof result, Iterable<number>>>(true);
+  });
+});

pipe/compress.ts

@@ -0,0 +1,27 @@
+import { compress as base } from "@core/iterutil/compress";
+
+/**
+ * Returns an operator that compresses an iterable by selecting elements using a selector iterable.
+ *
+ * See {@linkcode https://jsr.io/@core/iterutil/doc/compress/~/compress compress} for native compress.
+ *
+ * @param selectors The selectors to use.
+ * @returns An operator that compresses an iterable by selecting elements using a selector iterable.
+ *
+ * @example
+ * ```ts
+ * import { pipe } from "@core/pipe";
+ * import { compress } from "@core/iterutil/pipe/compress";
+ *
+ * const iter = pipe(
+ *   [1, 2, 3, 4, 5],
+ *   compress([true, false, true, false, true]),
+ * );
+ * console.log(Array.from(iter)); // [1, 3, 5]
+ * ```
+ */
+export function compress(
+  selectors: Iterable<boolean>,
+): <T>(iterable: Iterable<T>) => Iterable<T> {
+  return (iterable) => base(iterable, selectors);
+}

pipe/compress_test.ts

@@ -0,0 +1,16 @@
+import { assertEquals } from "@std/assert";
+import { assertType, type IsExact } from "@std/testing/types";
+import { pipe } from "@core/pipe";
+import { compress } from "./compress.ts";
+
+Deno.test("compress", async (t) => {
+  await t.step("usage", () => {
+    const result = pipe(
+      [1, 2, 3, 4, 5],
+      compress([true, false, true, false, true]),
+    );
+    const expected = [1, 3, 5];
+    assertEquals(Array.from(result), expected);
+    assertType<IsExact<typeof result, Iterable<number>>>(true);
+  });
+});

pipe/cycle.ts

@@ -0,0 +1,24 @@
+import { cycle } from "@core/iterutil/cycle";
+
+export {
+  /**
+   * An operator to return a function that cycles the elements of an iterable.
+   *
+   * See {@linkcode https://jsr.io/@core/iterutil/doc/cycle/~/cycle cycle} for native cycle.
+   *
+   * @example
+   * ```ts
+   * import { pipe } from "@core/pipe";
+   * import { cycle } from "@core/iterutil/pipe/cycle";
+   * import { take } from "@core/iterutil/pipe/take";
+   *
+   * const iter = pipe(
+   *   [1, 2, 3],
+   *   cycle,
+   *   take(5),
+   * );
+   * console.log(Array.from(iter)); // [1, 2, 3, 1, 2]
+   * ```
+   */
+  cycle,
+};