0.2.1 + 2.0.0-beta.1 (#7)

Co-authored-by: Julien Valverdé <julien.valverde@mailo.com> Reviewed-on: #7
2026-07-17 00:15:45 +02:00
parent fd0e84f136
commit 078dfc7712
14 changed files with 490 additions and 367 deletions
@@ -16,7 +16,7 @@
    },
    "packages/effect-lens": {
      "name": "effect-lens",
-      "version": "0.2.0",
+      "version": "0.2.1",
      "devDependencies": {
        "effect": "^3.21.0",
      },
@@ -26,12 +26,12 @@
    },
    "packages/effect-lens-next": {
      "name": "effect-lens-next",
-      "version": "0.1.0-beta.0",
+      "version": "2.0.0-beta.1",
      "devDependencies": {
-        "effect": "4.0.0-beta.85",
+        "effect": "4.0.0-beta.98",
      },
      "peerDependencies": {
-        "effect": "4.0.0-beta.85",
+        "effect": "4.0.0-beta.98",
      },
    },
    "packages/example": {
@@ -185,7 +185,7 @@

    "pure-rand": ["pure-rand@6.1.0", "", {}, "sha512-bVWawvoZoBYpp6yIoQtQXHZjmz35RSVHnUOTefl8Vcjr8snTPY1wnpSPMWekcFwbxI6gtmT7rSYPFvz71ldiOA=="],

-    "toml": ["toml@4.1.1", "", {}, "sha512-EBJnVBr3dTXdA89WVFoAIPUqkBjxPMwRqsfuo1r240tKFHXv3zgca4+NJib/h6TyvGF7vOawz0jGuryJCdNHrw=="],
+    "toml": ["toml@4.3.0", "", {}, "sha512-lVb8X9BsPVuH0M4BKeS91tXAmJvCjQ5UIyAbQFaxkKGyUFK2RPkhwaFSQH8vbpl1d23eu/IBH+dwVMHWaq9A5A=="],

    "turbo": ["turbo@2.9.18", "", { "optionalDependencies": { "@turbo/darwin-64": "2.9.18", "@turbo/darwin-arm64": "2.9.18", "@turbo/linux-64": "2.9.18", "@turbo/linux-arm64": "2.9.18", "@turbo/windows-64": "2.9.18", "@turbo/windows-arm64": "2.9.18" }, "bin": { "turbo": "bin/turbo" } }, "sha512-bwabv6PupzeavybzEoArBAkwq5fnzwf8OFnRtpHwnviFWuwJPFxtyH+aVp36TmIqK3aYYgtTJ3J0m2ysxxSzQg=="],

@@ -203,12 +203,14 @@

    "@effect/sql/uuid": ["uuid@11.1.1", "", { "bin": { "uuid": "dist/esm/bin/uuid" } }, "sha512-vIYxrBCC/N/K+Js3qSN88go7kIfNPssr/hHCesKCQNAjmgvYS2oqr69kIufEG+O4+PfezOH4EbIeHCfFov8ZgQ=="],

-    "effect-lens-next/effect": ["effect@4.0.0-beta.85", "", { "dependencies": { "@standard-schema/spec": "^1.1.0", "fast-check": "^4.8.0", "find-my-way-ts": "^0.1.6", "ini": "^7.0.0", "kubernetes-types": "^1.30.0", "msgpackr": "^2.0.1", "multipasta": "^0.2.7", "toml": "^4.1.1", "uuid": "^14.0.0", "yaml": "^2.9.0" } }, "sha512-Cjv9YQyv4CiIccmRAQIWAoeESCpCpiuHYY8zb5vqiYs3Ac2yE5RQAnKq7z4Ir/3VJYZb8kxh6rS8czDDnpTdkQ=="],
+    "effect-lens-next/effect": ["effect@4.0.0-beta.98", "", { "dependencies": { "@standard-schema/spec": "^1.1.0", "fast-check": "^4.9.0", "find-my-way-ts": "^0.1.6", "ini": "^7.0.0", "kubernetes-types": "^1.30.0", "msgpackr": "^2.0.4", "multipasta": "^0.2.8", "toml": "^4.1.2", "uuid": "^14.0.1", "yaml": "^2.9.0" } }, "sha512-oz+bsG5h+6RNrw4t5GMfQrk/xBS8ROoqkYsuvRhBr5O7mCOrpvH/hbw+QrDzvKIpX4HJClwm86F94c87W0sJxg=="],

-    "effect-lens-next/effect/fast-check": ["fast-check@4.8.0", "", { "dependencies": { "pure-rand": "^8.0.0" } }, "sha512-GOJ158CUMnN6cSahsv4+ExARvIDuzzinFjkp0E9WtiBa5zcVeLozVkWaE4IzFcc+Y48Wp1EDlUZsXRyAztQcSg=="],
+    "effect-lens-next/effect/fast-check": ["fast-check@4.9.0", "", { "dependencies": { "pure-rand": "^8.0.0" } }, "sha512-7ms6T7SybUev/PQITciI0yLM2pOSFy5zpG8Ty7tQofcVaQUvrMXp6CBwqF6fThLCLOrfBtuHAtwq6Yu4XPCllg=="],

    "effect-lens-next/effect/msgpackr": ["msgpackr@2.0.4", "", { "optionalDependencies": { "msgpackr-extract": "^3.0.4" } }, "sha512-o1C5KRmuRt+apqMr1HuGSqWStZoRBUpEsCsl15uM9VdAF1qHLtvMOU2En747EnTyEl6c4pzPewRMFF31s1CNbA=="],

+    "effect-lens-next/effect/multipasta": ["multipasta@0.2.8", "", {}, "sha512-ZPWuMKyv0cSO29f7hozp+k6+crZbQijV8ipMvxNxRf2SwtYGTX1ZX89Kd20VV4H9Znonx+EQn+iy1wGQsJ+b+Q=="],
+
    "effect-lens-next/effect/fast-check/pure-rand": ["pure-rand@8.4.0", "", {}, "sha512-IoM8YF/jY0hiugFo/wOWqfmarlE6J0wc6fDK1PhftMk7MGhVZl88sZimmqBBFomLOCSmcCCpsfj7wXASCpvK9A=="],
  }
 }
