@typed/fx 1.2.0 → 1.3.0

package/src/Subject/HoldSubject.ts

@@ -1,5 +1,5 @@
 import { identity } from '@effect/data/Function'
-import { type MutableRef, make } from '@effect/data/MutableRef'
+import * as MutableRef from '@effect/data/MutableRef'
 import { type Option, none } from '@effect/data/Option'
 import * as Effect from '@effect/io/Effect'
 
@@ -32,7 +32,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<Option<A>> = make(none())): HoldSubject<E, A> {
+  export function unsafeMake<E, A>(value: MutableRef.MutableRef<Option<A>> = MutableRef.make(none())): HoldSubject<E, A> {
     return new HoldSubjectImpl(value)
   }
 
@@ -43,11 +43,11 @@ export namespace HoldSubject {
     };
     readonly [TypeId]: HoldSubject.Variance<E, A>[TypeId] = this[Subject.TypeId]
 
-    constructor(value: MutableRef<Option<A>>) {
+    constructor(value: MutableRef.MutableRef<Option<A>>) {
       super(never, value)
     }
 
-    readonly value = Effect.sync(() => this.current.get())
+    readonly value = Effect.sync(() => MutableRef.get(this.current))
   }
 }
 

package/src/Subject/RefSubject.ts

@@ -25,11 +25,9 @@ export interface RefSubject<A> extends HoldSubject<never, A>, Ref.Ref<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 compute: <R, E, B>(
     f: (a: A) => Effect.Effect<R, E, B>,
   ) => Effect.Effect<R | Scope.Scope, never, Computed<E, B>>
-
   readonly computeSync: <B>(f: (a: A) => B) => Effect.Effect<Scope.Scope, never, Computed<never, B>>
 }
 
