@typed/fx 1.0.7 → 1.0.9

package/src/operator/flatMapCause.ts

@@ -1,4 +1,4 @@
-import type { Cause } from '@effect/io/Cause'
+import * as Cause from '@effect/io/Cause'
 import * as Effect from '@effect/io/Effect'
 import { pipe } from '@fp-ts/data/Function'
 
@@ -6,7 +6,7 @@ import { Fx } from '../Fx.js'
 import { withRefCounter } from '../_internal/RefCounter.js'
 
 export function flatMapCause<E, R2, E2, B>(
-  f: (cause: Cause<E>) => Fx<R2, E2, B>,
+  f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>,
 ): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A | B> {
   return (fx) => new FlatMapCauseFx(fx, f)
 }
@@ -15,7 +15,7 @@ class FlatMapCauseFx<R, E, A, R2, E2, B>
   extends Fx.Variance<R | R2, E | E2, B>
   implements Fx<R | R2, E | E2, A | B>
 {
-  constructor(readonly fx: Fx<R, E, A>, readonly f: (cause: Cause<E>) => Fx<R2, E2, B>) {
+  constructor(readonly fx: Fx<R, E, A>, readonly f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>) {
     super()
   }
 
@@ -32,6 +32,9 @@ class FlatMapCauseFx<R, E, A, R2, E2, B>
                 Effect.flatMap(() =>
                   this.f(cause).run(Fx.Sink(sink.event, sink.error, counter.decrement)),
                 ),
+                Effect.onError((cause) =>
+                  Cause.isInterruptedOnly(cause) ? Effect.unit() : sink.error(cause),
+                ),
                 Effect.forkScoped,
               ),
             counter.decrement,

package/src/operator/mergeRace.ts

@@ -1,5 +1,7 @@
+import * as Cause from '@effect/io/Cause'
 import * as Effect from '@effect/io/Effect'
 import * as Fiber from '@effect/io/Fiber'
+import { pipe } from '@fp-ts/data/Function'
 
 import { Fx } from '../Fx.js'
 
@@ -16,7 +18,13 @@ export function mergeRace<R2, E2, B>(raced: Fx<R2, E2, B>) {
       Effect.gen(function* ($) {
         let interrupted = false
         const racedFiber = yield* $(
-          Effect.forkScoped(raced.run(Fx.Sink(sink.event, sink.error, Effect.unit()))),
+          pipe(
+            raced.run(Fx.Sink(sink.event, sink.error, Effect.unit())),
+            Effect.onError((cause) =>
+              Cause.isInterruptedOnly(cause) ? Effect.unit() : sink.error(cause),
+            ),
+            Effect.forkScoped,
+          ),
         )
 
         return yield* $(

package/src/operator/since.test.ts

@@ -1,48 +1,48 @@
-// import { deepStrictEqual } from 'assert'
-
-// import * as Effect from '@effect/io/Effect'
-// import * as Fiber from '@effect/io/Fiber'
-// // TODO: Fix these tests reaching the test environment
-// import * as TestClock from '@effect/io/internal/testing/testClock'
-// import * as TE from '@effect/io/internal/testing/testEnvironment'
-// import * as Duration from '@fp-ts/data/Duration'
-// import { pipe } from '@fp-ts/data/Function'
-// import { describe, it } from 'vitest'
-
-// import { at } from '../constructor/at.js'
-// import { periodic } from '../constructor/periodic.js'
-// import { collectAll } from '../run/collectAll.js'
-
-// import { since } from './since.js'
-// import { withItems } from './withItems.js'
-
-// describe(import.meta.url, () => {
-//   describe(since.name, () => {
-//     it('interrupts a stream when a signal is received', async () => {
-//       const delay = 20
-//       const expected = 5
-//       const fx = pipe(
-//         periodic(Duration.millis(delay)),
-//         withItems([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]),
-//         since(at(Duration.millis(delay * expected), null)),
-//       )
-
-//       const test = pipe(
-//         Effect.gen(function* ($) {
-//           const fiber = yield* $(Effect.fork(collectAll(fx)))
-
-//           for (let i = 0; i <= expected * 2; i++) {
-//             yield* $(TestClock.adjust(Duration.millis(delay)))
-//           }
-
-//           return yield* $(Fiber.join(fiber))
-//         }),
-//         Effect.provideSomeLayer(TE.TestEnvironment),
-//       )
-
-//       const events = await Effect.unsafeRunPromise(test)
-
-//       deepStrictEqual(events, [6, 7, 8, 9, 10])
-//     })
-//   })
-// })
+import { deepStrictEqual } from 'assert'
+
+import * as Effect from '@effect/io/Effect'
+import * as Fiber from '@effect/io/Fiber'
+import * as TestClock from '@effect/test/TestClock'
+import * as TE from '@effect/test/TestEnvironment'
+import * as Duration from '@fp-ts/data/Duration'
+import { pipe } from '@fp-ts/data/Function'
+import { describe, it } from 'vitest'
+
+import { at } from '../constructor/at.js'
+import { periodic } from '../constructor/periodic.js'
+import { collectAll } from '../run/collectAll.js'
+
+import { since } from './since.js'
+import { withItems } from './withItems.js'
+
+// TODO: remove skip when @effect/test has been updated to latest @effect/io
+describe.skip(import.meta.url, () => {
+  describe(since.name, () => {
+    it('interrupts a stream when a signal is received', async () => {
+      const delay = 20
+      const expected = 5
+      const fx = pipe(
+        periodic(Duration.millis(delay)),
+        withItems([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]),
+        since(at(Duration.millis(delay * expected), null)),
+      )
+
+      const test = pipe(
+        Effect.gen(function* ($) {
+          const fiber = yield* $(Effect.fork(collectAll(fx)))
+
+          for (let i = 0; i <= expected * 2; i++) {
+            yield* $(TestClock.adjust(Duration.millis(delay)))
+          }
+
+          return yield* $(Fiber.join(fiber))
+        }),
+        Effect.provideSomeLayer(TE.TestEnvironment),
+      )
+
+      const events = await Effect.unsafeRunPromise(test)
+
+      deepStrictEqual(events, [6, 7, 8, 9, 10])
+    })
+  })
+})

package/src/operator/snapshot.ts

@@ -1,3 +1,4 @@
+import * as Cause from '@effect/io/Cause'
 import * as Effect from '@effect/io/Effect'
 import * as Ref from '@effect/io/Ref'
 import { pipe } from '@fp-ts/data/Function'
@@ -32,6 +33,9 @@ class SnapshotFx<R, E, A, R2, E2, B, C>
         pipe(
           sampled,
           run((b) => pipe(ref, Ref.set(Option.some(b))), sink.error, Effect.unit()),
+          Effect.onError((cause) =>
+            Cause.isInterruptedOnly(cause) ? Effect.unit() : sink.error(cause),
+          ),
           Effect.forkScoped,
         ),
       )

package/src/operator/snapshotEffect.ts

@@ -1,3 +1,4 @@
+import * as Cause from '@effect/io/Cause'
 import * as Effect from '@effect/io/Effect'
 import * as Ref from '@effect/io/Ref/Synchronized'
 import { pipe } from '@fp-ts/data/Function'
@@ -36,6 +37,9 @@ class SnapshotEffectFx<R, E, A, R2, E2, B, R3, E3, C>
         pipe(
           sampled,
           run((b) => pipe(ref, Ref.set(Option.some(b))), sink.error, Effect.unit()),
+          Effect.onError((cause) =>
+            Cause.isInterruptedOnly(cause) ? Effect.unit() : sink.error(cause),
+          ),
           Effect.forkScoped,
         ),
       )

package/src/operator/switchMap.ts

@@ -1,3 +1,4 @@
+import * as Cause from '@effect/io/Cause'
 import * as Effect from '@effect/io/Effect'
 import * as Fiber from '@effect/io/Fiber'
 import * as Ref from '@effect/io/Ref/Synchronized'
@@ -47,7 +48,7 @@ class SwitchMapFx<R, E, A, R2, E2, B>
                           : Effect.asUnit(counter.increment),
                         // eslint-disable-next-line @typescript-eslint/no-unused-vars
                         Effect.flatMap((_: unknown) =>
-                          Effect.forkScoped(
+                          pipe(
                             this.f(a).run(
                               Fx.Sink(
                                 sink.event,
@@ -55,6 +56,10 @@ class SwitchMapFx<R, E, A, R2, E2, B>
                                 pipe(counter.decrement, Effect.zipLeft(resetRef)),
                               ),
                             ),
+                            Effect.onError((cause) =>
+                              Cause.isInterruptedOnly(cause) ? Effect.unit() : sink.error(cause),
+                            ),
+                            Effect.forkScoped,
                           ),
                         ),
                       ),

package/src/operator/switchMatch.ts

@@ -63,7 +63,7 @@ class SwitchMatchFx<R, E, A, R2, E2, B, R3, E3, C>
                       : Effect.asUnit(counter.increment),
                     // eslint-disable-next-line @typescript-eslint/no-unused-vars
                     Effect.flatMap((_: unknown) =>
-                      Effect.forkScoped(
+                      pipe(
                         fx.run(
                           Fx.Sink(
                             sink.event,
@@ -71,6 +71,10 @@ class SwitchMatchFx<R, E, A, R2, E2, B, R3, E3, C>
                             pipe(counter.decrement, Effect.zipLeft(resetRef)),
                           ),
                         ),
+                        Effect.onError((cause) =>
+                          Cause.isInterruptedOnly(cause) ? Effect.unit() : sink.error(cause),
+                        ),
+                        Effect.forkScoped,
                       ),
                     ),
                   ),

package/src/operator/until.test.ts

@@ -1,47 +1,48 @@
-// import { deepStrictEqual } from 'assert'
-
-// import * as Effect from '@effect/io/Effect'
-// import * as Fiber from '@effect/io/Fiber'
-// import * as TestClock from '@effect/io/internal/testing/testClock'
-// import * as TE from '@effect/io/internal/testing/testEnvironment'
-// import * as Duration from '@fp-ts/data/Duration'
-// import { pipe } from '@fp-ts/data/Function'
-// import { describe, it } from 'vitest'
-
-// import { at } from '../constructor/at.js'
-// import { periodic } from '../constructor/periodic.js'
-// import { collectAll } from '../run/collectAll.js'
-
-// import { until } from './until.js'
-// import { withItems } from './withItems.js'
-
-// describe(import.meta.url, () => {
-//   describe(until.name, () => {
-//     it('interrupts a stream when a signal is received', async () => {
-//       const delay = 20
-//       const expected = 5
-//       const fx = pipe(
-//         periodic(Duration.millis(delay)),
-//         withItems([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]),
-//         until(at(Duration.millis(delay * expected), null)),
-//       )
-
-//       const test = pipe(
-//         Effect.gen(function* ($) {
-//           const fiber = yield* $(Effect.fork(collectAll(fx)))
-
-//           for (let i = 0; i < expected; i++) {
-//             yield* $(TestClock.adjust(Duration.millis(delay)))
-//           }
-
-//           return yield* $(Fiber.join(fiber))
-//         }),
-//         Effect.provideSomeLayer(TE.TestEnvironment),
-//       )
-
-//       const events = await Effect.unsafeRunPromise(test)
-
-//       deepStrictEqual(events, [1, 2, 3, 4, 5])
-//     })
-//   })
-// })
+import { deepStrictEqual } from 'assert'
+
+import * as Effect from '@effect/io/Effect'
+import * as Fiber from '@effect/io/Fiber'
+import * as TestClock from '@effect/test/TestClock'
+import * as TE from '@effect/test/TestEnvironment'
+import * as Duration from '@fp-ts/data/Duration'
+import { pipe } from '@fp-ts/data/Function'
+import { describe, it } from 'vitest'
+
+import { at } from '../constructor/at.js'
+import { periodic } from '../constructor/periodic.js'
+import { collectAll } from '../run/collectAll.js'
+
+import { until } from './until.js'
+import { withItems } from './withItems.js'
+
+// TODO: remove skip when @effect/test has been updated to latest @effect/io
+describe.skip(import.meta.url, () => {
+  describe(until.name, () => {
+    it('interrupts a stream when a signal is received', async () => {
+      const delay = 20
+      const expected = 5
+      const fx = pipe(
+        periodic(Duration.millis(delay)),
+        withItems([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]),
+        until(at(Duration.millis(delay * expected), null)),
+      )
+
+      const test = pipe(
+        Effect.gen(function* ($) {
+          const fiber = yield* $(Effect.fork(collectAll(fx)))
+
+          for (let i = 0; i < expected; i++) {
+            yield* $(TestClock.adjust(Duration.millis(delay)))
+          }
+
+          return yield* $(Fiber.join(fiber))
+        }),
+        Effect.provideSomeLayer(TE.TestEnvironment),
+      )
+
+      const events = await Effect.unsafeRunPromise(test)
+
+      deepStrictEqual(events, [1, 2, 3, 4, 5])
+    })
+  })
+})

package/src/operator/withPermit.ts

@@ -1,3 +1,5 @@
+import type { Effect } from '@effect/io/Effect'
+import type { Scope } from '@effect/io/Scope'
 import * as TSemaphore from '@effect/stm/TSemaphore'
 import { pipe } from '@fp-ts/data/Function'
 
@@ -12,7 +14,7 @@ class WithPermitFx<R, E, A> extends Fx.Variance<R, E, A> implements Fx<R, E, A>
     super()
   }
 
-  run<R2>(sink: Fx.Sink<R2, E, A>) {
+  run<R2>(sink: Fx.Sink<R2, E, A>): Effect<R | R2 | Scope, never, unknown> {
     return pipe(this.fx.run(sink), TSemaphore.withPermit(this.semaphore))
   }
 }

package/src/run/run.ts

@@ -1,4 +1,4 @@
-import type { Cause } from '@effect/io/Cause'
+import * as Cause from '@effect/io/Cause'
 import * as Deferred from '@effect/io/Deferred'
 import * as Effect from '@effect/io/Effect'
 import * as Fiber from '@effect/io/Fiber'
@@ -9,7 +9,7 @@ import { Fx, Sink } from '../Fx.js'
 
 export function run<A, R2, E2, E, R3, E3, B, R4, E4>(
   event: (a: A) => Effect.Effect<R2, E2, any>,
-  error: (cause: Cause<E>) => Effect.Effect<R3, E3, B>,
+  error: (cause: Cause.Cause<E>) => Effect.Effect<R3, E3, B>,
   end: Effect.Effect<R4, E4, B>,
 ): <R>(fx: Fx<R, E, A>) => Effect.Effect<R | R2 | R3 | R4, E2 | E3 | E4, B> {
   return flow(run_(event, error, end), Effect.scoped)
@@ -17,7 +17,7 @@ export function run<A, R2, E2, E, R3, E3, B, R4, E4>(
 
 export function run_<A, R2, E2, E, R3, E3, B, R4, E4>(
   event: (a: A) => Effect.Effect<R2, E2, any>,
-  error: (cause: Cause<E>) => Effect.Effect<R3, E3, B>,
+  error: (cause: Cause.Cause<E>) => Effect.Effect<R3, E3, B>,
   end: Effect.Effect<R4, E4, B>,
 ) {
   return <R>(fx: Fx<R, E, A>): Effect.Effect<R | R2 | R3 | R4 | Scope, E2 | E3 | E4, B> =>
@@ -38,7 +38,19 @@ export function run_<A, R2, E2, E, R3, E3, B, R4, E4>(
         pipe(end, Effect.intoDeferred(deferred)),
       )
 
-      const fiber = yield* $(Effect.forkScoped(fx.run(sink)))
+      const fiber = yield* $(
+        pipe(
+          fx.run(sink),
+          Effect.onError((cause) =>
+            Effect.sync(() =>
+              Cause.isInterruptedOnly(cause)
+                ? null
+                : pipe(deferred, Deferred.unsafeDone<E2 | E3 | E4, B>(Effect.failCause(cause))),
+            ),
+          ),
+          Effect.forkScoped,
+        ),
+      )
 
       const c = yield* $(Deferred.await(deferred))