effect-lens 0.1.0

package/README.md

@@ -0,0 +1,237 @@
+# Effect Lens
+
+A Lens type for [Effect](https://effect.website/) to easily manage nested state.
+
+A proper documentation is currently being written. In the meantime, you can take a look at the quickstart below and at the `packages/example` directory.
+
+## Install
+```
+npm install effect-lens
+yarn add effect-lens
+bun add effect-lens
+```
+
+## Peer dependencies
+- `effect` 3.21+
+
+
+## Quickstart
+
+A Lens is an effectful abstraction for focusing on (i.e., getting, subscribing to, setting, or modifying) a specific part of a larger immutable data structure, without losing the surrounding context.
+
+Picture it as a proxy to a separate data source with a similar API to Effect's `SubscriptionRef`, that can point to
+a nested part of a data structure (I.E.: a `SubscriptionRef` holds an array of numbers, a Lens can proxy that array
+or the number at a specific index).
+
+What makes a Lens effectful is the fact that the proxy logic uses effects, which means reading from or writing to a
+Lens can fail or have requirements:
+```typescript
+Lens<
+    A,   // Type of the value the lens is focused on
+    ER,  // Errors that can happen when reading
+    EW,  // Errors that can happen when writing
+    RE,  // Requirements for reading
+    RW   // Requirements for writing
+>
+```
+
+
+### Creating a Lens
+
+#### From an exisiting type
+We provide a few helpers to create Lenses from some Effect types:
+```typescript
+// The ref is the data source
+const ref = yield* SubscriptionRef.make([12, 87, 69])
+
+// The lens acts as a proxy that allows reading, subscribing from and writing to that
+// data source with a similar API to Effect's SubscriptionRef
+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* Lens.update(lens, Array.replace(1, 1664))
+```
+
+Currently available:
+- `fromSubscriptionRef`
+- `fromSynchronizedRef` (note: since `SynchronizedRef` is not reactive (does not produces a stream of value changes), the resulting Lens' `changes` stream will only emit the current value of the lens when evaluated, and nothing else)
+
+More to come!
+
+#### Manually
+You can also create Lenses manually using `make` by providing a getter, a stream of changes and either a `set` or `modify` function depending on your needs.
+
+You can get pretty creative! Here's an example of a Lens that points to a specific key of the browser `LocalStorage`:
+```typescript
+//      \/ Lens<Option.Option<string>, PlatformError, PlatformError, never, never>
+const lens = Effect.all([
+    KeyValueStore.KeyValueStore,
+    Effect.succeed("someKey"),
+]).pipe(
+    Effect.map(([kv, key]) => Lens.make({
+        get: kv.get(key),
+
+        changes: kv.get(key).pipe(
+            Effect.map(Stream.make),
+            Effect.map(a => Stream.concat(
+                a,
+                BrowserStream.fromEventListenerWindow("storage").pipe(
+                    Stream.filter(event => event.key === key),
+                    Stream.map(event => Option.fromNullable(event.newValue)),
+                ),
+            )),
+            Stream.unwrap,
+        ),
+
+        set: a => Option.isSome(a)
+            ? kv.set(key, a.value)
+            : kv.remove(key),
+    })),
+
+    Effect.provide(BrowserKeyValueStore.layerLocalStorage),
+    Lens.unwrap,
+)
+```
+
+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.
+
+What does this mean? Let's say you have a Lens with this signature:
+```typescript
+Lens<{ readonly a: string, readonly b: number }, never, never, never, never>
+```
+
+*Focusing this Lens on `a`* means deriving a new Lens that points to the `a` field of the struct the current Lens points to, resulting in a:
+```typescript
+Lens<string, never, never, never, never>
+```
+
+Focuses Lenses work just the same as a Lens that points directly to a data source and can be read, subscribed to or written to.
+
+Writing to them will properly update parent Lenses or data sources. Such updates can be performed in both a mutable or an immutable manner depending on your choice.
+
+This is a very powerful pattern as it enables you to keep your state in some shared data store while allowing you to pass specific parts of that state to some parts of your application. Very useful for frontend development!
+
+#### Using built-in transforms
+We provide a few helpers to create focused Lenses:
+```typescript
+interface User {
+    readonly name: string
+    readonly age: DateTime.Utc
+}
+
+// The state of your app
+const ref = yield* SubscriptionRef.make<{
+    readonly users: readonly User[]
+}>({
+    users: [
+        { name: "Jean Dupont", age: yield* DateTime.make("03/25/1969") },
+        { name: "Juan Joya Borja", age: yield* DateTime.make("04/05/1956") },
+        { name: "Benzemonstre", age: yield* DateTime.make("06/12/2000") },
+    ]
+})
+
+//                \/ Lens<User, NoSuchElementException, NoSuchElementException, never, never>
+const jeanDupontLens = ref.pipe(
+    Lens.fromSubscriptionRef,  // Creates a lens that proxies the ref
+    Lens.focusField("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
+)
+// 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
+
+const jeanDupont = yield* Lens.get(jeanDupontLens)
+
+yield* Lens.set(
+    // You can focus even further down
+    Lens.focusField(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'
+```
+
+Currently available:
+| Name | Description | Parent state mutation behavior | Notes |
+| - | - | - | - |
+| `focusField` | Focuses to the field of an object. Replaces the parent object immutably when writing to the focused field | Immutable | |
+| `focusMutableField` | Focuses to the 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 |
+| `focusChunkAt` | Focuses to an indexed entry of a `Chunk`. Replaces the parent `Chunk` immutably when writing to the focused element | Immutable | |
+
+Also more to come!
+
+#### Manually
+You can create focused Lenses by composing them manually using `map`, `mapEffect` and `unwrap`:
+```typescript
+interface User {
+    readonly name: string
+    readonly age: DateTime.Utc
+}
+
+const ref = yield* SubscriptionRef.make<readonly User[]>([
+    { name: "Jean Dupont", age: yield* DateTime.make("03/25/1969") },
+    { name: "Juan Joya Borja", age: yield* DateTime.make("04/05/1956") },
+    { name: "Benzemonstre", age: yield* DateTime.make("06/12/2000") },
+])
+
+//                  \/ Lens<User, NoSuchElementException, NoSuchElementException, never, never>
+const benzemonstreLens = ref.pipe(
+    Lens.fromSubscriptionRef,
+
+    // Manually focus
+    Lens.mapEffect(
+        // Getter:
+        Array.get(2),
+        // Setter:
+        (a, b) => Array.replaceOption(a, 2, b),
+    //   ^ The current Lens value (readonly User[])
+    //      ^ The new focused value to push (User)
+    ),
+)
+// Both Array.get and Array.replaceOption return an Option
+// When evaluated by the lens, Option<A> becomes Effect<A, NoSuchElementException>
+// As you can see, this is automatically tracked by the Lens type
+```
+
+
+### 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:
+```typescript
+const ref = yield* SubscriptionRef.make<{
+    readonly users: readonly User[]
+}>({ 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(users.changes, ...))
+})
+
+const lens = ref.pipe(
+    Lens.fromSubscriptionRef,
+    Lens.focusField("users"),
+)
+yield* someFunctionThatShouldOnlyHaveReadonlyAccessToTheState(lens)
+```
+
+
+## Todo
+
+This library is already ready to use! However, there is always more to do...
+- Finish those docs
+- Provide an API reference
+- Add new adapters for various data source types
+- Add new focus transforms
+- Provide a preview version for Effect 4 beta

package/dist/Lens.d.ts

@@ -0,0 +1,194 @@
+import { Chunk, Effect, Pipeable, Readable, Stream, Subscribable, type SubscriptionRef, type SynchronizedRef } from "effect";
+import type { NoSuchElementException } from "effect/Cause";
+export declare const LensTypeId: unique symbol;
+export type LensTypeId = typeof LensTypeId;
+/**
+ * A bidirectional view into some shared state that exposes:
+ *
+ * 1. a `get` effect for reading the current value of type `A`,
+ * 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> {
+    readonly [LensTypeId]: LensTypeId;
+    readonly modify: <B, E1 = never, R1 = never>(f: (a: A) => Effect.Effect<readonly [B, A], E1, R1>) => Effect.Effect<B, ER | EW | E1, RR | RW | R1>;
+}
+declare const LensImpl_base: Pipeable.PipeableConstructor;
+/**
+ * Internal `Lens` implementation.
+ */
+export declare class LensImpl<in out A, in out ER = never, in out EW = never, in out RR = never, in out RW = never> extends LensImpl_base implements Lens<A, ER, EW, RR, RW> {
+    readonly get: Effect.Effect<A, ER, RR>;
+    readonly changes: Stream.Stream<A, ER, RR>;
+    readonly modify: <B, E1 = never, R1 = never>(f: (a: A) => Effect.Effect<readonly [B, A], E1, R1>) => Effect.Effect<B, ER | EW | E1, RR | RW | R1>;
+    readonly [Readable.TypeId]: Readable.TypeId;
+    readonly [Subscribable.TypeId]: Subscribable.TypeId;
+    readonly [LensTypeId]: LensTypeId;
+    constructor(get: Effect.Effect<A, ER, RR>, changes: Stream.Stream<A, ER, RR>, modify: <B, E1 = never, R1 = never>(f: (a: A) => Effect.Effect<readonly [B, A], E1, R1>) => Effect.Effect<B, ER | EW | E1, RR | RW | R1>);
+}
+/**
+ * Checks whether a value is a `Lens`.
+ */
+export declare const isLens: (u: unknown) => u is Lens<unknown, unknown, unknown, unknown, unknown>;
+/**
+ * Creates a `Lens` by supplying how to read the current value, observe changes, and apply transformations.
+ *
+ * Either `modify` or `set` needs to be supplied.
+ */
+export declare const make: <A, ER, EW, RR, RW>(options: {
+    readonly get: Effect.Effect<A, ER, RR>;
+    readonly changes: Stream.Stream<A, ER, RR>;
+} & ({
+    readonly modify: <B, E1 = never, R1 = never>(f: (a: A) => Effect.Effect<readonly [B, A], E1, R1>) => Effect.Effect<B, ER | EW | E1, RR | RW | R1>;
+} | {
+    readonly set: (a: A) => Effect.Effect<void, EW, RW>;
+})) => Lens<A, ER, EW, RR, RW>;
+/**
+ * Creates a `Lens` that proxies a `SubscriptionRef`.
+ */
+export declare const fromSubscriptionRef: <A>(ref: SubscriptionRef.SubscriptionRef<A>) => Lens<A, never, never, never, never>;
+/**
+ * Creates a `Lens` that proxies a `SynchronizedRef`.
+ *
+ * Note: since `SynchronizedRef` does not provide any kind of reactivity mechanism, the produced `Lens` will be non-reactive.
+ * This means its `changes` stream will only emit the current value once when evaluated and nothing else.
+ */
+export declare const fromSynchronizedRef: <A>(ref: SynchronizedRef.SynchronizedRef<A>) => Lens<A, never, never, never, never>;
+/**
+ * Flattens an effectful `Lens`.
+ */
+export declare 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>;
+/**
+ * Derives a new `Lens` by applying synchronous getters and setters over the focused value.
+ */
+export declare 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, 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>;
+};
+/**
+ * Derives a new `Lens` by applying effectful getters and setters over the focused value.
+ */
+export declare 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, 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>;
+};
+/**
+ * Allows transforming only the `changes` stream of a `Lens` while keeping the focus type intact.
+ */
+export declare const mapStream: {
+    <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>;
+};
+/**
+ * Narrows the focus to a field of an object. Replaces the object in an immutable fashion when written to.
+ */
+export declare const focusField: {
+    <A extends object, K extends keyof A, ER, EW, RR, RW>(self: Lens<A, ER, EW, RR, RW>, key: K): Lens<A[K], ER, EW, RR, RW>;
+    <A extends object, K extends keyof A, ER, EW, RR, RW>(key: K): (self: Lens<A, ER, EW, RR, RW>) => Lens<A[K], ER, EW, RR, RW>;
+};
+export declare namespace focusMutableField {
+    type WritableKeys<T> = {
+        [K in keyof T]-?: IfEquals<{
+            [P in K]: T[K];
+        }, {
+            -readonly [P in K]: T[K];
+        }, K, never>;
+    }[keyof T];
+    type IfEquals<X, Y, A = X, B = never> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? A : B;
+}
+/**
+ * Narrows the focus to a mutable field of an object. Mutates the object in place when written to.
+ */
+export declare const focusMutableField: {
+    <A extends object, K extends focusMutableField.WritableKeys<A>, ER, EW, RR, RW>(self: Lens<A, ER, EW, RR, RW>, key: K): Lens<A[K], ER, EW, RR, RW>;
+    <A extends object, K extends focusMutableField.WritableKeys<A>, ER, EW, RR, RW>(key: K): (self: Lens<A, ER, EW, RR, RW>) => Lens<A[K], ER, EW, RR, RW>;
+};
+/**
+ * Narrows the focus to an indexed element of an array. Replaces the array in an immutable fashion when written to.
+ */
+export declare const focusArrayAt: {
+    <A extends readonly any[], ER, EW, RR, RW>(self: Lens<A, ER, EW, RR, RW>, index: number): Lens<A[number]>;
+    <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>;
+};
+/**
+ * Narrows the focus to an indexed element of a mutable array. Mutates the array in place when written to.
+ */
+export declare const focusMutableArrayAt: {
+    <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>;
+};
+/**
+ * Narrows the focus to an indexed element of `Chunk`. Replaces the `Chunk` in an immutable fashion when written to.
+ */
+export declare const focusChunkAt: {
+    <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>;
+};
+/**
+ * Reads the current value from a `Lens`.
+ */
+export declare const get: <A, ER, EW, RR, RW>(self: Lens<A, ER, EW, RR, RW>) => Effect.Effect<A, ER, RR>;
+/**
+ * Sets the value of a `Lens`.
+ */
+export declare const set: {
+    <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>;
+};
+/**
+ * Sets a `Lens` to a new value and returns the previous value.
+ */
+export declare const getAndSet: {
+    <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>;
+};
+/**
+ * Applies a synchronous transformation to the value of a `Lens`, discarding the previous value.
+ */
+export declare const update: {
+    <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>;
+};
+/**
+ * Applies an effectful transformation to the value of a `Lens`, discarding the previous value.
+ */
+export declare const updateEffect: {
+    <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>;
+};
+/**
+ * Applies a synchronous transformation the value of a `Lens` while returning the previous value.
+ */
+export declare const getAndUpdate: {
+    <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>;
+};
+/**
+ * Applies an effectful transformation the value of a `Lens` while returning the previous value.
+ */
+export declare const getAndUpdateEffect: {
+    <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>;
+};
+/**
+ * Sets the value of a `Lens` and returns the new value.
+ */
+export declare const setAndGet: {
+    <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>;
+};
+/**
+ * Applies a synchronous update the value of a `Lens` and returns the new value.
+ */
+export declare const updateAndGet: {
+    <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>;
+};
+/**
+ * Applies an effectful update to the value of a `Lens` and returns the new value.
+ */
+export declare const updateAndGetEffect: {
+    <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>;
+};
+export {};

