Moved Trait helper types to a namespace

package.json

@@ -28,6 +28,7 @@
     "clean:node": "rm -rf node_modules"
   },
   "dependencies": {
+    "hotscript": "^1.0.13",
     "type-fest": "^4.10.1"
   },
   "devDependencies": {

src/Trait.ts

@@ -0,0 +1,117 @@
+import { Fn } from "hotscript"
+import { AbstractClass, Class, Opaque } from "type-fest"
+import { AbstractTag, TraitExpression, TraitExpressionAllTraits, TraitExpressionNullSuperclass, emptyTraitExpression } from "."
+import { StaticMembers } from "./util"
+
+
+type AddAbstractToImplClass<
+    ImplClass extends Class<{}, []>,
+    Abstract  extends {},
+> = (
+    Class<
+        InstanceType<ImplClass> & Abstract,
+        ConstructorParameters<ImplClass>
+    > &
+    StaticMembers<ImplClass>
+)
+
+type RemoveAbstractFromImplClass<
+    ImplClassWithAbstract extends Class<Abstract, []>,
+    Abstract              extends {},
+> = (
+    Class<
+        Omit<InstanceType<ImplClassWithAbstract>, keyof Abstract>,
+        ConstructorParameters<ImplClassWithAbstract>
+    > &
+    StaticMembers<ImplClassWithAbstract>
+)
+
+
+export class Trait<
+    Super     extends TraitExpression<typeof TraitExpressionNullSuperclass, Trait<any, any, any>[], Trait<any, any, any>[]>,
+    Abstract  extends {},
+    ImplClass extends Class<{}, []>,
+> {
+    constructor(
+        readonly supertraits:  Super,
+        readonly abstract:     Abstract,
+        readonly apply:        (Super: AbstractClass<{}>) => ImplClass,
+    ) {}
+}
+
+export namespace Trait {
+    export type OwnAbstract<T> = (
+        T extends Trait<any, infer Abstract, any>
+            ? Abstract
+            : never
+    )
+    export interface OwnAbstractFn extends Fn {
+        return: Trait.OwnAbstract<this["arg0"]>
+    }
+
+    export type OwnImplClass<T> = (
+        T extends Trait<any, any, infer ImplClass>
+            ? ImplClass
+            : never
+    )
+    export interface OwnImplClassFn extends Fn {
+        return: Trait.OwnImplClass<this["arg0"]>
+    }
+
+    export type OwnImplInstance<T> = (
+        T extends Trait<any, any, infer ImplClass>
+            ? 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<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<
+                AddAbstractToImplClass<ImplClass, Abstract>
+            >
+            : never
+    )
+    export interface OwnInstanceFn extends Fn {
+        return: Trait.OwnInstance<this["arg0"]>
+    }
+
+    export type Supertraits<T> = (
+        T extends Trait<infer Super, any, any>
+            ? TraitExpressionAllTraits<Super>
+            : never
+    )
+    export interface SupertraitsFn extends Fn {
+        return: Trait.Supertraits<this["arg0"]>
+    }
+}
+
+
+export type TraitApplierSuperTag = "@thilawyn/traitify-ts/TraitApplierSuper"
+
+export function trait<
+    Abstract              extends {},
+    ImplClassWithAbstract extends Class<Abstract, []>,
+>(
+    abstract: Opaque<Abstract, AbstractTag>,
+    apply: (Super: Opaque<AbstractClass<Abstract>, TraitApplierSuperTag>) => (
+        Opaque<ImplClassWithAbstract, TraitApplierSuperTag>
+    ),
+) {
+    return new Trait(
+        emptyTraitExpression,
+        abstract as Abstract,
+        apply    as any as (Super: AbstractClass<{}>) => RemoveAbstractFromImplClass<ImplClassWithAbstract, Abstract>,
+    )
+}

src/TraitExpression.ts

@@ -0,0 +1,107 @@
+import { Call, Fn, Pipe, Tuples } from "hotscript"
+import { AbstractClass, Class, Opaque } from "type-fest"
+import { AbstractTag, Trait, TraitApplierSuperTag } from "."
+import { ExtendFn, SimplifyFn, StaticMembersFn } from "./util"
+
+
+export class TraitExpressionNullSuperclass {}
+
+export class TraitExpression<
+    Super     extends AbstractClass<{}>,
+    OwnTraits extends Trait<any, any, any>[],
+    AllTraits extends Trait<any, any, any>[],
+> {
+    constructor(
+        readonly superclass:  Super,
+        readonly ownTraits:   OwnTraits,
+        readonly allTraits:   AllTraits,
+    ) {}
+
+    get extends(): (
+        AbstractClass<
+            Pipe<[
+                InstanceType<Super>,
+                ...Call<Tuples.Map<Trait.OwnImplInstanceFn>, OwnTraits>,
+            ], [
+                ExtendFn,
+                SimplifyFn,
+            ]>,
+
+            ConstructorParameters<Super>
+        > &
+
+        Pipe<[
+            Super,
+            ...Call<Tuples.Map<Trait.OwnImplClassFn>, OwnTraits>,
+        ], [
+            Tuples.Map<StaticMembersFn>,
+            ExtendFn,
+            SimplifyFn,
+        ]>
+    ) {
+        return this.allTraits.reduce(
+            (previous, trait) => trait.apply(previous),
+            this.superclass as Opaque<Super, TraitApplierSuperTag>,
+        ) as any
+    }
+
+    subtrait<
+        SubtraitAbstract         extends {},
+        SubtraitImplWithAbstract extends Class<{}>,
+    >(
+        abstract: (
+            abstract: Pipe<typeof this, [
+
+            ]>
+        ) => Opaque<SubtraitAbstract, AbstractTag>,
+
+        // impl: ()
+    ) {
+
+    }
+}
+
+export type TraitExpressionSuper<T> = (
+    T extends TraitExpression<infer Super, any, any>
+        ? Super
+        : never
+)
+export interface TraitExpressionSuperFn extends Fn {
+    return: TraitExpressionSuper<this["arg0"]>
+}
+
+export type TraitExpressionOwnTraits<T> = (
+    T extends TraitExpression<any, infer OwnTraits, any>
+        ? OwnTraits
+        : never
+)
+export interface TraitExpressionOwnTraitsFn extends Fn {
+    return: TraitExpressionOwnTraits<this["arg0"]>
+}
+
+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<Trait.OwnAbstractFn>,
+            ExtendFn,
+            SimplifyFn,
+        ]>
+        : never
+)
+
+
+export const emptyTraitExpression = new TraitExpression(
+    TraitExpressionNullSuperclass,
+    [] as const,
+    [] as const,
+)

