@typed/fx 1.5.9 → 1.6.2

package/src/constructor/failCauseSync.ts

@@ -1,12 +0,0 @@
-import { flow } from '@effect/data/Function'
-import type { Cause } from '@effect/io/Cause'
-import * as Effect from '@effect/io/Effect'
-
-import type { Fx } from '../Fx.js'
-
-import { fromEffect } from './fromEffect.js'
-
-export const failCauseSync: <E>(cause: () => Cause<E>) => Fx<never, E, never> = flow(
-  Effect.failCauseSync,
-  fromEffect,
-)

package/src/constructor/fromArray.test.ts

@@ -1,19 +0,0 @@
-import { deepStrictEqual } from 'assert'
-
-import * as Effect from '@effect/io/Effect'
-import { describe, it } from 'vitest'
-
-import { collectAll } from '../run/collectAll.js'
-
-import { fromArray } from './fromArray.js'
-
-describe(import.meta.url, () => {
-  describe(fromArray.name, () => {
-    it('converts an Effect to an Fx', async () => {
-      const test = collectAll(fromArray([1, 2, 3]))
-      const events = await Effect.runPromise(test)
-
-      deepStrictEqual(events, [1, 2, 3])
-    })
-  })
-})

package/src/constructor/fromArray.ts

@@ -1,21 +0,0 @@
-import { pipe } from '@effect/data/Function'
-import * as Effect from '@effect/io/Effect'
-
-import { Fx, Sink } from '../Fx.js'
-
-export function fromArray<A extends ReadonlyArray<any>>(array: A): Fx<never, never, A[number]> {
-  return new FromArrayFx(array)
-}
-
-class FromArrayFx<A extends ReadonlyArray<any>>
-  extends Fx.Variance<never, never, A[number]>
-  implements Fx<never, never, A[number]>
-{
-  constructor(readonly array: A) {
-    super()
-  }
-
-  run<R2>(sink: Sink<R2, never, A>) {
-    return pipe(this.array, Effect.forEachDiscard(sink.event), Effect.zipRight(sink.end))
-  }
-}

package/src/constructor/fromEffect.test.ts

@@ -1,19 +0,0 @@
-import { deepStrictEqual } from 'assert'
-
-import * as Effect from '@effect/io/Effect'
-import { describe, it } from 'vitest'
-
-import { collectAll } from '../run/collectAll.js'
-
-import { fromEffect } from './fromEffect.js'
-
-describe(import.meta.url, () => {
-  describe(fromEffect.name, () => {
-    it('converts an Effect to an Fx', async () => {
-      const test = collectAll(fromEffect(Effect.sync(() => 1)))
-      const events = await Effect.runPromise(test)
-
-      deepStrictEqual(events, [1])
-    })
-  })
-})

package/src/constructor/fromEffect.ts

@@ -1,21 +0,0 @@
-import { flow } from '@effect/data/Function'
-import * as Effect from '@effect/io/Effect'
-
-import { Fx, Sink } from '../Fx.js'
-
-export function fromEffect<R, E, A>(effect: Effect.Effect<R, E, A>): Fx<R, E, A> {
-  return new FromEffect(effect)
-}
-
-class FromEffect<R, E, A> extends Fx.Variance<R, E, A> implements Fx<R, E, A> {
-  constructor(readonly effect: Effect.Effect<R, E, A>) {
-    super()
-  }
-
-  run<R2>(sink: Sink<R2, E, A>) {
-    return Effect.matchCauseEffect(
-      sink.error,
-      flow(sink.event, Effect.zipRight(sink.end)),
-    )(this.effect)
-  }
-}

package/src/constructor/fromEither.ts

@@ -1,12 +0,0 @@
-import type { Either } from '@effect/data/Either'
-import { flow } from '@effect/data/Function'
-import * as Effect from '@effect/io/Effect'
-
-import type { Fx } from '../Fx.js'
-
-import { fromEffect } from './fromEffect.js'
-
-export const fromEither: <E, A>(either: Either<E, A>) => Fx<never, E, A> = flow(
-  Effect.fromEither,
-  fromEffect,
-)