@@ -4,13 +4,13 @@ A Lens type for [Effect](https://effect.website/) to easily manage nested state.

 ## Install
 ```
-npm install effect-lens@beta effect@4.0.0-beta.85
-yarn add effect-lens@beta effect@4.0.0-beta.85
-bun add effect-lens@beta effect@4.0.0-beta.85
+npm install effect-lens@beta effect@4.0.0-beta.98
+yarn add effect-lens@beta effect@4.0.0-beta.98
+bun add effect-lens@beta effect@4.0.0-beta.98
 ```

 ## Peer dependencies
- `effect` 4.0.0-beta.85
+- `effect` 4.0.0-beta.98


 ## Quickstart
@@ -48,7 +48,7 @@ const lens = Lens.fromSubscriptionRef(ref)
 //       ^ Lens.Lens<number[], never, never, never, never>

 const value = yield* Lens.get(lens)
-yield* Effect.forkScoped(Stream.runForEach(lens.changes, Console.log))
+yield* Effect.forkScoped(Stream.runForEach(Lens.changes(lens), Console.log))
 yield* Lens.updateEffect(lens, values =>
    Effect.fromOption(Array.replace(values, 1, 1664))
 )
@@ -64,7 +64,7 @@ You can also create Lenses manually using `make` by providing:
 - `get`: an effect that reads the current value,
 - `changes`: a stream of value changes,
 - `commit`: an effectful write primitive,
- `lock`: an effect that produces the lock used to serialize writes.
+- `lock`: an effect that produces the lock used to serialize writes and preserve atomicity.

 You can get pretty creative! Here's an example of a Lens that points to a specific key of the browser `LocalStorage`:
 ```typescript
@@ -101,9 +101,6 @@ const lens = Effect.all([
 )
 ```

-Note: while Lens supports asynchronous effects for the proxy logic, we would recommend keeping them synchronous to preserve atomicity.
-
-
 ### Focusing

 Lenses can focus on a nested part of the data type they point to.
@@ -240,41 +237,44 @@ const nameLens = lens.pipe(
 ```


-### Subscribable
+### View

-Effect 4 no longer provides `Subscribable` and `Readable`. This library provides its own `Subscribable` interface, which you can use as a constraint to allow some parts of your app to only read and subscribe to the Lenses you provide them:
+A `View` is a read-only, reactive view of a value: it lets you read the current value and observe subsequent changes. Every `Lens` is also a `View`, which you can use as a constraint to allow some parts of your app to only read and subscribe to the Lenses you provide them. It replaces Effect v3's `Subscribable` module:
 ```typescript
 const ref = yield* SubscriptionRef.make<{
    readonly users: readonly User[]
-}>({ users: [...] })
+}>({ users: [] })

-const someFunctionThatShouldOnlyHaveReadonlyAccessToTheState = (
-    usersSub: Subscribable.Subscribable<readonly User[], never, never>
-) => Effect.gen(function*() {
-    // Do whatever
-    const usersCountSub = Subscribable.map(usersSub, a => a.length)
-    const users = yield* usersSub.get
-    yield* Effect.forkScoped(Stream.runForEach(usersSub.changes, ...))
+const logUserCount = (users: View.View<readonly User[]>) =>
+    Effect.gen(function*() {
+        const userCount = View.focusArrayLength(users)
+        yield* Console.log(`There are ${yield* View.get(userCount)} users`)
+        yield* Stream.runForEach(
+            View.changes(userCount),
+            count => Console.log(`There are now ${count} users`),
+        )
    })

-const lens = ref.pipe(
+const usersLens = ref.pipe(
    Lens.fromSubscriptionRef,
    Lens.focusObjectOn("users"),
 )
-yield* someFunctionThatShouldOnlyHaveReadonlyAccessToTheState(lens)
+yield* Effect.forkScoped(logUserCount(usersLens))
 ```

+Use `Lens.asView` when you want to make that read-only boundary explicit.
+
 #### Focusing
-This library provides a `Subscribable` module with value and error transforms, recovery (`catch`, `catchCause`, `orElse`, `orElseSucceed`, and `retry`), and transforms to narrow the focus of `Subscribable`'s, same as Lenses:
+Views can be focused in the same way as Lenses. The `View` module also provides value and error transforms, plus recovery (`catch`, `catchCause`, `orElse`, `orElseSucceed`, and `retry`):
 ```typescript
-import { Subscribable } from "effect-lens"
+import { View } from "effect-lens"

-declare const sub: Subscribable.Subscribable<readonly { name: string }[], never, never>
+declare const view: View.View<readonly { name: string }[], never, never>

-//         \/ Subscribable.Subscribable<string, NoSuchElementError, never>
-const nameSub = sub.pipe(
-    Subscribable.focusArrayAt(1),
-    Subscribable.focusObjectOn("name"),
+//         \/ View.View<string, NoSuchElementError, never>
+const nameView = view.pipe(
+    View.focusArrayAt(1),
+    View.focusObjectOn("name"),
 )
 ```

@@ -1,7 +1,7 @@
 {
  "name": "effect-lens-next",
  "description": "An effectful Lens type to easily manage nested state",
-  "version": "2.0.0-beta.0",
+  "version": "2.0.0-beta.1",
  "type": "module",
  "files": [
    "./README.md",
@@ -21,9 +21,9 @@
      "types": "./dist/Lens.d.ts",
      "default": "./dist/Lens.js"
    },
-    "./Subscribable": {
-      "types": "./dist/Subscribable.d.ts",
-      "default": "./dist/Subscribable.js"
+    "./View": {
+      "types": "./dist/View.d.ts",
+      "default": "./dist/View.js"
    }
  },
  "scripts": {
@@ -36,9 +36,9 @@
    "clean:modules": "rm -rf node_modules"
  },
  "peerDependencies": {
-    "effect": "4.0.0-beta.85"
+    "effect": "4.0.0-beta.98"
  },
  "devDependencies": {
-    "effect": "4.0.0-beta.85"
+    "effect": "4.0.0-beta.98"
  }
 }
@@ -187,7 +187,7 @@ describe("Lens", () => {
        expect(result[1]).toBe(25)
    })

-    test("Ref and SynchronizedRef adapters read and update their sources", async () => {
+    test("Ref, SynchronizedRef, and SubscriptionRef adapters read and update their sources", async () => {
        const result = await Effect.runPromise(Effect.gen(function*() {
            const ref = yield* Ref.make(1)
            const refLens = yield* Lens.fromRef(ref)
@@ -195,12 +195,20 @@ describe("Lens", () => {

            const synchronizedRef = yield* SynchronizedRef.make(10)
            const synchronizedLens = Lens.fromSynchronizedRef(synchronizedRef)
-            yield* Lens.updateEffect(synchronizedLens, n => Effect.succeed(n + 5))
+            yield* Lens.update(synchronizedLens, n => n + 5)

-            return [yield* Ref.get(ref), yield* SynchronizedRef.get(synchronizedRef)] as const
+            const subscriptionRef = yield* SubscriptionRef.make(100)
+            const subscriptionLens = Lens.fromSubscriptionRef(subscriptionRef)
+            yield* Lens.update(subscriptionLens, n => n + 2)
+
+            return [
+                yield* Ref.get(ref),
+                yield* SynchronizedRef.get(synchronizedRef),
+                yield* SubscriptionRef.get(subscriptionRef),
+            ] as const
        }))

-        expect(result).toEqual([2, 15])
+        expect(result).toEqual([2, 15, 102])
    })

    test("modifyEffect updates are atomic under concurrency", async () => {
@@ -1,25 +1,8 @@
-import {
-    Array,
-    type Cause,
-    Chunk,
-    type Context,
-    Effect,
-    Function,
-    identity,
-    Option,
-    Pipeable,
-    Predicate,
-    PubSub,
-    Ref,
-    Semaphore,
-    Stream,
-    SubscriptionRef,
-    SynchronizedRef,
-} from "effect"
-import * as Subscribable from "./Subscribable.js"
+import { Array, type Cause, Chunk, type Context, Effect, Function, identity, Option, Pipeable, Predicate, PubSub, Ref, Semaphore, Stream, SubscriptionRef, SynchronizedRef } from "effect"
+import * as View from "./View.js"


-export const LensTypeId: unique symbol = Symbol.for("@effect-fc/Lens/v4/Lens")
+export const LensTypeId: unique symbol = Symbol.for("@effect-lens/Lens/Lens")
 export type LensTypeId = typeof LensTypeId

 /**
@@ -29,8 +12,8 @@ export type LensTypeId = typeof LensTypeId
 * 2. a `changes` stream that emits every subsequent update to `A`, and
 * 3. a `modify` effect that can transform the current value.
 */
-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> {
+export interface Lens<in out A, out ER = never, out EW = never, out RR = never, out RW = never>
+extends View.View<A, ER, RR> {
    readonly [LensTypeId]: LensTypeId

    readonly modifyEffect: <B, E1 = never, R1 = never>(
@@ -52,7 +35,7 @@ export const LensImplTypeId: unique symbol = Symbol.for("@effect-fc/Lens/v4/Lens
 export type LensImplTypeId = typeof LensImplTypeId

 export declare namespace LensImpl {
-    export interface Resolved<in out A, in out EW = never, in out RW = never> {
+    export interface Resolved<in out A, out EW = never, out RW = never> {
        readonly value: A
        readonly commit: <E = never, R = never>(
            next: Effect.Effect<A, E, R>
@@ -64,9 +47,9 @@ export declare namespace LensImpl {
    }
 }

-export abstract class LensImpl<in out A, in out ER = never, in out EW = never, in out RR = never, in out RW = never>
+export abstract class LensImpl<in out A, out ER = never, out EW = never, out RR = never, out RW = never>
 extends Pipeable.Class implements Lens<A, ER, EW, RR, RW> {
-    readonly [Subscribable.SubscribableTypeId]: Subscribable.SubscribableTypeId = Subscribable.SubscribableTypeId
+    readonly [View.ViewTypeId]: View.ViewTypeId = View.ViewTypeId
    readonly [LensTypeId]: LensTypeId = LensTypeId
    readonly [LensImplTypeId]: LensImplTypeId = LensImplTypeId

@@ -120,13 +103,13 @@ export const asLensImpl = <A, ER, EW, RR, RW>(
    return lens as LensImpl<A, ER, EW, RR, RW>
 }

-export const asSubscribable = <A, ER, EW, RR, RW>(
+export const asView = <A, ER, EW, RR, RW>(
    lens: Lens<A, ER, EW, RR, RW>
-): Subscribable.Subscribable<A, ER, RR> => lens
+): View.View<A, ER, RR> => lens


 export declare namespace LensLazyImpl {
-    export interface Source<in out A, in out ER = never, in out EW = never, in out RR = never, in out RW = never> {
+    export interface Source<in out A, out ER = never, out EW = never, out RR = never, out RW = never> {
        readonly get: Effect.Effect<A, ER, RR>
        readonly changes: Stream.Stream<A, ER, RR>
        readonly commit: (a: A) => Effect.Effect<void, EW, RW>
@@ -134,7 +117,7 @@ export declare namespace LensLazyImpl {
    }
 }

-export class LensLazyImpl<in out A, in out ER = never, in out EW = never, in out RR = never, in out RW = never>
+export class LensLazyImpl<in out A, out ER = never, out EW = never, out RR = never, out RW = never>
 extends LensImpl<A, ER, EW, RR, RW> {
    constructor(
        readonly source: LensLazyImpl.Source<A, ER, EW, RR, RW>,
@@ -163,7 +146,7 @@ export const make = <A, ER, EW, RR, RW>(
 ): Lens<A, ER, EW, RR, RW> => new LensLazyImpl(source)


-export class UnwrappedLensImpl<in out A, in out ER, in out EW, in out RR, in out RW, in out E1, in out R1>
+export class UnwrappedLensImpl<in out A, out ER, out EW, out RR, out RW, out E1, out R1>
 extends LensImpl<A, ER | E1, EW | E1, RR | R1, RW | R1> {
    constructor(
        readonly effect: Effect.Effect<Lens<A, ER, EW, RR, RW>, E1, R1>
@@ -912,6 +895,11 @@ 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

+/**
+ * Returns the stream of changes from a `Lens`.
+ */
+export const changes = <A, ER, EW, RR, RW>(self: Lens<A, ER, EW, RR, RW>): Stream.Stream<A, ER, RR> => self.changes
+
 /**
 * Atomically modifies the value of a `Lens` and returns a computed result.
 */
@@ -1,246 +0,0 @@
-import { Array, type Cause, Chunk, Effect, Function, Iterable, Option, Pipeable, Predicate, type Result, type Schedule, Stream } from "effect"
-
-
-export const SubscribableTypeId: unique symbol = Symbol.for("@effect-fc/Lens/v4/Subscribable")
-export type SubscribableTypeId = typeof SubscribableTypeId
-
-export interface Subscribable<in out A, in out E = never, in out R = never> extends Pipeable.Pipeable {
-    readonly [SubscribableTypeId]: SubscribableTypeId
-    readonly get: Effect.Effect<A, E, R>
-    readonly changes: Stream.Stream<A, E, R>
-}
-
-export const isSubscribable = (u: unknown): u is Subscribable<unknown, unknown, unknown> => Predicate.hasProperty(u, SubscribableTypeId)
-
-
-export const SubscribableImplTypeId: unique symbol = Symbol.for("@effect-fc/Lens/v4/SubscribableImpl")
-export type SubscribableImplTypeId = typeof SubscribableImplTypeId
-
-export declare namespace SubscribableImpl {
-    export interface Source<in out A, in out E = never, in out R = never> {
-        readonly get: Effect.Effect<A, E, R>
-        readonly changes: Stream.Stream<A, E, R>
-    }
-}
-
-export class SubscribableImpl<in out A, in out E = never, in out R = never>
-extends Pipeable.Class implements Subscribable<A, E, R> {
-    readonly [SubscribableTypeId]: SubscribableTypeId = SubscribableTypeId
-    readonly [SubscribableImplTypeId]: SubscribableImplTypeId = SubscribableImplTypeId
-
-    constructor(
-        readonly source: SubscribableImpl.Source<A, E, R>,
-    ) {
-        super()
-    }
-
-    get get() { return this.source.get }
-    get changes() { return this.source.changes }
-}
-
-export const isSubscribableImpl = (u: unknown): u is SubscribableImpl<unknown, unknown, unknown> => Predicate.hasProperty(u, SubscribableImplTypeId)
-
-export const asSubscribableImpl = <A, E, R>(
-    subscribable: Subscribable<A, E, R>
-): SubscribableImpl<A, E, R> => {
-    if (!isSubscribableImpl(subscribable))
-        throw new Error("Not a 'SubscribableImpl'")
-    return subscribable as SubscribableImpl<A, E, R>
-}
-
-export const make = <A, E, R>(
-    source: SubscribableImpl.Source<A, E, R>
-): Subscribable<A, E, R> => new SubscribableImpl(source)
-
-export const unwrap = <A, E, R, E1, R1>(
-    effect: Effect.Effect<Subscribable<A, E, R>, E1, R1>,
-): Subscribable<A, E | E1, R | R1> => make({
-    get: Effect.flatMap(effect, self => self.get),
-    changes: Stream.unwrap(Effect.map(effect, self => self.changes)),
-})
-
-
-export const map: {
-    <A, B>(f: (a: NoInfer<A>) => B): <E, R>(self: Subscribable<A, E, R>) => Subscribable<B, E, R>
-    <A, E, R, B>(self: Subscribable<A, E, R>, f: (a: NoInfer<A>) => B): Subscribable<B, E, R>
-} = Function.dual(2, <A, E, R, B>(self: Subscribable<A, E, R>, f: (a: NoInfer<A>) => B) => make({
-    get get() { return Effect.map(self.get, f) },
-    get changes() { return Stream.map(self.changes, f) },
-}))
-
-export const mapEffect: {
-    <A, B, E2, R2>(f: (a: NoInfer<A>) => Effect.Effect<B, E2, R2>): <E, R>(self: Subscribable<A, E, R>) => Subscribable<B, E | E2, R | R2>
-    <A, E, R, B, E2, R2>(self: Subscribable<A, E, R>, f: (a: NoInfer<A>) => Effect.Effect<B, E2, R2>): Subscribable<B, E | E2, R | R2>
-} = Function.dual(2, <A, E, R, B, E2, R2>(
-    self: Subscribable<A, E, R>,
-    f: (a: NoInfer<A>) => Effect.Effect<B, E2, R2>,
-) => make({
-    get get() { return Effect.flatMap(self.get, f) },
-    get changes() { return Stream.mapEffect(self.changes, f) },
-}))
-
-/** Maps over an `Option` value in the `Subscribable`. */
-export const mapOption: {
-    <A, B>(f: (a: A) => B): <E, R>(self: Subscribable<Option.Option<A>, E, R>) => Subscribable<Option.Option<B>, E, R>
-    <A, B, E, R>(self: Subscribable<Option.Option<A>, E, R>, f: (a: A) => B): Subscribable<Option.Option<B>, E, R>
-} = Function.dual(2, <A, B, E, R>(self: Subscribable<Option.Option<A>, E, R>, f: (a: A) => B) =>
-    map(self, Option.map(f)),
-)
-
-/** Maps over an `Option` value in the `Subscribable` with an Effect. */
-export const mapOptionEffect: {
-    <A, B, E2, R2>(f: (a: A) => Effect.Effect<B, E2, R2>): <E, R>(self: Subscribable<Option.Option<A>, E, R>) => Subscribable<Option.Option<B>, E | E2, R | R2>
-    <A, B, E, R, E2, R2>(self: Subscribable<Option.Option<A>, E, R>, f: (a: A) => Effect.Effect<B, E2, R2>): Subscribable<Option.Option<B>, E | E2, R | R2>
-} = Function.dual(2, <A, B, E, R, E2, R2>(
-    self: Subscribable<Option.Option<A>, E, R>,
-    f: (a: A) => Effect.Effect<B, E2, R2>,
-) => mapEffect(self, Option.match({
-    onSome: a => Effect.map(f(a), Option.some),
-    onNone: () => Effect.succeed(Option.none()),
-})))
-
-
-/** Maps errors from both the current value and the stream of changes. */
-export const mapError: {
-    <E, E2>(f: (error: NoInfer<E>) => E2): <A, R>(self: Subscribable<A, E, R>) => Subscribable<A, E2, R>
-    <A, E, R, E2>(self: Subscribable<A, E, R>, f: (error: NoInfer<E>) => E2): Subscribable<A, E2, R>
-} = Function.dual(2, <A, E, R, E2>(
-    self: Subscribable<A, E, R>,
-    f: (error: NoInfer<E>) => E2,
-) => make({
-    get get() { return Effect.mapError(self.get, f) },
-    get changes() { return Stream.mapError(self.changes, f) },
-}))
-
-/** Runs an effect when either the current value or the stream of changes fails. */
-export const tapError: {
-    <E, B, E2, R2>(f: (error: NoInfer<E>) => Effect.Effect<B, E2, R2>): <A, R>(self: Subscribable<A, E, R>) => Subscribable<A, E | E2, R | R2>
-    <A, E, R, B, E2, R2>(self: Subscribable<A, E, R>, f: (error: NoInfer<E>) => Effect.Effect<B, E2, R2>): Subscribable<A, E | E2, R | R2>
-} = Function.dual(2, <A, E, R, B, E2, R2>(
-    self: Subscribable<A, E, R>,
-    f: (error: NoInfer<E>) => Effect.Effect<B, E2, R2>,
-) => make({
-    get get() { return Effect.tapError(self.get, f) },
-    get changes() { return Stream.tapError(self.changes, f) },
-}))
-
-const catch_: {
-    <E, B, E2, R2>(f: (error: NoInfer<E>) => Subscribable<B, E2, R2>): <A, R>(self: Subscribable<A, E, R>) => Subscribable<A | B, E2, R | R2>
-    <A, E, R, B, E2, R2>(self: Subscribable<A, E, R>, f: (error: NoInfer<E>) => Subscribable<B, E2, R2>): Subscribable<A | B, E2, R | R2>
-} = Function.dual(2, <A, E, R, B, E2, R2>(
-    self: Subscribable<A, E, R>,
-    f: (error: NoInfer<E>) => Subscribable<B, E2, R2>,
-) => make({
-    get get() { return Effect.catch(self.get, error => f(error).get) },
-    get changes() { return Stream.catch(self.changes, error => f(error).changes) },
-}))
-
-/** Recovers from typed errors with another `Subscribable`. */
-export { catch_ as catch }
-
-/** Recovers from all failure causes with another `Subscribable`. */
-export const catchCause: {
-    <E, B, E2, R2>(f: (cause: Cause.Cause<NoInfer<E>>) => Subscribable<B, E2, R2>): <A, R>(self: Subscribable<A, E, R>) => Subscribable<A | B, E2, R | R2>
-    <A, E, R, B, E2, R2>(self: Subscribable<A, E, R>, f: (cause: Cause.Cause<NoInfer<E>>) => Subscribable<B, E2, R2>): Subscribable<A | B, E2, R | R2>
-} = Function.dual(2, <A, E, R, B, E2, R2>(
-    self: Subscribable<A, E, R>,
-    f: (cause: Cause.Cause<NoInfer<E>>) => Subscribable<B, E2, R2>,
-) => make({
-    get get() { return Effect.catchCause(self.get, cause => f(cause).get) },
-    get changes() { return Stream.catchCause(self.changes, cause => f(cause).changes) },
-}))
-
-/** Runs an effect when either channel fails, exposing the complete failure cause. */
-export const tapCause: {
-    <E, B, E2, R2>(f: (cause: Cause.Cause<NoInfer<E>>) => Effect.Effect<B, E2, R2>): <A, R>(self: Subscribable<A, E, R>) => Subscribable<A, E | E2, R | R2>
-    <A, E, R, B, E2, R2>(self: Subscribable<A, E, R>, f: (cause: Cause.Cause<NoInfer<E>>) => Effect.Effect<B, E2, R2>): Subscribable<A, E | E2, R | R2>
-} = Function.dual(2, <A, E, R, B, E2, R2>(
-    self: Subscribable<A, E, R>,
-    f: (cause: Cause.Cause<NoInfer<E>>) => Effect.Effect<B, E2, R2>,
-) => make({
-    get get() { return Effect.tapCause(self.get, f) },
-    get changes() { return Stream.tapCause(self.changes, f) },
-}))
-
-/** Falls back to another `Subscribable` when either channel fails. */
-export const orElse: {
-    <B, E2, R2>(that: () => Subscribable<B, E2, R2>): <A, E, R>(self: Subscribable<A, E, R>) => Subscribable<A | B, E2, R | R2>
-    <A, E, R, B, E2, R2>(self: Subscribable<A, E, R>, that: () => Subscribable<B, E2, R2>): Subscribable<A | B, E2, R | R2>
-} = Function.dual(2, <A, E, R, B, E2, R2>(
-    self: Subscribable<A, E, R>,
-    that: () => Subscribable<B, E2, R2>,
-) => catch_(self, that))
-
-/** Replaces typed errors from either channel with a lazily evaluated value. */
-export const orElseSucceed: {
-    <B>(value: () => B): <A, E, R>(self: Subscribable<A, E, R>) => Subscribable<A | B, never, R>
-    <A, E, R, B>(self: Subscribable<A, E, R>, value: () => B): Subscribable<A | B, never, R>
-} = Function.dual(2, <A, E, R, B>(self: Subscribable<A, E, R>, value: () => B) => make({
-    get get() { return Effect.orElseSucceed(self.get, value) },
-    get changes() { return Stream.orElseSucceed(self.changes, value) },
-}))
-
-/** Retries failures from both channels according to the supplied schedule. */
-export const retry: {
-    <E, X, E2, R2>(policy: Schedule.Schedule<X, NoInfer<E>, E2, R2>): <A, R>(self: Subscribable<A, E, R>) => Subscribable<A, E | E2, R | R2>
-    <A, E, R, X, E2, R2>(self: Subscribable<A, E, R>, policy: Schedule.Schedule<X, NoInfer<E>, E2, R2>): Subscribable<A, E | E2, R | R2>
-} = Function.dual(2, <A, E, R, X, E2, R2>(
-    self: Subscribable<A, E, R>,
-    policy: Schedule.Schedule<X, NoInfer<E>, E2, R2>,
-) => make({
-    get get() { return Effect.retry(self.get, policy) },
-    get changes() { return Stream.retry(self.changes, policy) },
-}))
-
-/** Converts typed failures from both channels into `Result` values. */
-export const result = <A, E, R>(
-    self: Subscribable<A, E, R>,
-): Subscribable<Result.Result<A, E>, never, R> => make({
-    get get() { return Effect.result(self.get) },
-    get changes() { return Stream.result(self.changes) },
-})
-
-
-/** Narrows the focus to a field of an object. */
-export const focusObjectOn: {
-    <A extends object, K extends keyof A>(key: K): <E, R>(self: Subscribable<A, E, R>) => Subscribable<A[K], E, R>
-    <A extends object, K extends keyof A, E, R>(self: Subscribable<A, E, R>, key: K): Subscribable<A[K], E, R>
-} = Function.dual(2, <A extends object, K extends keyof A, E, R>(self: Subscribable<A, E, R>, key: K) =>
-    map(self, a => a[key]),
-)
-
-/** Narrows the focus to an indexed element of an array. */
-export const focusArrayAt: {
-    <A extends readonly any[]>(index: number): <E, R>(self: Subscribable<A, E, R>) => Subscribable<A[number], E | Cause.NoSuchElementError, R>
-    <A extends readonly any[], E, R>(self: Subscribable<A, E, R>, index: number): Subscribable<A[number], E | Cause.NoSuchElementError, R>
-} = Function.dual(2, <A extends readonly any[], E, R>(self: Subscribable<A, E, R>, index: number) =>
-    mapEffect(self, a => Effect.fromOption(Array.get(a, index))),
-)
-
-export const focusArrayLength = <A extends readonly any[], E, R>(
-    self: Subscribable<A, E, R>,
-): Subscribable<number, E, R> => map(self, Array.length)
-
-/** Narrows the focus to an indexed element of a readonly tuple. */
-export const focusTupleAt: {
-    <T extends readonly [any, ...any[]], I extends number>(index: I): <E, R>(self: Subscribable<T, E, R>) => Subscribable<T[I], E, R>
-    <T extends readonly [any, ...any[]], I extends number, E, R>(self: Subscribable<T, E, R>, index: I): Subscribable<T[I], E, R>
-} = Function.dual(2, <T extends readonly [any, ...any[]], I extends number, E, R>(self: Subscribable<T, E, R>, index: I) =>
-    map(self, Array.getUnsafe(index)),
-)
-
-/** Narrows the focus to an indexed element of `Chunk`. */
-export const focusChunkAt: {
-    <A>(index: number): <E, R>(self: Subscribable<Chunk.Chunk<A>, E, R>) => Subscribable<A, E | Cause.NoSuchElementError, R>
-    <A, E, R>(self: Subscribable<Chunk.Chunk<A>, E, R>, index: number): Subscribable<A, E | Cause.NoSuchElementError, R>
-} = Function.dual(2, <A, E, R>(self: Subscribable<Chunk.Chunk<A>, E, R>, index: number) =>
-    mapEffect(self, chunk => Effect.fromOption(Chunk.get(chunk, index))),
-)
-
-export const focusChunkSize = <A, E, R>(
-    self: Subscribable<Chunk.Chunk<A>, E, R>,
-): Subscribable<number, E, R> => map(self, Chunk.size)
-
-export const focusIterableSize = <A extends Iterable<any>, E, R>(
-    self: Subscribable<A, E, R>,
-): Subscribable<number, E, R> => map(self, Iterable.size)
@@ -1,16 +1,16 @@
 import { describe, expect, test } from "bun:test"
 import { Chunk, Effect, Stream, SubscriptionRef } from "effect"
 import * as Lens from "./Lens.js"
-import * as Subscribable from "./Subscribable.js"
+import * as View from "./View.js"


-describe("Subscribable", () => {
+describe("View", () => {
    test("mapError transforms errors from get and changes", async () => {
-        const source = Subscribable.make({
+        const source = View.make({
            get: Effect.fail("get"),
            changes: Stream.fail("changes"),
        })
-        const mapped = source.pipe(Subscribable.mapError((error: string) => `mapped:${error}`))
+        const mapped = source.pipe(View.mapError((error: string) => `mapped:${error}`))

        const result = await Effect.runPromise(Effect.gen(function*() {
            const getError = yield* Effect.flip(mapped.get)
@@ -23,11 +23,11 @@ describe("Subscribable", () => {

    test("tapError observes errors from get and changes", async () => {
        const observed: Array<string> = []
-        const source = Subscribable.make({
+        const source = View.make({
            get: Effect.fail("get"),
            changes: Stream.fail("changes"),
        })
-        const tapped = Subscribable.tapError(source, error => Effect.sync(() => observed.push(error)))
+        const tapped = View.tapError(source, error => Effect.sync(() => observed.push(error)))

        await Effect.runPromise(Effect.gen(function*() {
            yield* Effect.flip(tapped.get)
@@ -38,11 +38,11 @@ describe("Subscribable", () => {
    })

    test("catch recovers get and changes with the corresponding fallback channel", async () => {
-        const source = Subscribable.make({
+        const source = View.make({
            get: Effect.fail("get"),
            changes: Stream.fail("changes"),
        })
-        const recovered = source.pipe(Subscribable.catch(() => Subscribable.make({
+        const recovered = source.pipe(View.catch(() => View.make({
            get: Effect.succeed("fallback-get"),
            changes: Stream.succeed("fallback-changes"),
        })))
@@ -57,11 +57,11 @@ describe("Subscribable", () => {
    })

    test("orElseSucceed recovers errors from get and changes", async () => {
-        const source = Subscribable.make({
+        const source = View.make({
            get: Effect.fail("get"),
            changes: Stream.fail("changes"),
        })
-        const recovered = Subscribable.orElseSucceed(source, () => "fallback")
+        const recovered = View.orElseSucceed(source, () => "fallback")

        const result = await Effect.runPromise(Effect.gen(function*() {
            const current = yield* recovered.get
@@ -72,17 +72,40 @@ describe("Subscribable", () => {
        expect(result).toEqual(["fallback", ["fallback"]])
    })

+    test("zipLatestAll combines current values and change streams", async () => {
+        const zipped = View.zipLatestAll(
+            View.make({
+                get: Effect.succeed(1),
+                changes: Stream.succeed(2),
+            }),
+            View.make({
+                get: Effect.succeed("one"),
+                changes: Stream.succeed("two"),
+            }),
+        )
+
+        const result = await Effect.runPromise(Effect.all([
+            zipped.get,
+            Stream.runCollect(zipped.changes),
+        ]))
+
+        expect([result[0], Array.from(result[1])]).toEqual([
+            [1, "one"],
+            [[2, "two"]],
+        ])
+    })
+
    test("focusArrayLength reads the current array length and reflects updates", async () => {
        const result = await Effect.runPromise(
            Effect.flatMap(
                SubscriptionRef.make([1, 2, 3]),
                parent => {
-                    const sizeSub = Subscribable.focusArrayLength(Lens.fromSubscriptionRef(parent))
+                    const sizeView = View.focusArrayLength(Lens.fromSubscriptionRef(parent))
                    return Effect.flatMap(
-                        sizeSub.get,
+                        sizeView.get,
                        initial => Effect.flatMap(
                            SubscriptionRef.set(parent, [1, 2, 3, 4, 5]),
-                            () => Effect.map(sizeSub.get, next => [initial, next] as const),
+                            () => Effect.map(sizeView.get, next => [initial, next] as const),
                        ),
                    )
                },
@@ -97,12 +120,12 @@ describe("Subscribable", () => {
            Effect.flatMap(
                SubscriptionRef.make(Chunk.make(1, 2) as Chunk.Chunk<number>),
                parent => {
-                    const sizeSub = Subscribable.focusChunkSize(Lens.fromSubscriptionRef(parent))
+                    const sizeView = View.focusChunkSize(Lens.fromSubscriptionRef(parent))
                    return Effect.flatMap(
-                        sizeSub.get,
+                        sizeView.get,
                        initial => Effect.flatMap(
                            SubscriptionRef.set(parent, Chunk.make(1, 2, 3, 4)),
-                            () => Effect.map(sizeSub.get, next => [initial, next] as const),
+                            () => Effect.map(sizeView.get, next => [initial, next] as const),
                        ),
                    )
                },
@@ -117,12 +140,12 @@ describe("Subscribable", () => {
            Effect.flatMap(
                SubscriptionRef.make([1, 2, 3]),
                parent => {
-                    const sizeSub = Subscribable.focusIterableSize(Lens.fromSubscriptionRef(parent))
+                    const sizeView = View.focusIterableSize(Lens.fromSubscriptionRef(parent))
                    return Effect.flatMap(
-                        sizeSub.get,
+                        sizeView.get,
                        initial => Effect.flatMap(
                            SubscriptionRef.set(parent, [1, 2, 3, 4, 5]),
-                            () => Effect.map(sizeSub.get, next => [initial, next] as const),
+                            () => Effect.map(sizeView.get, next => [initial, next] as const),
                        ),
                    )
                },
@@ -0,0 +1,292 @@
+import { Array, type Cause, Chunk, Effect, Function, Iterable, Option, Pipeable, Predicate, type Result, type Schedule, Stream } from "effect"
+
+
+export const ViewTypeId: unique symbol = Symbol.for("@effect-lens/View/View")
+export type ViewTypeId = typeof ViewTypeId
+
+export interface View<out A, out E = never, out R = never> extends Pipeable.Pipeable {
+    readonly [ViewTypeId]: ViewTypeId
+    readonly get: Effect.Effect<A, E, R>
+    readonly changes: Stream.Stream<A, E, R>
+}
+
+export const isView = (u: unknown): u is View<unknown, unknown, unknown> => Predicate.hasProperty(u, ViewTypeId)
+
+
+export const ViewImplTypeId: unique symbol = Symbol.for("@effect-fc/Lens/v4/ViewImpl")
+export type ViewImplTypeId = typeof ViewImplTypeId
+
+export declare namespace ViewImpl {
+    export interface Source<out A, out E = never, out R = never> {
+        readonly get: Effect.Effect<A, E, R>
+        readonly changes: Stream.Stream<A, E, R>
+    }
+}
+
+export class ViewImpl<out A, out E = never, out R = never>
+extends Pipeable.Class implements View<A, E, R> {
+    readonly [ViewTypeId]: ViewTypeId = ViewTypeId
+    readonly [ViewImplTypeId]: ViewImplTypeId = ViewImplTypeId
+
+    constructor(
+        readonly source: ViewImpl.Source<A, E, R>,
+    ) {
+        super()
+    }
+
+    get get() { return this.source.get }
+    get changes() { return this.source.changes }
+}
+
+export const isViewImpl = (u: unknown): u is ViewImpl<unknown, unknown, unknown> => Predicate.hasProperty(u, ViewImplTypeId)
+
+export const asViewImpl = <A, E, R>(
+    view: View<A, E, R>
+): ViewImpl<A, E, R> => {
+    if (!isViewImpl(view))
+        throw new Error("Not a 'ViewImpl'")
+    return view as ViewImpl<A, E, R>
+}
+
+export const make = <A, E, R>(
+    source: ViewImpl.Source<A, E, R>
+): View<A, E, R> => new ViewImpl(source)
+
+export const unwrap = <A, E, R, E1, R1>(
+    effect: Effect.Effect<View<A, E, R>, E1, R1>,
+): View<A, E | E1, R | R1> => make({
+    get: Effect.flatMap(effect, self => self.get),
+    changes: Stream.unwrap(Effect.map(effect, self => self.changes)),
+})
+
+
+export const map: {
+    <A, B>(f: (a: NoInfer<A>) => B): <E, R>(self: View<A, E, R>) => View<B, E, R>
+    <A, E, R, B>(self: View<A, E, R>, f: (a: NoInfer<A>) => B): View<B, E, R>
+} = Function.dual(2, <A, E, R, B>(self: View<A, E, R>, f: (a: NoInfer<A>) => B) => make({
+    get get() { return Effect.map(self.get, f) },
+    get changes() { return Stream.map(self.changes, f) },
+}))
+
+export const mapEffect: {
+    <A, B, E2, R2>(f: (a: NoInfer<A>) => Effect.Effect<B, E2, R2>): <E, R>(self: View<A, E, R>) => View<B, E | E2, R | R2>
+    <A, E, R, B, E2, R2>(self: View<A, E, R>, f: (a: NoInfer<A>) => Effect.Effect<B, E2, R2>): View<B, E | E2, R | R2>
+} = Function.dual(2, <A, E, R, B, E2, R2>(
+    self: View<A, E, R>,
+    f: (a: NoInfer<A>) => Effect.Effect<B, E2, R2>,
+) => make({
+    get get() { return Effect.flatMap(self.get, f) },
+    get changes() { return Stream.mapEffect(self.changes, f) },
+}))
+
+/** Maps over an `Option` value in the `View`. */
+export const mapOption: {
+    <A, B>(f: (a: A) => B): <E, R>(self: View<Option.Option<A>, E, R>) => View<Option.Option<B>, E, R>
+    <A, B, E, R>(self: View<Option.Option<A>, E, R>, f: (a: A) => B): View<Option.Option<B>, E, R>
+} = Function.dual(2, <A, B, E, R>(self: View<Option.Option<A>, E, R>, f: (a: A) => B) =>
+    map(self, Option.map(f)),
+)
+
+/** Maps over an `Option` value in the `View` with an Effect. */
+export const mapOptionEffect: {
+    <A, B, E2, R2>(f: (a: A) => Effect.Effect<B, E2, R2>): <E, R>(self: View<Option.Option<A>, E, R>) => View<Option.Option<B>, E | E2, R | R2>
+    <A, B, E, R, E2, R2>(self: View<Option.Option<A>, E, R>, f: (a: A) => Effect.Effect<B, E2, R2>): View<Option.Option<B>, E | E2, R | R2>
+} = Function.dual(2, <A, B, E, R, E2, R2>(
+    self: View<Option.Option<A>, E, R>,
+    f: (a: A) => Effect.Effect<B, E2, R2>,
+) => mapEffect(self, Option.match({
+    onSome: a => Effect.map(f(a), Option.some),
+    onNone: () => Effect.succeed(Option.none()),
+})))
+
+/**
+ * Allows transforming only the `changes` stream of a `View`.
+ */
+export const mapStream: {
+    <A, E, R>(
+        f: (changes: Stream.Stream<NoInfer<A>, NoInfer<E>, NoInfer<R>>) => Stream.Stream<NoInfer<A>, NoInfer<E>, NoInfer<R>>,
+    ): (self: View<A, E, R>) => View<A, E, R>
+    <A, E, R>(
+        self: View<A, E, R>,
+        f: (changes: Stream.Stream<NoInfer<A>, NoInfer<E>, NoInfer<R>>) => Stream.Stream<NoInfer<A>, NoInfer<E>, NoInfer<R>>,
+    ): View<A, E, R>
+} = Function.dual(2, <A, E, R>(
+    self: View<A, E, R>,
+    f: (changes: Stream.Stream<NoInfer<A>, NoInfer<E>, NoInfer<R>>) => Stream.Stream<NoInfer<A>, NoInfer<E>, NoInfer<R>>,
+): View<A, E, R> => make({
+    get get() { return self.get },
+    get changes() { return f(self.changes) },
+}))
+
+/** Converts typed failures from both channels into `Result` values. */
+export const result = <A, E, R>(
+    self: View<A, E, R>,
+): View<Result.Result<A, E>, never, R> => make({
+    get get() { return Effect.result(self.get) },
+    get changes() { return Stream.result(self.changes) },
+})
+
+/**
+ * Combines the current values and streams of changes from multiple `View` values.
+ */
+export const zipLatestAll = <const T extends readonly View<any, any, any>[]>(
+    ...elements: T
+): View<
+    [T[number]] extends [never]
+        ? never
+        : { [K in keyof T]: T[K] extends View<infer A, infer _E, infer _R> ? A : never },
+    [T[number]] extends [never] ? never : T[number] extends View<infer _A, infer E, infer _R> ? E : never,
+    [T[number]] extends [never] ? never : T[number] extends View<infer _A, infer _E, infer R> ? R : never
+> => make({
+    get: Effect.all(elements.map(view => view.get)),
+    changes: Stream.zipLatestAll(...elements.map(view => view.changes)),
+}) as any
+
+
+/** Maps errors from both the current value and the stream of changes. */
+export const mapError: {
+    <E, E2>(f: (error: NoInfer<E>) => E2): <A, R>(self: View<A, E, R>) => View<A, E2, R>
+    <A, E, R, E2>(self: View<A, E, R>, f: (error: NoInfer<E>) => E2): View<A, E2, R>
+} = Function.dual(2, <A, E, R, E2>(
+    self: View<A, E, R>,
+    f: (error: NoInfer<E>) => E2,
+) => make({
+    get get() { return Effect.mapError(self.get, f) },
+    get changes() { return Stream.mapError(self.changes, f) },
+}))
+
+/** Runs an effect when either the current value or the stream of changes fails. */
+export const tapError: {
+    <E, B, E2, R2>(f: (error: NoInfer<E>) => Effect.Effect<B, E2, R2>): <A, R>(self: View<A, E, R>) => View<A, E | E2, R | R2>
+    <A, E, R, B, E2, R2>(self: View<A, E, R>, f: (error: NoInfer<E>) => Effect.Effect<B, E2, R2>): View<A, E | E2, R | R2>
+} = Function.dual(2, <A, E, R, B, E2, R2>(
+    self: View<A, E, R>,
+    f: (error: NoInfer<E>) => Effect.Effect<B, E2, R2>,
+) => make({
+    get get() { return Effect.tapError(self.get, f) },
+    get changes() { return Stream.tapError(self.changes, f) },
+}))
+
+const catch_: {
+    <E, B, E2, R2>(f: (error: NoInfer<E>) => View<B, E2, R2>): <A, R>(self: View<A, E, R>) => View<A | B, E2, R | R2>
+    <A, E, R, B, E2, R2>(self: View<A, E, R>, f: (error: NoInfer<E>) => View<B, E2, R2>): View<A | B, E2, R | R2>
+} = Function.dual(2, <A, E, R, B, E2, R2>(
+    self: View<A, E, R>,
+    f: (error: NoInfer<E>) => View<B, E2, R2>,
+) => make({
+    get get() { return Effect.catch(self.get, error => f(error).get) },
+    get changes() { return Stream.catch(self.changes, error => f(error).changes) },
+}))
+
+/** Recovers from typed errors with another `View`. */
+export { catch_ as catch }
+
+/** Recovers from all failure causes with another `View`. */
+export const catchCause: {
+    <E, B, E2, R2>(f: (cause: Cause.Cause<NoInfer<E>>) => View<B, E2, R2>): <A, R>(self: View<A, E, R>) => View<A | B, E2, R | R2>
+    <A, E, R, B, E2, R2>(self: View<A, E, R>, f: (cause: Cause.Cause<NoInfer<E>>) => View<B, E2, R2>): View<A | B, E2, R | R2>
+} = Function.dual(2, <A, E, R, B, E2, R2>(
+    self: View<A, E, R>,
+    f: (cause: Cause.Cause<NoInfer<E>>) => View<B, E2, R2>,
+) => make({
+    get get() { return Effect.catchCause(self.get, cause => f(cause).get) },
+    get changes() { return Stream.catchCause(self.changes, cause => f(cause).changes) },
+}))
+
+/** Runs an effect when either channel fails, exposing the complete failure cause. */
+export const tapCause: {
+    <E, B, E2, R2>(f: (cause: Cause.Cause<NoInfer<E>>) => Effect.Effect<B, E2, R2>): <A, R>(self: View<A, E, R>) => View<A, E | E2, R | R2>
+    <A, E, R, B, E2, R2>(self: View<A, E, R>, f: (cause: Cause.Cause<NoInfer<E>>) => Effect.Effect<B, E2, R2>): View<A, E | E2, R | R2>
+} = Function.dual(2, <A, E, R, B, E2, R2>(
+    self: View<A, E, R>,
+    f: (cause: Cause.Cause<NoInfer<E>>) => Effect.Effect<B, E2, R2>,
+) => make({
+    get get() { return Effect.tapCause(self.get, f) },
+    get changes() { return Stream.tapCause(self.changes, f) },
+}))
+
+/** Falls back to another `View` when either channel fails. */
+export const orElse: {
+    <B, E2, R2>(that: () => View<B, E2, R2>): <A, E, R>(self: View<A, E, R>) => View<A | B, E2, R | R2>
+    <A, E, R, B, E2, R2>(self: View<A, E, R>, that: () => View<B, E2, R2>): View<A | B, E2, R | R2>
+} = Function.dual(2, <A, E, R, B, E2, R2>(
+    self: View<A, E, R>,
+    that: () => View<B, E2, R2>,
+) => catch_(self, that))
+
+/** Replaces typed errors from either channel with a lazily evaluated value. */
+export const orElseSucceed: {
+    <B>(value: () => B): <A, E, R>(self: View<A, E, R>) => View<A | B, never, R>
+    <A, E, R, B>(self: View<A, E, R>, value: () => B): View<A | B, never, R>
+} = Function.dual(2, <A, E, R, B>(self: View<A, E, R>, value: () => B) => make({
+    get get() { return Effect.orElseSucceed(self.get, value) },
+    get changes() { return Stream.orElseSucceed(self.changes, value) },
+}))
+
+/** Retries failures from both channels according to the supplied schedule. */
+export const retry: {
+    <E, X, E2, R2>(policy: Schedule.Schedule<X, NoInfer<E>, E2, R2>): <A, R>(self: View<A, E, R>) => View<A, E | E2, R | R2>
+    <A, E, R, X, E2, R2>(self: View<A, E, R>, policy: Schedule.Schedule<X, NoInfer<E>, E2, R2>): View<A, E | E2, R | R2>
+} = Function.dual(2, <A, E, R, X, E2, R2>(
+    self: View<A, E, R>,
+    policy: Schedule.Schedule<X, NoInfer<E>, E2, R2>,
+) => make({
+    get get() { return Effect.retry(self.get, policy) },
+    get changes() { return Stream.retry(self.changes, policy) },
+}))
+
+
+/** Narrows the focus to a field of an object. */
+export const focusObjectOn: {
+    <A extends object, K extends keyof A>(key: K): <E, R>(self: View<A, E, R>) => View<A[K], E, R>
+    <A extends object, K extends keyof A, E, R>(self: View<A, E, R>, key: K): View<A[K], E, R>
+} = Function.dual(2, <A extends object, K extends keyof A, E, R>(self: View<A, E, R>, key: K) =>
+    map(self, a => a[key]),
+)
+
+/** Narrows the focus to an indexed element of an array. */
+export const focusArrayAt: {
+    <A extends readonly any[]>(index: number): <E, R>(self: View<A, E, R>) => View<A[number], E | Cause.NoSuchElementError, R>
+    <A extends readonly any[], E, R>(self: View<A, E, R>, index: number): View<A[number], E | Cause.NoSuchElementError, R>
+} = Function.dual(2, <A extends readonly any[], E, R>(self: View<A, E, R>, index: number) =>
+    mapEffect(self, a => Effect.fromOption(Array.get(a, index))),
+)
+
+export const focusArrayLength = <A extends readonly any[], E, R>(
+    self: View<A, E, R>,
+): View<number, E, R> => map(self, Array.length)
+
+/** Narrows the focus to an indexed element of a readonly tuple. */
+export const focusTupleAt: {
+    <T extends readonly [any, ...any[]], I extends number>(index: I): <E, R>(self: View<T, E, R>) => View<T[I], E, R>
+    <T extends readonly [any, ...any[]], I extends number, E, R>(self: View<T, E, R>, index: I): View<T[I], E, R>
+} = Function.dual(2, <T extends readonly [any, ...any[]], I extends number, E, R>(self: View<T, E, R>, index: I) =>
+    map(self, Array.getUnsafe(index)),
+)
+
+/** Narrows the focus to an indexed element of `Chunk`. */
+export const focusChunkAt: {
+    <A>(index: number): <E, R>(self: View<Chunk.Chunk<A>, E, R>) => View<A, E | Cause.NoSuchElementError, R>
+    <A, E, R>(self: View<Chunk.Chunk<A>, E, R>, index: number): View<A, E | Cause.NoSuchElementError, R>
+} = Function.dual(2, <A, E, R>(self: View<Chunk.Chunk<A>, E, R>, index: number) =>
+    mapEffect(self, chunk => Effect.fromOption(Chunk.get(chunk, index))),
+)
+
+export const focusChunkSize = <A, E, R>(
+    self: View<Chunk.Chunk<A>, E, R>,
+): View<number, E, R> => map(self, Chunk.size)
+
+export const focusIterableSize = <A extends Iterable<any>, E, R>(
+    self: View<A, E, R>,
+): View<number, E, R> => map(self, Iterable.size)
+
+
+/**
+ * Reads the current value from a `View`.
+ */
+export const get = <A, E, R>(self: View<A, E, R>): Effect.Effect<A, E, R> => self.get
+
+/**
+ * Returns the stream of changes from a `View`.
+ */
+export const changes = <A, E, R>(self: View<A, E, R>): Stream.Stream<A, E, R> => self.changes
@@ -1,2 +1,2 @@
 export * as Lens from "./Lens.js"
-export * as Subscribable from "./Subscribable.js"
+export * as View from "./View.js"
@@ -2,7 +2,7 @@

 A Lens type for [Effect](https://effect.website/) to easily manage nested state.

-This version is for Effect v3. For Effect v4, use version 2.X.X-beta.X.
+This version is for Effect v3. For Effect v4, use the [2.0.0 beta](https://www.npmjs.com/package/effect-lens/v/2.0.0-beta.1).

 ## Install
 ```
@@ -64,7 +64,7 @@ You can also create Lenses manually using `make` by providing:
 - `get`: an effect that reads the current value,
 - `changes`: a stream of value changes,
 - `commit`: an effectful write primitive,
- `lock`: an effect that produces the lock used to serialize writes.
+- `lock`: an effect that produces the lock used to serialize writes and preserve atomicity.

 You can get pretty creative! Here's an example of a Lens that points to a specific key of the browser `LocalStorage`:
 ```typescript
@@ -101,9 +101,6 @@ const lens = Effect.all([
 )
 ```

-Note: while Lens supports asynchronous effects for the proxy logic, we would recommend keeping them synchronous to preserve atomicity.
-
-
 ### Focusing

 Lenses can focus on a nested part of the data type they point to.
@@ -242,30 +239,31 @@ const nameLens = lens.pipe(

 ### Subscribable

-Lens implements both Effect's `Subscribable` and `Readable`, which you can use as a constraint to allow some parts of your app to only read and subscribe to the Lenses you provide them:
+Effect's `Subscribable` is a read-only, reactive view of a value: it lets you read the current value and observe subsequent changes. Every `Lens` implements both `Subscribable` and `Readable`, which you can use as constraints to allow some parts of your app to only read and subscribe to the Lenses you provide them:
 ```typescript
 const ref = yield* SubscriptionRef.make<{
    readonly users: readonly User[]
-}>({ users: [...] })
+}>({ users: [] })

-const someFunctionThatShouldOnlyHaveReadonlyAccessToTheState = (
-    usersSub: Subscribable.Subscribable<readonly User[], never, never>
-) => Effect.gen(function*() {
-    // Do whatever
-    const usersCountSub = Subscribable.map(usersSub, a => a.length)
-    const users = yield* usersSub.get
-    yield* Effect.forkScoped(Stream.runForEach(usersSub.changes, ...))
+const logUserCount = (users: Subscribable.Subscribable<readonly User[]>) =>
+    Effect.gen(function*() {
+        const userCount = Subscribable.focusArrayLength(users)
+        yield* Console.log(`There are ${yield* userCount.get} users`)
+        yield* Stream.runForEach(
+            userCount.changes,
+            count => Console.log(`There are now ${count} users`),
+        )
    })

-const lens = ref.pipe(
+const usersLens = ref.pipe(
    Lens.fromSubscriptionRef,
    Lens.focusObjectOn("users"),
 )
-yield* someFunctionThatShouldOnlyHaveReadonlyAccessToTheState(lens)
+yield* Effect.forkScoped(logUserCount(usersLens))
 ```

 #### Focusing
-This library re-exports Effect's `Subscribable` module and adds error transforms and recovery (`catchAll`, `catchAllCause`, `orElse`, `orElseSucceed`, and `retry`), plus transforms to narrow the focus of `Subscribable`'s, same as Lenses:
+Subscribables can be focused in the same way as Lenses. This library re-exports Effect's `Subscribable` module and adds value and error transforms, plus recovery (`catchAll`, `catchAllCause`, `orElse`, `orElseSucceed`, and `retry`):
 ```typescript
 import { Subscribable } from "effect-lens"

@@ -1,7 +1,7 @@
 {
  "name": "effect-lens",
  "description": "An effectful Lens type to easily manage nested state",
-  "version": "0.2.1",
+  "version": "0.2.2",
  "type": "module",
  "files": [
    "./README.md",
@@ -13,7 +13,7 @@ export type LensTypeId = typeof LensTypeId
 * 2. a `changes` stream that emits every subsequent update to `A`, and
 * 3. a `modify` effect that can transform the current value.
 */
-export interface Lens<in out A, in out ER = never, in out EW = never, in out RR = never, in out RW = never>
+export interface Lens<in out A, out ER = never, out EW = never, out RR = never, out RW = never>
 extends Subscribable.Subscribable<A, ER, RR> {
    readonly [LensTypeId]: LensTypeId

@@ -32,7 +32,7 @@ export const LensImplTypeId: unique symbol = Symbol.for("@effect-fc/Lens/LensImp
 export type LensImplTypeId = typeof LensImplTypeId

 export declare namespace LensImpl {
-    export interface Resolved<in out A, in out EW = never, in out RW = never> {
+    export interface Resolved<in out A, out EW = never, out RW = never> {
        readonly value: A
        readonly commit: <E = never, R = never>(
            next: Effect.Effect<A, E, R>
@@ -44,7 +44,7 @@ export declare namespace LensImpl {
    }
 }

-export abstract class LensImpl<in out A, in out ER = never, in out EW = never, in out RR = never, in out RW = never>
+export abstract class LensImpl<in out A, out ER = never, out EW = never, out RR = never, 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
@@ -89,7 +89,7 @@ export const asSubscribable = <A, ER, EW, RR, RW>(


 export declare namespace LensLazyImpl {
-    export interface Source<in out A, in out ER = never, in out EW = never, in out RR = never, in out RW = never> {
+    export interface Source<in out A, out ER = never, out EW = never, out RR = never, out RW = never> {
        readonly get: Effect.Effect<A, ER, RR>
        readonly changes: Stream.Stream<A, ER, RR>
        readonly commit: (a: A) => Effect.Effect<void, EW, RW>
@@ -97,7 +97,7 @@ export declare namespace LensLazyImpl {
    }
 }

-export class LensLazyImpl<in out A, in out ER = never, in out EW = never, in out RR = never, in out RW = never>
+export class LensLazyImpl<in out A, out ER = never, out EW = never, out RR = never, out RW = never>
 extends LensImpl<A, ER, EW, RR, RW> {
    constructor(
        readonly source: LensLazyImpl.Source<A, ER, EW, RR, RW>,
@@ -126,7 +126,7 @@ export const make = <A, ER, EW, RR, RW>(
 ): Lens<A, ER, EW, RR, RW> => new LensLazyImpl(source)


-export class UnwrappedLensImpl<in out A, in out ER, in out EW, in out RR, in out RW, in out E1, in out R1>
+export class UnwrappedLensImpl<in out A, out ER, out EW, out RR, out RW, out E1, out R1>
 extends LensImpl<A, ER | E1, EW | E1, RR | R1, RW | R1> {
    constructor(
        readonly effect: Effect.Effect<Lens<A, ER, EW, RR, RW>, E1, R1>
@@ -71,6 +71,29 @@ describe("Subscribable", () => {
        expect(result).toEqual(["fallback", ["fallback"]])
    })

+    test("zipLatestAll combines current values and change streams", async () => {
+        const zipped = Subscribable.zipLatestAll(
+            Subscribable.make({
+                get: Effect.succeed(1),
+                changes: Stream.succeed(2),
+            }),
+            Subscribable.make({
+                get: Effect.succeed("one"),
+                changes: Stream.succeed("two"),
+            }),
+        )
+
+        const result = await Effect.runPromise(Effect.all([
+            zipped.get,
+            Stream.runCollect(zipped.changes),
+        ]))
+
+        expect([result[0], Array.from(result[1])]).toEqual([
+            [1, "one"],
+            [[2, "two"]],
+        ])
+    })
+
    test("focusArrayLength reads the current array length and reflects updates", async () => {
        const result = await Effect.runPromise(
            Effect.flatMap(
@@ -40,6 +40,41 @@ export const mapOptionEffect: {
    onNone: () => Effect.succeed(Option.none()),
 })))

+/**
+ * Allows transforming only the `changes` stream of a `Subscribable`.
+ */
+export const mapStream: {
+    <A, E, R>(
+        f: (changes: Stream.Stream<NoInfer<A>, NoInfer<E>, NoInfer<R>>) => Stream.Stream<NoInfer<A>, NoInfer<E>, NoInfer<R>>,
+    ): (self: Subscribable.Subscribable<A, E, R>) => Subscribable.Subscribable<A, E, R>
+    <A, E, R>(
+        self: Subscribable.Subscribable<A, E, R>,
+        f: (changes: Stream.Stream<NoInfer<A>, NoInfer<E>, NoInfer<R>>) => Stream.Stream<NoInfer<A>, NoInfer<E>, NoInfer<R>>,
+    ): Subscribable.Subscribable<A, E, R>
+} = Function.dual(2, <A, E, R>(
+    self: Subscribable.Subscribable<A, E, R>,
+    f: (changes: Stream.Stream<NoInfer<A>, NoInfer<E>, NoInfer<R>>) => Stream.Stream<NoInfer<A>, NoInfer<E>, NoInfer<R>>,
+): Subscribable.Subscribable<A, E, R> => Subscribable.make({
+    get get() { return self.get },
+    get changes() { return f(self.changes) },
+}))
+
+/**
+ * Combines the current values and streams of changes from multiple `Subscribable` values.
+ */
+export const zipLatestAll = <const T extends readonly Subscribable.Subscribable<any, any, any>[]>(
+    ...elements: T
+): Subscribable.Subscribable<
+    [T[number]] extends [never]
+        ? never
+        : { [K in keyof T]: T[K] extends Subscribable.Subscribable<infer A, infer _E, infer _R> ? A : never },
+    [T[number]] extends [never] ? never : T[number] extends Subscribable.Subscribable<infer _A, infer E, infer _R> ? E : never,
+    [T[number]] extends [never] ? never : T[number] extends Subscribable.Subscribable<infer _A, infer _E, infer R> ? R : never
+> => Subscribable.make({
+    get: Effect.all(elements.map(view => view.get)),
+    changes: Stream.zipLatestAll(...elements.map(view => view.changes)),
+}) as any
+

 /**
 * Maps errors from both the current value and the stream of changes.