improve-typing

src/composeTyping.ts

@@ -9,9 +9,16 @@ type UnwrapPromiseFn<T extends Func> = true extends IsAsync<T> ? (
   ) => UnwrapPromise<ReturnType<T>>
   : T;
 
+type GenericGeneric<S> = <T extends S>(x: T) => T;
+
+// deno-lint-ignore no-explicit-any
+type IsGeneric<F extends Func, T = any> = F extends GenericGeneric<T> ? true
+  : false;
+
 type SimpleCompose<F, G> = G extends (...args: infer GArgs) => infer GReturn
   ? F extends (x: UnwrapPromise<GReturn>) => infer FReturn
-    ? (...args: GArgs) => UnwrapPromise<FReturn>
+    ? [true, true] extends [IsGeneric<G>, IsGeneric<F>] ? G
+    : (...args: GArgs) => UnwrapPromise<FReturn> // todo: does not preserve generics in case of generic identity.
   : never
   : never;
 

src/composition.test.ts

@@ -10,8 +10,8 @@ import { assertEquals } from "std-assert";
 import { multiply } from "./math.ts";
 import { not } from "./operator.ts";
 import { wrapPromise } from "./promise.ts";
-import type { AsyncFunction } from "./typing.ts";
 import { sleep } from "./time.ts";
+import type { AsyncFunction } from "./typing.ts";
 
 Deno.test("pipe with async functions", async () => {
   assertEquals(
@@ -105,10 +105,21 @@ const _generics6: number = pipe(
   <T>(t: T) => t,
 )(1);
 
+const _generics7: <T extends number>(t: T) => T = pipe(
+  <T extends number>(t: T) => t,
+  <T extends number>(t: T) => t,
+);
+
+const _generics8: <T extends number>(t: T) => T = pipe(
+  // @ts-expect-error no overlap
+  <T extends number>(t: T) => t,
+  <T extends string>(t: T) => t,
+);
+
 // failing typing tests:
 
 // Generics understands contextual extends
-// const _5 = <Fn extends (x: string) => number>(f: Fn) => {
+// const _generics9 = <Fn extends (x: string) => number>(f: Fn) => {
 //   // @ts-expect-error first function does not match second
 //   pipe((x: number) => x, f);
 // };