package/src/constructor/fromEitherCause.ts

@@ -1,13 +0,0 @@
-import type { Either } from '@effect/data/Either'
-import { flow } from '@effect/data/Function'
-import type { Cause } from '@effect/io/Cause'
-import * as Effect from '@effect/io/Effect'
-
-import type { Fx } from '../Fx.js'
-
-import { fromEffect } from './fromEffect.js'
-
-export const fromEitherCause: <E, A>(either: Either<Cause<E>, A>) => Fx<never, E, A> = flow(
-  Effect.fromEitherCause,
-  fromEffect,
-)

package/src/constructor/fromEmitter.test.ts

@@ -1,28 +0,0 @@
-import { deepStrictEqual } from 'assert'
-
-import * as Effect from '@effect/io/Effect'
-import { describe, it } from 'vitest'
-
-import { collectAll } from '../run/collectAll.js'
-
-import { fromEmitter } from './fromEmitter.js'
-
-describe(import.meta.url, () => {
-  describe(fromEmitter.name, () => {
-    it('converts an Effect to an Fx', async () => {
-      const test = collectAll(
-        fromEmitter((emitter) =>
-          Effect.sync(() => {
-            emitter.emit(1)
-            emitter.emit(2)
-            emitter.emit(3)
-            emitter.end()
-          }),
-        ),
-      )
-      const events = await Effect.runPromise(test)
-
-      deepStrictEqual(events, [1, 2, 3])
-    })
-  })
-})

package/src/constructor/fromEmitter.ts

@@ -1,61 +0,0 @@
-import { pipe } from '@effect/data/Function'
-import type { Cause } from '@effect/io/Cause'
-import * as Deferred from '@effect/io/Deferred'
-import * as Effect from '@effect/io/Effect'
-import * as Exit from '@effect/io/Exit'
-import * as Fiber from '@effect/io/Fiber'
-import * as Runtime from '@effect/io/Runtime'
-import type { Scope } from '@effect/io/Scope'
-
-import { Fx } from '../Fx.js'
-
-export interface Emitter<E, A> {
-  readonly emit: (a: A) => Fiber.RuntimeFiber<never, unknown>
-  readonly failCause: (e: Cause<E>) => Fiber.RuntimeFiber<never, unknown>
-  readonly end: () => Fiber.RuntimeFiber<never, unknown>
-}
-
-export function fromEmitter<E, A, R, E2>(
-  f: (emitter: Emitter<E, A>) => Effect.Effect<R | Scope, E2, void>,
-): Fx<Exclude<R, Scope>, E | E2, A> {
-  return new FromEmitterFx(f)
-}
-
-class FromEmitterFx<R, E, E2, A>
-  extends Fx.Variance<Exclude<R, Scope>, E | E2, A>
-  implements Fx<Exclude<R, Scope>, E | E2, A>
-{
-  constructor(readonly f: (emitter: Emitter<E, A>) => Effect.Effect<R | Scope, E2, void>) {
-    super()
-  }
-
-  run<R2>(sink: Fx.Sink<R2, E | E2, A>) {
-    const { f } = this
-
-    return Effect.gen(function* ($) {
-      const runtime = yield* $(Effect.runtime<R | R2 | Scope>())
-      const deferred = yield* $(Deferred.make<never, Exit.Exit<E | E2, void>>())
-      const done = (exit: Exit.Exit<E | E2, void>) => Deferred.done(Exit.succeed(exit))(deferred)
-      const emitter: Emitter<E, A> = {
-        emit: (a) => Runtime.runFork(runtime)(sink.event(a)),
-        failCause: (e) => Runtime.runFork(runtime)(done(Exit.failCause(e))),
-        end: () => Runtime.runFork(runtime)(done(Exit.succeed(undefined))),
-      }
-
-      const fiber = yield* $(
-        pipe(f(emitter), Effect.matchCauseEffect(sink.error, Effect.unit), Effect.forkScoped),
-      )
-
-      const exit = yield* $(Deferred.await(deferred))
-
-      yield* $(Fiber.interrupt(fiber))
-
-      return yield* $(
-        pipe(
-          exit,
-          Exit.matchEffect(sink.error, () => sink.end),
-        ),
-      )
-    }) as any
-  }
-}