src/TraitExpressionBuilder.ts

@@ -0,0 +1,134 @@
+import { Call, Fn, Pipe, Tuples } from "hotscript"
+import { AbstractClass } from "type-fest"
+import { Trait, TraitExpression, emptyTraitExpression } from "."
+import { ExtendableFn, StaticMembersFn } from "./util"
+
+
+class TraitExpressionBuilder<
+    Super     extends AbstractClass<{}>,
+    OwnTraits extends Trait<any, any, any>[],
+    AllTraits extends Trait<any, any, any>[],
+> {
+    constructor(public expression: TraitExpression<Super, OwnTraits, AllTraits>) {}
+
+    extends<
+        NewSuper extends AbstractClass<any>
+    >(superclass: NewSuper) {
+        return new TraitExpressionBuilder(
+            new TraitExpression(
+                superclass,
+                this.expression.ownTraits,
+                this.expression.allTraits,
+            )
+        )
+    }
+
+    expresses<
+        Traits extends Trait<any, any, any>[]
+    >(
+        ...traits: Traits
+    ): TraitExpressionBuilder<
+        Super,
+        [...OwnTraits, ...Traits],
+        [...AllTraits, SpreadSupertraits<Traits>]
+    > {
+        return new TraitExpressionBuilder(
+            new TraitExpression(
+                this.expression.superclass,
+                [...this.expression.ownTraits, ...traits] as const,
+                [...this.expression.allTraits, ...this.spreadSupertraits(traits)] as const,
+            )
+        ) as any
+    }
+
+    private spreadSupertraits<
+        Traits extends Trait<
+            TraitExpression<any, any, Trait<any, any, any>[]>,
+            any,
+            any
+        >[]
+    >(
+        traits: Traits
+    ) {
+        return traits.flatMap(trait => [
+            ...trait.supertraits.allTraits,
+            trait,
+        ]) as SpreadSupertraits<Traits>
+    }
+
+    get() {
+        return this.expression as GetTraitExpression<Super, OwnTraits, AllTraits>
+    }
+
+    then<V>(fn: (expression: ReturnType<typeof this.get>) => V): V {
+        return fn(this.get())
+    }
+}
+
+
+type SpreadSupertraits<Traits extends Trait<any, any, any>[]> = (
+    Call<
+        Tuples.FlatMap<PrependTraitSupertraitsFn>,
+        Traits
+    >
+)
+interface PrependTraitSupertraitsFn extends Fn {
+    return: this["arg0"] extends Trait<infer Super, any, any>
+        ? Super extends TraitExpression<any, any, infer AllTraits>
+            ? [...AllTraits, this["arg0"]]
+            : never
+        : never
+}
+
+
+type AbstractMembersExtendable<
+    Super  extends AbstractClass<{}>,
+    Traits extends Trait<any, any, any>[],
+> = (
+    Call<ExtendableFn, [
+        InstanceType<Super>,
+        ...Call<Tuples.Map<Trait.OwnAbstractFn>, Traits>,
+    ]>
+)
+
+type ImplInstanceExtendable<
+    Super  extends AbstractClass<{}>,
+    Traits extends Trait<any, any, any>[],
+> = (
+    Call<ExtendableFn, [
+        InstanceType<Super>,
+        ...Call<Tuples.Map<Trait.OwnImplInstanceFn>, Traits>,
+    ]>
+)
+
+type ImplStaticMembersExtendable<
+    Super  extends AbstractClass<{}>,
+    Traits extends Trait<any, any, any>[],
+> = (
+    Pipe<[
+        Super,
+        ...Call<Tuples.Map<Trait.OwnImplClassFn>, Traits>,
+    ], [
+        Tuples.Map<StaticMembersFn>,
+        ExtendableFn,
+    ]>
+)
+
+type GetTraitExpression<
+    Super     extends AbstractClass<{}>,
+    OwnTraits extends Trait<any, any, any>[],
+    AllTraits extends Trait<any, any, any>[],
+> = (
+    Call<Tuples.IsEmpty, OwnTraits> extends true
+        ? "Cannot express an empty list of traits."
+        : AbstractMembersExtendable<Super, OwnTraits> extends false
+            ? "Type conflict between the traits abstract members and/or the superclass instance."
+            : ImplInstanceExtendable<Super, OwnTraits> extends false
+                ? "Type conflict between the traits implementation instances and/or the superclass instance."
+                : ImplStaticMembersExtendable<Super, OwnTraits> extends false
+                    ? "Type conflict between the traits implementation static members and/or the superclass static members."
+                    : TraitExpression<Super, OwnTraits, AllTraits>
+)
+
+
+export const expression = new TraitExpressionBuilder(emptyTraitExpression)

