@typed/fx 0.0.35 → 1.0.2

package/src/constructor/asyncEffect.ts

@@ -0,0 +1,10 @@
+import * as Effect from '@effect/io/Effect'
+import { flow } from '@fp-ts/data/Function'
+
+import { Fx } from '../Fx.js'
+
+import { fromEffect } from './fromEffect.js'
+
+export const asyncEffect: <R, E, A, R2, E2, X>(
+  register: (callback: (_: Effect.Effect<R, E, A>) => void) => Effect.Effect<R2, E2, X>,
+) => Fx<R | R2, E | E2, A> = flow(Effect.asyncEffect, fromEffect)

package/src/constructor/asyncInterrupt.ts

@@ -0,0 +1,13 @@
+import * as Effect from '@effect/io/Effect'
+import { FiberId } from '@effect/io/Fiber/Id'
+
+import { Fx } from '../Fx.js'
+
+import { fromEffect } from './fromEffect.js'
+
+export const asyncInterrupt = <R, E, A>(
+  register: (
+    callback: (effect: Effect.Effect<R, E, A>) => void,
+  ) => Effect.Effect<R, never, void>,
+  blockingOn?: FiberId | undefined,
+): Fx<R, E, A> => fromEffect(Effect.asyncInterrupt<R, E, A>(register, blockingOn))

package/src/constructor/asyncOption.ts

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

package/src/constructor/at.ts

@@ -0,0 +1,11 @@
+import * as Effect from '@effect/io/Effect'
+import { Duration } from '@fp-ts/data/Duration'
+import { pipe } from '@fp-ts/data/Function'
+
+import { Fx } from '../Fx.js'
+
+import { fromEffect } from './fromEffect.js'
+
+export function at<A>(delay: Duration, value: A): Fx<never, never, A> {
+  return pipe(Effect.sleep(delay), Effect.as(value), fromEffect)
+}

package/src/constructor/die.ts

@@ -0,0 +1,8 @@
+import * as Effect from '@effect/io/Effect'
+import { flow } from '@fp-ts/data/Function'
+
+import { Fx } from '../Fx.js'
+
+import { fromEffect } from './fromEffect.js'
+
+export const die: (defect: unknown) => Fx<never, never, never> = flow(Effect.die, fromEffect)

package/src/constructor/dieMessage.ts

@@ -0,0 +1,11 @@
+import * as Effect from '@effect/io/Effect'
+import { flow } from '@fp-ts/data/Function'
+
+import { Fx } from '../Fx.js'
+
+import { fromEffect } from './fromEffect.js'
+
+export const dieMessage: (message: string) => Fx<never, never, never> = flow(
+  Effect.dieMessage,
+  fromEffect,
+)

package/src/constructor/dieSync.ts

@@ -0,0 +1,11 @@
+import * as Effect from '@effect/io/Effect'
+import { flow } from '@fp-ts/data/Function'
+
+import { Fx } from '../Fx.js'
+
+import { fromEffect } from './fromEffect.js'
+
+export const dieSync: (defect: () => unknown) => Fx<never, never, never> = flow(
+  Effect.dieSync,
+  fromEffect,
+)

package/src/constructor/done.ts

@@ -0,0 +1,19 @@
+import * as Effect from '@effect/io/Effect'
+import * as Exit from '@effect/io/Exit'
+import { flow, pipe } from '@fp-ts/data/Function'
+
+import { Fx, Sink } from '../Fx.js'
+
+export function done<E, A>(exit: Exit.Exit<E, A>): Fx<never, E, A> {
+  return new DoneFx(exit)
+}
+
+class DoneFx<E, A> extends Fx.Variance<never, E, A> implements Fx<never, E, A> {
+  constructor(readonly exit: Exit.Exit<E, A>) {
+    super()
+  }
+
+  run<R2>(sink: Sink<R2, E, A>) {
+    return pipe(this.exit, Exit.match(sink.error, flow(sink.event, Effect.zipRight(sink.end))))
+  }
+}

package/src/constructor/empty.ts

@@ -0,0 +1,13 @@
+import { Fx, Sink } from '../Fx.js'
+
+class EmptyFx extends Fx.Variance<never, never, never> implements Fx<never, never, never> {
+  constructor() {
+    super()
+  }
+
+  run<R2>(sink: Sink<R2, never, never>) {
+    return sink.end
+  }
+}
+
+export const empty: Fx<never, never, never> = new EmptyFx()

package/src/constructor/fail.ts

