extendsEffectSchema

src/TraitExpression.ts

@@ -1,3 +1,4 @@
+import { Schema as S } from "@effect/schema"
 import { AbstractClass, Class, Simplify } from "type-fest"
 import { Trait, TraitTuple } from "./Trait"
 import { TraitBuilder } from "./TraitBuilder"
@@ -13,14 +14,13 @@ export class TraitExpression<
         readonly traits:      Traits,
     ) {}
 
+
     get extends(): (
         AbstractClass<
             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 +39,48 @@ export class TraitExpression<
         ) as any
     }
 
+    extendsEffectSchema<
+        Fields extends S.Struct.Fields,
+        A, I, R, C,
+        Inherited,
+        Proto,
+    >(
+        this: TraitExpression<
+            S.Class<void, Fields, A, I, R, C, Inherited, Proto>,
+            Traits
+        >
+    ) {
+        return <Self>(): (
+            AbstractClass<
+                InstanceType<
+                    S.Class<Self, Fields, A, I, R, C, Inherited, Proto>
+                > &
+                Simplify<
+                    Extend<TraitTuple.MapImplInstance<Traits>>
+                >,
+
+                ConstructorParameters<S.Class<Self, Fields, A, I, R, C, Inherited, Proto>>
+            > &
+
+            StaticMembers<
+                S.Class<Self, Fields, A, I, R, C, Inherited, Proto>
+            > &
+            Simplify<
+                Extend<TraitTuple.MapImplStaticMembers<Traits>>
+            >
+        ) => this.extends as any
+    }
+
+
     staticImplements(target: StaticImplements<typeof this>, context: any) {}
 
+
     subtrait<
         This extends TraitExpression<typeof TraitExpression.NullSuperclass, any>
     >(
         this: This
     ) {
-        return new TraitBuilder<
-            This,
-
+        return new TraitBuilder<This,
             Simplify<
                 Extend<TraitTuple.MapAbstract<Traits>>
             >,

src/TraitExpressionBuilder.ts

@@ -1,4 +1,4 @@
-import { uniq } from "lodash-es"
+import { unique } from "remeda"
 import { AbstractClass, IsEqual } from "type-fest"
 import { Trait, TraitTuple } from "./Trait"
 import { TraitExpression } from "./TraitExpression"
@@ -49,7 +49,7 @@ export class TraitExpressionBuilder<
     >(
         traits: T
     ) {
-        return uniq(traits) as readonly Trait<any, any, any, any>[] as TraitExpressionBuilder.TraitsUniq<T>
+        return unique(traits) as readonly Trait<any, any, any, any>[] as TraitExpressionBuilder.TraitsUniq<T>
     }