TraitExpressionBuilder work

2024-02-04 04:26:20 +01:00
parent 2d32e4807d
commit bb5e85573c
4 changed files with 149 additions and 98 deletions
--- a/src/TraitExpressionBuilder.ts
+++ b/src/TraitExpressionBuilder.ts
@@ -0,0 +1,134 @@
+import { Call, Fn, Pipe, Tuples } from "hotscript"
+import { AbstractClass } from "type-fest"
+import { Trait, TraitExpression, TraitOwnAbstractFn, TraitOwnImplClassFn, TraitOwnImplInstanceFn, TraitSupertraitsFn, emptyTraitExpression } from "."
+import { ExtendableFn, StaticMembersFn } from "./util"
+
+
+class TraitExpressionBuilder<
+    Super     extends AbstractClass<{}>,
+    OwnTraits extends Trait<any, any, any>[],
+    AllTraits extends Trait<any, any, any>[],
+> {
+    constructor(public expression: TraitExpression<Super, OwnTraits, AllTraits>) {}
+
+    extends<
+        NewSuper extends AbstractClass<any>
+    >(superclass: NewSuper) {
+        return new TraitExpressionBuilder(
+            new TraitExpression(
+                superclass,
+                this.expression.ownTraits,
+                this.expression.allTraits,
+            )
+        )
+    }
+
+    expresses<
+        Traits extends Trait<any, any, any>[]
+    >(
+        ...traits: Traits
+    ) {
+        return new TraitExpressionBuilder(
+            new TraitExpression(
+                this.expression.superclass,
+                [...this.expression.ownTraits, ...traits] as const,
+                [
+                    ...this.expression.allTraits,
+                    ...this.spreadSupertraits(traits) as SpreadTraitsHierarchy<Traits>,
+                ] as const,
+            )
+        )
+    }
+
+    private spreadSupertraits<
+        Traits extends Trait<
+            TraitExpression<any, any, Trait<any, any, any>[]>,
+            any,
+            any
+        >[]
+    >(
+        traits: Traits
+    ) {
+        return traits.flatMap(trait => [
+            ...trait.superExpression.allTraits,
+            trait,
+        ])
+    }
+
+    get() {
+        return this.expression as GetTraitExpression<Super, OwnTraits, AllTraits>
+    }
+
+    then<V>(fn: (expression: ReturnType<typeof this.get>) => V): V {
+        return fn(this.get())
+    }
+}
+
+
+type SpreadTraitsHierarchy<Traits extends Trait<any, any, any>[]> = (
+    Call<
+        Tuples.FlatMap<PrependTraitSupertraitsFn>,
+        Traits
+    >
+)
+interface PrependTraitSupertraitsFn extends Fn {
+    return: this["arg0"] extends Trait<any, any, any>
+        ? [
+            ...Call<TraitSupertraitsFn, this["arg0"]>,
+            this["arg0"],
+        ]
+        : never
+}
+
+
+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<{}>,
+    OwnTraits extends Trait<any, any, any>[],
+    AllTraits extends Trait<any, any, any>[],
+> = (
+    Call<Tuples.IsEmpty, OwnTraits> extends true
+        ? "Cannot express an empty list of traits."
+        : AbstractMembersExtendable<Super, OwnTraits> extends false
+            ? "Type conflict between the traits abstract members and/or the superclass instance."
+            : ImplInstanceExtendable<Super, OwnTraits> extends false
+                ? "Type conflict between the traits implementation instances and/or the superclass instance."
+                : ImplStaticMembersExtendable<Super, OwnTraits> extends false
+                    ? "Type conflict between the traits implementation static members and/or the superclass static members."
+                    : TraitExpression<Super, OwnTraits, AllTraits>
+)
+
+
+export const expression = new TraitExpressionBuilder(emptyTraitExpression)