@typed/fx 1.12.6 → 1.14.0

package/src/RefSubject.ts

@@ -1,31 +1,47 @@
-import type { Trace } from '@effect/data/Debug'
-import { methodWithTrace } from '@effect/data/Debug'
-import { equals } from '@effect/data/Equal'
+import * as Context from '@effect/data/Context'
 import * as Equal from '@effect/data/Equal'
 import { identity, pipe } from '@effect/data/Function'
 import * as Hash from '@effect/data/Hash'
-import * as RR from '@effect/data/ReadonlyRecord'
-import * as Equivalence from '@effect/data/typeclass/Equivalence'
-
-import { Fx, Sink, isFx, Traced, FxTypeId } from './Fx.js'
-import type { Subject } from './Subject.js'
+import * as MutableRef from '@effect/data/MutableRef'
+import * as Option from '@effect/data/Option'
+import { Pipeable, pipeArguments } from '@effect/data/Pipeable'
+import * as Equivalence from '@effect/data/Equivalence'
+import * as Deferred from '@effect/io/Deferred'
+import * as Effect from '@effect/io/Effect'
+import * as Fiber from '@effect/io/Fiber'
+import * as Scope from '@effect/io/Scope'
+import fastDeepEqual from 'fast-deep-equal'
+
+import { Computed, ComputedImpl, ComputedTypeId } from './Computed.js'
+import { FilteredImpl } from './Filtered.js'
+import { Fx, FxTypeId, Sink, isFx } from './Fx.js'
+import { RefTransform, RefTransformImpl } from './RefTransform.js'
+import { Subject } from './Subject.js'
 import { combineAll } from './combineAll.js'
-import type { Context } from './externals.js'
-import { Effect, Fiber, MutableRef, Option } from './externals.js'
 import { HoldFx } from './hold.js'
-import { map } from './map.js'
-import { multicast } from './multicast.js'
 import { never } from './never.js'
-import { switchMapEffect } from './switchMap.js'
+import { drain } from './observe.js'
+import { struct } from './struct.js'
+import { switchMatchCauseEffect } from './switchMatch.js'
+
+const unboundedConcurrency = { concurrency: 'unbounded' } as const
+
+const refVariance = {
+  _R: identity,
+  _E: identity,
+  _A: identity,
+}
 
-export const RefSubjectTypeId = Symbol.for('./RefSubject')
+export const RefSubjectTypeId = Symbol.for('@typed/fx/RefSubject')
 export type RefSubjectTypeId = typeof RefSubjectTypeId
 
