packages/effect-lens/src/Lens.ts

@@ -61,6 +61,16 @@ export const isLensStep = (u: unknown): u is LensStep<unknown, unknown, unknown,
 export const LensImplTypeId: unique symbol = Symbol.for("@effect-fc/Lens/LensImpl")
 export type LensImplTypeId = typeof LensImplTypeId
 
+export const isLensImpl = (u: unknown): u is LensImpl<unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown> => Predicate.hasProperty(u, LensImplTypeId)
+
+export const asLensImpl = <A, ER, EW, RR, RW>(
+    lens: Lens<A, ER, EW, RR, RW>
+): LensImpl<A, unknown, ER, unknown, EW, unknown, RR, unknown, RW, unknown> => {
+    if (!isLensImpl(lens))
+        throw new Error("Not a 'LensImpl'.")
+    return lens as LensImpl<A, unknown, ER, unknown, EW, unknown, RR, unknown, RW, unknown>
+}
+
 export abstract class LensImpl<
     in out A,
     in out B,
@@ -86,7 +96,7 @@ extends Pipeable.Class() implements Lens<A, ER, EW, RR, RW> {
     abstract sourceCommit(b: B): Effect.Effect<void, ESW, RSW>
     abstract readonly withLock: <A1, E1, R1>(self: Effect.Effect<A1, E1, R1>) => Effect.Effect<A1, EW | E1, RW | R1>
 
-    private get access(): Effect.Effect<LensFrame<A, EW, RW>, ER, RR> {
+    get access(): Effect.Effect<LensFrame<A, EW, RW>, ER, RR> {
         let effect: Effect.Effect<LensFrame<unknown, unknown, unknown>, unknown, unknown> = Effect.map(
             this.sourceGet,
             value => ({
@@ -160,19 +170,12 @@ extends LensImpl<A, B, ER, ESR, EW, ESW, RR, RSR, RW, RSW> {
     get withLock() { return this.source.withLock }
 }
 
-/**
- * Creates a `Lens` by supplying how to read the current value, observe changes, and apply transformations.
- */
-// export const make = <A, ER, EW, RR, RW>(
-//     source: LensImpl.Source<A, ER, EW, RR, RW>
-// ): Lens<A, ER, EW, RR, RW> => new LensImpl(source)
-
 /**
  * Creates a `Lens` by supplying how to read the current value, observe changes, and apply transformations.
  */
 export const makeLazy = <B, ESW, ESR, RSR, RSW>(
     source: LensLazyImpl.Source<B, ESW, ESR, RSR, RSW>
-): Lens<B, ESW, ESR, RSR, RSW> => new LensLazyImpl(source)
+): Lens<B, ESR, ESW, RSR, RSW> => new LensLazyImpl(source)
 
 /**
  * Derives a new `Lens` by immutably appending a step to an existing `LensImpl`.
@@ -285,13 +288,14 @@ export const fromSubscriptionRef = <A>(
  */
 export const unwrap = <A, ER, EW, RR, RW, E1, R1>(
     effect: Effect.Effect<Lens<A, ER, EW, RR, RW>, E1, R1>
-): Lens<A, ER | E1, EW | E1, RR | R1, RW | R1> => make({
+): Lens<A, ER | E1, ER | EW | E1, RR | R1, RR | RW | R1> => makeLazy<A, ER | EW | E1, ER | E1, RR | R1, RR | RW | R1>({
-    get: Effect.flatMap(effect, l => l.get),
+    sourceGet: Effect.flatMap(effect, l => l.get),
-    changes: Stream.unwrap(Effect.map(effect, l => l.changes)),
+    sourceChanges: Stream.unwrap(Effect.map(effect, l => l.changes)),
-    update: a => Effect.flatMap(effect, l => asLensWithInternals(l).update(a)),
+    sourceCommit: a => Effect.flatMap(
-    withLock: <A2, E2, R2>(
+        effect,
-        effect2: Effect.Effect<A2, E2, R2>
+        l => Effect.flatMap(asLensImpl(l).access, frame => frame.commit(Effect.succeed(a))),
-    ) => Effect.flatMap(effect, l => asLensWithInternals(l).withLock(effect2)),
+    ),
+    withLock: identity,
 })
 
 /**
@@ -311,12 +315,11 @@ export const map: {
     self: Lens<A, ER, EW, RR, RW>,
     get: (a: NoInfer<A>) => B,
     update: (a: NoInfer<A>, b: B) => NoInfer<A>,
-): Lens<B, ER, EW, RR, RW> => makeLazy({
+): Lens<B, ER, EW, RR, RW> => mapEffect(
-    get get() { return Effect.map(self.get, get) },
+    self,
-    get changes() { return Stream.map(self.changes, get) },
+    a => Effect.succeed(get(a)),
-    update(a: A) { return  },
+    (a, b) => Effect.succeed(update(a, b)),
-    get withLock() { return asLensWithInternals(self).withLock },
+))
-}))
 
 /**
  * Derives a new `Lens` by applying effectful getters and setters over the focused value.
@@ -335,22 +338,25 @@ export const mapEffect: {
     self: Lens<A, ER, EW, RR, RW>,
     get: (a: NoInfer<A>) => Effect.Effect<B, EGet, RGet>,
     set: (a: NoInfer<A>, b: B) => Effect.Effect<NoInfer<A>, ESet, RSet>,
-): Lens<B, ER | EGet, EW | ESet, RR | RGet, RW | RSet> => make({
+): Lens<B, ER | EGet, EW | ESet, RR | RGet, RW | RSet> => {
-    get get() { return Effect.flatMap(self.get, get) },
+    return derive(
-    get changes() { return Stream.mapEffect(self.changes, get) },
+        asLensImpl(self),
-    modify: <C, E1 = never, R1 = never>(
+        {
-        f: (b: B) => Effect.Effect<readonly [C, B], E1, R1>
+            [LensStepTypeId]: LensStepTypeId,
-    ) => self.modify(a => Effect.flatMap(
+            access: parent => Effect.flatMap(
-        get(a),
+                parent,
-        b => Effect.flatMap(
+                frame => Effect.map(
-            f(b),
+                    get(frame.value),
-            ([c, bNext]) => Effect.flatMap(
+                    value => ({
-                set(a, bNext),
+                        value,
-                nextA => Effect.succeed([c, nextA] as const),
+                        commit: next => frame.commit(Effect.flatMap(next, b => set(frame.value, b))),
+                    }),
                 ),
+            ),
+            transformStream: stream => Stream.mapEffect(stream, get),
+        },
     )
-    )),
+})
-}))
 
 /**
  * Derives a new `Lens` by applying synchronous getters and setters over the value inside an `Option`.
@@ -432,11 +438,11 @@ export const mapStream: {
 } = Function.dual(2, <A, ER, EW, RR, RW>(
     self: Lens<A, ER, EW, RR, RW>,
     f: (changes: Stream.Stream<NoInfer<A>, NoInfer<ER>, NoInfer<RR>>) => Stream.Stream<NoInfer<A>, NoInfer<ER>, NoInfer<RR>>,
-): Lens<A, ER, EW, RR, RW> => make({
+): Lens<A, ER, EW, RR, RW> => derive(asLensImpl(self), {
-    get get() { return self.get },
+    [LensStepTypeId]: LensStepTypeId,
-    get changes() { return f(self.changes) },
+    access: parent => parent,
-    get modify() { return self.modify },
+    transformStream: f,
-}))
+} as LensStep<A, A, ER, ER, EW, EW, RR, RR, RW, RW>))
 
 
 /**
@@ -455,11 +461,11 @@ export const mapErrorRead: {
 } = Function.dual(2, <A, ER, EW, RR, RW, E2>(
     self: Lens<A, ER, EW, RR, RW>,
     f: (error: NoInfer<ER>) => E2,
-): Lens<A, E2, EW, RR, RW> => make({
+): Lens<A, E2, EW, RR, RW> => derive(asLensImpl(self), {
-    get get() { return Effect.mapError(self.get, f) },
+    [LensStepTypeId]: LensStepTypeId,
-    get changes() { return Stream.mapError(self.changes, f) },
+    access: parent => Effect.mapError(parent, f),
-    get modify() { return self.modify as any },
+    transformStream: stream => Stream.mapError(stream, f),
-}))
+} as LensStep<A, A, E2, ER, EW, EW, RR, RR, RW, RW>))
 
 /**
  * Transforms modify errors of a `Lens`.
@@ -478,13 +484,14 @@ export const mapErrorWrite: {
 } = Function.dual(2, <A, ER, EW, RR, RW, E2>(
     self: Lens<A, ER, EW, RR, RW>,
     f: (error: unknown) => E2,
-): Lens<A, ER, E2, RR, RW> => make({
+): Lens<A, ER, E2, RR, RW> => derive(asLensImpl(self), {
-    get get() { return self.get },
+    [LensStepTypeId]: LensStepTypeId,
-    get changes() { return self.changes },
+    access: parent => Effect.map(parent, frame => ({
-    modify: <B, E1 = never, R1 = never>(
+        value: frame.value,
-        g: (a: A) => Effect.Effect<readonly [B, A], E1, R1>
+        commit: next => Effect.mapError(frame.commit(next), f),
-    ) => Effect.mapError(self.modify(g), f),
+    })),
-}))
+    transformStream: stream => stream,
+} as LensStep<A, A, ER, ER, E2, EW, RR, RR, RW, RW>))
 
 /**
  * Transforms all errors of a `Lens`.
@@ -503,13 +510,17 @@ export const mapError: {
 } = Function.dual(2, <A, ER, EW, RR, RW, E2>(
     self: Lens<A, ER, EW, RR, RW>,
     f: (error: unknown) => E2,
-): Lens<A, E2, E2, RR, RW> => make({
+): Lens<A, E2, E2, RR, RW> => derive(asLensImpl(self), {
-    get get() { return Effect.mapError(self.get, f) },
+    [LensStepTypeId]: LensStepTypeId,
-    get changes() { return Stream.mapError(self.changes, f) },
+    access: parent => Effect.map(
-    modify: <B, E1 = never, R1 = never>(
+        Effect.mapError(parent, f),
-        g: (a: A) => Effect.Effect<readonly [B, A], E1, R1>
+        frame => ({
-    ) => Effect.mapError(self.modify(g), f),
+            value: frame.value,
-}))
+            commit: next => Effect.mapError(frame.commit(next), f),
+        }),
+    ),
+    transformStream: stream => Stream.mapError(stream, f),
+} as LensStep<A, A, E2, ER, E2, EW, RR, RR, RW, RW>))
 
 /**
  * Recovers from read failures of a `Lens`.
@@ -527,11 +538,11 @@ export const catchAllRead: {
 } = Function.dual(2, <A, ER, EW, RR, RW, E2, R2>(
     self: Lens<A, ER, EW, RR, RW>,
     f: (error: NoInfer<ER>) => Subscribable.Subscribable<A, E2, R2>,
-): Lens<A, E2, EW, RR | R2, RW> => make({
+): Lens<A, E2, EW, RR | R2, RW> => derive(asLensImpl(self), {
-    get get() { return Effect.catchAll(self.get, error => f(error).get) },
+    [LensStepTypeId]: LensStepTypeId,
-    get changes() { return Stream.catchAll(self.changes, error => f(error).changes) },
+    access: parent => Effect.catchAll(parent, error => asLensImpl(f(error) as Lens<A, E2, EW, R2, RW>).access),
-    get modify() { return self.modify as any },
+    transformStream: stream => Stream.catchAll(stream, error => f(error).changes),
-}))
+} as LensStep<A, A, E2, ER, EW, EW, RR | R2, RR, RW, RW>))
 
 /**
  * Runs an effect when read failures occur.
@@ -549,11 +560,11 @@ export const tapErrorRead: {
 } = Function.dual(2, <A, ER, EW, RR, RW, E2, R2>(
     self: Lens<A, ER, EW, RR, RW>,
     f: (error: NoInfer<ER>) => Effect.Effect<any, E2, R2>,
-): Lens<A, ER | E2, EW, RR | R2, RW> => make({
+): Lens<A, ER | E2, EW, RR | R2, RW> => derive(asLensImpl(self), {
-    get get() { return Effect.tapError(self.get, f) },
+    [LensStepTypeId]: LensStepTypeId,
-    get changes() { return Stream.tapError(self.changes, f) },
+    access: parent => Effect.tapError(parent, f),
-    get modify() { return self.modify as any },
+    transformStream: stream => Stream.tapError(stream, f),
-}))
+} as LensStep<A, A, ER | E2, ER, EW, EW, RR | R2, RR, RW, RW>))
 
 /**
  * Runs an effect when modify failures occur.
@@ -572,13 +583,14 @@ export const tapErrorWrite: {
 } = Function.dual(2, <A, ER, EW, RR, RW, E2, R2>(
     self: Lens<A, ER, EW, RR, RW>,
     f: (error: unknown) => Effect.Effect<any, E2, R2>,
-): Lens<A, ER, EW | E2, RR, RW | R2> => make({
+): Lens<A, ER, EW | E2, RR, RW | R2> => derive(asLensImpl(self), {
-    get get() { return self.get },
+    [LensStepTypeId]: LensStepTypeId,
-    get changes() { return self.changes },
+    access: parent => Effect.map(parent, frame => ({
-    modify: <B, E1 = never, R1 = never>(
+        value: frame.value,
-        g: (a: A) => Effect.Effect<readonly [B, A], E1, R1>
+        commit: next => Effect.tapError(frame.commit(next), f),
-    ) => Effect.tapError(self.modify(g), f),
+    })),
-}))
+    transformStream: stream => stream,
+} as LensStep<A, A, ER, ER, EW | E2, EW, RR, RR, RW | R2, RW>))
 
 /**
  * Runs an effect when any `Lens` failure occurs.
@@ -597,13 +609,17 @@ export const tapError: {
 } = Function.dual(2, <A, ER, EW, RR, RW, E2, R2>(
     self: Lens<A, ER, EW, RR, RW>,
     f: (error: unknown) => Effect.Effect<any, E2, R2>,
-): Lens<A, ER | E2, EW | E2, RR | R2, RW | R2> => make({
+): Lens<A, ER | E2, EW | E2, RR | R2, RW | R2> => derive(asLensImpl(self), {
-    get get() { return Effect.tapError(self.get, f) },
+    [LensStepTypeId]: LensStepTypeId,
-    get changes() { return Stream.tapError(self.changes, f) },
+    access: parent => Effect.map(
-    modify: <B, E1 = never, R1 = never>(
+        Effect.tapError(parent, f),
-        g: (a: A) => Effect.Effect<readonly [B, A], E1, R1>
+        frame => ({
-    ) => Effect.tapError(self.modify(g), f),
+            value: frame.value,
-}))
+            commit: next => Effect.tapError(frame.commit(next), f),
+        }),
+    ),
+    transformStream: stream => Stream.tapError(stream, f),
+} as LensStep<A, A, ER | E2, ER, EW | E2, EW, RR | R2, RR, RW | R2, RW>))
 
 
 /**
@@ -620,13 +636,17 @@ export const provideContext: {
 } = Function.dual(2, <A, ER, EW, RR, RW, R2>(
     self: Lens<A, ER, EW, RR, RW>,
     context: Context.Context<R2>,
-): Lens<A, ER, EW, Exclude<RR, R2>, Exclude<RW, R2>> => make({
+): Lens<A, ER, EW, Exclude<RR, R2>, Exclude<RW, R2>> => derive(asLensImpl(self), {
-    get get() { return Effect.provide(self.get, context) },
+    [LensStepTypeId]: LensStepTypeId,
-    get changes() { return Stream.provideSomeContext(self.changes, context) },
+    access: parent => Effect.map(
-    modify: <B, E1 = never, R1 = never>(
+        Effect.provide(parent, context),
-        f: (a: A) => Effect.Effect<readonly [B, A], E1, R1>
+        frame => ({
-    ) => Effect.provide(self.modify(f), context),
+            value: frame.value,
-}))
+            commit: next => Effect.provide(frame.commit(Effect.provide(next, context)), context),
+        }),
+    ),
+    transformStream: stream => Stream.provideSomeContext(stream, context),
+} as LensStep<A, A, ER, ER, EW, EW, Exclude<RR, R2>, RR, Exclude<RW, R2>, RW>))
 
 /**
  * Provides a `Runtime` or `ManagedRuntime` to a `Lens`, removing it from both the read and write environments.
@@ -651,18 +671,20 @@ export const provideRuntime: {
 } = Function.dual(2, <A, ER, EW, RR, RW, E2, R2>(
     self: Lens<A, ER, EW, RR, RW>,
     runtime: Runtime.Runtime<R2>,
-) => make<A, ER | E2, EW | E2, Exclude<RR, R2>, Exclude<RW, R2>>({
+) => derive(asLensImpl(self), {
-    get get() { return Effect.provide(self.get, runtime) },
+    [LensStepTypeId]: LensStepTypeId,
-    get changes() {
+    access: parent => Effect.map(
-        return Stream.unwrap(Effect.map(
+        Effect.provide(parent, runtime),
+        frame => ({
+            value: frame.value,
+            commit: next => Effect.provide(frame.commit(Effect.provide(next, runtime)), runtime),
+        }),
+    ),
+    transformStream: stream => Stream.unwrap(Effect.map(
             Effect.provide(Effect.context<RR>(), runtime),
-            context => Stream.provideContext(self.changes, context),
+            context => Stream.provideContext(stream, context),
-        ))
+    )),
-    },
+} as LensStep<A, A, ER | E2, ER, EW | E2, EW, Exclude<RR, R2>, RR, Exclude<RW, R2>, RW>))
-    modify: <B, E1 = never, R1 = never>(
-        f: (a: A) => Effect.Effect<readonly [B, A], E1, R1>
-    ) => Effect.provide(self.modify(f), runtime),
-}))
 
 /**
  * Provides a single service to a `Lens`, removing it from both the read and write environments.
@@ -684,13 +706,17 @@ export const provideService: {
     self: Lens<A, ER, EW, RR, RW>,
     tag: Context.Tag<I, S>,
     service: NoInfer<S>,
-): Lens<A, ER, EW, Exclude<RR, I>, Exclude<RW, I>> => make({
+): Lens<A, ER, EW, Exclude<RR, I>, Exclude<RW, I>> => derive(asLensImpl(self), {
-    get get() { return Effect.provideService(self.get, tag, service) },
+    [LensStepTypeId]: LensStepTypeId,
-    get changes() { return Stream.provideService(self.changes, tag, service) },
+    access: parent => Effect.map(
-    modify: <B, E1 = never, R1 = never>(
+        Effect.provideService(parent, tag, service),
-        f: (a: A) => Effect.Effect<readonly [B, A], E1, R1>
+        frame => ({
-    ) => Effect.provideService(self.modify(f), tag, service),
+            value: frame.value,
-}))
+            commit: next => Effect.provideService(frame.commit(Effect.provideService(next, tag, service)), tag, service),
+        }),
+    ),
+    transformStream: stream => Stream.provideService(stream, tag, service),
+} as LensStep<A, A, ER, ER, EW, EW, Exclude<RR, I>, RR, Exclude<RW, I>, RW>))
 
 
 /**
@@ -876,7 +902,7 @@ export const set: {
     <A, ER, EW, RR, RW>(value: A): (self: Lens<A, ER, EW, RR, RW>) => Effect.Effect<void, ER | EW, RR | RW>
     <A, ER, EW, RR, RW>(self: Lens<A, ER, EW, RR, RW>, value: A): Effect.Effect<void, ER | EW, RR | RW>
 } = Function.dual(2, <A, ER, EW, RR, RW>(self: Lens<A, ER, EW, RR, RW>, value: A) =>
-    self.modify<void, never, never>(() => Effect.succeed([void 0, value] as const)),
+    self.modifyEffect<void, never, never>(() => Effect.succeed([void 0, value] as const)),
 )
 
 /**
@@ -886,7 +912,7 @@ export const getAndSet: {
     <A, ER, EW, RR, RW>(value: A): (self: Lens<A, ER, EW, RR, RW>) => Effect.Effect<A, ER | EW, RR | RW>
     <A, ER, EW, RR, RW>(self: Lens<A, ER, EW, RR, RW>, value: A): Effect.Effect<A, ER | EW, RR | RW>
 } = Function.dual(2, <A, ER, EW, RR, RW>(self: Lens<A, ER, EW, RR, RW>, value: A) =>
-    self.modify<A, never, never>(a => Effect.succeed([a, value] as const)),
+    self.modifyEffect<A, never, never>(a => Effect.succeed([a, value] as const)),
 )
 
 /**
@@ -896,7 +922,7 @@ export const update: {
     <A, ER, EW, RR, RW>(f: (a: A) => A): (self: Lens<A, ER, EW, RR, RW>) => Effect.Effect<void, ER | EW, RR | RW>
     <A, ER, EW, RR, RW>(self: Lens<A, ER, EW, RR, RW>, f: (a: A) => A): Effect.Effect<void, ER | EW, RR | RW>
 } = Function.dual(2, <A, ER, EW, RR, RW>(self: Lens<A, ER, EW, RR, RW>, f: (a: A) => A) =>
-    self.modify<void, never, never>(a => Effect.succeed([void 0, f(a)] as const)),
+    self.modifyEffect<void, never, never>(a => Effect.succeed([void 0, f(a)] as const)),
 )
 
 /**
@@ -906,7 +932,7 @@ export const updateEffect: {
     <A, ER, EW, RR, RW, E, R>(f: (a: A) => Effect.Effect<A, E, R>): (self: Lens<A, ER, EW, RR, RW>) => Effect.Effect<void, ER | EW | E, RR | RW | R>
     <A, ER, EW, RR, RW, E, R>(self: Lens<A, ER, EW, RR, RW>, f: (a: A) => Effect.Effect<A, E, R>): Effect.Effect<void, ER | EW | E, RR | RW | R>
 } = Function.dual(2, <A, ER, EW, RR, RW, E, R>(self: Lens<A, ER, EW, RR, RW>, f: (a: A) => Effect.Effect<A, E, R>) =>
-    self.modify<void, E, R>(a => Effect.flatMap(
+    self.modifyEffect<void, E, R>(a => Effect.flatMap(
         f(a),
         next => Effect.succeed([void 0, next] as const),
     )),
@@ -919,7 +945,7 @@ export const getAndUpdate: {
     <A, ER, EW, RR, RW>(f: (a: A) => A): (self: Lens<A, ER, EW, RR, RW>) => Effect.Effect<A, ER | EW, RR | RW>
     <A, ER, EW, RR, RW>(self: Lens<A, ER, EW, RR, RW>, f: (a: A) => A): Effect.Effect<A, ER | EW, RR | RW>
 } = Function.dual(2, <A, ER, EW, RR, RW>(self: Lens<A, ER, EW, RR, RW>, f: (a: A) => A) =>
-    self.modify<A, never, never>(a => Effect.succeed([a, f(a)] as const)),
+    self.modifyEffect<A, never, never>(a => Effect.succeed([a, f(a)] as const)),
 )
 
 /**
@@ -929,7 +955,7 @@ export const getAndUpdateEffect: {
     <A, ER, EW, RR, RW, E, R>(f: (a: A) => Effect.Effect<A, E, R>): (self: Lens<A, ER, EW, RR, RW>) => Effect.Effect<A, ER | EW | E, RR | RW | R>
     <A, ER, EW, RR, RW, E, R>(self: Lens<A, ER, EW, RR, RW>, f: (a: A) => Effect.Effect<A, E, R>): Effect.Effect<A, ER | EW | E, RR | RW | R>
 } = Function.dual(2, <A, ER, EW, RR, RW, E, R>(self: Lens<A, ER, EW, RR, RW>, f: (a: A) => Effect.Effect<A, E, R>) =>
-    self.modify<A, E, R>(a => Effect.flatMap(
+    self.modifyEffect<A, E, R>(a => Effect.flatMap(
         f(a),
         next => Effect.succeed([a, next] as const)
     )),
@@ -942,7 +968,7 @@ export const setAndGet: {
     <A, ER, EW, RR, RW>(value: A): (self: Lens<A, ER, EW, RR, RW>) => Effect.Effect<A, ER | EW, RR | RW>
     <A, ER, EW, RR, RW>(self: Lens<A, ER, EW, RR, RW>, value: A): Effect.Effect<A, ER | EW, RR | RW>
 } = Function.dual(2, <A, ER, EW, RR, RW>(self: Lens<A, ER, EW, RR, RW>, value: A) =>
-    self.modify<A, never, never>(() => Effect.succeed([value, value] as const)),
+    self.modifyEffect<A, never, never>(() => Effect.succeed([value, value] as const)),
 )
 
 /**
@@ -952,7 +978,7 @@ export const updateAndGet: {
     <A, ER, EW, RR, RW>(f: (a: A) => A): (self: Lens<A, ER, EW, RR, RW>) => Effect.Effect<A, ER | EW, RR | RW>
     <A, ER, EW, RR, RW>(self: Lens<A, ER, EW, RR, RW>, f: (a: A) => A): Effect.Effect<A, ER | EW, RR | RW>
 } = Function.dual(2, <A, ER, EW, RR, RW>(self: Lens<A, ER, EW, RR, RW>, f: (a: A) => A) =>
-    self.modify<A, never, never>(a => {
+    self.modifyEffect<A, never, never>(a => {
         const next = f(a)
         return Effect.succeed([next, next] as const)
     }),
@@ -965,7 +991,7 @@ export const updateAndGetEffect: {
     <A, ER, EW, RR, RW, E, R>(f: (a: A) => Effect.Effect<A, E, R>): (self: Lens<A, ER, EW, RR, RW>) => Effect.Effect<A, ER | EW | E, RR | RW | R>
     <A, ER, EW, RR, RW, E, R>(self: Lens<A, ER, EW, RR, RW>, f: (a: A) => Effect.Effect<A, E, R>): Effect.Effect<A, ER | EW | E, RR | RW | R>
 } = Function.dual(2, <A, ER, EW, RR, RW, E, R>(self: Lens<A, ER, EW, RR, RW>, f: (a: A) => Effect.Effect<A, E, R>) =>
-    self.modify<A, E, R>(a => Effect.flatMap(
+    self.modifyEffect<A, E, R>(a => Effect.flatMap(
         f(a),
         next => Effect.succeed([next, next] as const),
     )),