packages/effect-lens/src/Lens.ts

@@ -324,13 +324,13 @@ extends LensImpl<A, ER, EW, RR, RW> {
  * Derives a new `Lens` by linking a step to an existing parent lens.
  */
 export const derive: {
+    <A, B, ER, EW, RR, RW, ER2, EW2, RR2, RW2>(
+        source: DerivedLensImpl.Source<A, B, ER2, ER, EW2, EW, RR2, RR, RW2, RW>,
+    ): (self: Lens<B, ER, EW, RR, RW>) => Lens<A, ER2, EW2, RR2, RW2>
     <A, B, ER, EW, RR, RW, ER2, EW2, RR2, RW2>(
         self: Lens<B, ER, EW, RR, RW>,
         source: DerivedLensImpl.Source<A, B, ER2, ER, EW2, EW, RR2, RR, RW2, RW>,
     ): Lens<A, ER2, EW2, RR2, RW2>
-    <A, B, ER, EW, RR, RW, ER2, EW2, RR2, RW2>(
-        source: DerivedLensImpl.Source<A, B, ER2, ER, EW2, EW, RR2, RR, RW2, RW>,
-    ): (self: Lens<B, ER, EW, RR, RW>) => Lens<A, ER2, EW2, RR2, RW2>
 } = Function.dual(2, <A, B, ER, EW, RR, RW, ER2, EW2, RR2, RW2>(
     self: Lens<B, ER, EW, RR, RW>,
     source: DerivedLensImpl.Source<A, B, ER2, ER, EW2, EW, RR2, RR, RW2, RW>,
@@ -341,15 +341,15 @@ export const derive: {
  * Derives a new `Lens` by applying synchronous getters and setters over the focused value.
  */
 export const map: {
+    <A, ER, EW, RR, RW, B>(
+        get: (a: NoInfer<A>) => B,
+        set: (a: NoInfer<A>, b: B) => NoInfer<A>,
+    ): (self: Lens<A, ER, EW, RR, RW>) => Lens<B, ER, EW, RR, RW>
     <A, ER, EW, RR, RW, B>(
         self: Lens<A, ER, EW, RR, RW>,
         get: (a: NoInfer<A>) => B,
         set: (a: NoInfer<A>, b: B) => NoInfer<A>,
     ): Lens<B, ER, EW, RR, RW>
-    <A, ER, EW, RR, RW, B>(
-        get: (a: NoInfer<A>) => B,
-        set: (a: NoInfer<A>, b: B) => NoInfer<A>,
-    ): (self: Lens<A, ER, EW, RR, RW>) => Lens<B, ER, EW, RR, RW>
 } = Function.dual(3, <A, ER, EW, RR, RW, B>(
     self: Lens<A, ER, EW, RR, RW>,
     get: (a: NoInfer<A>) => B,
@@ -370,15 +370,15 @@ export const map: {
  * Derives a new `Lens` by applying effectful getters and setters over the focused value.
  */
 export const mapEffect: {
+    <A, ER, EW, RR, RW, B, EGet = never, RGet = never, ESet = never, RSet = never>(
+        get: (a: NoInfer<A>) => Effect.Effect<B, EGet, RGet>,
+        set: (a: NoInfer<A>, b: B) => Effect.Effect<NoInfer<A>, ESet, RSet>,
+    ): (self: Lens<A, ER, EW, RR, RW>) => Lens<B, ER | EGet, EW | ESet, RR | RGet, RW | RSet>
     <A, ER, EW, RR, RW, B, EGet = never, RGet = never, ESet = never, RSet = never>(
         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>
-    <A, ER, EW, RR, RW, B, EGet = never, RGet = never, ESet = never, RSet = never>(
-        get: (a: NoInfer<A>) => Effect.Effect<B, EGet, RGet>,
-        set: (a: NoInfer<A>, b: B) => Effect.Effect<NoInfer<A>, ESet, RSet>,
-    ): (self: Lens<A, ER, EW, RR, RW>) => Lens<B, ER | EGet, EW | ESet, RR | RGet, RW | RSet>
 } = Function.dual(3, <A, ER, EW, RR, RW, B, EGet = never, RGet = never, ESet = never, RSet = never>(
     self: Lens<A, ER, EW, RR, RW>,
     get: (a: NoInfer<A>) => Effect.Effect<B, EGet, RGet>,
@@ -406,15 +406,15 @@ export const mapEffect: {
  * - If the `Option` is `None`, it remains `None`
  */
 export const mapOption: {
+    <A, ER, EW, RR, RW, B>(
+        get: (a: NoInfer<A>) => B,
+        set: (a: NoInfer<A>, b: B) => NoInfer<A>,
+    ): (self: Lens<Option.Option<A>, ER, EW, RR, RW>) => Lens<Option.Option<B>, ER, EW, RR, RW>
     <A, ER, EW, RR, RW, B>(
         self: Lens<Option.Option<A>, ER, EW, RR, RW>,
         get: (a: NoInfer<A>) => B,
         set: (a: NoInfer<A>, b: B) => NoInfer<A>,
     ): Lens<Option.Option<B>, ER, EW, RR, RW>
-    <A, ER, EW, RR, RW, B>(
-        get: (a: NoInfer<A>) => B,
-        set: (a: NoInfer<A>, b: B) => NoInfer<A>,
-    ): (self: Lens<Option.Option<A>, ER, EW, RR, RW>) => Lens<Option.Option<B>, ER, EW, RR, RW>
 } = Function.dual(3, <A, ER, EW, RR, RW, B>(
     self: Lens<Option.Option<A>, ER, EW, RR, RW>,
     get: (a: NoInfer<A>) => B,
@@ -436,15 +436,15 @@ export const mapOption: {
  * - If the `Option` is `None`, it remains `None`
  */
 export const mapOptionEffect: {
+    <A, ER, EW, RR, RW, B, EGet = never, RGet = never, ESet = never, RSet = never>(
+        get: (a: NoInfer<A>) => Effect.Effect<B, EGet, RGet>,
+        set: (a: NoInfer<A>, b: B) => Effect.Effect<NoInfer<A>, ESet, RSet>,
+    ): (self: Lens<Option.Option<A>, ER, EW, RR, RW>) => Lens<Option.Option<B>, ER | EGet, EW | ESet, RR | RGet, RW | RSet>
     <A, ER, EW, RR, RW, B, EGet = never, RGet = never, ESet = never, RSet = never>(
         self: Lens<Option.Option<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<Option.Option<B>, ER | EGet, EW | ESet, RR | RGet, RW | RSet>
-    <A, ER, EW, RR, RW, B, EGet = never, RGet = never, ESet = never, RSet = never>(
-        get: (a: NoInfer<A>) => Effect.Effect<B, EGet, RGet>,
-        set: (a: NoInfer<A>, b: B) => Effect.Effect<NoInfer<A>, ESet, RSet>,
-    ): (self: Lens<Option.Option<A>, ER, EW, RR, RW>) => Lens<Option.Option<B>, ER | EGet, EW | ESet, RR | RGet, RW | RSet>
 } = Function.dual(3, <A, ER, EW, RR, RW, B, EGet = never, RGet = never, ESet = never, RSet = never>(
     self: Lens<Option.Option<A>, ER, EW, RR, RW>,
     get: (a: NoInfer<A>) => Effect.Effect<B, EGet, RGet>,
@@ -468,13 +468,13 @@ export const mapOptionEffect: {
  * Allows transforming only the `changes` stream of a `Lens` while keeping the focus type intact.
  */
 export const mapStream: {
+    <A, ER, EW, RR, RW>(
+        f: (changes: Stream.Stream<NoInfer<A>, NoInfer<ER>, NoInfer<RR>>) => Stream.Stream<NoInfer<A>, NoInfer<ER>, NoInfer<RR>>,
+    ): (self: Lens<A, ER, EW, RR, RW>) => Lens<A, ER, EW, RR, RW>
     <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>
-    <A, ER, EW, RR, RW>(
-        f: (changes: Stream.Stream<NoInfer<A>, NoInfer<ER>, NoInfer<RR>>) => Stream.Stream<NoInfer<A>, NoInfer<ER>, NoInfer<RR>>,
-    ): (self: Lens<A, ER, EW, RR, RW>) => Lens<A, ER, EW, RR, RW>
 } = 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>>,
@@ -491,13 +491,13 @@ export const mapStream: {
  * Applies to `get` and `changes` while leaving `modify` unchanged.
  */
 export const mapErrorRead: {
+    <A, ER, EW, RR, RW, E2>(
+        f: (error: NoInfer<ER>) => E2,
+    ): (self: Lens<A, ER, EW, RR, RW>) => Lens<A, E2, EW, RR, RW>
     <A, ER, EW, RR, RW, E2>(
         self: Lens<A, ER, EW, RR, RW>,
         f: (error: NoInfer<ER>) => E2,
     ): Lens<A, E2, EW, RR, RW>
-    <A, ER, EW, RR, RW, E2>(
-        f: (error: NoInfer<ER>) => E2,
-    ): (self: Lens<A, ER, EW, RR, RW>) => Lens<A, E2, EW, RR, RW>
 } = Function.dual(2, <A, ER, EW, RR, RW, E2>(
     self: Lens<A, ER, EW, RR, RW>,
     f: (error: NoInfer<ER>) => E2,
@@ -514,13 +514,13 @@ export const mapErrorRead: {
  * user-supplied callback unchanged.
  */
 export const mapErrorWrite: {
+    <A, ER, EW, RR, RW, E2>(
+        f: (error: NoInfer<EW>) => E2,
+    ): (self: Lens<A, ER, EW, RR, RW>) => Lens<A, ER, E2, RR, RW>
     <A, ER, EW, RR, RW, E2>(
         self: Lens<A, ER, EW, RR, RW>,
         f: (error: NoInfer<EW>) => E2,
     ): Lens<A, ER, E2, RR, RW>
-    <A, ER, EW, RR, RW, E2>(
-        f: (error: NoInfer<EW>) => E2,
-    ): (self: Lens<A, ER, EW, RR, RW>) => Lens<A, ER, E2, RR, RW>
 } = Function.dual(2, <A, ER, EW, RR, RW, E2>(
     self: Lens<A, ER, EW, RR, RW>,
     f: (error: NoInfer<EW>) => E2,
@@ -543,13 +543,13 @@ export const mapErrorWrite: {
  * failures from the user-supplied callback unchanged.
  */
 export const mapError: {
+    <A, ER, EW, RR, RW, E2>(
+        f: (error: NoInfer<ER | EW>) => E2,
+    ): (self: Lens<A, ER, EW, RR, RW>) => Lens<A, E2, E2, RR, RW>
     <A, ER, EW, RR, RW, E2>(
         self: Lens<A, ER, EW, RR, RW>,
         f: (error: NoInfer<ER | EW>) => E2,
     ): Lens<A, E2, E2, RR, RW>
-    <A, ER, EW, RR, RW, E2>(
-        f: (error: NoInfer<ER | EW>) => E2,
-    ): (self: Lens<A, ER, EW, RR, RW>) => Lens<A, E2, E2, RR, RW>
 } = Function.dual(2, <A, ER, EW, RR, RW, E2>(
     self: Lens<A, ER, EW, RR, RW>,
     f: (error: NoInfer<ER | EW>) => E2,
@@ -574,13 +574,13 @@ export const mapError: {
  * Applies to `get` and `changes` while leaving `modify` unchanged.
  */
 export const tapErrorRead: {
+    <A, ER, EW, RR, RW, E2, R2>(
+        f: (error: NoInfer<ER>) => Effect.Effect<unknown, E2, R2>,
+    ): (self: Lens<A, ER, EW, RR, RW>) => Lens<A, ER | E2, EW, RR | R2, RW>
     <A, ER, EW, RR, RW, E2, R2>(
         self: Lens<A, ER, EW, RR, RW>,
         f: (error: NoInfer<ER>) => Effect.Effect<unknown, E2, R2>,
     ): Lens<A, ER | E2, EW, RR | R2, RW>
-    <A, ER, EW, RR, RW, E2, R2>(
-        f: (error: NoInfer<ER>) => Effect.Effect<unknown, E2, R2>,
-    ): (self: Lens<A, ER, EW, RR, RW>) => Lens<A, ER | E2, EW, RR | R2, RW>
 } = Function.dual(2, <A, ER, EW, RR, RW, E2, R2>(
     self: Lens<A, ER, EW, RR, RW>,
     f: (error: NoInfer<ER>) => Effect.Effect<unknown, E2, R2>,
@@ -597,13 +597,13 @@ export const tapErrorRead: {
  * user-supplied callback unchanged.
  */
 export const tapErrorWrite: {
+    <A, ER, EW, RR, RW, E2, R2>(
+        f: (error: NoInfer<EW>) => Effect.Effect<unknown, E2, R2>,
+    ): (self: Lens<A, ER, EW, RR, RW>) => Lens<A, ER, EW | E2, RR, RW | R2>
     <A, ER, EW, RR, RW, E2, R2>(
         self: Lens<A, ER, EW, RR, RW>,
         f: (error: NoInfer<EW>) => Effect.Effect<unknown, E2, R2>,
     ): Lens<A, ER, EW | E2, RR, RW | R2>
-    <A, ER, EW, RR, RW, E2, R2>(
-        f: (error: NoInfer<EW>) => Effect.Effect<unknown, E2, R2>,
-    ): (self: Lens<A, ER, EW, RR, RW>) => Lens<A, ER, EW | E2, RR, RW | R2>
 } = Function.dual(2, <A, ER, EW, RR, RW, E2, R2>(
     self: Lens<A, ER, EW, RR, RW>,
     f: (error: NoInfer<EW>) => Effect.Effect<unknown, E2, R2>,
@@ -626,13 +626,13 @@ export const tapErrorWrite: {
  * failures from the user-supplied callback unchanged.
  */
 export const tapError: {
+    <A, ER, EW, RR, RW, E2, R2>(
+        f: (error: NoInfer<ER | EW>) => Effect.Effect<unknown, E2, R2>,
+    ): (self: Lens<A, ER, EW, RR, RW>) => Lens<A, ER | E2, EW | E2, RR | R2, RW | R2>
     <A, ER, EW, RR, RW, E2, R2>(
         self: Lens<A, ER, EW, RR, RW>,
         f: (error: NoInfer<ER | EW>) => Effect.Effect<unknown, E2, R2>,
     ): Lens<A, ER | E2, EW | E2, RR | R2, RW | R2>
-    <A, ER, EW, RR, RW, E2, R2>(
-        f: (error: NoInfer<ER | EW>) => Effect.Effect<unknown, E2, R2>,
-    ): (self: Lens<A, ER, EW, RR, RW>) => Lens<A, ER | E2, EW | E2, RR | R2, RW | R2>
 } = Function.dual(2, <A, ER, EW, RR, RW, E2, R2>(
     self: Lens<A, ER, EW, RR, RW>,
     f: (error: NoInfer<ER | EW>) => Effect.Effect<unknown, E2, R2>,
@@ -656,13 +656,13 @@ export const tapError: {
  * Provides a `Context` to a `Lens`, removing it from both the read and write environments.
  */
 export const provideContext: {
+    <R2>(
+        context: Context.Context<R2>,
+    ): <A, ER, EW, RR, RW>(self: Lens<A, ER, EW, RR, RW>) => Lens<A, ER, EW, Exclude<RR, R2>, Exclude<RW, R2>>
     <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>>
-    <R2>(
-        context: Context.Context<R2>,
-    ): <A, ER, EW, RR, RW>(self: Lens<A, ER, EW, RR, RW>) => Lens<A, ER, EW, Exclude<RR, R2>, Exclude<RW, R2>>
 } = Function.dual(2, <A, ER, EW, RR, RW, R2>(
     self: Lens<A, ER, EW, RR, RW>,
     context: Context.Context<R2>,
@@ -685,15 +685,15 @@ export const provideContext: {
  * `Context.Tag` and you already have the concrete service value.
  */
 export const provideService: {
+    <I, S>(
+        tag: Context.Tag<I, S>,
+        service: NoInfer<S>,
+    ): <A, ER, EW, RR, RW>(self: Lens<A, ER, EW, RR, RW>) => Lens<A, ER, EW, Exclude<RR, I>, Exclude<RW, I>>
     <A, ER, EW, RR, RW, I, S>(
         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>>
-    <I, S>(
-        tag: Context.Tag<I, S>,
-        service: NoInfer<S>,
-    ): <A, ER, EW, RR, RW>(self: Lens<A, ER, EW, RR, RW>) => Lens<A, ER, EW, Exclude<RR, I>, Exclude<RW, I>>
 } = Function.dual(3, <A, ER, EW, RR, RW, I, S>(
     self: Lens<A, ER, EW, RR, RW>,
     tag: Context.Tag<I, S>,
@@ -715,13 +715,13 @@ export const provideService: {
  * Narrows the focus to a field of an object. Replaces the object in an immutable fashion when written to.
  */
 export const focusObjectOn: {
+    <A extends object, ER, EW, RR, RW, K extends keyof A>(
+        key: K,
+    ): (self: Lens<A, ER, EW, RR, RW>) => Lens<A[K], ER, EW, RR, RW>
     <A extends object, ER, EW, RR, RW, K extends keyof A>(
         self: Lens<A, ER, EW, RR, RW>,
         key: K,
     ): Lens<A[K], ER, EW, RR, RW>
-    <A extends object, ER, EW, RR, RW, K extends keyof A>(
-        key: K,
-    ): (self: Lens<A, ER, EW, RR, RW>) => Lens<A[K], ER, EW, RR, RW>
 } = Function.dual(2, <A extends object, ER, EW, RR, RW, K extends keyof A>(
     self: Lens<A, ER, EW, RR, RW>,
     key: K,
@@ -748,13 +748,13 @@ export declare namespace focusObjectOnWritable {
  * Narrows the focus to a writable field of an object. Mutates the object in place when written to.
  */
 export const focusObjectOnWritable: {
+    <A extends object, ER, EW, RR, RW, K extends focusObjectOnWritable.WritableKeys<A>>(
+        key: K,
+    ): (self: Lens<A, ER, EW, RR, RW>) => Lens<A[K], ER, EW, RR, RW>
     <A extends object, ER, EW, RR, RW, K extends focusObjectOnWritable.WritableKeys<A>>(
         self: Lens<A, ER, EW, RR, RW>,
         key: K,
     ): Lens<A[K], ER, EW, RR, RW>
-    <A extends object, ER, EW, RR, RW, K extends focusObjectOnWritable.WritableKeys<A>>(
-        key: K,
-    ): (self: Lens<A, ER, EW, RR, RW>) => Lens<A[K], ER, EW, RR, RW>
 } = Function.dual(2, <A extends object, ER, EW, RR, RW, K extends focusObjectOnWritable.WritableKeys<A>>(
     self: Lens<A, ER, EW, RR, RW>,
     key: K,
@@ -764,13 +764,13 @@ export const focusObjectOnWritable: {
  * Narrows the focus to an indexed element of an array. Replaces the array in an immutable fashion when written to.
  */
 export const focusArrayAt: {
+    <A extends readonly any[], ER, EW, RR, RW>(
+        index: number
+    ): (self: Lens<A, ER, EW, RR, RW>) => Lens<A[number], ER | NoSuchElementException, EW | NoSuchElementException, RR, RW>
     <A extends readonly any[], ER, EW, RR, RW>(
         self: Lens<A, ER, EW, RR, RW>,
         index: number,
     ): Lens<A[number], ER | NoSuchElementException, EW | NoSuchElementException, RR, RW>
-    <A extends readonly any[], ER, EW, RR, RW>(
-        index: number
-    ): (self: Lens<A, ER, EW, RR, RW>) => Lens<A[number], ER | NoSuchElementException, EW | NoSuchElementException, RR, RW>
 } = Function.dual(2, <A extends readonly any[], ER, EW, RR, RW>(
     self: Lens<A, ER, EW, RR, RW>,
     index: number,
@@ -784,13 +784,13 @@ export const focusArrayAt: {
  * Narrows the focus to an indexed element of a mutable array. Mutates the array in place when written to.
  */
 export const focusMutableArrayAt: {
+    <A, ER, EW, RR, RW>(
+        index: number
+    ): (self: Lens<A[], ER, EW, RR, RW>) => Lens<A, ER | NoSuchElementException, EW | NoSuchElementException, RR, RW>
     <A, ER, EW, RR, RW>(
         self: Lens<A[], ER, EW, RR, RW>,
         index: number,
     ): Lens<A, ER | NoSuchElementException, EW | NoSuchElementException, RR, RW>
-    <A, ER, EW, RR, RW>(
-        index: number
-    ): (self: Lens<A[], ER, EW, RR, RW>) => Lens<A, ER | NoSuchElementException, EW | NoSuchElementException, RR, RW>
 } = Function.dual(2, <A, ER, EW, RR, RW>(
     self: Lens<A[], ER, EW, RR, RW>,
     index: number,
@@ -807,13 +807,13 @@ export const focusMutableArrayAt: {
  * Narrows the focus to an indexed element of a readonly tuple. Replaces the tuple in an immutable fashion when written to.
  */
 export const focusTupleAt: {
+    <T extends readonly [any, ...any[]], ER, EW, RR, RW, I extends number>(
+        index: I
+    ): (self: Lens<T, ER, EW, RR, RW>) => Lens<T[I], ER, EW, RR, RW>
     <T extends readonly [any, ...any[]], ER, EW, RR, RW, I extends number>(
         self: Lens<T, ER, EW, RR, RW>,
         index: I,
     ): Lens<T[I], ER, EW, RR, RW>
-    <T extends readonly [any, ...any[]], ER, EW, RR, RW, I extends number>(
-        index: I
-    ): (self: Lens<T, ER, EW, RR, RW>) => Lens<T[I], ER, EW, RR, RW>
 } = Function.dual(2, <T extends readonly [any, ...any[]], ER, EW, RR, RW, I extends number>(
     self: Lens<T, ER, EW, RR, RW>,
     index: I,
@@ -827,13 +827,13 @@ export const focusTupleAt: {
  * Narrows the focus to an indexed element of a mutable tuple. Mutates the tuple in place when written to.
  */
 export const focusMutableTupleAt: {
+    <T extends [any, ...any[]], ER, EW, RR, RW, I extends number>(
+        index: I
+    ): (self: Lens<T, ER, EW, RR, RW>) => Lens<T[I], ER, EW, RR, RW>
     <T extends [any, ...any[]], ER, EW, RR, RW, I extends number>(
         self: Lens<T, ER, EW, RR, RW>,
         index: I,
     ): Lens<T[I], ER, EW, RR, RW>
-    <T extends [any, ...any[]], ER, EW, RR, RW, I extends number>(
-        index: I
-    ): (self: Lens<T, ER, EW, RR, RW>) => Lens<T[I], ER, EW, RR, RW>
 } = Function.dual(2, <T extends [any, ...any[]], ER, EW, RR, RW, I extends number>(
     self: Lens<T, ER, EW, RR, RW>,
     index: I,
@@ -847,13 +847,13 @@ export const focusMutableTupleAt: {
  * Narrows the focus to an indexed element of `Chunk`. Replaces the `Chunk` in an immutable fashion when written to.
  */
 export const focusChunkAt: {
+    <A, ER, EW, RR, RW>(
+        index: number
+    ): (self: Lens<Chunk.Chunk<A>, ER, EW, RR, RW>) => Lens<A, ER | NoSuchElementException, EW, RR, RW>
     <A, ER, EW, RR, RW>(
         self: Lens<Chunk.Chunk<A>, ER, EW, RR, RW>,
         index: number,
     ): Lens<A, ER | NoSuchElementException, EW, RR, RW>
-    <A, ER, EW, RR, RW>(
-        index: number
-    ): (self: Lens<Chunk.Chunk<A>, ER, EW, RR, RW>) => Lens<A, ER | NoSuchElementException, EW, RR, RW>
 } = Function.dual(2, <A, ER, EW, RR, RW>(
     self: Lens<Chunk.Chunk<A>, ER, EW, RR, RW>,
     index: number,
@@ -887,6 +887,46 @@ export const focusOption: {
  */
 export const get = <A, ER, EW, RR, RW>(self: Lens<A, ER, EW, RR, RW>): Effect.Effect<A, ER, RR> => self.get
 
+/**
+ * Atomically modifies the value of a `Lens` and returns a computed result.
+ */
+export const modify: {
+    <A, B>(f: (a: A) => readonly [B, A]): <ER, EW, RR, RW>(self: Lens<A, ER, EW, RR, RW>) => Effect.Effect<B, ER | EW, RR | RW>
+    <A, ER, EW, RR, RW, B>(self: Lens<A, ER, EW, RR, RW>, f: (a: A) => readonly [B, A]): Effect.Effect<B, ER | EW, RR | RW>
+} = Function.dual(2, <A, ER, EW, RR, RW, B>(self: Lens<A, ER, EW, RR, RW>, f: (a: A) => readonly [B, A]) =>
+    self.modifyEffect<B, never, never>(a => Effect.succeed(f(a))),
+)
+
+/**
+ * Atomically modifies the value of a `Lens` with an effect and returns a computed result.
+ */
+export const modifyEffect: {
+    <A, B, E, R>(f: (a: A) => Effect.Effect<readonly [B, A], E, R>): <ER, EW, RR, RW>(self: Lens<A, ER, EW, RR, RW>) => Effect.Effect<B, ER | EW | E, RR | RW | R>
+    <A, ER, EW, RR, RW, B, E, R>(self: Lens<A, ER, EW, RR, RW>, f: (a: A) => Effect.Effect<readonly [B, A], E, R>): Effect.Effect<B, ER | EW | E, RR | RW | R>
+} = Function.dual(2, <A, ER, EW, RR, RW, B, E, R>(self: Lens<A, ER, EW, RR, RW>, f: (a: A) => Effect.Effect<readonly [B, A], E, R>) =>
+    self.modifyEffect(f),
+)
+
+/**
+ * Conditionally modifies the value of a `Lens`, returning `fallback` when the function returns `None`.
+ */
+export const modifySome: {
+    <B, A>(fallback: B, pf: (a: A) => Option.Option<readonly [B, A]>): <ER, EW, RR, RW>(self: Lens<A, ER, EW, RR, RW>) => Effect.Effect<B, ER | EW, RR | RW>
+    <A, ER, EW, RR, RW, B>(self: Lens<A, ER, EW, RR, RW>, fallback: B, pf: (a: A) => Option.Option<readonly [B, A]>): Effect.Effect<B, ER | EW, RR | RW>
+} = Function.dual(3, <A, ER, EW, RR, RW, B>(self: Lens<A, ER, EW, RR, RW>, fallback: B, pf: (a: A) => Option.Option<readonly [B, A]>) =>
+    self.modifyEffect<B, never, never>(a => Effect.succeed(Option.getOrElse(pf(a), () => [fallback, a] as const))),
+)
+
+/**
+ * Conditionally modifies the value of a `Lens` with an effect, returning `fallback` when the function returns `None`.
+ */
+export const modifySomeEffect: {
+    <B, A, E, R>(fallback: B, pf: (a: A) => Option.Option<Effect.Effect<readonly [B, A], E, R>>): <ER, EW, RR, RW>(self: Lens<A, ER, EW, RR, RW>) => Effect.Effect<B, ER | EW | E, RR | RW | R>
+    <A, ER, EW, RR, RW, B, E, R>(self: Lens<A, ER, EW, RR, RW>, fallback: B, pf: (a: A) => Option.Option<Effect.Effect<readonly [B, A], E, R>>): Effect.Effect<B, ER | EW | E, RR | RW | R>
+} = Function.dual(3, <A, ER, EW, RR, RW, B, E, R>(self: Lens<A, ER, EW, RR, RW>, fallback: B, pf: (a: A) => Option.Option<Effect.Effect<readonly [B, A], E, R>>) =>
+    self.modifyEffect<B, E, R>(a => Option.getOrElse(pf(a), () => Effect.succeed([fallback, a] as const))),
+)
+
 /**
  * Sets the value of a `Lens`.
  */
@@ -953,6 +993,29 @@ export const getAndUpdateEffect: {
     )),
 )
 
+/**
+ * Conditionally updates a `Lens` and returns the previous value.
+ */
+export const getAndUpdateSome: {
+    <A>(pf: (a: A) => Option.Option<A>): <ER, EW, RR, RW>(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>, pf: (a: A) => Option.Option<A>): Effect.Effect<A, ER | EW, RR | RW>
+} = Function.dual(2, <A, ER, EW, RR, RW>(self: Lens<A, ER, EW, RR, RW>, pf: (a: A) => Option.Option<A>) =>
+    self.modifyEffect<A, never, never>(a => Effect.succeed([a, Option.getOrElse(pf(a), () => a)] as const)),
+)
+
+/**
+ * Conditionally updates a `Lens` with an effect and returns the previous value.
+ */
+export const getAndUpdateSomeEffect: {
+    <A, E, R>(pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>): <ER, EW, RR, RW>(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>, pf: (a: A) => Option.Option<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>, pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>) =>
+    self.modifyEffect<A, E, R>(a => Effect.map(
+        Option.getOrElse(pf(a), () => Effect.succeed(a)),
+        next => [a, next] as const,
+    )),
+)
+
 /**
  * Sets the value of a `Lens` and returns the new value.
  */
@@ -988,3 +1051,52 @@ export const updateAndGetEffect: {
         next => Effect.succeed([next, next] as const),
     )),
 )
+
+/**
+ * Conditionally updates the value of a `Lens`.
+ */
+export const updateSome: {
+    <A>(pf: (a: A) => Option.Option<A>): <ER, EW, RR, RW>(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>, pf: (a: A) => Option.Option<A>): Effect.Effect<void, ER | EW, RR | RW>
+} = Function.dual(2, <A, ER, EW, RR, RW>(self: Lens<A, ER, EW, RR, RW>, pf: (a: A) => Option.Option<A>) =>
+    self.modifyEffect<void, never, never>(a => Effect.succeed([void 0, Option.getOrElse(pf(a), () => a)] as const)),
+)
+
+/**
+ * Conditionally updates the value of a `Lens` with an effect.
+ */
+export const updateSomeEffect: {
+    <A, E, R>(pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>): <ER, EW, RR, RW>(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>, pf: (a: A) => Option.Option<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>, pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>) =>
+    self.modifyEffect<void, E, R>(a => Effect.map(
+        Option.getOrElse(pf(a), () => Effect.succeed(a)),
+        next => [void 0, next] as const,
+    )),
+)
+
+/**
+ * Conditionally updates a `Lens` and returns the resulting value.
+ */
+export const updateSomeAndGet: {
+    <A>(pf: (a: A) => Option.Option<A>): <ER, EW, RR, RW>(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>, pf: (a: A) => Option.Option<A>): Effect.Effect<A, ER | EW, RR | RW>
+} = Function.dual(2, <A, ER, EW, RR, RW>(self: Lens<A, ER, EW, RR, RW>, pf: (a: A) => Option.Option<A>) =>
+    self.modifyEffect<A, never, never>(a => {
+        const next = Option.getOrElse(pf(a), () => a)
+        return Effect.succeed([next, next] as const)
+    }),
+)
+
+/**
+ * Conditionally updates a `Lens` with an effect and returns the resulting value.
+ */
+export const updateSomeAndGetEffect: {
+    <A, E, R>(pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>): <ER, EW, RR, RW>(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>, pf: (a: A) => Option.Option<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>, pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>) =>
+    self.modifyEffect<A, E, R>(a => Effect.map(
+        Option.getOrElse(pf(a), () => Effect.succeed(a)),
+        next => [next, next] as const,
+    )),
+)

packages/effect-lens/src/Subscribable.ts

@@ -8,13 +8,13 @@ export * from "effect/Subscribable"
  * Maps over an `Option` value in the `Subscribable`.
  */
 export const mapOption: {
+    <A, B>(
+        f: (a: A) => B,
+    ): <E, R>(self: Subscribable.Subscribable<Option.Option<A>, E, R>) => Subscribable.Subscribable<Option.Option<B>, E, R>
     <A, B, E, R>(
         self: Subscribable.Subscribable<Option.Option<A>, E, R>,
         f: (a: A) => B,
     ): Subscribable.Subscribable<Option.Option<B>, E, R>
-    <A, B>(
-        f: (a: A) => B,
-    ): <E, R>(self: Subscribable.Subscribable<Option.Option<A>, E, R>) => Subscribable.Subscribable<Option.Option<B>, E, R>
 } = Function.dual(2, <A, B, E, R>(
     self: Subscribable.Subscribable<Option.Option<A>, E, R>,
     f: (a: A) => B,
@@ -24,13 +24,13 @@ export const mapOption: {
  * Maps over an `Option` value in the `Subscribable` with an Effect.
  */
 export const mapOptionEffect: {
+    <A, B, E2>(
+        f: (a: A) => Effect.Effect<B, E2>,
+    ): <E, R>(self: Subscribable.Subscribable<Option.Option<A>, E, R>) => Subscribable.Subscribable<Option.Option<B>, E | E2, R>
     <A, B, E, E2, R>(
         self: Subscribable.Subscribable<Option.Option<A>, E, R>,
         f: (a: A) => Effect.Effect<B, E2, R>,
     ): Subscribable.Subscribable<Option.Option<B>, E | E2, R>
-    <A, B, E2>(
-        f: (a: A) => Effect.Effect<B, E2>,
-    ): <E, R>(self: Subscribable.Subscribable<Option.Option<A>, E, R>) => Subscribable.Subscribable<Option.Option<B>, E | E2, R>
 } = Function.dual(2, <A, B, E, E2, R>(
     self: Subscribable.Subscribable<Option.Option<A>, E, R>,
     f: (a: A) => Effect.Effect<B, E2, R>,
@@ -43,13 +43,13 @@ export const mapOptionEffect: {
  * Narrows the focus to a field of an object.
  */
 export const focusObjectOn: {
+    <A extends object, K extends keyof A, E, R>(
+        key: K,
+    ): (self: Subscribable.Subscribable<A, E, R>) => Subscribable.Subscribable<A[K], E, R>
     <A extends object, K extends keyof A, E, R>(
         self: Subscribable.Subscribable<A, E, R>,
         key: K,
     ): Subscribable.Subscribable<A[K], E, R>
-    <A extends object, K extends keyof A, E, R>(
-        key: K,
-    ): (self: Subscribable.Subscribable<A, E, R>) => Subscribable.Subscribable<A[K], E, R>
 } = Function.dual(2, <A extends object, K extends keyof A, E, R>(
     self: Subscribable.Subscribable<A, E, R>,
     key: K,
@@ -59,13 +59,13 @@ export const focusObjectOn: {
  * Narrows the focus to an indexed element of an array.
  */
 export const focusArrayAt: {
+    <A extends readonly any[], E, R>(
+        index: number
+    ): (self: Subscribable.Subscribable<A, E, R>) => Subscribable.Subscribable<A[number], E | NoSuchElementException, R>
     <A extends readonly any[], E, R>(
         self: Subscribable.Subscribable<A, E, R>,
         index: number,
     ): Subscribable.Subscribable<A[number], E, R>
-    <A extends readonly any[], E, R>(
-        index: number
-    ): (self: Subscribable.Subscribable<A, E, R>) => Subscribable.Subscribable<A[number], E | NoSuchElementException, R>
 } = Function.dual(2, <A extends readonly any[], E, R>(
     self: Subscribable.Subscribable<A, E, R>,
     index: number,
@@ -82,13 +82,13 @@ export const focusArrayLength = <A extends readonly any[], E, R>(
  * Narrows the focus to an indexed element of a readonly tuple.
  */
 export const focusTupleAt: {
+    <T extends readonly [any, ...any[]], I extends number, E, R>(
+        index: I
+    ): (self: Subscribable.Subscribable<T, E, R>) => Subscribable.Subscribable<T[I], E, R>
     <T extends readonly [any, ...any[]], I extends number, E, R>(
         self: Subscribable.Subscribable<T, E, R>,
         index: I,
     ): Subscribable.Subscribable<T[I], E, R>
-    <T extends readonly [any, ...any[]], I extends number, E, R>(
-        index: I
-    ): (self: Subscribable.Subscribable<T, E, R>) => Subscribable.Subscribable<T[I], E, R>
 } = Function.dual(2, <T extends readonly [any, ...any[]], I extends number, E, R>(
     self: Subscribable.Subscribable<T, E, R>,
     index: I,
@@ -98,13 +98,13 @@ export const focusTupleAt: {
  * Narrows the focus to an indexed element of `Chunk`.
  */
 export const focusChunkAt: {
+    <A, E, R>(
+        index: number
+    ): (self: Subscribable.Subscribable<Chunk.Chunk<A>, E, R>) => Subscribable.Subscribable<A, E | NoSuchElementException, R>
     <A, E, R>(
         self: Subscribable.Subscribable<Chunk.Chunk<A>, E, R>,
         index: number,
     ): Subscribable.Subscribable<A, E | NoSuchElementException, R>
-    <A, E, R>(
-        index: number
-    ): (self: Subscribable.Subscribable<Chunk.Chunk<A>, E, R>) => Subscribable.Subscribable<A, E | NoSuchElementException, R>
 } = Function.dual(2, <A, E, R>(
     self: Subscribable.Subscribable<Chunk.Chunk<A>, E, R>,
     index: number,