Static abstract

src/Trait.ts

@@ -11,41 +11,50 @@ export type TraitApplierSuperTag = "@thilawyn/traitify-ts/TraitApplierSuper"
 export type AddAbstractToImplClass<
     ImplClass      extends Class<{}, []>,
     Abstract       extends {},
+    StaticAbstract extends {},
 > = (
     Class<
         Abstract & InstanceType<ImplClass>,
         ConstructorParameters<ImplClass>
     > &
+    StaticAbstract &
     StaticMembers<ImplClass>
 )
 
 export type RemoveAbstractFromImplClass<
     ImplClassWithAbstract extends Class<Abstract, []> & { _tag: TraitApplierSuperTag },
     Abstract              extends {},
+    StaticAbstract        extends {},
 > = (
     Class<
         Omit<InstanceType<ImplClassWithAbstract>, keyof Abstract>,
         ConstructorParameters<ImplClassWithAbstract>
     > &
-    Omit<StaticMembers<ImplClassWithAbstract>, "_tag">
+    Omit<StaticMembers<ImplClassWithAbstract>, keyof StaticAbstract | "_tag">
 )
 
 
 export class Trait<
-    Supertraits extends TraitExpression<typeof TraitExpression.NullSuperclass, Trait<any, any, any>[], Trait<any, any, any>[]>,
+    Supertraits    extends TraitExpression<
+        typeof TraitExpression.NullSuperclass,
+        Trait<any, any, any, any>[],
+        Trait<any, any, any, any>[]
+    >,
     Abstract       extends {},
