@typed/fx 1.5.1 → 1.5.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typed/fx",
-  "version": "1.5.1",
+  "version": "1.5.2",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -22,7 +22,7 @@
     "@effect/data": "^0.10.3",
     "@effect/io": "^0.17.0"
   },
-  "gitHead": "eb7de6339939cb3cad08520f2b1d179d333d10ca",
+  "gitHead": "4ba4f251d38dec8c5bee4d6f81f33b735338a7be",
   "publishConfig": {
     "access": "public"
   },

package/project.json

@@ -20,7 +20,12 @@
       }
     },
     "test": {
-      "executor": "@nrwl/vite:test"
+      "executor": "@nrwl/vite:test",
+      "configurations": {
+        "watch": {
+          "watch": true
+        }
+      }
     },
     "build:cjs": {
       "executor": "nx:run-commands",

package/src/_internal/Mutable.ts

@@ -0,0 +1,14 @@
+export interface Mutable<A> {
+  readonly get: () => A
+  readonly set: (a: A) => A
+}
+
+export function Mutable<A>(initial: A) {
+  let value = initial
+  return {
+    get: () => value,
+    set: (a: A) => {
+      return (value = a)
+    },
+  }
+}

package/src/_internal/disableCooperativeYielding.ts

@@ -0,0 +1,7 @@
+import { Effect, withRuntimeFlags } from '@effect/io/Effect'
+import { CooperativeYielding } from '@effect/io/Fiber/Runtime/Flags'
+import { disable } from '@effect/io/Fiber/Runtime/Flags/Patch'
+
+export function disableCooperativeYielding<R, E, A>(effect: Effect<R, E, A>): Effect<R, E, A> {
+  return withRuntimeFlags(effect, disable(CooperativeYielding))
+}

package/src/operator/hold.ts

@@ -1,5 +1,4 @@
 import { pipe } from '@effect/data/Function'
-import * as MutableRef from '@effect/data/MutableRef'
 import * as Option from '@effect/data/Option'
 import type * as Cause from '@effect/io/Cause'
 import * as Effect from '@effect/io/Effect'
@@ -7,15 +6,15 @@ import * as Fiber from '@effect/io/Fiber'
 import type { Scope } from '@effect/io/Scope'
 
 import type { Fx } from '../Fx.js'
-import { asap } from '../_internal/RefCounter.js'
+import { Mutable } from '../_internal/Mutable.js'
 
 import { MulticastFx } from './multicast.js'
 
 export function hold<R, E, A>(fx: Fx<R, E, A>): Fx<R, E, A> {
-  return new HoldFx(fx, MutableRef.make(Option.none()))
+  return new HoldFx(fx, Mutable(Option.none()))
 }
 
-export function hold_<R, E, A>(fx: Fx<R, E, A>, value: MutableRef.MutableRef<Option.Option<A>>) {
+export function hold_<R, E, A>(fx: Fx<R, E, A>, value: Mutable<Option.Option<A>>) {
   return new HoldFx(fx, value)
 }
 
@@ -23,10 +22,7 @@ export class HoldFx<R, E, A> extends MulticastFx<R, E, A> implements Fx<R, E, A>
   protected pendingSinks: Array<readonly [Fx.Sink<any, E, A>, A[]]> = []
   protected scheduledFiber: Fiber.RuntimeFiber<any, any> | undefined = undefined
 
-  constructor(
-    readonly fx: Fx<R, E, A>,
-    protected current: MutableRef.MutableRef<Option.Option<A>>,
-  ) {
+  constructor(readonly fx: Fx<R, E, A>, readonly current: Mutable<Option.Option<A>>) {
     super(fx)
 
     this.event = this.event.bind(this)
@@ -35,7 +31,7 @@ export class HoldFx<R, E, A> extends MulticastFx<R, E, A> implements Fx<R, E, A>
 
   run<R2>(sink: Fx.Sink<R2, E, A>): Effect.Effect<Scope | R | R2, never, void> {
     return Effect.suspend(() => {
-      if (Option.isSome(MutableRef.get(this.current))) {
+      if (Option.isSome(this.current.get())) {
         return pipe(
           this.scheduleFlush(sink),
           Effect.flatMap(() => super.run(sink)),
@@ -80,8 +76,7 @@ export class HoldFx<R, E, A> extends MulticastFx<R, E, A> implements Fx<R, E, A>
       this.pendingSinks.push([
         sink,
         pipe(
-          this.current,
-          MutableRef.get,
+          this.current.get(),
           Option.match(
             () => [],
             (a) => [a],
@@ -98,7 +93,7 @@ export class HoldFx<R, E, A> extends MulticastFx<R, E, A> implements Fx<R, E, A>
       return pipe(
         interrupt,
         Effect.flatMap(() => this.flushPending()),
-        Effect.scheduleForked(asap),
+        Effect.forkScoped,
         Effect.tap((f) =>
           Effect.sync(() => {
             this.scheduledFiber = f
@@ -138,7 +133,7 @@ export class HoldFx<R, E, A> extends MulticastFx<R, E, A> implements Fx<R, E, A>
   }
 
   protected addValue(a: A) {
-    MutableRef.set(this.current, Option.some(a))
+    this.current.set(Option.some(a))
     this.pendingSinks.forEach(([, events]) => events.push(a))
   }
 }

package/src/operator/slice.ts

@@ -32,12 +32,12 @@ class SliceSink<R, E, A> implements Fx.Sink<R, E, A> {
   ) {}
 
   event = (a: A) => {
-    if (this.skip > 0) {
-      this.skip--
-      return Effect.unit()
+    if (this.take === 0) {
+      return this.earlyExit
     }
 
-    if (this.take === 0) {
+    if (this.skip > 0) {
+      this.skip--
       return Effect.unit()
     }
 

package/src/operator/switchMap.test.ts

@@ -1,11 +1,13 @@
 import { deepStrictEqual } from 'assert'
 
 import { millis } from '@effect/data/Duration'
+import * as Either from '@effect/data/Either'
 import { pipe } from '@effect/data/Function'
 import * as Effect from '@effect/io/Effect'
 import { describe, it } from 'vitest'
 
 import { at } from '../constructor/at.js'
+import { fail } from '../constructor/fail.js'
 import { collectAll } from '../run/collectAll.js'
 
 import { mergeAll } from './merge.js'
@@ -23,5 +25,17 @@ describe(import.meta.url, () => {
 
       deepStrictEqual(events, [9])
     })
+
+    it('collects inner errors', async () => {
+      const test = pipe(
+        mergeAll(at(millis(0), 1), at(millis(20), 2), at(millis(40), 3)),
+        switchMap((n) => fail(n)),
+        collectAll,
+      )
+
+      const either = await Effect.runPromiseEither(test)
+
+      deepStrictEqual(either, Either.left(1))
+    })
   })
 })

package/src/run/observe.ts

@@ -3,13 +3,14 @@ import * as Effect from '@effect/io/Effect'
 import type { Scope } from '@effect/io/Scope'
 
 import type { Fx } from '../Fx.js'
+import { disableCooperativeYielding } from '../_internal/disableCooperativeYielding.js'
 
 import { run_ } from './run.js'
 
 export function observe<A, R2, E2, B>(
   f: (a: A) => Effect.Effect<R2, E2, B>,
 ): <R, E>(fx: Fx<R, E, A>) => Effect.Effect<R | R2, E2 | E, void> {
-  return flow(observe_(f), Effect.scoped)
+  return flow(observe_(f), Effect.scoped, disableCooperativeYielding)
 }
 
 export function observeSync<A, B>(

package/src/subject/HoldSubject.ts

@@ -1,8 +1,8 @@
 import { identity } from '@effect/data/Function'
-import * as MutableRef from '@effect/data/MutableRef'
 import { type Option, none } from '@effect/data/Option'
 import * as Effect from '@effect/io/Effect'
 
+import { Mutable } from '../_internal/Mutable.js'
 import { never } from '../constructor/never.js'
 import { HoldFx } from '../operator/hold.js'
 
@@ -10,6 +10,11 @@ import { isSubject, Subject } from './Subject.js'
 
 export interface HoldSubject<E, A> extends Subject<E, A>, HoldSubject.Variance<E, A> {
   readonly value: Effect.Effect<never, never, Option<A>>
+
+  /**
+   * @internal
+   */
+  readonly current: Mutable<Option<A>>
 }
 
 export namespace HoldSubject {
@@ -32,7 +37,7 @@ export namespace HoldSubject {
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   export type OutputsOf<T> = [T] extends [Variance<infer _E, infer A>] ? A : never
 
-  export function unsafeMake<E, A>(value: MutableRef.MutableRef<Option<A>> = MutableRef.make(none())): HoldSubject<E, A> {
+  export function unsafeMake<E, A>(value: Mutable<Option<A>> = Mutable(none())): HoldSubject<E, A> {
     return new HoldSubjectImpl(value)
   }
 
@@ -43,11 +48,11 @@ export namespace HoldSubject {
     };
     readonly [TypeId]: HoldSubject.Variance<E, A>[TypeId] = this[Subject.TypeId]
 
-    constructor(value: MutableRef.MutableRef<Option<A>>) {
+    constructor(value: Mutable<Option<A>>) {
       super(never, value)
     }
 
-    readonly value = Effect.sync(() => MutableRef.get(this.current))
+    readonly value = Effect.sync(() => this.current.get())
   }
 }
 

package/src/subject/RefSubject.test.ts

@@ -1,8 +1,12 @@
 import { deepStrictEqual } from 'assert'
 
+import { millis } from '@effect/data/Duration'
 import * as Effect from '@effect/io/Effect'
+import * as Fiber from '@effect/io/Fiber'
 import { describe, it } from 'vitest'
 
+import { collectAll } from '../run/collectAll.js'
+
 import { makeRef, RefSubject } from './RefSubject.js'
 
 describe(import.meta.url, () => {
@@ -77,5 +81,69 @@ describe(import.meta.url, () => {
 
       await Effect.runPromise(test)
     })
+
+    it('allows computing values from a Computed', async () => {
+      const test = Effect.scoped(
+        Effect.gen(function* ($) {
+          const refSubject = yield* $(makeRef(() => 1))
+          const computed = yield* $(refSubject.computeSync((a) => a + 42))
+          const computed2 = yield* $(computed.computeSync((a) => a + 1))
+
+          deepStrictEqual(yield* $(computed.get), 43, '1a -43')
+          deepStrictEqual(yield* $(computed2.get), 44, '1b - 44')
+
+          yield* $(refSubject.set(2))
+
+          deepStrictEqual(yield* $(computed.get), 44, '2a - 44')
+          deepStrictEqual(yield* $(computed2.get), 45, '2a - 45')
+        }),
+      )
+
+      await Effect.runPromise(test)
+    })
+  })
+
+  it('allows replaying latest events to late subscribers', async () => {
+    const test = Effect.gen(function* ($) {
+      const holdSubject = RefSubject.unsafeMake<number>(() => 0)
+
+      const producer = Effect.gen(function* ($) {
+        yield* $(Effect.sleep(millis(0)))
+        yield* $(holdSubject.event(1))
+        yield* $(Effect.sleep(millis(100)))
+        yield* $(holdSubject.event(2))
+        yield* $(Effect.sleep(millis(100)))
+        yield* $(holdSubject.event(3))
+        yield* $(Effect.sleep(millis(100)))
+        yield* $(holdSubject.event(4))
+        yield* $(Effect.sleep(millis(100)))
+        yield* $(holdSubject.event(5))
+        yield* $(Effect.sleep(millis(100)))
+        yield* $(holdSubject.event(6))
+        yield* $(holdSubject.end)
+      })
+
+      yield* $(Effect.fork(producer))
+
+      const fiber1 = yield* $(Effect.fork(collectAll(holdSubject)))
+
+      yield* $(Effect.sleep(millis(75)))
+
+      const fiber2 = yield* $(Effect.fork(collectAll(holdSubject)))
+
+      yield* $(Effect.sleep(millis(75)))
+
+      const fiber3 = yield* $(Effect.fork(collectAll(holdSubject)))
+
+      const events1 = yield* $(Fiber.join(fiber1))
+      const events2 = yield* $(Fiber.join(fiber2))
+      const events3 = yield* $(Fiber.join(fiber3))
+
+      deepStrictEqual(events1, [0, 1, 2, 3, 4, 5, 6], '1')
+      deepStrictEqual(events2, [1, 2, 3, 4, 5, 6], '2')
+      deepStrictEqual(events3, [2, 3, 4, 5, 6], '3')
+    })
+
+    await Effect.runPromise(test)
   })
 })

package/src/subject/RefSubject.ts

@@ -1,18 +1,18 @@
 import { equals } from '@effect/data/Equal'
 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 type * as Cause from '@effect/io/Cause'
 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, Sink } from '../Fx.js'
+import { Mutable } from '../_internal/Mutable.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'
 
@@ -24,7 +24,7 @@ export interface RefSubject<A> extends HoldSubject<never, A>, Ref.Ref<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, A>
+  readonly delete: Effect.Effect<never, Cause.NoSuchElementException, A>
   readonly compute: <R, E, B>(
     f: (a: A) => Effect.Effect<R, E, B>,
   ) => Effect.Effect<R | Scope.Scope, never, Computed<E, B>>
@@ -44,18 +44,26 @@ export namespace RefSubject {
   export function unsafeMake<A>(
     initial: () => A,
     eq: Equivalence.Equivalence<A> = equals,
+    current: Mutable<Option.Option<A>> = Mutable(Option.some(initial())),
   ): RefSubject<A> {
-    const current = MutableRef.make(Option.some(initial()))
     const subject = HoldSubject.unsafeMake<never, A>(current)
 
-    const getValue = () => pipe(current, MutableRef.get, Option.getOrElse(initial))
+    const getValue = () =>
+      pipe(
+        current.get(),
+        Option.getOrElse(() => {
+          const a = initial()
+          current.set(Option.some(a))
+          return a
+        }),
+      )
 
     const modify = <B>(f: (a: A) => readonly [B, A]): Effect.Effect<never, never, B> =>
       Effect.suspend(() => {
         const currentValue = getValue()
         const [b, a] = f(currentValue)
 
-        MutableRef.set(current, Option.some(a))
+        current.set(Option.some(a))
 
         if (eq(currentValue, a)) {
           return Effect.succeed(b)
@@ -76,15 +84,16 @@ export namespace RefSubject {
       error: subject.error.bind(subject),
       end: subject.end,
       value: subject.value,
+      current: subject.current,
       eq,
       modify,
       ...makeDerivations(modify, Effect.sync(getValue)),
-      delete: Effect.sync(() => {
-        const option = MutableRef.get(current)
-        const reset = initial()
-        MutableRef.set(current, Option.some(reset))
+      delete: Effect.suspend(() => {
+        const option = current.get()
+
+        current.set(Option.none())
 
-        return Option.getOrElse(option, () => reset)
+        return option
       }),
       compute: (f) => makeComputed(refSubject, f),
       computeSync: (f) => makeComputed(refSubject, (a) => Effect.sync(() => f(a))),
@@ -258,6 +267,12 @@ export function isRefSubject<A>(u: unknown): u is RefSubject<A> {
 
 export interface Computed<E, A> extends Fx<never, E, A> {
   readonly get: Effect.Effect<never, E, A>
+
+  readonly compute: <R2, E2, B>(
+    f: (a: A) => Effect.Effect<R2, E2, B>,
+  ) => Effect.Effect<R2 | Scope.Scope, never, Computed<E | E2, B>>
+
+  readonly computeSync: <B>(f: (a: A) => B) => Effect.Effect<Scope.Scope, never, Computed<E, B>>
 }
 
 export namespace Computed {
@@ -288,19 +303,23 @@ export namespace Computed {
   }
 
   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)
+      return pipe(this.input, flatMapEffect(Effect.done)).run(sink)
     }
 
     readonly get = Effect.flatMap(this.input.get, Effect.done)
+
+    readonly compute = <R2, E2, B>(
+      f: (a: A) => Effect.Effect<R2, E2, B>,
+    ): Effect.Effect<R2 | Scope.Scope, never, Computed<E | E2, B>> =>
+      Effect.tap(this.input.compute(Effect.flatMap(f)), Effect.yieldNow)
+
+    readonly computeSync = <B>(f: (a: A) => B): Effect.Effect<Scope.Scope, never, Computed<E, B>> =>
+      Effect.tap(this.input.compute(Effect.map(f)), Effect.yieldNow)
   }
 }