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.4",
+  "version": "0.1.24",
   "type": "module",
   "publishConfig": {
     "registry": "https://git.jvalver.de/api/packages/thilawyn/npm/"
@@ -8,40 +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": {
-    "hotscript": "^1.0.13",
-    "lodash-es": "^4.17.21",
-    "type-fest": "^4.10.2"
+    "remeda": "^1.61.0",
+    "type-fest": "^4.18.2"
   },
   "devDependencies": {
-    "@rollup/plugin-node-resolve": "^15.2.3",
-    "@types/lodash-es": "^4.17.12",
     "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,43 +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 const createBundleConfig = (
-    input:  string,
-    name:   keyof typeof pkg.exports,
-) => (
-    defineConfig({
-        input,
-
-        output: [
-            {
-                file:    pkg.exports[name].import.default,
-                format:  "esm",
-            },
-            {
-                file:    pkg.exports[name].require.default,
-                format:  "cjs",
-            },
-        ],
-
-        external: id => !/^[./]/.test(id),
-
-        plugins: [
-            nodeResolve(),
-            ts(),
-
-            cleanup({
-                comments: "jsdoc",
-                extensions: ["ts"],
-            }),
-        ],
-    })
-)
-
-
-export default [
-    createBundleConfig("src/lib.ts", "."),
-]

src/Trait.ts

@@ -1,22 +1,22 @@
-import { AbstractClass, Class, Simplify } from "type-fest"
+import { AbstractConstructor, Constructor, Simplify } from "type-fest"
 import { TraitExpression } from "./TraitExpression"
-import { Extend, StaticMembers as StaticMembersUtil } from "./util"
+import { Extend, StaticMembers } from "./util"
 
 
 export class Trait<
     SuperExpression extends TraitExpression<
         typeof TraitExpression.NullSuperclass,
-        Trait<any, any, any, any>[]
+        readonly Trait<any, any, any, any>[]
     >,
     Abstract        extends object,
     StaticAbstract  extends object,
-    ImplClass       extends AbstractClass<object, []>,
+    ImplClass       extends AbstractConstructor<object, []>,
 > {
     constructor(
         readonly superExpression:  SuperExpression,
         readonly abstract:         Abstract,
         readonly staticAbstract:   StaticAbstract,
-        readonly apply:            (Super: AbstractClass<object>) => ImplClass,
+        readonly apply:            (Super: AbstractConstructor<object>) => ImplClass,
     ) {}
 }
 
@@ -54,7 +54,7 @@ export namespace Trait {
     )
 
     export type ImplStaticMembers<T> = (
-        StaticMembersUtil<Trait.ImplClass<T>>
+        StaticMembers<Trait.ImplClass<T>>
     )
 
     export type Instance<T> = (
@@ -64,7 +64,7 @@ export namespace Trait {
         ]>
     )
 
