diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml
index 7e8acac..1fdc05e 100644
--- a/.github/FUNDING.yml
+++ b/.github/FUNDING.yml
@@ -1,6 +1,8 @@
 # These are supported funding model platforms
 
-github: [lambdalisue] # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
+github: [
+  lambdalisue,
+] # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
 patreon: # Replace with a single Patreon username
 open_collective: # Replace with a single Open Collective username
 ko_fi: # Replace with a single Ko-fi username
diff --git a/README.md b/README.md
index b84978a..8e065e9 100644
--- a/README.md
+++ b/README.md
@@ -21,7 +21,7 @@ inference and type checking of the operator functions.
 Pipe a value through a series of operator functions.
 
 ```ts
-import { pipe } from "@core/pipe";
+import { pipe } from "@core/pipe/pipe";
 
 const result = pipe(
   1,
@@ -36,7 +36,7 @@ Or use `async` module to pipe a value through a series of asynchronous operator
 functions.
 
 ```ts
-import { pipe } from "@core/pipe/async";
+import { pipe } from "@core/pipe/async/pipe";
 
 const result = await pipe(
   1,
@@ -47,6 +47,65 @@ const result = await pipe(
 console.log(result); // "4"
 ```
 
+If you want to create a new function that composes multiple operators, use
+`compose` like below.
+
+```ts
+import { compose } from "@core/pipe/compose";
+
+const operator = compose(
+  (v: number) => v + 1, // The first operator must be typed explicitly
+  (v) => v * 2, // inferred as (v: number) => number
+  (v) => v.toString(), // inferred as (v: number) => string
+);
+console.log(operator(1)); // "4"
+```
+
+Or use `async` module to compose multiple asynchronous operators.
+
+```ts
+import { compose } from "@core/pipe/async/compose";
+
+const operator = compose(
+  (v: number) => Promise.resolve(v + 1), // The first operator must be typed explicitly
+  (v) => Promise.resolve(v * 2), // inferred as (v: number) => number | Promise<number>
+  (v) => Promise.resolve(v.toString()), // inferred as (v: number) => string | Promise<string>
+);
+console.log(await operator(1)); // "4"
+```
+
+## Difference
+
+The `pipe` function in the root module is equivalent to function calls without
+`await` like below.
+
+```ts
+import { pipe } from "@core/pipe/pipe";
+
+const a = (v: unknown) => v;
+const b = (v: unknown) => v;
+const c = (v: unknown) => v;
+
+// Equivalent
+console.log(pipe(1, a, b, c)); // 1
+console.log(c(b(a(1)))); // 1
+```
+
+The `pipe` function in the `async` module is equivalent to function calls with
+`await` like below.
+
+```ts
+import { pipe } from "@core/pipe/async/pipe";
+
+const a = (v: unknown) => Promise.resolve(v);
+const b = (v: unknown) => Promise.resolve(v);
+const c = (v: unknown) => Promise.resolve(v);
+
+// Equivalent
+console.log(await pipe(1, a, b, c)); // 1
+console.log(await c(await b(await a(1)))); // 1
+```
+
 ## License
 
 The code follows MIT license written in [LICENSE](./LICENSE). Contributors need
diff --git a/_common.ts b/_common.ts
new file mode 100644
index 0000000..a747774
--- /dev/null
+++ b/_common.ts
@@ -0,0 +1,8 @@
+import type { Operator } from "./operator.ts";
+
+/**
+ * @internal
+ */
+export type LastOperatorReturn<T extends Operator<unknown, unknown>[]> =
+  T extends [...Operator<unknown, unknown>[], Operator<unknown, infer R>] ? R
+    : never;
diff --git a/async/_common.ts b/async/_common.ts
new file mode 100644
index 0000000..6e86efd
--- /dev/null
+++ b/async/_common.ts
@@ -0,0 +1,10 @@
+import type { AsyncOperator } from "./operator.ts";
+
+/**
+ * @internal
+ */
+export type LastAsyncOperatorReturn<
+  T extends AsyncOperator<unknown, unknown>[],
+> = T extends
+  [...AsyncOperator<unknown, unknown>[], AsyncOperator<unknown, infer R>] ? R
+  : never;
diff --git a/async/compose.ts b/async/compose.ts
new file mode 100644
index 0000000..e069659
--- /dev/null
+++ b/async/compose.ts
@@ -0,0 +1,470 @@
+import type { AsyncOperator } from "./operator.ts";
+import type { LastAsyncOperatorReturn } from "./_common.ts";
+
+/**
+ * Composes a sequence of operators to create a new function.
+ * Supports type inference for operators and the return type of the final operator.
+ *
+ * > [!NOTE]
+ * >
+ * > If more than 20 operators are used, their types default to `AsyncOperator<unknown, unknown>`,
+ * > requiring explicit type annotations.
+ *
+ * @param operators - A sequence of operators to apply to the value.
+ * @returns A function that processes the value through all operators and returns the final result.
+ *
+ * @example
+ * ```ts
+ * import { compose } from "@core/pipe/async";
+ *
+ * const result = await compose(
+ *   (v: number) => Promise.resolve(v + 1),  // The first operator requires an explicit type
+ *   (v) => Promise.resolve(v * 2),          // inferred as (v: number) => number | Promise<number>
+ *   (v) => Promise.resolve(v.toString()),   // inferred as (v: number) => string | Promise<string>
+ * )(1);
+ * console.log(result); // "4"
+ * ```
+ */
+export function compose<V, T01>(
+  o01: AsyncOperator<V, T01>,
+): AsyncOperator<V, T01>;
+export function compose<V, T01, T02>(
+  o01: AsyncOperator<V, T01>,
+  o02: AsyncOperator<T01, T02>,
+): AsyncOperator<V, T02>;
+export function compose<V, T01, T02, T03>(
+  o01: AsyncOperator<V, T01>,
+  o02: AsyncOperator<T01, T02>,
+  o03: AsyncOperator<T02, T03>,
+): AsyncOperator<V, T03>;
+export function compose<V, T01, T02, T03, T04>(
+  o01: AsyncOperator<V, T01>,
+  o02: AsyncOperator<T01, T02>,
+  o03: AsyncOperator<T02, T03>,
+  o04: AsyncOperator<T03, T04>,
+): AsyncOperator<V, T04>;
+export function compose<V, T01, T02, T03, T04, T05>(
+  o01: AsyncOperator<V, T01>,
+  o02: AsyncOperator<T01, T02>,
+  o03: AsyncOperator<T02, T03>,
+  o04: AsyncOperator<T03, T04>,
+  o05: AsyncOperator<T04, T05>,
+): AsyncOperator<V, T05>;
+export function compose<V, T01, T02, T03, T04, T05, T06>(
+  o01: AsyncOperator<V, T01>,
+  o02: AsyncOperator<T01, T02>,
+  o03: AsyncOperator<T02, T03>,
+  o04: AsyncOperator<T03, T04>,
+  o05: AsyncOperator<T04, T05>,
+  o06: AsyncOperator<T05, T06>,
+): AsyncOperator<V, T06>;
+export function compose<V, T01, T02, T03, T04, T05, T06, T07>(
+  o01: AsyncOperator<V, T01>,
+  o02: AsyncOperator<T01, T02>,
+  o03: AsyncOperator<T02, T03>,
+  o04: AsyncOperator<T03, T04>,
+  o05: AsyncOperator<T04, T05>,
+  o06: AsyncOperator<T05, T06>,
+  o07: AsyncOperator<T06, T07>,
+): AsyncOperator<V, T07>;
+export function compose<V, T01, T02, T03, T04, T05, T06, T07, T08>(
+  o01: AsyncOperator<V, T01>,
+  o02: AsyncOperator<T01, T02>,
+  o03: AsyncOperator<T02, T03>,
+  o04: AsyncOperator<T03, T04>,
+  o05: AsyncOperator<T04, T05>,
+  o06: AsyncOperator<T05, T06>,
+  o07: AsyncOperator<T06, T07>,
+  o08: AsyncOperator<T07, T08>,
+): AsyncOperator<V, T08>;
+export function compose<V, T01, T02, T03, T04, T05, T06, T07, T08, T09>(
+  o01: AsyncOperator<V, T01>,
+  o02: AsyncOperator<T01, T02>,
+  o03: AsyncOperator<T02, T03>,
+  o04: AsyncOperator<T03, T04>,
+  o05: AsyncOperator<T04, T05>,
+  o06: AsyncOperator<T05, T06>,
+  o07: AsyncOperator<T06, T07>,
+  o08: AsyncOperator<T07, T08>,
+  o09: AsyncOperator<T08, T09>,
+): AsyncOperator<V, T09>;
+export function compose<V, T01, T02, T03, T04, T05, T06, T07, T08, T09, T10>(
+  o01: AsyncOperator<V, T01>,
+  o02: AsyncOperator<T01, T02>,
+  o03: AsyncOperator<T02, T03>,
+  o04: AsyncOperator<T03, T04>,
+  o05: AsyncOperator<T04, T05>,
+  o06: AsyncOperator<T05, T06>,
+  o07: AsyncOperator<T06, T07>,
+  o08: AsyncOperator<T07, T08>,
+  o09: AsyncOperator<T08, T09>,
+  o10: AsyncOperator<T09, T10>,
+): AsyncOperator<V, T10>;
+export function compose<
+  V,
+  T01,
+  T02,
+  T03,
+  T04,
+  T05,
+  T06,
+  T07,
+  T08,
+  T09,
+  T10,
+  T11,
+>(
+  o01: AsyncOperator<V, T01>,
+  o02: AsyncOperator<T01, T02>,
+  o03: AsyncOperator<T02, T03>,
+  o04: AsyncOperator<T03, T04>,
+  o05: AsyncOperator<T04, T05>,
+  o06: AsyncOperator<T05, T06>,
+  o07: AsyncOperator<T06, T07>,
+  o08: AsyncOperator<T07, T08>,
+  o09: AsyncOperator<T08, T09>,
+  o10: AsyncOperator<T09, T10>,
+  o11: AsyncOperator<T10, T11>,
+): AsyncOperator<V, T11>;
+export function compose<
+  V,
+  T01,
+  T02,
+  T03,
+  T04,
+  T05,
+  T06,
+  T07,
+  T08,
+  T09,
+  T10,
+  T11,
+  T12,
+>(
+  o01: AsyncOperator<V, T01>,
+  o02: AsyncOperator<T01, T02>,
+  o03: AsyncOperator<T02, T03>,
+  o04: AsyncOperator<T03, T04>,
+  o05: AsyncOperator<T04, T05>,
+  o06: AsyncOperator<T05, T06>,
+  o07: AsyncOperator<T06, T07>,
+  o08: AsyncOperator<T07, T08>,
+  o09: AsyncOperator<T08, T09>,
+  o10: AsyncOperator<T09, T10>,
+  o11: AsyncOperator<T10, T11>,
+  o12: AsyncOperator<T11, T12>,
+): AsyncOperator<V, T12>;
+export function compose<
+  V,
+  T01,
+  T02,
+  T03,
+  T04,
+  T05,
+  T06,
+  T07,
+  T08,
+  T09,
+  T10,
+  T11,
+  T12,
+  T13,
+>(
+  o01: AsyncOperator<V, T01>,
+  o02: AsyncOperator<T01, T02>,
+  o03: AsyncOperator<T02, T03>,
+  o04: AsyncOperator<T03, T04>,
+  o05: AsyncOperator<T04, T05>,
+  o06: AsyncOperator<T05, T06>,
+  o07: AsyncOperator<T06, T07>,
+  o08: AsyncOperator<T07, T08>,
+  o09: AsyncOperator<T08, T09>,
+  o10: AsyncOperator<T09, T10>,
+  o11: AsyncOperator<T10, T11>,
+  o12: AsyncOperator<T11, T12>,
+  o13: AsyncOperator<T12, T13>,
+): AsyncOperator<V, T13>;
+export function compose<
+  V,
+  T01,
+  T02,
+  T03,
+  T04,
+  T05,
+  T06,
+  T07,
+  T08,
+  T09,
+  T10,
+  T11,
+  T12,
+  T13,
+  T14,
+>(
+  o01: AsyncOperator<V, T01>,
+  o02: AsyncOperator<T01, T02>,
+  o03: AsyncOperator<T02, T03>,
+  o04: AsyncOperator<T03, T04>,
+  o05: AsyncOperator<T04, T05>,
+  o06: AsyncOperator<T05, T06>,
+  o07: AsyncOperator<T06, T07>,
+  o08: AsyncOperator<T07, T08>,
+  o09: AsyncOperator<T08, T09>,
+  o10: AsyncOperator<T09, T10>,
+  o11: AsyncOperator<T10, T11>,
+  o12: AsyncOperator<T11, T12>,
+  o13: AsyncOperator<T12, T13>,
+  o14: AsyncOperator<T13, T14>,
+): AsyncOperator<V, T14>;
+export function compose<
+  V,
+  T01,
+  T02,
+  T03,
+  T04,
+  T05,
+  T06,
+  T07,
+  T08,
+  T09,
+  T10,
+  T11,
+  T12,
+  T13,
+  T14,
+  T15,
+>(
+  o01: AsyncOperator<V, T01>,
+  o02: AsyncOperator<T01, T02>,
+  o03: AsyncOperator<T02, T03>,
+  o04: AsyncOperator<T03, T04>,
+  o05: AsyncOperator<T04, T05>,
+  o06: AsyncOperator<T05, T06>,
+  o07: AsyncOperator<T06, T07>,
+  o08: AsyncOperator<T07, T08>,
+  o09: AsyncOperator<T08, T09>,
+  o10: AsyncOperator<T09, T10>,
+  o11: AsyncOperator<T10, T11>,
+  o12: AsyncOperator<T11, T12>,
+  o13: AsyncOperator<T12, T13>,
+  o14: AsyncOperator<T13, T14>,
+  o15: AsyncOperator<T14, T15>,
+): AsyncOperator<V, T15>;
+export function compose<
+  V,
+  T01,
+  T02,
+  T03,
+  T04,
+  T05,
+  T06,
+  T07,
+  T08,
+  T09,
+  T10,
+  T11,
+  T12,
+  T13,
+  T14,
+  T15,
+  T16,
+>(
+  o01: AsyncOperator<V, T01>,
+  o02: AsyncOperator<T01, T02>,
+  o03: AsyncOperator<T02, T03>,
+  o04: AsyncOperator<T03, T04>,
+  o05: AsyncOperator<T04, T05>,
+  o06: AsyncOperator<T05, T06>,
+  o07: AsyncOperator<T06, T07>,
+  o08: AsyncOperator<T07, T08>,
+  o09: AsyncOperator<T08, T09>,
+  o10: AsyncOperator<T09, T10>,
+  o11: AsyncOperator<T10, T11>,
+  o12: AsyncOperator<T11, T12>,
+  o13: AsyncOperator<T12, T13>,
+  o14: AsyncOperator<T13, T14>,
+  o15: AsyncOperator<T14, T15>,
+  o16: AsyncOperator<T15, T16>,
+): AsyncOperator<V, T16>;
+export function compose<
+  V,
+  T01,
+  T02,
+  T03,
+  T04,
+  T05,
+  T06,
+  T07,
+  T08,
+  T09,
+  T10,
+  T11,
+  T12,
+  T13,
+  T14,
+  T15,
+  T16,
+  T17,
+>(
+  o01: AsyncOperator<V, T01>,
+  o02: AsyncOperator<T01, T02>,
+  o03: AsyncOperator<T02, T03>,
+  o04: AsyncOperator<T03, T04>,
+  o05: AsyncOperator<T04, T05>,
+  o06: AsyncOperator<T05, T06>,
+  o07: AsyncOperator<T06, T07>,
+  o08: AsyncOperator<T07, T08>,
+  o09: AsyncOperator<T08, T09>,
+  o10: AsyncOperator<T09, T10>,
+  o11: AsyncOperator<T10, T11>,
+  o12: AsyncOperator<T11, T12>,
+  o13: AsyncOperator<T12, T13>,
+  o14: AsyncOperator<T13, T14>,
+  o15: AsyncOperator<T14, T15>,
+  o16: AsyncOperator<T15, T16>,
+  o17: AsyncOperator<T16, T17>,
+): AsyncOperator<V, T17>;
+export function compose<
+  V,
+  T01,
+  T02,
+  T03,
+  T04,
+  T05,
+  T06,
+  T07,
+  T08,
+  T09,
+  T10,
+  T11,
+  T12,
+  T13,
+  T14,
+  T15,
+  T16,
+  T17,
+  T18,
+>(
+  o01: AsyncOperator<V, T01>,
+  o02: AsyncOperator<T01, T02>,
+  o03: AsyncOperator<T02, T03>,
+  o04: AsyncOperator<T03, T04>,
+  o05: AsyncOperator<T04, T05>,
+  o06: AsyncOperator<T05, T06>,
+  o07: AsyncOperator<T06, T07>,
+  o08: AsyncOperator<T07, T08>,
+  o09: AsyncOperator<T08, T09>,
+  o10: AsyncOperator<T09, T10>,
+  o11: AsyncOperator<T10, T11>,
+  o12: AsyncOperator<T11, T12>,
+  o13: AsyncOperator<T12, T13>,
+  o14: AsyncOperator<T13, T14>,
+  o15: AsyncOperator<T14, T15>,
+  o16: AsyncOperator<T15, T16>,
+  o17: AsyncOperator<T16, T17>,
+  o18: AsyncOperator<T17, T18>,
+): AsyncOperator<V, T18>;
+export function compose<
+  V,
+  T01,
+  T02,
+  T03,
+  T04,
+  T05,
+  T06,
+  T07,
+  T08,
+  T09,
+  T10,
+  T11,
+  T12,
+  T13,
+  T14,
+  T15,
+  T16,
+  T17,
+  T18,
+  T19,
+>(
+  o01: AsyncOperator<V, T01>,
+  o02: AsyncOperator<T01, T02>,
+  o03: AsyncOperator<T02, T03>,
+  o04: AsyncOperator<T03, T04>,
+  o05: AsyncOperator<T04, T05>,
+  o06: AsyncOperator<T05, T06>,
+  o07: AsyncOperator<T06, T07>,
+  o08: AsyncOperator<T07, T08>,
+  o09: AsyncOperator<T08, T09>,
+  o10: AsyncOperator<T09, T10>,
+  o11: AsyncOperator<T10, T11>,
+  o12: AsyncOperator<T11, T12>,
+  o13: AsyncOperator<T12, T13>,
+  o14: AsyncOperator<T13, T14>,
+  o15: AsyncOperator<T14, T15>,
+  o16: AsyncOperator<T15, T16>,
+  o17: AsyncOperator<T16, T17>,
+  o18: AsyncOperator<T17, T18>,
+  o19: AsyncOperator<T18, T19>,
+): AsyncOperator<V, T19>;
+export function compose<
+  V,
+  T01,
+  T02,
+  T03,
+  T04,
+  T05,
+  T06,
+  T07,
+  T08,
+  T09,
+  T10,
+  T11,
+  T12,
+  T13,
+  T14,
+  T15,
+  T16,
+  T17,
+  T18,
+  T19,
+  T20,
+>(
+  o01: AsyncOperator<V, T01>,
+  o02: AsyncOperator<T01, T02>,
+  o03: AsyncOperator<T02, T03>,
+  o04: AsyncOperator<T03, T04>,
+  o05: AsyncOperator<T04, T05>,
+  o06: AsyncOperator<T05, T06>,
+  o07: AsyncOperator<T06, T07>,
+  o08: AsyncOperator<T07, T08>,
+  o09: AsyncOperator<T08, T09>,
+  o10: AsyncOperator<T09, T10>,
+  o11: AsyncOperator<T10, T11>,
+  o12: AsyncOperator<T11, T12>,
+  o13: AsyncOperator<T12, T13>,
+  o14: AsyncOperator<T13, T14>,
+  o15: AsyncOperator<T14, T15>,
+  o16: AsyncOperator<T15, T16>,
+  o17: AsyncOperator<T16, T17>,
+  o18: AsyncOperator<T17, T18>,
+  o19: AsyncOperator<T18, T19>,
+  o20: AsyncOperator<T19, T20>,
+): AsyncOperator<V, T20>;
+
+export function compose<
+  V,
+  // deno-lint-ignore no-explicit-any
+  AsyncOperators extends AsyncOperator<any, unknown>[],
+>(
+  ...operators: AsyncOperators
+): AsyncOperator<V, LastAsyncOperatorReturn<AsyncOperators>>;
+
+// deno-lint-ignore no-explicit-any
+export function compose<V>(...operators: AsyncOperator<unknown, any>[]) {
+  return async (value: V) => {
+    return await operators.reduce(
+      async (result, next) => next(await result),
+      Promise.resolve(value),
+    );
+  };
+}
diff --git a/async/compose_test.ts b/async/compose_test.ts
new file mode 100644
index 0000000..83dacd7
--- /dev/null
+++ b/async/compose_test.ts
@@ -0,0 +1,158 @@
+import { test } from "@cross/test";
+import { assertEquals } from "@std/assert";
+import { assertType, type IsExact } from "@std/testing/types";
+import { compose } from "./compose.ts";
+
+await test("compose with no operators should return an identity function", async () => {
+  assertEquals(await compose()(1), 1);
+});
+
+await test("compose with one operator should return the operator", async () => {
+  assertEquals(await compose((v: number) => Promise.resolve(v * 2))(1), 2);
+});
+
+await test("compose with one operator requires explicity type annotation", () => {
+  compose((v) => {
+    assertType<IsExact<typeof v, unknown>>(true);
+  });
+  compose((v: number) => {
+    assertType<IsExact<typeof v, number>>(true);
+    return v.toString();
+  });
+});
+
+await test("compose with two operators should return a composed operator", async () => {
+  assertEquals(
+    await compose(
+      (v: number) => Promise.resolve(v * 2),
+      (v) => Promise.resolve(v * 2),
+    )(1),
+    4,
+  );
+});
+
+await test("compose with two operators should resolve the type properly", () => {
+  compose((v: number) => {
+    assertType<IsExact<typeof v, number>>(true);
+    return v.toString();
+  }, (v) => {
+    assertType<IsExact<typeof v, string>>(true);
+    return v.length;
+  });
+});
+
+await test("compose with three operators should return a composed operator", async () => {
+  assertEquals(
+    await compose(
+      (v: number) => Promise.resolve(v * 2),
+      (v) => Promise.resolve(v * 2),
+      (v) => Promise.resolve(v * 2),
+    )(1),
+    8,
+  );
+});
+
+await test("compose with three operators should resolve the type properly", () => {
+  compose((v: number) => {
+    assertType<IsExact<typeof v, number>>(true);
+    return v.toString();
+  }, (v) => {
+    assertType<IsExact<typeof v, string>>(true);
+    return v.length;
+  }, (v) => {
+    assertType<IsExact<typeof v, number>>(true);
+    return v.toString();
+  });
+});
+
+await test("compose with twenty operators should return a composed operator", async () => {
+  assertEquals(
+    await compose(...Array(20).fill((v: number) => Promise.resolve(v * 2)))(1),
+    2 ** 20,
+  );
+});
+
+await test("compose with twenty operators should resolve the type properly", () => {
+  compose(
+    (v: number) => {
+      assertType<IsExact<typeof v, number>>(true);
+      return v;
+    },
+    (v) => {
+      assertType<IsExact<typeof v, number>>(true);
+      return v;
+    },
+    (v) => {
+      assertType<IsExact<typeof v, number>>(true);
+      return v;
+    },
+    (v) => {
+      assertType<IsExact<typeof v, number>>(true);
+      return v;
+    },
+    (v) => {
+      assertType<IsExact<typeof v, number>>(true);
+      return v;
+    },
+    (v) => {
+      assertType<IsExact<typeof v, number>>(true);
+      return v;
+    },
+    (v) => {
+      assertType<IsExact<typeof v, number>>(true);
+      return v;
+    },
+    (v) => {
+      assertType<IsExact<typeof v, number>>(true);
+      return v;
+    },
+    (v) => {
+      assertType<IsExact<typeof v, number>>(true);
+      return v;
+    },
+    (v) => {
+      assertType<IsExact<typeof v, number>>(true);
+      return v;
+    },
+    (v) => {
+      assertType<IsExact<typeof v, number>>(true);
+      return v;
+    },
+    (v) => {
+      assertType<IsExact<typeof v, number>>(true);
+      return v;
+    },
+    (v) => {
+      assertType<IsExact<typeof v, number>>(true);
+      return v;
+    },
+    (v) => {
+      assertType<IsExact<typeof v, number>>(true);
+      return v;
+    },
+    (v) => {
+      assertType<IsExact<typeof v, number>>(true);
+      return v;
+    },
+    (v) => {
+      assertType<IsExact<typeof v, number>>(true);
+      return v;
+    },
+    (v) => {
+      assertType<IsExact<typeof v, number>>(true);
+      return v;
+    },
+    (v) => {
+      assertType<IsExact<typeof v, number>>(true);
+      return v;
+    },
+    (v) => {
+      assertType<IsExact<typeof v, number>>(true);
+      return v;
+    },
+    (v) => {
+      assertType<IsExact<typeof v, number>>(true);
+      return v;
+    },
+  );
+});
diff --git a/async/mod.ts b/async/mod.ts
index dc62e19..d32b5d9 100644
--- a/async/mod.ts
+++ b/async/mod.ts
@@ -1,490 +1,3 @@
-/**
- * AsyncOperator function that takes a value and returns a new value.
- */
-export type AsyncOperator<A, B> = (v: A) => B | Promise<B>;
-
-/**
- * @internal
- */
-type LastAsyncOperatorReturn<
-  T extends AsyncOperator<unknown, unknown>[],
-> = T extends
-  [...AsyncOperator<unknown, unknown>[], AsyncOperator<unknown, infer R>] ? R
-  : never;
-
-/**
- * Pipes a value through a series of asynchronous operator functions.
- * Supports type inference for both the operator functions and the return value of the final operator.
- *
- * > [!NOTE]
- * >
- * > If the number of operators exceeds 20, the operator functions' types will default to
- * > `AsyncOperator<unknown, unknown>`, requiring explicit type annotations.
- *
- * @param value - The initial value to be processed through the operators.
- * @param operators - A sequence of functions to apply to the value.
- * @returns The final value after being processed through all the operators.
- *
- * @example
- * ```ts
- * import { pipe } from "@core/pipe/async";
- *
- * const result = await pipe(
- *   1,
- *   (v) => Promise.resolve(v + 1),  // inferred as (v: number) => number | Promise<number>
- *   (v) => Promise.resolve(v * 2),  // inferred as (v: number) => number | Promise<number>
- *   (v) => Promise.resolve(v.toString()), // inferred as (v: number) => string | Promise<string>
- * );
- * console.log(result); // "4"
- * ```
- */
-export function pipe<V>(value: V): Promise<V>;
-export function pipe<V, T01>(
-  value: V,
-  o01: AsyncOperator<V, T01>,
-): Promise<T01>;
-export function pipe<V, T01, T02>(
-  value: V,
-  o01: AsyncOperator<V, T01>,
-  o02: AsyncOperator<T01, T02>,
-): Promise<T02>;
-export function pipe<V, T01, T02, T03>(
-  value: V,
-  o01: AsyncOperator<V, T01>,
-  o02: AsyncOperator<T01, T02>,
-  o03: AsyncOperator<T02, T03>,
-): Promise<T03>;
-export function pipe<V, T01, T02, T03, T04>(
-  value: V,
-  o01: AsyncOperator<V, T01>,
-  o02: AsyncOperator<T01, T02>,
-  o03: AsyncOperator<T02, T03>,
-  o04: AsyncOperator<T03, T04>,
-): Promise<T04>;
-export function pipe<V, T01, T02, T03, T04, T05>(
-  value: V,
-  o01: AsyncOperator<V, T01>,
-  o02: AsyncOperator<T01, T02>,
-  o03: AsyncOperator<T02, T03>,
-  o04: AsyncOperator<T03, T04>,
-  o05: AsyncOperator<T04, T05>,
-): Promise<T05>;
-export function pipe<V, T01, T02, T03, T04, T05, T06>(
-  value: V,
-  o01: AsyncOperator<V, T01>,
-  o02: AsyncOperator<T01, T02>,
-  o03: AsyncOperator<T02, T03>,
-  o04: AsyncOperator<T03, T04>,
-  o05: AsyncOperator<T04, T05>,
-  o06: AsyncOperator<T05, T06>,
-): Promise<T06>;
-export function pipe<V, T01, T02, T03, T04, T05, T06, T07>(
-  value: V,
-  o01: AsyncOperator<V, T01>,
-  o02: AsyncOperator<T01, T02>,
-  o03: AsyncOperator<T02, T03>,
-  o04: AsyncOperator<T03, T04>,
-  o05: AsyncOperator<T04, T05>,
-  o06: AsyncOperator<T05, T06>,
-  o07: AsyncOperator<T06, T07>,
-): Promise<T07>;
-export function pipe<V, T01, T02, T03, T04, T05, T06, T07, T08>(
-  value: V,
-  o01: AsyncOperator<V, T01>,
-  o02: AsyncOperator<T01, T02>,
-  o03: AsyncOperator<T02, T03>,
-  o04: AsyncOperator<T03, T04>,
-  o05: AsyncOperator<T04, T05>,
-  o06: AsyncOperator<T05, T06>,
-  o07: AsyncOperator<T06, T07>,
-  o08: AsyncOperator<T07, T08>,
-): Promise<T08>;
-export function pipe<V, T01, T02, T03, T04, T05, T06, T07, T08, T09>(
-  value: V,
-  o01: AsyncOperator<V, T01>,
-  o02: AsyncOperator<T01, T02>,
-  o03: AsyncOperator<T02, T03>,
-  o04: AsyncOperator<T03, T04>,
-  o05: AsyncOperator<T04, T05>,
-  o06: AsyncOperator<T05, T06>,
-  o07: AsyncOperator<T06, T07>,
-  o08: AsyncOperator<T07, T08>,
-  o09: AsyncOperator<T08, T09>,
-): Promise<T09>;
-export function pipe<V, T01, T02, T03, T04, T05, T06, T07, T08, T09, T10>(
-  value: V,
-  o01: AsyncOperator<V, T01>,
-  o02: AsyncOperator<T01, T02>,
-  o03: AsyncOperator<T02, T03>,
-  o04: AsyncOperator<T03, T04>,
-  o05: AsyncOperator<T04, T05>,
-  o06: AsyncOperator<T05, T06>,
-  o07: AsyncOperator<T06, T07>,
-  o08: AsyncOperator<T07, T08>,
-  o09: AsyncOperator<T08, T09>,
-  o10: AsyncOperator<T09, T10>,
-): Promise<T10>;
-export function pipe<V, T01, T02, T03, T04, T05, T06, T07, T08, T09, T10, T11>(
-  value: V,
-  o01: AsyncOperator<V, T01>,
-  o02: AsyncOperator<T01, T02>,
-  o03: AsyncOperator<T02, T03>,
-  o04: AsyncOperator<T03, T04>,
-  o05: AsyncOperator<T04, T05>,
-  o06: AsyncOperator<T05, T06>,
-  o07: AsyncOperator<T06, T07>,
-  o08: AsyncOperator<T07, T08>,
-  o09: AsyncOperator<T08, T09>,
-  o10: AsyncOperator<T09, T10>,
-  o11: AsyncOperator<T10, T11>,
-): Promise<T11>;
-export function pipe<
-  V,
-  T01,
-  T02,
-  T03,
-  T04,
-  T05,
-  T06,
-  T07,
-  T08,
-  T09,
-  T10,
-  T11,
-  T12,
->(
-  value: V,
-  o01: AsyncOperator<V, T01>,
-  o02: AsyncOperator<T01, T02>,
-  o03: AsyncOperator<T02, T03>,
-  o04: AsyncOperator<T03, T04>,
-  o05: AsyncOperator<T04, T05>,
-  o06: AsyncOperator<T05, T06>,
-  o07: AsyncOperator<T06, T07>,
-  o08: AsyncOperator<T07, T08>,
-  o09: AsyncOperator<T08, T09>,
-  o10: AsyncOperator<T09, T10>,
-  o11: AsyncOperator<T10, T11>,
-  o12: AsyncOperator<T11, T12>,
-): Promise<T12>;
-export function pipe<
-  V,
-  T01,
-  T02,
-  T03,
-  T04,
-  T05,
-  T06,
-  T07,
-  T08,
-  T09,
-  T10,
-  T11,
-  T12,
-  T13,
->(
-  value: V,
-  o01: AsyncOperator<V, T01>,
-  o02: AsyncOperator<T01, T02>,
-  o03: AsyncOperator<T02, T03>,
-  o04: AsyncOperator<T03, T04>,
-  o05: AsyncOperator<T04, T05>,
-  o06: AsyncOperator<T05, T06>,
-  o07: AsyncOperator<T06, T07>,
-  o08: AsyncOperator<T07, T08>,
-  o09: AsyncOperator<T08, T09>,
-  o10: AsyncOperator<T09, T10>,
-  o11: AsyncOperator<T10, T11>,
-  o12: AsyncOperator<T11, T12>,
-  o13: AsyncOperator<T12, T13>,
-): Promise<T13>;
-export function pipe<
-  V,
-  T01,
-  T02,
-  T03,
-  T04,
-  T05,
-  T06,
-  T07,
-  T08,
-  T09,
-  T10,
-  T11,
-  T12,
-  T13,
-  T14,
->(
-  value: V,
-  o01: AsyncOperator<V, T01>,
-  o02: AsyncOperator<T01, T02>,
-  o03: AsyncOperator<T02, T03>,
-  o04: AsyncOperator<T03, T04>,
-  o05: AsyncOperator<T04, T05>,
-  o06: AsyncOperator<T05, T06>,
-  o07: AsyncOperator<T06, T07>,
-  o08: AsyncOperator<T07, T08>,
-  o09: AsyncOperator<T08, T09>,
-  o10: AsyncOperator<T09, T10>,
-  o11: AsyncOperator<T10, T11>,
-  o12: AsyncOperator<T11, T12>,
-  o13: AsyncOperator<T12, T13>,
-  o14: AsyncOperator<T13, T14>,
-): Promise<T14>;
-export function pipe<
-  V,
-  T01,
-  T02,
-  T03,
-  T04,
-  T05,
-  T06,
-  T07,
-  T08,
-  T09,
-  T10,
-  T11,
-  T12,
-  T13,
-  T14,
-  T15,
->(
-  value: V,
-  o01: AsyncOperator<V, T01>,
-  o02: AsyncOperator<T01, T02>,
-  o03: AsyncOperator<T02, T03>,
-  o04: AsyncOperator<T03, T04>,
-  o05: AsyncOperator<T04, T05>,
-  o06: AsyncOperator<T05, T06>,
-  o07: AsyncOperator<T06, T07>,
-  o08: AsyncOperator<T07, T08>,
-  o09: AsyncOperator<T08, T09>,
-  o10: AsyncOperator<T09, T10>,
-  o11: AsyncOperator<T10, T11>,
-  o12: AsyncOperator<T11, T12>,
-  o13: AsyncOperator<T12, T13>,
-  o14: AsyncOperator<T13, T14>,
-  o15: AsyncOperator<T14, T15>,
-): Promise<T15>;
-export function pipe<
-  V,
-  T01,
-  T02,
-  T03,
-  T04,
-  T05,
-  T06,
-  T07,
-  T08,
-  T09,
-  T10,
-  T11,
-  T12,
-  T13,
-  T14,
-  T15,
-  T16,
->(
-  value: V,
-  o01: AsyncOperator<V, T01>,
-  o02: AsyncOperator<T01, T02>,
-  o03: AsyncOperator<T02, T03>,
-  o04: AsyncOperator<T03, T04>,
-  o05: AsyncOperator<T04, T05>,
-  o06: AsyncOperator<T05, T06>,
-  o07: AsyncOperator<T06, T07>,
-  o08: AsyncOperator<T07, T08>,
-  o09: AsyncOperator<T08, T09>,
-  o10: AsyncOperator<T09, T10>,
-  o11: AsyncOperator<T10, T11>,
-  o12: AsyncOperator<T11, T12>,
-  o13: AsyncOperator<T12, T13>,
-  o14: AsyncOperator<T13, T14>,
-  o15: AsyncOperator<T14, T15>,
-  o16: AsyncOperator<T15, T16>,
-): Promise<T16>;
-export function pipe<
-  V,
-  T01,
-  T02,
-  T03,
-  T04,
-  T05,
-  T06,
-  T07,
-  T08,
-  T09,
-  T10,
-  T11,
-  T12,
-  T13,
-  T14,
-  T15,
-  T16,
-  T17,
->(
-  value: V,
-  o01: AsyncOperator<V, T01>,
-  o02: AsyncOperator<T01, T02>,
-  o03: AsyncOperator<T02, T03>,
-  o04: AsyncOperator<T03, T04>,
-  o05: AsyncOperator<T04, T05>,
-  o06: AsyncOperator<T05, T06>,
-  o07: AsyncOperator<T06, T07>,
-  o08: AsyncOperator<T07, T08>,
-  o09: AsyncOperator<T08, T09>,
-  o10: AsyncOperator<T09, T10>,
-  o11: AsyncOperator<T10, T11>,
-  o12: AsyncOperator<T11, T12>,
-  o13: AsyncOperator<T12, T13>,
-  o14: AsyncOperator<T13, T14>,
-  o15: AsyncOperator<T14, T15>,
-  o16: AsyncOperator<T15, T16>,
-  o17: AsyncOperator<T16, T17>,
-): Promise<T17>;
-export function pipe<
-  V,
-  T01,
-  T02,
-  T03,
-  T04,
-  T05,
-  T06,
-  T07,
-  T08,
-  T09,
-  T10,
-  T11,
-  T12,
-  T13,
-  T14,
-  T15,
-  T16,
-  T17,
-  T18,
->(
-  value: V,
-  o01: AsyncOperator<V, T01>,
-  o02: AsyncOperator<T01, T02>,
-  o03: AsyncOperator<T02, T03>,
-  o04: AsyncOperator<T03, T04>,
-  o05: AsyncOperator<T04, T05>,
-  o06: AsyncOperator<T05, T06>,
-  o07: AsyncOperator<T06, T07>,
-  o08: AsyncOperator<T07, T08>,
-  o09: AsyncOperator<T08, T09>,
-  o10: AsyncOperator<T09, T10>,
-  o11: AsyncOperator<T10, T11>,
-  o12: AsyncOperator<T11, T12>,
-  o13: AsyncOperator<T12, T13>,
-  o14: AsyncOperator<T13, T14>,
-  o15: AsyncOperator<T14, T15>,
-  o16: AsyncOperator<T15, T16>,
-  o17: AsyncOperator<T16, T17>,
-  o18: AsyncOperator<T17, T18>,
-): Promise<T18>;
-export function pipe<
-  V,
-  T01,
-  T02,
-  T03,
-  T04,
-  T05,
-  T06,
-  T07,
-  T08,
-  T09,
-  T10,
-  T11,
-  T12,
-  T13,
-  T14,
-  T15,
-  T16,
-  T17,
-  T18,
-  T19,
->(
-  value: V,
-  o01: AsyncOperator<V, T01>,
-  o02: AsyncOperator<T01, T02>,
-  o03: AsyncOperator<T02, T03>,
-  o04: AsyncOperator<T03, T04>,
-  o05: AsyncOperator<T04, T05>,
-  o06: AsyncOperator<T05, T06>,
-  o07: AsyncOperator<T06, T07>,
-  o08: AsyncOperator<T07, T08>,
-  o09: AsyncOperator<T08, T09>,
-  o10: AsyncOperator<T09, T10>,
-  o11: AsyncOperator<T10, T11>,
-  o12: AsyncOperator<T11, T12>,
-  o13: AsyncOperator<T12, T13>,
-  o14: AsyncOperator<T13, T14>,
-  o15: AsyncOperator<T14, T15>,
-  o16: AsyncOperator<T15, T16>,
-  o17: AsyncOperator<T16, T17>,
-  o18: AsyncOperator<T17, T18>,
-  o19: AsyncOperator<T18, T19>,
-): Promise<T19>;
-export function pipe<
-  V,
-  T01,
-  T02,
-  T03,
-  T04,
-  T05,
-  T06,
-  T07,
-  T08,
-  T09,
-  T10,
-  T11,
-  T12,
-  T13,
-  T14,
-  T15,
-  T16,
-  T17,
-  T18,
-  T19,
-  T20,
->(
-  value: V,
-  o01: AsyncOperator<V, T01>,
-  o02: AsyncOperator<T01, T02>,
-  o03: AsyncOperator<T02, T03>,
-  o04: AsyncOperator<T03, T04>,
-  o05: AsyncOperator<T04, T05>,
-  o06: AsyncOperator<T05, T06>,
-  o07: AsyncOperator<T06, T07>,
-  o08: AsyncOperator<T07, T08>,
-  o09: AsyncOperator<T08, T09>,
-  o10: AsyncOperator<T09, T10>,
-  o11: AsyncOperator<T10, T11>,
-  o12: AsyncOperator<T11, T12>,
-  o13: AsyncOperator<T12, T13>,
-  o14: AsyncOperator<T13, T14>,
-  o15: AsyncOperator<T14, T15>,
-  o16: AsyncOperator<T15, T16>,
-  o17: AsyncOperator<T16, T17>,
-  o18: AsyncOperator<T17, T18>,
-  o19: AsyncOperator<T18, T19>,
-  o20: AsyncOperator<T19, T20>,
-): Promise<T20>;
-
-// deno-lint-ignore no-explicit-any
-export function pipe<V, AsyncOperators extends AsyncOperator<any, unknown>[]>(
-  value: V,
-  ...operators: AsyncOperators
-): Promise<LastAsyncOperatorReturn<AsyncOperators>>;
-
-export async function pipe<V>(
-  value: V,
-  // deno-lint-ignore no-explicit-any
-  ...operators: AsyncOperator<unknown, any>[]
-) {
-  return await operators.reduce(
-    async (result, next) => next(await result),
-    Promise.resolve(value),
-  );
-}
+export type { AsyncOperator } from "./operator.ts";
+export * from "./compose.ts";
+export * from "./pipe.ts";
diff --git a/async/operator.ts b/async/operator.ts
new file mode 100644
index 0000000..0bb9af2
--- /dev/null
+++ b/async/operator.ts
@@ -0,0 +1,4 @@
+/**
+ * AsyncOperator function that takes a value and returns a new value.
+ */
+export type AsyncOperator<A, B> = (v: A) => B | Promise<B>;
diff --git a/async/pipe.ts b/async/pipe.ts
new file mode 100644
index 0000000..e32c51f
--- /dev/null
+++ b/async/pipe.ts
@@ -0,0 +1,479 @@
+import type { AsyncOperator } from "./operator.ts";
+import type { LastAsyncOperatorReturn } from "./_common.ts";
+
+/**
+ * Pipes a value through a series of asynchronous operator functions.
+ * Supports type inference for both the operator functions and the return value of the final operator.
+ *
+ * > [!NOTE]
+ * >
+ * > If the number of operators exceeds 20, the operator functions' types will default to
+ * > `AsyncOperator<unknown, unknown>`, requiring explicit type annotations.
+ *
+ * @param value - The initial value to be processed through the operators.
+ * @param operators - A sequence of functions to apply to the value.
+ * @returns The final value after being processed through all the operators.
+ *
+ * @example
+ * ```ts
+ * import { pipe } from "@core/pipe/async";
+ *
+ * const result = await pipe(
+ *   1,
+ *   (v) => Promise.resolve(v + 1),  // inferred as (v: number) => number | Promise<number>
+ *   (v) => Promise.resolve(v * 2),  // inferred as (v: number) => number | Promise<number>
+ *   (v) => Promise.resolve(v.toString()), // inferred as (v: number) => string | Promise<string>
+ * );
+ * console.log(result); // "4"
+ * ```
+ */
+export function pipe<V>(value: V): Promise<V>;
+export function pipe<V, T01>(
+  value: V,
+  o01: AsyncOperator<V, T01>,
+): Promise<T01>;
+export function pipe<V, T01, T02>(
+  value: V,
+  o01: AsyncOperator<V, T01>,
+  o02: AsyncOperator<T01, T02>,
+): Promise<T02>;
+export function pipe<V, T01, T02, T03>(
+  value: V,
+  o01: AsyncOperator<V, T01>,
+  o02: AsyncOperator<T01, T02>,
+  o03: AsyncOperator<T02, T03>,
+): Promise<T03>;
+export function pipe<V, T01, T02, T03, T04>(
+  value: V,
+  o01: AsyncOperator<V, T01>,
+  o02: AsyncOperator<T01, T02>,
+  o03: AsyncOperator<T02, T03>,
+  o04: AsyncOperator<T03, T04>,
+): Promise<T04>;
+export function pipe<V, T01, T02, T03, T04, T05>(
+  value: V,
+  o01: AsyncOperator<V, T01>,
+  o02: AsyncOperator<T01, T02>,
+  o03: AsyncOperator<T02, T03>,
+  o04: AsyncOperator<T03, T04>,
+  o05: AsyncOperator<T04, T05>,
+): Promise<T05>;
+export function pipe<V, T01, T02, T03, T04, T05, T06>(
+  value: V,
+  o01: AsyncOperator<V, T01>,
+  o02: AsyncOperator<T01, T02>,
+  o03: AsyncOperator<T02, T03>,
+  o04: AsyncOperator<T03, T04>,
+  o05: AsyncOperator<T04, T05>,
+  o06: AsyncOperator<T05, T06>,
+): Promise<T06>;
+export function pipe<V, T01, T02, T03, T04, T05, T06, T07>(
+  value: V,
+  o01: AsyncOperator<V, T01>,
+  o02: AsyncOperator<T01, T02>,
+  o03: AsyncOperator<T02, T03>,
+  o04: AsyncOperator<T03, T04>,
+  o05: AsyncOperator<T04, T05>,
+  o06: AsyncOperator<T05, T06>,
+  o07: AsyncOperator<T06, T07>,
+): Promise<T07>;
+export function pipe<V, T01, T02, T03, T04, T05, T06, T07, T08>(
+  value: V,
+  o01: AsyncOperator<V, T01>,
+  o02: AsyncOperator<T01, T02>,
+  o03: AsyncOperator<T02, T03>,
+  o04: AsyncOperator<T03, T04>,
+  o05: AsyncOperator<T04, T05>,
+  o06: AsyncOperator<T05, T06>,
+  o07: AsyncOperator<T06, T07>,
+  o08: AsyncOperator<T07, T08>,
+): Promise<T08>;
+export function pipe<V, T01, T02, T03, T04, T05, T06, T07, T08, T09>(
+  value: V,
+  o01: AsyncOperator<V, T01>,
+  o02: AsyncOperator<T01, T02>,
+  o03: AsyncOperator<T02, T03>,
+  o04: AsyncOperator<T03, T04>,
+  o05: AsyncOperator<T04, T05>,
+  o06: AsyncOperator<T05, T06>,
+  o07: AsyncOperator<T06, T07>,
+  o08: AsyncOperator<T07, T08>,
+  o09: AsyncOperator<T08, T09>,
+): Promise<T09>;
+export function pipe<V, T01, T02, T03, T04, T05, T06, T07, T08, T09, T10>(
+  value: V,
+  o01: AsyncOperator<V, T01>,
+  o02: AsyncOperator<T01, T02>,
+  o03: AsyncOperator<T02, T03>,
+  o04: AsyncOperator<T03, T04>,
+  o05: AsyncOperator<T04, T05>,
+  o06: AsyncOperator<T05, T06>,
+  o07: AsyncOperator<T06, T07>,
+  o08: AsyncOperator<T07, T08>,
+  o09: AsyncOperator<T08, T09>,
+  o10: AsyncOperator<T09, T10>,
+): Promise<T10>;
+export function pipe<V, T01, T02, T03, T04, T05, T06, T07, T08, T09, T10, T11>(
+  value: V,
+  o01: AsyncOperator<V, T01>,
+  o02: AsyncOperator<T01, T02>,
+  o03: AsyncOperator<T02, T03>,
+  o04: AsyncOperator<T03, T04>,
+  o05: AsyncOperator<T04, T05>,
+  o06: AsyncOperator<T05, T06>,
+  o07: AsyncOperator<T06, T07>,
+  o08: AsyncOperator<T07, T08>,
+  o09: AsyncOperator<T08, T09>,
+  o10: AsyncOperator<T09, T10>,
+  o11: AsyncOperator<T10, T11>,
+): Promise<T11>;
+export function pipe<
+  V,
+  T01,
+  T02,
+  T03,
+  T04,
+  T05,
+  T06,
+  T07,
+  T08,
+  T09,
+  T10,
+  T11,
+  T12,
+>(
+  value: V,
+  o01: AsyncOperator<V, T01>,
+  o02: AsyncOperator<T01, T02>,
+  o03: AsyncOperator<T02, T03>,
+  o04: AsyncOperator<T03, T04>,
+  o05: AsyncOperator<T04, T05>,
+  o06: AsyncOperator<T05, T06>,
+  o07: AsyncOperator<T06, T07>,
+  o08: AsyncOperator<T07, T08>,
+  o09: AsyncOperator<T08, T09>,
+  o10: AsyncOperator<T09, T10>,
+  o11: AsyncOperator<T10, T11>,
+  o12: AsyncOperator<T11, T12>,
+): Promise<T12>;
+export function pipe<
+  V,
+  T01,
+  T02,
+  T03,
+  T04,
+  T05,
+  T06,
+  T07,
+  T08,
+  T09,
+  T10,
+  T11,
+  T12,
+  T13,
+>(
+  value: V,
+  o01: AsyncOperator<V, T01>,
+  o02: AsyncOperator<T01, T02>,
+  o03: AsyncOperator<T02, T03>,
+  o04: AsyncOperator<T03, T04>,
+  o05: AsyncOperator<T04, T05>,
+  o06: AsyncOperator<T05, T06>,
+  o07: AsyncOperator<T06, T07>,
+  o08: AsyncOperator<T07, T08>,
+  o09: AsyncOperator<T08, T09>,
+  o10: AsyncOperator<T09, T10>,
+  o11: AsyncOperator<T10, T11>,
+  o12: AsyncOperator<T11, T12>,
+  o13: AsyncOperator<T12, T13>,
+): Promise<T13>;
+export function pipe<
+  V,
+  T01,
+  T02,
+  T03,
+  T04,
+  T05,
+  T06,
+  T07,
+  T08,
+  T09,
+  T10,
+  T11,
+  T12,
+  T13,
+  T14,
+>(
+  value: V,
+  o01: AsyncOperator<V, T01>,
+  o02: AsyncOperator<T01, T02>,
+  o03: AsyncOperator<T02, T03>,
+  o04: AsyncOperator<T03, T04>,
+  o05: AsyncOperator<T04, T05>,
+  o06: AsyncOperator<T05, T06>,
+  o07: AsyncOperator<T06, T07>,
+  o08: AsyncOperator<T07, T08>,
+  o09: AsyncOperator<T08, T09>,
+  o10: AsyncOperator<T09, T10>,
+  o11: AsyncOperator<T10, T11>,
+  o12: AsyncOperator<T11, T12>,
+  o13: AsyncOperator<T12, T13>,
+  o14: AsyncOperator<T13, T14>,
+): Promise<T14>;
+export function pipe<
+  V,
+  T01,
+  T02,
+  T03,
+  T04,
+  T05,
+  T06,
+  T07,
+  T08,
+  T09,
+  T10,
+  T11,
+  T12,
+  T13,
+  T14,
+  T15,
+>(
+  value: V,
+  o01: AsyncOperator<V, T01>,
+  o02: AsyncOperator<T01, T02>,
+  o03: AsyncOperator<T02, T03>,
+  o04: AsyncOperator<T03, T04>,
+  o05: AsyncOperator<T04, T05>,
+  o06: AsyncOperator<T05, T06>,
+  o07: AsyncOperator<T06, T07>,
+  o08: AsyncOperator<T07, T08>,
+  o09: AsyncOperator<T08, T09>,
+  o10: AsyncOperator<T09, T10>,
+  o11: AsyncOperator<T10, T11>,
+  o12: AsyncOperator<T11, T12>,
+  o13: AsyncOperator<T12, T13>,
+  o14: AsyncOperator<T13, T14>,
+  o15: AsyncOperator<T14, T15>,
+): Promise<T15>;
+export function pipe<
+  V,
+  T01,
+  T02,
+  T03,
+  T04,
+  T05,
+  T06,
+  T07,
+  T08,
+  T09,
+  T10,
+  T11,
+  T12,
+  T13,
+  T14,
+  T15,
+  T16,
+>(
+  value: V,
+  o01: AsyncOperator<V, T01>,
+  o02: AsyncOperator<T01, T02>,
+  o03: AsyncOperator<T02, T03>,
+  o04: AsyncOperator<T03, T04>,
+  o05: AsyncOperator<T04, T05>,
+  o06: AsyncOperator<T05, T06>,
+  o07: AsyncOperator<T06, T07>,
+  o08: AsyncOperator<T07, T08>,
+  o09: AsyncOperator<T08, T09>,
+  o10: AsyncOperator<T09, T10>,
+  o11: AsyncOperator<T10, T11>,
+  o12: AsyncOperator<T11, T12>,
+  o13: AsyncOperator<T12, T13>,
+  o14: AsyncOperator<T13, T14>,
+  o15: AsyncOperator<T14, T15>,
+  o16: AsyncOperator<T15, T16>,
+): Promise<T16>;
+export function pipe<
+  V,
+  T01,
+  T02,
+  T03,
+  T04,
+  T05,
+  T06,
+  T07,
+  T08,
+  T09,
+  T10,
+  T11,
+  T12,
+  T13,
+  T14,
+  T15,
+  T16,
+  T17,
+>(
+  value: V,
+  o01: AsyncOperator<V, T01>,
+  o02: AsyncOperator<T01, T02>,
+  o03: AsyncOperator<T02, T03>,
+  o04: AsyncOperator<T03, T04>,
+  o05: AsyncOperator<T04, T05>,
+  o06: AsyncOperator<T05, T06>,
+  o07: AsyncOperator<T06, T07>,
+  o08: AsyncOperator<T07, T08>,
+  o09: AsyncOperator<T08, T09>,
+  o10: AsyncOperator<T09, T10>,
+  o11: AsyncOperator<T10, T11>,
+  o12: AsyncOperator<T11, T12>,
+  o13: AsyncOperator<T12, T13>,
+  o14: AsyncOperator<T13, T14>,
+  o15: AsyncOperator<T14, T15>,
+  o16: AsyncOperator<T15, T16>,
+  o17: AsyncOperator<T16, T17>,
+): Promise<T17>;
+export function pipe<
+  V,
+  T01,
+  T02,
+  T03,
+  T04,
+  T05,
+  T06,
+  T07,
+  T08,
+  T09,
+  T10,
+  T11,
+  T12,
+  T13,
+  T14,
+  T15,
+  T16,
+  T17,
+  T18,
+>(
+  value: V,
+  o01: AsyncOperator<V, T01>,
+  o02: AsyncOperator<T01, T02>,
+  o03: AsyncOperator<T02, T03>,
+  o04: AsyncOperator<T03, T04>,
+  o05: AsyncOperator<T04, T05>,
+  o06: AsyncOperator<T05, T06>,
+  o07: AsyncOperator<T06, T07>,
+  o08: AsyncOperator<T07, T08>,
+  o09: AsyncOperator<T08, T09>,
+  o10: AsyncOperator<T09, T10>,
+  o11: AsyncOperator<T10, T11>,
+  o12: AsyncOperator<T11, T12>,
+  o13: AsyncOperator<T12, T13>,
+  o14: AsyncOperator<T13, T14>,
+  o15: AsyncOperator<T14, T15>,
+  o16: AsyncOperator<T15, T16>,
+  o17: AsyncOperator<T16, T17>,
+  o18: AsyncOperator<T17, T18>,
+): Promise<T18>;
+export function pipe<
+  V,
+  T01,
+  T02,
+  T03,
+  T04,
+  T05,
+  T06,
+  T07,
+  T08,
+  T09,
+  T10,
+  T11,
+  T12,
+  T13,
+  T14,
+  T15,
+  T16,
+  T17,
+  T18,
+  T19,
+>(
+  value: V,
+  o01: AsyncOperator<V, T01>,
+  o02: AsyncOperator<T01, T02>,
+  o03: AsyncOperator<T02, T03>,
+  o04: AsyncOperator<T03, T04>,
+  o05: AsyncOperator<T04, T05>,
+  o06: AsyncOperator<T05, T06>,
+  o07: AsyncOperator<T06, T07>,
+  o08: AsyncOperator<T07, T08>,
+  o09: AsyncOperator<T08, T09>,
+  o10: AsyncOperator<T09, T10>,
+  o11: AsyncOperator<T10, T11>,
+  o12: AsyncOperator<T11, T12>,
+  o13: AsyncOperator<T12, T13>,
+  o14: AsyncOperator<T13, T14>,
+  o15: AsyncOperator<T14, T15>,
+  o16: AsyncOperator<T15, T16>,
+  o17: AsyncOperator<T16, T17>,
+  o18: AsyncOperator<T17, T18>,
+  o19: AsyncOperator<T18, T19>,
+): Promise<T19>;
+export function pipe<
+  V,
+  T01,
+  T02,
+  T03,
+  T04,
+  T05,
+  T06,
+  T07,
+  T08,
+  T09,
+  T10,
+  T11,
+  T12,
+  T13,
+  T14,
+  T15,
+  T16,
+  T17,
+  T18,
+  T19,
+  T20,
+>(
+  value: V,
+  o01: AsyncOperator<V, T01>,
+  o02: AsyncOperator<T01, T02>,
+  o03: AsyncOperator<T02, T03>,
+  o04: AsyncOperator<T03, T04>,
+  o05: AsyncOperator<T04, T05>,
+  o06: AsyncOperator<T05, T06>,
+  o07: AsyncOperator<T06, T07>,
+  o08: AsyncOperator<T07, T08>,
+  o09: AsyncOperator<T08, T09>,
+  o10: AsyncOperator<T09, T10>,
+  o11: AsyncOperator<T10, T11>,
+  o12: AsyncOperator<T11, T12>,
+  o13: AsyncOperator<T12, T13>,
+  o14: AsyncOperator<T13, T14>,
+  o15: AsyncOperator<T14, T15>,
+  o16: AsyncOperator<T15, T16>,
+  o17: AsyncOperator<T16, T17>,
+  o18: AsyncOperator<T17, T18>,
+  o19: AsyncOperator<T18, T19>,
+  o20: AsyncOperator<T19, T20>,
+): Promise<T20>;
+
+// deno-lint-ignore no-explicit-any
+export function pipe<V, AsyncOperators extends AsyncOperator<any, unknown>[]>(
+  value: V,
+  ...operators: AsyncOperators
+): Promise<LastAsyncOperatorReturn<AsyncOperators>>;
+
+export async function pipe<V>(
+  value: V,
+  // deno-lint-ignore no-explicit-any
+  ...operators: AsyncOperator<unknown, any>[]
+) {
+  return await operators.reduce(
+    async (result, next) => next(await result),
+    Promise.resolve(value),
+  );
+}
diff --git a/async/mod_test.ts b/async/pipe_test.ts
similarity index 99%
rename from async/mod_test.ts
rename to async/pipe_test.ts
index f640b13..c1b65e2 100644
--- a/async/mod_test.ts
+++ b/async/pipe_test.ts
@@ -1,7 +1,7 @@
 import { test } from "@cross/test";
 import { assertEquals } from "@std/assert";
 import { assertType, type IsExact } from "@std/testing/types";
-import { pipe } from "./mod.ts";
+import { pipe } from "./pipe.ts";
 
 await test("pipe with no operators should return the input", async () => {
   assertEquals(await pipe(1), 1);
diff --git a/compose.ts b/compose.ts
new file mode 100644
index 0000000..038cfca
--- /dev/null
+++ b/compose.ts
@@ -0,0 +1,467 @@
+import type { Operator } from "./operator.ts";
+import type { LastOperatorReturn } from "./_common.ts";
+
+/**
+ * Composes a sequence of operators to create a new function.
+ * Supports type inference for operators and the return type of the final operator.
+ *
+ * > [!NOTE]
+ * >
+ * > If more than 20 operators are used, their types default to `Operator<unknown, unknown>`,
+ * > requiring explicit type annotations.
+ *
+ * @param operators - A sequence of operators to apply to the value.
+ * @returns A function that processes the value through all operators and returns the final result.
+ *
+ * @example
+ * ```ts
+ * import { compose } from "@core/pipe";
+ *
+ * const result = compose(
+ *   (v: number) => v + 1,  // The first operator requires an explicit type
+ *   (v) => v * 2,          // inferred as (v: number) => number
+ *   (v) => v.toString(),   // inferred as (v: number) => string
+ * )(1);
+ * console.log(result); // "4"
+ * ```
+ */
+export function compose<V, T01>(
+  o01: Operator<V, T01>,
+): Operator<V, T01>;
+export function compose<V, T01, T02>(
+  o01: Operator<V, T01>,
+  o02: Operator<T01, T02>,
+): Operator<V, T02>;
+export function compose<V, T01, T02, T03>(
+  o01: Operator<V, T01>,
+  o02: Operator<T01, T02>,
+  o03: Operator<T02, T03>,
+): Operator<V, T03>;
+export function compose<V, T01, T02, T03, T04>(
+  o01: Operator<V, T01>,
+  o02: Operator<T01, T02>,
+  o03: Operator<T02, T03>,
+  o04: Operator<T03, T04>,
+): Operator<V, T04>;
+export function compose<V, T01, T02, T03, T04, T05>(
+  o01: Operator<V, T01>,
+  o02: Operator<T01, T02>,
+  o03: Operator<T02, T03>,
+  o04: Operator<T03, T04>,
+  o05: Operator<T04, T05>,
+): Operator<V, T05>;
+export function compose<V, T01, T02, T03, T04, T05, T06>(
+  o01: Operator<V, T01>,
+  o02: Operator<T01, T02>,
+  o03: Operator<T02, T03>,
+  o04: Operator<T03, T04>,
+  o05: Operator<T04, T05>,
+  o06: Operator<T05, T06>,
+): Operator<V, T06>;
+export function compose<V, T01, T02, T03, T04, T05, T06, T07>(
+  o01: Operator<V, T01>,
+  o02: Operator<T01, T02>,
+  o03: Operator<T02, T03>,
+  o04: Operator<T03, T04>,
+  o05: Operator<T04, T05>,
+  o06: Operator<T05, T06>,
+  o07: Operator<T06, T07>,
+): Operator<V, T07>;
+export function compose<V, T01, T02, T03, T04, T05, T06, T07, T08>(
+  o01: Operator<V, T01>,
+  o02: Operator<T01, T02>,
+  o03: Operator<T02, T03>,
+  o04: Operator<T03, T04>,
+  o05: Operator<T04, T05>,
+  o06: Operator<T05, T06>,
+  o07: Operator<T06, T07>,
+  o08: Operator<T07, T08>,
+): Operator<V, T08>;
+export function compose<V, T01, T02, T03, T04, T05, T06, T07, T08, T09>(
+  o01: Operator<V, T01>,
+  o02: Operator<T01, T02>,
+  o03: Operator<T02, T03>,
+  o04: Operator<T03, T04>,
+  o05: Operator<T04, T05>,
+  o06: Operator<T05, T06>,
+  o07: Operator<T06, T07>,
+  o08: Operator<T07, T08>,
+  o09: Operator<T08, T09>,
+): Operator<V, T09>;
+export function compose<V, T01, T02, T03, T04, T05, T06, T07, T08, T09, T10>(
+  o01: Operator<V, T01>,
+  o02: Operator<T01, T02>,
+  o03: Operator<T02, T03>,
+  o04: Operator<T03, T04>,
+  o05: Operator<T04, T05>,
+  o06: Operator<T05, T06>,
+  o07: Operator<T06, T07>,
+  o08: Operator<T07, T08>,
+  o09: Operator<T08, T09>,
+  o10: Operator<T09, T10>,
+): Operator<V, T10>;
+export function compose<
+  V,
+  T01,
+  T02,
+  T03,
+  T04,
+  T05,
+  T06,
+  T07,
+  T08,
+  T09,
+  T10,
+  T11,
+>(
+  o01: Operator<V, T01>,
+  o02: Operator<T01, T02>,
+  o03: Operator<T02, T03>,
+  o04: Operator<T03, T04>,
+  o05: Operator<T04, T05>,
+  o06: Operator<T05, T06>,
+  o07: Operator<T06, T07>,
+  o08: Operator<T07, T08>,
+  o09: Operator<T08, T09>,
+  o10: Operator<T09, T10>,
+  o11: Operator<T10, T11>,
+): Operator<V, T11>;
+export function compose<
+  V,
+  T01,
+  T02,
+  T03,
+  T04,
+  T05,
+  T06,
+  T07,
+  T08,
+  T09,
+  T10,
+  T11,
+  T12,
+>(
+  o01: Operator<V, T01>,
+  o02: Operator<T01, T02>,
+  o03: Operator<T02, T03>,
+  o04: Operator<T03, T04>,
+  o05: Operator<T04, T05>,
+  o06: Operator<T05, T06>,
+  o07: Operator<T06, T07>,
+  o08: Operator<T07, T08>,
+  o09: Operator<T08, T09>,
+  o10: Operator<T09, T10>,
+  o11: Operator<T10, T11>,
+  o12: Operator<T11, T12>,
+): Operator<V, T12>;
+export function compose<
+  V,
+  T01,
+  T02,
+  T03,
+  T04,
+  T05,
+  T06,
+  T07,
+  T08,
+  T09,
+  T10,
+  T11,
+  T12,
+  T13,
+>(
+  o01: Operator<V, T01>,
+  o02: Operator<T01, T02>,
+  o03: Operator<T02, T03>,
+  o04: Operator<T03, T04>,
+  o05: Operator<T04, T05>,
+  o06: Operator<T05, T06>,
+  o07: Operator<T06, T07>,
+  o08: Operator<T07, T08>,
+  o09: Operator<T08, T09>,
+  o10: Operator<T09, T10>,
+  o11: Operator<T10, T11>,
+  o12: Operator<T11, T12>,
+  o13: Operator<T12, T13>,
+): Operator<V, T13>;
+export function compose<
+  V,
+  T01,
+  T02,
+  T03,
+  T04,
+  T05,
+  T06,
+  T07,
+  T08,
+  T09,
+  T10,
+  T11,
+  T12,
+  T13,
+  T14,
+>(
+  o01: Operator<V, T01>,
+  o02: Operator<T01, T02>,
+  o03: Operator<T02, T03>,
+  o04: Operator<T03, T04>,
+  o05: Operator<T04, T05>,
+  o06: Operator<T05, T06>,
+  o07: Operator<T06, T07>,
+  o08: Operator<T07, T08>,
+  o09: Operator<T08, T09>,
+  o10: Operator<T09, T10>,
+  o11: Operator<T10, T11>,
+  o12: Operator<T11, T12>,
+  o13: Operator<T12, T13>,
+  o14: Operator<T13, T14>,
+): Operator<V, T14>;
+export function compose<
+  V,
+  T01,
+  T02,
+  T03,
+  T04,
+  T05,
+  T06,
+  T07,
+  T08,
+  T09,
+  T10,
+  T11,
+  T12,
+  T13,
+  T14,
+  T15,
+>(
+  o01: Operator<V, T01>,
+  o02: Operator<T01, T02>,
+  o03: Operator<T02, T03>,
+  o04: Operator<T03, T04>,
+  o05: Operator<T04, T05>,
+  o06: Operator<T05, T06>,
+  o07: Operator<T06, T07>,
+  o08: Operator<T07, T08>,
+  o09: Operator<T08, T09>,
+  o10: Operator<T09, T10>,
+  o11: Operator<T10, T11>,
+  o12: Operator<T11, T12>,
+  o13: Operator<T12, T13>,
+  o14: Operator<T13, T14>,
+  o15: Operator<T14, T15>,
+): Operator<V, T15>;
+export function compose<
+  V,
+  T01,
+  T02,
+  T03,
+  T04,
+  T05,
+  T06,
+  T07,
+  T08,
+  T09,
+  T10,
+  T11,
+  T12,
+  T13,
+  T14,
+  T15,
+  T16,
+>(
+  o01: Operator<V, T01>,
+  o02: Operator<T01, T02>,
+  o03: Operator<T02, T03>,
+  o04: Operator<T03, T04>,
+  o05: Operator<T04, T05>,
+  o06: Operator<T05, T06>,
+  o07: Operator<T06, T07>,
+  o08: Operator<T07, T08>,
+  o09: Operator<T08, T09>,
+  o10: Operator<T09, T10>,
+  o11: Operator<T10, T11>,
+  o12: Operator<T11, T12>,
+  o13: Operator<T12, T13>,
+  o14: Operator<T13, T14>,
+  o15: Operator<T14, T15>,
+  o16: Operator<T15, T16>,
+): Operator<V, T16>;
+export function compose<
+  V,
+  T01,
+  T02,
+  T03,
+  T04,
+  T05,
+  T06,
+  T07,
+  T08,
+  T09,
+  T10,
+  T11,
+  T12,
+  T13,
+  T14,
+  T15,
+  T16,
+  T17,
+>(
+  o01: Operator<V, T01>,
+  o02: Operator<T01, T02>,
+  o03: Operator<T02, T03>,
+  o04: Operator<T03, T04>,
+  o05: Operator<T04, T05>,
+  o06: Operator<T05, T06>,
+  o07: Operator<T06, T07>,
+  o08: Operator<T07, T08>,
+  o09: Operator<T08, T09>,
+  o10: Operator<T09, T10>,
+  o11: Operator<T10, T11>,
+  o12: Operator<T11, T12>,
+  o13: Operator<T12, T13>,
+  o14: Operator<T13, T14>,
+  o15: Operator<T14, T15>,
+  o16: Operator<T15, T16>,
+  o17: Operator<T16, T17>,
+): Operator<V, T17>;
+export function compose<
+  V,
+  T01,
+  T02,
+  T03,
+  T04,
+  T05,
+  T06,
+  T07,
+  T08,
+  T09,
+  T10,
+  T11,
+  T12,
+  T13,
+  T14,
+  T15,
+  T16,
+  T17,
+  T18,
+>(
+  o01: Operator<V, T01>,
+  o02: Operator<T01, T02>,
+  o03: Operator<T02, T03>,
+  o04: Operator<T03, T04>,
+  o05: Operator<T04, T05>,
+  o06: Operator<T05, T06>,
+  o07: Operator<T06, T07>,
+  o08: Operator<T07, T08>,
+  o09: Operator<T08, T09>,
+  o10: Operator<T09, T10>,
+  o11: Operator<T10, T11>,
+  o12: Operator<T11, T12>,
+  o13: Operator<T12, T13>,
+  o14: Operator<T13, T14>,
+  o15: Operator<T14, T15>,
+  o16: Operator<T15, T16>,
+  o17: Operator<T16, T17>,
+  o18: Operator<T17, T18>,
+): Operator<V, T18>;
+export function compose<
+  V,
+  T01,
+  T02,
+  T03,
+  T04,
+  T05,
+  T06,
+  T07,
+  T08,
+  T09,
+  T10,
+  T11,
+  T12,
+  T13,
+  T14,
+  T15,
+  T16,
+  T17,
+  T18,
+  T19,
+>(
+  o01: Operator<V, T01>,
+  o02: Operator<T01, T02>,
+  o03: Operator<T02, T03>,
+  o04: Operator<T03, T04>,
+  o05: Operator<T04, T05>,
+  o06: Operator<T05, T06>,
+  o07: Operator<T06, T07>,
+  o08: Operator<T07, T08>,
+  o09: Operator<T08, T09>,
+  o10: Operator<T09, T10>,
+  o11: Operator<T10, T11>,
+  o12: Operator<T11, T12>,
+  o13: Operator<T12, T13>,
+  o14: Operator<T13, T14>,
+  o15: Operator<T14, T15>,
+  o16: Operator<T15, T16>,
+  o17: Operator<T16, T17>,
+  o18: Operator<T17, T18>,
+  o19: Operator<T18, T19>,
+): Operator<V, T19>;
+export function compose<
+  V,
+  T01,
+  T02,
+  T03,
+  T04,
+  T05,
+  T06,
+  T07,
+  T08,
+  T09,
+  T10,
+  T11,
+  T12,
+  T13,
+  T14,
+  T15,
+  T16,
+  T17,
+  T18,
+  T19,
+  T20,
+>(
+  o01: Operator<V, T01>,
+  o02: Operator<T01, T02>,
+  o03: Operator<T02, T03>,
+  o04: Operator<T03, T04>,
+  o05: Operator<T04, T05>,
+  o06: Operator<T05, T06>,
+  o07: Operator<T06, T07>,
+  o08: Operator<T07, T08>,
+  o09: Operator<T08, T09>,
+  o10: Operator<T09, T10>,
+  o11: Operator<T10, T11>,
+  o12: Operator<T11, T12>,
+  o13: Operator<T12, T13>,
+  o14: Operator<T13, T14>,
+  o15: Operator<T14, T15>,
+  o16: Operator<T15, T16>,
+  o17: Operator<T16, T17>,
+  o18: Operator<T17, T18>,
+  o19: Operator<T18, T19>,
+  o20: Operator<T19, T20>,
+): Operator<V, T20>;
+
+// deno-lint-ignore no-explicit-any
+export function compose<V, Operators extends Operator<any, unknown>[]>(
+  ...operators: Operators
+): Operator<V, LastOperatorReturn<Operators>>;
+
+// deno-lint-ignore no-explicit-any
+export function compose<V>(...operators: Operator<unknown, any>[]) {
+  return (value: V) => {
+    return operators.reduce(
+      (result, next) => next(result),
+      value,
+    );
+  };
+}
diff --git a/compose_test.ts b/compose_test.ts
new file mode 100644
index 0000000..e08042a
--- /dev/null
+++ b/compose_test.ts
@@ -0,0 +1,142 @@
+import { test } from "@cross/test";
+import { assertEquals } from "@std/assert";
+import { assertType, type IsExact } from "@std/testing/types";
+import { compose } from "./compose.ts";
+
+await test("compose with no operators should return an identity function", () => {
+  assertEquals(compose()(1), 1);
+});
+
+await test("compose with one operator should return the operator", () => {
+  assertEquals(compose((v: number) => v * 2)(1), 2);
+});
+
+await test("compose with one operator requires explicity type annotation", () => {
+  compose((v) => {
+    assertType<IsExact<typeof v, unknown>>(true);
+  });
+  compose((v: number) => {
+    assertType<IsExact<typeof v, number>>(true);
+    return v.toString();
+  });
+});
+
+await test("compose with two operators should return a composed operator", () => {
+  assertEquals(compose((v: number) => v * 2, (v) => v * 2)(1), 4);
+});
+
+await test("compose with two operators should resolve the type properly", () => {
+  compose((v: number) => {
+    assertType<IsExact<typeof v, number>>(true);
+    return v.toString();
+  }, (v) => {
+    assertType<IsExact<typeof v, string>>(true);
+    return v.length;
+  });
+});
+
+await test("compose with three operators should return a composed operator", () => {
+  assertEquals(compose((v: number) => v * 2, (v) => v * 2, (v) => v * 2)(1), 8);
+});
+
+await test("compose with three operators should resolve the type properly", () => {
+  compose((v: number) => {
+    assertType<IsExact<typeof v, number>>(true);
+    return v.toString();
+  }, (v) => {
+    assertType<IsExact<typeof v, string>>(true);
+    return v.length;
+  }, (v) => {
+    assertType<IsExact<typeof v, number>>(true);
+    return v.toString();
+  });
+});
+
+await test("compose with twenty operators should return a composed operator", () => {
+  assertEquals(compose(...Array(20).fill((v: number) => v * 2))(1), 2 ** 20);
+});
+
+await test("compose with twenty operators should resolve the type properly", () => {
+  compose(
+    (v: number) => {
+      assertType<IsExact<typeof v, number>>(true);
+      return v;
+    },
+    (v) => {
+      assertType<IsExact<typeof v, number>>(true);
+      return v;
+    },
+    (v) => {
+      assertType<IsExact<typeof v, number>>(true);
+      return v;
+    },
+    (v) => {
+      assertType<IsExact<typeof v, number>>(true);
+      return v;
+    },
+    (v) => {
+      assertType<IsExact<typeof v, number>>(true);
+      return v;
+    },
+    (v) => {
+      assertType<IsExact<typeof v, number>>(true);
+      return v;
+    },
+    (v) => {
+      assertType<IsExact<typeof v, number>>(true);
+      return v;
+    },
+    (v) => {
+      assertType<IsExact<typeof v, number>>(true);
+      return v;
+    },
+    (v) => {
+      assertType<IsExact<typeof v, number>>(true);
+      return v;
+    },
+    (v) => {
+      assertType<IsExact<typeof v, number>>(true);
+      return v;
+    },
+    (v) => {
+      assertType<IsExact<typeof v, number>>(true);
+      return v;
+    },
+    (v) => {
+      assertType<IsExact<typeof v, number>>(true);
+      return v;
+    },
+    (v) => {
+      assertType<IsExact<typeof v, number>>(true);
+      return v;
+    },
+    (v) => {
+      assertType<IsExact<typeof v, number>>(true);
+      return v;
+    },
+    (v) => {
+      assertType<IsExact<typeof v, number>>(true);
+      return v;
+    },
+    (v) => {
+      assertType<IsExact<typeof v, number>>(true);
+      return v;
+    },
+    (v) => {
+      assertType<IsExact<typeof v, number>>(true);
+      return v;
+    },
+    (v) => {
+      assertType<IsExact<typeof v, number>>(true);
+      return v;
+    },
+    (v) => {
+      assertType<IsExact<typeof v, number>>(true);
+      return v;
+    },
+    (v) => {
+      assertType<IsExact<typeof v, number>>(true);
+      return v;
+    },
+  );
+});
diff --git a/deno.jsonc b/deno.jsonc
index 5a3b249..c65f81f 100644
--- a/deno.jsonc
+++ b/deno.jsonc
@@ -3,7 +3,13 @@
   "version": "0.0.0",
   "exports": {
     ".": "./mod.ts",
-    "./async": "./async/mod.ts"
+    "./async": "./async/mod.ts",
+    "./async/compose": "./async/compose.ts",
+    "./async/operator": "./async/operator.ts",
+    "./async/pipe": "./async/pipe.ts",
+    "./compose": "./compose.ts",
+    "./operator": "./operator.ts",
+    "./pipe": "./pipe.ts"
   },
   "exclude": [
     ".coverage/**"
diff --git a/mod.ts b/mod.ts
index 0e0c09c..083e9a6 100644
--- a/mod.ts
+++ b/mod.ts
@@ -1,482 +1,3 @@
-/**
- * Operator function that takes a value and returns a new value.
- */
-export type Operator<A, B> = (v: A) => B;
-
-/**
- * @internal
- */
-type LastOperatorReturn<T extends Operator<unknown, unknown>[]> = T extends
-  [...Operator<unknown, unknown>[], Operator<unknown, infer R>] ? R
-  : never;
-
-/**
- * Pipes a value through a series of operator functions.
- * Supports type inference for both the operator functions and the return value of the final operator.
- *
- * > [!NOTE]
- * >
- * > If the number of operators exceeds 20, the operator functions' types will default to
- * > `Operator<unknown, unknown>`, requiring explicit type annotations.
- *
- * @param value - The initial value to be processed through the operators.
- * @param operators - A sequence of functions to apply to the value.
- * @returns The final value after being processed through all the operators.
- *
- * @example
- * ```ts
- * import { pipe } from "@core/pipe";
- *
- * const result = pipe(
- *   1,
- *   (v) => v + 1,  // inferred as (v: number) => number
- *   (v) => v * 2,  // inferred as (v: number) => number
- *   (v) => v.toString(), // inferred as (v: number) => string
- * );
- * console.log(result); // "4"
- * ```
- */
-export function pipe<V>(value: V): V;
-export function pipe<V, T01>(value: V, o01: Operator<V, T01>): T01;
-export function pipe<V, T01, T02>(
-  value: V,
-  o01: Operator<V, T01>,
-  o02: Operator<T01, T02>,
-): T02;
-export function pipe<V, T01, T02, T03>(
-  value: V,
-  o01: Operator<V, T01>,
-  o02: Operator<T01, T02>,
-  o03: Operator<T02, T03>,
-): T03;
-export function pipe<V, T01, T02, T03, T04>(
-  value: V,
-  o01: Operator<V, T01>,
-  o02: Operator<T01, T02>,
-  o03: Operator<T02, T03>,
-  o04: Operator<T03, T04>,
-): T04;
-export function pipe<V, T01, T02, T03, T04, T05>(
-  value: V,
-  o01: Operator<V, T01>,
-  o02: Operator<T01, T02>,
-  o03: Operator<T02, T03>,
-  o04: Operator<T03, T04>,
-  o05: Operator<T04, T05>,
-): T05;
-export function pipe<V, T01, T02, T03, T04, T05, T06>(
-  value: V,
-  o01: Operator<V, T01>,
-  o02: Operator<T01, T02>,
-  o03: Operator<T02, T03>,
-  o04: Operator<T03, T04>,
-  o05: Operator<T04, T05>,
-  o06: Operator<T05, T06>,
-): T06;
-export function pipe<V, T01, T02, T03, T04, T05, T06, T07>(
-  value: V,
-  o01: Operator<V, T01>,
-  o02: Operator<T01, T02>,
-  o03: Operator<T02, T03>,
-  o04: Operator<T03, T04>,
-  o05: Operator<T04, T05>,
-  o06: Operator<T05, T06>,
-  o07: Operator<T06, T07>,
-): T07;
-export function pipe<V, T01, T02, T03, T04, T05, T06, T07, T08>(
-  value: V,
-  o01: Operator<V, T01>,
-  o02: Operator<T01, T02>,
-  o03: Operator<T02, T03>,
-  o04: Operator<T03, T04>,
-  o05: Operator<T04, T05>,
-  o06: Operator<T05, T06>,
-  o07: Operator<T06, T07>,
-  o08: Operator<T07, T08>,
-): T08;
-export function pipe<V, T01, T02, T03, T04, T05, T06, T07, T08, T09>(
-  value: V,
-  o01: Operator<V, T01>,
-  o02: Operator<T01, T02>,
-  o03: Operator<T02, T03>,
-  o04: Operator<T03, T04>,
-  o05: Operator<T04, T05>,
-  o06: Operator<T05, T06>,
-  o07: Operator<T06, T07>,
-  o08: Operator<T07, T08>,
-  o09: Operator<T08, T09>,
-): T09;
-export function pipe<V, T01, T02, T03, T04, T05, T06, T07, T08, T09, T10>(
-  value: V,
-  o01: Operator<V, T01>,
-  o02: Operator<T01, T02>,
-  o03: Operator<T02, T03>,
-  o04: Operator<T03, T04>,
-  o05: Operator<T04, T05>,
-  o06: Operator<T05, T06>,
-  o07: Operator<T06, T07>,
-  o08: Operator<T07, T08>,
-  o09: Operator<T08, T09>,
-  o10: Operator<T09, T10>,
-): T10;
-export function pipe<V, T01, T02, T03, T04, T05, T06, T07, T08, T09, T10, T11>(
-  value: V,
-  o01: Operator<V, T01>,
-  o02: Operator<T01, T02>,
-  o03: Operator<T02, T03>,
-  o04: Operator<T03, T04>,
-  o05: Operator<T04, T05>,
-  o06: Operator<T05, T06>,
-  o07: Operator<T06, T07>,
-  o08: Operator<T07, T08>,
-  o09: Operator<T08, T09>,
-  o10: Operator<T09, T10>,
-  o11: Operator<T10, T11>,
-): T11;
-export function pipe<
-  V,
-  T01,
-  T02,
-  T03,
-  T04,
-  T05,
-  T06,
-  T07,
-  T08,
-  T09,
-  T10,
-  T11,
-  T12,
->(
-  value: V,
-  o01: Operator<V, T01>,
-  o02: Operator<T01, T02>,
-  o03: Operator<T02, T03>,
-  o04: Operator<T03, T04>,
-  o05: Operator<T04, T05>,
-  o06: Operator<T05, T06>,
-  o07: Operator<T06, T07>,
-  o08: Operator<T07, T08>,
-  o09: Operator<T08, T09>,
-  o10: Operator<T09, T10>,
-  o11: Operator<T10, T11>,
-  o12: Operator<T11, T12>,
-): T12;
-export function pipe<
-  V,
-  T01,
-  T02,
-  T03,
-  T04,
-  T05,
-  T06,
-  T07,
-  T08,
-  T09,
-  T10,
-  T11,
-  T12,
-  T13,
->(
-  value: V,
-  o01: Operator<V, T01>,
-  o02: Operator<T01, T02>,
-  o03: Operator<T02, T03>,
-  o04: Operator<T03, T04>,
-  o05: Operator<T04, T05>,
-  o06: Operator<T05, T06>,
-  o07: Operator<T06, T07>,
-  o08: Operator<T07, T08>,
-  o09: Operator<T08, T09>,
-  o10: Operator<T09, T10>,
-  o11: Operator<T10, T11>,
-  o12: Operator<T11, T12>,
-  o13: Operator<T12, T13>,
-): T13;
-export function pipe<
-  V,
-  T01,
-  T02,
-  T03,
-  T04,
-  T05,
-  T06,
-  T07,
-  T08,
-  T09,
-  T10,
-  T11,
-  T12,
-  T13,
-  T14,
->(
-  value: V,
-  o01: Operator<V, T01>,
-  o02: Operator<T01, T02>,
-  o03: Operator<T02, T03>,
-  o04: Operator<T03, T04>,
-  o05: Operator<T04, T05>,
-  o06: Operator<T05, T06>,
-  o07: Operator<T06, T07>,
-  o08: Operator<T07, T08>,
-  o09: Operator<T08, T09>,
-  o10: Operator<T09, T10>,
-  o11: Operator<T10, T11>,
-  o12: Operator<T11, T12>,
-  o13: Operator<T12, T13>,
-  o14: Operator<T13, T14>,
-): T14;
-export function pipe<
-  V,
-  T01,
-  T02,
-  T03,
-  T04,
-  T05,
-  T06,
-  T07,
-  T08,
-  T09,
-  T10,
-  T11,
-  T12,
-  T13,
-  T14,
-  T15,
->(
-  value: V,
-  o01: Operator<V, T01>,
-  o02: Operator<T01, T02>,
-  o03: Operator<T02, T03>,
-  o04: Operator<T03, T04>,
-  o05: Operator<T04, T05>,
-  o06: Operator<T05, T06>,
-  o07: Operator<T06, T07>,
-  o08: Operator<T07, T08>,
-  o09: Operator<T08, T09>,
-  o10: Operator<T09, T10>,
-  o11: Operator<T10, T11>,
-  o12: Operator<T11, T12>,
-  o13: Operator<T12, T13>,
-  o14: Operator<T13, T14>,
-  o15: Operator<T14, T15>,
-): T15;
-export function pipe<
-  V,
-  T01,
-  T02,
-  T03,
-  T04,
-  T05,
-  T06,
-  T07,
-  T08,
-  T09,
-  T10,
-  T11,
-  T12,
-  T13,
-  T14,
-  T15,
-  T16,
->(
-  value: V,
-  o01: Operator<V, T01>,
-  o02: Operator<T01, T02>,
-  o03: Operator<T02, T03>,
-  o04: Operator<T03, T04>,
-  o05: Operator<T04, T05>,
-  o06: Operator<T05, T06>,
-  o07: Operator<T06, T07>,
-  o08: Operator<T07, T08>,
-  o09: Operator<T08, T09>,
-  o10: Operator<T09, T10>,
-  o11: Operator<T10, T11>,
-  o12: Operator<T11, T12>,
-  o13: Operator<T12, T13>,
-  o14: Operator<T13, T14>,
-  o15: Operator<T14, T15>,
-  o16: Operator<T15, T16>,
-): T16;
-export function pipe<
-  V,
-  T01,
-  T02,
-  T03,
-  T04,
-  T05,
-  T06,
-  T07,
-  T08,
-  T09,
-  T10,
-  T11,
-  T12,
-  T13,
-  T14,
-  T15,
-  T16,
-  T17,
->(
-  value: V,
-  o01: Operator<V, T01>,
-  o02: Operator<T01, T02>,
-  o03: Operator<T02, T03>,
-  o04: Operator<T03, T04>,
-  o05: Operator<T04, T05>,
-  o06: Operator<T05, T06>,
-  o07: Operator<T06, T07>,
-  o08: Operator<T07, T08>,
-  o09: Operator<T08, T09>,
-  o10: Operator<T09, T10>,
-  o11: Operator<T10, T11>,
-  o12: Operator<T11, T12>,
-  o13: Operator<T12, T13>,
-  o14: Operator<T13, T14>,
-  o15: Operator<T14, T15>,
-  o16: Operator<T15, T16>,
-  o17: Operator<T16, T17>,
-): T17;
-export function pipe<
-  V,
-  T01,
-  T02,
-  T03,
-  T04,
-  T05,
-  T06,
-  T07,
-  T08,
-  T09,
-  T10,
-  T11,
-  T12,
-  T13,
-  T14,
-  T15,
-  T16,
-  T17,
-  T18,
->(
-  value: V,
-  o01: Operator<V, T01>,
-  o02: Operator<T01, T02>,
-  o03: Operator<T02, T03>,
-  o04: Operator<T03, T04>,
-  o05: Operator<T04, T05>,
-  o06: Operator<T05, T06>,
-  o07: Operator<T06, T07>,
-  o08: Operator<T07, T08>,
-  o09: Operator<T08, T09>,
-  o10: Operator<T09, T10>,
-  o11: Operator<T10, T11>,
-  o12: Operator<T11, T12>,
-  o13: Operator<T12, T13>,
-  o14: Operator<T13, T14>,
-  o15: Operator<T14, T15>,
-  o16: Operator<T15, T16>,
-  o17: Operator<T16, T17>,
-  o18: Operator<T17, T18>,
-): T18;
-export function pipe<
-  V,
-  T01,
-  T02,
-  T03,
-  T04,
-  T05,
-  T06,
-  T07,
-  T08,
-  T09,
-  T10,
-  T11,
-  T12,
-  T13,
-  T14,
-  T15,
-  T16,
-  T17,
-  T18,
-  T19,
->(
-  value: V,
-  o01: Operator<V, T01>,
-  o02: Operator<T01, T02>,
-  o03: Operator<T02, T03>,
-  o04: Operator<T03, T04>,
-  o05: Operator<T04, T05>,
-  o06: Operator<T05, T06>,
-  o07: Operator<T06, T07>,
-  o08: Operator<T07, T08>,
-  o09: Operator<T08, T09>,
-  o10: Operator<T09, T10>,
-  o11: Operator<T10, T11>,
-  o12: Operator<T11, T12>,
-  o13: Operator<T12, T13>,
-  o14: Operator<T13, T14>,
-  o15: Operator<T14, T15>,
-  o16: Operator<T15, T16>,
-  o17: Operator<T16, T17>,
-  o18: Operator<T17, T18>,
-  o19: Operator<T18, T19>,
-): T19;
-export function pipe<
-  V,
-  T01,
-  T02,
-  T03,
-  T04,
-  T05,
-  T06,
-  T07,
-  T08,
-  T09,
-  T10,
-  T11,
-  T12,
-  T13,
-  T14,
-  T15,
-  T16,
-  T17,
-  T18,
-  T19,
-  T20,
->(
-  value: V,
-  o01: Operator<V, T01>,
-  o02: Operator<T01, T02>,
-  o03: Operator<T02, T03>,
-  o04: Operator<T03, T04>,
-  o05: Operator<T04, T05>,
-  o06: Operator<T05, T06>,
-  o07: Operator<T06, T07>,
-  o08: Operator<T07, T08>,
-  o09: Operator<T08, T09>,
-  o10: Operator<T09, T10>,
-  o11: Operator<T10, T11>,
-  o12: Operator<T11, T12>,
-  o13: Operator<T12, T13>,
-  o14: Operator<T13, T14>,
-  o15: Operator<T14, T15>,
-  o16: Operator<T15, T16>,
-  o17: Operator<T16, T17>,
-  o18: Operator<T17, T18>,
-  o19: Operator<T18, T19>,
-  o20: Operator<T19, T20>,
-): T20;
-
-// deno-lint-ignore no-explicit-any
-export function pipe<V, Operators extends Operator<any, unknown>[]>(
-  value: V,
-  ...operators: Operators
-): LastOperatorReturn<Operators>;
-
-// deno-lint-ignore no-explicit-any
-export function pipe<V>(value: V, ...operators: Operator<unknown, any>[]) {
-  return operators.reduce(
-    (result, next) => next(result),
-    value,
-  );
-}
+export type { Operator } from "./operator.ts";
+export * from "./compose.ts";
+export * from "./pipe.ts";
diff --git a/operator.ts b/operator.ts
new file mode 100644
index 0000000..63af12d
--- /dev/null
+++ b/operator.ts
@@ -0,0 +1,4 @@
+/**
+ * Operator function that takes a value and returns a new value.
+ */
+export type Operator<A, B> = (v: A) => B;
diff --git a/pipe.ts b/pipe.ts
new file mode 100644
index 0000000..67d7f97
--- /dev/null
+++ b/pipe.ts
@@ -0,0 +1,473 @@
+import type { Operator } from "./operator.ts";
+import type { LastOperatorReturn } from "./_common.ts";
+
+/**
+ * Pipes a value through a series of operator functions.
+ * Supports type inference for both the operator functions and the return value of the final operator.
+ *
+ * > [!NOTE]
+ * >
+ * > If the number of operators exceeds 20, the operator functions' types will default to
+ * > `Operator<unknown, unknown>`, requiring explicit type annotations.
+ *
+ * @param value - The initial value to be processed through the operators.
+ * @param operators - A sequence of functions to apply to the value.
+ * @returns The final value after being processed through all the operators.
+ *
+ * @example
+ * ```ts
+ * import { pipe } from "@core/pipe";
+ *
+ * const result = pipe(
+ *   1,
+ *   (v) => v + 1,  // inferred as (v: number) => number
+ *   (v) => v * 2,  // inferred as (v: number) => number
+ *   (v) => v.toString(), // inferred as (v: number) => string
+ * );
+ * console.log(result); // "4"
+ * ```
+ */
+export function pipe<V>(value: V): V;
+export function pipe<V, T01>(value: V, o01: Operator<V, T01>): T01;
+export function pipe<V, T01, T02>(
+  value: V,
+  o01: Operator<V, T01>,
+  o02: Operator<T01, T02>,
+): T02;
+export function pipe<V, T01, T02, T03>(
+  value: V,
+  o01: Operator<V, T01>,
+  o02: Operator<T01, T02>,
+  o03: Operator<T02, T03>,
+): T03;
+export function pipe<V, T01, T02, T03, T04>(
+  value: V,
+  o01: Operator<V, T01>,
+  o02: Operator<T01, T02>,
+  o03: Operator<T02, T03>,
+  o04: Operator<T03, T04>,
+): T04;
+export function pipe<V, T01, T02, T03, T04, T05>(
+  value: V,
+  o01: Operator<V, T01>,
+  o02: Operator<T01, T02>,
+  o03: Operator<T02, T03>,
+  o04: Operator<T03, T04>,
+  o05: Operator<T04, T05>,
+): T05;
+export function pipe<V, T01, T02, T03, T04, T05, T06>(
+  value: V,
+  o01: Operator<V, T01>,
+  o02: Operator<T01, T02>,
+  o03: Operator<T02, T03>,
+  o04: Operator<T03, T04>,
+  o05: Operator<T04, T05>,
+  o06: Operator<T05, T06>,
+): T06;
+export function pipe<V, T01, T02, T03, T04, T05, T06, T07>(
+  value: V,
+  o01: Operator<V, T01>,
+  o02: Operator<T01, T02>,
+  o03: Operator<T02, T03>,
+  o04: Operator<T03, T04>,
+  o05: Operator<T04, T05>,
+  o06: Operator<T05, T06>,
+  o07: Operator<T06, T07>,
+): T07;
+export function pipe<V, T01, T02, T03, T04, T05, T06, T07, T08>(
+  value: V,
+  o01: Operator<V, T01>,
+  o02: Operator<T01, T02>,
+  o03: Operator<T02, T03>,
+  o04: Operator<T03, T04>,
+  o05: Operator<T04, T05>,
+  o06: Operator<T05, T06>,
+  o07: Operator<T06, T07>,
+  o08: Operator<T07, T08>,
+): T08;
+export function pipe<V, T01, T02, T03, T04, T05, T06, T07, T08, T09>(
+  value: V,
+  o01: Operator<V, T01>,
+  o02: Operator<T01, T02>,
+  o03: Operator<T02, T03>,
+  o04: Operator<T03, T04>,
+  o05: Operator<T04, T05>,
+  o06: Operator<T05, T06>,
+  o07: Operator<T06, T07>,
+  o08: Operator<T07, T08>,
+  o09: Operator<T08, T09>,
+): T09;
+export function pipe<V, T01, T02, T03, T04, T05, T06, T07, T08, T09, T10>(
+  value: V,
+  o01: Operator<V, T01>,
+  o02: Operator<T01, T02>,
+  o03: Operator<T02, T03>,
+  o04: Operator<T03, T04>,
+  o05: Operator<T04, T05>,
+  o06: Operator<T05, T06>,
+  o07: Operator<T06, T07>,
+  o08: Operator<T07, T08>,
+  o09: Operator<T08, T09>,
+  o10: Operator<T09, T10>,
+): T10;
+export function pipe<V, T01, T02, T03, T04, T05, T06, T07, T08, T09, T10, T11>(
+  value: V,
+  o01: Operator<V, T01>,
+  o02: Operator<T01, T02>,
+  o03: Operator<T02, T03>,
+  o04: Operator<T03, T04>,
+  o05: Operator<T04, T05>,
+  o06: Operator<T05, T06>,
+  o07: Operator<T06, T07>,
+  o08: Operator<T07, T08>,
+  o09: Operator<T08, T09>,
+  o10: Operator<T09, T10>,
+  o11: Operator<T10, T11>,
+): T11;
+export function pipe<
+  V,
+  T01,
+  T02,
+  T03,
+  T04,
+  T05,
+  T06,
+  T07,
+  T08,
+  T09,
+  T10,
+  T11,
+  T12,
+>(
+  value: V,
+  o01: Operator<V, T01>,
+  o02: Operator<T01, T02>,
+  o03: Operator<T02, T03>,
+  o04: Operator<T03, T04>,
+  o05: Operator<T04, T05>,
+  o06: Operator<T05, T06>,
+  o07: Operator<T06, T07>,
+  o08: Operator<T07, T08>,
+  o09: Operator<T08, T09>,
+  o10: Operator<T09, T10>,
+  o11: Operator<T10, T11>,
+  o12: Operator<T11, T12>,
+): T12;
+export function pipe<
+  V,
+  T01,
+  T02,
+  T03,
+  T04,
+  T05,
+  T06,
+  T07,
+  T08,
+  T09,
+  T10,
+  T11,
+  T12,
+  T13,
+>(
+  value: V,
+  o01: Operator<V, T01>,
+  o02: Operator<T01, T02>,
+  o03: Operator<T02, T03>,
+  o04: Operator<T03, T04>,
+  o05: Operator<T04, T05>,
+  o06: Operator<T05, T06>,
+  o07: Operator<T06, T07>,
+  o08: Operator<T07, T08>,
+  o09: Operator<T08, T09>,
+  o10: Operator<T09, T10>,
+  o11: Operator<T10, T11>,
+  o12: Operator<T11, T12>,
+  o13: Operator<T12, T13>,
+): T13;
+export function pipe<
+  V,
+  T01,
+  T02,
+  T03,
+  T04,
+  T05,
+  T06,
+  T07,
+  T08,
+  T09,
+  T10,
+  T11,
+  T12,
+  T13,
+  T14,
+>(
+  value: V,
+  o01: Operator<V, T01>,
+  o02: Operator<T01, T02>,
+  o03: Operator<T02, T03>,
+  o04: Operator<T03, T04>,
+  o05: Operator<T04, T05>,
+  o06: Operator<T05, T06>,
+  o07: Operator<T06, T07>,
+  o08: Operator<T07, T08>,
+  o09: Operator<T08, T09>,
+  o10: Operator<T09, T10>,
+  o11: Operator<T10, T11>,
+  o12: Operator<T11, T12>,
+  o13: Operator<T12, T13>,
+  o14: Operator<T13, T14>,
+): T14;
+export function pipe<
+  V,
+  T01,
+  T02,
+  T03,
+  T04,
+  T05,
+  T06,
+  T07,
+  T08,
+  T09,
+  T10,
+  T11,
+  T12,
+  T13,
+  T14,
+  T15,
+>(
+  value: V,
+  o01: Operator<V, T01>,
+  o02: Operator<T01, T02>,
+  o03: Operator<T02, T03>,
+  o04: Operator<T03, T04>,
+  o05: Operator<T04, T05>,
+  o06: Operator<T05, T06>,
+  o07: Operator<T06, T07>,
+  o08: Operator<T07, T08>,
+  o09: Operator<T08, T09>,
+  o10: Operator<T09, T10>,
+  o11: Operator<T10, T11>,
+  o12: Operator<T11, T12>,
+  o13: Operator<T12, T13>,
+  o14: Operator<T13, T14>,
+  o15: Operator<T14, T15>,
+): T15;
+export function pipe<
+  V,
+  T01,
+  T02,
+  T03,
+  T04,
+  T05,
+  T06,
+  T07,
+  T08,
+  T09,
+  T10,
+  T11,
+  T12,
+  T13,
+  T14,
+  T15,
+  T16,
+>(
+  value: V,
+  o01: Operator<V, T01>,
+  o02: Operator<T01, T02>,
+  o03: Operator<T02, T03>,
+  o04: Operator<T03, T04>,
+  o05: Operator<T04, T05>,
+  o06: Operator<T05, T06>,
+  o07: Operator<T06, T07>,
+  o08: Operator<T07, T08>,
+  o09: Operator<T08, T09>,
+  o10: Operator<T09, T10>,
+  o11: Operator<T10, T11>,
+  o12: Operator<T11, T12>,
+  o13: Operator<T12, T13>,
+  o14: Operator<T13, T14>,
+  o15: Operator<T14, T15>,
+  o16: Operator<T15, T16>,
+): T16;
+export function pipe<
+  V,
+  T01,
+  T02,
+  T03,
+  T04,
+  T05,
+  T06,
+  T07,
+  T08,
+  T09,
+  T10,
+  T11,
+  T12,
+  T13,
+  T14,
+  T15,
+  T16,
+  T17,
+>(
+  value: V,
+  o01: Operator<V, T01>,
+  o02: Operator<T01, T02>,
+  o03: Operator<T02, T03>,
+  o04: Operator<T03, T04>,
+  o05: Operator<T04, T05>,
+  o06: Operator<T05, T06>,
+  o07: Operator<T06, T07>,
+  o08: Operator<T07, T08>,
+  o09: Operator<T08, T09>,
+  o10: Operator<T09, T10>,
+  o11: Operator<T10, T11>,
+  o12: Operator<T11, T12>,
+  o13: Operator<T12, T13>,
+  o14: Operator<T13, T14>,
+  o15: Operator<T14, T15>,
+  o16: Operator<T15, T16>,
+  o17: Operator<T16, T17>,
+): T17;
+export function pipe<
+  V,
+  T01,
+  T02,
+  T03,
+  T04,
+  T05,
+  T06,
+  T07,
+  T08,
+  T09,
+  T10,
+  T11,
+  T12,
+  T13,
+  T14,
+  T15,
+  T16,
+  T17,
+  T18,
+>(
+  value: V,
+  o01: Operator<V, T01>,
+  o02: Operator<T01, T02>,
+  o03: Operator<T02, T03>,
+  o04: Operator<T03, T04>,
+  o05: Operator<T04, T05>,
+  o06: Operator<T05, T06>,
+  o07: Operator<T06, T07>,
+  o08: Operator<T07, T08>,
+  o09: Operator<T08, T09>,
+  o10: Operator<T09, T10>,
+  o11: Operator<T10, T11>,
+  o12: Operator<T11, T12>,
+  o13: Operator<T12, T13>,
+  o14: Operator<T13, T14>,
+  o15: Operator<T14, T15>,
+  o16: Operator<T15, T16>,
+  o17: Operator<T16, T17>,
+  o18: Operator<T17, T18>,
+): T18;
+export function pipe<
+  V,
+  T01,
+  T02,
+  T03,
+  T04,
+  T05,
+  T06,
+  T07,
+  T08,
+  T09,
+  T10,
+  T11,
+  T12,
+  T13,
+  T14,
+  T15,
+  T16,
+  T17,
+  T18,
+  T19,
+>(
+  value: V,
+  o01: Operator<V, T01>,
+  o02: Operator<T01, T02>,
+  o03: Operator<T02, T03>,
+  o04: Operator<T03, T04>,
+  o05: Operator<T04, T05>,
+  o06: Operator<T05, T06>,
+  o07: Operator<T06, T07>,
+  o08: Operator<T07, T08>,
+  o09: Operator<T08, T09>,
+  o10: Operator<T09, T10>,
+  o11: Operator<T10, T11>,
+  o12: Operator<T11, T12>,
+  o13: Operator<T12, T13>,
+  o14: Operator<T13, T14>,
+  o15: Operator<T14, T15>,
+  o16: Operator<T15, T16>,
+  o17: Operator<T16, T17>,
+  o18: Operator<T17, T18>,
+  o19: Operator<T18, T19>,
+): T19;
+export function pipe<
+  V,
+  T01,
+  T02,
+  T03,
+  T04,
+  T05,
+  T06,
+  T07,
+  T08,
+  T09,
+  T10,
+  T11,
+  T12,
+  T13,
+  T14,
+  T15,
+  T16,
+  T17,
+  T18,
+  T19,
+  T20,
+>(
+  value: V,
+  o01: Operator<V, T01>,
+  o02: Operator<T01, T02>,
+  o03: Operator<T02, T03>,
+  o04: Operator<T03, T04>,
+  o05: Operator<T04, T05>,
+  o06: Operator<T05, T06>,
+  o07: Operator<T06, T07>,
+  o08: Operator<T07, T08>,
+  o09: Operator<T08, T09>,
+  o10: Operator<T09, T10>,
+  o11: Operator<T10, T11>,
+  o12: Operator<T11, T12>,
+  o13: Operator<T12, T13>,
+  o14: Operator<T13, T14>,
+  o15: Operator<T14, T15>,
+  o16: Operator<T15, T16>,
+  o17: Operator<T16, T17>,
+  o18: Operator<T17, T18>,
+  o19: Operator<T18, T19>,
+  o20: Operator<T19, T20>,
+): T20;
+
+// deno-lint-ignore no-explicit-any
+export function pipe<V, Operators extends Operator<any, unknown>[]>(
+  value: V,
+  ...operators: Operators
+): LastOperatorReturn<Operators>;
+
+// deno-lint-ignore no-explicit-any
+export function pipe<V>(value: V, ...operators: Operator<unknown, any>[]) {
+  return operators.reduce(
+    (result, next) => next(result),
+    value,
+  );
+}
diff --git a/mod_test.ts b/pipe_test.ts
similarity index 99%
rename from mod_test.ts
rename to pipe_test.ts
index 339cf83..35fce9f 100644
--- a/mod_test.ts
+++ b/pipe_test.ts
@@ -1,7 +1,7 @@
 import { test } from "@cross/test";
 import { assertEquals } from "@std/assert";
 import { assertType, type IsExact } from "@std/testing/types";
-import { pipe } from "./mod.ts";
+import { pipe } from "./pipe.ts";
 
 await test("pipe with no operators should return the input", () => {
   assertEquals(pipe(1), 1);