package/dist/Lens.js

@@ -0,0 +1,146 @@
+import { Array, Chunk, Effect, Function, Pipeable, Predicate, Readable, Stream, Subscribable } from "effect";
+export const LensTypeId = Symbol.for("@effect-fc/Lens/Lens");
+/**
+ * Internal `Lens` implementation.
+ */
+export class LensImpl extends Pipeable.Class() {
+    get;
+    changes;
+    modify;
+    [Readable.TypeId] = Readable.TypeId;
+    [Subscribable.TypeId] = Subscribable.TypeId;
+    [LensTypeId] = LensTypeId;
+    constructor(get, changes, modify) {
+        super();
+        this.get = get;
+        this.changes = changes;
+        this.modify = modify;
+    }
+}
+/**
+ * Checks whether a value is a `Lens`.
+ */
+export const isLens = (u) => Predicate.hasProperty(u, LensTypeId);
+/**
+ * Creates a `Lens` by supplying how to read the current value, observe changes, and apply transformations.
+ *
+ * Either `modify` or `set` needs to be supplied.
+ */
+export const make = (options) => new LensImpl(options.get, options.changes, Predicate.hasProperty(options, "modify")
+    ? options.modify
+    : (f) => Effect.flatMap(options.get, a => Effect.flatMap(f(a), ([b, next]) => Effect.as(options.set(next), b))));
+/**
+ * Creates a `Lens` that proxies a `SubscriptionRef`.
+ */
+export const fromSubscriptionRef = (ref) => make({
+    get get() { return ref.get; },
+    get changes() { return ref.changes; },
+    modify: (f) => ref.modifyEffect(f),
+});
+/**
+ * Creates a `Lens` that proxies a `SynchronizedRef`.
+ *
+ * Note: since `SynchronizedRef` does not provide any kind of reactivity mechanism, the produced `Lens` will be non-reactive.
+ * This means its `changes` stream will only emit the current value once when evaluated and nothing else.
+ */
+export const fromSynchronizedRef = (ref) => make({
+    get get() { return ref.get; },
+    get changes() { return Stream.unwrap(Effect.map(ref.get, Stream.make)); },
+    modify: (f) => ref.modifyEffect(f),
+});
+/**
+ * Flattens an effectful `Lens`.
+ */
+export const unwrap = (effect) => make({
+    get: Effect.flatMap(effect, l => l.get),
+    changes: Stream.unwrap(Effect.map(effect, l => l.changes)),
+    modify: (f) => Effect.flatMap(effect, l => l.modify(f)),
+});
+/**
+ * Derives a new `Lens` by applying synchronous getters and setters over the focused value.
+ */
+export const map = Function.dual(3, (self, get, set) => make({
+    get get() { return Effect.map(self.get, get); },
+    get changes() { return Stream.map(self.changes, get); },
+    modify: (f) => self.modify(a => Effect.flatMap(f(get(a)), ([c, next]) => Effect.succeed([c, set(a, next)]))),
+}));
+/**
+ * Derives a new `Lens` by applying effectful getters and setters over the focused value.
+ */
+export const mapEffect = Function.dual(3, (self, get, set) => make({
+    get get() { return Effect.flatMap(self.get, get); },
+    get changes() { return Stream.mapEffect(self.changes, get); },
+    modify: (f) => self.modify(a => Effect.flatMap(get(a), b => Effect.flatMap(f(b), ([c, bNext]) => Effect.flatMap(set(a, bNext), nextA => Effect.succeed([c, nextA]))))),
+}));
+/**
+ * Allows transforming only the `changes` stream of a `Lens` while keeping the focus type intact.
+ */
+export const mapStream = Function.dual(2, (self, f) => make({
+    get get() { return self.get; },
+    get changes() { return f(self.changes); },
+    get modify() { return self.modify; },
+}));
+/**
+ * Narrows the focus to a field of an object. Replaces the object in an immutable fashion when written to.
+ */
+export const focusField = Function.dual(2, (self, key) => map(self, a => a[key], (a, b) => Object.setPrototypeOf({ ...a, [key]: b }, Object.getPrototypeOf(a))));
+/**
+ * Narrows the focus to a mutable field of an object. Mutates the object in place when written to.
+ */
+export const focusMutableField = Function.dual(2, (self, key) => map(self, a => a[key], (a, b) => { a[key] = b; return a; }));
+/**
+ * Narrows the focus to an indexed element of an array. Replaces the array in an immutable fashion when written to.
+ */
+export const focusArrayAt = Function.dual(2, (self, index) => mapEffect(self, Array.get(index), (a, b) => Array.replaceOption(a, index, b)));
+/**
+ * Narrows the focus to an indexed element of a mutable array. Mutates the array in place when written to.
+ */
+export const focusMutableArrayAt = Function.dual(2, (self, index) => mapEffect(self, Array.get(index), (a, b) => Effect.flatMap(Array.get(a, index), () => Effect.as(Effect.sync(() => { a[index] = b; }), a))));
+/**
+ * Narrows the focus to an indexed element of `Chunk`. Replaces the `Chunk` in an immutable fashion when written to.
+ */
+export const focusChunkAt = Function.dual(2, (self, index) => mapEffect(self, Chunk.get(index), (a, b) => Effect.succeed(Chunk.replace(a, index, b))));
+/**
+ * Reads the current value from a `Lens`.
+ */
+export const get = (self) => self.get;
+/**
+ * Sets the value of a `Lens`.
+ */
+export const set = Function.dual(2, (self, value) => self.modify(() => Effect.succeed([void 0, value])));
+/**
+ * Sets a `Lens` to a new value and returns the previous value.
+ */
+export const getAndSet = Function.dual(2, (self, value) => self.modify(a => Effect.succeed([a, value])));
+/**
+ * Applies a synchronous transformation to the value of a `Lens`, discarding the previous value.
+ */
+export const update = Function.dual(2, (self, f) => self.modify(a => Effect.succeed([void 0, f(a)])));
+/**
+ * Applies an effectful transformation to the value of a `Lens`, discarding the previous value.
+ */
+export const updateEffect = Function.dual(2, (self, f) => self.modify(a => Effect.flatMap(f(a), next => Effect.succeed([void 0, next]))));
+/**
+ * Applies a synchronous transformation the value of a `Lens` while returning the previous value.
+ */
+export const getAndUpdate = Function.dual(2, (self, f) => self.modify(a => Effect.succeed([a, f(a)])));
+/**
+ * Applies an effectful transformation the value of a `Lens` while returning the previous value.
+ */
+export const getAndUpdateEffect = Function.dual(2, (self, f) => self.modify(a => Effect.flatMap(f(a), next => Effect.succeed([a, next]))));
+/**
+ * Sets the value of a `Lens` and returns the new value.
+ */
+export const setAndGet = Function.dual(2, (self, value) => self.modify(() => Effect.succeed([value, value])));
+/**
+ * Applies a synchronous update the value of a `Lens` and returns the new value.
+ */
+export const updateAndGet = Function.dual(2, (self, f) => self.modify(a => {
+    const next = f(a);
+    return Effect.succeed([next, next]);
+}));
+/**
+ * Applies an effectful update to the value of a `Lens` and returns the new value.
+ */
+export const updateAndGetEffect = Function.dual(2, (self, f) => self.modify(a => Effect.flatMap(f(a), next => Effect.succeed([next, next]))));
+//# sourceMappingURL=Lens.js.map