-export interface RefSubject<in out E, in out A> extends Subject<E, A>, Effect.Effect<never, E, A> {
+export interface RefSubject<in out E, in out A>
+  extends Subject<E, A>,
+    Computed<never, E, A>,
+    Pipeable {
   readonly [RefSubjectTypeId]: RefSubjectTypeId
 
   readonly eq: Equivalence.Equivalence<A>
-  readonly get: Effect.Effect<never, E, A>
 
   readonly modifyEffect: <R2, E2, B>(
     f: (a: A) => Effect.Effect<R2, E2, readonly [B, A]>,
@@ -39,57 +55,75 @@ export interface RefSubject<in out E, in out A> extends Subject<E, A>, Effect.Ef
 
   readonly update: (f: (a: A) => A) => Effect.Effect<never, E, A>
 
-  readonly set: (a: A) => Effect.Effect<never, E, A>
+  readonly set: (a: A) => Effect.Effect<never, never, A>
 
   readonly delete: Effect.Effect<never, E, Option.Option<A>>
 
-  readonly mapEffect: <R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>) => Computed<R2, E | E2, B>
-
-  readonly map: <B>(f: (a: A) => B) => Computed<never, E, B>
+  /**
+   * The current version of the RefSubject, starting with 0, 1 when initialized,
+   * and incremented each time the value is updated.
+   */
+  readonly version: () => number
 }
 
-export interface Computed<R, E, A> extends Fx<R, E, A>, Effect.Effect<R, E, A> {
-  readonly get: Effect.Effect<R, E, A>
-
-  readonly mapEffect: <R2, E2, B>(
-    f: (a: A) => Effect.Effect<R2, E2, B>,
-  ) => Computed<R | R2, E | E2, B>
-
-  readonly map: <B>(f: (a: A) => B) => Computed<R, E, B>
-}
+type Lock = <R2, E2, B>(effect: Effect.Effect<R2, E2, B>) => Effect.Effect<R2, E2, B>
 
 export function makeRef<R, E, A>(
   effect: Effect.Effect<R, E, A>,
-  eq: Equivalence.Equivalence<A> = equals,
-): Effect.Effect<R, never, RefSubject<E, A>> {
-  return Effect.contextWith(
-    (ctx: Context.Context<R>) => new RefSubjectImpl(Effect.provideContext(effect, ctx), eq),
+  eq?: Equivalence.Equivalence<A>,
+): Effect.Effect<R | Scope.Scope, never, RefSubject<E, A>> {
+  return Effect.contextWithEffect((context) =>
+    Effect.suspend(() => {
+      const ref = RefSubject.unsafeMake(
+        Effect.provideContext(effect, context),
+        Context.get(context, Scope.Scope),
+        eq,
+      )
+
+      return Effect.as(
+        Effect.addFinalizer(() => ref.end()),
+        ref,
+      )
+    }),
   )
 }
 
 export namespace RefSubject {
   export type Any = RefSubject<any, any> | RefSubject<never, any>
 
-  export function tuple<S extends ReadonlyArray<Any>>(
-    ...subjects: S
+  export function unsafeMake<E, A>(
+    initial: Effect.Effect<never, E, A>,
+    scope: Scope.Scope,
+    eq: Equivalence.Equivalence<A> = fastDeepEqual,
+  ): RefSubject<E, A> {
+    return makeRefFromPrimitive(unsafeMakeRefPrimitive(initial, scope, eq))
+  }
+
+  export function tuple<const Refs extends readonly Any[]>(
+    ...refs: Refs
   ): RefSubject<
-    Fx.ErrorsOf<S[number]>,
+    Fx.ErrorsOf<Refs[number]>,
     {
-      readonly [K in keyof S]: Fx.OutputOf<S[K]>
+      readonly [K in keyof Refs]: Fx.OutputOf<Refs[K]>
     }
   > {
-    return new TupleRefSubjectImpl(subjects)
+    return makeRefFromPrimitive<
+      Fx.ErrorsOf<Refs[number]>,
+      {
+        readonly [K in keyof Refs]: Fx.OutputOf<Refs[K]>
+      }
+    >(tupleRefPrimitive<Refs>(refs))
   }
 
-  export function struct<S extends RR.ReadonlyRecord<Any>>(
-    subjects: S,
+  export function struct<const Refs extends Readonly<Record<string, Any>>>(
+    refs: Refs,
   ): RefSubject<
-    Fx.ErrorsOf<S[keyof S]>,
+    Fx.ErrorsOf<Refs[string]>,
     {
-      readonly [K in keyof S]: Fx.OutputOf<S[K]>
+      readonly [K in keyof Refs]: Fx.OutputOf<Refs[K]>
     }
   > {
-    return new StructRefSubjectImpl(subjects)
+    return makeRefFromPrimitive(structRefPrimitive<Refs>(refs))
   }
 
   export function all<S extends ReadonlyArray<Any>>(
@@ -101,7 +135,16 @@ export namespace RefSubject {
     }
   >
 
-  export function all<S extends RR.ReadonlyRecord<Any>>(
+  export function all<S extends ReadonlyArray<Any>>(
+    ...subjects: S
+  ): RefSubject<
+    Fx.ErrorsOf<S[number]>,
+    {
+      readonly [K in keyof S]: Fx.OutputOf<S[K]>
+    }
+  >
+
+  export function all<S extends Readonly<Record<string, Any>>>(
     subjects: S,
   ): RefSubject<
     Fx.ErrorsOf<S[string]>,
@@ -110,643 +153,623 @@ export namespace RefSubject {
     }
   >
 
-  export function all(subjects: any): any {
-    return (Array.isArray(subjects) ? tuple(...subjects) : struct(subjects)) as any
-  }
+  export function all(...subjects: any): any {
+    /// MUST be a tuple if more than one argument
+    if (subjects.length > 1) {
+      return tuple(...subjects)
+    }
 
-  export function unsafeMake<E, A>(
-    get: Effect.Effect<never, E, A>,
-    eq: Equivalence.Equivalence<A> = equals,
-  ): RefSubject<E, A> {
-    return new RefSubjectImpl(get, eq)
+    // Otherwise a single param is either a tuple or a struct
+    const singleParam = subjects[0]
+
+    if (Array.isArray(singleParam)) {
+      return tuple(...singleParam)
+    }
+
+    return struct(singleParam)
   }
 }
 
-const refSubjectVariant = {
-  _R: identity,
-  _E: identity,
-  _A: identity,
+export function isRefSubject<E, A>(u: unknown): u is RefSubject<E, A> {
+  return isFx<never, E, A>(u) && RefSubjectTypeId in u
 }
 
-class RefSubjectImpl<E, A> extends HoldFx<never, E, A> implements RefSubject<E, A> {
-  readonly _tag = 'Commit'
-  public i2: any = undefined
-  public trace: Trace = undefined;
-
-  readonly [Effect.EffectTypeId] = refSubjectVariant;
-  readonly [RefSubjectTypeId]: RefSubjectTypeId = RefSubjectTypeId
-
-  readonly lock = Effect.unsafeMakeSemaphore(1).withPermits(1)
-  readonly initializeFiber: MutableRef.MutableRef<Option.Option<Fiber.RuntimeFiber<E, A>>> =
-    MutableRef.make(Option.none())
+// Internals for RefSubject
 
-  readonly eq: Equivalence.Equivalence<A>
-
-  constructor(readonly i0: Effect.Effect<never, E, A>, readonly i1: Equivalence.Equivalence<A>) {
-    super(never<E, A>())
+function makeGetFromContext<E, A>(ctx: RefSubjectContext<E, A>): RefSubject<E, A>['get'] {
+  return Effect.suspend(() => {
+    const current = MutableRef.get(ctx.currentRef)
 
-    this.modifyEffect = this.modifyEffect.bind(this)
-    this.eq = i1
-  }
+    if (Option.isSome(current)) {
+      return Effect.succeed(current.value)
+    }
 
-  run<R2>(sink: Sink<R2, E, A>) {
-    return Effect.suspend(() => {
-      const current = MutableRef.get(this.current)
+    const fiber = MutableRef.get(ctx.initializingFiberRef)
 
-      if (Option.isNone(current)) {
-        return pipe(
-          this.get,
-          Effect.catchAllCause(sink.error),
-          Effect.flatMap(() => super.run(sink)),
-        )
-      }
+    if (Option.isSome(fiber)) {
+      return Fiber.join(fiber.value)
+    }
 
-      return super.run(sink)
-    })
-  }
+    return Effect.tap(ctx.lock(initializeFromContext(ctx)), (a) => ctx.hold.event(a))
+  })
+}
 
-  readonly event: RefSubject<E, A>['event'] = methodWithTrace(
-    (trace) => (a: A) => Effect.catchAllCause(this.set(a), this.error).traced(trace),
+function initializeFromContext<E, A>(ctx: RefSubjectContext<E, A>): Effect.Effect<never, E, A> {
+  return Effect.uninterruptibleMask((restore) =>
+    Effect.flatMap(Effect.forkIn(restore(ctx.initial), ctx.scope), (fiber) => {
+      MutableRef.set(ctx.initializingFiberRef, Option.some(fiber))
+
+      return Effect.tap(Fiber.join(fiber), (a) =>
+        Effect.sync(() => {
+          MutableRef.increment(ctx.version)
+          MutableRef.set(ctx.currentRef, Option.some(a))
+          MutableRef.set(ctx.initializingFiberRef, Option.none())
+        }),
+      )
+    }),
   )
+}
 
-  readonly end = methodWithTrace(
-    (trace) => () =>
-      Effect.suspend(() =>
-        Effect.zipPar(this.interruptFibers(), this.interruptInitializeFiber()),
-      ).traced(trace),
-  )
+function makeRefMethods<E, A>(
+  primitive: RefPrimitive<E, A>,
+): Pick<RefSubject<E, A>, 'modify' | 'updateEffect' | 'update'> {
+  const modify = makeModify<E, A>(primitive.modifyEffect)
+  const updateEffect = makeUpdateEffect<E, A>(primitive.modifyEffect)
+  const update = makeUpdate<E, A>(updateEffect)
+
+  return {
+    modify,
+    updateEffect,
+    update,
+  } as const
+}
 
-  protected interruptFibers() {
-    return this.fiber ? Fiber.interrupt(this.fiber) : Effect.unit()
-  }
+function makeModifyEffectFromContext<E, A>(
+  get: RefSubject<E, A>['get'],
+  ctx: RefSubjectContext<E, A>,
+): RefSubject<E, A>['modifyEffect'] {
+  return (f) =>
+    Effect.flatMap(get, (a1) =>
+      ctx.lock(
+        Effect.flatMap(f(a1), ([b, a2]) =>
+          Effect.suspend(() => {
+            MutableRef.set(ctx.currentRef, Option.some(a2))
 
-  protected interruptInitializeFiber() {
-    const fiber = MutableRef.get(this.initializeFiber)
-    if (Option.isSome(fiber)) {
-      return Fiber.interrupt(fiber.value)
-    }
+            if (ctx.eq(a1, a2)) {
+              return Effect.succeed(b)
+            }
 
-    return Effect.unit()
-  }
+            MutableRef.increment(ctx.version)
 
-  readonly get: RefSubject<E, A>['get'] = Effect.suspend(() =>
-    pipe(
-      MutableRef.get(this.current),
-      Option.match(
-        () =>
-          pipe(
-            MutableRef.get(this.initializeFiber),
-            Option.match(
-              () =>
-                this.lock(
-                  Effect.uninterruptibleMask((restore) =>
-                    pipe(
-                      Effect.forkDaemon(restore(this.i0)),
-                      Effect.tap((fiber) =>
-                        Effect.sync(() => MutableRef.set(this.initializeFiber, Option.some(fiber))),
-                      ),
-                      Effect.flatMap(Fiber.join),
-                      Effect.tap((a) =>
-                        Effect.suspend(() => {
-                          MutableRef.set(this.current, Option.some(a))
-                          MutableRef.set(this.initializeFiber, Option.none())
-
-                          return super.event(a)
-                        }),
-                      ),
-                    ),
-                  ),
-                ),
-              Fiber.join,
-            ),
-          ),
-        Effect.succeed,
+            return Effect.as(ctx.hold.event(a2), b)
+          }),
+        ),
       ),
-    ),
-  )
-
-  modifyEffect<R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, readonly [B, A]>) {
-    return methodWithTrace(
-      (trace) =>
-        <R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, readonly [B, A]>) =>
-          Effect.flatMap(this.get, (a1) =>
-            this.lock(
-              Effect.flatMap(f(a1), ([b, a2]) =>
-                Effect.suspend(() => {
-                  MutableRef.set(this.current, Option.some(a2))
-
-                  if (this.i1(a1, a2)) {
-                    return Effect.succeed(b)
-                  }
-
-                  return Effect.as(super.event(a2), b)
-                }),
-              ),
-            ),
-          ).traced(trace),
-    )(f)
-  }
+    )
+}
 
-  readonly modify: RefSubject<E, A>['modify'] = (f) =>
-    this.modifyEffect((a) => Effect.sync(() => f(a)))
+function makeModify<E, A>(
+  modifyEffect: RefSubject<E, A>['modifyEffect'],
+): RefSubject<E, A>['modify'] {
+  return (f) => modifyEffect((a) => Effect.sync(() => f(a)))
+}
 
-  readonly updateEffect: RefSubject<E, A>['updateEffect'] = (f) =>
-    this.modifyEffect((a) => Effect.map(f(a), (a) => [a, a]))
+function makeUpdateEffect<E, A>(
+  modifyEffect: RefSubject<E, A>['modifyEffect'],
+): RefSubject<E, A>['updateEffect'] {
+  return (f) => modifyEffect((a) => Effect.map(f(a), (a) => [a, a]))
+}
 
-  readonly update: RefSubject<E, A>['update'] = (f) =>
-    this.updateEffect((a) => Effect.sync(() => f(a)))
+function makeUpdate<E, A>(
+  updateEffect: RefSubject<E, A>['updateEffect'],
+): RefSubject<E, A>['update'] {
+  return (f) => updateEffect((a) => Effect.sync(() => f(a)))
+}
 
-  readonly set: RefSubject<E, A>['set'] = (a) => this.update(() => a)
+function makeSetFromContext<E, A>(ctx: RefSubjectContext<E, A>): RefSubject<E, A>['set'] {
+  return (a: A) =>
+    Effect.suspend(() => {
+      const fiber = MutableRef.get(ctx.initializingFiberRef)
+
+      return pipe(
+        fiber,
+        Option.match({ onNone: () => Effect.unit, onSome: Fiber.await }),
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        Effect.flatMap((_: unknown) => {
+          const current = MutableRef.get(ctx.currentRef)
+
+          MutableRef.set(ctx.currentRef, Option.some(a))
+
+          // Only emit if the value has changed
+          if (Option.isNone(current) || (Option.isSome(current) && !ctx.eq(current.value, a))) {
+            // Increment the version
+            MutableRef.increment(ctx.version)
+            return Effect.as(ctx.hold.event(a), a)
+          }
+
+          return Effect.succeed(a)
+        }),
+      )
+    })
+}
 
-  readonly delete: RefSubject<E, A>['delete'] = Effect.suspend(() => {
-    const current = MutableRef.get(this.current)
+function makeDeleteFromContext<E, A>(ctx: RefSubjectContext<E, A>): RefSubject<E, A>['delete'] {
+  return Effect.sync(() => {
+    const current = MutableRef.get(ctx.currentRef)
 
     if (Option.isSome(current)) {
-      MutableRef.set(this.current, Option.none())
+      MutableRef.set(ctx.version, 0)
+      MutableRef.set(ctx.currentRef, Option.none())
     }
 
-    return Effect.succeed<Option.Option<A>>(current)
+    return current
   })
+}
 
-  readonly mapEffect: RefSubject<E, A>['mapEffect'] = <R2, E2, B>(
-    f: (a: A) => Effect.Effect<R2, E2, B>,
-  ) => new ComputedImpl<never, E, A, R2, E2, B>(this, f)
-
-  readonly map: RefSubject<E, A>['map'] = (f) => this.mapEffect((a) => Effect.sync(() => f(a)));
+function makeEndFromContext<E, A>(ctx: RefSubjectContext<E, A>): RefSubject<E, A>['end'] {
+  return () =>
+    Effect.suspend(() => {
+      MutableRef.set(ctx.version, 0)
 
-  [Equal.symbol](that: unknown) {
-    return this === that
-  }
+      const fibers = [
+        ctx.hold.fiber || Fiber.unit,
+        Option.getOrElse(MutableRef.get(ctx.initializingFiberRef), () => Fiber.unit),
+      ]
 
-  [Hash.symbol]() {
-    return Hash.random(this)
-  }
+      return Fiber.interruptAll(fibers)
+    })
+}
 
-  traced(trace: Trace): Effect.Effect<never, E, A> {
-    if (trace) {
-      const traced = new RefSubjectImpl(this.i0, this.i1)
-      traced.trace = trace
-      return traced
-    }
+function makeFiltered<E, A>(
+  f: () => RefSubject<E, A>,
+): Pick<
+  RefSubject<E, A>,
+  'filterMapEffect' | 'filterMap' | 'filterEffect' | 'filter' | 'filterNotEffect' | 'filterNot'
+> {
+  const get = makeMemoizedGet(f)
 
-    return this
+  function filterMapEffect<R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, Option.Option<B>>) {
+    return new FilteredImpl(get(), f)
   }
 
-  commit(): Effect.Effect<never, E, A> {
-    return this.get.traced(this.trace)
+  function filterMap<B>(f: (a: A) => Option.Option<B>) {
+    return filterMapEffect((a) => Effect.sync(() => f(a)))
   }
-}
 
-class TupleRefSubjectImpl<S extends ReadonlyArray<RefSubject.Any>>
-  extends HoldFx<
-    never,
-    Fx.ErrorsOf<S[number]>,
-    {
-      readonly [K in keyof S]: Fx.OutputOf<S[K]>
-    }
-  >
-  implements
-    RefSubject<
-      Fx.ErrorsOf<S[number]>,
-      {
-        readonly [K in keyof S]: Fx.OutputOf<S[K]>
-      }
-    >
-{
-  readonly _tag = 'Commit'
-  public trace: Trace = undefined;
-
-  readonly [Effect.EffectTypeId] = refSubjectVariant;
-  readonly [RefSubjectTypeId]: RefSubjectTypeId = RefSubjectTypeId
-
-  readonly i1: Equivalence.Equivalence<{ readonly [K in keyof S]: Fx.OutputOf<S[K]> }>
-  public i2: any = undefined
-
-  readonly lock = Effect.unsafeMakeSemaphore(1).withPermits(1)
-
-  readonly eq: Equivalence.Equivalence<{ readonly [K in keyof S]: Fx.OutputOf<S[K]> }>
-
-  constructor(readonly i0: S) {
-    super(combineAll(...i0) as any)
-
-    this.i1 = this.eq = Equivalence.tuple(...i0.map((s) => s.eq)) as Equivalence.Equivalence<{
-      readonly [K in keyof S]: Fx.OutputOf<S[K]>
-    }>
+  function filterEffect<R2, E2>(f: (a: A) => Effect.Effect<R2, E2, boolean>) {
+    return filterMapEffect((a) => Effect.map(f(a), (b) => (b ? Option.some(a) : Option.none())))
   }
 
-  end() {
-    return Effect.allPar(this.i0.map((s) => s.end()))
+  function filter(f: (a: A) => boolean) {
+    return filterEffect((a) => Effect.sync(() => f(a)))
   }
 
-  readonly get: RefSubject<
-    Fx.ErrorsOf<S[number]>,
-    {
-      readonly [K in keyof S]: Fx.OutputOf<S[K]>
-    }
-  >['get'] = Effect.suspend(
-    () =>
-      Effect.allPar(this.i0.map((s) => s.get)) as Effect.Effect<
-        never,
-        Fx.ErrorsOf<S[number]>,
-        {
-          readonly [K in keyof S]: Fx.OutputOf<S[K]>
-        }
-      >,
-  )
-
-  modifyEffect<R2, E2, B>(
-    f: (a: {
-      readonly [K in keyof S]: Fx.OutputOf<S[K]>
-    }) => Effect.Effect<R2, E2, readonly [B, { readonly [K in keyof S]: Fx.OutputOf<S[K]> }]>,
-  ) {
-    const { current, i0 } = this
+  function filterNotEffect<R2, E2>(f: (a: A) => Effect.Effect<R2, E2, boolean>) {
+    return filterEffect((a) => Effect.map(f(a), (b) => !b))
+  }
 
-    return pipe(
-      this.get,
-      Effect.flatMap((a) =>
-        this.lock(
-          Effect.gen(function* ($) {
-            const [b, a2] = yield* $(f(a))
+  function filterNot(f: (a: A) => boolean) {
+    return filterNotEffect((a) => Effect.sync(() => f(a)))
+  }
 
-            MutableRef.set(current, Option.some(a2))
+  return {
+    filterMapEffect,
+    filterMap,
+    filterEffect,
+    filter,
+    filterNotEffect,
+    filterNot,
+  } as const
+}
 
-            yield* $(Effect.allPar(i0.map((s, i) => s.set(a2[i]))))
+function makeComputedMethods<E, A>(
+  f: () => RefSubject<E, A>,
+): Pick<RefSubject<E, A>, 'mapEffect' | 'map'> {
+  const get = makeMemoizedGet(f)
 
-            return b
-          }),
-        ),
-      ),
-    )
+  function mapEffect<R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>): Computed<R2, E | E2, B> {
+    return new ComputedImpl(get(), f)
   }
 
-  readonly modify: RefSubject<
-    Fx.ErrorsOf<S[number]>,
-    {
-      readonly [K in keyof S]: Fx.OutputOf<S[K]>
-    }
-  >['modify'] = (f) => this.modifyEffect((a) => Effect.sync(() => f(a)))
-
-  readonly updateEffect: RefSubject<
-    Fx.ErrorsOf<S[number]>,
-    {
-      readonly [K in keyof S]: Fx.OutputOf<S[K]>
-    }
-  >['updateEffect'] = (f) => this.modifyEffect((a) => Effect.map(f(a), (a) => [a, a]))
-
-  readonly update: RefSubject<
-    Fx.ErrorsOf<S[number]>,
-    {
-      readonly [K in keyof S]: Fx.OutputOf<S[K]>
-    }
-  >['update'] = (f) => this.updateEffect((a) => Effect.sync(() => f(a)))
+  function map<B>(f: (a: A) => B): Computed<never, E, B> {
+    return mapEffect((a) => Effect.sync(() => f(a)))
+  }
 
-  readonly set: RefSubject<
-    Fx.ErrorsOf<S[number]>,
-    {
-      readonly [K in keyof S]: Fx.OutputOf<S[K]>
-    }
-  >['set'] = (a) => this.update(() => a)
+  return {
+    mapEffect,
+    map,
+  } as const
+}
 
-  readonly delete: RefSubject<
-    Fx.ErrorsOf<S[number]>,
-    {
-      readonly [K in keyof S]: Fx.OutputOf<S[K]>
-    }
-  >['delete'] = Effect.suspend(() => {
-    const current = MutableRef.get(this.current)
+function makeTransformMethods<E, A>(
+  f: () => RefSubject<E, A>,
+): Pick<RefSubject<E, A>, 'transformBoth' | 'transform' | 'transformGet'> {
+  const get = makeMemoizedGet(f)
 
-    if (Option.isSome(current)) {
-      MutableRef.set(this.current, Option.none())
-    }
+  function transformBoth<R3, E3, C, R4, E4, D>(
+    f: (fx: Fx<never, E, A>) => Fx<R3, E3, C>,
+    g: (effect: Effect.Effect<never, E, A>) => Effect.Effect<R4, E4, D>,
+  ): RefTransform<R3, E3, C, R4, E4, D> {
+    return new RefTransformImpl(get(), f, g)
+  }
 
-    return Effect.succeed<
-      Option.Option<{
-        readonly [K in keyof S]: Fx.OutputOf<S[K]>
-      }>
-    >(current)
-  })
+  function transform<R3, E3, C>(
+    f: (fx: Fx<never, E, A>) => Fx<R3, E3, C>,
+  ): RefTransform<R3, E3, C, never, E, A> {
+    return transformBoth(f, identity)
+  }
 
-  readonly mapEffect: RefSubject<
-    Fx.ErrorsOf<S[number]>,
-    {
-      readonly [K in keyof S]: Fx.OutputOf<S[K]>
-    }
-  >['mapEffect'] = <R2, E2, B>(
-    f: (a: {
-      readonly [K in keyof S]: Fx.OutputOf<S[K]>
-    }) => Effect.Effect<R2, E2, B>,
-  ) =>
-    new ComputedImpl<
-      never,
-      Fx.ErrorsOf<S[number]>,
-      {
-        readonly [K in keyof S]: Fx.OutputOf<S[K]>
-      },
-      R2,
-      E2,
-      B
-    >(this, f)
+  function transformGet<R3, E3, C>(
+    f: (effect: Effect.Effect<never, E, A>) => Effect.Effect<R3, E3, C>,
+  ): RefTransform<never, E, A, R3, E3, C> {
+    return transformBoth(identity, f)
+  }
 
-  readonly map: RefSubject<
-    Fx.ErrorsOf<S[number]>,
-    {
-      readonly [K in keyof S]: Fx.OutputOf<S[K]>
-    }
-  >['map'] = (f) => this.mapEffect((a) => Effect.sync(() => f(a)));
+  return {
+    transformBoth,
+    transform,
+    transformGet,
+  } as const
+}
 
+const placeholders = {
+  _tag: 'Commit',
+  [Effect.EffectTypeId]: refVariance,
+  i0: undefined,
+  i1: undefined,
+  i2: undefined,
   [Equal.symbol](that: unknown) {
     return this === that
-  }
-
+  },
   [Hash.symbol]() {
     return Hash.random(this)
-  }
+  },
+  pipe() {
+    // eslint-disable-next-line prefer-rest-params
+    return pipeArguments(this, arguments)
+  },
+}
 
-  traced(trace: Trace): Effect.Effect<
-    never,
-    Fx.ErrorsOf<S[number]>,
+function makeEffectMethods<E, A>(
+  get: RefSubject<E, A>['get'],
+): Pick<RefSubject<E, A>, Extract<keyof Effect.Effect<never, E, A>, keyof RefSubject<E, A>>> {
+  return Object.assign(
     {
-      readonly [K in keyof S]: Fx.OutputOf<S[K]>
-    }
-  > {
-    if (trace) {
-      const traced = new TupleRefSubjectImpl(this.i0)
-      traced.trace = trace
-      return traced
-    }
+      commit() {
+        return get
+      },
+    } as const,
+    placeholders,
+  ) as any
+}
 
-    return this
-  }
+function makeMemoizedGet<A>(f: () => A) {
+  let memoized: Option.Option<A> = Option.none()
 
-  commit(): Effect.Effect<
-    never,
-    Fx.ErrorsOf<S[number]>,
-    {
-      readonly [K in keyof S]: Fx.OutputOf<S[K]>
+  return () => {
+    if (Option.isNone(memoized)) {
+      memoized = Option.some(f())
     }
-  > {
-    return this.get.traced(this.trace)
+
+    return (memoized as Option.Some<A>).value
   }
 }
 
-class StructRefSubjectImpl<S extends RR.ReadonlyRecord<RefSubject.Any>>
-  extends HoldFx<
-    never,
-    Fx.ErrorsOf<S[number]>,
-    {
-      readonly [K in keyof S]: Fx.OutputOf<S[K]>
-    }
-  >
-  implements
-    RefSubject<
-      Fx.ErrorsOf<S[number]>,
-      {
-        readonly [K in keyof S]: Fx.OutputOf<S[K]>
-      }
-    >
-{
-  readonly _tag = 'Commit'
-  public trace: Trace = undefined;
-
-  readonly [Effect.EffectTypeId] = refSubjectVariant;
-  readonly [RefSubjectTypeId]: RefSubjectTypeId = RefSubjectTypeId
+type RefSubjectContext<E, A> = {
+  initial: Effect.Effect<never, E, A>
+  currentRef: MutableRef.MutableRef<Option.Option<A>>
+  initializingFiberRef: MutableRef.MutableRef<Option.Option<Fiber.RuntimeFiber<E, A>>>
+  lock: Lock
+  scope: Scope.Scope
+  eq: Equivalence.Equivalence<A>
+  hold: HoldFx<never, E, A>
+  version: MutableRef.MutableRef<number>
+}
 
-  readonly i1: Equivalence.Equivalence<{ readonly [K in keyof S]: Fx.OutputOf<S[K]> }>
-  public i2: any = undefined
+function makeRefSubjectContext<E, A>(
+  initial: Effect.Effect<never, E, A>,
+  scope: Scope.Scope,
+  eq: Equivalence.Equivalence<A>,
+) {
+  const hold = new HoldFx(never<E, A>())
+  const ctx: RefSubjectContext<E, A> = {
+    initial,
+    currentRef: hold.current,
+    initializingFiberRef: MutableRef.make(Option.none()),
+    lock: Effect.unsafeMakeSemaphore(1).withPermits(1),
+    scope,
+    eq,
+    hold,
+    version: MutableRef.make(0),
+  }
+
+  return ctx
+}
 
-  readonly lock = Effect.unsafeMakeSemaphore(1).withPermits(1)
+function unsafeMakeRefPrimitive<E, A>(
+  initial: Effect.Effect<never, E, A>,
+  scope: Scope.Scope,
+  eq: Equivalence.Equivalence<A>,
+): RefPrimitive<E, A> {
+  const ctx = makeRefSubjectContext(initial, scope, eq)
+  const get = makeGetFromContext(ctx)
+  const set = makeSetFromContext(ctx)
 
-  readonly eq: Equivalence.Equivalence<{ readonly [K in keyof S]: Fx.OutputOf<S[K]> }>
+  function run<R2>(sink: Sink<R2, E, A>) {
+    return Effect.suspend(() => {
+      const current = MutableRef.get(ctx.hold.current)
 
-  constructor(readonly i0: S) {
-    super(
-      map(
-        combineAll(...Object.entries(i0).map(([k, s]) => map(s, (x) => [k, x]))),
-        Object.fromEntries,
-      ) as any,
-    )
+      if (Option.isNone(current)) {
+        return pipe(
+          primitive.get,
+          Effect.catchAllCause(sink.error),
+          Effect.flatMap(() => ctx.hold.run(sink)),
+        )
+      }
 
-    this.i1 = this.eq = Equivalence.struct(RR.map(i0, (s) => s.eq)) as Equivalence.Equivalence<{
-      readonly [K in keyof S]: Fx.OutputOf<S[K]>
-    }>
+      return ctx.hold.run(sink)
+    })
   }
 
-  end() {
-    return Effect.allPar(RR.map(this.i0, (s) => s.end()))
+  const primitive: RefPrimitive<E, A> = {
+    delete: makeDeleteFromContext(ctx),
+    end: makeEndFromContext(ctx),
+    eq,
+    error: (cause) => ctx.hold.error(cause),
+    event: set,
+    get,
+    modifyEffect: makeModifyEffectFromContext(get, ctx),
+    run,
+    set,
+    version: ctx.version,
   }
 
-  readonly get: RefSubject<
-    Fx.ErrorsOf<S[number]>,
-    {
-      readonly [K in keyof S]: Fx.OutputOf<S[K]>
-    }
-  >['get'] = Effect.suspend(
-    () =>
-      Effect.allPar(RR.map(this.i0, (s) => s.get)) as Effect.Effect<
-        never,
-        Fx.ErrorsOf<S[number]>,
-        {
-          readonly [K in keyof S]: Fx.OutputOf<S[K]>
-        }
-      >,
-  )
-
-  modifyEffect<R2, E2, B>(
-    f: (a: {
-      readonly [K in keyof S]: Fx.OutputOf<S[K]>
-    }) => Effect.Effect<R2, E2, readonly [B, { readonly [K in keyof S]: Fx.OutputOf<S[K]> }]>,
-  ) {
-    const { current, i0: subjects } = this
-
-    return pipe(
-      this.get,
-      Effect.flatMap((a) =>
-        this.lock(
-          Effect.gen(function* ($) {
-            const [b, a2] = yield* $(f(a))
+  return primitive
+}
 
-            MutableRef.set(current, Option.some(a2))
+function makeRefFromPrimitive<E, A>(primitive: RefPrimitive<E, A>): RefSubject<E, A> {
+  const ref: RefSubject<E, A> = {
+    [FxTypeId]: refVariance,
+    [RefSubjectTypeId]: RefSubjectTypeId,
+    [ComputedTypeId]: ComputedTypeId,
+    ...primitive,
+    ...makeRefMethods(primitive),
+    ...makeEffectMethods(primitive.get),
+    ...makeFiltered(() => ref),
+    ...makeComputedMethods(() => ref),
+    ...makeTransformMethods(() => ref),
+    version() {
+      return MutableRef.get(primitive.version)
+    },
+  }
+
+  return ref
+}
 
-            yield* $(Effect.allPar(RR.map(subjects, (s, i) => s.set(a2[i]))))
+// Base Ref which provides all functionality that can otherwise be derived
+// using makeRefFromPrimitive
+interface RefPrimitive<E, A> {
+  // Fx
+  run: RefSubject<E, A>['run']
+
+  // Subject
+  event: RefSubject<E, A>['event']
+  error: RefSubject<E, A>['error']
+  end: RefSubject<E, A>['end']
+
+  // Ref
+  eq: RefSubject<E, A>['eq']
+  get: RefSubject<E, A>['get']
+  modifyEffect: RefSubject<E, A>['modifyEffect']
+  set: RefSubject<E, A>['set']
+  delete: RefSubject<E, A>['delete']
+
+  // Primitive
+  version: MutableRef.MutableRef<number>
+}
 
-            return b
-          }),
-        ),
+// Internals for RefSubject.tuple
+
+function tupleRefPrimitive<const Refs extends ReadonlyArray<RefSubject.Any>>(
+  refs: Refs,
+): RefPrimitive<Fx.ErrorsOf<Refs[number]>, { readonly [K in keyof Refs]: Fx.OutputOf<Refs[K]> }> {
+  type _E = Fx.ErrorsOf<Refs[number]>
+  type _A = { readonly [K in keyof Refs]: Fx.OutputOf<Refs[K]> }
+
+  const hold = new HoldFx(combineAll(...refs) as any as Fx<never, _E, _A>)
+  const eq = Equivalence.tuple(...refs.map((ref) => ref.eq))
+  const get = Effect.all(
+    refs.map((ref) => ref.get),
+    unboundedConcurrency,
+  ) as Effect.Effect<never, _E, _A>
+
+  const primitive: RefPrimitive<_E, _A> = {
+    delete: Effect.map(
+      Effect.all(
+        refs.map((ref) => ref.delete),
+        { concurrency: 'unbounded' },
       ),
-    )
-  }
-
-  readonly modify: RefSubject<
-    Fx.ErrorsOf<S[number]>,
-    {
-      readonly [K in keyof S]: Fx.OutputOf<S[K]>
-    }
-  >['modify'] = (f) => this.modifyEffect((a) => Effect.sync(() => f(a)))
-
-  readonly updateEffect: RefSubject<
-    Fx.ErrorsOf<S[number]>,
-    {
-      readonly [K in keyof S]: Fx.OutputOf<S[K]>
-    }
-  >['updateEffect'] = (f) => this.modifyEffect((a) => Effect.map(f(a), (a) => [a, a]))
-
-  readonly update: RefSubject<
-    Fx.ErrorsOf<S[number]>,
-    {
-      readonly [K in keyof S]: Fx.OutputOf<S[K]>
-    }
-  >['update'] = (f) => this.updateEffect((a) => Effect.sync(() => f(a)))
-
-  readonly set: RefSubject<
-    Fx.ErrorsOf<S[number]>,
-    {
-      readonly [K in keyof S]: Fx.OutputOf<S[K]>
-    }
-  >['set'] = (a) => this.update(() => a)
-
-  readonly delete: RefSubject<
-    Fx.ErrorsOf<S[number]>,
-    {
-      readonly [K in keyof S]: Fx.OutputOf<S[K]>
-    }
-  >['delete'] = Effect.suspend(() => {
-    const current = MutableRef.get(this.current)
-
-    if (Option.isSome(current)) {
-      MutableRef.set(this.current, Option.none())
-    }
-
-    return Effect.succeed<
-      Option.Option<{
-        readonly [K in keyof S]: Fx.OutputOf<S[K]>
-      }>
-    >(current)
-  })
-
-  readonly mapEffect: RefSubject<
-    Fx.ErrorsOf<S[number]>,
-    {
-      readonly [K in keyof S]: Fx.OutputOf<S[K]>
-    }
-  >['mapEffect'] = <R2, E2, B>(
-    f: (a: {
-      readonly [K in keyof S]: Fx.OutputOf<S[K]>
-    }) => Effect.Effect<R2, E2, B>,
-  ) =>
-    new ComputedImpl<
-      never,
-      Fx.ErrorsOf<S[number]>,
-      {
-        readonly [K in keyof S]: Fx.OutputOf<S[K]>
-      },
-      R2,
-      E2,
-      B
-    >(this, f)
-
-  readonly map: RefSubject<
-    Fx.ErrorsOf<S[number]>,
-    {
-      readonly [K in keyof S]: Fx.OutputOf<S[K]>
-    }
-  >['map'] = (f) => this.mapEffect((a) => Effect.sync(() => f(a)));
-
-  [Equal.symbol](that: unknown) {
-    return this === that
-  }
-
-  [Hash.symbol]() {
-    return Hash.random(this)
-  }
+      (values) => Option.all(values),
+    ) as Effect.Effect<never, _E, Option.Option<_A>>,
+    end: () =>
+      Effect.all(
+        refs.map((ref) => ref.end()),
+        unboundedConcurrency,
+      ),
+    eq,
+    error: (error) => hold.error(error),
+    event: (value) =>
+      Effect.all(
+        value.map((v, i) => refs[i].event(v)),
+        unboundedConcurrency,
+      ),
+    get,
+    modifyEffect: makeModifyEffectTuple(refs, get, eq),
+    run: (sink) => hold.run(sink),
+    set: (value) =>
+      Effect.all(
+        value.map((v, i) => refs[i].set(v)),
+        unboundedConcurrency,
+      ) as Effect.Effect<never, never, _A>,
+    version: MutableRef.make(0),
+  }
+
+  return primitive
+}
 
-  traced(trace: Trace): Effect.Effect<
-    never,
-    Fx.ErrorsOf<S[number]>,
-    {
-      readonly [K in keyof S]: Fx.OutputOf<S[K]>
-    }
-  > {
-    if (trace) {
-      const traced = new StructRefSubjectImpl(this.i0)
-      traced.trace = trace
-      return traced
-    }
+function makeModifyEffectTuple<
+  const Refs extends ReadonlyArray<RefSubject.Any>,
+  E,
+  A extends readonly any[],
+>(
+  refs: Refs,
+  get: Effect.Effect<never, E, A>,
+  eq: Equivalence.Equivalence<A>,
+): RefSubject<E, A>['modifyEffect'] {
+  return <R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, readonly [B, A]>) => {
+    return Effect.gen(function* ($) {
+      const current = yield* $(get)
+      const [b, a] = yield* $(f(current))
+
+      if (eq(a, current)) {
+        return b
+      }
 
-    return this
-  }
+      yield* $(
+        Effect.all(
+          refs.map((ref, i) => ref.set(a[i])),
+          unboundedConcurrency,
+        ),
+      )
 
-  commit(): Effect.Effect<
-    never,
-    Fx.ErrorsOf<S[number]>,
-    {
-      readonly [K in keyof S]: Fx.OutputOf<S[K]>
-    }
-  > {
-    return this.get.traced(this.trace)
+      return b
+    })
   }
 }
 
-class ComputedImpl<R, E, A, R2, E2, B> implements Computed<R | R2, E | E2, B> {
-  readonly [FxTypeId] = {
-    _R: identity,
-    _E: identity,
-    _A: identity,
-  }
-
-  readonly _tag = 'Commit'
-  public trace: Trace = undefined;
+function structRefPrimitive<const Refs extends Readonly<Record<string, RefSubject.Any>>>(
+  refs: Refs,
+): RefPrimitive<Fx.ErrorsOf<Refs[string]>, { readonly [K in keyof Refs]: Fx.OutputOf<Refs[K]> }> {
+  type _E = Fx.ErrorsOf<Refs[string]>
+  type _A = { readonly [K in keyof Refs]: Fx.OutputOf<Refs[K]> }
+
+  const hold = new HoldFx(struct(refs)) as HoldFx<never, _E, _A>
+  const eq = Equivalence.struct(mapRecord(refs, (ref) => ref.eq))
+  const get = Effect.all(
+    mapRecord(refs, (ref) => ref.get),
+    unboundedConcurrency,
+  ) as Effect.Effect<never, _E, _A>
+
+  const primitive: RefPrimitive<_E, _A> = {
+    delete: Effect.map(
+      Effect.all(
+        mapRecord(refs, (ref) => ref.delete),
+        unboundedConcurrency,
+      ),
+      (values) => Option.all(values),
+    ) as Effect.Effect<never, _E, Option.Option<_A>>,
+    end: () =>
+      Effect.all(
+        mapRecord(refs, (ref) => ref.end()),
+        unboundedConcurrency,
+      ),
+    eq,
+    error: (error) => hold.error(error),
+    event: (value) =>
+      Effect.all(
+        mapRecord(value, (v, i) => refs[i].event(v)),
+        unboundedConcurrency,
+      ),
+    get,
+    modifyEffect: makeModifyEffectStruct(refs, get, eq),
+    run: (sink) => hold.run(sink),
+    set: (value) =>
+      Effect.all(
+        mapRecord(value, (v, i) => refs[i].set(v)),
+        unboundedConcurrency,
+      ) as Effect.Effect<never, never, _A>,
+    version: MutableRef.make(0),
+  }
+
+  return primitive
+}
 
-  readonly [Effect.EffectTypeId] = refSubjectVariant;
-  readonly [RefSubjectTypeId]: RefSubjectTypeId = RefSubjectTypeId
+function makeModifyEffectStruct<
+  const Refs extends Readonly<Record<string, RefSubject.Any>>,
+  E,
+  A extends Readonly<Record<string, any>>,
+>(
+  refs: Refs,
+  get: Effect.Effect<never, E, A>,
+  eq: Equivalence.Equivalence<A>,
+): RefSubject<E, A>['modifyEffect'] {
+  return <R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, readonly [B, A]>) => {
+    return Effect.gen(function* ($) {
+      const current = yield* $(get)
+      const [b, a] = yield* $(f(current))
+
+      if (eq(a, current)) {
+        return b
+      }
 
-  readonly i2: Fx<R | R2, E | E2, B>
+      yield* $(
+        Effect.all(
+          mapRecord(refs, (ref, i) => ref.set(a[i])),
+          unboundedConcurrency,
+        ),
+      )
 
-  constructor(readonly i0: Computed<R, E, A>, readonly i1: (a: A) => Effect.Effect<R2, E2, B>) {
-    // Create a stable reference to derived Fx
-    this.i2 = multicast(switchMapEffect(this.i0, this.i1))
+      return b
+    })
   }
+}
 
-  run<R3>(sink: Sink<R3, E | E2, B>) {
-    return this.i2.run(sink)
-  }
+function mapRecord<K extends string, A, B>(
+  record: Readonly<Record<K, A>>,
+  f: (a: A, k: K) => B,
+): { readonly [_ in K]: B } {
+  const result: Record<K, B> = {} as any
 
-  addTrace(trace: Trace): Fx<R | R2, E | E2, B> {
-    return Traced<R | R2, E | E2, B>(this, trace)
+  for (const k in record) {
+    result[k] = f(record[k], k)
   }
 
-  readonly get = Effect.flatMap(this.i0.get, this.i1)
-
-  readonly mapEffect: Computed<R | R2, E | E2, B>['mapEffect'] = <R3, E3, C>(
-    f: (b: B) => Effect.Effect<R3, E3, C>,
-  ): Computed<R | R2 | R3, E | E2 | E3, C> =>
-    new ComputedImpl(this.i0, (a) => Effect.flatMap(this.i1(a), f))
-
-  readonly map: Computed<R | R2, E | E2, B>['map'] = <C>(f: (b: B) => C) =>
-    this.mapEffect((a) => Effect.sync(() => f(a)));
+  return result
+}
 
-  [Equal.symbol](that: unknown) {
-    return this === that
-  }
+export function asRef<R, E, A>(fx: Fx<R, E, A>) {
+  return Effect.flatMap(Deferred.make<E, A>(), (deferred) =>
+    Effect.flatMap(makeRef(Deferred.await(deferred)), (ref) => {
+      const onValue = (value: A) =>
+        Effect.flatMap(Deferred.succeed(deferred, value), (closed) =>
+          closed ? Effect.unit : ref.set(value),
+        )
 
-  [Hash.symbol]() {
-    return Hash.random(this)
-  }
+      return Effect.as(
+        Effect.forkScoped(
+          Effect.catchAllCause(drain(switchMatchCauseEffect(fx, ref.error, onValue)), ref.error),
+        ),
+        ref,
+      )
+    }),
+  )
 
-  traced(trace: Trace): Effect.Effect<R | R2, E | E2, B> {
-    if (trace) {
-      const traced = new ComputedImpl(this.i0, this.i1)
-      traced.trace = trace
-      return traced
-    }
+  return Effect.gen(function* ($) {
+    const deferred = yield* $(Deferred.make<E, A>())
+    const ref = yield* $(makeRef(Deferred.await(deferred)))
 
-    return this
-  }
+    const onValue = (value: A) =>
+      Effect.flatMap(Deferred.succeed(deferred, value), (closed) =>
+        closed ? Effect.unit : ref.set(value),
+      )
 
-  commit(): Effect.Effect<R | R2, E | E2, B> {
-    return this.get.traced(this.trace)
-  }
-}
+    yield* $(
+      switchMatchCauseEffect(fx, ref.error, onValue),
+      drain,
+      Effect.catchAllCause(ref.error),
+      Effect.forkScoped,
+    )
 
-export function isRefSubject<E, A>(u: unknown): u is RefSubject<E, A> {
-  return isFx<never, E, A>(u) && RefSubjectTypeId in u && u[RefSubjectTypeId] === RefSubjectTypeId
+    return ref
+  })
 }