@typed/fx 1.15.4 → 1.16.1

package/src/RefSubject.ts

@@ -199,12 +199,14 @@ function initializeFromContext<E, A>(ctx: RefSubjectContext<E, A>): Effect.Effec
     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())
-        }),
+      return Fiber.join(fiber).pipe(
+        Effect.tap((a) =>
+          Effect.sync(() => {
+            MutableRef.increment(ctx.version)
+            MutableRef.set(ctx.currentRef, Option.some(a))
+          }),
+        ),
+        Effect.ensuring(Effect.sync(() => MutableRef.set(ctx.initializingFiberRef, Option.none()))),
       )
     }),
   )
@@ -753,23 +755,4 @@ export function asRef<R, E, A>(fx: Fx<R, E, A>) {
       )
     }),
   )
-
-  return Effect.gen(function* ($) {
-    const deferred = yield* $(Deferred.make<E, A>())
-    const ref = yield* $(makeRef(Deferred.await(deferred)))
-
-    const onValue = (value: A) =>
-      Effect.flatMap(Deferred.succeed(deferred, value), (closed) =>
-        closed ? Effect.unit : ref.set(value),
-      )
-
-    yield* $(
-      switchMatchCauseEffect(fx, ref.error, onValue),
-      drain,
-      Effect.catchAllCause(ref.error),
-      Effect.forkScoped,
-    )
-
-    return ref
-  })
 }

package/src/data-first.ts

@@ -41,6 +41,7 @@ export * from './orElse.js'
 export * from './promise.js'
 export * from './provide.js'
 export * from './reduce.js'
+export * from './RefArray.js'
 export * from './RefSubject.js'
 export * from './RefTransform.js'
 export * from './scan.js'

package/src/fromEffect.ts

@@ -1,3 +1,4 @@
+import { pipeArguments } from '@effect/data/Pipeable'
 import * as Effect from '@effect/io/Effect'
 
 import { Fx, FxTypeId, Sink } from './Fx.js'
@@ -14,4 +15,9 @@ class FromEffect<R, E, A> implements Fx<R, E, A> {
   run<R2>(sink: Sink<R2, E, A>): Effect.Effect<R | R2, never, void> {
     return Effect.matchCauseEffect(this.effect, { onFailure: sink.error, onSuccess: sink.event })
   }
+
+  pipe() {
+    // eslint-disable-next-line prefer-rest-params
+    return pipeArguments(this, arguments)
+  }
 }

package/src/index.ts

@@ -606,52 +606,29 @@ export const onInterrupt: {
   ): Fx<R | R2, E | E2, A>
 } = dual(2, (fx, f) => internal.onInterrupt(fx, f))
 
-export const promise: <A>(f: () => Promise<A>) => Fx<never, never, A> = (f) => internal.promise(f)
+export const promise: <A>(f: (signal: AbortSignal) => Promise<A>) => Fx<never, never, A> = (f) =>
+  internal.promise(f)
 
-export const promiseInterrupt: <A>(
-  f: (signal: AbortSignal) => Promise<A>,
-) => Fx<never, never, A> = (f) => internal.promiseInterrupt(f)
-
-export const tryPromise: <A>(f: () => Promise<A>) => Fx<never, unknown, A> = (f) =>
-  internal.tryPromise(f)
-
-export const tryPromiseInterrupt: <A>(
-  f: (signal: AbortSignal) => Promise<A>,
-) => Fx<never, unknown, A> = (f) => internal.tryPromiseInterrupt(f)
+export const tryPromise: <A>(f: (signal: AbortSignal) => Promise<A>) => Fx<never, unknown, A> = (
+  f,
+) => internal.tryPromise(f)
 
 export const tryCatchPromise: <A, E>(
-  f: () => Promise<A>,
-  g: (error: unknown) => E,
-) => Fx<never, E, A> = (f, g) => internal.tryCatchPromise(f, g)
-
-export const tryCatchPromiseInterrupt: <A, E>(
   f: (signal: AbortSignal) => Promise<A>,
   g: (error: unknown) => E,
-) => Fx<never, E, A> = (f, g) => internal.tryCatchPromiseInterrupt(f, g)
+) => Fx<never, E, A> = (f, g) => internal.tryCatchPromise(f, g)
 
 export const promiseFx: <R, E, A>(f: () => Promise<Fx<R, E, A>>) => Fx<R, E, A> = (f) =>
   internal.promiseFx(f)
 
-export const promiseInterrupFx: <R, E, A>(
+export const tryPromiseFx: <R, E, A>(
   f: (signal: AbortSignal) => Promise<Fx<R, E, A>>,
-) => Fx<R, E, A> = (f) => internal.promiseInterruptFx(f)
-
-export const tryPromiseFx: <R, E, A>(f: () => Promise<Fx<R, E, A>>) => Fx<R, unknown, A> = (f) =>
-  internal.tryPromiseFx(f)
-
-export const tryPromiseInterruptFx: <R, E, A>(
-  f: (signal: AbortSignal) => Promise<Fx<R, E, A>>,
-) => Fx<R, unknown, A> = (f) => internal.tryPromiseInterruptFx(f)
+) => Fx<R, unknown, A> = (f) => internal.tryPromiseFx(f)
 
 export const tryCatchPromiseFx: <R, E, A, E2>(
-  f: () => Promise<Fx<R, E, A>>,
-  g: (error: unknown) => E2,
-) => Fx<R, E | E2, A> = (f, g) => internal.tryCatchPromiseFx(f, g)
-
-export const tryCatchPromiseInterruptFx: <R, E, A, E2>(
   f: (signal: AbortSignal) => Promise<Fx<R, E, A>>,
   g: (error: unknown) => E2,
-) => Fx<R, E | E2, A> = (f, g) => internal.tryCatchPromiseInterruptFx(f, g)
+) => Fx<R, E | E2, A> = (f, g) => internal.tryCatchPromiseFx(f, g)
 
 export const provideContext: {
   <R>(context: Context.Context<R>): <E, A>(fx: Fx<R, E, A>) => Fx<never, E, A>
@@ -1086,6 +1063,7 @@ export const orElse: {
   ): Fx<R | R2, E2, B> => internal.orElse(fx, f),
 )
 
