TraitExpressionBuilder work

src/TraitExpression.ts

@@ -7,19 +7,21 @@ import { ExtendFn, ExtendableFn, SimplifyFn, StaticMembersFn } from "./util"
 export class TraitExpressionNullSuperclass {}
 
 export class TraitExpression<
-    Super  extends AbstractClass<{}>,
-    Traits extends Trait<any, any, any>[],
+    Super     extends AbstractClass<{}>,
+    OwnTraits extends Trait<any, any, any>[],
+    AllTraits extends Trait<any, any, any>[],
 > {
     constructor(
         readonly superclass:  Super,
-        readonly traits:      Traits,
+        readonly ownTraits:   OwnTraits,
+        readonly allTraits:   AllTraits,
     ) {}
 
     get extends(): (
         AbstractClass<
             Pipe<[
                 InstanceType<Super>,
-                ...Call<Tuples.Map<TraitOwnImplInstanceFn>, Traits>,
+                ...Call<Tuples.Map<TraitOwnImplInstanceFn>, OwnTraits>,
             ], [
                 ExtendFn,
                 SimplifyFn,
@@ -30,14 +32,14 @@ export class TraitExpression<
 
         Pipe<[
             Super,
-            ...Call<Tuples.Map<TraitOwnImplClassFn>, Traits>,
+            ...Call<Tuples.Map<TraitOwnImplClassFn>, OwnTraits>,
         ], [
             Tuples.Map<StaticMembersFn>,
             ExtendFn,
             SimplifyFn,
         ]>
     ) {
-        return this.traits.reduce(
+        return this.ownTraits.reduce(
             (previous, trait) => trait.apply(previous),
             this.superclass as Opaque<Super, TraitApplierSuperTag>,
         ) as any
@@ -60,7 +62,11 @@ export class TraitExpression<
     }
 }
 
-export const emptyTraitExpression = new TraitExpression(TraitExpressionNullSuperclass, [] as const)
+export const emptyTraitExpression = new TraitExpression(
+    TraitExpressionNullSuperclass,
+    [] as const,
+    [] as const,
+)
 
 interface PrependTraitSupertraitsFn extends Fn {
     return: this["arg0"] extends Trait<any, any, any>
@@ -95,93 +101,3 @@ export type Implements<Exp extends TraitExpression<any, any>> = (
         ]>
         : never
 )
-
-
-class TraitExpressionBuilder<
-    Super  extends AbstractClass<{}>,
-    Traits extends Trait<any, 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 Trait<any, 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: ReturnType<typeof this.get>) => V): V {
-        return fn(this.get())
-    }
-}
-
-
-type AbstractMembersExtendable<
-    Super  extends AbstractClass<{}>,
-    Traits extends Trait<any, any, any>[],
-> = (
-    Call<ExtendableFn, [
-        InstanceType<Super>,
-        ...Call<Tuples.Map<TraitOwnAbstractFn>, Traits>,
-    ]>
-)
-
-type ImplInstanceExtendable<
-    Super  extends AbstractClass<{}>,
-    Traits extends Trait<any, any, any>[],
-> = (
-    Call<ExtendableFn, [
-        InstanceType<Super>,
-        ...Call<Tuples.Map<TraitOwnImplInstanceFn>, Traits>,
-    ]>
-)
-
-type ImplStaticMembersExtendable<
-    Super  extends AbstractClass<{}>,
-    Traits extends Trait<any, any, any>[],
-> = (
-    Pipe<[
-        Super,
-        ...Call<Tuples.Map<TraitOwnImplClassFn>, Traits>,
-    ], [
-        Tuples.Map<StaticMembersFn>,
-        ExtendableFn,
-    ]>
-)
-
-type GetTraitExpression<
-    Super  extends AbstractClass<{}>,
-    Traits extends Trait<any, any, any>[],
-> = (
-    Call<Tuples.IsEmpty, Traits> extends true
-        ? "Cannot express an empty list of traits."
-        : AbstractMembersExtendable<Super, Traits> extends false
-            ? "Type conflict between the traits abstract members and/or the superclass instance."
-            : ImplInstanceExtendable<Super, Traits> extends false
-                ? "Type conflict between the traits implementation instances and/or the superclass instance."
-                : ImplStaticMembersExtendable<Super, Traits> extends false
-                    ? "Type conflict between the traits implementation static members and/or the superclass static members."
-                    : TraitExpression<Super, Traits>
-)
-
-
-export const expression = new TraitExpressionBuilder(emptyTraitExpression)