-    export type StaticMembers<T> = (
+    export type Static<T> = (
         Extend<[
             Trait.StaticAbstract<T>,
             Trait.ImplStaticMembers<T>,
@@ -74,56 +74,56 @@ export namespace Trait {
 
 export namespace TraitTuple {
     export type MapAbstract<T> = {
-        [K in keyof T]: K extends keyof []
+        [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 []
+        [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 []
+        [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 []
+        [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 []
+        [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 []
+        [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 []
+        [K in keyof T]: K extends keyof readonly []
             ? T[K]
-            : Trait.StaticMembers<T[K]>
+            : Trait.Static<T[K]>
     }
 }
 
 
 export type TraitClass<T extends Trait<any, any, any, any>> = (
-    AbstractClass<TraitInstance<T>, any[]> &
+    AbstractConstructor<TraitInstance<T>, any[]> &
     TraitStaticMembers<T>
 )
 
 export type TraitConcreteClass<T extends Trait<any, any, any, any>> = (
-    Class<TraitInstance<T>, any[]> &
+    Constructor<TraitInstance<T>, any[]> &
     TraitStaticMembers<T>
 )
 
@@ -132,5 +132,5 @@ export type TraitInstance<T extends Trait<any, any, any, any>> = (
 )
 
 export type TraitStaticMembers<T extends Trait<any, any, any, any>> = (
-    Simplify<Trait.StaticMembers<T>>
+    Simplify<Trait.Static<T>>
 )

src/TraitBuilder.ts

@@ -1,10 +1,105 @@
-import { AbstractClass, Simplify } from "type-fest"
+import { AbstractConstructor, Constructor, Simplify } from "type-fest"
 import { Trait } from "./Trait"
 import { TraitExpression } from "./TraitExpression"
-import { Extend, StaticMembers } from "./util"
+import { Extend, StaticMembers, type } from "./util"
 
 
-type ImplSuper<This> = (
+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,
@@ -12,7 +107,7 @@ type ImplSuper<This> = (
             infer ImplClass
         >
             ? (
-            AbstractClass<
+                AbstractConstructor<
                     Simplify<
                         Extend<[
                             Abstract,
@@ -27,93 +122,59 @@ type ImplSuper<This> = (
                         StaticMembers<ImplClass>,
                     ]>
                 > &
-            { readonly _tag: "@thilawyn/traitify-ts/Super" }  // TODO: replace with unique symbol?
+                { readonly [implSuperSymbol]: true }
             )
             : never
     )
-
-
-export class TraitBuilder<
-    SuperExpression extends TraitExpression<
-        typeof TraitExpression.NullSuperclass,
-        Trait<any, any, any, any>[]
-    >,
-    Abstract        extends object,
-    StaticAbstract  extends object,
-    ImplClass       extends AbstractClass<object, []>,
-> {
-    constructor(
-        private readonly traitSuperExpression:  SuperExpression,
-        private readonly traitAbstract:         Abstract,
-        private readonly traitStaticAbstract:   StaticAbstract,
-        private readonly traitApply:            (Super: AbstractClass<object>) => ImplClass,
-    ) {}
-
-    abstract<A extends Abstract>(
-        _: (Super: AbstractClass<Abstract>) => AbstractClass<A, []>
-    ) {
-        return new TraitBuilder(
-            this.traitSuperExpression,
-            {} as Simplify<A>,
-            this.traitStaticAbstract,
-            this.traitApply,
-        )
 }
 
-    staticAbstract<A extends StaticAbstract>(
-        _: (Super: AbstractClass<StaticAbstract>) => AbstractClass<A, []>
-    ) {
-        return new TraitBuilder(
-            this.traitSuperExpression,
-            this.traitAbstract,
-            {} as Simplify<A>,
-            this.traitApply,
-        )
-    }
 
-    implement<
-        ImplClassWithAbstract extends ImplSuper<typeof this>
+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>,
 >(
-        apply: (Super: ImplSuper<typeof this>) => ImplClassWithAbstract
+    _Impl:    ImplClass,
+    thisArg:  This,
 ) {
-        return new TraitBuilder(
-            this.traitSuperExpression,
-            this.traitAbstract,
-            this.traitStaticAbstract,
-
-            apply as unknown as (Super: AbstractClass<object>) => (
-                AbstractClass<
-                    Simplify<
-                        Omit<
-                            InstanceType<ImplClassWithAbstract>,
-                            keyof Abstract
-                        >
-                    >
+    return thisArg as unknown as (
+        AbstractConstructor<
+            InstanceType<ImplClass> & InstanceType<This>,
+            ConstructorParameters<This>
         > &
-
-                Simplify<
-                    Omit<
-                        StaticMembers<ImplClassWithAbstract>,
-                        keyof StaticAbstract | "_tag"
-                    >
-                >
-            ),
+        ImplStatic<ImplClass> &
+        StaticMembers<This>
     )
 }
 
-    build() {
-        return new Trait(
-            this.traitSuperExpression,
-            this.traitAbstract,
-            this.traitStaticAbstract,
-            this.traitApply,
+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 object,
-    {} as object,
-    Super => class extends Super {} as AbstractClass<object>,
+    {} as {},
+    {} as {},
+    Super => class extends Super {} as AbstractConstructor<{}>,
 )

src/TraitExpression.ts

@@ -1,26 +1,35 @@
-import { AbstractClass, Class, Simplify } from "type-fest"
+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 AbstractClass<object>,
-    const Traits extends Trait<any, any, any, any>[],
-> {
+    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(): (
-        AbstractClass<
+        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>
-                >
+                Extend<TraitTuple.MapImplInstance<Traits>>
             >,
 
             ConstructorParameters<Superclass>
@@ -39,16 +48,20 @@ export class TraitExpression<
         ) as any
     }
 
-    implementsStatic(target: ImplementsStatic<typeof this>, context: 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,
-
+        return new TraitBuilder<This,
             Simplify<
                 Extend<TraitTuple.MapAbstract<Traits>>
             >,
@@ -56,7 +69,7 @@ export class TraitExpression<
                 Extend<TraitTuple.MapStaticAbstract<Traits>>
             >,
 
-            AbstractClass<
+            AbstractConstructor<
                 Simplify<
                     Extend<TraitTuple.MapImplInstance<Traits>>
                 >
@@ -74,19 +87,20 @@ export class TraitExpression<
 }
 
 export namespace TraitExpression {
+    const nullSuperclassSymbol = Symbol()
     export class NullSuperclass {
-        static readonly _tag = "@thilawyn/traitify-ts/TraitExpression.NullSuperclass"
-        constructor(...args: any[]) {}
+        static readonly [nullSuperclassSymbol]: true
+        constructor(..._args: any[]) {}
     }
 
     export type Superclass<T> = (
-        T extends TraitExpression<infer Superclass, any>
+        T extends TraitExpressionLike<infer Superclass, any>
             ? Superclass
             : never
     )
 
     export type Traits<T> = (
-        T extends TraitExpression<any, infer Traits>
+        T extends TraitExpressionLike<any, infer Traits>
             ? Traits
             : never
     )
@@ -94,7 +108,7 @@ export namespace TraitExpression {
 
 
 export type Implements<
-    Exp extends TraitExpression<any, Trait<any, any, any, any>[]>
+    Exp extends TraitExpressionLike<any, readonly Trait<any, any, any, any>[]>
 > = (
     Simplify<
         Extend<
@@ -105,8 +119,8 @@ export type Implements<
     >
 )
 
-export type ImplementsStatic<
-    Exp extends TraitExpression<any, Trait<any, any, any, any>[]>
+export type StaticImplements<
+    Exp extends TraitExpressionLike<any, readonly Trait<any, any, any, any>[]>
 > = (
     Simplify<
         Extend<
@@ -119,19 +133,19 @@ export type ImplementsStatic<
 
 
 export type TraitExpressionClass<
-    Exp extends TraitExpression<any, Trait<any, any, any, any>[]>
+    Exp extends TraitExpressionLike<any, readonly Trait<any, any, any, any>[]>
 > = (
-    AbstractClass<
+    AbstractConstructor<
         TraitExpressionInstance<Exp>,
         ConstructorParameters<TraitExpression.Superclass<Exp>>
     > &
     TraitExpressionStaticMembers<Exp>
 )
 
-export type TraitExpressionConcreteClass<
-    Exp extends TraitExpression<any, Trait<any, any, any, any>[]>
+export type TraitExpressionInstantiableClass<
+    Exp extends TraitExpressionLike<any, readonly Trait<any, any, any, any>[]>
 > = (
-    Class<
+    Constructor<
         TraitExpressionInstance<Exp>,
         ConstructorParameters<TraitExpression.Superclass<Exp>>
     > &
@@ -139,7 +153,7 @@ export type TraitExpressionConcreteClass<
 )
 
 export type TraitExpressionInstance<
-    Exp extends TraitExpression<any, Trait<any, any, any, any>[]>
+    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
@@ -151,7 +165,7 @@ export type TraitExpressionInstance<
 )
 
 export type TraitExpressionStaticMembers<
-    Exp extends TraitExpression<any, Trait<any, any, any, any>[]>
+    Exp extends TraitExpressionLike<any, readonly Trait<any, any, any, any>[]>
 > = (
     Simplify<
         Extend<[

src/TraitExpressionBuilder.ts

@@ -1,64 +1,23 @@
-import { uniq } from "lodash-es"
-import { AbstractClass } from "type-fest"
+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"
 
 
-type SpreadSupertraits<T> = (
-    T extends [infer Trait, ...infer Rest]
-        ? [
-            ...Trait.Supertraits<Trait>,
-            Trait,
-            ...SpreadSupertraits<Rest>,
-        ]
-        : []
-)
-
-
-type InstanceExtendable<
-    Superclass extends AbstractClass<object>,
-    Traits     extends Trait<any, any, any, any>[],
-> = (
-    Extendable<[
-        InstanceType<Superclass>,
-        ...TraitTuple.MapInstance<Traits>,
-    ]>
-)
-
-type StaticMembersExtendable<
-    Superclass extends AbstractClass<object>,
-    Traits     extends Trait<any, any, any, any>[],
-> = (
-    Extendable<[
-        StaticMembers<Superclass>,
-        ...TraitTuple.MapStaticMembers<Traits>,
-    ]>
-)
-
-type BuildTraitExpression<
-    Superclass extends AbstractClass<object>,
-    Traits     extends Trait<any, any, any, any>[],
-> = (
-    InstanceExtendable<Superclass, Traits> extends false
-        ? "Type conflict on the instance side."
-        : StaticMembersExtendable<Superclass, Traits> extends false
-            ? "Type conflict on the static side."
-            : TraitExpression<Superclass, Traits>
-)
-
-
-class TraitExpressionBuilder<
-    Superclass   extends AbstractClass<object>,
-    const Traits extends Trait<any, any, any, any>[],
+export class TraitExpressionBuilder<
+    Superclass   extends AbstractConstructor<object>,
+    const Traits extends readonly Trait<any, any, any, any>[],
 > {
     constructor(
-        private readonly expressionSuperclass:  Superclass,
-        private readonly expressionTraits:      Traits,
+        readonly expressionSuperclass:  Superclass,
+        readonly expressionTraits:      Traits,
     ) {}
 
+
     extends<
-        Super extends AbstractClass<object>
+        Super extends AbstractConstructor<object>
     >(
         superclass: Super
     ) {
@@ -69,10 +28,10 @@ class TraitExpressionBuilder<
     }
 
     expresses<
-        const T extends Trait<
+        const T extends readonly Trait<
             TraitExpression<
                 typeof TraitExpression.NullSuperclass,
-                Trait<any, any, any, any>[]
+                readonly Trait<any, any, any, any>[]
             >,
             any,
             any,
@@ -80,30 +39,112 @@ class TraitExpressionBuilder<
         >[]
     >(
         ...traits: T
-    ) {
+    ): TraitExpressionBuilder<
+        Superclass,
+        TraitExpressionBuilder.ExpressesReturnTypeTraits<Traits, T>
+    > {
         return new TraitExpressionBuilder(
             this.expressionSuperclass,
 
-            uniq([
+            traitsUnique([
                 ...this.expressionTraits,
-                ...traits.flatMap(trait => [
-                    ...trait.superExpression.traits,
-                    trait,
+                ...spreadSupertraits(traits),
             ]),
-            ]) as [...Traits, ...SpreadSupertraits<T>],
         )
     }
 
+    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 BuildTraitExpression<Superclass, Traits>
+        ) 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/lib.ts

@@ -1,4 +1,5 @@
 export { Trait, TraitClass, TraitConcreteClass, TraitInstance, TraitStaticMembers, TraitTuple } from "./Trait"
-export { TraitBuilder, trait } from "./TraitBuilder"
-export { Implements, ImplementsStatic, TraitExpression, TraitExpressionClass, TraitExpressionConcreteClass, TraitExpressionInstance, TraitExpressionStaticMembers } from "./TraitExpression"
-export { expression } from "./TraitExpressionBuilder"
+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,7 +1,8 @@
 import { TraitClass } from "./Trait"
 import { trait } from "./TraitBuilder"
-import { Implements, ImplementsStatic, TraitExpressionClass } from "./TraitExpression"
+import { Implements, StaticImplements, TraitExpressionClass } from "./TraitExpression"
 import { expression } from "./TraitExpressionBuilder"
+import { type } from "./util"
 
 
 const PrintsHelloOnNew = trait
@@ -18,9 +19,12 @@ const PrintsHelloOnNew = trait
 type PrintsHelloOnNewClass = TraitClass<typeof PrintsHelloOnNew>
 
 const Identifiable = <ID>() => trait
-    .abstract(Super => class extends Super {
-        declare readonly id: ID
-    })
+    // .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
@@ -28,6 +32,15 @@ const Identifiable = <ID>() => trait
     })
     .build()
 
+const ImplementsIdentifiable = <ID>(defaultID: ID) => expression
+    .expresses(Identifiable<ID>())
+    .build()
+    .subtrait()
+        .implement(Super => class ImplementsIdentifiable extends Super {
+            readonly id = defaultID
+        })
+        .build()
+
 const StatefulSubscription = trait
     .abstract(Super => class extends Super {
         declare readonly isStatefulSubscription: true
@@ -64,15 +77,16 @@ const exp = expression
         PrintsHelloOnNew,
         Identifiable<bigint>(),
         // Identifiable<number>(),
+        // StatefulSubscription,
         ActiveStatefulSubscription,
     )
     .build()
 
 type Abs = Implements<typeof exp>
-type AbsStatic = ImplementsStatic<typeof exp>
+type AbsStatic = StaticImplements<typeof exp>
 type ExpClass = TraitExpressionClass<typeof exp>
 
-@exp.implementsStatic
+@exp.staticImplements
 class User extends exp.extends implements Implements<typeof exp> {
     readonly isStatefulSubscription: true = true
     readonly isActiveStatefulSubscription: true = true
@@ -81,9 +95,3 @@ class User extends exp.extends implements Implements<typeof exp> {
 }
 
 console.log(new User())
-
-
-// type T = NonExtendableKeys<[
-//     { prout: "gneugneu" },
-//     { prout: string },
-// ]>

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/extend.ts

@@ -20,31 +20,32 @@ import { CommonKeys } from "."
 // ]>
 
 
+// TODO: use OverrideProperties from type-fest?
 export type Extend<T extends readonly object[]> = (
-    T extends [
+    T extends readonly [
         infer Super,
         infer Self,
-        ...infer Rest extends object[],
+        ...infer Rest extends readonly object[],
     ]
         ? Pick<Self, CommonKeys<Self, Super>> extends Pick<Super, CommonKeys<Self, Super>>
-            ? Extend<[
+            ? Extend<readonly [
                 Omit<Super, CommonKeys<Self, Super>> & Self,
                 ...Rest,
             ]>
             : never
-        : T extends [infer Self]
+        : T extends readonly [infer Self]
             ? Self
             : {}
 )
 
 export type Extendable<T extends readonly object[]> = (
-    T extends [
+    T extends readonly [
         infer Super,
         infer Self,
-        ...infer Rest extends object[],
+        ...infer Rest extends readonly object[],
     ]
         ? Pick<Self, CommonKeys<Self, Super>> extends Pick<Super, CommonKeys<Self, Super>>
-            ? Extendable<[
+            ? Extendable<readonly [
                 Omit<Super, CommonKeys<Self, Super>> & Self,
                 ...Rest,
             ]>
@@ -53,16 +54,16 @@ export type Extendable<T extends readonly object[]> = (
 )
 
 export type NonExtendableKeys<T extends readonly object[]> = (
-    T extends [
+    T extends readonly [
         infer Super   extends object,
         infer Self    extends object,
-        ...infer Rest 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<[
+        | NonExtendableKeys<readonly [
             Super & Self,
             ...Rest,
         ]>

src/util/misc.ts

@@ -1,5 +1,4 @@
-import { Fn } from "hotscript"
-import { AbstractClass, Simplify } from "type-fest"
+import { AbstractConstructor } from "type-fest"
 
 
 /**
@@ -9,17 +8,10 @@ import { AbstractClass, Simplify } from "type-fest"
  */
 export type CommonKeys<A, B> = Extract<keyof A, keyof B>
 
-export interface SimplifyFn extends Fn {
-    return: Simplify<this["arg0"]>
-}
-
 /**
  * Represents the static members of a class.
- * @template Class - A class extending AbstractClass.
+ * @template Class - A class.
  */
-export type StaticMembers<Class extends AbstractClass<any>> = (
-    Omit<Class, "prototype">
-)
-export interface StaticMembersFn extends Fn {
-    return: StaticMembers<this["arg0"]>
-}
+export type StaticMembers<Class extends AbstractConstructor<any>> = Omit<Class, "prototype">
+
+export function type<T>() { return {} as T }

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,
+})