diff --git a/bun.lockb b/bun.lockb
index 7e6b681..d14c997 100755
Binary files a/bun.lockb and b/bun.lockb differ
diff --git a/package.json b/package.json
index 946a334..53eb38b 100644
--- a/package.json
+++ b/package.json
@@ -29,16 +29,20 @@
     "clean:node": "rm -rf node_modules"
   },
   "dependencies": {
-    "lodash-es": "^4.17.21",
-    "type-fest": "^4.14.0"
+    "remeda": "^1.61.0",
+    "type-fest": "^4.18.0"
   },
   "devDependencies": {
     "@types/lodash-es": "^4.17.12",
     "bun-types": "latest",
-    "npm-check-updates": "^16.14.17",
+    "npm-check-updates": "^16.14.20",
     "npm-sort": "^0.0.4",
     "tsup": "^8.0.2",
-    "tsx": "^4.7.1",
-    "typescript": "^5.4.3"
+    "tsx": "^4.7.3",
+    "typescript": "^5.4.5"
+  },
+  "optionalDependencies": {
+    "@effect/schema": "^0.66.12",
+    "effect": "^3.1.0"
   }
 }
diff --git a/src/TraitExpression.ts b/src/TraitExpression.ts
index 44367d0..26a7ab1 100644
--- a/src/TraitExpression.ts
+++ b/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>>
             >,
diff --git a/src/TraitExpressionBuilder.ts b/src/TraitExpressionBuilder.ts
index 60335c9..8e28338 100644
--- a/src/TraitExpressionBuilder.ts
+++ b/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>
     }