0.1.24 (#24)

Co-authored-by: Julien Valverdé <julien.valverde@mailo.com>
Reviewed-on: https://git.jvalver.de/Thilawyn/traitify-ts/pulls/24

.drone.jsonnet

@@ -16,8 +16,8 @@ local lint_step = {
 
 local build_step = {
     name: "build",
-    image: bun_image,
-    commands: ["bun run build"],
+    image: node_image,
+    commands: ["npm run build"],
 };
 
 local pack_step = {

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thilawyn/traitify-ts",
-  "version": "0.1.0",
+  "version": "0.1.24",
   "type": "module",
   "publishConfig": {
     "registry": "https://git.jvalver.de/api/packages/thilawyn/npm/"
@@ -8,37 +8,58 @@
   "files": [
     "./dist"
   ],
+  "types": "./dist/lib.d.ts",
   "exports": {
     ".": {
       "import": {
-        "types": "./dist/lib.d.mts",
-        "default": "./dist/lib.mjs"
+        "types": "./dist/lib.d.ts",
+        "default": "./dist/lib.js"
       },
       "require": {
         "types": "./dist/lib.d.cts",
         "default": "./dist/lib.cjs"
       }
+    },
+    "./effect": {
+      "import": {
+        "types": "./dist/effect/lib.d.ts",
+        "default": "./dist/effect/lib.js"
+      },
+      "require": {
+        "types": "./dist/effect/lib.d.cts",
+        "default": "./dist/effect/lib.cjs"
+      }
+    },
+    "./traitsUnique-DCJN7XEW": {
+      "import": {
+        "types": "./dist/traitsUnique-DCJN7XEW.d.ts"
+      },
+      "require": {
+        "types": "./dist/traitsUnique-DCJN7XEW.d.ts"
+      }
     }
   },
   "scripts": {
-    "build": "rollup -c rollup.config.ts",
+    "build": "tsup",
     "lint:tsc": "tsc --noEmit",
     "clean:cache": "rm -f tsconfig.tsbuildinfo",
     "clean:dist": "rm -rf dist",
     "clean:node": "rm -rf node_modules"
   },
   "dependencies": {
-    "type-fest": "^4.10.1"
+    "remeda": "^1.61.0",
+    "type-fest": "^4.18.2"
   },
   "devDependencies": {
-    "@rollup/plugin-node-resolve": "^15.2.3",
     "bun-types": "latest",
-    "npm-check-updates": "^16.14.14",
+    "npm-check-updates": "^16.14.20",
     "npm-sort": "^0.0.4",
-    "rollup": "^4.9.6",
-    "rollup-plugin-cleanup": "^3.2.1",
-    "rollup-plugin-ts": "^3.4.5",
-    "tsx": "^4.7.0",
-    "typescript": "^5.3.3"
+    "tsup": "^8.0.2",
+    "tsx": "^4.10.1",
+    "typescript": "^5.4.5"
+  },
+  "optionalDependencies": {
+    "@effect/schema": "^0.67.0",
+    "effect": "^3.1.3"
   }
 }

rollup.config.ts

@@ -1,34 +0,0 @@
-import { nodeResolve } from "@rollup/plugin-node-resolve"
-import { defineConfig } from "rollup"
-import cleanup from "rollup-plugin-cleanup"
-import ts from "rollup-plugin-ts"
-import pkg from "./package.json" assert { type: "json" }
-
-
-export default defineConfig({
-    input: "src/index.ts",
-
-    output: [
-        {
-            file:    pkg.exports["."].import.default,
-            format:  "esm",
-        },
-
-        {
-            file:    pkg.exports["."].require.default,
-            format:  "cjs",
-        },
-    ],
-
-    external: id => !/^[./]/.test(id),
-
-    plugins: [
-        nodeResolve(),
-        ts(),
-
-        cleanup({
-            comments: "jsdoc",
-            extensions: ["ts"],
-        }),
-    ],
-})

src/Trait.ts

@@ -0,0 +1,136 @@
+import { AbstractConstructor, Constructor, Simplify } from "type-fest"
+import { TraitExpression } from "./TraitExpression"
+import { Extend, StaticMembers } from "./util"
+
+
+export class Trait<
+    SuperExpression extends TraitExpression<
+        typeof TraitExpression.NullSuperclass,
+        readonly Trait<any, any, any, any>[]
+    >,
+    Abstract        extends object,
+    StaticAbstract  extends object,
+    ImplClass       extends AbstractConstructor<object, []>,
+> {
+    constructor(
+        readonly superExpression:  SuperExpression,
+        readonly abstract:         Abstract,
+        readonly staticAbstract:   StaticAbstract,
+        readonly apply:            (Super: AbstractConstructor<object>) => ImplClass,
+    ) {}
+}
+
+export namespace Trait {
+    export type SuperExpression<T> = (
+        T extends Trait<infer SuperExpression, any, any, any>
+            ? SuperExpression
+            : never
+    )
+
+    export type Supertraits<T> = (
+        TraitExpression.Traits<Trait.SuperExpression<T>>
+    )
+
+    export type Abstract<T> = (
+        T extends Trait<any, infer Abstract, any, any>
+            ? Abstract
+            : never
+    )
+
+    export type StaticAbstract<T> = (
+        T extends Trait<any, any, infer StaticAbstract, any>
+            ? StaticAbstract
+            : never
+    )
+
+    export type ImplClass<T> = (
+        T extends Trait<any, any, any, infer ImplClass>
+            ? ImplClass
+            : never
+    )
+
+    export type ImplInstance<T> = (
+        InstanceType<Trait.ImplClass<T>>
+    )
+
+    export type ImplStaticMembers<T> = (
+        StaticMembers<Trait.ImplClass<T>>
+    )
+
+    export type Instance<T> = (
+        Extend<[
+            Trait.Abstract<T>,
+            Trait.ImplInstance<T>,
+        ]>
+    )
+
+    export type Static<T> = (
+        Extend<[
+            Trait.StaticAbstract<T>,
+            Trait.ImplStaticMembers<T>,
+        ]>
+    )
+}
+
+export namespace TraitTuple {
+    export type MapAbstract<T> = {
+        [K in keyof T]: K extends keyof readonly []
+            ? T[K]
+            : Trait.Abstract<T[K]>
+    }
+
+    export type MapStaticAbstract<T> = {
+        [K in keyof T]: K extends keyof readonly []
+            ? T[K]
+            : Trait.StaticAbstract<T[K]>
+    }
+
+    export type MapImplClass<T> = {
+        [K in keyof T]: K extends keyof readonly []
+            ? T[K]
+            : Trait.ImplClass<T[K]>
+    }
+
+    export type MapImplInstance<T> = {
+        [K in keyof T]: K extends keyof readonly []
+            ? T[K]
+            : Trait.ImplInstance<T[K]>
+    }
+
+    export type MapImplStaticMembers<T> = {
+        [K in keyof T]: K extends keyof readonly []
+            ? T[K]
+            : Trait.ImplStaticMembers<T[K]>
+    }
+
+    export type MapInstance<T> = {
+        [K in keyof T]: K extends keyof readonly []
+            ? T[K]
+            : Trait.Instance<T[K]>
+    }
+
+    export type MapStaticMembers<T> = {
+        [K in keyof T]: K extends keyof readonly []
+            ? T[K]
+            : Trait.Static<T[K]>
+    }
+}
+
+
+export type TraitClass<T extends Trait<any, any, any, any>> = (
+    AbstractConstructor<TraitInstance<T>, any[]> &
+    TraitStaticMembers<T>
+)
+
+export type TraitConcreteClass<T extends Trait<any, any, any, any>> = (
+    Constructor<TraitInstance<T>, any[]> &
+    TraitStaticMembers<T>
+)
+
+export type TraitInstance<T extends Trait<any, any, any, any>> = (
+    Simplify<Trait.Instance<T>>
+)
+
+export type TraitStaticMembers<T extends Trait<any, any, any, any>> = (
+    Simplify<Trait.Static<T>>
+)

src/TraitBuilder.ts

@@ -0,0 +1,180 @@
+import { AbstractConstructor, Constructor, Simplify } from "type-fest"
+import { Trait } from "./Trait"
+import { TraitExpression } from "./TraitExpression"
+import { Extend, StaticMembers, type } from "./util"
+
+
+declare const implSuperSymbol: unique symbol
+
+
+export class TraitBuilder<
+    SuperExpression extends TraitExpression<
+        typeof TraitExpression.NullSuperclass,
+        readonly Trait<any, any, any, any>[]
+    >,
+    Abstract        extends object,
+    StaticAbstract  extends object,
+    ImplClass       extends AbstractConstructor<object, []>,
+> {
+    constructor(
+        readonly traitSuperExpression:  SuperExpression,
+        readonly traitAbstract:         Abstract,
+        readonly traitStaticAbstract:   StaticAbstract,
+        readonly traitApply:            (Super: AbstractConstructor<object>) => ImplClass,
+    ) {}
+
+
+    abstract<A extends AbstractConstructor<Abstract> & StaticAbstract>(
+        _: (Super: AbstractConstructor<Abstract> & StaticAbstract) => A
+    ) {
+        return new TraitBuilder(
+            this.traitSuperExpression,
+            {} as Simplify<InstanceType<A>>,
+            {} as Simplify<StaticMembers<A>>,
+            this.traitApply,
+        )
+    }
+
+    abstractType<A extends Abstract>(
+        _: (Super: Abstract) => typeof type<A>
+    ) {
+        return new TraitBuilder(
+            this.traitSuperExpression,
+            {} as Simplify<A>,
+            this.traitStaticAbstract,
+            this.traitApply,
+        )
+    }
+
+    staticAbstractType<A extends StaticAbstract>(
+        _: (Super: StaticAbstract) => typeof type<A>
+    ) {
+        return new TraitBuilder(
+            this.traitSuperExpression,
+            this.traitAbstract,
+            {} as Simplify<A>,
+            this.traitApply,
+        )
+    }
+
+    implement<
+        ImplClassWithAbstract extends TraitBuilder.ImplSuper<typeof this>  // TODO: find a way to set the constraint to concrete classes while keeping the Super arg as an abstract class
+    >(
+        apply: (Super: TraitBuilder.ImplSuper<typeof this>) => ImplClassWithAbstract
+    ) {
+        return new TraitBuilder(
+            this.traitSuperExpression,
+            this.traitAbstract,
+            this.traitStaticAbstract,
+
+            apply as unknown as (Super: AbstractConstructor<object>) => (
+                AbstractConstructor<
+                    Simplify<
+                        Omit<
+                            InstanceType<ImplClassWithAbstract>,
+                            keyof Abstract | "constructor"
+                        >
+                    >
+                > &
+
+                Simplify<
+                    Omit<
+                        StaticMembers<ImplClassWithAbstract>,
+                        keyof StaticAbstract | typeof implSuperSymbol
+                    >
+                >
+            ),
+        )
+    }
+
+
+    build() {
+        return new Trait(
+            this.traitSuperExpression,
+            this.traitAbstract,
+            this.traitStaticAbstract,
+            this.traitApply,
+        )
+    }
+}
+
+export namespace TraitBuilder {
+    export type ImplSuper<This> = (
+        This extends TraitBuilder<
+            any,
+            infer Abstract,
+            infer StaticAbstract,
+            infer ImplClass
+        >
+            ? (
+                AbstractConstructor<
+                    Simplify<
+                        Extend<[
+                            Abstract,
+                            InstanceType<ImplClass>,
+                        ]>
+                    >
+                > &
+
+                Simplify<
+                    Extend<[
+                        StaticAbstract,
+                        StaticMembers<ImplClass>,
+                    ]>
+                > &
+                { readonly [implSuperSymbol]: true }
+            )
+            : never
+    )
+}
+
+
+export type ImplStatic<
+    ImplClass extends AbstractConstructor<object> & { readonly [implSuperSymbol]: true }
+> = (
+    Simplify<
+        Omit<StaticMembers<ImplClass>, typeof implSuperSymbol>
+    >
+)
+
+export function implStaticThis<
+    ImplClass extends AbstractConstructor<object> & { readonly [implSuperSymbol]: true },
+    This      extends AbstractConstructor<object>,
+>(
+    _Impl:    ImplClass,
+    thisArg:  This,
+) {
+    return thisArg as unknown as (
+        AbstractConstructor<
+            InstanceType<ImplClass> & InstanceType<This>,
+            ConstructorParameters<This>
+        > &
+        ImplStatic<ImplClass> &
+        StaticMembers<This>
+    )
+}
+
+export function implStaticInstantiableThis<
+    ImplClass extends AbstractConstructor<object> & { readonly [implSuperSymbol]: true },
+    This      extends Constructor<object>,
+>(
+    _Impl:    ImplClass,
+    thisArg:  This,
+) {
+    return thisArg as unknown as (
+        Constructor<
+            InstanceType<ImplClass> & InstanceType<This>,
+            ConstructorParameters<This>
+        > &
+        ImplStatic<ImplClass> &
+        StaticMembers<This>
+    )
+}
+
+
+export const trait = new TraitBuilder(
+    new TraitExpression(TraitExpression.NullSuperclass, []),
+    {} as {},
+    {} as {},
+    Super => class extends Super {} as AbstractConstructor<{}>,
+)

src/TraitExpression.ts

@@ -0,0 +1,176 @@
+import { AbstractConstructor, Constructor, Simplify } from "type-fest"
+import { Trait, TraitTuple } from "./Trait"
+import { TraitBuilder } from "./TraitBuilder"
+import { Extend, StaticMembers } from "./util"
+
+
+export type TraitExpressionLike<
+    Superclass extends AbstractConstructor<object>,
+    Traits     extends readonly Trait<any, any, any, any>[],
+> = {
+    readonly superclass:  Superclass,
+    readonly traits:      Traits,
+}
+
+
+export class TraitExpression<
+    Superclass   extends AbstractConstructor<object>,
+    const Traits extends readonly Trait<any, any, any, any>[],
+>
+implements TraitExpressionLike<Superclass, Traits> {
+    constructor(
+        readonly superclass:  Superclass,
+        readonly traits:      Traits,
+    ) {}
+
+
+    get extends(): (
+        AbstractConstructor<
+            InstanceType<Superclass> &  // Keep the instance of the superclass outside of any kind of type manipulation
+                                        // as it can accidentely remove abstract properties
+            Simplify<
+                Extend<TraitTuple.MapImplInstance<Traits>>
+            >,
+
+            ConstructorParameters<Superclass>
+        > &
+
+        Simplify<
+            Extend<[
+                StaticMembers<Superclass>,
+                ...TraitTuple.MapImplStaticMembers<Traits>,
+            ]>
+        >
+    ) {
+        return this.traits.reduce(
+            (previous, trait) => trait.apply(previous),
+            this.superclass,
+        ) as any
+    }
+
+
+    staticImplements(_target: StaticImplements<typeof this>, _context: any) {}
+
+    get staticImplementsStage2() {
+        return (_target: StaticImplements<typeof this>) => {}
+    }
+
+
+    subtrait<
+        This extends TraitExpression<typeof TraitExpression.NullSuperclass, any>
+    >(
+        this: This
+    ) {
+        return new TraitBuilder<This,
+            Simplify<
+                Extend<TraitTuple.MapAbstract<Traits>>
+            >,
+            Simplify<
+                Extend<TraitTuple.MapStaticAbstract<Traits>>
+            >,
+
+            AbstractConstructor<
+                Simplify<
+                    Extend<TraitTuple.MapImplInstance<Traits>>
+                >
+            > &
+            Simplify<
+                Extend<TraitTuple.MapImplStaticMembers<Traits>>
+            >
+        >(
+            this,
+            {} as any,
+            {} as any,
+            Super => class extends Super {} as any,
+        )
+    }
+}
+
+export namespace TraitExpression {
+    const nullSuperclassSymbol = Symbol()
+    export class NullSuperclass {
+        static readonly [nullSuperclassSymbol]: true
+        constructor(..._args: any[]) {}
+    }
+
+    export type Superclass<T> = (
+        T extends TraitExpressionLike<infer Superclass, any>
+            ? Superclass
+            : never
+    )
+
+    export type Traits<T> = (
+        T extends TraitExpressionLike<any, infer Traits>
+            ? Traits
+            : never
+    )
+}
+
+
+export type Implements<
+    Exp extends TraitExpressionLike<any, readonly Trait<any, any, any, any>[]>
+> = (
+    Simplify<
+        Extend<
+            TraitTuple.MapAbstract<
+                TraitExpression.Traits<Exp>
+            >
+        >
+    >
+)
+
+export type StaticImplements<
+    Exp extends TraitExpressionLike<any, readonly Trait<any, any, any, any>[]>
+> = (
+    Simplify<
+        Extend<
+            TraitTuple.MapStaticAbstract<
+                TraitExpression.Traits<Exp>
+            >
+        >
+    >
+)
+
+
+export type TraitExpressionClass<
+    Exp extends TraitExpressionLike<any, readonly Trait<any, any, any, any>[]>
+> = (
+    AbstractConstructor<
+        TraitExpressionInstance<Exp>,
+        ConstructorParameters<TraitExpression.Superclass<Exp>>
+    > &
+    TraitExpressionStaticMembers<Exp>
+)
+
+export type TraitExpressionInstantiableClass<
+    Exp extends TraitExpressionLike<any, readonly Trait<any, any, any, any>[]>
+> = (
+    Constructor<
+        TraitExpressionInstance<Exp>,
+        ConstructorParameters<TraitExpression.Superclass<Exp>>
+    > &
+    TraitExpressionStaticMembers<Exp>
+)
+
+export type TraitExpressionInstance<
+    Exp extends TraitExpressionLike<any, readonly Trait<any, any, any, any>[]>
+> = (
+    InstanceType<TraitExpression.Superclass<Exp>> &  // Keep the instance of the superclass outside of any kind of type manipulation
+                                                     // as it can accidentely remove abstract properties
+    Simplify<
+        Extend<
+            TraitTuple.MapInstance<TraitExpression.Traits<Exp>>
+        >
+    >
+)
+
+export type TraitExpressionStaticMembers<
+    Exp extends TraitExpressionLike<any, readonly Trait<any, any, any, any>[]>
+> = (
+    Simplify<
+        Extend<[
+            StaticMembers<TraitExpression.Superclass<Exp>>,
+            ...TraitTuple.MapStaticMembers<TraitExpression.Traits<Exp>>,
+        ]>
+    >
+)

src/TraitExpressionBuilder.ts

@@ -0,0 +1,150 @@
+import { AbstractConstructor } from "type-fest"
+import { Trait, TraitTuple } from "./Trait"
+import { TraitExpression } from "./TraitExpression"
+import { SpreadSupertraits, spreadSupertraits } from "./spreadSupertraits"
+import { TraitsUnique, traitsUnique } from "./traitsUnique"
+import { Extendable, StaticMembers } from "./util"
+
+
+export class TraitExpressionBuilder<
+    Superclass   extends AbstractConstructor<object>,
+    const Traits extends readonly Trait<any, any, any, any>[],
+> {
+    constructor(
+        readonly expressionSuperclass:  Superclass,
+        readonly expressionTraits:      Traits,
+    ) {}
+
+
+    extends<
+        Super extends AbstractConstructor<object>
+    >(
+        superclass: Super
+    ) {
+        return new TraitExpressionBuilder(
+            superclass,
+            this.expressionTraits,
+        )
+    }
+
+    expresses<
+        const T extends readonly Trait<
+            TraitExpression<
+                typeof TraitExpression.NullSuperclass,
+                readonly Trait<any, any, any, any>[]
+            >,
+            any,
+            any,
+            any
+        >[]
+    >(
+        ...traits: T
+    ): TraitExpressionBuilder<
+        Superclass,
+        TraitExpressionBuilder.ExpressesReturnTypeTraits<Traits, T>
+    > {
+        return new TraitExpressionBuilder(
+            this.expressionSuperclass,
+
+            traitsUnique([
+                ...this.expressionTraits,
+                ...spreadSupertraits(traits),
+            ]),
+        )
+    }
+
+    expressesFirst<
+        const T extends readonly Trait<
+            TraitExpression<
+                typeof TraitExpression.NullSuperclass,
+                readonly Trait<any, any, any, any>[]
+            >,
+            any,
+            any,
+            any
+        >[]
+    >(
+        ...traits: T
+    ): TraitExpressionBuilder<
+        Superclass,
+        TraitExpressionBuilder.ExpressesFirstReturnTypeTraits<Traits, T>
+    > {
+        return new TraitExpressionBuilder(
+            this.expressionSuperclass,
+
+            traitsUnique([
+                ...spreadSupertraits(traits),
+                ...this.expressionTraits,
+            ]),
+        )
+    }
+
+
+    build() {
+        return new TraitExpression(
+            this.expressionSuperclass,
+            this.expressionTraits,
+        ) as TraitExpressionBuilder.BuildTraitExpression<Superclass, Traits>
+    }
+
+    then<V>(fn: (expression: ReturnType<typeof this.build>) => V): V {
+        return fn(this.build())
+    }
+
+    buildAnyway() {
+        return new TraitExpression(
+            this.expressionSuperclass,
+            this.expressionTraits,
+        )
+    }
+
+    thenAnyway<V>(fn: (expression: ReturnType<typeof this.buildAnyway>) => V): V {
+        return fn(this.buildAnyway())
+    }
+}
+
+export namespace TraitExpressionBuilder {
+    export type ExpressesReturnTypeTraits<
+        Traits extends readonly Trait<any, any, any, any>[],
+        T      extends readonly Trait<any, any, any, any>[],
+    > = (
+        TraitsUnique<readonly [
+            ...Traits,
+            ...SpreadSupertraits<T>,
+        ]>
+    )
+
+    export type ExpressesFirstReturnTypeTraits<
+        Traits extends readonly Trait<any, any, any, any>[],
+        T      extends readonly Trait<any, any, any, any>[],
+    > = (
+        TraitsUnique<readonly [
+            ...SpreadSupertraits<T>,
+            ...Traits,
+        ]>
+    )
+
+    export type BuildTraitExpression<
+        Superclass extends AbstractConstructor<object>,
+        Traits     extends readonly Trait<any, any, any, any>[],
+    > = (
+        Extendable<TraitTuple.MapAbstract<Traits>> extends false
+            ? "Type conflict between the traits abstract definitions."
+            : Extendable<TraitTuple.MapStaticAbstract<Traits>> extends false
+                ? "Type conflict between the traits static abstract definitions."
+                : Extendable<[
+                    InstanceType<Superclass>,
+                    ...TraitTuple.MapImplInstance<Traits>,
+                ]> extends false
+                    ? "Type conflict between the traits implementation instance and/or the superclass instance."
+                    : Extendable<[
+                        StaticMembers<Superclass>,
+                        ...TraitTuple.MapImplStaticMembers<Traits>,
+                    ]> extends false
+                        ? "Type conflict between the traits implementation static members and/or the superclass static members."
+                        : TraitExpression<Superclass, Traits>
+    )
+}
+
+
+export const expression = new TraitExpressionBuilder(TraitExpression.NullSuperclass, [])

src/effect/EffectSchemaTraitExpression.ts

@@ -0,0 +1,83 @@
+import { Schema as S } from "@effect/schema"
+import { AbstractConstructor, Simplify } from "type-fest"
+import { Trait, TraitTuple } from "../Trait"
+import { StaticImplements, TraitExpressionLike } from "../TraitExpression"
+import { Extend, StaticMembers } from "../util"
+
+
+export class EffectSchemaTraitExpression<
+    Fields                  extends S.Struct.Fields,
+    I, R, C,
+    Inherited               extends object,
+    Proto,
+    Static                  extends object,
+
+    const Traits            extends readonly Trait<any, any, any, any>[],
+
+    const Mutability        extends "Immutable" | "Mutable",
+    const EncodedMutability extends "Immutable" | "Mutable",
+>
+implements TraitExpressionLike<
+    S.Class<unknown, Fields, I, R, C, Inherited, Proto>,
+    Traits
+> {
+    constructor(
+        readonly superclass:         S.Class<unknown, Fields, I, R, C, Inherited, Proto>,
+        readonly superclassStatic:   Static,
+        readonly traits:             Traits,
+        readonly mutability:         Mutability,
+        readonly encodedMutability:  EncodedMutability,
+    ) {}
+
+
+    extends<Self>(): (
+        AbstractConstructor<
+            Simplify<
+                ApplyMutability<S.Struct.Type<Fields>, Mutability> &
+                Extend<[
+                    Omit<Inherited, keyof Fields>,
+                    ...TraitTuple.MapImplInstance<Traits>
+                ]> &
+                Proto
+            >,
+
+            ConstructorParameters<S.Class<unknown, Fields, I, R, C, Inherited, Proto>>
+        > &
+
+        StaticMembers<
+            S.Class<
+                Self,
+                Fields,
+                ApplyMutability<I, EncodedMutability>,
+                R, C,
+                Inherited,
+                Proto
+            >
+        > &
+        Simplify<
+            Extend<[
+                Static,
+                ...TraitTuple.MapImplStaticMembers<Traits>
+            ]>
+        >
+    ) {
+        return this.traits.reduce(
+            (previous, trait) => trait.apply(previous),
+            this.superclass,
+        ) as any
+    }
+
+
+    staticImplements(_target: StaticImplements<typeof this>, _context: any) {}
+
+    get staticImplementsStage2() {
+        return (_target: StaticImplements<typeof this>) => {}
+    }
+}
+
+
+type ApplyMutability<T, Mutability extends "Immutable" | "Mutable"> = (
+    Mutability extends "Immutable"
+        ? { +readonly [P in keyof T]: T[P] }
+        : { -readonly [P in keyof T]: T[P] }
+)

src/effect/EffectSchemaTraitExpressionBuilder.ts

@@ -0,0 +1,206 @@
+import { Schema as S } from "@effect/schema"
+import { Simplify } from "type-fest"
+import { Trait, TraitTuple } from "../Trait"
+import { TraitExpression } from "../TraitExpression"
+import { TraitExpressionBuilder } from "../TraitExpressionBuilder"
+import { spreadSupertraits } from "../spreadSupertraits"
+import { traitsUnique } from "../traitsUnique"
+import { Extendable, StaticMembers } from "../util"
+import { EffectSchemaTraitExpression } from "./EffectSchemaTraitExpression"
+
+
+export class EffectSchemaInitialTraitExpressionBuilder {
+    class<
+        Fields extends S.Struct.Fields
+    >(
+        identifier:    string,
+        fields:        Fields,
+        annotations?:  S.Annotations.Schema<unknown>,
+    ) {
+        return new EffectSchemaTraitExpressionBuilder(
+            S.Class<unknown>(identifier)(fields, annotations),
+            {},
+            [],
+            "Immutable",
+            "Immutable",
+        )
+    }
+
+    taggedClass<
+        Tag    extends string,
+        Fields extends S.Struct.Fields,
+    >(
+        tag:           Tag,
+        fields:        Fields,
+        annotations?:  S.Annotations.Schema<unknown>,
+    ) {
+        return new EffectSchemaTraitExpressionBuilder(
+            S.TaggedClass<unknown>()(tag, fields, annotations),
+            {},
+            [],
+            "Immutable",
+            "Immutable",
+        )
+    }
+
+    extends<
+        Super     extends StaticMembers<S.Class<Self, Fields, I, R, C, Inherited, Proto>>,
+        Self      extends object,
+        Fields    extends S.Struct.Fields,
+        I, R, C,
+        Inherited extends object,
+        Proto,
+
+        NewFields extends S.Struct.Fields,
+    >(
+        superclass:    Super | StaticMembers<S.Class<Self, Fields, I, R, C, Inherited, Proto>>,
+        identifier:    string,
+        fields:        NewFields,
+        annotations?:  S.Annotations.Schema<unknown>,
+    ) {
+        return new EffectSchemaTraitExpressionBuilder(
+            superclass.extend<unknown>(identifier)(fields, annotations),
+
+            {} as Simplify<
+                Omit<Super,
+                    "prototype" | keyof S.Class<Self, Fields, I, R, C, Inherited, Proto>
+                >
+            >,
+
+            [],
+            "Immutable",
+            "Immutable",
+        )
+    }
+}
+
+
+export class EffectSchemaTraitExpressionBuilder<
+    Fields                  extends S.Struct.Fields,
+    I, R, C,
+    Inherited               extends object,
+    Proto,
+    Static                  extends object,
+
+    const Traits            extends readonly Trait<any, any, any, any>[],
+
+    const Mutability        extends "Immutable" | "Mutable",
+    const EncodedMutability extends "Immutable" | "Mutable",
+> {
+    constructor(
+        readonly expressionSuperclass:         S.Class<unknown, Fields, I, R, C, Inherited, Proto>,
+        readonly expressionSuperclassStatic:   Static,
+        readonly expressionTraits:             Traits,
+        readonly expressionMutability:         Mutability,
+        readonly expressionEncodedMutability:  EncodedMutability,
+    ) {}
+
+
+    mutable() {
+        return new EffectSchemaTraitExpressionBuilder(
+            this.expressionSuperclass,
+            this.expressionSuperclassStatic,
+            this.expressionTraits,
+            "Mutable",
+            this.expressionEncodedMutability,
+        )
+    }
+
+    immutable() {
+        return new EffectSchemaTraitExpressionBuilder(
+            this.expressionSuperclass,
+            this.expressionSuperclassStatic,
+            this.expressionTraits,
+            "Immutable",
+            this.expressionEncodedMutability,
+        )
+    }
+
+    mutableEncoded() {
+        return new EffectSchemaTraitExpressionBuilder(
+            this.expressionSuperclass,
+            this.expressionSuperclassStatic,
+            this.expressionTraits,
+            this.expressionMutability,
+            "Mutable",
+        )
+    }
+
+    immutableEncoded() {
+        return new EffectSchemaTraitExpressionBuilder(
+            this.expressionSuperclass,
+            this.expressionSuperclassStatic,
+            this.expressionTraits,
+            this.expressionMutability,
+            "Immutable",
+        )
+    }
+
+
+    expresses<
+        const T extends readonly Trait<
+            TraitExpression<
+                typeof TraitExpression.NullSuperclass,
+                readonly Trait<any, any, any, any>[]
+            >,
+            any,
+            any,
+            any
+        >[]
+    >(
+        ...traits: T
+    ) {
+        return new EffectSchemaTraitExpressionBuilder(
+            this.expressionSuperclass,
+            this.expressionSuperclassStatic,
+
+            traitsUnique([
+                ...this.expressionTraits,
+                ...spreadSupertraits(traits),
+            ]) as TraitExpressionBuilder.ExpressesReturnTypeTraits<Traits, T>,
+
+            this.expressionMutability,
+            this.expressionEncodedMutability,
+        )
+    }
+
+
+    build(): (
+        Extendable<TraitTuple.MapAbstract<Traits>> extends false
+            ? "Type conflict between the traits abstract definitions."
+            : Extendable<TraitTuple.MapStaticAbstract<Traits>> extends false
+                ? "Type conflict between the traits static abstract definitions."
+                : Extendable<[
+                    InstanceType<typeof this.expressionSuperclass>,
+                    ...TraitTuple.MapImplInstance<Traits>,
+                ]> extends false
+                    ? "Type conflict between the traits implementation instance and/or the superclass instance."
+                    : Extendable<[
+                        Static,
+                        ...TraitTuple.MapImplStaticMembers<Traits>,
+                    ]> extends false
+                        ? "Type conflict between the traits implementation static members and/or the superclass static members."
+                        : EffectSchemaTraitExpression<
+                            Fields,
+                            I, R, C,
+                            Inherited,
+                            Proto,
+                            Static,
+
+                            Traits,
+                            Mutability,
+                            EncodedMutability
+                        >
+    ) {
+        return new EffectSchemaTraitExpression(
+            this.expressionSuperclass,
+            this.expressionSuperclassStatic,
+            this.expressionTraits,
+            this.expressionMutability,
+            this.expressionEncodedMutability,
+        ) as any
+    }
+}
+
+
+export const effectSchemaExpression = new EffectSchemaInitialTraitExpressionBuilder()

src/effect/lib.ts

@@ -0,0 +1,2 @@
+export { EffectSchemaTraitExpression } from "./EffectSchemaTraitExpression"
+export { EffectSchemaInitialTraitExpressionBuilder, EffectSchemaTraitExpressionBuilder, effectSchemaExpression } from "./EffectSchemaTraitExpressionBuilder"

src/effect/tests.ts

@@ -0,0 +1,48 @@
+import { Schema as S } from "@effect/schema"
+import { Implements } from "../TraitExpression"
+import { effectSchemaExpression } from "./EffectSchemaTraitExpressionBuilder"
+
+
+type RequiredKeys<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? never : K
+  }[keyof T]
+
+type InspectSchemaClass<T> = T extends S.Class<infer Self, infer Fields, infer I, infer R, infer C, infer Inherited, infer Proto>
+    ? Inherited
+    : never
+
+
+const userExp = effectSchemaExpression
+    .class("User", {
+        id:    S.BigIntFromSelf,
+        role:  S.Union(S.Literal("User"), S.Literal("Admin")),
+    })
+    .mutable()
+    .mutableEncoded()
+    .build()
+
+@userExp.staticImplements
+export class User extends userExp.extends<User>() implements Implements<typeof userExp> {
+    aMethodThatShouldBeInherited() {}
+    static aStaticMethodThatShouldBeInherited() {}
+}
+
+User.Encoded
+
+const user = new User({ id: 0n, role: "User" })
+user.id = 0n
+
+
+const adminExp = effectSchemaExpression
+    .extends(User, "User", {
+        role: S.Literal("Admin")
+    })
+    // .immutable()
+    .build()
+
+@adminExp.staticImplements
+export class Admin extends adminExp.extends<Admin>() implements Implements<typeof adminExp> {
+}
+
+const admin = new Admin({ id: 1n, role: "Admin" })
+// admin.role = "Admin"

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 +0,0 @@
-export * from "./expresses"
-export * from "./trait"

src/lib.ts

@@ -0,0 +1,5 @@
+export { Trait, TraitClass, TraitConcreteClass, TraitInstance, TraitStaticMembers, TraitTuple } from "./Trait"
+export { ImplStatic, TraitBuilder, implStaticInstantiableThis, implStaticThis, trait } from "./TraitBuilder"
+export { Implements, StaticImplements, TraitExpression, TraitExpressionClass, TraitExpressionInstance, TraitExpressionInstantiableClass, TraitExpressionStaticMembers } from "./TraitExpression"
+export { TraitExpressionBuilder, expression } from "./TraitExpressionBuilder"
+export { type } from "./util"

src/spreadSupertraits.ts

@@ -0,0 +1,35 @@
+import { Trait } from "./Trait"
+import { TraitExpression } from "./TraitExpression"
+
+
+export function spreadSupertraits<
+    const T extends readonly Trait<
+        TraitExpression<
+            typeof TraitExpression.NullSuperclass,
+            readonly Trait<any, any, any, any>[]
+        >,
+        any,
+        any,
+        any
+    >[]
+>(
+    traits: T
+) {
+    return traits.flatMap(trait => [
+        ...trait.superExpression.traits,
+        trait,
+    ]) as readonly Trait<any, any, any, any>[] as SpreadSupertraits<T>
+}
+
+export type SpreadSupertraits<Traits> = (
+    Traits extends readonly [
+        infer El extends Trait<any, any, any, any>,
+        ...infer Rest,
+    ]
+        ? readonly [
+            ...Trait.Supertraits<El>,
+            El,
+            ...SpreadSupertraits<Rest>,
+        ]
+        : readonly []
+)

src/tests.ts

@@ -1,131 +1,97 @@
-import { AbstractClass } from "type-fest"
-import { expresses, extendsAndExpresses, trait } from "."
-import { ClassesInstances, MergeInheritanceTree } from "./util"
+import { TraitClass } from "./Trait"
+import { trait } from "./TraitBuilder"
+import { Implements, StaticImplements, TraitExpressionClass } from "./TraitExpression"
+import { expression } from "./TraitExpressionBuilder"
+import { type } from "./util"
 
 
-const Identifiable = <ID>() =>
-    trait(Super => {
-        abstract class Identifiable extends Super {
-            abstract readonly id: ID
+const PrintsHelloOnNew = trait
+    .implement(Super => class PrintsHelloOnNew extends Super {
+        static readonly isPrintsHelloOnNew = true
 
+        constructor(...args: any[]) {
+            super(...args)
+            console.log("Hello!")
+        }
+    })
+    .build()
+
+type PrintsHelloOnNewClass = TraitClass<typeof PrintsHelloOnNew>
+
+const Identifiable = <ID>() => trait
+    // .abstract(Super => class extends Super {
+    //     declare readonly id: ID
+    // })
+    .abstractType(Super => type<typeof Super & {
+        readonly id: ID
+    }>)
+    .implement(Super => class Identifiable extends Super {
         equals(el: Identifiable) {
             return this.id === el.id
         }
-
-            constructor(...args: any[]) {
-                super(...args)
-                console.log("Identified constructor")
-            }
-        }
-
-        return Identifiable
     })
+    .build()
 
-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 ImplementsIdentifiable = <ID>(defaultID: ID) => expression
+    .expresses(Identifiable<ID>())
+    .build()
+    .subtrait()
+        .implement(Super => class ImplementsIdentifiable extends Super {
+            readonly id = defaultID
         })
+        .build()
 
-
-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 {
-    constructor(id: bigint) {
-        super()
-        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
+const StatefulSubscription = trait
+    .abstract(Super => class extends Super {
+        declare readonly isStatefulSubscription: true
         declare readonly status: (
             { _tag: "awaitingPayment" } |
             { _tag: "active", activeSince: Date, expiresAt?: Date } |
             { _tag: "expired", expiredSince: Date }
         )
-    }
+    })
+    .build()
 
-    return Test1
-})
+type StatefulSubscriptionClass = TraitClass<typeof StatefulSubscription>
 
-const Test2 = trait(Super => {
-    abstract class Test2 extends Super {
+const ActiveStatefulSubscription = expression
+    .expresses(StatefulSubscription)
+    .build()
+    .subtrait()
+        .abstract(Super => class extends Super {
+            declare readonly isActiveStatefulSubscription: true
             declare readonly status: { _tag: "active", activeSince: Date, expiresAt?: Date }
-    }
+        })
+        .build()
 
-    return Test2
-})
+type ActiveStatefulSubscriptionClass = TraitClass<typeof ActiveStatefulSubscription>
 
-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 {
-    ahi: string
-    get adolf(): string
+class TestSuperclass {
+    // id: number = 69
+    static test = 69
 }
 
-class GneugneuImpl implements Gneugneu {
-    ahi: string = ""
-    get adolf(): string {
-        throw new Error("Method not implemented.")
-    }
+const exp = expression
+    .extends(TestSuperclass)
+    .expresses(
+        PrintsHelloOnNew,
+        Identifiable<bigint>(),
+        // Identifiable<number>(),
+        // StatefulSubscription,
+        ActiveStatefulSubscription,
+    )
+    .build()
 
+type Abs = Implements<typeof exp>
+type AbsStatic = StaticImplements<typeof exp>
+type ExpClass = TraitExpressionClass<typeof exp>
+
+@exp.staticImplements
+class User extends exp.extends implements Implements<typeof exp> {
+    readonly isStatefulSubscription: true = true
+    readonly isActiveStatefulSubscription: true = true
+    declare status: { _tag: "active"; activeSince: Date; expiresAt?: Date | undefined }
+    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/traitsUnique.ts

@@ -0,0 +1,39 @@
+import { unique } from "remeda"
+import { IsEqual } from "type-fest"
+import { Trait } from "./Trait"
+import { TraitExpression } from "./TraitExpression"
+
+
+export function traitsUnique<
+    const T extends readonly Trait<
+        TraitExpression<
+            typeof TraitExpression.NullSuperclass,
+            readonly Trait<any, any, any, any>[]
+        >,
+        any,
+        any,
+        any
+    >[]
+>(
+    traits: T
+) {
+    return unique(traits) as readonly Trait<any, any, any, any>[] as TraitsUnique<T>
+}
+
+export type TraitsUnique<Traits> = (
+    Traits extends readonly [
+        ...infer Rest,
+        infer El extends Trait<any, any, any, any>,
+    ]
+        ? IsTraitInTupleFromRight<Rest, El> extends true
+            ? TraitsUnique<Rest>
+            : readonly [...TraitsUnique<Rest>, El]
+        : readonly []
+)
+type IsTraitInTupleFromRight<Traits, T> = (
+    Traits extends readonly [...infer Rest, infer El]
+        ? IsEqual<El, T> extends true
+            ? true
+            : IsTraitInTupleFromRight<Rest, T>
+        : false
+)

src/util/class.ts

@@ -1,66 +0,0 @@
-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.
- */
-export type StaticMembers<Class extends AbstractClass<any>> = (
-    Omit<Class, "prototype">
-)
-
-/**
- * Represents an array of static members corresponding to the provided classes.
- * @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,71 @@
+import { CommonKeys } from "."
+
+
+// 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 ExtendableFn = ComposeLeft<[
+//     ExtendFn,
+//     Match<[
+//         Match.With<never, false>,
+//         Match.With<any, true>,
+//     ]>
+// ]>
+
+
+// TODO: use OverrideProperties from type-fest?
+export type Extend<T extends readonly object[]> = (
+    T extends readonly [
+        infer Super,
+        infer Self,
+        ...infer Rest extends readonly object[],
+    ]
+        ? Pick<Self, CommonKeys<Self, Super>> extends Pick<Super, CommonKeys<Self, Super>>
+            ? Extend<readonly [
+                Omit<Super, CommonKeys<Self, Super>> & Self,
+                ...Rest,
+            ]>
+            : never
+        : T extends readonly [infer Self]
+            ? Self
+            : {}
+)
+
+export type Extendable<T extends readonly object[]> = (
+    T extends readonly [
+        infer Super,
+        infer Self,
+        ...infer Rest extends readonly object[],
+    ]
+        ? Pick<Self, CommonKeys<Self, Super>> extends Pick<Super, CommonKeys<Self, Super>>
+            ? Extendable<readonly [
+                Omit<Super, CommonKeys<Self, Super>> & Self,
+                ...Rest,
+            ]>
+            : false
+        : true
+)
+
+export type NonExtendableKeys<T extends readonly object[]> = (
+    T extends readonly [
+        infer Super   extends object,
+        infer Self    extends object,
+        ...infer Rest extends readonly object[],
+    ]
+        ? {[K in keyof Super & keyof Self]: Self[K] extends Super[K]
+            ? never
+            : K
+        }[keyof Super & keyof Self]
+        | NonExtendableKeys<readonly [
+            Super & Self,
+            ...Rest,
+        ]>
+        : void
+)

src/util/index.ts

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

src/util/inheritance.ts

@@ -1,9 +1,5 @@
-/**
- * Represents the common keys between two types.
- * @template A - The first type.
- * @template B - The second type.
- */
-export type CommonKeys<A, B> = Extract<keyof A, keyof B>
+import { CommonKeys } from "."
+
 
 /**
  * Merges an inheritance tree defined by an array of types, considering overrides.

src/util/misc.ts

@@ -0,0 +1,17 @@
+import { AbstractConstructor } from "type-fest"
+
+
+/**
+ * Represents the common keys between two types.
+ * @template A - The first type.
+ * @template B - The second type.
+ */
+export type CommonKeys<A, B> = Extract<keyof A, keyof B>
+
+/**
+ * Represents the static members of a class.
+ * @template Class - A class.
+ */
+export type StaticMembers<Class extends AbstractConstructor<any>> = Omit<Class, "prototype">
+
+export function type<T>() { return {} as T }

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
-        : []
-)

tsconfig.json

@@ -8,7 +8,7 @@
     // "allowImportingTsExtensions": true,
     // "noEmit": true,
     "declaration": true,
-    "composite": true,
+    // "composite": true,
     "strict": true,
     "downlevelIteration": true,
     "skipLibCheck": true,

tsup.config.ts

@@ -0,0 +1,12 @@
+import { defineConfig } from "tsup"
+
+
+export default defineConfig({
+    entry: ["./src/lib.ts", "./src/effect/lib.ts"],
+    format: ["esm", "cjs"],
+    skipNodeModulesBundle: true,
+    dts: true,
+    splitting: true,
+    sourcemap: true,
+    clean: true,
+})