package/src/constructor/fromFiber.ts

@@ -1,12 +0,0 @@
-import { flow } from '@effect/data/Function'
-import * as Effect from '@effect/io/Effect'
-import type { Fiber } from '@effect/io/Fiber'
-
-import type { Fx } from '../Fx.js'
-
-import { fromEffect } from './fromEffect.js'
-
-export const fromFiber: <E, A>(fiber: Fiber<E, A>) => Fx<never, E, A> = flow(
-  Effect.fromFiber,
-  fromEffect,
-)

package/src/constructor/fromFiberEffect.ts

@@ -1,11 +0,0 @@
-import { flow } from '@effect/data/Function'
-import * as Effect from '@effect/io/Effect'
-import type { Fiber } from '@effect/io/Fiber'
-
-import type { Fx } from '../Fx.js'
-
-import { fromEffect } from './fromEffect.js'
-
-export const fromFiberEffect = flow(Effect.fromFiberEffect, fromEffect) as <R, E, E2, A>(
-  fiber: Effect.Effect<R, E, Fiber<E2, A>>,
-) => Fx<R, E | E2, A>

package/src/constructor/fromFxEffect.ts

@@ -1,31 +0,0 @@
-import { pipe } from '@effect/data/Function'
-import * as Effect from '@effect/io/Effect'
-
-import { Fx } from '../Fx.js'
-import { matchInterruptCause } from '../_internal/matchInterruptCause.js'
-
-export function fromFxEffect<R, E, R2, E2, A>(
-  effect: Effect.Effect<R, E, Fx<R2, E2, A>>,
-): Fx<R | R2, E | E2, A> {
-  return new FromFxEffect(effect)
-}
-
-class FromFxEffect<R, E, R2, E2, A>
-  extends Fx.Variance<R | R2, E | E2, A>
-  implements Fx<R | R2, E | E2, A>
-{
-  constructor(readonly effect: Effect.Effect<R, E, Fx<R2, E2, A>>) {
-    super()
-  }
-
-  run<R3>(sink: Fx.Sink<R3, E | E2, A>) {
-    return pipe(
-      this.effect,
-      matchInterruptCause(
-        sink.error,
-        () => sink.end,
-        (fx) => fx.run(sink),
-      ),
-    )
-  }
-}

package/src/constructor/fromIterable.test.ts

@@ -1,19 +0,0 @@
-import { deepStrictEqual } from 'assert'
-
-import * as Effect from '@effect/io/Effect'
-import { describe, it } from 'vitest'
-
-import { collectAll } from '../run/collectAll.js'
-
-import { fromIterable } from './fromIterable.js'
-
-describe(import.meta.url, () => {
-  describe(fromIterable.name, () => {
-    it('converts an Effect to an Fx', async () => {
-      const test = collectAll(fromIterable([1, 2, 3]))
-      const events = await Effect.runPromise(test)
-
-      deepStrictEqual(events, [1, 2, 3])
-    })
-  })
-})

package/src/constructor/fromIterable.ts

@@ -1,29 +0,0 @@
-import * as Effect from '@effect/io/Effect'
-
-import { Fx, Sink } from '../Fx.js'
-
-export function fromIterable<A>(iterable: Iterable<A>): Fx<never, never, A> {
-  return new FromIterableFx(iterable)
-}
-
-class FromIterableFx<A> extends Fx.Variance<never, never, A> implements Fx<never, never, A> {
-  constructor(readonly iterable: Iterable<A>) {
-    super()
-  }
-
-  run<R2>(sink: Sink<R2, never, A>) {
-    const { iterable } = this
-
-    return Effect.gen(function* ($) {
-      const iterator = iterable[Symbol.iterator]()
-
-      let result = iterator.next()
-      while (!result.done) {
-        yield* $(sink.event(result.value))
-        result = iterator.next()
-      }
-
-      yield* $(sink.end)
-    })
-  }
-}