@@ -50,14 +48,14 @@ export namespace RefSubject {
     const current = MutableRef.make(Option.some(initial()))
     const subject = HoldSubject.unsafeMake<never, A>(current)
 
-    const getValue = () => pipe(current.get(), Option.getOrElse(initial))
+    const getValue = () => pipe(current, MutableRef.get, Option.getOrElse(initial))
 
     const modify = <B>(f: (a: A) => readonly [B, A]): Effect.Effect<never, never, B> =>
-      Effect.suspendSucceed(() => {
+      Effect.suspend(() => {
         const currentValue = getValue()
         const [b, a] = f(currentValue)
 
-        current.set(Option.some(a))
+        MutableRef.set(current, (Option.some(a)))
 
         if (eq(currentValue, a)) {
           return Effect.succeed(b)
@@ -82,9 +80,9 @@ export namespace RefSubject {
       modify,
       ...makeDerivations(modify, Effect.sync(getValue)),
       delete: Effect.sync(() => {
-        const option = current.get()
+        const option = MutableRef.get(current)
         const reset = initial()
-        current.set(Option.some(reset))
+        MutableRef.set(current, (Option.some(reset)))
 
         return Option.getOrElse(option, () => reset)
       }),
@@ -105,7 +103,7 @@ export namespace RefSubject {
     type Val = { readonly [K in keyof Subjects]: ValueOf<Subjects[K]> }
     const length = subjects.length
 
-    const getUnderlyingValues = Effect.tuple(
+    const getUnderlyingValues = Effect.all(
       ...ReadonlyArray.mapNonEmpty(subjects, (s) => s.get),
     ) as Effect.Effect<never, never, Val>
 
@@ -130,7 +128,7 @@ export namespace RefSubject {
 
       // Override event to replicate events into underlying subjects
       const event = (val: Val) =>
-        Effect.tuple(...ReadonlyArray.mapNonEmpty(subjects, (s, i) => s.event(val[i])))
+        Effect.all(...ReadonlyArray.mapNonEmpty(subjects, (s, i) => s.event(val[i])))
 
       // Override modify to replicate events into underlying subjects
       const modify = <B>(f: (a: Val) => readonly [B, Val]): Effect.Effect<never, never, B> =>
@@ -175,7 +173,7 @@ export namespace RefSubject {
   > {
     type Val = { readonly [K in keyof Subjects]: ValueOf<Subjects[K]> }
 
-    const getUnderlyingValues = Effect.struct(
+    const getUnderlyingValues = Effect.all(
       ReadonlyRecord.map(subjects, (s) => s.get),
     ) as Effect.Effect<never, never, Val>
 
@@ -199,7 +197,7 @@ export namespace RefSubject {
 
       // Override event to replicate events into underlying subjects
       const event = (val: Val) =>
-        Effect.struct(ReadonlyRecord.map(subjects, (s, i) => s.event(val[i])))
+        Effect.all(ReadonlyRecord.map(subjects, (s, i) => s.event(val[i])))
 
       // Override modify to replicate events into underlying subjects
       const modify = <B>(f: (a: Val) => readonly [B, Val]): Effect.Effect<never, never, B> =>

package/src/Subject/SynchronizedSubject.ts

@@ -34,11 +34,11 @@ export namespace SynchronizedSubject {
 
     const getValue = () =>
       pipe(
-        mutableRef.get(),
+        MutableRef.get(mutableRef),
         Option.getOrElse(() => {
           const a = initial()
 
-          mutableRef.set(Option.some(a))
+          MutableRef.set(mutableRef, Option.some(a))
 
           return a
         }),
@@ -56,7 +56,7 @@ export namespace SynchronizedSubject {
             return b
           }
 
-          mutableRef.set(Option.some(a))
+          MutableRef.set(mutableRef, Option.some(a))
 
           yield* $(subject.event(a))
 
@@ -100,7 +100,7 @@ export namespace SynchronizedSubject {
       delete: Effect.sync(() => {
         const value = getValue()
 
-        mutableRef.set(Option.some(value))
+        MutableRef.set(mutableRef, Option.some(value))
 
         return value
       }),

package/src/_internal/RefCounter.ts

@@ -33,7 +33,7 @@ export class RefCounter {
 
   readonly wait = Deferred.await(this.deferred)
 
-  private checkShouldClose = Effect.suspendSucceed(() => {
+  private checkShouldClose = Effect.suspend(() => {
     const interrupt = this.fiber ? Fiber.interrupt(this.fiber) : Effect.unit()
 
     this.fiber = undefined

package/src/constructor/index.ts

@@ -38,8 +38,4 @@ export * from './serviceWithFx.js'
 export * from './succeed.js'
 export * from './suspend.js'
 export * from './sync.js'
-export * from './tryCatchPromise.js'
-export * from './tryCatchPromiseAbort.js'
-export * from './tryPromise.js'
-export * from './tryPromiseAbort.js'
 export * from './unit.js'

package/src/constructor/promiseFx.ts

@@ -20,25 +20,3 @@ export const promiseInterruptFx = <R, E, A>(
       Effect.matchCauseEffect(sink.error, (fx) => fx.run(sink)),
     ),
   )
-
-export const tryCatchPromiseFx = <R, E, A, E2>(
-  f: () => Promise<Fx<R, E, A>>,
-  onError: (u: unknown) => E2,
-): Fx<R, E | E2, A> =>
-  Fx((sink) =>
-    pipe(
-      Effect.tryCatchPromise(f, onError),
-      Effect.matchCauseEffect(sink.error, (fx) => fx.run(sink)),
-    ),
-  )
-
-export const tryCatchPromiseInterruptFx = <R, E, A, E2>(
-  f: (signal: AbortSignal) => Promise<Fx<R, E, A>>,
-  onError: (u: unknown) => E2,
-): Fx<R, E | E2, A> =>
-  Fx((sink) =>
-    pipe(
-      Effect.tryCatchPromiseInterrupt(f, onError),
-      Effect.matchCauseEffect(sink.error, (fx) => fx.run(sink)),
-    ),
-  )

package/src/operator/catchAllDefect.ts

@@ -1,5 +1,6 @@
 import { pipe } from '@effect/data/Function'
 import { match } from '@effect/data/Option'
+import * as Chunk from '@effect/data/Chunk'
 import * as Cause from '@effect/io/Cause'
 
 import type { Fx } from '../Fx.js'
@@ -14,7 +15,7 @@ export function catchAllDefect<R2, E2, B>(f: (defect: unknown) => Fx<R2, E2, B>)
       catchAllCause(
         (cause): Fx<R2, E | E2, B> =>
           pipe(
-            Cause.defects(cause).get(0),
+           Chunk.get(Cause.defects(cause), 0),
             match(() => failCause(cause), f),
           ),
       ),

package/src/operator/continueWith.ts

@@ -1,4 +1,4 @@
-import { suspendSucceed } from '@effect/io/Effect'
+import { suspend } from '@effect/io/Effect'
 
 import { Fx } from '../Fx.js'
 
@@ -24,5 +24,5 @@ class ContinueWithSink<R, E, A, R2, E2, B> {
 
   event = this.sink.event
   error = this.sink.error
-  end = suspendSucceed(() => this.f().run(this.sink))
+  end = suspend(() => this.f().run(this.sink))
 }

package/src/operator/debounce.ts

@@ -27,7 +27,7 @@ class DebounceFx<R, E, A> extends Fx.Variance<R, E, A> implements Fx<R, E, A> {
         return fx.run(
           Fx.Sink(
             (a: A) =>
-              Effect.suspendSucceed(() =>
+              Effect.suspend(() =>
                 pipe(
                   scheduledFiber ? Fiber.interrupt(scheduledFiber) : counter.increment,
                   // eslint-disable-next-line @typescript-eslint/no-unused-vars

package/src/operator/during.ts

@@ -42,7 +42,7 @@ class DuringFx<R, E, A, R2, E2, R3, E3, B>
               signal.run(
                 Fx.Sink(
                   (endSignal) =>
-                    Effect.suspendSucceed(() => {
+                    Effect.suspend(() => {
                       shouldRun = true
 
                       return endSignal.run(Fx.Sink(() => earlyExit, sink.error, earlyExit))

package/src/operator/hold.ts

@@ -34,8 +34,8 @@ 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.suspendSucceed(() => {
-      if (Option.isSome(this.current.get())) {
+    return Effect.suspend(() => {
+      if (Option.isSome(MutableRef.get(this.current))) {
         return pipe(
           this.scheduleFlush(sink),
           Effect.flatMap(() => super.run(sink)),
@@ -47,7 +47,7 @@ export class HoldFx<R, E, A> extends MulticastFx<R, E, A> implements Fx<R, E, A>
   }
 
   event(a: A) {
-    return Effect.suspendSucceed(() => {
+    return Effect.suspend(() => {
       this.addValue(a)
 
       return pipe(
@@ -58,7 +58,7 @@ export class HoldFx<R, E, A> extends MulticastFx<R, E, A> implements Fx<R, E, A>
   }
 
   error(cause: Cause.Cause<E>) {
-    return Effect.suspendSucceed(() =>
+    return Effect.suspend(() =>
       pipe(
         this.flushPending(),
         Effect.flatMap(() => super.error(cause)),
@@ -67,7 +67,7 @@ export class HoldFx<R, E, A> extends MulticastFx<R, E, A> implements Fx<R, E, A>
   }
 
   get end() {
-    return Effect.suspendSucceed(() =>
+    return Effect.suspend(() =>
       pipe(
         this.flushPending(),
         Effect.flatMap(() => super.end),
@@ -76,11 +76,12 @@ export class HoldFx<R, E, A> extends MulticastFx<R, E, A> implements Fx<R, E, A>
   }
 
   protected scheduleFlush(sink: Fx.Sink<any, E, A>) {
-    return Effect.suspendSucceed(() => {
+    return Effect.suspend(() => {
       this.pendingSinks.push([
         sink,
         pipe(
-          this.current.get(),
+          this.current,
+          MutableRef.get,
           Option.match(
             () => [],
             (a) => [a],
@@ -137,7 +138,7 @@ export class HoldFx<R, E, A> extends MulticastFx<R, E, A> implements Fx<R, E, A>
   }
 
   protected addValue(a: A) {
-    this.current.set(Option.some(a))
+    MutableRef.set(this.current, Option.some(a))
     this.pendingSinks.forEach(([, events]) => events.push(a))
   }
 }

package/src/operator/loop.ts

@@ -30,7 +30,7 @@ class LoopSink<R, E, A, B, C> implements Fx.Sink<R, E, A> {
   ) {}
 
   readonly event = (a: A) =>
-    Effect.suspendSucceed(() => {
+    Effect.suspend(() => {
       const [c, b] = this.f(this.acc, a)
 
       this.acc = b

package/src/operator/multicast.ts

@@ -55,13 +55,13 @@ export class MulticastFx<R, E, A>
   }
 
   event(a: A) {
-    return Effect.suspendSucceed(() =>
+    return Effect.suspend(() =>
       Effect.forEachDiscard(this.observers.slice(), (observer) => this.runEvent(a, observer)),
     )
   }
 
   error(cause: Cause<E>) {
-    return Effect.suspendSucceed(() =>
+    return Effect.suspend(() =>
       pipe(
         Effect.forEachDiscard(this.observers.slice(), (observer) => this.runError(cause, observer)),
         Effect.tap(() => this.cleanup()),
@@ -70,7 +70,7 @@ export class MulticastFx<R, E, A>
   }
 
   get end(): Effect.Effect<never, never, void> {
-    return Effect.suspendSucceed(() =>
+    return Effect.suspend(() =>
       pipe(
         this.observers.slice(),
         Effect.forEachDiscard((observer) => this.runEnd(observer)),

package/src/operator/skipRepeats.ts

@@ -22,13 +22,13 @@ class SkipRepeatsWithFx<R, E, A> extends Fx.Variance<R, E, A> implements Fx<R, E
   }
 
   run<R2>(sink: Fx.Sink<R2, E, A>) {
-    return Effect.suspendSucceed(() => {
+    return Effect.suspend(() => {
       let previous: Option.Option<A> = Option.none()
 
       return this.self.run({
         ...sink,
         event: (a) =>
-          Effect.suspendSucceed(() => {
+          Effect.suspend(() => {
             if (Option.isNone(previous) || !this.equals(previous.value, a)) {
               previous = Option.some(a)
 

package/src/operator/switchMatch.ts

@@ -49,7 +49,7 @@ class SwitchMatchFx<R, E, A, R2, E2, B, R3, E3, C>
 
             let firstError = true
 
-            const handleError = Effect.suspendSucceed(() =>
+            const handleError = Effect.suspend(() =>
               firstError ? ((firstError = false), Effect.asUnit(counter.decrement)) : Effect.unit(),
             )
 

package/src/operator/tapDefect.ts

@@ -1,5 +1,6 @@
 import { pipe } from '@effect/data/Function'
 import { match } from '@effect/data/Option'
+import * as Chunk from '@effect/data/Chunk'
 import * as Cause from '@effect/io/Cause'
 import * as Effect from '@effect/io/Effect'
 
@@ -14,7 +15,7 @@ export function tapDefect<R2, E2, B>(f: (defect: unknown) => Effect.Effect<R2, E
       tapCause(
         (cause): Effect.Effect<R2, E | E2, B> =>
           pipe(
-            Cause.defects(cause).get(0),
+            Chunk.get(Cause.defects(cause), 0),
             match(() => Effect.failCause(cause), f),
           ),
       ),

package/src/run/collectAll.ts

@@ -6,7 +6,7 @@ import type { Fx } from '../Fx.js'
 import { reduce } from './reduce.js'
 
 export const collectAll = <R, E, A>(fx: Fx<R, E, A>): Effect.Effect<R, E, readonly A[]> =>
-  Effect.suspendSucceed(() =>
+  Effect.suspend(() =>
     pipe(
       fx,
       reduce([] as A[], (acc, a) => {

package/src/run/collectN.ts

@@ -9,7 +9,7 @@ import { reduce } from './reduce.js'
 export const collectN =
   (amount: number) =>
   <R, E, A>(fx: Fx<R, E, A>): Effect.Effect<R, E, readonly A[]> =>
-    Effect.suspendSucceed(() =>
+    Effect.suspend(() =>
       pipe(
         fx,
         take(amount),

package/src/run/reduce.ts

@@ -9,7 +9,7 @@ export const reduce: <B, A>(
   seed: B,
   f: (acc: B, a: A) => B,
 ) => <R, E>(fx: Fx<R, E, A>) => Effect.Effect<R, E, B> = (seed, f) => (fx) =>
-  Effect.suspendSucceed(() => {
+  Effect.suspend(() => {
     let acc = seed
 
     return pipe(