src/abstract.ts

@@ -0,0 +1,10 @@
+import { Opaque } from "type-fest"
+
+
+export type AbstractTag = "@thilawyn/traitify-ts/Abstract"
+
+export function abstract<
+    Abstract extends {} = {}
+>() {
+    return {} as Opaque<Abstract, AbstractTag>
+}

src/expresses.ts

@@ -1,84 +0,0 @@
-import { AbstractClass, Opaque } from "type-fest"
-import { Trait, TraitApplierSuperTag } from "."
-import { ClassesInstances, ClassesStaticMembers, MergeInheritanceTree, MergeInheritanceTreeWithoutOverriding, StaticMembers, TraitsClasses } from "./util"
-
-
-/**
- * Extends a class with the given traits and expresses their combined functionality.
- * @template C - The abstract class type.
- * @template Traits - An array of traits.
- * @param extend - The class to extend.
- * @param traits - An array of traits to apply.
- * @returns A new class type expressing the combined functionality of the base class and traits.
- * @example
- * Extends a superclass and applies traits:
- * ```ts
- * class User extends extendsAndExpresses(Entity,
- *     Identifiable<bigint>(),
- *     Permissible,
- * ) {
- *     readonly id: bigint
- *
- *     constructor(id: bigint) {
- *         super()
- *         this.id = id
- *     }
- * }
- * ```
- */
-export function extendsAndExpresses<
-    C      extends AbstractClass<any>,
-    Traits extends readonly Trait<any>[],
->(
-    extend: C,
-    ...traits: Traits
-) {
-    return traits.reduce(
-        (previous, trait) => trait(previous),
-        extend as Opaque<C, TraitApplierSuperTag>,
-    ) as unknown as (
-        AbstractClass<
-            MergeInheritanceTreeWithoutOverriding<[
-                InstanceType<C>,
-                ...ClassesInstances<
-                    TraitsClasses<Traits>
-                >,
-            ]>,
-
-            ConstructorParameters<C>
-        > &
-
-        MergeInheritanceTree<[
-            StaticMembers<C>,
-            ...ClassesStaticMembers<
-                TraitsClasses<Traits>
-            >,
-        ]>
-    )
-}
-
-/**
- * Expresses the combined functionality of multiple traits.
- * @template Traits - An array of trait.
- * @param traits - An array of trait to apply.
- * @returns A new class type expressing the combined functionality of the traits.
- * @example
- * Applies traits to a class:
- * ```ts
- * class User extends expresses(Identifiable<bigint>(), Permissible) {
- *     readonly id: bigint
- *
- *     constructor(id: bigint) {
- *         super()
- *         this.id = id
- *     }
- * }
- * ```
- */
-export function expresses<
-    Traits extends readonly Trait<any>[],
->(
-    ...traits: Traits
-) {
-    return extendsAndExpresses(Object, ...traits)
-}