+export * from './RefArray.js'
 export * from './RefSubject.js'
 export * from './Computed.js'
 export * from './Filtered.js'

package/src/multicast.ts

@@ -1,5 +1,6 @@
 import type * as Context from '@effect/data/Context'
 import { identity } from '@effect/data/Function'
+import { pipeArguments } from '@effect/data/Pipeable'
 import type * as Cause from '@effect/io/Cause'
 import * as Effect from '@effect/io/Effect'
 import * as Fiber from '@effect/io/Fiber'
@@ -84,6 +85,11 @@ export class MulticastFx<R, E, A> implements Fx<R, E, A>, Sink<never, E, A> {
     )
   }
 
+  pipe() {
+    // eslint-disable-next-line prefer-rest-params
+    return pipeArguments(this, arguments)
+  }
+
   protected runEvent<R>(observer: MulticastObserver<R, E, A>, a: A) {
     return Effect.catchAllCause(
       Effect.provideContext(observer.sink.event(a), observer.context),

package/src/promise.ts

@@ -4,68 +4,34 @@ import type { Fx } from './Fx.js'
 import { fromEffect } from './fromEffect.js'
 import { fromFxEffect } from './fromFxEffect.js'
 
-export function promise<A>(f: () => Promise<A>): Fx<never, never, A> {
+export function promise<A>(f: (signal: AbortSignal) => Promise<A>): Fx<never, never, A> {
   return fromEffect(Effect.promise(f))
 }
 
-export function promiseInterrupt<A>(f: (signal: AbortSignal) => Promise<A>): Fx<never, never, A> {
-  return fromEffect(Effect.promiseInterrupt(f))
-}
-
-export function tryPromise<A>(f: () => Promise<A>): Fx<never, unknown, A> {
+export function tryPromise<A>(f: (signal: AbortSignal) => Promise<A>): Fx<never, unknown, A> {
   return fromEffect(Effect.tryPromise(f))
 }
 
-export function tryPromiseInterrupt<A>(
-  f: (signal: AbortSignal) => Promise<A>,
-): Fx<never, unknown, A> {
-  return fromEffect(Effect.tryPromiseInterrupt(f))
-}
-
 export function tryCatchPromise<A, E>(
-  f: () => Promise<A>,
-  g: (error: unknown) => E,
-): Fx<never, E, A> {
-  return fromEffect(Effect.tryPromise({ try: f, catch: g }))
-}
-
-export function tryCatchPromiseInterrupt<A, E>(
   f: (signal: AbortSignal) => Promise<A>,
   g: (error: unknown) => E,
 ): Fx<never, E, A> {
-  return fromEffect(Effect.tryPromiseInterrupt({ try: f, catch: g }))
+  return fromEffect(Effect.tryPromise({ try: f, catch: g }))
 }
 
-export function promiseFx<R, E, A>(f: () => Promise<Fx<R, E, A>>): Fx<R, E, A> {
+export function promiseFx<R, E, A>(f: (signal: AbortSignal) => Promise<Fx<R, E, A>>): Fx<R, E, A> {
   return fromFxEffect(Effect.promise(f))
 }
 
-export function promiseInterruptFx<R, E, A>(
-  f: (signal: AbortSignal) => Promise<Fx<R, E, A>>,
-): Fx<R, E, A> {
-  return fromFxEffect(Effect.promiseInterrupt(f))
-}
-
-export function tryPromiseFx<R, E, A>(f: () => Promise<Fx<R, E, A>>): Fx<R, unknown, A> {
-  return fromFxEffect(Effect.tryPromise(f))
-}
-
-export function tryPromiseInterruptFx<R, E, A>(
+export function tryPromiseFx<R, E, A>(
   f: (signal: AbortSignal) => Promise<Fx<R, E, A>>,
 ): Fx<R, unknown, A> {
-  return fromFxEffect(Effect.tryPromiseInterrupt(f))
+  return fromFxEffect(Effect.tryPromise(f))
 }
 
 export function tryCatchPromiseFx<R, E, A, E2>(
-  f: () => Promise<Fx<R, E, A>>,
-  g: (error: unknown) => E2,
-): Fx<R, E | E2, A> {
-  return fromFxEffect(Effect.tryPromise({ try: f, catch: g }))
-}
-
-export function tryCatchPromiseInterruptFx<R, E, A, E2>(
   f: (signal: AbortSignal) => Promise<Fx<R, E, A>>,
   g: (error: unknown) => E2,
 ): Fx<R, E | E2, A> {
-  return fromFxEffect(Effect.tryPromiseInterrupt({ try: f, catch: g }))
+  return fromFxEffect(Effect.tryPromise({ try: f, catch: g }))
 }