+    StaticAbstract extends {},
     ImplClass      extends Class<{}, []>,
 > {
     constructor(
         readonly supertraits:     Supertraits,
         readonly abstract:        Abstract,
+        readonly staticAbstract:  StaticAbstract,
         readonly apply:           (Super: AbstractClass<{}>) => ImplClass,
     ) {}
 }
 
 export namespace Trait {
     export type OwnSupertraits<T> = (
-        T extends Trait<infer Supertraits, any, any>
+        T extends Trait<infer Supertraits, any, any, any>
             ? Supertraits
             : never
     )
@@ -54,7 +63,7 @@ export namespace Trait {
     }
 
     export type OwnAbstract<T> = (
-        T extends Trait<any, infer Abstract, any>
+        T extends Trait<any, infer Abstract, any, any>
             ? Abstract
             : never
     )
@@ -62,8 +71,17 @@ export namespace Trait {
         return: Trait.OwnAbstract<this["arg0"]>
     }
 
+    export type OwnStaticAbstract<T> = (
+        T extends Trait<any, any, infer StaticAbstract, any>
+            ? StaticAbstract
+            : never
+    )
+    export interface OwnStaticAbstractFn extends Fn {
+        return: Trait.OwnAbstract<this["arg0"]>
+    }
+
     export type OwnImplClass<T> = (
-        T extends Trait<any, any, infer ImplClass>
+        T extends Trait<any, any, any, infer ImplClass>
             ? ImplClass
             : never
     )
@@ -72,38 +90,28 @@ export namespace Trait {
     }
 
     export type OwnImplInstance<T> = (
-        T extends Trait<any, any, infer ImplClass>
+        InstanceType<Trait.OwnImplClass<T>>
-            ? InstanceType<ImplClass>
-            : never
     )
     export interface OwnImplInstanceFn extends Fn {
         return: Trait.OwnImplInstance<this["arg0"]>
     }
 
     export type OwnClass<T> = (
-        T extends Trait<any, infer Abstract, infer ImplClass>
+        AddAbstractToImplClass<Trait.OwnImplClass<T>, Trait.OwnAbstract<T>, Trait.OwnStaticAbstract<T>>
-            ? AddAbstractToImplClass<ImplClass, Abstract>
-            : never
     )
     export interface OwnClassFn extends Fn {
         return: Trait.OwnClass<this["arg0"]>
     }
 
     export type OwnInstance<T> = (
-        T extends Trait<any, infer Abstract, infer ImplClass>
+        InstanceType<Trait.OwnClass<T>>
-            ? InstanceType<
-                AddAbstractToImplClass<ImplClass, Abstract>
-            >
-            : never
     )
     export interface OwnInstanceFn extends Fn {
         return: Trait.OwnInstance<this["arg0"]>
     }
 
     export type Supertraits<T> = (
-        T extends Trait<infer Supertraits, any, any>
+        TraitExpression.AllTraits<Trait.OwnSupertraits<T>>
-            ? TraitExpression.AllTraits<Supertraits>
-            : never
     )
     export interface SupertraitsFn extends Fn {
         return: Trait.Supertraits<this["arg0"]>
@@ -144,14 +152,17 @@ export namespace Trait {
 
 export function trait<
     Abstract              extends {},
+    StaticAbstract        extends {},
     ImplClassWithAbstract extends Class<Abstract, []> & { _tag: TraitApplierSuperTag },
 >(
     abstract:        Opaque<Abstract, AbstractTag>,
+    staticAbstract:  Opaque<StaticAbstract, AbstractTag>,
     apply:           (Super: AbstractClass<Abstract> & { _tag: TraitApplierSuperTag }) => ImplClassWithAbstract,
 ) {
     return new Trait(
         emptyTraitExpression,
         abstract       as Abstract,
-        apply    as any as (Super: AbstractClass<{}>) => RemoveAbstractFromImplClass<ImplClassWithAbstract, Abstract>,
+        staticAbstract as StaticAbstract,
+        apply          as any as (Super: AbstractClass<{}>) => RemoveAbstractFromImplClass<ImplClassWithAbstract, Abstract, StaticAbstract>,
     )
 }

src/TraitExpression.ts

@@ -14,8 +14,8 @@ import { ExtendFn, SimplifyFn, StaticMembersFn } from "./util"
 
 export class TraitExpression<
     Superclass      extends AbstractClass<{}>,
-    const OwnTraits extends Trait<any, any, any>[],
+    const OwnTraits extends Trait<any, any, any, any>[],
-    const AllTraits extends Trait<any, any, any>[],
+    const AllTraits extends Trait<any, any, any, any>[],
 > {
     constructor(
         readonly superclass:  Superclass,
@@ -52,17 +52,20 @@ export class TraitExpression<
     subtrait<
         This                          extends TraitExpression<typeof TraitExpression.NullSuperclass, any, any>,
         SubtraitAbstract              extends Implements<This>,
+        SubtraitStaticAbstract        extends StaticImplements<This>,
         SubtraitImplClassWithAbstract extends Class<SubtraitAbstract, []> & { _tag: TraitApplierSuperTag },
     >(
         this:            This,
         abstract:        (expression: This) => Opaque<SubtraitAbstract, AbstractTag>,
+        staticAbstract:  (expression: This) => Opaque<SubtraitStaticAbstract, AbstractTag>,
         apply:           (Super: AbstractClass<SubtraitAbstract> & { _tag: TraitApplierSuperTag }) => SubtraitImplClassWithAbstract,
     ) {
         return new Trait(
             this,
             // {} as RemoveSupertraitsAbstractFromAbstract<SubtraitAbstract, Implements<typeof this>>,
             {}    as SubtraitAbstract,  // TODO: find a way to cleanly substract Implements<typeof this> from this.
-            apply as any as (Super: AbstractClass<{}>) => RemoveAbstractFromImplClass<SubtraitImplClassWithAbstract, SubtraitAbstract>,
+            {}    as SubtraitStaticAbstract,
+            apply as any as (Super: AbstractClass<{}>) => RemoveAbstractFromImplClass<SubtraitImplClassWithAbstract, SubtraitAbstract, SubtraitStaticAbstract>,
         )
     }
 }
@@ -111,3 +114,12 @@ export type Implements<Exp extends TraitExpression<any, any, any>> = (
         SimplifyFn,
     ]>
 )
+
+export type StaticImplements<Exp extends TraitExpression<any, any, any>> = (
+    Pipe<Exp, [
+        TraitExpression.AllTraitsFn,
+        Tuples.Map<Trait.OwnStaticAbstractFn>,
+        ExtendFn,
+        SimplifyFn,
+    ]>
+)

src/TraitExpressionBuilder.ts

@@ -5,7 +5,7 @@ import { TraitExpression, emptyTraitExpression } from "./TraitExpression"
 import { ExtendableFn, StaticMembersFn } from "./util"
 
 
-type SpreadSupertraits<Traits extends Trait<any, any, any>[]> = (
+type SpreadSupertraits<Traits extends Trait<any, any, any, any>[]> = (
     Call<
         Tuples.FlatMap<PrependTraitSupertraitsFn>,
         Traits
@@ -18,7 +18,7 @@ interface PrependTraitSupertraitsFn extends Fn {
 
 type AbstractMembersExtendable<
     Superclass extends AbstractClass<{}>,
-    Traits     extends Trait<any, any, any>[],
+    Traits     extends Trait<any, any, any, any>[],
 > = (
     Pipe<Traits, [
         Tuples.Map<Trait.OwnAbstractFn>,
@@ -28,7 +28,7 @@ type AbstractMembersExtendable<
 
 type ImplInstanceExtendable<
     Superclass extends AbstractClass<{}>,
-    Traits     extends Trait<any, any, any>[],
+    Traits     extends Trait<any, any, any, any>[],
 > = (
     Pipe<Traits, [
         Tuples.Map<Trait.OwnImplInstanceFn>,
@@ -38,7 +38,7 @@ type ImplInstanceExtendable<
 
 type ImplStaticMembersExtendable<
     Superclass extends AbstractClass<{}>,
-    Traits     extends Trait<any, any, any>[],
+    Traits     extends Trait<any, any, any, any>[],
 > = (
     Pipe<Traits, [
         Tuples.Map<Trait.OwnImplClassFn>,
@@ -50,8 +50,8 @@ type ImplStaticMembersExtendable<
 
 type BuildTraitExpression<
     Superclass extends AbstractClass<{}>,
-    OwnTraits  extends Trait<any, any, any>[],
+    OwnTraits  extends Trait<any, any, any, any>[],
-    AllTraits  extends Trait<any, any, any>[],
+    AllTraits  extends Trait<any, any, any, any>[],
 > = (
     AbstractMembersExtendable<Superclass, AllTraits> extends false
         ? "Type conflict between the traits abstract members and/or the superclass instance."
@@ -65,8 +65,8 @@ type BuildTraitExpression<
 
 class TraitExpressionBuilder<
     Superclass      extends AbstractClass<{}>,
-    const OwnTraits extends Trait<any, any, any>[],
+    const OwnTraits extends Trait<any, any, any, any>[],
-    const AllTraits extends Trait<any, any, any>[],
+    const AllTraits extends Trait<any, any, any, any>[],
 > {
     constructor(private expression: TraitExpression<Superclass, OwnTraits, AllTraits>) {}
 
@@ -85,7 +85,7 @@ class TraitExpressionBuilder<
     }
 
     expresses<
-        const Traits extends Trait<any, any, any>[]
+        const Traits extends Trait<any, any, any, any>[]
     >(
         ...traits: Traits
     ): TraitExpressionBuilder<
@@ -104,7 +104,8 @@ class TraitExpressionBuilder<
 
     private spreadSupertraits<
         const Traits extends Trait<
-            TraitExpression<any, any, Trait<any, any, any>[]>,
+            TraitExpression<any, any, Trait<any, any, any, any>[]>,
+            any,
             any,
             any
         >[]

src/tests.ts

@@ -1,10 +1,11 @@
 import { Trait, trait } from "./Trait"
-import { Implements } from "./TraitExpression"
+import { Implements, StaticImplements } from "./TraitExpression"
 import { expression } from "./TraitExpressionBuilder"
 import { abstract } from "./abstract"
 
 
 const PrintsHelloOnNew = trait(
+    abstract(),
     abstract(),
     Super => class PrintsHelloOnNew extends Super {
         static readonly isPrintsHelloOnNew = true
@@ -19,6 +20,7 @@ type PrintsHelloOnNewClass = Trait.Class<typeof PrintsHelloOnNew>
 
 const Identifiable = <ID>() => trait(
     abstract<{ readonly id: ID }>(),
+    abstract(),
     Super => class Identifiable extends Super {
         equals(el: Identifiable) {
             return this.id === el.id
@@ -35,6 +37,7 @@ const StatefulSubscription = trait(
             { _tag: "expired", expiredSince: Date }
         )
     }>(),
+    abstract(),
 
     Super => class StatefulSubscription extends Super {},
 )
@@ -53,6 +56,8 @@ const ActiveStatefulSubscription = expression
             return abstract<IActiveStatefulSubscription>()
         },
 
+        exp => abstract<StaticImplements<typeof exp>>(),
+
         Super => class ActiveStatefulSubscription extends Super {},
     )
 
@@ -86,7 +91,9 @@ class User extends exp.extends implements Implements<typeof exp> {
 console.log(new User())
 
 
-declare function StaticImplements(target: { issou: string }, context: any): typeof target
+declare function StaticImplements(target: { issou: string }, context: any): void
 
 @StaticImplements
-class Gneugneu {}
+class Gneugneu {
+    // static issou: string = "juif"
+}