package/src/constructor/fromOption.ts

@@ -1,12 +0,0 @@
-import { flow } from '@effect/data/Function'
-import type { Option } from '@effect/data/Option'
-import * as Effect from '@effect/io/Effect'
-
-import type { Fx } from '../Fx.js'
-
-import { fromEffect } from './fromEffect.js'
-
-export const fromOption: <A>(option: Option<A>) => Fx<never, Option<never>, A> = flow(
-  Effect.fromOption,
-  fromEffect,
-)

package/src/constructor/gen.ts

@@ -1,34 +0,0 @@
-import * as Effect from '@effect/io/Effect'
-import type * as Scope from '@effect/io/Scope'
-
-import type { Fx } from '../Fx.js'
-
-import { fromFxEffect } from './fromFxEffect.js'
-
-export type EffectAdapter = <R, E, A>(
-  effect: Effect.Effect<R, E, A>,
-) => Generator<Effect.EffectGen<R, E, A>, A, A>
-
-export type EffectGenResources<Eff> = [Eff] extends [never]
-  ? never
-  : [Eff] extends [Effect.EffectGen<infer R, any, any>]
-  ? R
-  : never
-
-export type EffectGenErrors<Eff> = [Eff] extends [never]
-  ? never
-  : [Eff] extends [Effect.EffectGen<any, infer E, any>]
-  ? E
-  : never
-
-/**
- * A helper for running a generator function that yields effects, and returns an Fx.
- * This allows using yield* to represent all of your setup, but then constructing
- * some sort of Fx to represent changes over time. This can be useful for things like
- * initializing a component and/or keeping local states.
- */
-export function gen<Eff extends Effect.EffectGen<any, any, any>, R, E, A, N = unknown>(
-  f: (adapter: EffectAdapter) => Generator<Eff, Fx<R, E, A>, N>,
-): Fx<R | Exclude<EffectGenResources<Eff>, Scope.Scope>, E | EffectGenErrors<Eff>, A> {
-  return fromFxEffect(Effect.gen(f as any))
-}

package/src/constructor/index.ts

@@ -1,40 +0,0 @@
-export * from './acquireUseRelease.js'
-export * from './async.js'
-export * from './asyncEffect.js'
-export * from './asyncInterrupt.js'
-export * from './asyncOption.js'
-export * from './at.js'
-export * from './die.js'
-export * from './dieMessage.js'
-export * from './dieSync.js'
-export * from './Do.js'
-export * from './done.js'
-export * from './empty.js'
-export * from './fail.js'
-export * from './failCause.js'
-export * from './failCauseSync.js'
-export * from './fromArray.js'
-export * from './fromEffect.js'
-export * from './fromEither.js'
-export * from './fromEitherCause.js'
-export * from './fromEmitter.js'
-export * from './fromFiber.js'
-export * from './fromFiberEffect.js'
-export * from './fromFxEffect.js'
-export * from './gen.js'
-export * from './fromIterable.js'
-export * from './fromOption.js'
-export * from './never.js'
-export * from './periodic.js'
-export * from './promise.js'
-export * from './promiseAbort.js'
-export * from './promiseFx.js'
-export * from './random.js'
-export * from './scheduled.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 './unit.js'

package/src/constructor/never.ts

@@ -1,16 +0,0 @@
-import * as Effect from '@effect/io/Effect'
-
-import { Fx, Sink } from '../Fx.js'
-
-class NeverFx extends Fx.Variance<never, never, never> implements Fx<never, never, never> {
-  constructor() {
-    super()
-  }
-
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  run<R2>(_: Sink<R2, never, never>) {
-    return Effect.never()
-  }
-}
-
-export const never: Fx<never, never, never> = new NeverFx()

package/src/constructor/periodic.ts

