Fixed effect

src/effect/EffectSchemaTraitExpression.ts

@@ -7,10 +7,7 @@ import { Extend } from "../util"
 
 export class EffectSchemaTraitExpression<
     Fields       extends S.Struct.Fields,
-    A,
+    A, I, R, C,
-    I,
-    R,
-    C,
     Inherited    extends object,
     Proto,
     Static       extends object,
@@ -18,12 +15,13 @@ export class EffectSchemaTraitExpression<
     const Traits extends readonly Trait<any, any, any, any>[],
 >
 implements TraitExpressionLike<
-    S.Class<unknown, Fields, A, I, R, C, Inherited, Proto> & Static,
+    S.Class<unknown, Fields, A, I, R, C, Inherited, Proto>,
     Traits
 > {
     constructor(
-        readonly superclass:  S.Class<unknown, Fields, A, I, R, C, Inherited, Proto> & Static,
+        readonly superclass:        S.Class<unknown, Fields, A, I, R, C, Inherited, Proto>,
-        readonly traits:      Traits,
+        readonly superclassStatic:  Static,
+        readonly traits:            Traits,
     ) {}
 
 
@@ -31,10 +29,7 @@ implements TraitExpressionLike<
         S.Class<
             Self,
             Fields,
-            A,
+            A, I, R, C,
-            I,
-            R,
-            C,
             Simplify<
                 Extend<[
                     Inherited,

src/effect/EffectSchemaTraitExpressionBuilder.ts

@@ -1,5 +1,6 @@
 import { Schema as S } from "@effect/schema"
-import { Mutable, Simplify } from "effect/Types"
+import * as Types from "effect/Types"
+import { Simplify } from "type-fest"
 import { Trait, TraitTuple } from "../Trait"
 import { TraitExpression } from "../TraitExpression"
 import { TraitExpressionBuilder } from "../TraitExpressionBuilder"
@@ -19,6 +20,7 @@ export class EffectSchemaInitialTraitExpressionBuilder {
     ) {
         return new EffectSchemaTraitExpressionBuilder(
             S.Class<unknown>(identifier)(fields, annotations),
+            {},
             [],
         )
     }
@@ -33,6 +35,7 @@ export class EffectSchemaInitialTraitExpressionBuilder {
     ) {
         return new EffectSchemaTraitExpressionBuilder(
             S.TaggedClass<unknown>()(tag, fields, annotations),
+            {},
             [],
         )
     }
@@ -41,10 +44,7 @@ export class EffectSchemaInitialTraitExpressionBuilder {
         Super     extends S.Class<any, Fields, A, I, R, C, Inherited, Proto>,
 
         Fields    extends S.Struct.Fields,
-        A,
+        A, I, R, C,
-        I,
-        R,
-        C,
         Inherited extends object,
         Proto,
 
@@ -55,19 +55,22 @@ export class EffectSchemaInitialTraitExpressionBuilder {
         fields:        NewFields,
         annotations?:  S.Annotations.Schema<unknown>,
     ) {
-        return new EffectSchemaTraitExpressionBuilder<
+        return new EffectSchemaTraitExpressionBuilder(
-            Fields & NewFields,
+            superclass.extend<unknown>(identifier)(fields, annotations) as S.Class<
-            Simplify<A & S.Struct.Type<NewFields>>,
+                unknown,
-            Simplify<I & S.Struct.Encoded<NewFields>>,
+                Fields & NewFields,
-            R | S.Struct.Context<NewFields>,
+                Types.Simplify<A & S.Struct.Type<NewFields>>,
-            Simplify<C & S.Struct.Type<NewFields>>,
+                Types.Simplify<I & S.Struct.Encoded<NewFields>>,
-            InstanceType<Super>,
+                R | S.Struct.Context<NewFields>,
-            Proto,
+                Types.Simplify<C & S.Struct.Type<NewFields>>,
-            StaticMembers<Super>,
+                InstanceType<Super>,
+                Proto
+            >,
+
+            {} as Simplify<
+                Omit<StaticMembers<Super>, keyof S.Class<any, Fields, A, I, R, C, Inherited, Proto>>
+            >,
 
-            readonly []
-        >(
-            superclass.extend<unknown>(identifier)(fields, annotations) as any,
             [],
         )
     }
@@ -76,10 +79,7 @@ export class EffectSchemaInitialTraitExpressionBuilder {
 
 export class EffectSchemaTraitExpressionBuilder<
     Fields       extends S.Struct.Fields,
-    A,
+    A, I, R, C,
-    I,
-    R,
-    C,
     Inherited    extends object,
     Proto,
     Static       extends object,
@@ -87,39 +87,42 @@ export class EffectSchemaTraitExpressionBuilder<
     const Traits extends readonly Trait<any, any, any, any>[],
 > {
     constructor(
-        readonly expressionSuperclass:  S.Class<unknown, Fields, A, I, R, C, Inherited, Proto> & Static,
+        readonly expressionSuperclass:        S.Class<unknown, Fields, A, I, R, C, Inherited, Proto>,
-        readonly expressionTraits:      Traits,
+        readonly expressionSuperclassStatic:  Static,
+        readonly expressionTraits:            Traits,
     ) {}
 
 
-    mutable(): EffectSchemaTraitExpressionBuilder<
+    mutable() {
-        Fields,
+        return new EffectSchemaTraitExpressionBuilder(
-        Mutable<A>,
+            this.expressionSuperclass as S.Class<unknown, Fields, Types.Mutable<A>, I, R, C, Inherited, Proto>,
-        I,
+            this.expressionSuperclassStatic,
-        R,
+            this.expressionTraits,
-        C,
+        )
-        Inherited,
-        Proto,
-        Static,
-
-        Traits
-    > {
-        return new EffectSchemaTraitExpressionBuilder(this.expressionSuperclass, this.expressionTraits)
     }
 
-    mutableEncoded(): EffectSchemaTraitExpressionBuilder<
+    immutable() {
-        Fields,
+        return new EffectSchemaTraitExpressionBuilder(
-        A,
+            this.expressionSuperclass as S.Class<unknown, Fields, Readonly<A>, I, R, C, Inherited, Proto>,
-        Mutable<I>,
+            this.expressionSuperclassStatic,
-        R,
+            this.expressionTraits,
-        C,
+        )
-        Inherited,
+    }
-        Proto,
-        Static,
 
-        Traits
+    mutableEncoded() {
-    > {
+        return new EffectSchemaTraitExpressionBuilder(
-        return new EffectSchemaTraitExpressionBuilder(this.expressionSuperclass, this.expressionTraits)
+            this.expressionSuperclass as S.Class<unknown, Fields, A, Readonly<I>, R, C, Inherited, Proto>,
+            this.expressionSuperclassStatic,
+            this.expressionTraits,
+        )
+    }
+
+    immutableEncoded() {
+        return new EffectSchemaTraitExpressionBuilder(
+            this.expressionSuperclass as S.Class<unknown, Fields, A, Types.Mutable<I>, R, C, Inherited, Proto>,
+            this.expressionSuperclassStatic,
+            this.expressionTraits,
+        )
     }
 
 
@@ -135,25 +138,15 @@ export class EffectSchemaTraitExpressionBuilder<
         >[]
     >(
         ...traits: T
-    ): EffectSchemaTraitExpressionBuilder<
+    ) {
-        Fields,
-        A,
-        I,
-        R,
-        C,
-        Inherited,
-        Proto,
-        Static,
-
-        TraitExpressionBuilder.ExpressesReturnTypeTraits<Traits, T>
-    > {
         return new EffectSchemaTraitExpressionBuilder(
             this.expressionSuperclass,
+            this.expressionSuperclassStatic,
 
             traitsUnique([
                 ...this.expressionTraits,
                 ...spreadSupertraits(traits),
-            ]),
+            ]) as TraitExpressionBuilder.ExpressesReturnTypeTraits<Traits, T>,
         )
     }
 
@@ -175,10 +168,7 @@ export class EffectSchemaTraitExpressionBuilder<
                         ? "Type conflict between the traits implementation static members and/or the superclass static members."
                         : EffectSchemaTraitExpression<
                             Fields,
-                            A,
+                            A, I, R, C,
-                            I,
-                            R,
-                            C,
                             Inherited,
                             Proto,
                             Static,
@@ -186,7 +176,11 @@ export class EffectSchemaTraitExpressionBuilder<
                             Traits
                         >
     ) {
-        return new EffectSchemaTraitExpression(this.expressionSuperclass, this.expressionTraits) as any
+        return new EffectSchemaTraitExpression(
+            this.expressionSuperclass,
+            this.expressionSuperclassStatic,
+            this.expressionTraits,
+        ) as any
     }
 }
 

src/effect/tests.ts

@@ -1,6 +1,26 @@
 import { Schema as S } from "@effect/schema"
 import { Implements } from "../TraitExpression"
 import { effectSchemaExpression } from "./EffectSchemaTraitExpressionBuilder"
+import { StaticMembers } from "../util"
+import { Trait } from "../Trait"
+import { EffectSchemaTraitExpression } from "./EffectSchemaTraitExpression"
+
+
+type Extr<T> =
+    T extends EffectSchemaTraitExpression<
+    infer Fields,
+    infer A,
+    infer I,
+    infer R,
+    infer C,
+    infer Inherited,
+    infer Proto,
+    infer Static,
+
+    infer Traits
+    >
+        ? Static
+        : never
 
 
 const userExp = effectSchemaExpression
@@ -27,11 +47,15 @@ const adminExp = effectSchemaExpression
     .extends(User, "User", {
         role: S.Literal("Admin")
     })
+    .immutable()
     .build()
 
+adminExp.superclass
+type T = Extr<typeof adminExp>
+
 @adminExp.staticImplements
 class Admin extends adminExp.extends<Admin>() implements Implements<typeof adminExp> {
 }
 
 const admin = new Admin({ id: 1n, role: "Admin" })
-// admin.id = 1n
+// admin.role = "Admin"