From eea6bcac4de93a2f161b7f8cde2c15c4b73d05c1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Julien=20Valverd=C3=A9?= <julien.valverde@mailo.com>
Date: Tue, 24 Mar 2026 07:17:14 +0100
Subject: [PATCH] Update

---
 packages/effect-fc/src/Lens.ts | 84 +++++++++++++++++-----------------
 1 file changed, 42 insertions(+), 42 deletions(-)

diff --git a/packages/effect-fc/src/Lens.ts b/packages/effect-fc/src/Lens.ts
index 24ecfae..f0e46ad 100644
--- a/packages/effect-fc/src/Lens.ts
+++ b/packages/effect-fc/src/Lens.ts
@@ -4,7 +4,7 @@ import { Chunk, Effect, Function, Pipeable, Predicate, Readable, Stream, Subscri
 export const LensTypeId: unique symbol = Symbol.for("@effect-fc/Lens/Lens")
 export type LensTypeId = typeof LensTypeId
 
-export interface Lens<in out A, in out ER = never, in out RR = never, in out EW = never, in out RW = never>
+export interface Lens<in out A, in out ER = never, in out EW = never, in out RR = never, in out RW = never>
 extends Subscribable.Subscribable<A, ER, RR> {
     readonly [LensTypeId]: LensTypeId
 
@@ -13,8 +13,8 @@ extends Subscribable.Subscribable<A, ER, RR> {
     ) => Effect.Effect<B, ER | EW | E1, RR | RW | R1>
 }
 
-export class LensImpl<in out A, in out ER = never, in out RR = never, in out EW = never, in out RW = never>
-extends Pipeable.Class() implements Lens<A, ER, RR, EW, RW> {
+export class LensImpl<in out A, in out ER = never, in out EW = never, in out RR = never, in out RW = never>
+    extends Pipeable.Class() implements Lens<A, ER, EW, RR, RW> {
     readonly [Readable.TypeId]: Readable.TypeId = Readable.TypeId
     readonly [Subscribable.TypeId]: Subscribable.TypeId = Subscribable.TypeId
     readonly [LensTypeId]: LensTypeId = LensTypeId
@@ -34,7 +34,7 @@ extends Pipeable.Class() implements Lens<A, ER, RR, EW, RW> {
 export const isLens = (u: unknown): u is Lens<unknown, unknown, unknown, unknown, unknown> => Predicate.hasProperty(u, LensTypeId)
 
 
-export const make = <A, ER, RR, EW, RW>(
+export const make = <A, ER, EW, RR, RW>(
     options: {
         readonly get: Effect.Effect<A, ER, RR>
         readonly changes: Stream.Stream<A, ER, RR>
@@ -46,7 +46,7 @@ export const make = <A, ER, RR, EW, RW>(
         }
         | { readonly set: (a: A) => Effect.Effect<void, EW, RW> }
     )
-): Lens<A, ER, RR, EW, RW> => new LensImpl<A, ER, RR, EW, RW>(
+): Lens<A, ER, EW, RR, RW> => new LensImpl<A, ER, EW, RR, RW>(
     options.get,
     options.changes,
     Predicate.hasProperty(options, "modify")
@@ -71,11 +71,11 @@ export const fromSubscriptionRef = <A>(
 })
 
 
-export const map = <A, ER, RR, EW, RW, B>(
-    self: Lens<A, ER, RR, EW, RW>,
+export const map = <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, RR, EW, RW> => make({
+): Lens<B, ER, EW, RR, RW> => make({
     get get() { return Effect.map(self.get, get) },
     get changes() { return Stream.map(self.changes, get) },
     modify: <C, E1 = never, R1 = never>(
@@ -85,11 +85,11 @@ export const map = <A, ER, RR, EW, RW, B>(
     ),
 })
 
-export const mapEffect = <A, ER, RR, EW, RW, B, EGet = never, RGet = never, ESet = never, RSet = never>(
-    self: Lens<A, ER, RR, EW, RW>,
+export const mapEffect = <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, RR | RGet, EW | ESet, RW | RSet> => make({
+): Lens<B, ER | EGet, EW | ESet, RR | RGet, RW | RSet> => make({
     get get() { return Effect.flatMap(self.get, get) },
     get changes() { return Stream.mapEffect(self.changes, get) },
     modify: <C, E1 = never, R1 = never>(
@@ -106,33 +106,33 @@ export const mapEffect = <A, ER, RR, EW, RW, B, EGet = never, RGet = never, ESet
     )),
 })
 
-export const get = <A, ER, RR, EW, RW>(self: Lens<A, ER, RR, EW, RW>): Effect.Effect<A, ER, RR> => self.get
+export const get = <A, ER, EW, RR, RW>(self: Lens<A, ER, EW, RR, RW>): Effect.Effect<A, ER, RR> => self.get
 
 export const set: {
-    <A, ER, RR, EW, RW>(value: A): (self: Lens<A, ER, RR, EW, RW>) => Effect.Effect<void, ER | EW, RR | RW>
-    <A, ER, RR, EW, RW>(self: Lens<A, ER, RR, EW, RW>, value: A): Effect.Effect<void, ER | EW, RR | RW>
-} = Function.dual(2, <A, ER, RR, EW, RW>(self: Lens<A, ER, RR, EW, RW>, value: A) =>
+    <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)),
 )
 
 export const getAndSet: {
-    <A, ER, RR, EW, RW>(value: A): (self: Lens<A, ER, RR, EW, RW>) => Effect.Effect<A, ER | EW, RR | RW>
-    <A, ER, RR, EW, RW>(self: Lens<A, ER, RR, EW, RW>, value: A): Effect.Effect<A, ER | EW, RR | RW>
-} = Function.dual(2, <A, ER, RR, EW, RW>(self: Lens<A, ER, RR, EW, RW>, value: A) =>
+    <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)),
 )
 
 export const update: {
-    <A, ER, RR, EW, RW>(f: (a: A) => A): (self: Lens<A, ER, RR, EW, RW>) => Effect.Effect<void, ER | EW, RR | RW>
-    <A, ER, RR, EW, RW>(self: Lens<A, ER, RR, EW, RW>, f: (a: A) => A): Effect.Effect<void, ER | EW, RR | RW>
-} = Function.dual(2, <A, ER, RR, EW, RW>(self: Lens<A, ER, RR, EW, RW>, f: (a: A) => A) =>
+    <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)),
 )
 
 export const updateEffect: {
-    <A, ER, RR, EW, RW, E, R>(f: (a: A) => Effect.Effect<A, E, R>): (self: Lens<A, ER, RR, EW, RW>) => Effect.Effect<void, ER | EW | E, RR | RW | R>
-    <A, ER, RR, EW, RW, E, R>(self: Lens<A, ER, RR, EW, RW>, f: (a: A) => Effect.Effect<A, E, R>): Effect.Effect<void, ER | EW | E, RR | RW | R>
-} = Function.dual(2, <A, ER, RR, EW, RW, E, R>(self: Lens<A, ER, RR, EW, RW>, f: (a: A) => Effect.Effect<A, E, R>) =>
+    <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(
         f(a),
         next => Effect.succeed([void 0, next] as const),
@@ -140,16 +140,16 @@ export const updateEffect: {
 )
 
 export const getAndUpdate: {
-    <A, ER, RR, EW, RW>(f: (a: A) => A): (self: Lens<A, ER, RR, EW, RW>) => Effect.Effect<A, ER | EW, RR | RW>
-    <A, ER, RR, EW, RW>(self: Lens<A, ER, RR, EW, RW>, f: (a: A) => A): Effect.Effect<A, ER | EW, RR | RW>
-} = Function.dual(2, <A, ER, RR, EW, RW>(self: Lens<A, ER, RR, EW, RW>, f: (a: A) => A) =>
+    <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)),
 )
 
 export const getAndUpdateEffect: {
-    <A, ER, RR, EW, RW, E, R>(f: (a: A) => Effect.Effect<A, E, R>): (self: Lens<A, ER, RR, EW, RW>) => Effect.Effect<A, ER | EW | E, RR | RW | R>
-    <A, ER, RR, EW, RW, E, R>(self: Lens<A, ER, RR, EW, RW>, f: (a: A) => Effect.Effect<A, E, R>): Effect.Effect<A, ER | EW | E, RR | RW | R>
-} = Function.dual(2, <A, ER, RR, EW, RW, E, R>(self: Lens<A, ER, RR, EW, RW>, f: (a: A) => Effect.Effect<A, E, R>) =>
+    <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(
         f(a),
         next => Effect.succeed([a, next] as const)
@@ -157,16 +157,16 @@ export const getAndUpdateEffect: {
 )
 
 export const setAndGet: {
-    <A, ER, RR, EW, RW>(value: A): (self: Lens<A, ER, RR, EW, RW>) => Effect.Effect<A, ER | EW, RR | RW>
-    <A, ER, RR, EW, RW>(self: Lens<A, ER, RR, EW, RW>, value: A): Effect.Effect<A, ER | EW, RR | RW>
-} = Function.dual(2, <A, ER, RR, EW, RW>(self: Lens<A, ER, RR, EW, RW>, value: A) =>
+    <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)),
 )
 
 export const updateAndGet: {
-    <A, ER, RR, EW, RW>(f: (a: A) => A): (self: Lens<A, ER, RR, EW, RW>) => Effect.Effect<A, ER | EW, RR | RW>
-    <A, ER, RR, EW, RW>(self: Lens<A, ER, RR, EW, RW>, f: (a: A) => A): Effect.Effect<A, ER | EW, RR | RW>
-} = Function.dual(2, <A, ER, RR, EW, RW>(self: Lens<A, ER, RR, EW, RW>, f: (a: A) => A) =>
+    <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 => {
         const next = f(a)
         return Effect.succeed([next, next] as const)
@@ -174,18 +174,18 @@ export const updateAndGet: {
 )
 
 export const updateAndGetEffect: {
-    <A, ER, RR, EW, RW, E, R>(f: (a: A) => Effect.Effect<A, E, R>): (self: Lens<A, ER, RR, EW, RW>) => Effect.Effect<A, ER | EW | E, RR | RW | R>
-    <A, ER, RR, EW, RW, E, R>(self: Lens<A, ER, RR, EW, RW>, f: (a: A) => Effect.Effect<A, E, R>): Effect.Effect<A, ER | EW | E, RR | RW | R>
-} = Function.dual(2, <A, ER, RR, EW, RW, E, R>(self: Lens<A, ER, RR, EW, RW>, f: (a: A) => Effect.Effect<A, E, R>) =>
+    <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(
         f(a),
         next => Effect.succeed([next, next] as const),
     )),
 )
 
-export const unwrap = <A, ER, RR, EW, RW, E1, R1>(
-    effect: Effect.Effect<Lens<A, ER, RR, EW, RW>, E1, R1>
-): Lens<A, ER | E1, RR | R1, EW | E1, RW | R1> => make({
+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({
     get: Effect.flatMap(effect, l => l.get),
     changes: Stream.unwrap(Effect.map(effect, l => l.changes)),
     modify: <B, E2 = never, R2 = never>(