Super -> Superclass

src/TraitExpression.ts

@@ -7,12 +7,12 @@ import { ExtendFn, SimplifyFn, StaticMembersFn } from "./util"
 export class TraitExpressionNullSuperclass {}
 
 export class TraitExpression<
-    Super     extends AbstractClass<{}>,
+    Superclass extends AbstractClass<{}>,
     OwnTraits  extends Trait<any, any, any>[],
     AllTraits  extends Trait<any, any, any>[],
 > {
     constructor(
-        readonly superclass:  Super,
+        readonly superclass:  Superclass,
         readonly ownTraits:   OwnTraits,
         readonly allTraits:   AllTraits,
     ) {}
@@ -20,18 +20,18 @@ export class TraitExpression<
     get extends(): (
         AbstractClass<
             Pipe<[
-                InstanceType<Super>,
+                InstanceType<Superclass>,
                 ...Call<Tuples.Map<Trait.OwnImplInstanceFn>, OwnTraits>,
             ], [
                 ExtendFn,
                 SimplifyFn,
             ]>,
 
-            ConstructorParameters<Super>
+            ConstructorParameters<Superclass>
         > &
 
         Pipe<[
-            Super,
+            Superclass,
             ...Call<Tuples.Map<Trait.OwnImplClassFn>, OwnTraits>,
         ], [
             Tuples.Map<StaticMembersFn>,
@@ -41,7 +41,7 @@ export class TraitExpression<
     ) {
         return this.allTraits.reduce(
             (previous, trait) => trait.apply(previous),
-            this.superclass as Opaque<Super, TraitApplierSuperTag>,
+            this.superclass as Opaque<Superclass, TraitApplierSuperTag>,
         ) as any
     }
 
@@ -62,13 +62,13 @@ export class TraitExpression<
 }
 
 export namespace TraitExpression {
-    export type Super<T> = (
+    export type Superclass<T> = (
-        T extends TraitExpression<infer Super, any, any>
+        T extends TraitExpression<infer Superclass, any, any>
-            ? Super
+            ? Superclass
             : never
     )
-    export interface SuperFn extends Fn {
+    export interface SuperclassFn extends Fn {
-        return: TraitExpression.Super<this["arg0"]>
+        return: TraitExpression.Superclass<this["arg0"]>
     }
 
     export type OwnTraits<T> = (

src/tests.ts

@@ -1,4 +1,4 @@
-import { Implements, Trait, abstract, expression, trait } from "."
+import { Implements, Trait, TraitExpression, abstract, expression, trait } from "."
 
 
 const PrintsHelloOnNew = trait(
@@ -57,6 +57,8 @@ const builder = expression
         StatefulSubscription,
     )
 
+type T = TraitExpression.OwnTraits<typeof builder.expression>
+
 const exp = builder.get()
 type Abs = Implements<typeof exp>