Working TraitExpressionBuilder

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 { ExtendFn, ExtendableFn, SimplifyFn, StaticMembersFn } from "./util"
+import { AbstractTag, Trait, TraitApplierSuperTag, TraitOwnAbstractFn, TraitOwnImplClassFn, TraitOwnImplInstanceFn } from "."
+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<
-                ComposeLeft<[TraitExpressionAbstractFn, SimplifyFn]>,
-                typeof this
-            >
+            abstract: Pipe<typeof this, [
+
+            ]>
         ) => Opaque<SubtraitAbstract, AbstractTag>,
 
         // impl: ()
@@ -62,42 +61,47 @@ export class TraitExpression<
     }
 }
 
-export const emptyTraitExpression = new TraitExpression(
-    TraitExpressionNullSuperclass,
-    [] as const,
-    [] as const,
+export type TraitExpressionSuper<T> = (
+    T extends TraitExpression<infer Super, any, any>
+        ? Super
+        : never
 )
-
-interface PrependTraitSupertraitsFn extends Fn {
-    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 TraitExpressionSuperFn extends Fn {
+    return: TraitExpressionSuper<this["arg0"]>
 }
 
-export interface TraitExpressionAbstractFn extends Fn {
-    return: this["arg0"] extends TraitExpression<any, any>
-        ? Pipe<this["arg0"], [
-            TraitExpressionTraitsFn,
-            Tuples.Map<TraitOwnAbstractFn>,
-            ExtendFn,
-        ]>
+export type TraitExpressionOwnTraits<T> = (
+    T extends TraitExpression<any, infer OwnTraits, any>
+        ? OwnTraits
         : never
+)
+export interface TraitExpressionOwnTraitsFn extends Fn {
+    return: TraitExpressionOwnTraits<this["arg0"]>
 }
 
-export type Implements<Exp extends TraitExpression<any, any>> = (
-    Exp extends TraitExpression<any, infer Traits>
-        ? Pipe<Traits, [
+export type TraitExpressionAllTraits<T> = (
+    T extends TraitExpression<any, any, infer AllTraits>
+        ? 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,
+)