@typed/fx 1.1.1 → 1.2.0

package/src/Subject/HoldSubject.ts

@@ -3,17 +3,12 @@ import { type MutableRef, make } from '@effect/data/MutableRef'
 import { type Option, none } from '@effect/data/Option'
 import * as Effect from '@effect/io/Effect'
 
-import type { Fx, Sink } from '../Fx.js'
 import { never } from '../constructor/never.js'
 import { HoldFx } from '../operator/hold.js'
 
 import { isSubject, Subject } from './Subject.js'
 
-export interface HoldSubject<E, A>
-  extends Fx<never, E, A>,
-    Sink<never, E, A>,
-    Subject.Variance<E, A>,
-    HoldSubject.Variance<E, A> {
+export interface HoldSubject<E, A> extends Subject<E, A>, HoldSubject.Variance<E, A> {
   readonly value: Effect.Effect<never, never, Option<A>>
 }
 

package/src/Subject/RefSubject.test.ts

@@ -0,0 +1,81 @@
+import { deepStrictEqual } from 'assert'
+
+import * as Effect from '@effect/io/Effect'
+import { describe, it } from 'vitest'
+
+import { makeRef, RefSubject } from './RefSubject.js'
+
+describe(import.meta.url, () => {
+  describe('RefSubject.tuple', () => {
+    it('allows joining RefSubjects into a single interface', async () => {
+      const test = Effect.scoped(
+        Effect.gen(function* ($) {
+          const a = yield* $(makeRef(() => 1))
+          const b = yield* $(makeRef(() => 2))
+          const c = yield* $(makeRef(() => 3))
+          const tupled = yield* $(RefSubject.tuple(a, b, c))
+
+          deepStrictEqual(yield* $(tupled.get), [1, 2, 3])
+
+          yield* $(b.set(4))
+
+          deepStrictEqual(yield* $(tupled.get), [1, 4, 3])
+
+          yield* $(tupled.set([5, 6, 7]))
+
+          deepStrictEqual(yield* $(a.get), 5)
+          deepStrictEqual(yield* $(b.get), 6)
+          deepStrictEqual(yield* $(c.get), 7)
+        }),
+      )
+
+      await Effect.runPromise(test)
+    })
+  })
+
+  describe('RefSubject.struct', () => {
+    it('allows joining RefSubjects into a single interface', async () => {
+      const test = Effect.scoped(
+        Effect.gen(function* ($) {
+          const a = yield* $(makeRef(() => 1))
+          const b = yield* $(makeRef(() => 2))
+          const c = yield* $(makeRef(() => 3))
+          const struct = yield* $(RefSubject.struct({ a, b, c }))
+
+          deepStrictEqual(yield* $(struct.get), { a: 1, b: 2, c: 3 })
+
+          yield* $(b.set(4))
+
+          deepStrictEqual(yield* $(struct.get), { a: 1, b: 4, c: 3 })
+
+          yield* $(struct.set({ a: 5, b: 6, c: 7 }))
+
+          deepStrictEqual(yield* $(a.get), 5)
+          deepStrictEqual(yield* $(b.get), 6)
+          deepStrictEqual(yield* $(c.get), 7)
+        }),
+      )
+
+      await Effect.runPromise(test)
+    })
+  })
+
+  describe('Computed', () => {
+    it('allows computing values from a RefSubject', async () => {
+      const test = Effect.scoped(
+        Effect.gen(function* ($) {
+          const refSubject = yield* $(makeRef(() => 1))
+          const computed = yield* $(refSubject.computeSync((a) => a + 42))
+
+          deepStrictEqual(yield* $(computed.get), 43)
+
+          yield* $(refSubject.set(2))
+
+          deepStrictEqual(yield* $(computed.get), 44)
+        }),
+      )
+
+      await Effect.runPromise(test)
+    })
+  })
+})

package/src/Subject/RefSubject.ts

@@ -1,57 +1,65 @@
 import { equals } from '@effect/data/Equal'
-import { identity, pipe } from '@effect/data/Function'
+import { identity, pipe, dual, flow } from '@effect/data/Function'
 import * as MutableRef from '@effect/data/MutableRef'
 import * as Option from '@effect/data/Option'
+import * as ReadonlyArray from '@effect/data/ReadonlyArray'
+import * as ReadonlyRecord from '@effect/data/ReadonlyRecord'
+import * as Equivalence from '@effect/data/typeclass/Equivalence'
 import * as Effect from '@effect/io/Effect'
+import type * as Exit from '@effect/io/Exit'
 import * as Ref from '@effect/io/Ref'
+import type * as Scope from '@effect/io/Scope'
 
-import { Fx } from '../Fx.js'
+import { Fx, Sink } from '../Fx.js'
+import { flatMapEffect } from '../operator/flatMapEffect.js'
+import { hold } from '../operator/hold.js'
+import { skipWhile } from '../operator/skipWhile.js'
+import { observe } from '../run/observe.js'
 
 import { HoldSubject, isHoldSubject } from './HoldSubject.js'
 import { Subject } from './Subject.js'
 
 export interface RefSubject<A> extends HoldSubject<never, A>, Ref.Ref<A> {
+  readonly eq: Equivalence.Equivalence<A>
   readonly get: Effect.Effect<never, never, A>
   readonly set: (a: A) => Effect.Effect<never, never, A>
   readonly update: (f: (a: A) => A) => Effect.Effect<never, never, A>
-  readonly delete: Effect.Effect<never, never, Option.Option<A>>
+  readonly delete: Effect.Effect<never, never, A>
+
+  readonly compute: <R, E, B>(
+    f: (a: A) => Effect.Effect<R, E, B>,
+  ) => Effect.Effect<R | Scope.Scope, never, Computed<E, B>>
+
+  readonly computeSync: <B>(f: (a: A) => B) => Effect.Effect<Scope.Scope, never, Computed<never, B>>
 }
 
 export function makeRef<A>(
   initial: () => A,
-  eq: (a: A, b: A) => boolean = equals,
+  eq: Equivalence.Equivalence<A> = equals,
 ): Effect.Effect<never, never, RefSubject<A>> {
   return Effect.sync(() => RefSubject.unsafeMake(initial, eq))
 }
 
 export namespace RefSubject {
+  export type ValueOf<T> = T extends RefSubject<infer A> ? A : never
+
   export function unsafeMake<A>(
     initial: () => A,
-    eq: (a: A, b: A) => boolean = equals,
+    eq: Equivalence.Equivalence<A> = equals,
   ): RefSubject<A> {
-    const mutableRef = MutableRef.make(Option.some(initial()))
-    const subject = HoldSubject.unsafeMake<never, A>(mutableRef)
+    const current = MutableRef.make(Option.some(initial()))
+    const subject = HoldSubject.unsafeMake<never, A>(current)
 
-    const getValue = () =>
-      pipe(
-        mutableRef.get(),
-        Option.getOrElse(() => {
-          const a = initial()
+    const getValue = () => pipe(current.get(), Option.getOrElse(initial))
 
-          mutableRef.set(Option.some(a))
-
-          return a
-        }),
-      )
-
-    const modify = <B>(f: (a: A) => [B, A]): Effect.Effect<never, never, B> =>
+    const modify = <B>(f: (a: A) => readonly [B, A]): Effect.Effect<never, never, B> =>
       Effect.suspendSucceed(() => {
-        const current = getValue()
-        const [b, a] = f(current)
+        const currentValue = getValue()
+        const [b, a] = f(currentValue)
 
-        mutableRef.set(Option.some(a))
+        current.set(Option.some(a))
 
-        if (eq(current, a)) {
+        if (eq(currentValue, a)) {
           return Effect.succeed(b)
         }
 
@@ -70,30 +78,242 @@ export namespace RefSubject {
       error: subject.error.bind(subject),
       end: subject.end,
       value: subject.value,
+      eq,
       modify,
-      get get() {
-        return Ref.get(refSubject)
-      },
-      set(a: A) {
-        return Ref.updateAndGet(() => a)(refSubject)
-      },
-      update(f: (a: A) => A) {
-        return Ref.updateAndGet(f)(refSubject)
-      },
+      ...makeDerivations(modify, Effect.sync(getValue)),
       delete: Effect.sync(() => {
-        const option = mutableRef.get()
+        const option = current.get()
+        const reset = initial()
+        current.set(Option.some(reset))
 
-        // Next pull should recompute the initial value
-        mutableRef.set(Option.none())
-
-        return option
+        return Option.getOrElse(option, () => reset)
       }),
+      compute: (f) => makeComputed(refSubject, f),
+      computeSync: (f) => makeComputed(refSubject, (a) => Effect.sync(() => f(a))),
     }
 
     return refSubject
   }
+
+  export function tuple<Subjects extends ReadonlyArray.NonEmptyReadonlyArray<RefSubject<any>>>(
+    ...subjects: Subjects
+  ): Effect.Effect<
+    Scope.Scope,
+    never,
+    RefSubject<{ readonly [K in keyof Subjects]: ValueOf<Subjects[K]> }>
+  > {
+    type Val = { readonly [K in keyof Subjects]: ValueOf<Subjects[K]> }
+    const length = subjects.length
+
+    const getUnderlyingValues = Effect.tuple(
+      ...ReadonlyArray.mapNonEmpty(subjects, (s) => s.get),
+    ) as Effect.Effect<never, never, Val>
+
+    const eq = Equivalence.tuple(
+      ...ReadonlyArray.mapNonEmpty(subjects, (s) => s.eq),
+    ) as Equivalence.Equivalence<Val>
+
+    return Effect.gen(function* ($) {
+      const initial = yield* $(getUnderlyingValues)
+      const refSubject = unsafeMake(() => initial, eq)
+
+      const updateAtIndex =
+        <I extends keyof Val & number>(i: I) =>
+        (a: Val[I]) =>
+          Effect.gen(function* ($) {
+            const current = yield* $(refSubject.get)
+            const next = current.slice()
+            next[i] = a
+
+            yield* $(refSubject.set(next as Val))
+          })
+
+      // Override event to replicate events into underlying subjects
+      const event = (val: Val) =>
+        Effect.tuple(...ReadonlyArray.mapNonEmpty(subjects, (s, i) => s.event(val[i])))
+
+      // Override modify to replicate events into underlying subjects
+      const modify = <B>(f: (a: Val) => readonly [B, Val]): Effect.Effect<never, never, B> =>
+        Effect.gen(function* ($) {
+          const current = yield* $(getUnderlyingValues)
+          const [b, a] = f(current)
+
+          if (!eq(current, a)) {
+            // Will update this RefSubject using observe below
+            yield* $(event(a))
+          }
+
+          return b
+        })
+
+      // Listen to changes to each subject and update the derived subject
+      for (let i = 0; i < length; i++) {
+        yield* $(Effect.forkScoped(observe(updateAtIndex(i))(subjects[i])))
+      }
+
+      // Allow underlying subscriptions to start
+      yield* $(Effect.yieldNow())
+
+      const derived: RefSubject<Val> = {
+        ...refSubject,
+        event,
+        modify,
+        ...makeDerivations(modify, refSubject.get),
+        compute: (f) => makeComputed(derived, f),
+      }
+
+      return derived
+    })
+  }
+
+  export function struct<Subjects extends Readonly<Record<string, RefSubject<any>>>>(
+    subjects: Subjects,
+  ): Effect.Effect<
+    Scope.Scope,
+    never,
+    RefSubject<{ readonly [K in keyof Subjects]: ValueOf<Subjects[K]> }>
+  > {
+    type Val = { readonly [K in keyof Subjects]: ValueOf<Subjects[K]> }
+
+    const getUnderlyingValues = Effect.struct(
+      ReadonlyRecord.map(subjects, (s) => s.get),
+    ) as Effect.Effect<never, never, Val>
+
+    const eq = Equivalence.struct(
+      ReadonlyRecord.map(subjects, (s) => s.eq),
+    ) as Equivalence.Equivalence<Val>
+
+    return Effect.gen(function* ($) {
+      const initial = yield* $(getUnderlyingValues)
+      const refSubject = unsafeMake(() => initial, eq)
+
+      const updateAtKey =
+        <I extends keyof Val & string>(i: I) =>
+        (a: Val[I]) =>
+          Effect.gen(function* ($) {
+            const current = yield* $(refSubject.get)
+            const next = { ...current, [i]: a }
+
+            yield* $(refSubject.set(next as Val))
+          })
+
+      // Override event to replicate events into underlying subjects
+      const event = (val: Val) =>
+        Effect.struct(ReadonlyRecord.map(subjects, (s, i) => s.event(val[i])))
+
+      // Override modify to replicate events into underlying subjects
+      const modify = <B>(f: (a: Val) => readonly [B, Val]): Effect.Effect<never, never, B> =>
+        Effect.gen(function* ($) {
+          const current = yield* $(getUnderlyingValues)
+          const [b, a] = f(current)
+
+          if (!eq(current, a)) {
+            // Will update this RefSubject using observe below
+            yield* $(event(a))
+          }
+
+          return b
+        })
+
+      // Listen to changes to each subject and update the derived subject
+      for (const i in subjects) {
+        yield* $(Effect.forkScoped(observe(updateAtKey(i))(subjects[i])))
+      }
+
+      // Allow underlying subscriptions to start
+      yield* $(Effect.yieldNow())
+
+      const derived: RefSubject<Val> = {
+        ...refSubject,
+        event,
+        modify,
+        ...makeDerivations(modify, refSubject.get),
+        compute: (f) => makeComputed(derived, f),
+      }
+
+      return derived
+    })
+  }
+
+  const makeDerivations = <A>(
+    modify: <B>(f: (a: A) => readonly [B, A]) => Effect.Effect<never, never, B>,
+    getValue: Effect.Effect<never, never, A>,
+  ) => {
+    return {
+      get: getValue,
+      set(a: A) {
+        return modify(() => [a, a])
+      },
+      update(f: (a: A) => A) {
+        return modify((a) => {
+          const a2 = f(a)
+          return [a2, a2]
+        })
+      },
+    }
+  }
 }
 
 export function isRefSubject<A>(u: unknown): u is RefSubject<A> {
   return isHoldSubject(u) && Ref.RefTypeId in u
 }
+
+export interface Computed<E, A> extends Fx<never, E, A> {
+  readonly get: Effect.Effect<never, E, A>
+}
+
+export namespace Computed {
+  export function make<A, R, E, B>(
+    input: RefSubject<A>,
+    compute: (a: A) => Effect.Effect<R, E, B>,
+  ): Effect.Effect<R | Scope.Scope, never, Computed<E, B>> {
+    return Effect.gen(function* ($) {
+      const compute_ = flow(compute, Effect.exit)
+      const initialInput = yield* $(input.get)
+      const initial = yield* $(compute_(initialInput))
+      const refSubject = yield* $(makeRef(() => initial))
+
+      yield* $(
+        pipe(
+          input,
+          skipWhile((x) => input.eq(x, initialInput)), // We already have the initial value, don't waste downstream resources
+          observe((a) => Effect.flatMap(compute_(a), refSubject.set)),
+          Effect.forkScoped,
+        ),
+      )
+
+      // Allow subscription to finalize as HoldFx under the hood of RefSubject schedules the start of the Fx.
+      yield* $(Effect.yieldNow())
+
+      return new ComputedImpl(refSubject)
+    })
+  }
+
+  class ComputedImpl<E, A> extends Fx.Variance<never, E, A> implements Computed<E, A> {
+    readonly fx: Fx<never, E, A>
+
+    constructor(readonly input: RefSubject<Exit.Exit<E, A>>) {
+      super()
+
+      this.fx = pipe(input, flatMapEffect(Effect.done), hold)
+    }
+
+    run<R3>(sink: Sink<R3, E, A>) {
+      return this.fx.run(sink)
+    }
+
+    readonly get = Effect.flatMap(this.input.get, Effect.done)
+  }
+}
+
+export const makeComputed: {
+  <A, R, E, B>(input: RefSubject<A>, compute: (a: A) => Effect.Effect<R, E, B>): Effect.Effect<
+    R | Scope.Scope,
+    never,
+    Computed<E, B>
+  >
+
+  <A, R, E, B>(compute: (a: A) => Effect.Effect<R, E, B>): (
+    input: RefSubject<A>,
+  ) => Effect.Effect<R | Scope.Scope, never, Computed<E, B>>
+} = dual(2, Computed.make)

package/src/Subject/SynchronizedSubject.ts

@@ -9,7 +9,7 @@ import * as Synchronized from '@effect/io/Ref/Synchronized'
 import { Fx } from '../Fx.js'
 
 import { HoldSubject } from './HoldSubject.js'
-import { isRefSubject, RefSubject } from './RefSubject.js'
+import { Computed, isRefSubject, RefSubject } from './RefSubject.js'
 import { Subject } from './Subject.js'
 
 export interface SynchronizedSubject<A> extends RefSubject<A>, Synchronized.Synchronized<A> {
@@ -30,8 +30,7 @@ export namespace SynchronizedSubject {
   ): SynchronizedSubject<A> {
     const mutableRef = MutableRef.make(Option.some(initial()))
     const subject = HoldSubject.unsafeMake<never, A>(mutableRef)
-    const semaphore = Effect.unsafeMakeSemaphore(1)
-    const locked = semaphore.withPermits(1)
+    const locked = Effect.unsafeMakeSemaphore(1).withPermits(1)
 
     const getValue = () =>
       pipe(
@@ -83,6 +82,7 @@ export namespace SynchronizedSubject {
       error: subject.error.bind(subject),
       end: subject.end,
       value: subject.value,
+      eq,
       modify,
       modifyEffect,
       get get() {
@@ -98,13 +98,14 @@ export namespace SynchronizedSubject {
         return Synchronized.updateAndGetEffect(f)(synchronizedSubject)
       },
       delete: Effect.sync(() => {
-        const option = mutableRef.get()
+        const value = getValue()
 
-        // Next pull should recompute the initial value
-        mutableRef.set(Option.none())
+        mutableRef.set(Option.some(value))
 
-        return option
+        return value
       }),
+      compute: (f) => Computed.make(synchronizedSubject, f),
+      computeSync: (f) => Computed.make(synchronizedSubject, (a) => Effect.sync(() => f(a))),
     }
 
     return synchronizedSubject

package/src/operator/multicast.ts

@@ -16,7 +16,7 @@ export class MulticastFx<R, E, A>
   extends Fx.Variance<R, E, A>
   implements Fx<R, E, A>, Fx.Sink<never, E, A>
 {
-  protected observers: Array<MulticastObserver<any, E, A>> = []
+  readonly observers: Array<MulticastObserver<any, E, A>> = []
   protected fiber: RuntimeFiber<never, unknown> | undefined
 
   constructor(readonly fx: Fx<R, E, A>) {