@@ -1,18 +0,0 @@
-import type { Duration } from '@effect/data/Duration'
-import { pipe } from '@effect/data/Function'
-import * as Effect from '@effect/io/Effect'
-import * as Schedule from '@effect/io/Schedule'
-
-import type { Fx } from '../Fx.js'
-
-import { scheduled } from './scheduled.js'
-
-const schedule_ = (duration: Duration) =>
-  pipe(
-    Schedule.forever(),
-    Schedule.delayed(() => duration),
-  )
-
-export function periodic(duration: Duration): Fx<never, never, void> {
-  return pipe(Effect.unit(), scheduled(schedule_(duration)))
-}

package/src/constructor/promise.ts

@@ -1,11 +0,0 @@
-import { flow } from '@effect/data/Function'
-import * as Effect from '@effect/io/Effect'
-
-import type { Fx } from '../Fx.js'
-
-import { fromEffect } from './fromEffect.js'
-
-export const promise: <A>(evaluate: () => Promise<A>) => Fx<never, never, A> = flow(
-  Effect.promise,
-  fromEffect,
-)

package/src/constructor/promiseAbort.ts

@@ -1,10 +0,0 @@
-import { flow } from '@effect/data/Function'
-import * as Effect from '@effect/io/Effect'
-
-import type { Fx } from '../Fx.js'
-
-import { fromEffect } from './fromEffect.js'
-
-export const promiseInterrupt: <A>(
-  evaluate: (controller: AbortSignal) => Promise<A>,
-) => Fx<never, never, A> = flow(Effect.promiseInterrupt, fromEffect)

package/src/constructor/promiseFx.ts

@@ -1,22 +0,0 @@
-import { pipe } from '@effect/data/Function'
-import * as Effect from '@effect/io/Effect'
-
-import { Fx } from '../Fx.js'
-
-export const promiseFx = <R, E, A>(f: () => Promise<Fx<R, E, A>>): Fx<R, E, A> =>
-  Fx((sink) =>
-    pipe(
-      Effect.promise(f),
-      Effect.matchCauseEffect(sink.error, (fx) => fx.run(sink)),
-    ),
-  )
-
-export const promiseInterruptFx = <R, E, A>(
-  f: (signal: AbortSignal) => Promise<Fx<R, E, A>>,
-): Fx<R, E, A> =>
-  Fx((sink) =>
-    pipe(
-      Effect.promiseInterrupt(f),
-      Effect.matchCauseEffect(sink.error, (fx) => fx.run(sink)),
-    ),
-  )

package/src/constructor/random.ts

@@ -1,9 +0,0 @@
-import { pipe } from '@effect/data/Function'
-import * as Effect from '@effect/io/Effect'
-import type { Random } from '@effect/io/Random'
-
-import type { Fx } from '../Fx.js'
-
-import { fromEffect } from './fromEffect.js'
-
-export const random: Fx<never, never, Random> = pipe(Effect.random(), fromEffect)

package/src/constructor/scheduled.ts

@@ -1,24 +0,0 @@
-import { pipe } from '@effect/data/Function'
-import * as Effect from '@effect/io/Effect'
-import type { Schedule } from '@effect/io/Schedule'
-
-import { Fx } from '../Fx.js'
-
-export function scheduled<R2, O>(schedule: Schedule<R2, any, O>) {
-  return <R, E, A>(effect: Effect.Effect<R, E, A>) => new ScheduledFx(effect, schedule)
-}
-
-class ScheduledFx<R, E, A, R2, O> extends Fx.Variance<R | R2, E, A> {
-  constructor(readonly effect: Effect.Effect<R, E, A>, readonly schedule: Schedule<R2, any, O>) {
-    super()
-  }
-
-  run<R3>(sink: Fx.Sink<R3, E, A>) {
-    return pipe(
-      this.effect,
-      Effect.matchCauseEffect(sink.error, sink.event),
-      Effect.schedule(this.schedule),
-      Effect.zipRight(sink.end),
-    )
-  }
-}

package/src/constructor/serviceWith.ts

