Trait refactoring

src/Trait.ts

@@ -1,7 +1,6 @@
-import { Fn } from "hotscript"
 import { AbstractClass, Class, Simplify } from "type-fest"
 import { TraitExpression } from "./TraitExpression"
-import { Extend, ExtendPlain, StaticMembers } from "./util"
+import { ExtendPlain, StaticMembers } from "./util"
 
 
 export class Trait<
@@ -22,90 +21,72 @@ export class Trait<
 }
 
 export namespace Trait {
-    export type OwnSuperExpression<T> = (
+    export type SuperExpression<T> = (
         T extends Trait<infer SuperExpression, any, any, any>
             ? SuperExpression
             : never
     )
-    export interface OwnSuperExpressionFn extends Fn {
-        return: Trait.OwnSuperExpression<this["arg0"]>
-    }
 
-    export type OwnAbstract<T> = (
+    export type Abstract<T> = (
         T extends Trait<any, infer Abstract, any, any>
             ? Abstract
             : never
     )
-    export interface OwnAbstractFn extends Fn {
-        return: Trait.OwnAbstract<this["arg0"]>
-    }
 
-    export type OwnStaticAbstract<T> = (
+    export type StaticAbstract<T> = (
         T extends Trait<any, any, infer StaticAbstract, any>
             ? StaticAbstract
             : never
     )
-    export interface OwnStaticAbstractFn extends Fn {
-        return: Trait.OwnStaticAbstract<this["arg0"]>
-    }
 
-    export type OwnImplClass<T> = (
+    export type ImplClass<T> = (
         T extends Trait<any, any, any, infer ImplClass>
             ? ImplClass
             : never
     )
-    export interface OwnImplClassFn extends Fn {
-        return: Trait.OwnImplClass<this["arg0"]>
-    }
 
-    export type OwnImplInstance<T> = (
+    export type ImplInstance<T> = (
-        InstanceType<Trait.OwnImplClass<T>>
+        InstanceType<Trait.ImplClass<T>>
     )
-    export interface OwnImplInstanceFn extends Fn {
-        return: Trait.OwnImplInstance<this["arg0"]>
-    }
 
-    export type OwnImplStaticMembers<T> = (
+    export type ImplStaticMembers<T> = (
-        StaticMembers<Trait.OwnImplClass<T>>
+        StaticMembers<Trait.ImplClass<T>>
     )
 
     export type Supertraits<T> = (
-        TraitExpression.Traits<Trait.OwnSuperExpression<T>>
+        TraitExpression.Traits<Trait.SuperExpression<T>>
     )
-    export interface SupertraitsFn extends Fn {
-        return: Trait.Supertraits<this["arg0"]>
-    }
 }
 
-export namespace Traits {
+export namespace TraitTuple {
     export type MapAbstract<T> = {
         [K in keyof T]: K extends keyof []
             ? T[K]
-            : Trait.OwnAbstract<T[K]>
+            : Trait.Abstract<T[K]>
     }
 
     export type MapStaticAbstract<T> = {
         [K in keyof T]: K extends keyof []
             ? T[K]
-            : Trait.OwnStaticAbstract<T[K]>
+            : Trait.StaticAbstract<T[K]>
     }
 
     export type MapImplClass<T> = {
         [K in keyof T]: K extends keyof []
             ? T[K]
-            : Trait.OwnImplClass<T[K]>
+            : Trait.ImplClass<T[K]>
     }
 
     export type MapImplInstance<T> = {
         [K in keyof T]: K extends keyof []
             ? T[K]
-            : Trait.OwnImplInstance<T[K]>
+            : Trait.ImplInstance<T[K]>
     }
 
     export type MapImplStaticMembers<T> = {
         [K in keyof T]: K extends keyof []
             ? T[K]
-            : Trait.OwnImplStaticMembers<T[K]>
+            : Trait.ImplStaticMembers<T[K]>
     }
 }
 
@@ -123,8 +104,8 @@ export type TraitConcreteClass<T extends Trait<any, any, any, any>> = (
 export type TraitInstance<T extends Trait<any, any, any, any>> = (
     Simplify<
         ExtendPlain<[
-            Trait.OwnAbstract<T>,
+            Trait.Abstract<T>,
-            Trait.OwnImplInstance<T>,
+            Trait.ImplInstance<T>,
         ]>
     >
 )
@@ -132,8 +113,8 @@ export type TraitInstance<T extends Trait<any, any, any, any>> = (
 export type TraitStaticMembers<T extends Trait<any, any, any, any>> = (
     Simplify<
         ExtendPlain<[
-            Trait.OwnStaticAbstract<T>,
+            Trait.StaticAbstract<T>,
-            StaticMembers<Trait.OwnImplClass<T>>,
+            Trait.ImplStaticMembers<T>,
         ]>
     >
 )

src/TraitExpression.ts

@@ -1,16 +1,16 @@
 import { AbstractClass, Class, Simplify } from "type-fest"
-import { Trait, TraitInstance, TraitStaticMembers, Traits } from "./Trait"
+import { Trait, TraitInstance, TraitStaticMembers, TraitTuple } from "./Trait"
 import { TraitBuilder } from "./TraitBuilder"
 import { ExtendPlain, StaticMembers } from "./util"
 
 
 export class TraitExpression<
     Superclass   extends AbstractClass<object>,
-    const T    extends Trait<any, any, any, any>[],
+    const Traits extends Trait<any, any, any, any>[],
 > {
     constructor(
         readonly superclass:  Superclass,
-        readonly traits:      T,
+        readonly traits:      Traits,
     ) {}
 
     get extends(): (
@@ -18,7 +18,7 @@ export class TraitExpression<
             Simplify<
                 ExtendPlain<[
                     InstanceType<Superclass>,
-                    ...Traits.MapImplInstance<T>,
+                    ...TraitTuple.MapImplInstance<Traits>,
                 ]>
             >,
 
@@ -28,7 +28,7 @@ export class TraitExpression<
         Simplify<
             ExtendPlain<[
                 StaticMembers<Superclass>,
-                ...Traits.MapImplStaticMembers<T>,
+                ...TraitTuple.MapImplStaticMembers<Traits>,
             ]>
         >
     ) {
@@ -49,19 +49,19 @@ export class TraitExpression<
             This,
 
             Simplify<
-                ExtendPlain<Traits.MapAbstract<T>>
+                ExtendPlain<TraitTuple.MapAbstract<Traits>>
             >,
             Simplify<
-                ExtendPlain<Traits.MapStaticAbstract<T>>
+                ExtendPlain<TraitTuple.MapStaticAbstract<Traits>>
             >,
 
             AbstractClass<
                 Simplify<
-                    ExtendPlain<Traits.MapImplInstance<T>>
+                    ExtendPlain<TraitTuple.MapImplInstance<Traits>>
                 >
             > &
             Simplify<
-                ExtendPlain<Traits.MapImplStaticMembers<T>>
+                ExtendPlain<TraitTuple.MapImplStaticMembers<Traits>>
             >
         >(
             this,
@@ -97,7 +97,7 @@ export type Implements<
 > = (
     Simplify<
         ExtendPlain<
-            Traits.MapAbstract<
+            TraitTuple.MapAbstract<
                 TraitExpression.Traits<Exp>
             >
         >
@@ -109,7 +109,7 @@ export type ImplementsStatic<
 > = (
     Simplify<
         ExtendPlain<
-            Traits.MapStaticAbstract<
+            TraitTuple.MapStaticAbstract<
                 TraitExpression.Traits<Exp>
             >
         >