@typed/fx 0.0.13 → 0.0.15

package/src/multicast.ts

@@ -20,6 +20,10 @@ export interface MulticastObserver<E, A> {
 }
 
 export class Multicast<R, E, A> implements Fx<R, E, A>, Emitter<never, E, A> {
+  readonly _R!: () => R
+  readonly _E!: () => E
+  readonly _A!: () => A
+
   protected observers: MulticastObserver<E, A>[] = []
   protected fiber: Fiber.Fiber<never, unknown> | undefined
 

package/src/runCollect.ts

@@ -2,6 +2,7 @@ import * as Effect from '@effect/core/io/Effect'
 import { pipe } from '@fp-ts/data/Function'
 
 import { Fx } from './Fx.js'
+import { onEarlyExitFailure } from './_internal.js'
 import { runObserve } from './runObserve.js'
 
 export function runCollect<R, E, A>(fx: Fx<R, E, A>): Effect.Effect<R, E, ReadonlyArray<A>> {
@@ -11,6 +12,7 @@ export function runCollect<R, E, A>(fx: Fx<R, E, A>): Effect.Effect<R, E, Readon
       pipe(
         fx,
         runObserve((a) => Effect.sync(() => values.push(a))),
+        onEarlyExitFailure(Effect.unit),
         Effect.map(() => values),
       ),
     ),

package/src/runDrain.ts

@@ -3,6 +3,7 @@ import * as Effect from '@effect/core/io/Effect'
 import { pipe } from '@fp-ts/data/Function'
 
 import { Fx } from './Fx.js'
+import { onEarlyExitFailure } from './_internal.js'
 
 export function runDrain<R, E, A>(fx: Fx<R, E, A>): Effect.Effect<R, E, void> {
   return pipe(
@@ -16,6 +17,7 @@ export function runDrain<R, E, A>(fx: Fx<R, E, A>): Effect.Effect<R, E, void> {
         }),
         Effect.forkScoped,
         Effect.zipRight(deferred.await),
+        onEarlyExitFailure(Effect.sync(() => deferred.succeed(undefined))),
       ),
     ),
     Effect.scoped,

package/src/runObserve.ts

@@ -3,6 +3,7 @@ import * as Effect from '@effect/core/io/Effect'
 import { flow, pipe } from '@fp-ts/data/Function'
 
 import { Emitter, Fx } from './Fx.js'
+import { onEarlyExitFailure } from './_internal.js'
 
 export function runObserve<A, R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>) {
   return <R, E>(fx: Fx<R, E, A>): Effect.Effect<R | R2, E | E2, void> =>
@@ -26,6 +27,7 @@ export function runObserve<A, R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>)
         ),
       ),
       Effect.flatMap((deferred) => deferred.await),
+      onEarlyExitFailure(Effect.unit),
       Effect.scoped,
     )
 }

package/src/snapshot.ts

@@ -5,24 +5,20 @@ import * as Maybe from '@tsplus/stdlib/data/Maybe'
 
 import { Emitter, Fx } from './Fx.js'
 
-export function snapshot<R2, E2, B, A, R3, E3, C>(sampled: Fx<R2, E2, B>, f: (b: B, a: A) => C) {
-  return <R, E>(sampler: Fx<R, E, A>): Fx<R & R2 & R3, E | E2 | E3, C> =>
-    snapshot_(sampler, sampled, f)
+export function snapshot<R2, E2, B, A, C>(sampled: Fx<R2, E2, B>, f: (b: B, a: A) => C) {
+  return <R, E>(sampler: Fx<R, E, A>): Fx<R | R2, E | E2, C> => snapshot_(sampler, sampled, f)
 }
 
 export function sample<R2, E2, B>(sampled: Fx<R2, E2, B>) {
   return <R, E, A>(sampler: Fx<R, E, A>): Fx<R | R2, E | E2, readonly [A, B]> =>
-    pipe(
-      sampler,
-      snapshot(sampled, (b, a) => [a, b]),
-    )
+    snapshot_(sampler, sampled, (b, a) => [a, b])
 }
 
-function snapshot_<R, E, A, R2, E2, B, R3, E3, C>(
+function snapshot_<R, E, A, R2, E2, B, C>(
   sampler: Fx<R, E, A>,
   sampled: Fx<R2, E2, B>,
   f: (b: B, a: A) => C,
-): Fx<R | R2 | R3, E | E2 | E3, C> {
+): Fx<R | R2, E | E2, C> {
   return Fx((emitter) =>
     pipe(
       Effect.sync(() => new AtomicReference<Maybe.Maybe<B>>(Maybe.none)),

package/src/struct.ts

@@ -0,0 +1,24 @@
+import { pipe } from '@fp-ts/data/Function'
+
+import { Fx } from './Fx.js'
+import { combineAll } from './combine.js'
+import { map } from './filterMap.js'
+
+export const struct = <Props extends Readonly<Record<string, Fx<any, any, any>>>>(
+  props: Props,
+): Fx<
+  Fx.ResourcesOf<Props[string]>,
+  Fx.ErrorsOf<Props[string]>,
+  { readonly [K in keyof Props]: Fx.OutputOf<Props[K]> }
+> =>
+  pipe(
+    combineAll(
+      Object.entries(props).map(([key, fx]) =>
+        pipe(
+          fx,
+          map((value) => ({ [key]: value })),
+        ),
+      ),
+    ),
+    map((values) => Object.assign({}, ...values)),
+  )

package/src/withEmitter.ts

@@ -1,4 +1,3 @@
-import { Cause } from '@effect/core/io/Cause'
 import * as Effect from '@effect/core/io/Effect'
 import * as Exit from '@effect/core/io/Exit'
 import { unsafeForkUnstarted } from '@effect/core/io/Fiber/_internal/runtime'
@@ -6,13 +5,10 @@ import { Scope } from '@effect/core/io/Scope'
 import { flow, pipe } from '@fp-ts/data/Function'
 
 import { Emitter, Fx } from './Fx.js'
+import type { SubjectEmitter } from './Subject.js'
 
 export function withEmitter<R, E, A>(
-  f: (sink: {
-    readonly emit: (a: A) => void
-    readonly failCause: (cause: Cause<E>) => void
-    readonly end: () => void
-  }) => Effect.Canceler<R>,
+  f: (emitter: SubjectEmitter<E, A>) => Effect.Canceler<R>,
 ): Fx<R, E, A> {
   return Fx<R, E, A>(<R2>(sink: Emitter<R2, E, A>) => {
     return Effect.withFiberRuntime<R | R2 | Scope, never, unknown>((fiber, status) => {