diff --git a/README.md b/README.md
index 257b9b6..05ce430 100644
--- a/README.md
+++ b/README.md
@@ -47,6 +47,33 @@ const result = 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
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 2985ca8..d32b5d9 100644
--- a/async/mod.ts
+++ b/async/mod.ts
@@ -1,2 +1,3 @@
 export type { AsyncOperator } from "./operator.ts";
+export * from "./compose.ts";
 export * from "./pipe.ts";
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 b65d377..c65f81f 100644
--- a/deno.jsonc
+++ b/deno.jsonc
@@ -4,8 +4,10 @@
   "exports": {
     ".": "./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"
   },
diff --git a/mod.ts b/mod.ts
index fef5067..083e9a6 100644
--- a/mod.ts
+++ b/mod.ts
@@ -1,2 +1,3 @@
 export type { Operator } from "./operator.ts";
+export * from "./compose.ts";
 export * from "./pipe.ts";