From a82c978c9e394e951731e04cbce4a08d7f78a51e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Julien=20Valverd=C3=A9?= <julien.valverde@mailo.com>
Date: Thu, 1 Feb 2024 02:21:10 +0100
Subject: [PATCH] Extendable

---
 src/expresses.ts   | 38 ++++++++++++++++++++++++++++++++------
 src/tests.ts       | 10 ++++++++--
 src/util/extend.ts | 12 +++++++++++-
 3 files changed, 51 insertions(+), 9 deletions(-)

diff --git a/src/expresses.ts b/src/expresses.ts
index 716e76b..5b9ed22 100644
--- a/src/expresses.ts
+++ b/src/expresses.ts
@@ -1,10 +1,10 @@
 import { Call, Pipe, Tuples } from "hotscript"
 import { AbstractClass, Opaque } from "type-fest"
-import { Trait, TraitAbstractMembersFn, TraitApplierSuperTag, TraitImplClassFn, TraitImplInstanceFn } from "."
+import { Trait, TraitAbstractMembersFn, TraitApplierSuperTag, TraitClassFn, TraitImplClassFn, TraitImplInstanceFn, TraitInstanceFn } from "."
 import { ExtendFn, SimplifyFn, StaticMembersFn } from "./util"
 
 
-class TraitsExpression<
+class TraitExpression<
     Super  extends AbstractClass<any>,
     Traits extends readonly Trait<any, any>[],
 > {
@@ -42,9 +42,35 @@ class TraitsExpression<
     }
 }
 
+type TraitExpressionOutput<Exp extends TraitExpression<any, any>> = (
+    Exp extends TraitExpression<infer Super, infer Traits>
+        ? (
+            AbstractClass<
+                Pipe<[
+                    InstanceType<Super>,
+                    ...Call<Tuples.Map<TraitInstanceFn>, Traits>,
+                ], [
+                    ExtendFn,
+                    SimplifyFn,
+                ]>,
 
-export type Implements<Exp extends TraitsExpression<any, any>> = (
-    Exp extends TraitsExpression<any, infer Traits>
+                ConstructorParameters<Super>
+            > &
+
+            Pipe<[
+                Super,
+                ...Call<Tuples.Map<TraitClassFn>, Traits>,
+            ], [
+                Tuples.Map<StaticMembersFn>,
+                ExtendFn,
+                SimplifyFn,
+            ]>
+        )
+        : never
+)
+
+export type Implements<Exp extends TraitExpression<any, any>> = (
+    Exp extends TraitExpression<any, infer Traits>
         ? Pipe<Traits, [
             Tuples.Map<TraitAbstractMembersFn>,
             ExtendFn,
@@ -61,7 +87,7 @@ export function extendsAndExpresses<
     superclass:  Super,
     ...traits:   Traits
 ) {
-    return new TraitsExpression(superclass, traits)
+    return new TraitExpression(superclass, traits)
 }
 
 class DefaultSuperclass {}
@@ -71,5 +97,5 @@ export function expresses<
 >(
     ...traits: Traits
 ) {
-    return new TraitsExpression(DefaultSuperclass, traits)
+    return new TraitExpression(DefaultSuperclass, traits)
 }
diff --git a/src/tests.ts b/src/tests.ts
index 965715b..b5ca906 100644
--- a/src/tests.ts
+++ b/src/tests.ts
@@ -1,4 +1,6 @@
-import { Implements, TraitAbstractMembers, expresses, extendsAndExpresses, trait } from "."
+import { Booleans, Call, Compose, ComposeLeft, Match, Pipe, Tuples } from "hotscript"
+import { Implements, TraitAbstractMembers, TraitAbstractMembersFn, expresses, extendsAndExpresses, trait } from "."
+import { CheckExtendableFn, ExtendFn, Extendable, ExtendableFn, SimplifyFn } from "./util"
 
 
 const PrintsHelloOnNew = trait()(Super =>
@@ -52,7 +54,11 @@ const exp = extendsAndExpresses(
     Identifiable<bigint>(),
     // Identifiable<number>()
 )
-type Impl = Implements<typeof exp>
+type ExpImpl = Implements<typeof exp>
+type ExpAbstractMembers = Pipe<typeof exp.traits, [
+    Tuples.Map<TraitAbstractMembersFn>,
+]>
+type ExpExtendable = Extendable<ExpAbstractMembers>
 
 class User extends exp.extends() implements Implements<typeof exp> {
     id: bigint = -1n
diff --git a/src/util/extend.ts b/src/util/extend.ts
index c36ae4e..4639319 100644
--- a/src/util/extend.ts
+++ b/src/util/extend.ts
@@ -1,4 +1,4 @@
-import { Call, Fn, Tuples } from "hotscript"
+import { Call, ComposeLeft, Fn, Match, Tuples } from "hotscript"
 
 
 type CommonKeys<A, B> = Extract<keyof A, keyof B>
@@ -14,3 +14,13 @@ interface ExtendReducerFn extends Fn {
 
 export type ExtendFn = Tuples.Reduce<ExtendReducerFn, {}>
 export type Extend<T extends readonly object[]> = Call<ExtendFn, T>
+
+
+export type ExtendableFn = ComposeLeft<[
+    ExtendFn,
+    Match<[
+        Match.With<never, false>,
+        Match.With<any, true>,
+    ]>
+]>
+export type Extendable<T extends readonly object[]> = Call<ExtendableFn, T>