package/dist/Lens.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Lens.js","sourceRoot":"","sources":["../src/Lens.ts"],"names":[],"mappings":"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"}

package/dist/PropertyPath.d.ts

@@ -0,0 +1,23 @@
+import { Equivalence, Option } from "effect";
+export type PropertyPath = readonly PropertyKey[];
+type Prev = readonly [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+export type Paths<T, D extends number = 5, Seen = never> = readonly [] | (D extends never ? readonly [] : T extends Seen ? readonly [] : T extends readonly any[] ? {
+    [K in keyof T as K extends number ? K : never]: readonly [K] | readonly [K, ...Paths<T[K], Prev[D], Seen | T>];
+} extends infer O ? O[keyof O] : never : T extends object ? {
+    [K in keyof T as K extends string | number | symbol ? K : never]-?: NonNullable<T[K]> extends infer V ? readonly [K] | readonly [K, ...Paths<V, Prev[D], Seen>] : never;
+} extends infer O ? O[keyof O] : never : never);
+export type ValueFromPath<T, P extends readonly any[]> = P extends readonly [infer Head, ...infer Tail] ? Head extends keyof T ? ValueFromPath<T[Head], Tail> : T extends readonly any[] ? Head extends number ? ValueFromPath<T[number], Tail> : never : never : T;
+export declare const equivalence: Equivalence.Equivalence<PropertyPath>;
+export declare const unsafeGet: {
+    <T, const P extends Paths<T>>(path: P): (self: T) => ValueFromPath<T, P>;
+    <T, const P extends Paths<T>>(self: T, path: P): ValueFromPath<T, P>;
+};
+export declare const get: {
+    <T, const P extends Paths<T>>(path: P): (self: T) => Option.Option<ValueFromPath<T, P>>;
+    <T, const P extends Paths<T>>(self: T, path: P): Option.Option<ValueFromPath<T, P>>;
+};
+export declare const immutableSet: {
+    <T, const P extends Paths<T>>(path: P, value: ValueFromPath<T, P>): (self: T) => Option.Option<T>;
+    <T, const P extends Paths<T>>(self: T, path: P, value: ValueFromPath<T, P>): Option.Option<T>;
+};
+export {};

package/dist/PropertyPath.js

@@ -0,0 +1,30 @@
+import { Array, Equivalence, Function, Option, Predicate } from "effect";
+export const equivalence = Equivalence.array(Equivalence.strict());
+export const unsafeGet = Function.dual(2, (self, path) => path.reduce((acc, key) => acc?.[key], self));
+export const get = Function.dual(2, (self, path) => path.reduce((acc, key) => Option.isSome(acc)
+    ? Predicate.hasProperty(acc.value, key)
+        ? Option.some(acc.value[key])
+        : Option.none()
+    : acc, Option.some(self)));
+export const immutableSet = Function.dual(3, (self, path, value) => {
+    const key = Array.head(path);
+    if (Option.isNone(key))
+        return Option.some(value);
+    if (!Predicate.hasProperty(self, key.value))
+        return Option.none();
+    const child = immutableSet(self[key.value], Option.getOrThrow(Array.tail(path)), value);
+    if (Option.isNone(child))
+        return child;
+    if (Array.isArray(self))
+        return typeof key.value === "number"
+            ? Option.some([
+                ...self.slice(0, key.value),
+                child.value,
+                ...self.slice(key.value + 1),
+            ])
+            : Option.none();
+    if (typeof self === "object")
+        return Option.some(Object.assign(Object.create(Object.getPrototypeOf(self)), { ...self, [key.value]: child.value }));
+    return Option.none();
+});
+//# sourceMappingURL=PropertyPath.js.map

package/dist/PropertyPath.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PropertyPath.js","sourceRoot":"","sources":["../src/PropertyPath.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAA;AAyCxE,MAAM,CAAC,MAAM,WAAW,GAA0C,WAAW,CAAC,KAAK,CAAC,WAAW,CAAC,MAAM,EAAE,CAAC,CAAA;AAEzG,MAAM,CAAC,MAAM,SAAS,GAGlB,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,CAA8B,IAAO,EAAE,IAAO,EAAuB,EAAE,CACxF,IAAI,CAAC,MAAM,CAAC,CAAC,GAAQ,EAAE,GAAQ,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC,CACxD,CAAA;AAED,MAAM,CAAC,MAAM,GAAG,GAGZ,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,CAA8B,IAAO,EAAE,IAAO,EAAsC,EAAE,CACvG,IAAI,CAAC,MAAM,CACP,CAAC,GAAuB,EAAE,GAAQ,EAAsB,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC;IACzE,CAAC,CAAC,SAAS,CAAC,WAAW,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC;QACnC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAC7B,CAAC,CAAC,MAAM,CAAC,IAAI,EAAE;IACnB,CAAC,CAAC,GAAG,EAET,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CACpB,CACJ,CAAA;AAED,MAAM,CAAC,MAAM,YAAY,GAGrB,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,CAA8B,IAAO,EAAE,IAAO,EAAE,KAA0B,EAAoB,EAAE;IACjH,MAAM,GAAG,GAAG,KAAK,CAAC,IAAI,CAAC,IAAoB,CAAC,CAAA;IAC5C,IAAI,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC;QAClB,OAAO,MAAM,CAAC,IAAI,CAAC,KAAU,CAAC,CAAA;IAClC,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,IAAI,EAAE,GAAG,CAAC,KAAK,CAAC;QACvC,OAAO,MAAM,CAAC,IAAI,EAAE,CAAA;IAExB,MAAM,KAAK,GAAG,YAAY,CAAW,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,IAAoB,CAAC,CAAC,EAAE,KAAK,CAAC,CAAA;IACjH,IAAI,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC;QACpB,OAAO,KAAK,CAAA;IAEhB,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC;QACnB,OAAO,OAAO,GAAG,CAAC,KAAK,KAAK,QAAQ;YAChC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC;gBACV,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,KAAK,CAAC;gBAC3B,KAAK,CAAC,KAAK;gBACX,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,GAAG,CAAC,CAAC;aAC1B,CAAC;YACP,CAAC,CAAC,MAAM,CAAC,IAAI,EAAE,CAAA;IAEvB,IAAI,OAAO,IAAI,KAAK,QAAQ;QACxB,OAAO,MAAM,CAAC,IAAI,CACd,MAAM,CAAC,MAAM,CACT,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,EAC1C,EAAE,GAAG,IAAI,EAAE,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,KAAK,EAAE,CACxC,CACJ,CAAA;IAEL,OAAO,MAAM,CAAC,IAAI,EAAE,CAAA;AACxB,CAAC,CAAC,CAAA"}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * as Lens from "./Lens.js";
+export * as PropertyPath from "./PropertyPath.js";

package/dist/index.js

@@ -0,0 +1,3 @@
+export * as Lens from "./Lens.js";
+export * as PropertyPath from "./PropertyPath.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AACjC,OAAO,KAAK,YAAY,MAAM,mBAAmB,CAAA"}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "effect-lens",
+  "description": "An effectful Lens type to easily manage nested state",
+  "version": "0.1.0",
+  "type": "module",
+  "files": [
+    "./README.md",
+    "./dist"
+  ],
+  "license": "MIT",
+  "repository": {
+    "url": "git+https://github.com/Thiladev/effect-lens.git"
+  },
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./*": [
+      {
+        "types": "./dist/*/index.d.ts",
+        "default": "./dist/*/index.js"
+      },
+      {
+        "types": "./dist/*.d.ts",
+        "default": "./dist/*.js"
+      }
+    ]
+  },
+  "scripts": {
+    "build": "tsc",
+    "lint:tsc": "tsc --noEmit",
+    "lint:biome": "biome lint",
+    "pack": "npm pack",
+    "clean:cache": "rm -rf .turbo tsconfig.tsbuildinfo",
+    "clean:dist": "rm -rf dist",
+    "clean:modules": "rm -rf node_modules"
+  },
+  "peerDependencies": {
+    "effect": "^3.21.0"
+  }
+}