@typed/fx 1.2.1 → 1.4.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

@@ -48,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)
@@ -80,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)
       }),
@@ -103,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>
 
@@ -128,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> =>
@@ -173,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>
 
@@ -197,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

@@ -31,15 +31,10 @@ export * from './promiseAbort.js'
 export * from './promiseFx.js'
 export * from './random.js'
 export * from './scheduled.js'
-export * from './service.js'
 export * from './serviceWith.js'
 export * from './serviceWithEffect.js'
 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/constructor/serviceWith.ts

@@ -5,6 +5,6 @@ import type { Fx } from '../Fx.js'
 
 import { fromEffect } from './fromEffect.js'
 
-export const serviceWith: <T>(tag: Tag<T>) => <A>(f: (a: T) => A) => Fx<T, never, A> =
+export const serviceWith: <I, T>(tag: Tag<I, T>) => <A>(f: (a: T) => A) => Fx<I, never, A> =
   (tag) => (f) =>
-    fromEffect(Effect.serviceWith(tag, f))
+    fromEffect(Effect.map(tag, f))

package/src/constructor/serviceWithEffect.ts

@@ -5,7 +5,7 @@ import type { Fx } from '../Fx.js'
 
 import { fromEffect } from './fromEffect.js'
 
-export const serviceWithEffect: <T>(
-  tag: Tag<T>,
-) => <R, E, A>(f: (a: T) => Effect.Effect<R, E, A>) => Fx<T | R, E, A> = (tag) => (f) =>
-  fromEffect(Effect.serviceWithEffect(tag, f))
+export const serviceWithEffect: <I, T>(
+  tag: Tag<I, T>,
+) => <R, E, A>(f: (a: T) => Effect.Effect<R, E, A>) => Fx<I | R, E, A> = (tag) => (f) =>
+  fromEffect(Effect.flatMap(tag, f))

package/src/constructor/serviceWithFx.ts

@@ -4,16 +4,16 @@ import * as Effect from '@effect/io/Effect'
 import { Fx } from '../Fx.js'
 
 export const serviceWithFx =
-  <T>(tag: Tag<T>) =>
-  <R, E, A>(f: (t: T) => Fx<R, E, A>): Fx<T | R, E, A> =>
+  <I, S>(tag: Tag<I, S>) =>
+  <R, E, A>(f: (s: S) => Fx<R, E, A>): Fx<I | R, E, A> =>
     new ServiceWithFx(tag, f)
 
-class ServiceWithFx<T, R, E, A> extends Fx.Variance<T | R, E, A> implements Fx<T | R, E, A> {
-  constructor(readonly tag: Tag<T>, readonly f: (a: T) => Fx<R, E, A>) {
+class ServiceWithFx<I, S, R, E, A> extends Fx.Variance<I | R, E, A> implements Fx<I | R, E, A> {
+  constructor(readonly tag: Tag<I, S>, readonly f: (a: S) => Fx<R, E, A>) {
     super()
   }
 
   run<R2>(sink: Fx.Sink<R2, E, A>) {
-    return Effect.serviceWithEffect(this.tag, (a) => this.f(a).run(sink))
+    return Effect.flatMap(this.tag, (a) => this.f(a).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/provideService.ts

@@ -4,18 +4,22 @@ import * as Effect from '@effect/io/Effect'
 
 import { Fx } from '../Fx.js'
 
-export function provideService<S>(tag: Context.Tag<S>) {
+export function provideService<I, S>(tag: Context.Tag<I, S>) {
   return (service: S) => {
-    return <R, E, A>(self: Fx<R | S, E, A>): Fx<Exclude<R, S>, E, A> =>
+    return <R, E, A>(self: Fx<R | I, E, A>): Fx<Exclude<R, I>, E, A> =>
       new ProvideServiceFx(self, tag, service)
   }
 }
 
-class ProvideServiceFx<R, E, A, S>
-  extends Fx.Variance<Exclude<R, S>, E, A>
-  implements Fx<Exclude<R, S>, E, A>
+class ProvideServiceFx<R, E, A, I, S>
+  extends Fx.Variance<Exclude<R, I>, E, A>
+  implements Fx<Exclude<R, I>, E, A>
 {
-  constructor(readonly self: Fx<R | S, E, A>, readonly tag: Context.Tag<S>, readonly service: S) {
+  constructor(
+    readonly self: Fx<R | I, E, A>,
+    readonly tag: Context.Tag<I, S>,
+    readonly service: S,
+  ) {
     super()
   }
 

package/src/operator/provideServiceEffect.ts

@@ -5,21 +5,21 @@ import type { Scope } from '@effect/io/Scope'
 
 import { Fx } from '../Fx.js'
 
-export function provideServiceEffect<S, R2, E2>(
-  tag: Context.Tag<S>,
+export function provideServiceEffect<I, S, R2, E2>(
+  tag: Context.Tag<I, S>,
   service: Effect.Effect<R2, E2, S>,
 ) {
-  return <R, E, A>(self: Fx<R | S, E, A>): Fx<Exclude<R | R2, S>, E | E2, A> =>
+  return <R, E, A>(self: Fx<R | I, E, A>): Fx<Exclude<R | R2, I>, E | E2, A> =>
     new ProvideServiceEffectFx(self, tag, service)
 }
 
-class ProvideServiceEffectFx<R, E, A, R2, E2, S>
-  extends Fx.Variance<Exclude<R | R2, S>, E | E2, A>
-  implements Fx<Exclude<R | R2, S>, E | E2, A>
+class ProvideServiceEffectFx<R, E, A, R2, E2, I, S>
+  extends Fx.Variance<Exclude<R | R2, I>, E | E2, A>
+  implements Fx<Exclude<R | R2, I>, E | E2, A>
 {
   constructor(
-    readonly self: Fx<R | S, E, A>,
-    readonly tag: Context.Tag<S>,
+    readonly self: Fx<R | I, E, A>,
+    readonly tag: Context.Tag<I, S>,
     readonly service: Effect.Effect<R2, E2, S>,
   ) {
     super()
@@ -30,6 +30,6 @@ class ProvideServiceEffectFx<R, E, A, R2, E2, S>
       this.self.run(sink),
       Effect.provideServiceEffect(this.tag, this.service),
       Effect.matchCauseEffect(sink.error, Effect.succeed),
-    ) as Effect.Effect<Exclude<R | R2 | R3 | Scope, S>, never, unknown>
+    ) as Effect.Effect<Exclude<R | R2 | R3 | Scope, I>, never, unknown>
   }
 }

package/src/operator/race.ts

@@ -57,7 +57,7 @@ class RaceAllFx<Streams extends readonly Fx<any, any, any>[]>
                 run(sink.event, sink.error, sink.end),
                 Effect.scheduleForked(asap), // Schedule starts so that all Scopes can be returned *before* attempting to cleanup
                 Effect.as(scope),
-                Effect.provideService(Scope.Tag, scope),
+                Effect.provideService(Scope.Scope, scope),
               ),
             ),
           ),

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(