@typed/fx 0.0.35 → 1.0.2

package/src/Fx.ts

@@ -1,51 +1,71 @@
-import { Cause } from '@effect/core/io/Cause'
-import * as Effect from '@effect/core/io/Effect'
-import { Scope } from '@effect/core/io/Scope'
+import { Cause } from '@effect/io/Cause'
+import { Effect } from '@effect/io/Effect'
+import { Scope } from '@effect/io/Scope'
+import { identity } from '@fp-ts/data/Function'
 
-export interface Fx<R, E, A> {
-  readonly _R: () => R
-  readonly _E: () => E
-  readonly _A: () => A
-
-  run<R2>(emitter: Emitter<R2, E, A>): Effect.Effect<R | R2 | Scope, never, unknown>
+export interface Fx<R, E, A> extends Fx.Variance<R, E, A> {
+  readonly run: <R2>(sink: Fx.Sink<R2, E, A>) => Effect<R | R2 | Scope, never, unknown>
 }
 
-export function Fx<R, E, A>(run: Fx<R, E, A>['run']): Fx<R, E, A> {
-  return {
-    run,
-  } as Fx<R, E, A>
+export function Fx<R, E, A>(
+  run: <R2>(sink: Fx.Sink<R2, E, A>) => Effect<R | R2 | Scope, never, unknown>,
+): Fx<R, E, A> {
+  return new (class extends Fx.Variance<R, E, A> {
+    readonly run = run
+  })()
 }
 
 export namespace Fx {
+  export const TypeId = Symbol.for('@typed/fx/Fx')
+  export type TypeId = typeof TypeId
+
+  export abstract class Variance<R, E, A> {
+    readonly [TypeId]: {
+      readonly _R: (_: never) => R
+      readonly _E: (_: never) => E
+      readonly _A: (_: never) => A
+    } = {
+      _R: identity,
+      _E: identity,
+      _A: identity,
+    }
+  }
+
   /* eslint-disable @typescript-eslint/no-unused-vars */
 
-  export type ResourcesOf<T> = [T] extends [Fx<infer R, infer _E, infer _A>] ? R : never
-  export type ErrorsOf<T> = [T] extends [Fx<infer _R, infer E, infer _A>] ? E : never
-  export type OutputOf<T> = [T] extends [Fx<infer _R, infer _E, infer A>] ? A : never
+  export type ResourcesOf<T> = [T] extends [Variance<infer R, infer _E, infer _A>] ? R : never
+
+  export type ErrorsOf<T> = [T] extends [Variance<infer _R, infer E, infer _A>] ? E : never
+
+  export type OutputOf<T> = [T] extends [Variance<infer _R, infer _E, infer A>] ? A : never
 
   /* eslint-enable @typescript-eslint/no-unused-vars */
-}
 
-export interface Emitter<R, E, A> {
-  readonly emit: (a: A) => Effect.Effect<R, never, unknown>
-  readonly failCause: (e: Cause<E>) => Effect.Effect<R, never, unknown>
-  readonly end: Effect.Effect<R, never, unknown>
-}
+  export interface Sink<out R, in E, in A> {
+    readonly event: (value: A) => Effect<R, never, unknown>
+    readonly error: (error: Cause<E>) => Effect<R, never, unknown>
+    readonly end: Effect<R, never, unknown>
+  }
 
-export function Emitter<R, E, A>(
-  emit: Emitter<R, E, A>['emit'],
-  failCause: Emitter<R, E, A>['failCause'],
-  end: Emitter<R, E, A>['end'],
-): Emitter<R, E, A> {
-  return {
-    emit,
-    failCause,
-    end,
+  export function Sink<A, R, E, R2, R3>(
+    event: (value: A) => Effect<R, never, unknown>,
+    error: (error: Cause<E>) => Effect<R2, never, unknown>,
+    end: Effect<R3, never, unknown>,
+  ): Sink<R | R2 | R3, E, A> {
+    return { event, error, end }
   }
 }
 
-export namespace Emitter {
-  export type ResourcesOf<T> = T extends Emitter<infer R, any, any> ? R : never
-  export type ErrorsOf<T> = T extends Emitter<any, infer E, any> ? E : never
-  export type OutputOf<T> = T extends Emitter<any, any, infer A> ? A : never
+export const TypeId = Fx.TypeId
+export type TypeId = Fx.TypeId
+
+export type ResourcesOf<T> = Fx.ResourcesOf<T>
+export type ErrorOf<T> = Fx.ErrorsOf<T>
+export type OutputOf<T> = Fx.OutputOf<T>
+
+export type Sink<R, E, A> = Fx.Sink<R, E, A>
+export const Sink = Fx.Sink
+
+export function isFx<R, E, A>(v: unknown): v is Fx<R, E, A> {
+  return typeof v === 'object' && v != null && TypeId in v
 }

package/src/Subject/HoldSubject.test.ts

@@ -0,0 +1,58 @@
+import { deepStrictEqual } from 'assert'
+
+import * as Effect from '@effect/io/Effect'
+import * as Fiber from '@effect/io/Fiber'
+import { millis } from '@fp-ts/data/Duration'
+import { describe, it } from 'vitest'
+
+import { collectAll } from '../run/collectAll.js'
+
+import { HoldSubject } from './HoldSubject.js'
+
+describe(import.meta.url, () => {
+  describe('HoldSubject', () => {
+    it('allows replaying latest events to late subscribers', async () => {
+      const test = Effect.gen(function* ($) {
+        const holdSubject = HoldSubject.unsafeMake<never, number>()
+
+        const producer = Effect.gen(function* ($) {
+          yield* $(Effect.sleep(millis(0)))
+          yield* $(holdSubject.event(1))
+          yield* $(Effect.sleep(millis(100)))
+          yield* $(holdSubject.event(2))
+          yield* $(Effect.sleep(millis(100)))
+          yield* $(holdSubject.event(3))
+          yield* $(Effect.sleep(millis(100)))
+          yield* $(holdSubject.event(4))
+          yield* $(Effect.sleep(millis(100)))
+          yield* $(holdSubject.event(5))
+          yield* $(Effect.sleep(millis(100)))
+          yield* $(holdSubject.event(6))
+          yield* $(holdSubject.end)
+        })
+
+        yield* $(Effect.fork(producer))
+
+        const fiber1 = yield* $(Effect.fork(collectAll(holdSubject)))
+
+        yield* $(Effect.sleep(millis(75)))
+
+        const fiber2 = yield* $(Effect.fork(collectAll(holdSubject)))
+
+        yield* $(Effect.sleep(millis(75)))
+
+        const fiber3 = yield* $(Effect.fork(collectAll(holdSubject)))
+
+        const events1 = yield* $(Fiber.join(fiber1))
+        const events2 = yield* $(Fiber.join(fiber2))
+        const events3 = yield* $(Fiber.join(fiber3))
+
+        deepStrictEqual(events1, [1, 2, 3, 4, 5, 6], '1')
+        deepStrictEqual(events2, [1, 2, 3, 4, 5, 6], '2')
+        deepStrictEqual(events3, [2, 3, 4, 5, 6], '3')
+      })
+
+      await Effect.unsafeRunPromise(test)
+    })
+  })
+})

package/src/Subject/HoldSubject.ts

@@ -0,0 +1,61 @@
+import * as Effect from '@effect/io/Effect'
+import { identity } from '@fp-ts/data/Function'
+import { MutableRef, make } from '@fp-ts/data/MutableRef'
+import { Option, none } from '@fp-ts/data/Option'
+
+import { Fx, Sink } from '../Fx.js'
+import { never } from '../constructor/never.js'
+import { HoldFx } from '../operator/hold.js'
+
+import { isSubject, Subject } from './Subject.js'
+
+export interface HoldSubject<E, A>
+  extends Fx<never, E, A>,
+    Sink<never, E, A>,
+    Subject.Variance<E, A>,
+    HoldSubject.Variance<E, A> {
+  readonly value: Effect.Effect<never, never, Option<A>>
+}
+
+export namespace HoldSubject {
+  export const TypeId = Symbol.for('@typed/fx/HoldSubject')
+  export type TypeId = typeof TypeId
+
+  export abstract class Variance<E, A> extends Subject.Variance<E, A> {
+    readonly [TypeId]: {
+      readonly _E: (_: never) => E
+      readonly _A: (_: never) => A
+    } = {
+      _E: identity,
+      _A: identity,
+    }
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  export type ErrorsOf<T> = [T] extends [Variance<infer E, infer _A>] ? E : never
+
+  // 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> {
+    return new HoldSubjectImpl(value)
+  }
+
+  class HoldSubjectImpl<E, A> extends HoldFx<never, E, A> implements HoldSubject<E, A> {
+    readonly [Subject.TypeId]: Subject.Variance<E, A>[Subject.TypeId] = {
+      _E: identity,
+      _A: identity,
+    };
+    readonly [TypeId]: HoldSubject.Variance<E, A>[TypeId] = this[Subject.TypeId]
+
+    constructor(value: MutableRef<Option<A>>) {
+      super(never, value)
+    }
+
+    readonly value = Effect.sync(() => this.current.get())
+  }
+}
+
+export function isHoldSubject<E, A>(u: unknown): u is HoldSubject<E, A> {
+  return isSubject(u) && HoldSubject.TypeId in u
+}

package/src/Subject/RefSubject.ts

@@ -0,0 +1,99 @@
+import * as Effect from '@effect/io/Effect'
+import * as Ref from '@effect/io/Ref'
+import { equals } from '@fp-ts/data/Equal'
+import { identity, pipe } from '@fp-ts/data/Function'
+import * as MutableRef from '@fp-ts/data/MutableRef'
+import * as Option from '@fp-ts/data/Option'
+
+import { Fx } from '../Fx.js'
+
+import { HoldSubject, isHoldSubject } from './HoldSubject.js'
+import { Subject } from './Subject.js'
+
+export interface RefSubject<A> extends HoldSubject<never, A>, Ref.Ref<A> {
+  readonly get: Effect.Effect<never, never, 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, Option.Option<A>>
+}
+
+export function makeRef<A>(
+  initial: () => A,
+  eq: (a: A, b: A) => boolean = equals,
+): Effect.Effect<never, never, RefSubject<A>> {
+  return Effect.sync(() => RefSubject.unsafeMake(initial, eq))
+}
+
+export namespace RefSubject {
+  export function unsafeMake<A>(
+    initial: () => A,
+    eq: (a: A, b: A) => boolean = equals,
+  ): RefSubject<A> {
+    const mutableRef = MutableRef.make(Option.some(initial()))
+    const subject = HoldSubject.unsafeMake<never, A>(mutableRef)
+
+    const getValue = () =>
+      pipe(
+        mutableRef.get(),
+        Option.getOrElse(() => {
+          const a = initial()
+
+          mutableRef.set(Option.some(a))
+
+          return a
+        }),
+      )
+
+    const modify = <B>(f: (a: A) => [B, A]): Effect.Effect<never, never, B> =>
+      Effect.suspendSucceed(() => {
+        const current = getValue()
+        const [b, a] = f(current)
+
+        if (eq(current, a)) {
+          return Effect.succeed(b)
+        }
+
+        mutableRef.set(Option.some(a))
+
+        return pipe(subject.event(a), Effect.as(b))
+      })
+
+    const refSubject: RefSubject<A> = {
+      [Fx.TypeId]: subject[Fx.TypeId],
+      [Subject.TypeId]: subject[Subject.TypeId],
+      [HoldSubject.TypeId]: subject[HoldSubject.TypeId],
+      [Ref.RefTypeId]: {
+        _A: identity,
+      },
+      run: subject.run.bind(subject),
+      event: subject.event.bind(subject),
+      error: subject.error.bind(subject),
+      end: subject.end,
+      value: subject.value,
+      modify,
+      get get() {
+        return Ref.get(refSubject)
+      },
+      set(a: A) {
+        return Ref.updateAndGet(() => a)(refSubject)
+      },
+      update(f: (a: A) => A) {
+        return Ref.updateAndGet(f)(refSubject)
+      },
+      delete: Effect.sync(() => {
+        const option = mutableRef.get()
+
+        // Next pull should recompute the initial value
+        mutableRef.set(Option.none)
+
+        return option
+      }),
+    }
+
+    return refSubject
+  }
+}
+
+export function isRefSubject<A>(u: unknown): u is RefSubject<A> {
+  return isHoldSubject(u) && Ref.RefTypeId in u
+}

package/src/Subject/Subject.test.ts

@@ -0,0 +1,37 @@
+import { deepStrictEqual } from 'assert'
+
+import * as Effect from '@effect/io/Effect'
+import * as Fiber from '@effect/io/Fiber'
+import { describe, it } from 'vitest'
+
+import { collectAll } from '../run/collectAll.js'
+
+import { Subject } from './Subject.js'
+
+describe(import.meta.url, () => {
+  describe('Subject', () => {
+    it('allows broadcastig values directly to observers', async () => {
+      const test = Effect.gen(function* ($) {
+        const subject = Subject.unsafeMake<never, number>()
+
+        const fiber1 = yield* $(Effect.fork(collectAll(subject)))
+        const fiber2 = yield* $(Effect.fork(collectAll(subject)))
+
+        yield* $(Effect.yieldNow())
+
+        yield* $(subject.event(1))
+        yield* $(subject.event(2))
+        yield* $(subject.event(3))
+        yield* $(subject.end)
+
+        const events1 = yield* $(Fiber.join(fiber1))
+        const events2 = yield* $(Fiber.join(fiber2))
+
+        deepStrictEqual(events1, [1, 2, 3])
+        deepStrictEqual(events1, events2)
+      })
+
+      await Effect.unsafeRunPromise(test)
+    })
+  })
+})

package/src/Subject/Subject.ts

@@ -0,0 +1,47 @@
+import { identity } from '@fp-ts/data/Function'
+
+import { Fx, isFx, Sink } from '../Fx.js'
+import { never } from '../constructor/never.js'
+import { MulticastFx } from '../operator/multicast.js'
+
+export interface Subject<E, A> extends Fx<never, E, A>, Sink<never, E, A>, Subject.Variance<E, A> {}
+
+export namespace Subject {
+  export const TypeId = Symbol.for('@typed/fx/Subject')
+  export type TypeId = typeof TypeId
+
+  export abstract class Variance<E, A> extends Fx.Variance<never, E, A> {
+    readonly [TypeId]: {
+      readonly _E: (_: never) => E
+      readonly _A: (_: never) => A
+    } = {
+      _E: identity,
+      _A: identity,
+    }
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  export type ErrorsOf<T> = [T] extends [Variance<infer E, infer _A>] ? E : never
+
+  // 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>(): Subject<E, A> {
+    return new SubjectImpl()
+  }
+
+  class SubjectImpl<E, A> extends MulticastFx<never, E, A> implements Subject<E, A> {
+    readonly [TypeId]: Subject.Variance<E, A>[TypeId] = {
+      _E: identity,
+      _A: identity,
+    }
+
+    constructor() {
+      super(never)
+    }
+  }
+}
+
+export function isSubject<E, A>(u: unknown): u is Subject<E, A> {
+  return isFx(u) && Subject.TypeId in u
+}

package/src/Subject/SynchronizedSubject.ts

@@ -0,0 +1,117 @@
+import * as Effect from '@effect/io/Effect'
+import * as Ref from '@effect/io/Ref'
+import * as Synchronized from '@effect/io/Ref/Synchronized'
+import * as TSemaphore from '@effect/stm/TSemaphore'
+import { equals } from '@fp-ts/data/Equal'
+import { identity, pipe } from '@fp-ts/data/Function'
+import * as MutableRef from '@fp-ts/data/MutableRef'
+import * as Option from '@fp-ts/data/Option'
+
+import { Fx } from '../Fx.js'
+
+import { HoldSubject } from './HoldSubject.js'
+import { isRefSubject, RefSubject } from './RefSubject.js'
+import { Subject } from './Subject.js'
+
+export interface SynchronizedSubject<A> extends RefSubject<A>, Synchronized.Synchronized<A> {
+  readonly updateEffect: <R2, E2>(f: (a: A) => Effect.Effect<R2, E2, A>) => Effect.Effect<R2, E2, A>
+}
+
+export function makeSynchronized<A>(
+  initial: () => A,
+  eq: (a: A, b: A) => boolean = equals,
+): Effect.Effect<never, never, SynchronizedSubject<A>> {
+  return Effect.sync(() => SynchronizedSubject.unsafeMake(initial, eq))
+}
+
+export namespace SynchronizedSubject {
+  export function unsafeMake<A>(
+    initial: () => A,
+    eq: (a: A, b: A) => boolean = equals,
+  ): SynchronizedSubject<A> {
+    const mutableRef = MutableRef.make(Option.some(initial()))
+    const subject = HoldSubject.unsafeMake<never, A>(mutableRef)
+    const semaphore = TSemaphore.unsafeMake(1)
+    const locked = TSemaphore.withPermit(semaphore)
+
+    const getValue = () =>
+      pipe(
+        mutableRef.get(),
+        Option.getOrElse(() => {
+          const a = initial()
+
+          mutableRef.set(Option.some(a))
+
+          return a
+        }),
+      )
+
+    const modifyEffect = <B, R2, E2>(
+      f: (a: A) => Effect.Effect<R2, E2, readonly [B, A]>,
+    ): Effect.Effect<R2, E2, B> =>
+      locked(
+        Effect.gen(function* ($) {
+          const current = getValue()
+          const [b, a] = yield* $(f(current))
+
+          if (eq(current, a)) {
+            return b
+          }
+
+          mutableRef.set(Option.some(a))
+
+          yield* $(subject.event(a))
+
+          return b
+        }),
+      )
+
+    const modify = <B>(f: (a: A) => readonly [B, A]): Effect.Effect<never, never, B> =>
+      modifyEffect((a) => Effect.sync(() => f(a)))
+
+    const synchronizedSubject: SynchronizedSubject<A> = {
+      [Fx.TypeId]: subject[Fx.TypeId],
+      [Subject.TypeId]: subject[Subject.TypeId],
+      [HoldSubject.TypeId]: subject[HoldSubject.TypeId],
+      [Ref.RefTypeId]: {
+        _A: identity,
+      },
+      [Synchronized.SynchronizedTypeId]: {
+        _A: identity,
+      },
+      run: subject.run.bind(subject),
+      event: subject.event.bind(subject),
+      error: subject.error.bind(subject),
+      end: subject.end,
+      value: subject.value,
+      modify,
+      modifyEffect,
+      get get() {
+        return Synchronized.get(synchronizedSubject)
+      },
+      set(a: A) {
+        return Ref.updateAndGet(() => a)(synchronizedSubject)
+      },
+      update(f: (a: A) => A) {
+        return Ref.updateAndGet(f)(synchronizedSubject)
+      },
+      updateEffect<R2, E2>(f: (a: A) => Effect.Effect<R2, E2, A>) {
+        return Synchronized.updateAndGetEffect(f)(synchronizedSubject)
+      },
+      delete: Effect.sync(() => {
+        const option = mutableRef.get()
+
+        // Next pull should recompute the initial value
+        mutableRef.set(Option.none)
+
+        return option
+      }),
+    }
+
+    return synchronizedSubject
+  }
+}
+
+export function isSynchronizedSubject<A>(u: unknown): u is SynchronizedSubject<A> {
+  return isRefSubject(u) && Synchronized.SynchronizedTypeId in u
+}

package/src/Subject/index.ts

@@ -0,0 +1,4 @@
+export * from './HoldSubject.js'
+export * from './RefSubject.js'
+export * from './Subject.js'
+export * from './SynchronizedSubject.js'

package/src/_internal/RefCounter.ts

@@ -0,0 +1,76 @@
+import * as Deferred from '@effect/io/Deferred'
+import * as Effect from '@effect/io/Effect'
+import * as Fiber from '@effect/io/Fiber'
+import * as Ref from '@effect/io/Ref'
+import * as Schedule from '@effect/io/Schedule'
+import { Scope } from '@effect/io/Scope'
+import { millis } from '@fp-ts/data/Duration'
+import { pipe } from '@fp-ts/data/Function'
+
+export const asap = pipe(
+  Schedule.once(),
+  Schedule.delayed(() => millis(0)),
+)
+
+export class RefCounter {
+  protected count = Ref.unsafeMake(this.initial)
+  protected fiber: Fiber.RuntimeFiber<never, void> | undefined
+
+  constructor(readonly initial: number, readonly deferred: Deferred.Deferred<never, void>) {}
+
+  readonly get = Ref.get(this.count)
+
+  readonly increment = pipe(
+    this.count,
+    Ref.updateAndGet((x) => x + 1),
+  )
+
+  readonly decrement = pipe(
+    this.count,
+    Ref.updateAndGet((x) => Math.max(0, x - 1)),
+    Effect.tap(() => this.checkShouldClose),
+  )
+
+  readonly wait = Deferred.await(this.deferred)
+
+  private checkShouldClose = Effect.suspendSucceed(() => {
+    const interrupt = this.fiber ? Fiber.interrupt(this.fiber) : Effect.unit()
+
+    this.fiber = undefined
+
+    return pipe(
+      interrupt,
+      Effect.flatMap(() => Ref.get(this.count)),
+      Effect.flatMap((x) =>
+        Effect.sync(() => {
+          if (x === 0) Deferred.unsafeDone(Effect.unit())(this.deferred)
+        }),
+      ),
+      Effect.scheduleForked(asap),
+      Effect.tap((fiber) =>
+        Effect.sync(() => {
+          this.fiber = fiber
+        }),
+      ),
+    )
+  })
+}
+
+export function withRefCounter<R, E, A, R2, E2, B>(
+  initialCount: number,
+  f: (counter: RefCounter) => Effect.Effect<R, E, A>,
+  onEnd: Effect.Effect<R2, E2, B>,
+): Effect.Effect<R | R2 | Scope, E | E2, B> {
+  return Effect.gen(function* ($) {
+    const deferred = yield* $(Deferred.make<never, void>())
+    const counter = new RefCounter(initialCount, deferred)
+
+    const fiber = yield* $(Effect.forkScoped(f(counter)))
+
+    yield* $(counter.wait)
+
+    yield* $(Fiber.interrupt(fiber))
+
+    return yield* $(onEnd)
+  })
+}

package/src/_internal/earlyExit.ts

@@ -0,0 +1,16 @@
+import * as Effect from '@effect/io/Effect'
+import { pipe } from '@fp-ts/data/Function'
+
+export function withEarlyExit<R, E, A, R2, E2, B>(
+  f: (_: Effect.Effect<never, never, never>) => Effect.Effect<R, E, A>,
+  onEnd: Effect.Effect<R2, E2, B>,
+): Effect.Effect<R | R2, E | E2, A | B> {
+  return Effect.asyncEffect((cb) =>
+    pipe(
+      Effect.sync(() => cb(onEnd)),
+      Effect.flatMap(Effect.never),
+      f,
+      Effect.onExit((exit) => Effect.sync(() => cb(Effect.done(exit)))),
+    ),
+  )
+}

package/src/_internal/entriesOf.ts

@@ -0,0 +1,3 @@
+export function entriesOf<O>(o: O): ReadonlyArray<readonly [keyof O, O[keyof O]]> {
+  return Reflect.ownKeys(o as O & object).map((k) => [k, o[k as keyof typeof o]]) as any
+}

package/src/constructor/Do.ts

@@ -0,0 +1,3 @@
+import { succeed } from './succeed.js'
+
+export const Do = succeed<Readonly<Record<never, never>>>({})

package/src/constructor/acquireUseRelease.ts

@@ -0,0 +1,30 @@
+import * as Effect from '@effect/io/Effect'
+import { pipe } from '@fp-ts/data/Function'
+
+import { Fx } from '../Fx.js'
+
+export const acquireUseRelease =
+  <R, E, A>(acquire: Effect.Effect<R, E, A>) =>
+  <R2>(release: (a: A) => Effect.Effect<R2, never, void>) =>
+  <R3, E3, B>(use: (a: A) => Fx<R3, E3, B>): Fx<R | R2 | R3, E | E3, B> =>
+    new AcquireUseReleaseFx(acquire, release, use)
+
+class AcquireUseReleaseFx<R, E, A, R2, R3, E3, B>
+  extends Fx.Variance<R | R2 | R3, E | E3, B>
+  implements Fx<R | R2 | R3, E | E3, B>
+{
+  constructor(
+    readonly acquire: Effect.Effect<R, E, A>,
+    readonly release: (a: A) => Effect.Effect<R2, never, void>,
+    readonly use: (a: A) => Fx<R3, E3, B>,
+  ) {
+    super()
+  }
+
+  run<R4>(sink: Fx.Sink<R4, E | E3, B>) {
+    return pipe(
+      Effect.acquireUseRelease(this.acquire, (a) => this.use(a).run(sink), this.release),
+      Effect.matchCauseEffect(sink.error, Effect.succeed),
+    )
+  }
+}

package/src/constructor/async.ts

@@ -0,0 +1,12 @@
+import * as Effect from '@effect/io/Effect'
+import { FiberId } from '@effect/io/Fiber/Id'
+import { flow } from '@fp-ts/data/Function'
+
+import { Fx } from '../Fx.js'
+
+import { fromEffect } from './fromEffect.js'
+
+export const async: <R, E, A>(
+  register: (callback: (_: Effect.Effect<R, E, A>) => void) => void,
+  blockingOn?: FiberId | undefined,
+) => Fx<R, E, A> = flow(Effect.async, fromEffect)