src/Trait.ts

@@ -39,61 +39,62 @@ export class Trait<
     ) {}
 }
 
-export type TraitOwnAbstract<T> = (
+export namespace Trait {
-    T extends Trait<any, infer Abstract, any>
+    export type OwnAbstract<T> = (
-        ? Abstract
+        T extends Trait<any, infer Abstract, any>
-        : never
+            ? Abstract
-)
+            : never
-export interface TraitOwnAbstractFn extends Fn {
+    )
-    return: TraitOwnAbstract<this["arg0"]>
+    export interface OwnAbstractFn extends Fn {
-}
+        return: Trait.OwnAbstract<this["arg0"]>
+    }
 
-export type TraitOwnImplClass<T> = (
+    export type OwnImplClass<T> = (
-    T extends Trait<any, any, infer ImplClass>
+        T extends Trait<any, any, infer ImplClass>
-        ? ImplClass
+            ? ImplClass
-        : never
+            : never
-)
+    )
-export interface TraitOwnImplClassFn extends Fn {
+    export interface OwnImplClassFn extends Fn {
-    return: TraitOwnImplClass<this["arg0"]>
+        return: Trait.OwnImplClass<this["arg0"]>
-}
+    }
 
-export type TraitOwnImplInstance<T> = (
+    export type OwnImplInstance<T> = (
-    T extends Trait<any, any, infer ImplClass>
+        T extends Trait<any, any, infer ImplClass>
-        ? InstanceType<ImplClass>
+            ? InstanceType<ImplClass>
-        : never
+            : never
-)
+    )
-export interface TraitOwnImplInstanceFn extends Fn {
+    export interface OwnImplInstanceFn extends Fn {
-    return: TraitOwnImplInstance<this["arg0"]>
+        return: Trait.OwnImplInstance<this["arg0"]>
-}
+    }
 
-export type TraitOwnClass<T> = (
+    export type OwnClass<T> = (
-    T extends Trait<any, infer Abstract, infer ImplClass>
+        T extends Trait<any, infer Abstract, infer ImplClass>
-        ? AddAbstractToImplClass<ImplClass, Abstract>
+            ? AddAbstractToImplClass<ImplClass, Abstract>
-        : never
+            : never
-)
+    )
-export interface TraitOwnClassFn extends Fn {
+    export interface OwnClassFn extends Fn {
-    return: TraitOwnClass<this["arg0"]>
+        return: Trait.OwnClass<this["arg0"]>
-}
+    }
 
-export type TraitOwnInstance<T> = (
+    export type OwnInstance<T> = (
-    T extends Trait<any, infer Abstract, infer ImplClass>
+        T extends Trait<any, infer Abstract, infer ImplClass>
-        ? InstanceType<
+            ? InstanceType<
-            AddAbstractToImplClass<ImplClass, Abstract>
+                AddAbstractToImplClass<ImplClass, Abstract>
-        >
+            >
-        : never
+            : never
-)
+    )
-export interface TraitOwnInstanceFn extends Fn {
+    export interface OwnInstanceFn extends Fn {
-    return: TraitOwnInstance<this["arg0"]>
+        return: Trait.OwnInstance<this["arg0"]>
-}
+    }
 
-
+    export type Supertraits<T> = (
-export type TraitSupertraits<T> = (
+        T extends Trait<infer Super, any, any>
-    T extends Trait<infer Super, any, any>
+            ? TraitExpressionAllTraits<Super>
-        ? TraitExpressionAllTraits<Super>
+            : never
-        : never
+    )
-)
+    export interface SupertraitsFn extends Fn {
-export interface TraitSupertraitsFn extends Fn {
+        return: Trait.Supertraits<this["arg0"]>
-    return: TraitSupertraits<this["arg0"]>
+    }
 }
 
 

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, emptyTraitExpression } from "."
+import { Trait, TraitExpression, emptyTraitExpression } from "."
 import { ExtendableFn, StaticMembersFn } from "./util"
 
 
@@ -87,7 +87,7 @@ type AbstractMembersExtendable<
 > = (
     Call<ExtendableFn, [
         InstanceType<Super>,
-        ...Call<Tuples.Map<TraitOwnAbstractFn>, Traits>,
+        ...Call<Tuples.Map<Trait.OwnAbstractFn>, Traits>,
     ]>
 )
 
@@ -97,7 +97,7 @@ type ImplInstanceExtendable<
 > = (
     Call<ExtendableFn, [
         InstanceType<Super>,
-        ...Call<Tuples.Map<TraitOwnImplInstanceFn>, Traits>,
+        ...Call<Tuples.Map<Trait.OwnImplInstanceFn>, Traits>,
     ]>
 )
 
@@ -107,7 +107,7 @@ type ImplStaticMembersExtendable<
 > = (
     Pipe<[
         Super,
-        ...Call<Tuples.Map<TraitOwnImplClassFn>, Traits>,
+        ...Call<Tuples.Map<Trait.OwnImplClassFn>, Traits>,
     ], [
         Tuples.Map<StaticMembersFn>,
         ExtendableFn,

src/tests.ts

@@ -1,4 +1,4 @@
-import { Implements, abstract, expression, trait } from "."
+import { Implements, Trait, abstract, expression, trait } from "."
 
 
 const PrintsHelloOnNew = trait(