Working TraitExpressionBuilder

src/Trait.ts

@@ -1,6 +1,6 @@
-import { Call, Fn } from "hotscript"
+import { Fn } from "hotscript"
 import { AbstractClass, Class, Opaque } from "type-fest"
-import { AbstractTag, TraitExpression, TraitExpressionNullSuperclass, TraitExpressionTraitsFn, emptyTraitExpression } from "."
+import { AbstractTag, TraitExpression, TraitExpressionAllTraits, TraitExpressionNullSuperclass, emptyTraitExpression } from "."
 import { StaticMembers } from "./util"
 
 
@@ -33,7 +33,7 @@ export class Trait<
     ImplClass extends Class<{}, []>,
 > {
     constructor(
-        readonly superExpression:  Super,
+        readonly supertraits:  Super,
         readonly abstract:     Abstract,
         readonly apply:        (Super: AbstractClass<{}>) => ImplClass,
     ) {}
@@ -87,10 +87,13 @@ export interface TraitOwnInstanceFn extends Fn {
 }
 
 
-export interface TraitSupertraitsFn extends Fn {
+export type TraitSupertraits<T> = (
-    return: this["arg0"] extends Trait<infer Super, any, any>
+    T extends Trait<infer Super, any, any>
-        ? Call<TraitExpressionTraitsFn, Super>
+        ? TraitExpressionAllTraits<Super>
         : never
+)
+export interface TraitSupertraitsFn extends Fn {
+    return: TraitSupertraits<this["arg0"]>
 }
 
 

src/TraitExpression.ts

@@ -1,7 +1,7 @@
-import { Call, ComposeLeft, Fn, Pipe, Tuples } from "hotscript"
+import { Call, Fn, Pipe, Tuples } from "hotscript"
 import { AbstractClass, Class, Opaque } from "type-fest"
-import { AbstractTag, Trait, TraitApplierSuperTag, TraitOwnAbstractFn, TraitOwnImplClassFn, TraitOwnImplInstanceFn, TraitSupertraitsFn } from "."
+import { AbstractTag, Trait, TraitApplierSuperTag, TraitOwnAbstractFn, TraitOwnImplClassFn, TraitOwnImplInstanceFn } from "."
-import { ExtendFn, ExtendableFn, SimplifyFn, StaticMembersFn } from "./util"
+import { ExtendFn, SimplifyFn, StaticMembersFn } from "./util"
 
 
 export class TraitExpressionNullSuperclass {}
@@ -39,7 +39,7 @@ export class TraitExpression<
             SimplifyFn,
         ]>
     ) {
-        return this.ownTraits.reduce(
+        return this.allTraits.reduce(
             (previous, trait) => trait.apply(previous),
             this.superclass as Opaque<Super, TraitApplierSuperTag>,
         ) as any
@@ -50,10 +50,9 @@ export class TraitExpression<
         SubtraitImplWithAbstract extends Class<{}>,
     >(
         abstract: (
-            abstract: Call<
+            abstract: Pipe<typeof this, [
-                ComposeLeft<[TraitExpressionAbstractFn, SimplifyFn]>,
+
-                typeof this
+            ]>
-            >
         ) => Opaque<SubtraitAbstract, AbstractTag>,
 
         // impl: ()
@@ -62,42 +61,47 @@ export class TraitExpression<
     }
 }
 
-export const emptyTraitExpression = new TraitExpression(
+export type TraitExpressionSuper<T> = (
-    TraitExpressionNullSuperclass,
+    T extends TraitExpression<infer Super, any, any>
-    [] as const,
+        ? Super
-    [] as const,
+        : never
 )
-
+export interface TraitExpressionSuperFn extends Fn {
-interface PrependTraitSupertraitsFn extends Fn {
+    return: TraitExpressionSuper<this["arg0"]>
-    return: this["arg0"] extends Trait<any, any, any>
-        ? [
-            ...Call<TraitSupertraitsFn, this["arg0"]>,
-            this["arg0"],
-        ]
-        : never
-}
-export interface TraitExpressionTraitsFn extends Fn {
-    return: this["arg0"] extends TraitExpression<any, infer Traits>
-        ? Call<Tuples.FlatMap<PrependTraitSupertraitsFn>, Traits>
-        : never
 }
 
-export interface TraitExpressionAbstractFn extends Fn {
+export type TraitExpressionOwnTraits<T> = (
-    return: this["arg0"] extends TraitExpression<any, any>
+    T extends TraitExpression<any, infer OwnTraits, any>
-        ? Pipe<this["arg0"], [
+        ? OwnTraits
-            TraitExpressionTraitsFn,
-            Tuples.Map<TraitOwnAbstractFn>,
-            ExtendFn,
-        ]>
         : never
+)
+export interface TraitExpressionOwnTraitsFn extends Fn {
+    return: TraitExpressionOwnTraits<this["arg0"]>
 }
 
-export type Implements<Exp extends TraitExpression<any, any>> = (
+export type TraitExpressionAllTraits<T> = (
-    Exp extends TraitExpression<any, infer Traits>
+    T extends TraitExpression<any, any, infer AllTraits>
-        ? Pipe<Traits, [
+        ? AllTraits
+        : never
+)
+export interface TraitExpressionAllTraitsFn extends Fn {
+    return: TraitExpressionAllTraits<this["arg0"]>
+}
+
+
+export type Implements<Exp extends TraitExpression<any, any, any>> = (
+    Exp extends TraitExpression<any, infer AllTraits, any>
+        ? Pipe<AllTraits, [
             Tuples.Map<TraitOwnAbstractFn>,
             ExtendFn,
             SimplifyFn,
         ]>
         : never
 )
+
+
+export const emptyTraitExpression = new TraitExpression(
+    TraitExpressionNullSuperclass,
+    [] as const,
+    [] as const,
+)

src/TraitExpressionBuilder.ts

@@ -1,6 +1,6 @@
 import { Call, Fn, Pipe, Tuples } from "hotscript"
 import { AbstractClass } from "type-fest"
-import { Trait, TraitExpression, TraitOwnAbstractFn, TraitOwnImplClassFn, TraitOwnImplInstanceFn, TraitSupertraitsFn, emptyTraitExpression } from "."
+import { Trait, TraitExpression, TraitOwnAbstractFn, TraitOwnImplClassFn, TraitOwnImplInstanceFn, emptyTraitExpression } from "."
 import { ExtendableFn, StaticMembersFn } from "./util"
 
 
@@ -27,17 +27,18 @@ class TraitExpressionBuilder<
         Traits extends Trait<any, any, any>[]
     >(
         ...traits: Traits
-    ) {
+    ): TraitExpressionBuilder<
+        Super,
+        [...OwnTraits, ...Traits],
+        [...AllTraits, SpreadSupertraits<Traits>]
+    > {
         return new TraitExpressionBuilder(
             new TraitExpression(
                 this.expression.superclass,
                 [...this.expression.ownTraits, ...traits] as const,
-                [
+                [...this.expression.allTraits, ...this.spreadSupertraits(traits)] as const,
-                    ...this.expression.allTraits,
-                    ...this.spreadSupertraits(traits) as SpreadTraitsHierarchy<Traits>,
-                ] as const,
-            )
             )
+        ) as any
     }
 
     private spreadSupertraits<
@@ -50,9 +51,9 @@ class TraitExpressionBuilder<
         traits: Traits
     ) {
         return traits.flatMap(trait => [
-            ...trait.superExpression.allTraits,
+            ...trait.supertraits.allTraits,
             trait,
-        ])
+        ]) as SpreadSupertraits<Traits>
     }
 
     get() {
@@ -65,18 +66,17 @@ class TraitExpressionBuilder<
 }
 
 
-type SpreadTraitsHierarchy<Traits extends Trait<any, any, any>[]> = (
+type SpreadSupertraits<Traits extends Trait<any, any, any>[]> = (
     Call<
         Tuples.FlatMap<PrependTraitSupertraitsFn>,
         Traits
     >
 )
 interface PrependTraitSupertraitsFn extends Fn {
-    return: this["arg0"] extends Trait<any, any, any>
+    return: this["arg0"] extends Trait<infer Super, any, any>
-        ? [
+        ? Super extends TraitExpression<any, any, infer AllTraits>
-            ...Call<TraitSupertraitsFn, this["arg0"]>,
+            ? [...AllTraits, this["arg0"]]
-            this["arg0"],
+            : never
-        ]
         : never
 }
 

src/tests.ts

@@ -1,6 +1,4 @@
-import { Call, ComposeLeft } from "hotscript"
+import { Implements, abstract, expression, trait } from "."
-import { Implements, TraitExpressionAbstractFn, abstract, expression, trait } from "."
-import { SimplifyFn } from "./util"
 
 
 const PrintsHelloOnNew = trait(
@@ -60,10 +58,7 @@ const builder = expression
     )
 
 const exp = builder.get()
-type Abs = Call<ComposeLeft<[
+type Abs = Implements<typeof exp>
-    TraitExpressionAbstractFn,
-    SimplifyFn,
-]>, typeof exp>
 
 // exp.subtrait(
 //     s => {