From fc217da6c57a90313e2a80fe60668af197dae599 Mon Sep 17 00:00:00 2001
From: gvergnaud <gabriel.vergnaud@gmail.com>
Date: Sun, 16 Jul 2023 01:22:37 +0200
Subject: [PATCH 1/8] try new core idea

---
 src/internals/core/Core.ts           |   8 +-
 src/internals/core/Core2.ts          | 138 +++++++++++++++++++++++++++
 src/internals/core/impl/MergeArgs.ts |   9 ++
 3 files changed, 151 insertions(+), 4 deletions(-)
 create mode 100644 src/internals/core/Core2.ts

diff --git a/src/internals/core/Core.ts b/src/internals/core/Core.ts
index 4f9f630..0f8095a 100644
--- a/src/internals/core/Core.ts
+++ b/src/internals/core/Core.ts
@@ -1,8 +1,8 @@
 import { ExcludePlaceholders, MergeArgs } from "./impl/MergeArgs";
 import { Head } from "../helpers";
 
-declare const rawArgs: unique symbol;
-type rawArgs = typeof rawArgs;
+export declare const rawArgs: unique symbol;
+export type rawArgs = typeof rawArgs;
 
 /**
  * Base interface for all functions.
@@ -36,8 +36,8 @@ export interface Fn {
   return: unknown;
 }
 
-declare const unset: unique symbol;
-declare const _: unique symbol;
+export declare const unset: unique symbol;
+export declare const _: unique symbol;
 
 /**
  * A placeholder type that can be used to indicate that a parameter is not set.
diff --git a/src/internals/core/Core2.ts b/src/internals/core/Core2.ts
new file mode 100644
index 0000000..d2e943f
--- /dev/null
+++ b/src/internals/core/Core2.ts
@@ -0,0 +1,138 @@
+import { _, unset } from "./Core";
+import { ExcludePlaceholders, ExcludeUnset, MergeArgs } from "./impl/MergeArgs";
+import * as NumberImpl from "../numbers/impl/numbers";
+
+/**
+ * Core
+ */
+
+export interface Fn<input extends any[] = unknown[]> {
+  inputTypes: input;
+  args: unknown;
+  return: unknown;
+}
+
+interface Ap<fn extends Fn, partialArgs extends any[] = []> extends Fn {
+  name: "Ap";
+
+  inputTypes: fn["inputTypes"];
+
+  argsArray: Extract<this["args"], any[]>;
+  allArgs: [...partialArgs, ...this["argsArray"]];
+
+  expectedArgsCount: fn["inputTypes"]["length"];
+  providedArgsCount: ExcludePlaceholders<this["allArgs"]>["length"];
+
+  return: NumberImpl.Compare<
+    this["providedArgsCount"],
+    this["expectedArgsCount"]
+  > extends 1 | 0
+    ? Apply<fn, MergeArgs<this["argsArray"], partialArgs>>
+    : Ap<fn, this["allArgs"]>;
+}
+
+export type Apply<fn extends Fn, args extends any[]> = (fn & {
+  args: args;
+})["return"];
+
+export type $<
+  fn extends Fn,
+  arg0 extends fn["inputTypes"][0] | _ | unset = unset,
+  arg1 extends fn["inputTypes"][1] | _ | unset = unset,
+  arg2 extends fn["inputTypes"][2] | _ | unset = unset,
+  arg3 extends fn["inputTypes"][3] | _ | unset = unset
+> = ((fn extends { name: "Ap" } ? fn : Ap<fn>) & {
+  args: ExcludeUnset<[arg0, arg1, arg2, arg3]>;
+})["return"];
+
+type Args<fn extends Fn> = Extract<fn["args"], fn["inputTypes"]>;
+type Arg0<fn extends Fn> = Extract<fn["args"], fn["inputTypes"]>[0];
+type Arg1<fn extends Fn> = Extract<fn["args"], fn["inputTypes"]>[1];
+type Arg2<fn extends Fn> = Extract<fn["args"], fn["inputTypes"]>[2];
+type Arg3<fn extends Fn> = Extract<fn["args"], fn["inputTypes"]>[3];
+
+type ExpectNumber<a extends number> = [a];
+// arguments are typed internally:
+interface TypedArgsTest extends Fn<[number, string]> {
+  works: ExpectNumber<Arg0<this>>; // ✅
+  fails: ExpectNumber<Arg1<this>>;
+  //                  ~~~~~~~~~~  ❌
+  return: true;
+}
+
+interface Div extends Fn<[number, number]> {
+  return: NumberImpl.Div<Arg0<this>, Arg1<this>>;
+}
+
+/**
+ * Full application
+ */
+
+type x = $<Div, 10, 2>; // 5
+//   ^?
+type y = $<Div, "10", 2>;
+//              ~~~ ❌
+type z = $<Div, 11, "2">;
+//                  ~~~ ❌
+
+/**
+ * Partial application in order
+ */
+
+type Div1 = $<Div, 10>;
+type Three = $<Div1, 2>;
+//    ^?
+type w = $<$<Div, 10>, "2">;
+//                     ~~~ ❌
+
+/**
+ * Partial application different order order
+ */
+type DivBy2 = $<Div, _, 2>;
+//   ^?
+type q = $<DivBy2, 10>; // 5 ✅
+//   ^?
+type r = $<$<Div, _>, 10, 5>; // ✅
+//   ^?
+
+/**
+ * Higher order
+ */
+
+interface Map extends Fn<[Fn, any[]]> {
+  return: Args<this> extends [infer fn extends Fn, infer tuple]
+    ? { [key in keyof tuple]: $<fn, tuple[key]> }
+    : never;
+}
+
+type z2 = $<Map, $<Div, _, 2>, [2, 4, 6, 8, 10]>;
+//   ^?
+
+type ReduceImpl<fn extends Fn, acc, xs> = xs extends [
+  infer first,
+  ...infer rest
+]
+  ? ReduceImpl<fn, $<fn, acc, first>, rest>
+  : acc;
+
+interface Reduce extends Fn<[Fn, any, any[]]> {
+  return: Args<this> extends [infer fn extends Fn, infer acc, infer tuple]
+    ? ReduceImpl<fn, acc, tuple>
+    : never;
+}
+
+interface Add extends Fn<[number, number]> {
+  return: NumberImpl.Add<Arg0<this>, Arg1<this>>;
+}
+
+interface Mul extends Fn<[number, number]> {
+  return: NumberImpl.Mul<Arg0<this>, Arg1<this>>;
+}
+
+type reduced1 = $<Reduce, Add, 0, [2, 4, 6, 8, 10]>;
+//   ^?
+type reduced2 = $<Reduce, Mul, 1, [2, 4, 6, 8, 10]>;
+//   ^?
+
+type reducedOops = $<Reduce, Mul, 1, "oops">;
+//                                   ~~~~~~ ❌
diff --git a/src/internals/core/impl/MergeArgs.ts b/src/internals/core/impl/MergeArgs.ts
index 2873e13..e892aa1 100644
--- a/src/internals/core/impl/MergeArgs.ts
+++ b/src/internals/core/impl/MergeArgs.ts
@@ -10,6 +10,15 @@ export type ExcludePlaceholders<xs, output extends any[] = []> = xs extends [
     : ExcludePlaceholders<rest, [...output, first]>
   : output;
 
+export type ExcludeUnset<xs, output extends any[] = []> = xs extends [
+  infer first,
+  ...infer rest
+]
+  ? Equal<first, unset> extends true
+    ? ExcludeUnset<rest, output>
+    : ExcludeUnset<rest, [...output, first]>
+  : output;
+
 type MergeArgsRec<
   pipedArgs extends any[],
   partialArgs extends any[],

From 37f136549c0e54bd105004c0912a2d1f6d14524e Mon Sep 17 00:00:00 2001
From: gvergnaud <gabriel.vergnaud@gmail.com>
Date: Sun, 16 Jul 2023 13:42:56 +0200
Subject: [PATCH 2/8]  Add function's return type

---
 src/internals/core/Core2.ts | 123 ++++++++++++++++++++++++++++--------
 1 file changed, 98 insertions(+), 25 deletions(-)

diff --git a/src/internals/core/Core2.ts b/src/internals/core/Core2.ts
index d2e943f..d0e1800 100644
--- a/src/internals/core/Core2.ts
+++ b/src/internals/core/Core2.ts
@@ -1,28 +1,44 @@
 import { _, unset } from "./Core";
 import { ExcludePlaceholders, ExcludeUnset, MergeArgs } from "./impl/MergeArgs";
 import * as NumberImpl from "../numbers/impl/numbers";
+import * as StringImpl from "../strings/impl/strings";
+import { Iterator } from "../helpers";
 
 /**
  * Core
  */
 
-export interface Fn<input extends any[] = unknown[]> {
+export interface Fn<input extends any[] = unknown[], output = unknown> {
   inputTypes: input;
+  outputType: output;
   args: unknown;
   return: unknown;
 }
 
+type Drop<
+  xs extends readonly any[],
+  n extends number,
+  dropped extends readonly any[] = []
+> = n extends dropped["length"]
+  ? xs
+  : xs extends readonly [infer first, ...infer tail]
+  ? Drop<tail, n, [...dropped, first]>
+  : [];
+
 interface Ap<fn extends Fn, partialArgs extends any[] = []> extends Fn {
   name: "Ap";
 
-  inputTypes: fn["inputTypes"];
-
   argsArray: Extract<this["args"], any[]>;
   allArgs: [...partialArgs, ...this["argsArray"]];
 
   expectedArgsCount: fn["inputTypes"]["length"];
   providedArgsCount: ExcludePlaceholders<this["allArgs"]>["length"];
 
+  inputTypes: Drop<
+    fn["inputTypes"],
+    ExcludePlaceholders<partialArgs>["length"]
+  >;
+
   return: NumberImpl.Compare<
     this["providedArgsCount"],
     this["expectedArgsCount"]
@@ -37,13 +53,16 @@ export type Apply<fn extends Fn, args extends any[]> = (fn & {
 
 export type $<
   fn extends Fn,
-  arg0 extends fn["inputTypes"][0] | _ | unset = unset,
-  arg1 extends fn["inputTypes"][1] | _ | unset = unset,
-  arg2 extends fn["inputTypes"][2] | _ | unset = unset,
-  arg3 extends fn["inputTypes"][3] | _ | unset = unset
-> = ((fn extends { name: "Ap" } ? fn : Ap<fn>) & {
-  args: ExcludeUnset<[arg0, arg1, arg2, arg3]>;
-})["return"];
+  arg0 extends fn["inputTypes"][0] | _ = unset,
+  arg1 extends fn["inputTypes"][1] | _ = unset,
+  arg2 extends fn["inputTypes"][2] | _ = unset,
+  arg3 extends fn["inputTypes"][3] | _ = unset
+> = Extract<
+  ((fn extends { name: "Ap" } ? fn : Ap<fn>) & {
+    args: ExcludeUnset<[arg0, arg1, arg2, arg3]>;
+  })["return"],
+  fn["outputType"]
+>;
 
 type Args<fn extends Fn> = Extract<fn["args"], fn["inputTypes"]>;
 type Arg0<fn extends Fn> = Extract<fn["args"], fn["inputTypes"]>[0];
@@ -53,14 +72,14 @@ type Arg3<fn extends Fn> = Extract<fn["args"], fn["inputTypes"]>[3];
 
 type ExpectNumber<a extends number> = [a];
 // arguments are typed internally:
-interface TypedArgsTest extends Fn<[number, string]> {
+interface TakeNumAndStr extends Fn<[number, string], boolean> {
   works: ExpectNumber<Arg0<this>>; // ✅
   fails: ExpectNumber<Arg1<this>>;
   //                  ~~~~~~~~~~  ❌
   return: true;
 }
 
-interface Div extends Fn<[number, number]> {
+interface Div extends Fn<[number, number], number> {
   return: NumberImpl.Div<Arg0<this>, Arg1<this>>;
 }
 
@@ -86,7 +105,7 @@ type w = $<$<Div, 10>, "2">;
 //                     ~~~ ❌
 
 /**
- * Partial application different order order
+ * Partial application different order
  */
 type DivBy2 = $<Div, _, 2>;
 //   ^?
@@ -95,6 +114,16 @@ type q = $<DivBy2, 10>; // 5 ✅
 type r = $<$<Div, _>, 10, 5>; // ✅
 //   ^?
 
+type TakeStr = $<TakeNumAndStr, 10>;
+//   ^? Ap<TakeNumAndStr, [10]>
+type e = $<TakeStr, 10>;
+//                  ~~ ❌
+
+type TakeNum = $<TakeNumAndStr, _, "10">;
+//   ^?Ap<TakeNumAndStr, [_, "10"]>
+type s = $<TakeNum, 10>;
+//                  ~~ FIXME
+
 /**
  * Higher order
  */
@@ -106,7 +135,15 @@ interface Map extends Fn<[Fn, any[]]> {
 }
 
 type z2 = $<Map, $<Div, _, 2>, [2, 4, 6, 8, 10]>;
-//   ^?
+//   ^? [1, 2, 3, 4, 5]
+
+interface Add extends Fn<[number, number], number> {
+  return: NumberImpl.Add<Arg0<this>, Arg1<this>>;
+}
+
+interface Mul extends Fn<[number, number], number> {
+  return: NumberImpl.Mul<Arg0<this>, Arg1<this>>;
+}
 
 type ReduceImpl<fn extends Fn, acc, xs> = xs extends [
   infer first,
@@ -115,24 +152,60 @@ type ReduceImpl<fn extends Fn, acc, xs> = xs extends [
   ? ReduceImpl<fn, $<fn, acc, first>, rest>
   : acc;
 
-interface Reduce extends Fn<[Fn, any, any[]]> {
+interface Reduce<A = any, B = any> extends Fn<[Fn<[B, A], B>, B, A[]], B> {
   return: Args<this> extends [infer fn extends Fn, infer acc, infer tuple]
     ? ReduceImpl<fn, acc, tuple>
     : never;
 }
 
-interface Add extends Fn<[number, number]> {
-  return: NumberImpl.Add<Arg0<this>, Arg1<this>>;
+type reduced1 = $<Reduce<number, number>, Add, 0, [2, 4, 6, 8, 10]>;
+//   ^? 30
+type reduced2 = $<Reduce<number, number>, Mul, 1, [2, 4, 6, 8, 10]>;
+//   ^? 3840
+type reduced3 = $<Reduce<number, number>, Mul, 1, ["2", "4", "6", "8", "10"]>;
+//                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~ ❌
+type reducedOops = $<Reduce, Mul, 1, "oops">;
+//                                   ~~~~~~ ❌
+
+interface NumToStringReducer extends Fn<[string, number], string> {
+  return: `${Arg0<this>}${Arg1<this>}`;
 }
 
-interface Mul extends Fn<[number, number]> {
-  return: NumberImpl.Mul<Arg0<this>, Arg1<this>>;
+interface StringToNumReducer extends Fn<[number, string], number> {
+  return: NumberImpl.Add<Arg0<this>, StringImpl.Length<Arg1<this>>>;
 }
 
-type reduced1 = $<Reduce, Add, 0, [2, 4, 6, 8, 10]>;
-//   ^?
-type reduced2 = $<Reduce, Mul, 1, [2, 4, 6, 8, 10]>;
-//   ^?
+// prettier-ignore
+type reduced4 = $<Reduce<string, number>, StringToNumReducer, 1, ["a", "aa", "aaa", "aaaa", "aaaaa"]>;
+//     ^? 16
 
-type reducedOops = $<Reduce, Mul, 1, "oops">;
-//                                   ~~~~~~ ❌
+// prettier-ignore
+type reduced5 = $<Reduce<string, number>, NumToStringReducer, 1, ["a", "aa", "aaa", "aaaa", "aaaaa"]>;
+//                                        ~~~~~~~~~~~~~~~~~~ ❌
+
+interface ToString extends Fn<[number], string> {
+  return: `${Arg0<this>}`;
+}
+
+interface ToNumber extends Fn<[string], number> {
+  return: Arg0<this> extends `${infer N extends number}` ? N : never;
+}
+
+interface Prepend extends Fn<[string, string], string> {
+  return: this["args"] extends [
+    infer first extends string,
+    infer str extends string
+  ]
+    ? `${first}${str}`
+    : never;
+}
+
+type Times10<T extends number> = $<ToNumber, $<Prepend, "1", $<ToString, T>>>;
+
+type WrongComposition1<T extends string> = $<Prepend, "1", $<ToNumber, T>>;
+//                                                         ~~~~~~~~~~~~~~ ❌
+type WrongComposition2<T extends number> = $<Add, 1, $<ToString, T>>;
+//                                                   ~~~~~~~~~~~~~~ ❌
+
+type test1 = Times10<10>;
+//    ^? 110

From 7363f6df9527eb7e0eb0289a261025c2906834c7 Mon Sep 17 00:00:00 2001
From: gvergnaud <gabriel.vergnaud@gmail.com>
Date: Sun, 16 Jul 2023 15:55:18 +0200
Subject: [PATCH 3/8] Some improvements

---
 src/internals/core/Core2.ts | 103 +++++++++++++++++++++++++-----------
 1 file changed, 71 insertions(+), 32 deletions(-)

diff --git a/src/internals/core/Core2.ts b/src/internals/core/Core2.ts
index d0e1800..3493ff6 100644
--- a/src/internals/core/Core2.ts
+++ b/src/internals/core/Core2.ts
@@ -2,7 +2,6 @@ import { _, unset } from "./Core";
 import { ExcludePlaceholders, ExcludeUnset, MergeArgs } from "./impl/MergeArgs";
 import * as NumberImpl from "../numbers/impl/numbers";
 import * as StringImpl from "../strings/impl/strings";
-import { Iterator } from "../helpers";
 
 /**
  * Core
@@ -25,6 +24,21 @@ type Drop<
   ? Drop<tail, n, [...dropped, first]>
   : [];
 
+type ExcludePlaceholdersFromInputTypes<
+  inputTypes extends any[],
+  partialArgs extends any[],
+  result extends any[] = []
+> = [inputTypes, partialArgs] extends [
+  [infer fInput, ...infer rInput],
+  [infer fPartial, ...infer rPartial]
+]
+  ? ExcludePlaceholdersFromInputTypes<
+      rInput,
+      rPartial,
+      fPartial extends _ ? [...result, fInput] : result
+    >
+  : [...result, ...inputTypes];
+
 interface Ap<fn extends Fn, partialArgs extends any[] = []> extends Fn {
   name: "Ap";
 
@@ -34,15 +48,18 @@ interface Ap<fn extends Fn, partialArgs extends any[] = []> extends Fn {
   expectedArgsCount: fn["inputTypes"]["length"];
   providedArgsCount: ExcludePlaceholders<this["allArgs"]>["length"];
 
-  inputTypes: Drop<
-    fn["inputTypes"],
-    ExcludePlaceholders<partialArgs>["length"]
-  >;
+  inputTypes: ExcludePlaceholdersFromInputTypes<fn["inputTypes"], partialArgs>;
+
+  outputType: fn["outputType"];
 
-  return: NumberImpl.Compare<
+  isFullyApplied: NumberImpl.Compare<
     this["providedArgsCount"],
     this["expectedArgsCount"]
   > extends 1 | 0
+    ? true
+    : false;
+
+  return: this["isFullyApplied"] extends true
     ? Apply<fn, MergeArgs<this["argsArray"], partialArgs>>
     : Ap<fn, this["allArgs"]>;
 }
@@ -51,24 +68,40 @@ export type Apply<fn extends Fn, args extends any[]> = (fn & {
   args: args;
 })["return"];
 
+type AnyAp = Ap<any, any>;
+
 export type $<
   fn extends Fn,
-  arg0 extends fn["inputTypes"][0] | _ = unset,
-  arg1 extends fn["inputTypes"][1] | _ = unset,
-  arg2 extends fn["inputTypes"][2] | _ = unset,
-  arg3 extends fn["inputTypes"][3] | _ = unset
-> = Extract<
-  ((fn extends { name: "Ap" } ? fn : Ap<fn>) & {
-    args: ExcludeUnset<[arg0, arg1, arg2, arg3]>;
-  })["return"],
-  fn["outputType"]
+  arg0 extends fn["inputTypes"][0] | AnyAp | _ = unset,
+  arg1 extends fn["inputTypes"][1] | AnyAp | _ = unset,
+  arg2 extends fn["inputTypes"][2] | AnyAp | _ = unset,
+  arg3 extends fn["inputTypes"][3] | AnyAp | _ = unset,
+  ap extends AnyAp = fn extends { name: "Ap" } ? fn : Ap<fn>
+> = (ap & {
+  args: ExcludeUnset<[arg0, arg1, arg2, arg3]>;
+})["return"];
+
+type Args<fn extends Fn> = fn["args"];
+type Arg0<fn extends Fn> = Extract<
+  Extract<fn["args"], any[]>[0],
+  fn["inputTypes"][0]
+>;
+type Arg1<fn extends Fn> = Extract<
+  Extract<fn["args"], any[]>[1],
+  fn["inputTypes"][1]
+>;
+type Arg2<fn extends Fn> = Extract<
+  Extract<fn["args"], any[]>[2],
+  fn["inputTypes"][2]
+>;
+type Arg3<fn extends Fn> = Extract<
+  Extract<fn["args"], any[]>[3],
+  fn["inputTypes"][3]
 >;
 
-type Args<fn extends Fn> = Extract<fn["args"], fn["inputTypes"]>;
-type Arg0<fn extends Fn> = Extract<fn["args"], fn["inputTypes"]>[0];
-type Arg1<fn extends Fn> = Extract<fn["args"], fn["inputTypes"]>[1];
-type Arg2<fn extends Fn> = Extract<fn["args"], fn["inputTypes"]>[2];
-type Arg3<fn extends Fn> = Extract<fn["args"], fn["inputTypes"]>[3];
+/**
+ * Playground 👇
+ */
 
 type ExpectNumber<a extends number> = [a];
 // arguments are typed internally:
@@ -111,6 +144,7 @@ type DivBy2 = $<Div, _, 2>;
 //   ^?
 type q = $<DivBy2, 10>; // 5 ✅
 //   ^?
+
 type r = $<$<Div, _>, 10, 5>; // ✅
 //   ^?
 
@@ -121,20 +155,21 @@ type e = $<TakeStr, 10>;
 
 type TakeNum = $<TakeNumAndStr, _, "10">;
 //   ^?Ap<TakeNumAndStr, [_, "10"]>
-type s = $<TakeNum, 10>;
-//                  ~~ FIXME
+type s = $<TakeNum, 10>; // ✅
+type d = $<TakeNum, "10">;
+//                  ~~~~ ❌
 
 /**
  * Higher order
  */
 
-interface Map extends Fn<[Fn, any[]]> {
+interface Map<A = any, B = any> extends Fn<[Fn<[A], B>, A[]], B[]> {
   return: Args<this> extends [infer fn extends Fn, infer tuple]
     ? { [key in keyof tuple]: $<fn, tuple[key]> }
     : never;
 }
 
-type z2 = $<Map, $<Div, _, 2>, [2, 4, 6, 8, 10]>;
+type z2 = $<Map<number, number>, $<Div, _, 2>, [2, 4, 6, 8, 10]>;
 //   ^? [1, 2, 3, 4, 5]
 
 interface Add extends Fn<[number, number], number> {
@@ -192,20 +227,24 @@ interface ToNumber extends Fn<[string], number> {
 }
 
 interface Prepend extends Fn<[string, string], string> {
-  return: this["args"] extends [
-    infer first extends string,
-    infer str extends string
-  ]
-    ? `${first}${str}`
-    : never;
+  return: `${Arg0<this>}${Arg1<this>}`;
+}
+
+interface ToArray extends Fn<[any], [any]> {
+  return: [Arg0<this>];
 }
 
-type Times10<T extends number> = $<ToNumber, $<Prepend, "1", $<ToString, T>>>;
+type Times10<T extends number> = $<Prepend, "1", $<ToString, T>>;
+
+type test1 = Times10<10>;
+//    ^? 110
 
 type WrongComposition1<T extends string> = $<Prepend, "1", $<ToNumber, T>>;
 //                                                         ~~~~~~~~~~~~~~ ❌
 type WrongComposition2<T extends number> = $<Add, 1, $<ToString, T>>;
 //                                                   ~~~~~~~~~~~~~~ ❌
 
-type test1 = Times10<10>;
+type Test<T extends string> = $<Prepend, "1", T>;
+
+type test2 = Test<"10">;
 //    ^? 110

From 8dc9ff2059d79dacd608071eedd02dd6878ef389 Mon Sep 17 00:00:00 2001
From: gvergnaud <gabriel.vergnaud@gmail.com>
Date: Sun, 16 Jul 2023 17:16:23 +0200
Subject: [PATCH 4/8] use unknown instead of any to preserve constraints

---
 src/internals/core/Core2.ts | 35 ++++++++++++++++++-----------------
 1 file changed, 18 insertions(+), 17 deletions(-)

diff --git a/src/internals/core/Core2.ts b/src/internals/core/Core2.ts
index 3493ff6..ab7dec5 100644
--- a/src/internals/core/Core2.ts
+++ b/src/internals/core/Core2.ts
@@ -7,7 +7,7 @@ import * as StringImpl from "../strings/impl/strings";
  * Core
  */
 
-export interface Fn<input extends any[] = unknown[], output = unknown> {
+export interface Fn<input extends unknown[] = unknown[], output = unknown> {
   inputTypes: input;
   outputType: output;
   args: unknown;
@@ -15,9 +15,9 @@ export interface Fn<input extends any[] = unknown[], output = unknown> {
 }
 
 type Drop<
-  xs extends readonly any[],
+  xs extends readonly unknown[],
   n extends number,
-  dropped extends readonly any[] = []
+  dropped extends readonly unknown[] = []
 > = n extends dropped["length"]
   ? xs
   : xs extends readonly [infer first, ...infer tail]
@@ -25,9 +25,9 @@ type Drop<
   : [];
 
 type ExcludePlaceholdersFromInputTypes<
-  inputTypes extends any[],
-  partialArgs extends any[],
-  result extends any[] = []
+  inputTypes extends unknown[],
+  partialArgs extends unknown[],
+  result extends unknown[] = []
 > = [inputTypes, partialArgs] extends [
   [infer fInput, ...infer rInput],
   [infer fPartial, ...infer rPartial]
@@ -39,10 +39,10 @@ type ExcludePlaceholdersFromInputTypes<
     >
   : [...result, ...inputTypes];
 
-interface Ap<fn extends Fn, partialArgs extends any[] = []> extends Fn {
+interface Ap<fn extends Fn, partialArgs extends unknown[] = []> extends Fn {
   name: "Ap";
 
-  argsArray: Extract<this["args"], any[]>;
+  argsArray: Extract<this["args"], unknown[]>;
   allArgs: [...partialArgs, ...this["argsArray"]];
 
   expectedArgsCount: fn["inputTypes"]["length"];
@@ -64,11 +64,11 @@ interface Ap<fn extends Fn, partialArgs extends any[] = []> extends Fn {
     : Ap<fn, this["allArgs"]>;
 }
 
-export type Apply<fn extends Fn, args extends any[]> = (fn & {
+export type Apply<fn extends Fn, args extends unknown[]> = (fn & {
   args: args;
 })["return"];
 
-type AnyAp = Ap<any, any>;
+type AnyAp = Ap<unknown, unknown>;
 
 export type $<
   fn extends Fn,
@@ -83,19 +83,19 @@ export type $<
 
 type Args<fn extends Fn> = fn["args"];
 type Arg0<fn extends Fn> = Extract<
-  Extract<fn["args"], any[]>[0],
+  Extract<fn["args"], unknown[]>[0],
   fn["inputTypes"][0]
 >;
 type Arg1<fn extends Fn> = Extract<
-  Extract<fn["args"], any[]>[1],
+  Extract<fn["args"], unknown[]>[1],
   fn["inputTypes"][1]
 >;
 type Arg2<fn extends Fn> = Extract<
-  Extract<fn["args"], any[]>[2],
+  Extract<fn["args"], unknown[]>[2],
   fn["inputTypes"][2]
 >;
 type Arg3<fn extends Fn> = Extract<
-  Extract<fn["args"], any[]>[3],
+  Extract<fn["args"], unknown[]>[3],
   fn["inputTypes"][3]
 >;
 
@@ -163,7 +163,7 @@ type d = $<TakeNum, "10">;
  * Higher order
  */
 
-interface Map<A = any, B = any> extends Fn<[Fn<[A], B>, A[]], B[]> {
+interface Map<A = unknown, B = unknown> extends Fn<[Fn<[A], B>, A[]], B[]> {
   return: Args<this> extends [infer fn extends Fn, infer tuple]
     ? { [key in keyof tuple]: $<fn, tuple[key]> }
     : never;
@@ -187,7 +187,8 @@ type ReduceImpl<fn extends Fn, acc, xs> = xs extends [
   ? ReduceImpl<fn, $<fn, acc, first>, rest>
   : acc;
 
-interface Reduce<A = any, B = any> extends Fn<[Fn<[B, A], B>, B, A[]], B> {
+interface Reduce<A = unknown, B = unknown>
+  extends Fn<[Fn<[B, A], B>, B, A[]], B> {
   return: Args<this> extends [infer fn extends Fn, infer acc, infer tuple]
     ? ReduceImpl<fn, acc, tuple>
     : never;
@@ -230,7 +231,7 @@ interface Prepend extends Fn<[string, string], string> {
   return: `${Arg0<this>}${Arg1<this>}`;
 }
 
-interface ToArray extends Fn<[any], [any]> {
+interface ToArray extends Fn<[unknown], [unknown]> {
   return: [Arg0<this>];
 }
 

From 0f510a09e0307fcf3aaee198c9d002dbfcf05f63 Mon Sep 17 00:00:00 2001
From: gvergnaud <gabriel.vergnaud@gmail.com>
Date: Sun, 16 Jul 2023 18:47:34 +0200
Subject: [PATCH 5/8] Add another Core version with partial and pipe as
 separate helpers

---
 src/internals/core/Core2.ts |  99 ++++++----
 src/internals/core/Core3.ts | 357 ++++++++++++++++++++++++++++++++++++
 2 files changed, 418 insertions(+), 38 deletions(-)
 create mode 100644 src/internals/core/Core3.ts

diff --git a/src/internals/core/Core2.ts b/src/internals/core/Core2.ts
index ab7dec5..800dd5b 100644
--- a/src/internals/core/Core2.ts
+++ b/src/internals/core/Core2.ts
@@ -2,6 +2,7 @@ import { _, unset } from "./Core";
 import { ExcludePlaceholders, ExcludeUnset, MergeArgs } from "./impl/MergeArgs";
 import * as NumberImpl from "../numbers/impl/numbers";
 import * as StringImpl from "../strings/impl/strings";
+import { Equal, Expect } from "../helpers";
 
 /**
  * Core
@@ -14,16 +15,6 @@ export interface Fn<input extends unknown[] = unknown[], output = unknown> {
   return: unknown;
 }
 
-type Drop<
-  xs extends readonly unknown[],
-  n extends number,
-  dropped extends readonly unknown[] = []
-> = n extends dropped["length"]
-  ? xs
-  : xs extends readonly [infer first, ...infer tail]
-  ? Drop<tail, n, [...dropped, first]>
-  : [];
-
 type ExcludePlaceholdersFromInputTypes<
   inputTypes extends unknown[],
   partialArgs extends unknown[],
@@ -68,7 +59,7 @@ export type Apply<fn extends Fn, args extends unknown[]> = (fn & {
   args: args;
 })["return"];
 
-type AnyAp = Ap<unknown, unknown>;
+type AnyAp = Ap<any, any>;
 
 export type $<
   fn extends Fn,
@@ -107,6 +98,7 @@ type ExpectNumber<a extends number> = [a];
 // arguments are typed internally:
 interface TakeNumAndStr extends Fn<[number, string], boolean> {
   works: ExpectNumber<Arg0<this>>; // ✅
+  // @ts-expect-error
   fails: ExpectNumber<Arg1<this>>;
   //                  ~~~~~~~~~~  ❌
   return: true;
@@ -120,44 +112,61 @@ interface Div extends Fn<[number, number], number> {
  * Full application
  */
 
-type x = $<Div, 10, 2>; // 5
+type t1 = $<Div, 10, 2>; // 5
 //   ^?
-type y = $<Div, "10", 2>;
-//              ~~~ ❌
-type z = $<Div, 11, "2">;
-//                  ~~~ ❌
+type test1 = Expect<Equal<t1, 5>>;
+
+// @ts-expect-error
+type err1 = $<Div, "10", 2>;
+//                 ~~~ ❌
+
+// @ts-expect-error
+type err2 = $<Div, 11, "2">;
+//                     ~~~ ❌
 
 /**
  * Partial application in order
  */
 
 type Div1 = $<Div, 10>;
-type Three = $<Div1, 2>;
+type t2 = $<Div1, 2>;
+//   ^?
+type test2 = Expect<Equal<t2, 5>>;
 //    ^?
-type w = $<$<Div, 10>, "2">;
-//                     ~~~ ❌
+
+// @ts-expect-error
+type t3 = $<$<Div, 10>, "2">;
+//                      ~~~ ❌
 
 /**
  * Partial application different order
  */
 type DivBy2 = $<Div, _, 2>;
 //   ^?
-type q = $<DivBy2, 10>; // 5 ✅
+type t4 = $<DivBy2, 10>; // 5 ✅
 //   ^?
+type test4 = Expect<Equal<t4, 5>>;
 
-type r = $<$<Div, _>, 10, 5>; // ✅
+type t5 = $<$<Div, _>, 10, 5>; // ✅
 //   ^?
+type test5 = Expect<Equal<t5, 2>>;
 
 type TakeStr = $<TakeNumAndStr, 10>;
 //   ^? Ap<TakeNumAndStr, [10]>
-type e = $<TakeStr, 10>;
-//                  ~~ ❌
+
+// @ts-expect-error
+type t8 = $<TakeStr, 10>;
+//                   ~~ ❌
 
 type TakeNum = $<TakeNumAndStr, _, "10">;
 //   ^?Ap<TakeNumAndStr, [_, "10"]>
-type s = $<TakeNum, 10>; // ✅
-type d = $<TakeNum, "10">;
-//                  ~~~~ ❌
+
+type t7 = $<TakeNum, 10>; // ✅
+type test7 = Expect<Equal<t7, true>>;
+
+// @ts-expect-error
+type t8 = $<TakeNum, "10">;
+//                   ~~~~ ❌
 
 /**
  * Higher order
@@ -169,8 +178,9 @@ interface Map<A = unknown, B = unknown> extends Fn<[Fn<[A], B>, A[]], B[]> {
     : never;
 }
 
-type z2 = $<Map<number, number>, $<Div, _, 2>, [2, 4, 6, 8, 10]>;
+type t9 = $<Map<number, number>, $<Div, _, 2>, [2, 4, 6, 8, 10]>;
 //   ^? [1, 2, 3, 4, 5]
+type test9 = Expect<Equal<t9, [1, 2, 3, 4, 5]>>;
 
 interface Add extends Fn<[number, number], number> {
   return: NumberImpl.Add<Arg0<this>, Arg1<this>>;
@@ -194,14 +204,21 @@ interface Reduce<A = unknown, B = unknown>
     : never;
 }
 
-type reduced1 = $<Reduce<number, number>, Add, 0, [2, 4, 6, 8, 10]>;
+type t11 = $<Reduce<number, number>, Add, 0, [2, 4, 6, 8, 10]>;
 //   ^? 30
-type reduced2 = $<Reduce<number, number>, Mul, 1, [2, 4, 6, 8, 10]>;
+type test11 = Expect<Equal<t11, 30>>;
+
+type t12 = $<Reduce<number, number>, Mul, 1, [2, 4, 6, 8, 10]>;
 //   ^? 3840
-type reduced3 = $<Reduce<number, number>, Mul, 1, ["2", "4", "6", "8", "10"]>;
-//                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~ ❌
-type reducedOops = $<Reduce, Mul, 1, "oops">;
-//                                   ~~~~~~ ❌
+type test12 = Expect<Equal<t12, 3840>>;
+
+// @ts-expect-error
+type t13 = $<Reduce<number, number>, Mul, 1, ["2", "4", "6", "8", "10"]>;
+//                                           ~~~~~~~~~~~~~~~~~~~~~~~~~~ ❌
+
+// @ts-expect-error
+type t14 = $<Reduce, Mul, 1, "oops">;
+//                           ~~~~~~ ❌
 
 interface NumToStringReducer extends Fn<[string, number], string> {
   return: `${Arg0<this>}${Arg1<this>}`;
@@ -212,12 +229,14 @@ interface StringToNumReducer extends Fn<[number, string], number> {
 }
 
 // prettier-ignore
-type reduced4 = $<Reduce<string, number>, StringToNumReducer, 1, ["a", "aa", "aaa", "aaaa", "aaaaa"]>;
+type t15 = $<Reduce<string, number>, StringToNumReducer, 1, ["a", "aa", "aaa", "aaaa", "aaaaa"]>;
 //     ^? 16
+type test15 = Expect<Equal<t15, 16>>;
 
+// @ts-expect-error
 // prettier-ignore
-type reduced5 = $<Reduce<string, number>, NumToStringReducer, 1, ["a", "aa", "aaa", "aaaa", "aaaaa"]>;
-//                                        ~~~~~~~~~~~~~~~~~~ ❌
+type t16 = $<Reduce<string, number>, NumToStringReducer, 1, ["a", "aa", "aaa", "aaaa", "aaaaa"]>;
+//                                   ~~~~~~~~~~~~~~~~~~ ❌
 
 interface ToString extends Fn<[number], string> {
   return: `${Arg0<this>}`;
@@ -237,15 +256,19 @@ interface ToArray extends Fn<[unknown], [unknown]> {
 
 type Times10<T extends number> = $<Prepend, "1", $<ToString, T>>;
 
-type test1 = Times10<10>;
+type t17 = Times10<10>;
 //    ^? 110
+type test17 = Expect<Equal<t17, "110">>;
 
+// @ts-expect-error
 type WrongComposition1<T extends string> = $<Prepend, "1", $<ToNumber, T>>;
 //                                                         ~~~~~~~~~~~~~~ ❌
+// @ts-expect-error
 type WrongComposition2<T extends number> = $<Add, 1, $<ToString, T>>;
 //                                                   ~~~~~~~~~~~~~~ ❌
 
 type Test<T extends string> = $<Prepend, "1", T>;
 
-type test2 = Test<"10">;
+type t18 = Test<"10">;
 //    ^? 110
+type test18 = Expect<Equal<t18, "110">>;
diff --git a/src/internals/core/Core3.ts b/src/internals/core/Core3.ts
new file mode 100644
index 0000000..3c3d08d
--- /dev/null
+++ b/src/internals/core/Core3.ts
@@ -0,0 +1,357 @@
+import { _, unset } from "./Core";
+import { ExcludePlaceholders, ExcludeUnset, MergeArgs } from "./impl/MergeArgs";
+import * as NumberImpl from "../numbers/impl/numbers";
+import * as StringImpl from "../strings/impl/strings";
+import { Equal, Expect } from "../helpers";
+
+/**
+ * Core
+ */
+
+export interface Fn<input extends unknown[] = unknown[], output = unknown> {
+  inputTypes: input;
+  outputType: output;
+  args: unknown;
+  return: unknown;
+}
+
+export type Apply<fn extends Fn, args extends unknown[]> = (fn & {
+  args: args;
+})["return"];
+
+type ExcludePlaceholdersFromInputTypes<
+  inputTypes extends unknown[],
+  partialArgs extends unknown[],
+  result extends unknown[] = []
+> = [inputTypes, partialArgs] extends [
+  [infer fInput, ...infer rInput],
+  [infer fPartial, ...infer rPartial]
+]
+  ? ExcludePlaceholdersFromInputTypes<
+      rInput,
+      rPartial,
+      fPartial extends _ ? [...result, fInput] : result
+    >
+  : [...result, ...inputTypes];
+
+interface Applied<fn extends Fn, partialArgs extends unknown[] = []>
+  extends Fn {
+  name: "$.partial";
+
+  argsArray: Extract<this["args"], unknown[]>;
+  allArgs: [...partialArgs, ...this["argsArray"]];
+
+  inputTypes: ExcludePlaceholdersFromInputTypes<fn["inputTypes"], partialArgs>;
+
+  outputType: fn["outputType"];
+
+  return: Apply<fn, MergeArgs<this["argsArray"], partialArgs>>;
+}
+
+namespace Tuple {
+  export type Last<xs> = xs extends [...any, infer last] ? last : never;
+}
+
+type ApplyLeftToRight<x extends any[], fns> = fns extends [
+  infer fn extends Fn,
+  ...infer restFns
+]
+  ? ApplyLeftToRight<[Apply<fn, x>], restFns>
+  : x[0];
+
+interface Piped<fns extends Fn[]> extends Fn {
+  name: "$.pipe";
+
+  inputTypes: fns[0]["inputTypes"];
+  outputType: Extract<Tuple.Last<fns>, Fn>["outputType"];
+
+  return: ApplyLeftToRight<Extract<this["args"], any[]>, fns>;
+}
+
+namespace $ {
+  export type partial<
+    fn extends Fn,
+    arg0 extends fn["inputTypes"][0] | _ = unset,
+    arg1 extends fn["inputTypes"][1] | _ = unset,
+    arg2 extends fn["inputTypes"][2] | _ = unset,
+    arg3 extends fn["inputTypes"][3] | _ = unset
+  > = Applied<fn, ExcludeUnset<[arg0, arg1, arg2, arg3]>>;
+
+  type getOutputType<x> = x extends { outputType: infer O } ? O : never;
+
+  export type pipe<
+    fn0 extends Fn,
+    fn1 extends Fn<[getOutputType<fn0>]> | unset = unset,
+    fn2 extends Fn<[getOutputType<fn1>]> | unset = unset,
+    fn3 extends Fn<[getOutputType<fn2>]> | unset = unset,
+    fn4 extends Fn<[getOutputType<fn3>]> | unset = unset,
+    fn5 extends Fn<[getOutputType<fn4>]> | unset = unset,
+    fn6 extends Fn<[getOutputType<fn5>]> | unset = unset,
+    fn7 extends Fn<[getOutputType<fn6>]> | unset = unset,
+    fn8 extends Fn<[getOutputType<fn7>]> | unset = unset,
+    fn9 extends Fn<[getOutputType<fn8>]> | unset = unset,
+    fn10 extends Fn<[getOutputType<fn9>]> | unset = unset,
+    fn11 extends Fn<[getOutputType<fn10>]> | unset = unset,
+    fn12 extends Fn<[getOutputType<fn11>]> | unset = unset,
+    fn13 extends Fn<[getOutputType<fn12>]> | unset = unset
+  > = Piped<
+    Extract<
+      ExcludeUnset<
+        [
+          fn0,
+          fn1,
+          fn2,
+          fn3,
+          fn4,
+          fn5,
+          fn6,
+          fn7,
+          fn8,
+          fn9,
+          fn10,
+          fn11,
+          fn12,
+          fn13
+        ]
+      >,
+      Fn[]
+    >
+  >;
+}
+
+export type $<
+  fn extends Fn,
+  arg0 extends fn["inputTypes"][0] = unset,
+  arg1 extends fn["inputTypes"][1] = unset,
+  arg2 extends fn["inputTypes"][2] = unset,
+  arg3 extends fn["inputTypes"][3] = unset
+> = Extract<
+  (fn & {
+    args: ExcludeUnset<[arg0, arg1, arg2, arg3]>;
+  })["return"],
+  fn["outputType"]
+>;
+
+type Args<fn extends Fn> = fn["args"];
+type Arg0<fn extends Fn> = Extract<
+  Extract<fn["args"], unknown[]>[0],
+  fn["inputTypes"][0]
+>;
+type Arg1<fn extends Fn> = Extract<
+  Extract<fn["args"], unknown[]>[1],
+  fn["inputTypes"][1]
+>;
+type Arg2<fn extends Fn> = Extract<
+  Extract<fn["args"], unknown[]>[2],
+  fn["inputTypes"][2]
+>;
+type Arg3<fn extends Fn> = Extract<
+  Extract<fn["args"], unknown[]>[3],
+  fn["inputTypes"][3]
+>;
+
+/**
+ * Playground 👇
+ */
+
+type ExpectNumber<a extends number> = [a];
+// arguments are typed internally:
+interface TakeNumAndStr extends Fn<[number, string], boolean> {
+  works: ExpectNumber<Arg0<this>>; // ✅
+  // @ts-expect-error
+  fails: ExpectNumber<Arg1<this>>;
+  //                  ~~~~~~~~~~  ❌
+  return: true;
+}
+
+interface Div extends Fn<[number, number], number> {
+  return: NumberImpl.Div<Arg0<this>, Arg1<this>>;
+}
+
+/**
+ * Full application
+ */
+
+type t1 = $<Div, 10, 2>; // 5
+//   ^?
+type test1 = Expect<Equal<t1, 5>>;
+
+// @ts-expect-error
+type err1 = $<Div, "10", 2>;
+//                 ~~~ ❌
+
+// @ts-expect-error
+type err2 = $<Div, 11, "2">;
+//                     ~~~ ❌
+
+/**
+ * Partial application in order
+ */
+
+type Div1 = $.partial<Div, 10>;
+type t2 = $<Div1, 2>;
+//   ^?
+type test2 = Expect<Equal<t2, 5>>;
+//    ^?
+
+// @ts-expect-error
+type t3 = $<$.partial<Div, 10>, "2">;
+//                       ~~~ ❌
+
+/**
+ * Partial application different order
+ */
+type DivBy2 = $.partial<Div, _, 2>;
+//   ^?
+type t4 = $<DivBy2, 10>; // 5 ✅
+//   ^?
+type test4 = Expect<Equal<t4, 5>>;
+
+type t5 = $<$.partial<Div, _>, 10, 5>; // ✅
+//   ^?
+type test5 = Expect<Equal<t5, 2>>;
+
+type TakeStr = $.partial<TakeNumAndStr, 10>;
+//   ^? $.partial<TakeNumAndStr, [10]>
+
+// @ts-expect-error
+type t8 = $<TakeStr, 10>;
+//                   ~~ ❌
+
+type TakeNum = $.partial<TakeNumAndStr, _, "10">;
+//   ^?$.partial<TakeNumAndStr, [_, "10"]>
+
+type t7 = $<TakeNum, 10>; // ✅
+type test7 = Expect<Equal<t7, true>>;
+
+// @ts-expect-error
+type t8 = $<TakeNum, "10">;
+//                   ~~~~ ❌
+
+/**
+ * Higher order
+ */
+
+interface Map<A = unknown, B = unknown> extends Fn<[Fn<[A], B>, A[]], B[]> {
+  return: Args<this> extends [infer fn extends Fn, infer tuple]
+    ? { [key in keyof tuple]: $<fn, tuple[key]> }
+    : never;
+}
+
+type t9 = $<Map<number, number>, $.partial<Div, _, 2>, [2, 4, 6, 8, 10]>;
+//   ^? [1, 2, 3, 4, 5]
+type test9 = Expect<Equal<t9, [1, 2, 3, 4, 5]>>;
+
+type Defaults<a, b> = [a] extends [undefined] ? b : a;
+
+interface Add extends Fn<[number, number], number> {
+  return: NumberImpl.Add<Arg0<this>, Arg1<this>>;
+}
+
+interface Mul extends Fn<[number, number], number> {
+  return: NumberImpl.Mul<Arg0<this>, Arg1<this>>;
+}
+
+type ReduceImpl<fn extends Fn, acc, xs> = xs extends [
+  infer first,
+  ...infer rest
+]
+  ? ReduceImpl<fn, $<fn, acc, first>, rest>
+  : acc;
+
+interface Reduce<A = unknown, B = unknown>
+  extends Fn<[Fn<[B, A], B>, B, A[]], B> {
+  return: Args<this> extends [infer fn extends Fn, infer acc, infer tuple]
+    ? ReduceImpl<fn, acc, tuple>
+    : never;
+}
+
+type t11 = $<Reduce<number, number>, Add, 0, [2, 4, 6, 8, 10]>;
+//   ^? 30
+type test11 = Expect<Equal<t11, 30>>;
+
+type t12 = $<Reduce<number, number>, Mul, 1, [2, 4, 6, 8, 10]>;
+//   ^? 3840
+type test12 = Expect<Equal<t12, 3840>>;
+
+// @ts-expect-error
+type t13 = $<Reduce<number, number>, Mul, 1, ["2", "4", "6", "8", "10"]>;
+//                                           ~~~~~~~~~~~~~~~~~~~~~~~~~~ ❌
+
+// @ts-expect-error
+type t14 = $<Reduce, Mul, 1, "oops">;
+//                           ~~~~~~ ❌
+
+interface NumToStringReducer extends Fn<[string, number], string> {
+  return: `${Arg0<this>}${Arg1<this>}`;
+}
+
+interface StringToNumReducer extends Fn<[number, string], number> {
+  return: NumberImpl.Add<Arg0<this>, StringImpl.Length<Arg1<this>>>;
+}
+
+// prettier-ignore
+type t15 = $<Reduce<string, number>, StringToNumReducer, 1, ["a", "aa", "aaa", "aaaa", "aaaaa"]>;
+//     ^? 16
+type test15 = Expect<Equal<t15, 16>>;
+
+// @ts-expect-error
+// prettier-ignore
+type t16 = $<Reduce<string, number>, NumToStringReducer, 1, ["a", "aa", "aaa", "aaaa", "aaaaa"]>;
+//                                   ~~~~~~~~~~~~~~~~~~ ❌
+
+interface ToString extends Fn<[number], string> {
+  return: `${Arg0<this>}`;
+}
+
+interface ToNumber extends Fn<[string], number> {
+  return: Arg0<this> extends `${infer N extends number}` ? N : never;
+}
+
+interface Prepend extends Fn<[string, string], string> {
+  return: `${Arg0<this>}${Arg1<this>}`;
+}
+
+interface ToArray extends Fn<[unknown], [unknown]> {
+  return: [Arg0<this>];
+}
+
+type Times10<T extends number> = $<Prepend, "1", $<ToString, T>>;
+
+type t17 = Times10<10>;
+//    ^? 110
+type test17 = Expect<Equal<t17, "110">>;
+
+// @ts-expect-error
+type WrongComposition1<T extends string> = $<Prepend, "1", $<ToNumber, T>>;
+//                                                         ~~~~~~~~~~~~~~ ❌
+// @ts-expect-error
+type WrongComposition2<T extends number> = $<Add, 1, $<ToString, T>>;
+//                                                   ~~~~~~~~~~~~~~ ❌
+
+type Test<T extends string> = $<Prepend, "1", T>;
+
+type t18 = Test<"10">;
+//    ^? 110
+type test18 = Expect<Equal<t18, "110">>;
+
+type MapAdd1 = $.partial<Map<number>, $.partial<Add, 1>>;
+type Sum = $.partial<Reduce<number, number>, Add, 0>;
+
+type t19 = $<
+  // ^?
+  $.pipe<
+    MapAdd1,
+    Sum,
+    ToString,
+    $.partial<Prepend, "1">,
+    ToNumber,
+    $.partial<Mul, _, 10>,
+    $.partial<Div, _, 2>,
+    ToString,
+    $.partial<Prepend, _, "10">,
+    ToNumber
+  >,
+  [1, 2, 3, 4]
+>;
+type test19 = Expect<Equal<t19, 57010>>;

From 2adf1cc362441afa7dabb28fdaee324b18e34ee2 Mon Sep 17 00:00:00 2001
From: gvergnaud <gabriel.vergnaud@gmail.com>
Date: Sun, 16 Jul 2023 19:27:21 +0200
Subject: [PATCH 6/8] Add more examples

---
 src/internals/core/Core3.ts          | 40 +++++++++++++++++-----------
 src/internals/core/impl/MergeArgs.ts |  2 +-
 2 files changed, 26 insertions(+), 16 deletions(-)

diff --git a/src/internals/core/Core3.ts b/src/internals/core/Core3.ts
index 3c3d08d..a5a9472 100644
--- a/src/internals/core/Core3.ts
+++ b/src/internals/core/Core3.ts
@@ -232,13 +232,13 @@ type t8 = $<TakeNum, "10">;
  * Higher order
  */
 
-interface Map<A = unknown, B = unknown> extends Fn<[Fn<[A], B>, A[]], B[]> {
+interface Map<A = unknown, B = A> extends Fn<[Fn<[A], B>, A[]], B[]> {
   return: Args<this> extends [infer fn extends Fn, infer tuple]
     ? { [key in keyof tuple]: $<fn, tuple[key]> }
     : never;
 }
 
-type t9 = $<Map<number, number>, $.partial<Div, _, 2>, [2, 4, 6, 8, 10]>;
+type t9 = $<Map<number>, $.partial<Div, _, 2>, [2, 4, 6, 8, 10]>;
 //   ^? [1, 2, 3, 4, 5]
 type test9 = Expect<Equal<t9, [1, 2, 3, 4, 5]>>;
 
@@ -259,23 +259,22 @@ type ReduceImpl<fn extends Fn, acc, xs> = xs extends [
   ? ReduceImpl<fn, $<fn, acc, first>, rest>
   : acc;
 
-interface Reduce<A = unknown, B = unknown>
-  extends Fn<[Fn<[B, A], B>, B, A[]], B> {
+interface Reduce<A = unknown, B = A> extends Fn<[Fn<[B, A], B>, B, A[]], B> {
   return: Args<this> extends [infer fn extends Fn, infer acc, infer tuple]
     ? ReduceImpl<fn, acc, tuple>
     : never;
 }
 
-type t11 = $<Reduce<number, number>, Add, 0, [2, 4, 6, 8, 10]>;
+type t11 = $<Reduce<number>, Add, 0, [2, 4, 6, 8, 10]>;
 //   ^? 30
 type test11 = Expect<Equal<t11, 30>>;
 
-type t12 = $<Reduce<number, number>, Mul, 1, [2, 4, 6, 8, 10]>;
+type t12 = $<Reduce<number>, Mul, 1, [2, 4, 6, 8, 10]>;
 //   ^? 3840
 type test12 = Expect<Equal<t12, 3840>>;
 
 // @ts-expect-error
-type t13 = $<Reduce<number, number>, Mul, 1, ["2", "4", "6", "8", "10"]>;
+type t13 = $<Reduce<number>, Mul, 1, ["2", "4", "6", "8", "10"]>;
 //                                           ~~~~~~~~~~~~~~~~~~~~~~~~~~ ❌
 
 // @ts-expect-error
@@ -335,23 +334,34 @@ type t18 = Test<"10">;
 //    ^? 110
 type test18 = Expect<Equal<t18, "110">>;
 
-type MapAdd1 = $.partial<Map<number>, $.partial<Add, 1>>;
-type Sum = $.partial<Reduce<number, number>, Add, 0>;
+type Sum = $.partial<Reduce<number>, Add, 0>;
 
-type t19 = $<
-  // ^?
+type Composition<T extends number[]> = $<
   $.pipe<
-    MapAdd1,
+    $.partial<Map<number>, $.partial<Add, 1>>,
+    $.partial<
+      Map<number>,
+      $.pipe<
+        $.partial<Add, 1>,
+        $.partial<Mul, 3>,
+        ToString,
+        $.partial<Prepend, "1">,
+        ToNumber
+      >
+    >,
     Sum,
     ToString,
     $.partial<Prepend, "1">,
     ToNumber,
-    $.partial<Mul, _, 10>,
+    $.partial<Mul, 10>,
     $.partial<Div, _, 2>,
     ToString,
     $.partial<Prepend, _, "10">,
     ToNumber
   >,
-  [1, 2, 3, 4]
+  T
 >;
-type test19 = Expect<Equal<t19, 57010>>;
+
+type t19 = Composition<[1, 2, 3, 4]>;
+//   ^?
+type test19 = Expect<Equal<t19, 682010>>;
diff --git a/src/internals/core/impl/MergeArgs.ts b/src/internals/core/impl/MergeArgs.ts
index e892aa1..3c40d53 100644
--- a/src/internals/core/impl/MergeArgs.ts
+++ b/src/internals/core/impl/MergeArgs.ts
@@ -14,7 +14,7 @@ export type ExcludeUnset<xs, output extends any[] = []> = xs extends [
   infer first,
   ...infer rest
 ]
-  ? Equal<first, unset> extends true
+  ? first extends unset
     ? ExcludeUnset<rest, output>
     : ExcludeUnset<rest, [...output, first]>
   : output;

From 318759a03c72bce33981dc5ba5de65152ee5f7b2 Mon Sep 17 00:00:00 2001
From: gvergnaud <gabriel.vergnaud@gmail.com>
Date: Mon, 17 Jul 2023 19:27:40 +0200
Subject: [PATCH 7/8] try creating larger compositions

---
 src/internals/core/Core2.ts |  78 +++++++++++++
 src/internals/core/Core3.ts | 212 ++++++++++++++++++++++--------------
 test/tuples.test.ts         |  34 +++++-
 3 files changed, 242 insertions(+), 82 deletions(-)

diff --git a/src/internals/core/Core2.ts b/src/internals/core/Core2.ts
index 800dd5b..b5b6409 100644
--- a/src/internals/core/Core2.ts
+++ b/src/internals/core/Core2.ts
@@ -55,6 +55,52 @@ interface Ap<fn extends Fn, partialArgs extends unknown[] = []> extends Fn {
     : Ap<fn, this["allArgs"]>;
 }
 
+namespace Tuple {
+  export type Last<xs> = xs extends [...any, infer last] ? last : never;
+}
+
+type ApplyLeftToRight<x extends any[], fns> = fns extends [
+  infer fn extends Fn,
+  ...infer restFns
+]
+  ? ApplyLeftToRight<[Apply<fn, x>], restFns>
+  : x[0];
+
+interface Piped<fns extends Fn[]> extends Fn {
+  name: "Pipe";
+
+  inputTypes: fns[0]["inputTypes"];
+  outputType: Extract<Tuple.Last<fns>, Fn>["outputType"];
+
+  return: ApplyLeftToRight<Extract<this["args"], any[]>, fns>;
+}
+
+type GetOutputType<x> = x extends { outputType: infer O } ? O : never;
+
+export type Pipe<
+  fn0 extends Fn,
+  fn1 extends Fn<[GetOutputType<fn0>]> | unset = unset,
+  fn2 extends Fn<[GetOutputType<fn1>]> | unset = unset,
+  fn3 extends Fn<[GetOutputType<fn2>]> | unset = unset,
+  fn4 extends Fn<[GetOutputType<fn3>]> | unset = unset,
+  fn5 extends Fn<[GetOutputType<fn4>]> | unset = unset,
+  fn6 extends Fn<[GetOutputType<fn5>]> | unset = unset,
+  fn7 extends Fn<[GetOutputType<fn6>]> | unset = unset,
+  fn8 extends Fn<[GetOutputType<fn7>]> | unset = unset,
+  fn9 extends Fn<[GetOutputType<fn8>]> | unset = unset,
+  fn10 extends Fn<[GetOutputType<fn9>]> | unset = unset,
+  fn11 extends Fn<[GetOutputType<fn10>]> | unset = unset,
+  fn12 extends Fn<[GetOutputType<fn11>]> | unset = unset,
+  fn13 extends Fn<[GetOutputType<fn12>]> | unset = unset
+> = Piped<
+  Extract<
+    ExcludeUnset<
+      [fn0, fn1, fn2, fn3, fn4, fn5, fn6, fn7, fn8, fn9, fn10, fn11, fn12, fn13]
+    >,
+    Fn[]
+  >
+>;
+
 export type Apply<fn extends Fn, args extends unknown[]> = (fn & {
   args: args;
 })["return"];
@@ -73,18 +119,22 @@ export type $<
 })["return"];
 
 type Args<fn extends Fn> = fn["args"];
+
 type Arg0<fn extends Fn> = Extract<
   Extract<fn["args"], unknown[]>[0],
   fn["inputTypes"][0]
 >;
+
 type Arg1<fn extends Fn> = Extract<
   Extract<fn["args"], unknown[]>[1],
   fn["inputTypes"][1]
 >;
+
 type Arg2<fn extends Fn> = Extract<
   Extract<fn["args"], unknown[]>[2],
   fn["inputTypes"][2]
 >;
+
 type Arg3<fn extends Fn> = Extract<
   Extract<fn["args"], unknown[]>[3],
   fn["inputTypes"][3]
@@ -272,3 +322,31 @@ type Test<T extends string> = $<Prepend, "1", T>;
 type t18 = Test<"10">;
 //    ^? 110
 type test18 = Expect<Equal<t18, "110">>;
+
+type Sum = $<Reduce<number>, Add, 0>;
+
+type TransformNumber = Pipe<
+  $<Add, 1>,
+  $<Mul, 3>,
+  ToString,
+  $<Prepend, "1">,
+  ToNumber
+>;
+
+type Composed = Pipe<
+  $<Map<number>, $<Add, 1>>,
+  $<Map<number>, TransformNumber>,
+  Sum,
+  ToString,
+  $<Prepend, "1">,
+  ToNumber,
+  $<Mul, 10>,
+  $<Div, _, 2>,
+  ToString,
+  $<Prepend, _, "10">,
+  ToNumber
+>;
+
+type t19 = $<Composed, [1, 2, 3, 4]>;
+//   ^?
+type test19 = Expect<Equal<t19, 5010>>;
diff --git a/src/internals/core/Core3.ts b/src/internals/core/Core3.ts
index a5a9472..6e79503 100644
--- a/src/internals/core/Core3.ts
+++ b/src/internals/core/Core3.ts
@@ -1,5 +1,5 @@
 import { _, unset } from "./Core";
-import { ExcludePlaceholders, ExcludeUnset, MergeArgs } from "./impl/MergeArgs";
+import { ExcludeUnset, MergeArgs } from "./impl/MergeArgs";
 import * as NumberImpl from "../numbers/impl/numbers";
 import * as StringImpl from "../strings/impl/strings";
 import { Equal, Expect } from "../helpers";
@@ -8,8 +8,18 @@ import { Equal, Expect } from "../helpers";
  * Core
  */
 
-export interface Fn<input extends unknown[] = unknown[], output = unknown> {
-  inputTypes: input;
+type Contra<t> = (a: t) => void;
+
+type GetInputTypes<fn> = fn extends {
+  inputTypes: Contra<infer I extends any[]>;
+}
+  ? I
+  : never;
+
+type GetOutputType<fn> = fn extends { outputType: infer O } ? O : never;
+
+export interface Fn<in input extends any = any, out output = unknown> {
+  inputTypes: Contra<input>;
   outputType: output;
   args: unknown;
   return: unknown;
@@ -41,7 +51,9 @@ interface Applied<fn extends Fn, partialArgs extends unknown[] = []>
   argsArray: Extract<this["args"], unknown[]>;
   allArgs: [...partialArgs, ...this["argsArray"]];
 
-  inputTypes: ExcludePlaceholdersFromInputTypes<fn["inputTypes"], partialArgs>;
+  inputTypes: Contra<
+    ExcludePlaceholdersFromInputTypes<GetInputTypes<fn>, partialArgs>
+  >;
 
   outputType: fn["outputType"];
 
@@ -71,60 +83,82 @@ interface Piped<fns extends Fn[]> extends Fn {
 namespace $ {
   export type partial<
     fn extends Fn,
-    arg0 extends fn["inputTypes"][0] | _ = unset,
-    arg1 extends fn["inputTypes"][1] | _ = unset,
-    arg2 extends fn["inputTypes"][2] | _ = unset,
-    arg3 extends fn["inputTypes"][3] | _ = unset
+    arg0 extends GetInputTypes<fn>[0] | _ = unset,
+    arg1 extends GetInputTypes<fn>[1] | _ = unset,
+    arg2 extends GetInputTypes<fn>[2] | _ = unset,
+    arg3 extends GetInputTypes<fn>[3] | _ = unset
   > = Applied<fn, ExcludeUnset<[arg0, arg1, arg2, arg3]>>;
 
-  type getOutputType<x> = x extends { outputType: infer O } ? O : never;
+  export type call<
+    fn extends Fn,
+    arg0 extends GetInputTypes<fn>[0] = unset,
+    arg1 extends GetInputTypes<fn>[1] = unset,
+    arg2 extends GetInputTypes<fn>[2] = unset,
+    arg3 extends GetInputTypes<fn>[3] = unset
+  > = Extract<
+    (fn & {
+      args: ExcludeUnset<[arg0, arg1, arg2, arg3]>;
+    })["return"],
+    fn["outputType"]
+  >;
 
   export type pipe<
     fn0 extends Fn,
-    fn1 extends Fn<[getOutputType<fn0>]> | unset = unset,
-    fn2 extends Fn<[getOutputType<fn1>]> | unset = unset,
-    fn3 extends Fn<[getOutputType<fn2>]> | unset = unset,
-    fn4 extends Fn<[getOutputType<fn3>]> | unset = unset,
-    fn5 extends Fn<[getOutputType<fn4>]> | unset = unset,
-    fn6 extends Fn<[getOutputType<fn5>]> | unset = unset,
-    fn7 extends Fn<[getOutputType<fn6>]> | unset = unset,
-    fn8 extends Fn<[getOutputType<fn7>]> | unset = unset,
-    fn9 extends Fn<[getOutputType<fn8>]> | unset = unset,
-    fn10 extends Fn<[getOutputType<fn9>]> | unset = unset,
-    fn11 extends Fn<[getOutputType<fn10>]> | unset = unset,
-    fn12 extends Fn<[getOutputType<fn11>]> | unset = unset,
-    fn13 extends Fn<[getOutputType<fn12>]> | unset = unset
+    fn1 extends Fn<[GetOutputType<fn0>]> | unset = unset,
+    fn2 extends Fn<[GetOutputType<fn1>]> | unset = unset,
+    fn3 extends Fn<[GetOutputType<fn2>]> | unset = unset,
+    fn4 extends Fn<[GetOutputType<fn3>]> | unset = unset,
+    fn5 extends Fn<[GetOutputType<fn4>]> | unset = unset,
+    fn6 extends Fn<[GetOutputType<fn5>]> | unset = unset,
+    fn7 extends Fn<[GetOutputType<fn6>]> | unset = unset,
+    fn8 extends Fn<[GetOutputType<fn7>]> | unset = unset,
+    fn9 extends Fn<[GetOutputType<fn8>]> | unset = unset,
+    fn10 extends Fn<[GetOutputType<fn9>]> | unset = unset,
+    fn11 extends Fn<[GetOutputType<fn10>]> | unset = unset,
+    fn12 extends Fn<[GetOutputType<fn11>]> | unset = unset,
+    fn13 extends Fn<[GetOutputType<fn12>]> | unset = unset,
+    fn14 extends Fn<[GetOutputType<fn13>]> | unset = unset,
+    fn15 extends Fn<[GetOutputType<fn14>]> | unset = unset,
+    fn16 extends Fn<[GetOutputType<fn15>]> | unset = unset,
+    fn17 extends Fn<[GetOutputType<fn16>]> | unset = unset,
+    fn18 extends Fn<[GetOutputType<fn17>]> | unset = unset,
+    fn19 extends Fn<[GetOutputType<fn18>]> | unset = unset,
+    fn20 extends Fn<[GetOutputType<fn19>]> | unset = unset
   > = Piped<
-    Extract<
-      ExcludeUnset<
-        [
-          fn0,
-          fn1,
-          fn2,
-          fn3,
-          fn4,
-          fn5,
-          fn6,
-          fn7,
-          fn8,
-          fn9,
-          fn10,
-          fn11,
-          fn12,
-          fn13
-        ]
-      >,
-      Fn[]
+    ExcludeUnset<
+      [
+        fn0,
+        fn1,
+        fn2,
+        fn3,
+        fn4,
+        fn5,
+        fn6,
+        fn7,
+        fn8,
+        fn9,
+        fn10,
+        fn11,
+        fn12,
+        fn13,
+        fn14,
+        fn15,
+        fn16,
+        fn17,
+        fn18,
+        fn19,
+        fn20
+      ]
     >
   >;
 }
 
 export type $<
   fn extends Fn,
-  arg0 extends fn["inputTypes"][0] = unset,
-  arg1 extends fn["inputTypes"][1] = unset,
-  arg2 extends fn["inputTypes"][2] = unset,
-  arg3 extends fn["inputTypes"][3] = unset
+  arg0 extends GetInputTypes<fn>[0] = unset,
+  arg1 extends GetInputTypes<fn>[1] = unset,
+  arg2 extends GetInputTypes<fn>[2] = unset,
+  arg3 extends GetInputTypes<fn>[3] = unset
 > = Extract<
   (fn & {
     args: ExcludeUnset<[arg0, arg1, arg2, arg3]>;
@@ -135,19 +169,19 @@ export type $<
 type Args<fn extends Fn> = fn["args"];
 type Arg0<fn extends Fn> = Extract<
   Extract<fn["args"], unknown[]>[0],
-  fn["inputTypes"][0]
+  GetInputTypes<fn>[0]
 >;
 type Arg1<fn extends Fn> = Extract<
   Extract<fn["args"], unknown[]>[1],
-  fn["inputTypes"][1]
+  GetInputTypes<fn>[1]
 >;
 type Arg2<fn extends Fn> = Extract<
   Extract<fn["args"], unknown[]>[2],
-  fn["inputTypes"][2]
+  GetInputTypes<fn>[2]
 >;
 type Arg3<fn extends Fn> = Extract<
   Extract<fn["args"], unknown[]>[3],
-  fn["inputTypes"][3]
+  GetInputTypes<fn>[3]
 >;
 
 /**
@@ -232,7 +266,7 @@ type t8 = $<TakeNum, "10">;
  * Higher order
  */
 
-interface Map<A = unknown, B = A> extends Fn<[Fn<[A], B>, A[]], B[]> {
+interface Map<A = any, B = A> extends Fn<[Fn<[A], B>, A[]], B[]> {
   return: Args<this> extends [infer fn extends Fn, infer tuple]
     ? { [key in keyof tuple]: $<fn, tuple[key]> }
     : never;
@@ -259,7 +293,7 @@ type ReduceImpl<fn extends Fn, acc, xs> = xs extends [
   ? ReduceImpl<fn, $<fn, acc, first>, rest>
   : acc;
 
-interface Reduce<A = unknown, B = A> extends Fn<[Fn<[B, A], B>, B, A[]], B> {
+interface Reduce<A = any, B = A> extends Fn<[Fn<[B, A], B>, B, A[]], B> {
   return: Args<this> extends [infer fn extends Fn, infer acc, infer tuple]
     ? ReduceImpl<fn, acc, tuple>
     : never;
@@ -275,7 +309,7 @@ type test12 = Expect<Equal<t12, 3840>>;
 
 // @ts-expect-error
 type t13 = $<Reduce<number>, Mul, 1, ["2", "4", "6", "8", "10"]>;
-//                                           ~~~~~~~~~~~~~~~~~~~~~~~~~~ ❌
+//                                   ~~~~~~~~~~~~~~~~~~~~~~~~~~ ❌
 
 // @ts-expect-error
 type t14 = $<Reduce, Mul, 1, "oops">;
@@ -311,7 +345,7 @@ interface Prepend extends Fn<[string, string], string> {
   return: `${Arg0<this>}${Arg1<this>}`;
 }
 
-interface ToArray extends Fn<[unknown], [unknown]> {
+interface ToArray<T = unknown> extends Fn<[T], [T]> {
   return: [Arg0<this>];
 }
 
@@ -322,6 +356,7 @@ type t17 = Times10<10>;
 type test17 = Expect<Equal<t17, "110">>;
 
 // @ts-expect-error
+// prettier-ignore
 type WrongComposition1<T extends string> = $<Prepend, "1", $<ToNumber, T>>;
 //                                                         ~~~~~~~~~~~~~~ ❌
 // @ts-expect-error
@@ -334,34 +369,49 @@ type t18 = Test<"10">;
 //    ^? 110
 type test18 = Expect<Equal<t18, "110">>;
 
-type Sum = $.partial<Reduce<number>, Add, 0>;
-
-type Composition<T extends number[]> = $<
-  $.pipe<
-    $.partial<Map<number>, $.partial<Add, 1>>,
-    $.partial<
-      Map<number>,
-      $.pipe<
-        $.partial<Add, 1>,
-        $.partial<Mul, 3>,
-        ToString,
-        $.partial<Prepend, "1">,
-        ToNumber
-      >
-    >,
-    Sum,
-    ToString,
-    $.partial<Prepend, "1">,
-    ToNumber,
-    $.partial<Mul, 10>,
-    $.partial<Div, _, 2>,
-    ToString,
-    $.partial<Prepend, _, "10">,
-    ToNumber
+type Sum = $.partial<Reduce, Add, 0>;
+
+type Composed = $.pipe<
+  $.partial<Map, $.partial<Add, 1>>,
+  $.partial<
+    Map,
+    $.pipe<
+      $.partial<Add, 1>,
+      $.partial<Mul, 3>,
+      ToString,
+      $.partial<Prepend, "1">,
+      ToNumber
+    >
+  >,
+  $.partial<
+    Map,
+    $.pipe<
+      $.partial<Add, 1>,
+      $.partial<Mul, 3>,
+      ToString,
+      $.partial<Prepend, "1">,
+      ToNumber
+    >
+  >,
+  $.partial<
+    Map,
+    $.pipe<
+      $.partial<Add, 1>,
+      $.partial<Mul, 3>,
+      ToString,
+      $.partial<Prepend, "1">,
+      ToNumber
+    >
   >,
-  T
+  $.partial<Map, $.partial<Add, 1>>,
+  Sum,
+  ToString,
+  $.partial<Prepend, "1">,
+  ToNumber,
+  $.partial<Mul, 10>,
+  $.partial<Div, _, 2>
 >;
 
-type t19 = Composition<[1, 2, 3, 4]>;
+type t19 = $<Composed, [1, 2, 3, 4]>;
 //   ^?
-type test19 = Expect<Equal<t19, 682010>>;
+type test19 = Expect<Equal<t19, 718140>>;
diff --git a/test/tuples.test.ts b/test/tuples.test.ts
index 6a4a8b3..52fdad8 100644
--- a/test/tuples.test.ts
+++ b/test/tuples.test.ts
@@ -1,5 +1,5 @@
 import { Booleans } from "../src/internals/booleans/Booleans";
-import { Call, Fn, Pipe, _ } from "../src/internals/core/Core";
+import { Call, ComposeLeft, Fn, Pipe, _ } from "../src/internals/core/Core";
 import { Equal, Expect } from "../src/internals/helpers";
 import { Numbers } from "../src/internals/numbers/Numbers";
 import { Strings } from "../src/internals/strings/Strings";
@@ -569,3 +569,35 @@ describe("Tuples", () => {
     type test3 = Expect<Equal<res3, 362880>>;
   });
 });
+
+type Sum = Tuples.Reduce<Numbers.Add, 0>;
+
+type Comp1 = ComposeLeft<
+  [
+    Tuples.Map<Numbers.Add<1>>,
+    Tuples.Map<
+      ComposeLeft<
+        [
+          Numbers.Add<1>,
+          Numbers.Mul<3>,
+          Strings.ToString,
+          Strings.Prepend<"1">,
+          Strings.ToNumber
+        ]
+      >
+    >,
+    Tuples.Map<Numbers.Add<1>>,
+    Sum,
+    Strings.ToString,
+    Strings.Prepend<"1">,
+    Strings.ToNumber,
+    Numbers.Mul<10>,
+    Numbers.Div<_, 2>
+  ]
+>;
+
+type Composition = ComposeLeft<[Comp1, Tuples.Append<_, []>, Comp1]>;
+
+type t19 = Call<Composition, [1, 2, 3, 4]>;
+//   ^?
+type test19 = Expect<Equal<t19, 5602635>>;

From 289a0d358ba9ccfb3ca88351c30b61c262088080 Mon Sep 17 00:00:00 2001
From: gvergnaud <gabriel.vergnaud@gmail.com>
Date: Wed, 28 Aug 2024 22:24:27 -0400
Subject: [PATCH 8/8] feat: add ability to return an error in pipe

---
 src/internals/core/Core3.ts | 16 +++++++++++++---
 1 file changed, 13 insertions(+), 3 deletions(-)

diff --git a/src/internals/core/Core3.ts b/src/internals/core/Core3.ts
index 6e79503..da8dcad 100644
--- a/src/internals/core/Core3.ts
+++ b/src/internals/core/Core3.ts
@@ -64,12 +64,16 @@ namespace Tuple {
   export type Last<xs> = xs extends [...any, infer last] ? last : never;
 }
 
-type ApplyLeftToRight<x extends any[], fns> = fns extends [
+type ApplyLeftToRight<args extends any[], fns> = fns extends [
   infer fn extends Fn,
   ...infer restFns
 ]
-  ? ApplyLeftToRight<[Apply<fn, x>], restFns>
-  : x[0];
+  ? Apply<fn, args> extends infer output
+    ? output extends $.Error<any>
+      ? output
+      : ApplyLeftToRight<[output], restFns>
+    : never
+  : args[0];
 
 interface Piped<fns extends Fn[]> extends Fn {
   name: "$.pipe";
@@ -151,6 +155,12 @@ namespace $ {
       ]
     >
   >;
+
+  const brand = Symbol.for("@hotscript/brand");
+
+  export interface Error<msg> {
+    [brand]: "@hotscript/error";
+  }
 }
 
 export type $<