Refactoring

src/expresses.ts

@@ -13,8 +13,8 @@ class TraitExpression<
         readonly traits:      Traits,
     ) {}
 
-    then<V>(fn: (e: this) => V): V {
-        return fn(this)
+    get implements() {
+        return {}
     }
 
     extends(): (
@@ -57,6 +57,44 @@ export type Implements<Exp extends TraitExpression<any, any>> = (
 )
 
 
+class TraitExpressionBuilder<
+    Super  extends AbstractClass<any>,
+    Traits extends readonly Trait<any, any>[],
+> {
+    constructor(public expression: TraitExpression<Super, Traits>) {}
+
+    extends<
+        NewSuper extends AbstractClass<any>
+    >(superclass: NewSuper) {
+        return new TraitExpressionBuilder(
+            new TraitExpression(
+                superclass,
+                this.expression.traits,
+            )
+        )
+    }
+
+    expresses<
+        AppendTraits extends readonly Trait<any, any>[]
+    >(...traits: AppendTraits) {
+        return new TraitExpressionBuilder(
+            new TraitExpression(
+                this.expression.superclass,
+                [...this.expression.traits, ...traits] as const,
+            )
+        )
+    }
+
+    get() {
+        return this.expression as GetTraitExpression<Super, Traits>
+    }
+
+    then<V>(fn: (expression: typeof this.expression) => V): V {
+        return fn(this.expression)
+    }
+}
+
+
 type AbstractMembersExtendable<
     Super  extends AbstractClass<any>,
     Traits extends readonly Trait<any, any>[],
@@ -90,8 +128,7 @@ type ImplStaticMembersExtendable<
     ]>
 )
 
-
-type ExtendsAndExpressesReturnType<
+type GetTraitExpression<
     Super  extends AbstractClass<any>,
     Traits extends readonly Trait<any, any>[],
 > = (
@@ -106,22 +143,9 @@ type ExtendsAndExpressesReturnType<
                     : TraitExpression<Super, Traits>
 )
 
-export function extendsAndExpresses<
-    Super  extends AbstractClass<any>,
-    Traits extends readonly Trait<any, any>[],
->(
-    superclass:  Super,
-    ...traits:   Traits
-): ExtendsAndExpressesReturnType<Super, Traits> {
-    return new TraitExpression(superclass, traits) as any
-}
 
 class DefaultSuperclass {}
 
-export function expresses<
-    Traits extends readonly Trait<any, any>[],
->(
-    ...traits: Traits
-): ExtendsAndExpressesReturnType<typeof DefaultSuperclass, Traits> {
-    return new TraitExpression(DefaultSuperclass, traits) as any
-}
+export const expression = new TraitExpressionBuilder(
+    new TraitExpression(DefaultSuperclass, [] as const)
+)

src/tests.ts

@@ -1,4 +1,4 @@
-import { Implements, TraitAbstractMembers, extendsAndExpresses, trait } from "."
+import { Implements, TraitAbstractMembers, expression, trait } from "."
 
 
 const PrintsHelloOnNew = trait()(Super =>
@@ -44,21 +44,25 @@ const ActiveStatefulSubscription = trait<ActiveStatefulSubscriptionAbstractMembe
 
 class TestSuperclass {
     // id: number = 69
-    static test = 69
+    // static test = 69
 }
 
 
-const User = extendsAndExpresses(
-    TestSuperclass,
-    PrintsHelloOnNew,
-    Identifiable<bigint>(),
-    // Identifiable<number>()
-).then(e =>
-    class User
-    extends e.extends()
-    implements Implements<typeof e> {
-        id: bigint = -1n
-    }
-)
+const builder = expression
+    .extends(TestSuperclass)
+    .expresses(
+        // PrintsHelloOnNew,
+        Identifiable<bigint>(),
+        // Identifiable<number>(),
+    )
+
+type Impl = Implements<typeof builder.expression>
+
+
+const exp = builder.get()
+
+class User extends exp.extends() implements (typeof exp.implements) {
+    // id: bigint = -1n
+}
 
 console.log(new User())