src/index.ts

@@ -1,2 +1,4 @@
-export * from "./expresses"
+export * from "./Trait"
-export * from "./trait"
+export * from "./TraitExpression"
+export * from "./TraitExpressionBuilder"
+export * from "./abstract"

src/tests.ts

@@ -1,131 +1,78 @@
-import { AbstractClass } from "type-fest"
+import { Implements, Trait, abstract, expression, trait } from "."
-import { expresses, extendsAndExpresses, trait } from "."
-import { ClassesInstances, MergeInheritanceTree } from "./util"
 
 
-const Identifiable = <ID>() =>
+const PrintsHelloOnNew = trait(
-    trait(Super => {
+    abstract(),
-        abstract class Identifiable extends Super {
+    Super => class PrintsHelloOnNew extends Super {
-            abstract readonly id: ID
+        constructor(...args: any[]) {
+            super(...args)
+            console.log("Hello!")
+        }
+    },
+)
 
+const Identifiable = <ID>() => trait(
+    abstract<{ readonly id: ID }>(),
+    Super => class Identifiable extends Super {
         equals(el: Identifiable) {
             return this.id === el.id
         }
-
+    },
-            constructor(...args: any[]) {
-                super(...args)
-                console.log("Identified constructor")
-            }
-        }
-
-        return Identifiable
-    })
-
-const ImplementsIdentifiable = <ID>(defaultID: ID) =>
-    trait(Super => {
-        abstract class ImplementsIdentifiable extends extendsAndExpresses(
-            Super,
-            Identifiable<ID>(),
-        ) {
-            id: ID = defaultID
-
-            constructor(...args: any[]) {
-                super(...args)
-                console.log("ImplementsIdentifiable constructor")
-            }
-        }
-
-        return ImplementsIdentifiable
-    })
-
-
-const Permissible = trait(Super => {
-    abstract class Permissible extends Super {
-        static readonly defaultPermissions: string[] = []
-        permissions: string[] = []
-
-        constructor(...args: any[]) {
-            super(...args)
-            console.log("Permissible constructor")
-        }
-    }
-
-    return Permissible
-})
-
-
-const UserProto = expresses(
-    // Identifiable<bigint>(),
-    ImplementsIdentifiable(0n),
-    Permissible,
 )
 
-class User extends UserProto {
+const StatefulSubscription = trait(
-    constructor(id: bigint) {
+    abstract<{
-        super()
+        readonly status: (
-        this.id = id
-    }
-}
-
-const user1 = new User(1n)
-console.log(user1)
-console.log(user1.equals(user1))
-
-
-const Test1 = trait(Super => {
-    abstract class Test1 extends Super {
-        declare static name: string
-        declare static testValue: (
-            { _tag: "type1", value: string } |
-            { _tag: "type2", value: number }
-        )
-
-        abstract name: string
-
-        declare createdAt: Date
-        declare readonly status: (
             { _tag: "awaitingPayment" } |
             { _tag: "active", activeSince: Date, expiresAt?: Date } |
             { _tag: "expired", expiredSince: Date }
         )
-    }
+    }>(),
 
-    return Test1
+    Super => class StatefulSubscription extends Super {},
-})
+)
 
-const Test2 = trait(Super => {
+// interface ActiveStatefulSubscriptionAbstractMembers extends TraitAbstractMembers<typeof StatefulSubscription> {
-    abstract class Test2 extends Super {
+//     readonly status: { _tag: "active", activeSince: Date, expiresAt?: Date }
-        declare readonly status: { _tag: "active", activeSince: Date, expiresAt?: Date }
+// }
-    }
 
-    return Test2
+// const ActiveStatefulSubscription = trait(
-})
+//     abstract<ActiveStatefulSubscriptionAbstractMembers>(),
-
+//     Super => class ActiveStatefulSubscription extends Super {},
-const Test3 = trait(Super => {
+// )
-    abstract class Test3 extends Super {
-        declare static testValue: { _tag: "type2", value: number }
-        declare lol: 10n
-    }
-
-    return Test3
-})
-
-const TestObjectProto = expresses(Test1, Test2, Test3)
-TestObjectProto.testValue
 
 
-interface Gneugneu {
+class TestSuperclass {
-    ahi: string
+    // id: number = 69
-    get adolf(): string
+    // static test = 69
 }
 
-class GneugneuImpl implements Gneugneu {
-    ahi: string = ""
-    get adolf(): string {
-        throw new Error("Method not implemented.")
-    }
 
+const builder = expression
+    .extends(TestSuperclass)
+    .expresses(
+        PrintsHelloOnNew,
+        Identifiable<bigint>(),
+        // Identifiable<number>(),
+        StatefulSubscription,
+    )
+
+const exp = builder.get()
+type Abs = Implements<typeof exp>
+
+// exp.subtrait(
+//     s => {
+//         interface Subtrait extends (typeof s) {
+
+//         }
+
+//         return abstract<Subtrait>()
+//     },
+// )
+
+class User extends exp.extends implements Implements<typeof exp> {
+    declare status: { _tag: "awaitingPayment" } | { _tag: "active"; activeSince: Date; expiresAt?: Date | undefined } | { _tag: "expired"; expiredSince: Date }
+    id: bigint = -1n
 }
 
-abstract class Issou extends GneugneuImpl implements Gneugneu {
+console.log(new User())
-}

src/trait.ts

@@ -1,117 +0,0 @@
-import { AbstractClass, AbstractConstructor, Opaque } from "type-fest"
-
-
-/**
- * Represents a trait that can be applied to a class.
- * @template C - The abstract class type.
- */
-export type Trait<
-    C extends AbstractClass<any>
-> = Opaque<
-    TraitApplier<C>,
-    "@thilawyn/thilatrait/Trait"
->
-
-export type TraitApplierSuperTag = "@thilawyn/thilatrait/Super"
-
-/**
- * Represents the function signature for applying a trait to a parent class.
- * @template C - The abstract class type.
- */
-export type TraitApplier<
-    C extends AbstractClass<any>
-> = (
-    (Super: Opaque<AbstractConstructor<object>, TraitApplierSuperTag>) => Opaque<C, TraitApplierSuperTag>
-)
-
-/**
- * Creates a trait using the provided trait applier function.
- * @template C - The abstract class type.
- * @param applier - The trait applier function.
- * @returns A trait.
- * @example
- * Creates a trait:
- * ```ts
- * const Permissible = trait(Super => {
- *     abstract class Permissible extends Super {
- *         static readonly defaultPermissions: string[] = []
- *         permissions: string[] = []
- *
- *         // Constructor is optional
- *         // If you wish to use it, make sure it takes any[] as an args array and passes it to the super call. This is necessary for inheritance to work properly.
- *         // Trait constructors cannot have typed arguments of their own, they only serve to run logic during object instantiation.
- *         constructor(...args: any[]) {
- *             super(...args)
- *         }
- *     }
- *
- *     return Permissible
- * })
- * ```
- * Creates a generic trait:
- * ```ts
- * const Identifiable = <ID>() =>
- *     trait(Super => {
- *         abstract class Identifiable extends Super {
- *             abstract readonly id: ID
- *
- *             equals(el: Identifiable) {
- *                 return this.id === el.id
- *             }
- *
- *             // Optional
- *             constructor(...args: any[]) {
- *                 super(...args)
- *             }
- *         }
- *
- *         return Identifiable
- *     })
- * ```
- * Creates a subtrait:
- * ```ts
- * const ImplementsIdentifiable = <ID>(defaultID: ID) =>
- *     trait(Super => {
- *         abstract class ImplementsIdentifiable extends extendsAndExpresses(
- *             Super,
- *             Identifiable<ID>(),
- *         ) {
- *             id: ID = defaultID
- *
- *             // Optional
- *             constructor(...args: any[]) {
- *                 super(...args)
- *             }
- *         }
- *
- *         return ImplementsIdentifiable
- *     })
- * ```
- */
-export function trait<
-    C extends AbstractClass<any>
->(
-    applier: TraitApplier<C>
-) {
-    return applier as Trait<C>
-}
-
-/**
- * Returns the class type of a trait.
- * @template T - The trait type.
- */
-export type TraitClass<T> = (
-    T extends Trait<infer C>
-        ? C
-        : never
-)
-
-/**
- * Returns the instance type of a trait.
- * @template T - The trait type.
- */
-export type TraitInstance<T> = (
-    T extends Trait<infer C>
-        ? InstanceType<C>
-        : never
-)

src/util/class.ts

@@ -1,34 +1,7 @@
+import { Fn } from "hotscript"
 import { AbstractClass } from "type-fest"
 
 
-/**
- * Represents an array of instances corresponding to the provided classes.
- * @template Classes - An array of classes extending AbstractClass.
- */
-export type ClassesInstances<Classes extends readonly AbstractClass<any>[]> = (
-    Classes extends [infer Class, ...infer Rest]
-        ? Class extends AbstractClass<any>
-            ? Rest extends AbstractClass<any>[]
-                ? [InstanceType<Class>, ...ClassesInstances<Rest>]
-                : never
-            : never
-        : []
-)
-
-/**
- * Represents an intersection of instances of the provided classes.
- * @template Classes - An array of classes extending AbstractClass.
- */
-export type ClassesInstancesIntersection<Classes extends readonly AbstractClass<any>[]> = (
-    Classes extends [infer Class, ...infer Rest]
-        ? Class extends AbstractClass<any>
-            ? Rest extends AbstractClass<any>[]
-                ? InstanceType<Class> & ClassesInstancesIntersection<Rest>
-                : never
-            : never
-        : {}
-)
-
 /**
  * Represents the static members of a class.
  * @template Class - A class extending AbstractClass.
@@ -37,30 +10,6 @@ export type StaticMembers<Class extends AbstractClass<any>> = (
     Omit<Class, "prototype">
 )
 
-/**
+export interface StaticMembersFn extends Fn {
- * Represents an array of static members corresponding to the provided classes.
+    return: StaticMembers<this["arg0"]>
- * @template Classes - An array of classes extending AbstractClass.
+}
- */
-export type ClassesStaticMembers<Classes extends readonly AbstractClass<any>[]> = (
-    Classes extends [infer Class, ...infer Rest]
-        ? Class extends AbstractClass<any>
-            ? Rest extends AbstractClass<any>[]
-                ? [StaticMembers<Class>, ...ClassesStaticMembers<Rest>]
-                : never
-            : never
-        : []
-)
-
-/**
- * Represents an intersection of static members of the provided classes.
- * @template Classes - An array of classes extending AbstractClass.
- */
-export type ClassesStaticMembersIntersection<Classes extends readonly AbstractClass<any>[]> = (
-    Classes extends [infer Class, ...infer Rest]
-        ? Class extends AbstractClass<any>
-            ? Rest extends AbstractClass<any>[]
-                ? StaticMembers<Class> & ClassesStaticMembersIntersection<Rest>
-                : never
-            : never
-        : {}
-)

src/util/extend.ts

@@ -0,0 +1,26 @@
+import { Call, ComposeLeft, Fn, Match, Tuples } from "hotscript"
+
+
+type CommonKeys<A, B> = Extract<keyof A, keyof B>
+
+type ExtendReducer<Super, Self> = (
+    Pick<Self, CommonKeys<Self, Super>> extends Pick<Super, CommonKeys<Self, Super>>
+        ? Omit<Super, CommonKeys<Self, Super>> & Self
+        : never
+)
+interface ExtendReducerFn extends Fn {
+    return: ExtendReducer<this["arg0"], this["arg1"]>
+}
+
+export type ExtendFn = Tuples.Reduce<ExtendReducerFn, {}>
+export type Extend<T extends object[]> = Call<ExtendFn, T>
+
+
+export type ExtendableFn = ComposeLeft<[
+    ExtendFn,
+    Match<[
+        Match.With<never, false>,
+        Match.With<any, true>,
+    ]>
+]>
+export type Extendable<T extends object[]> = Call<ExtendableFn, T>

src/util/index.ts

@@ -1,3 +1,4 @@
 export * from "./class"
+export * from "./extend"
 export * from "./inheritance"
-export * from "./trait"
+export * from "./misc"

src/util/misc.ts

@@ -0,0 +1,7 @@
+import { Fn } from "hotscript"
+import { Simplify } from "type-fest"
+
+
+export interface SimplifyFn extends Fn {
+    return: Simplify<this["arg0"]>
+}

src/util/trait.ts

@@ -1,16 +0,0 @@
-import { Trait, TraitClass } from ".."
-
-
-/**
- * Represents an array of classes corresponding to the provided traits.
- * @template Traits - An array of traits extending Trait<any>.
- */
-export type TraitsClasses<Traits extends readonly Trait<any>[]> = (
-    Traits extends [infer T, ...infer Rest]
-        ? T extends Trait<any>
-            ? Rest extends Trait<any>[]
-                ? [TraitClass<T>, ...TraitsClasses<Rest>]
-                : never
-            : never
-        : []
-)