From 9f2c42db1432631527f68e3b0336dbf5f0d011ab Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Julien=20Valverd=C3=A9?= <julien.valverde@mailo.com>
Date: Fri, 16 Feb 2024 01:14:36 +0100
Subject: [PATCH] Refactoring

---
 src/Trait.ts           | 89 ++++++++++++++++++------------------------
 src/TraitExpression.ts | 35 +++++++++++------
 2 files changed, 63 insertions(+), 61 deletions(-)

diff --git a/src/Trait.ts b/src/Trait.ts
index 91df43a..3f2e39f 100644
--- a/src/Trait.ts
+++ b/src/Trait.ts
@@ -1,23 +1,7 @@
 import { Fn, Pipe, Tuples } from "hotscript"
 import { AbstractClass, Class } from "type-fest"
 import { TraitExpression } from "./TraitExpression"
-import { ExtendFn, SimplifyFn, StaticMembers, StaticMembersFn } from "./util"
-
-
-type AddAbstractToImplClass<
-    ImplClass      extends Class<object, []>,
-    Abstract       extends object,
-    StaticAbstract extends object,
-> = (
-    Class<
-        Abstract &
-        InstanceType<ImplClass>,
-
-        ConstructorParameters<ImplClass>
-    > &
-    StaticAbstract &
-    StaticMembers<ImplClass>
-)
+import { Extend, ExtendFn, SimplifyFn, StaticMembers, StaticMembersFn } from "./util"
 
 
 export class Trait<
