packages/effect-lens/src/Lens.ts

@@ -47,17 +47,17 @@ extends Pipeable.Class() implements Lens<A, ER, EW, RR, RW> {
     readonly [LensTypeId]: LensTypeId = LensTypeId
     readonly [LensImplTypeId]: LensImplTypeId = LensImplTypeId
 
-    abstract readonly access: Effect.Effect<LensImpl.Frame<A, EW, RW>, ER, RR>
+    abstract readonly resolve: Effect.Effect<LensImpl.Frame<A, EW, RW>, ER, RR>
     abstract readonly changes: Stream.Stream<A, ER, RR>
     abstract readonly withLock: <A1, E1, R1>(self: Effect.Effect<A1, E1, R1>) => Effect.Effect<A1, EW | E1, RW | R1>
 
-    get get() { return Effect.map(this.access, frame => frame.value) }
+    get get() { return Effect.map(this.resolve, frame => frame.value) }
 
     modifyEffect<B, E1 = never, R1 = never>(
         f: (a: A) => Effect.Effect<readonly [B, A], E1, R1>,
     ): Effect.Effect<B, ER | EW | E1, RR | RW | R1> {
         return this.withLock(Effect.flatMap(
-            this.access,
+            this.resolve,
             frame => Effect.flatMap(
                 f(frame.value),
                 ([c, next]) => Effect.as(frame.commit(Effect.succeed(next)), c),
@@ -94,7 +94,7 @@ extends LensImpl<A, ER, EW, RR, RW> {
         super()
     }
 
-    get access(): Effect.Effect<LensImpl.Frame<A, EW, RW>, ER, RR> {
+    get resolve(): Effect.Effect<LensImpl.Frame<A, EW, RW>, ER, RR> {
         return Effect.map(
             this.source.get,
             value => ({
@@ -128,7 +128,7 @@ export declare namespace DerivedLensImpl {
         in out RW = never,
         in out RSW = never,
     > {
-        readonly access: (effect: Effect.Effect<LensImpl.Frame<B, ESW, RSW>, ESR, RSR>) => Effect.Effect<LensImpl.Frame<A, EW, RW>, ER, RR>
+        readonly resolve: (effect: Effect.Effect<LensImpl.Frame<B, ESW, RSW>, ESR, RSR>) => Effect.Effect<LensImpl.Frame<A, EW, RW>, ER, RR>
         readonly transformStream: (stream: Stream.Stream<B, ESR, RSR>) => Stream.Stream<A, ER, RR>
     }
 }
@@ -153,7 +153,7 @@ extends LensImpl<A, ER, EW, RR, RW> {
         super()
     }
 
-    get access() { return this.source.access(this.parent.access) }
+    get resolve() { return this.source.resolve(this.parent.resolve) }
     get changes() { return this.source.transformStream(this.parent.changes) }
     get withLock() { return this.parent.withLock }
 }
@@ -191,7 +191,7 @@ extends LensImpl<A, never, never, never, never> {
         super()
     }
 
-    get access(): Effect.Effect<LensImpl.Frame<A>, never, never> {
+    get resolve(): Effect.Effect<LensImpl.Frame<A>, never, never> {
         return Effect.map(
             this.ref.get,
             value => ({
@@ -234,7 +234,7 @@ extends LensImpl<A, never, never, never, never> {
         super()
     }
 
-    get access(): Effect.Effect<LensImpl.Frame<A>, never, never> {
+    get resolve(): Effect.Effect<LensImpl.Frame<A>, never, never> {
         return Effect.map(
             this.ref.get,
             value => ({
@@ -272,7 +272,7 @@ export const unwrap = <A, ER, EW, RR, RW, E1, R1>(
     changes: Stream.unwrap(Effect.map(effect, l => l.changes)),
     commit: a => Effect.flatMap(
         effect,
-        l => Effect.flatMap(asLensImpl(l).access, frame => frame.commit(Effect.succeed(a))),
+        l => Effect.flatMap(asLensImpl(l).resolve, frame => frame.commit(Effect.succeed(a))),
     ),
     withLock: <A1, E1, R1>(self: Effect.Effect<A1, E1, R1>) => Effect.flatMap(effect, l => asLensImpl(l).withLock(self)),
 })
@@ -318,7 +318,7 @@ export const mapEffect: {
     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> => derive(self, {
-    access: parent => Effect.flatMap(
+    resolve: parent => Effect.flatMap(
         parent,
         frame => Effect.map(
             get(frame.value),
@@ -412,7 +412,7 @@ export const mapStream: {
     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> => derive(self, {
-    access: identity,
+    resolve: identity,
     transformStream: f,
 }))
 
@@ -434,7 +434,7 @@ export const mapErrorRead: {
     self: Lens<A, ER, EW, RR, RW>,
     f: (error: NoInfer<ER>) => E2,
 ): Lens<A, E2, EW, RR, RW> => derive(self, {
-    access: Effect.mapError(f),
+    resolve: Effect.mapError(f),
     transformStream: Stream.mapError(f),
 }))
 
@@ -456,7 +456,7 @@ export const mapErrorWrite: {
     self: Lens<A, ER, EW, RR, RW>,
     f: (error: unknown) => E2,
 ): Lens<A, ER, E2, RR, RW> => derive(self, {
-    access: parent => Effect.map(parent, frame => ({
+    resolve: parent => Effect.map(parent, frame => ({
         value: frame.value,
         commit: next => Effect.mapError(frame.commit(next), f),
     })),
@@ -481,7 +481,7 @@ export const mapError: {
     self: Lens<A, ER, EW, RR, RW>,
     f: (error: unknown) => E2,
 ): Lens<A, E2, E2, RR, RW> => derive(self, {
-    access: parent => Effect.map(
+    resolve: parent => Effect.map(
         Effect.mapError(parent, f),
         frame => ({
             value: frame.value,
@@ -508,7 +508,7 @@ export const catchAllRead: {
     self: Lens<A, ER, EW, RR, RW>,
     f: (error: NoInfer<ER>) => Subscribable.Subscribable<A, E2, R2>,
 ): Lens<A, E2, EW, RR | R2, RW> => derive(self, {
-    access: Effect.catchAll(error => asLensImpl(f(error) as Lens<A, E2, EW, R2, RW>).access),
+    resolve: Effect.catchAll(error => asLensImpl(f(error) as Lens<A, E2, EW, R2, RW>).resolve),
     transformStream: Stream.catchAll(error => f(error).changes),
 }))
 
@@ -529,7 +529,7 @@ export const tapErrorRead: {
     self: Lens<A, ER, EW, RR, RW>,
     f: (error: NoInfer<ER>) => Effect.Effect<any, E2, R2>,
 ): Lens<A, ER | E2, EW, RR | R2, RW> => derive(self, {
-    access: Effect.tapError(f),
+    resolve: Effect.tapError(f),
     transformStream: Stream.tapError(f),
 }))
 
@@ -551,7 +551,7 @@ export const tapErrorWrite: {
     self: Lens<A, ER, EW, RR, RW>,
     f: (error: unknown) => Effect.Effect<any, E2, R2>,
 ): Lens<A, ER, EW | E2, RR, RW | R2> => derive(self, {
-    access: parent => Effect.map(parent, frame => ({
+    resolve: parent => Effect.map(parent, frame => ({
         value: frame.value,
         commit: next => Effect.tapError(frame.commit(next), f),
     })),
@@ -576,7 +576,7 @@ export const tapError: {
     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> => derive(self, {
-    access: parent => Effect.map(
+    resolve: parent => Effect.map(
         Effect.tapError(parent, f),
         frame => ({
             value: frame.value,
@@ -602,7 +602,7 @@ export const provideContext: {
     self: Lens<A, ER, EW, RR, RW>,
     context: Context.Context<R2>,
 ): Lens<A, ER, EW, Exclude<RR, R2>, Exclude<RW, R2>> => derive(self, {
-    access: parent => Effect.map(
+    resolve: parent => Effect.map(
         Effect.provide(parent, context),
         frame => ({
             value: frame.value,
@@ -633,7 +633,7 @@ export const provideService: {
     tag: Context.Tag<I, S>,
     service: NoInfer<S>,
 ): Lens<A, ER, EW, Exclude<RR, I>, Exclude<RW, I>> => derive(self, {
-    access: parent => Effect.map(
+    resolve: parent => Effect.map(
         Effect.provideService(parent, tag, service),
         frame => ({
             value: frame.value,