@@ -1,10 +0,0 @@
-import type { Tag } from '@effect/data/Context'
-import * as Effect from '@effect/io/Effect'
-
-import type { Fx } from '../Fx.js'
-
-import { fromEffect } from './fromEffect.js'
-
-export const serviceWith: <I, T>(tag: Tag<I, T>) => <A>(f: (a: T) => A) => Fx<I, never, A> =
-  (tag) => (f) =>
-    fromEffect(Effect.map(tag, f))

package/src/constructor/serviceWithEffect.ts

@@ -1,11 +0,0 @@
-import type { Tag } from '@effect/data/Context'
-import * as Effect from '@effect/io/Effect'
-
-import type { Fx } from '../Fx.js'
-
-import { fromEffect } from './fromEffect.js'
-
-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

@@ -1,19 +0,0 @@
-import type { Tag } from '@effect/data/Context'
-import * as Effect from '@effect/io/Effect'
-
-import { Fx } from '../Fx.js'
-
-export const serviceWithFx =
-  <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<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.flatMap(this.tag, (a) => this.f(a).run(sink))
-  }
-}

package/src/constructor/succeed.ts

@@ -1,18 +0,0 @@
-import { pipe } from '@effect/data/Function'
-import { zipRight } from '@effect/io/Effect'
-
-import { Fx } from '../Fx.js'
-
-export function succeed<A>(a: A): Fx<never, never, A> {
-  return new SucceedFx(a)
-}
-
-class SucceedFx<A> extends Fx.Variance<never, never, A> implements Fx<never, never, A> {
-  constructor(private readonly a: A) {
-    super()
-  }
-
-  run<R2>(sink: Fx.Sink<R2, never, A>) {
-    return pipe(sink.event(this.a), zipRight(sink.end))
-  }
-}

package/src/constructor/suspend.ts

@@ -1,15 +0,0 @@
-import { Fx } from '../Fx.js'
-
-export function suspend<R, E, A>(f: () => Fx<R, E, A>): Fx<R, E, A> {
-  return new SuspendFx(f)
-}
-
-class SuspendFx<R, E, A> extends Fx.Variance<R, E, A> implements Fx<R, E, A> {
-  constructor(readonly f: () => Fx<R, E, A>) {
-    super()
-  }
-
-  run<R2>(sink: Fx.Sink<R2, E, A>) {
-    return this.f().run(sink)
-  }
-}

package/src/constructor/sync.ts

@@ -1,8 +0,0 @@
-import { flow } from '@effect/data/Function'
-import * as Effect from '@effect/io/Effect'
-
-import type { Fx } from '../Fx.js'
-
-import { fromEffect } from './fromEffect.js'
-
-export const sync: <A>(evaluate: () => A) => Fx<never, never, A> = flow(Effect.sync, fromEffect)

package/src/constructor/unit.ts

@@ -1,3 +0,0 @@
-import { succeed } from './succeed.js'
-
-export const unit = succeed<void>(undefined)

package/src/operator/as.ts

@@ -1,7 +0,0 @@
-import type { Fx } from '../Fx.js'
-
-import { map } from './map.js'
-
-export function as<B>(value: B): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, B> {
-  return map(() => value)
-}

package/src/operator/asUnit.ts

@@ -1,3 +0,0 @@
-import { as } from './as.js'
-
-export const asUnit = as<void>(undefined)

package/src/operator/catchAll.ts

@@ -1,16 +0,0 @@
-import { match } from '@effect/data/Either'
-import { pipe } from '@effect/data/Function'
-import * as Cause from '@effect/io/Cause'
-
-import type { Fx } from '../Fx.js'
-import { failCause } from '../constructor/failCause.js'
-
-import { catchAllCause } from './catchAllCause.js'
-
-export function catchAll<E, R2, E2, B>(f: (error: E) => Fx<R2, E2, B>) {
-  return <R, A>(fx: Fx<R, E, A>): Fx<R | R2, E2, A | B> =>
-    pipe(
-      fx,
-      catchAllCause((cause) => pipe(cause, Cause.failureOrCause, match(f, failCause))),
-    )
-}