@@ -82,14 +66,18 @@ export namespace Trait {
     }
 
     export type OwnClass<T> = (
-        AddAbstractToImplClass<Trait.OwnImplClass<T>, Trait.OwnAbstract<T>, Trait.OwnStaticAbstract<T>>
+        AbstractClass<Trait.OwnInstance<T>, any[]> &
+        Extend<[
+            Trait.OwnStaticAbstract<T>,
+            StaticMembers<Trait.OwnImplClass<T>>,
+        ]>
     )
     export interface OwnClassFn extends Fn {
         return: Trait.OwnClass<this["arg0"]>
     }
 
     export type OwnInstance<T> = (
-        InstanceType<Trait.OwnClass<T>>
+        Extend<[Trait.OwnAbstract<T>, Trait.OwnImplInstance<T>]>
     )
     export interface OwnInstanceFn extends Fn {
         return: Trait.OwnInstance<this["arg0"]>
@@ -101,35 +89,36 @@ export namespace Trait {
     export interface SupertraitsFn extends Fn {
         return: Trait.Supertraits<this["arg0"]>
     }
-
-    export type Class<T> = (
-        AbstractClass<
-            Trait.Instance<T>,
-            any[]
-        > &
-        Pipe<T, [
-            Trait.SupertraitsFn,
-            Tuples.Append<T>,
-            Tuples.Map<Trait.OwnClassFn>,
-            Tuples.Map<StaticMembersFn>,
-            ExtendFn,
-            SimplifyFn,
-        ]>
-    )
-    export interface ClassFn extends Fn {
-        return: Trait.Class<this["arg0"]>
-    }
-
-    export type Instance<T> = (
-        Pipe<T, [
-            Trait.SupertraitsFn,
-            Tuples.Append<T>,
-            Tuples.Map<Trait.OwnInstanceFn>,
-            ExtendFn,
-            SimplifyFn,
-        ]>
-    )
-    export interface InstanceFn extends Fn {
-        return: Trait.Instance<this["arg0"]>
-    }
 }
+
+
+export type TraitClass<T extends Trait<any, any, any, any>> = (
+    AbstractClass<TraitInstance<T>, any[]> &
+    TraitStaticMembers<T>
+)
+
+export type TraitConcreteClass<T extends Trait<any, any, any, any>> = (
+    Class<TraitInstance<T>, any[]> &
+    TraitStaticMembers<T>
+)
+
+export type TraitInstance<T extends Trait<any, any, any, any>> = (
+    Pipe<T, [
+        Trait.SupertraitsFn,
+        Tuples.Append<T>,
+        Tuples.Map<Trait.OwnInstanceFn>,
+        ExtendFn,
+        SimplifyFn,
+    ]>
+)
+
+export type TraitStaticMembers<T extends Trait<any, any, any, any>> = (
+    Pipe<T, [
+        Trait.SupertraitsFn,
+        Tuples.Append<T>,
+        Tuples.Map<Trait.OwnClassFn>,
+        Tuples.Map<StaticMembersFn>,
+        ExtendFn,
+        SimplifyFn,
+    ]>
+)
diff --git a/src/TraitExpression.ts b/src/TraitExpression.ts
index 73c467b..b631dbc 100644
--- a/src/TraitExpression.ts
+++ b/src/TraitExpression.ts
@@ -1,5 +1,5 @@
 import { Fn, Pipe, Tuples } from "hotscript"
-import { AbstractClass } from "type-fest"
+import { AbstractClass, Class } from "type-fest"
 import { Trait } from "./Trait"
 import { TraitBuilder } from "./TraitBuilder"
 import { ExtendFn, SimplifyFn, StaticMembersFn } from "./util"
@@ -59,6 +59,7 @@ export class TraitExpression<
 export namespace TraitExpression {
     export class NullSuperclass {
         static readonly _tag = "@thilawyn/traitify-ts/TraitExpression.NullSuperclass"
+        constructor(...args: any[]) {}
     }
 
     export type Superclass<T> = (
@@ -102,25 +103,37 @@ export type ImplementsStatic<Exp extends TraitExpression<any, any>> = (
 
 export type TraitExpressionClass<Exp extends TraitExpression<any, any>> = (
     AbstractClass<
+        TraitExpressionInstance<Exp>,
+        ConstructorParameters<TraitExpression.Superclass<Exp>>
     > &
-
-
+    TraitExpressionStaticMembers<Exp>
 )
 
 export type TraitExpressionConcreteClass<Exp extends TraitExpression<any, any>> = (
-
+    Class<
+        TraitExpressionInstance<Exp>,
+        ConstructorParameters<TraitExpression.Superclass<Exp>>
+    > &
+    TraitExpressionStaticMembers<Exp>
 )
 
 export type TraitExpressionInstance<Exp extends TraitExpression<any, any>> = (
-
+    Pipe<TraitExpression.Traits<Exp>, [
+        Tuples.Map<Trait.OwnInstanceFn>,                   // Map all the traits to their instance representation
+        Tuples.Prepend<                                    // Add the instance of the superclass at the top of the list
+            InstanceType<TraitExpression.Superclass<Exp>>
+        >,
+        ExtendFn,                                          // Reduce to a single object that extends all the objects in the list
+        SimplifyFn,                                        // Make readable for IDEs
+    ]>
 )
 
 export type TraitExpressionStaticMembers<Exp extends TraitExpression<any, any>> = (
-    Pipe<Traits, [
-        Tuples.Map<Trait.OwnClassFn>,  // Map all the traits to their implementation class
-        Tuples.Prepend<Superclass>,        // Add the superclass at the top of the list
-        Tuples.Map<StaticMembersFn>,       // Map all the classes to an object containing their static members
-        ExtendFn,                          // Reduce to a single object that extends all the objects in the list
-        SimplifyFn,                        // Make readable for IDEs
+    Pipe<TraitExpression.Traits<Exp>, [
+        Tuples.Map<Trait.OwnClassFn>,                     // Map all the traits to their class representation
+        Tuples.Prepend<TraitExpression.Superclass<Exp>>,  // Add the superclass at the top of the list
+        Tuples.Map<StaticMembersFn>,                      // Map all the classes to an object containing their static members
+        ExtendFn,                                         // Reduce to a single object that extends all the objects in the list
+        SimplifyFn,                                       // Make readable for IDEs
     ]>
 )