@@ -0,0 +1,8 @@
+import * as Effect from '@effect/io/Effect'
+import { flow } from '@fp-ts/data/Function'
+
+import { Fx } from '../Fx.js'
+
+import { fromEffect } from './fromEffect.js'
+
+export const fail: <E>(error: E) => Fx<never, E, never> = flow(Effect.fail, fromEffect)

package/src/constructor/failCause.ts

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

package/src/constructor/failCauseSync.ts

@@ -0,0 +1,12 @@
+import { Cause } from '@effect/io/Cause'
+import * as Effect from '@effect/io/Effect'
+import { flow } from '@fp-ts/data/Function'
+
+import { 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

@@ -0,0 +1,19 @@
+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.unsafeRunPromise(test)
+
+      deepStrictEqual(events, [1, 2, 3])
+    })
+  })
+})

package/src/constructor/fromArray.ts

@@ -0,0 +1,21 @@
+import * as Effect from '@effect/io/Effect'
+import { pipe } from '@fp-ts/data/Function'
+
+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

@@ -0,0 +1,19 @@
+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.unsafeRunPromise(test)
+
+      deepStrictEqual(events, [1])
+    })
+  })
+})

package/src/constructor/fromEffect.ts

@@ -0,0 +1,21 @@
+import * as Effect from '@effect/io/Effect'
+import { flow } from '@fp-ts/data/Function'
+
+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

@@ -0,0 +1,12 @@
+import * as Effect from '@effect/io/Effect'
+import { Either } from '@fp-ts/data/Either'
+import { flow } from '@fp-ts/data/Function'
+
+import { 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

@@ -0,0 +1,13 @@
+import { Cause } from '@effect/io/Cause'
+import * as Effect from '@effect/io/Effect'
+import { Either } from '@fp-ts/data/Either'
+import { flow } from '@fp-ts/data/Function'
+
+import { 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

@@ -0,0 +1,28 @@
+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.unsafeRunPromise(test)
+
+      deepStrictEqual(events, [1, 2, 3])
+    })
+  })
+})

package/src/constructor/fromEmitter.ts

@@ -0,0 +1,61 @@
+import { 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 { Scope } from '@effect/io/Scope'
+import { pipe } from '@fp-ts/data/Function'
+
+import { Fx } from '../Fx.js'
+
+export interface Emitter<E, A> {
+  readonly emit: (a: A) => Runtime.Cancel<never, unknown>
+  readonly failCause: (e: Cause<E>) => Runtime.Cancel<never, unknown>
+  readonly end: () => Runtime.Cancel<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.unsafeRun(sink.event(a)),
+        failCause: (e) => runtime.unsafeRun(done(Exit.failCause(e))),
+        end: () => runtime.unsafeRun(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

@@ -0,0 +1,12 @@
+import * as Effect from '@effect/io/Effect'
+import { Fiber } from '@effect/io/Fiber'
+import { flow } from '@fp-ts/data/Function'
+
+import { 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

@@ -0,0 +1,11 @@
+import * as Effect from '@effect/io/Effect'
+import { Fiber } from '@effect/io/Fiber'
+import { flow } from '@fp-ts/data/Function'
+
+import { 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

@@ -0,0 +1,26 @@
+import * as Effect from '@effect/io/Effect'
+import { pipe } from '@fp-ts/data/Function'
+
+import { Fx } from '../Fx.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,
+      Effect.matchCauseEffect(sink.error, (fx) => fx.run(sink)),
+    )
+  }
+}

package/src/constructor/fromIterable.test.ts

@@ -0,0 +1,19 @@
+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.unsafeRunPromise(test)
+
+      deepStrictEqual(events, [1, 2, 3])
+    })
+  })
+})

package/src/constructor/fromIterable.ts

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,12 @@
+import * as Effect from '@effect/io/Effect'
+import { flow } from '@fp-ts/data/Function'
+import { Option } from '@fp-ts/data/Option'
+
+import { 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

@@ -0,0 +1,34 @@
+import * as Effect from '@effect/io/Effect'
+import * as Scope from '@effect/io/Scope'
+
+import { 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

@@ -0,0 +1,45 @@
+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 './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/never.ts

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,18 @@
+import * as Effect from '@effect/io/Effect'
+import * as Schedule from '@effect/io/Schedule'
+import { Duration } from '@fp-ts/data/Duration'
+import { pipe } from '@fp-ts/data/Function'
+
+import { 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

@@ -0,0 +1,11 @@
+import * as Effect from '@effect/io/Effect'
+import { flow } from '@fp-ts/data/Function'
+
+import { 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

@@ -0,0 +1,10 @@
+import * as Effect from '@effect/io/Effect'
+import { flow } from '@fp-ts/data/Function'
+
+import { 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)