Refactor

packages/effect-lens/src/Lens.ts

@@ -90,20 +90,56 @@ extends Pipeable.Class() implements Lens<A, ER, EW, RR, RW> {
     abstract readonly withLock: <A1, E1, R1>(self: Effect.Effect<A1, E1, R1>) => Effect.Effect<A1, EW | E1, RW | R1>
 
     get get(): Effect.Effect<A, ER, RR> {
-        return this.sourceGet
+        let effect: Effect.Effect<unknown, unknown, unknown> = this.sourceGet
+        for (const step of this.steps) {
+            effect = step.transform(effect as never)
+        }
+        return effect as Effect.Effect<A, ER, RR>
     }
 
     get changes(): Stream.Stream<A, ER, RR> {
-        return this.sourceChanges
+        let stream: Stream.Stream<unknown, unknown, unknown> = this.sourceChanges
+        for (const step of this.steps) {
+            stream = step.transformStream(stream as never)
+        }
+        return stream as Stream.Stream<A, ER, RR>
     }
 
-    modifyEffect<B, E1 = never, R1 = never>(
+    modifyEffect<C, E1 = never, R1 = never>(
-        f: (a: A) => Effect.Effect<readonly [B, A], E1, R1>,
+        f: (a: A) => Effect.Effect<readonly [C, A], E1, R1>,
-    ): Effect.Effect<B, ER | EW | E1, RR | RW | R1> {
+    ): Effect.Effect<C, ER | EW | E1, RR | RW | R1> {
         return this.withLock(Effect.flatMap(
-            this.get,
+            this.sourceGet,
-            a => Effect.flatMap(f(a), ([b, next]) => Effect.as(this.sourceCommit(next), b),
+            source => {
-        )))
+                const parents: unknown[] = []
+                let current: Effect.Effect<unknown, unknown, unknown> = Effect.succeed(source)
+
+                for (const step of this.steps) {
+                    current = Effect.flatMap(current, parent => {
+                        parents.push(parent)
+                        return step.transform(Effect.succeed(parent) as never)
+                    })
+                }
+
+                return Effect.flatMap(current, a => Effect.flatMap(
+                    f(a as A),
+                    ([c, next]) => {
+                        let rebuilt: Effect.Effect<unknown, unknown, unknown> = Effect.succeed(next)
+
+                        for (let i = this.steps.length - 1; i >= 0; i--) {
+                            const step = this.steps[i]!
+                            const parent = parents[i]!
+                            rebuilt = step.update(rebuilt as never, parent as never)
+                        }
+
+                        return Effect.as(
+                            Effect.flatMap(rebuilt, b => this.sourceCommit(b as B)),
+                            c,
+                        )
+                    },
+                ))
+            },
+        )) as Effect.Effect<C, ER | EW | E1, RR | RW | R1>
     }
 }