packages/effect-lens/README.md

@@ -137,9 +137,9 @@ const ref = yield* SubscriptionRef.make<{
 
 //                \/ Lens<User, NoSuchElementException, NoSuchElementException, never, never>
 const jeanDupontLens = ref.pipe(
-    Lens.fromSubscriptionRef,  // Creates a lens that proxies the ref
+    Lens.fromSubscriptionRef,     // Creates a lens that proxies the ref
-    Lens.focusObjectField("users"),  // Creates a focused lens that points to the users field
+    Lens.focusObjectOn("users"),  // Creates a focused lens that points to the users field
-    Lens.focusArrayAt(0),      // Creates a focused lens that points to the first entry of the user array
+    Lens.focusArrayAt(0),         // Creates a focused lens that points to the first entry of the user array
 )
 // Reading or writing from this lense can fail with NoSuchElementException
 // This is because of Lens.focusArrayAt(0), as reading and writing to an array is an unsafe operation
@@ -148,18 +148,18 @@ const jeanDupont = yield* Lens.get(jeanDupontLens)
 
 yield* Lens.set(
     // You can focus even further down
-    Lens.focusObjectField(jeanDupontLens, "age"),
+    Lens.focusObjectOn(jeanDupontLens, "age"),
     yield* DateTime.make("03/25/1970"),
 )
 // Mutations with the parent state are performed immutably by default
-// unless you use a specific mutable transform such as 'focusMutableField'
+// unless you use a specific mutable transform such as 'focusObjectOnWritable'
 ```
 
 Currently available:
 | Name | Description | Parent state mutation behavior | Notes |
 | - | - | - | - |
-| `focusObjectField` | Focuses to the field of an object. Replaces the parent object immutably when writing to the focused field | Immutable | |
+| `focusObjectOn` | Focuses to a field of an object. Replaces the parent object immutably when writing to the focused field | Immutable | |
-| `focusObjectMutableField` | Focuses to the writable field of an object. Mutates the parent object in place via the writable field | Mutable | Type-safe: will not allow you to mutate `readonly` fields |
+| `focusObjectOnWritable` | Focuses to a writable field of an object. Mutates the parent object in place via the writable field | Mutable | Type-safe: will not allow you to mutate `readonly` fields |
 | `focusArrayAt` | Focuses to an indexed entry of an array. Replaces the parent array immutably when writing to the focused index | Immutable | |
 | `focusMutableArrayAt` | Focuses to an indexed entry of an array. Mutates the parent array in place at the focused index | Mutable | Type-safe: will not allow you to mutate `readonly` arrays |
 | `focusTupleAt` | Focuses to an indexed entry of a readonly tuple. Replaces the parent tuple immutably when writing to the focused index | Immutable | |
@@ -216,7 +216,7 @@ const someFunctionThatShouldOnlyHaveReadonlyAccessToTheState = (
 
 const lens = ref.pipe(
     Lens.fromSubscriptionRef,
-    Lens.focusObjectField("users"),
+    Lens.focusObjectOn("users"),
 )
 yield* someFunctionThatShouldOnlyHaveReadonlyAccessToTheState(lens)
 ```
@@ -231,14 +231,14 @@ declare const sub: Subscribabe.Subscribable<readonly { name: string }[], never,
 //         \/ Subscribabe.Subscribable<string, NoSuchElementException, never>
 const nameSub = sub.pipe(
     Subscribable.focusArrayAt(1),
-    Subscribable.focusObjectField("name"),
+    Subscribable.focusObjectOn("name"),
 )
 ```
 
 Currently available:
 | Name | Description |
 | - | - |
-| `focusObjectField` | Focuses to the field of an object |
+| `focusObjectOn` | Focuses to the field of an object |
 | `focusArrayAt` | Focuses to an indexed entry of an array |
 | `focusTupleAt` | Focuses to an indexed entry of a tuple |
 | `focusChunkAt` | Focuses to an indexed entry of a `Chunk` |

packages/effect-lens/src/Lens.test.ts

@@ -54,12 +54,12 @@ describe("Lens", () => {
         expect(result[1]).toEqual(Option.some(50)) // 100 / 2
     })
 
-    test("focusObjectField focuses a nested property without touching other fields", async () => {
+    test("focusObjectOn focuses a nested property without touching other fields", async () => {
         const [initialCount, updatedState] = await Effect.runPromise(
             Effect.flatMap(
                 SubscriptionRef.make({ count: 1, label: "original" }),
                 parent => {
-                    const countLens = Lens.focusObjectField(Lens.fromSubscriptionRef(parent), "count")
+                    const countLens = Lens.focusObjectOn(Lens.fromSubscriptionRef(parent), "count")
                     return Effect.flatMap(
                         Lens.get(countLens),
                         count => Effect.flatMap(
@@ -75,13 +75,13 @@ describe("Lens", () => {
         expect(updatedState).toEqual({ count: 6, label: "original" })
     })
 
-    test("focusObjectMutableField preserves the root identity when mutating in place", async () => {
+    test("focusObjectOnWritable preserves the root identity when mutating in place", async () => {
         const original = { detail: "keep" }
         const updated = await Effect.runPromise(
             Effect.flatMap(
                 SubscriptionRef.make(original),
                 parent => {
-                    const detailLens = Lens.focusObjectMutableField(Lens.fromSubscriptionRef(parent), "detail")
+                    const detailLens = Lens.focusObjectOnWritable(Lens.fromSubscriptionRef(parent), "detail")
                     return Effect.flatMap(
                         Lens.set(detailLens, "mutated"),
                         () => parent.get,

packages/effect-lens/src/Lens.ts

@@ -273,7 +273,7 @@ export const mapStream: {
 /**
  * Narrows the focus to a field of an object. Replaces the object in an immutable fashion when written to.
  */
-export const focusObjectField: {
+export const focusObjectOn: {
     <A extends object, ER, EW, RR, RW, K extends keyof A>(
         self: Lens<A, ER, EW, RR, RW>,
         key: K,
@@ -290,7 +290,7 @@ export const focusObjectField: {
     (a, b) => Object.setPrototypeOf({ ...a, [key]: b }, Object.getPrototypeOf(a)),
 ))
 
-export declare namespace focusObjectMutableField {
+export declare namespace focusObjectOnWritable {
     export type WritableKeys<T> = {
         [K in keyof T]-?: IfEquals<
             { [P in K]: T[K] },
@@ -304,17 +304,17 @@ export declare namespace focusObjectMutableField {
 }
 
 /**
- * Narrows the focus to a mutable field of an object. Mutates the object in place when written to.
+ * Narrows the focus to a writable field of an object. Mutates the object in place when written to.
  */
-export const focusObjectMutableField: {
+export const focusObjectOnWritable: {
-    <A extends object, ER, EW, RR, RW, K extends focusObjectMutableField.WritableKeys<A>>(
+    <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 focusObjectMutableField.WritableKeys<A>>(
+    <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 focusObjectMutableField.WritableKeys<A>>(
+} = Function.dual(2, <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> => map(self, a => a[key], (a, b) => { a[key] = b; return a }))

packages/effect-lens/src/Subscribable.ts

@@ -42,7 +42,7 @@ export const mapOptionEffect: {
 /**
  * Narrows the focus to a field of an object.
  */
-export const focusObjectField: {
+export const focusObjectOn: {
     <A extends object, K extends keyof A, E, R>(
         self: Subscribable.Subscribable<A, E, R>,
         key: K,