@typed/fx 0.0.8 → 0.0.10

package/src/flatMapConcurrently.ts

@@ -0,0 +1,16 @@
+import * as TSemaphore from '@effect/core/stm/TSemaphore'
+import { flow, pipe } from '@fp-ts/data/Function'
+
+import { Fx } from './Fx.js'
+import { flatMap } from './flatMap.js'
+import { suspendSucceed } from './suspendSucceed.js'
+import { withPermit } from './transform.js'
+
+export function flatMapConcurrently<A, R2, E2, B>(concurrency: number, f: (a: A) => Fx<R2, E2, B>) {
+  return <R, E>(fx: Fx<R, E, A>): Fx<R | R2, E | E2, B> =>
+    suspendSucceed(() => pipe(fx, flatMap(flow(f, withPermit(TSemaphore.unsafeMake(concurrency))))))
+}
+
+export function concatMap<A, R2, E2, B>(f: (a: A) => Fx<R2, E2, B>) {
+  return <R, E>(fx: Fx<R, E, A>): Fx<R | R2, E | E2, B> => pipe(fx, flatMapConcurrently(1, f))
+}

package/src/fromEffect.ts

@@ -0,0 +1,112 @@
+import * as Cause from '@effect/core/io/Cause'
+import { Clock } from '@effect/core/io/Clock'
+import * as Effect from '@effect/core/io/Effect'
+import { Exit } from '@effect/core/io/Exit'
+import { Fiber } from '@effect/core/io/Fiber'
+import { FiberId } from '@effect/core/io/FiberId'
+import { LazyArg, flow, pipe } from '@fp-ts/data/Function'
+import { Either } from '@tsplus/stdlib/data/Either'
+import { Maybe } from '@tsplus/stdlib/data/Maybe'
+import { Env } from '@tsplus/stdlib/service/Env'
+import { Tag } from '@tsplus/stdlib/service/Tag'
+
+import { Fx } from './Fx.js'
+
+export function fromEffect<R, E, A>(effect: Effect.Effect<R, E, A>): Fx<R, E, A> {
+  return Fx((emitter) =>
+    pipe(
+      effect,
+      Effect.foldCauseEffect(emitter.failCause, flow(emitter.emit, Effect.zipRight(emitter.end))),
+    ),
+  )
+}
+
+export const succeed = flow(Effect.succeed, fromEffect)
+
+export const failCause: <E>(cause: Cause.Cause<E>) => Fx<never, E, never> = flow(
+  Effect.failCause,
+  fromEffect,
+)
+
+export const fail: <E>(e: E) => Fx<never, E, never> = flow(Effect.fail, fromEffect)
+
+export const unit: Fx<never, never, void> = fromEffect(Effect.unit)
+
+export const never: Fx<never, never, never> = fromEffect(Effect.never)
+
+export const interrupt = fromEffect(Effect.interrupt)
+export const interruptAs: (fiberId: FiberId) => Fx<never, never, never> = flow(
+  Effect.interruptAs,
+  fromEffect,
+)
+
+export const die = flow(Effect.die, fromEffect)
+export const dieMessage = flow(Effect.dieMessage, fromEffect)
+export const dieSync: <A>(f: LazyArg<A>) => Fx<never, never, never> = flow(
+  Effect.dieSync,
+  fromEffect,
+)
+
+export const done: <E, A>(exit: Exit<E, A>) => Fx<never, E, A> = flow(Effect.done, fromEffect)
+
+export const fromEither: <E, A>(either: Either<E, A>) => Fx<never, E, A> = flow(
+  Effect.fromEither,
+  fromEffect,
+)
+
+export const succeedLeft: <A>(value: A) => Fx<never, never, Either<A, never>> = flow(
+  Effect.succeedLeft,
+  fromEffect,
+)
+
+export const succeedRight: <A>(value: A) => Fx<never, never, Either<never, A>> = flow(
+  Effect.succeedRight,
+  fromEffect,
+)
+
+export const yieldNow = fromEffect(Effect.yieldNow)
+
+export const tryPromise: <A>(promise: LazyArg<Promise<A>>) => Fx<never, unknown, A> = flow(
+  Effect.tryPromise,
+  fromEffect,
+)
+
+export const tryCatchPromise: <A, E>(
+  promise: LazyArg<Promise<A>>,
+  onThrow: (u: unknown) => E,
+) => Fx<never, E, A> = flow(Effect.tryPromise, fromEffect)
+
+export const tryCatch: <A, E>(f: LazyArg<A>, onThrow: (u: unknown) => E) => Fx<never, E, A> = flow(
+  Effect.tryCatch,
+  fromEffect,
+)
+
+export const sync: <A>(f: LazyArg<A>) => Fx<never, never, A> = flow(Effect.sync, fromEffect)
+
+export const async = flow(Effect.async, fromEffect)
+
+export const asyncEffect = flow(Effect.asyncEffect, fromEffect)
+
+export const asyncInterrupt = flow(Effect.asyncInterrupt, fromEffect)
+
+export const asyncMaybe: <R, E, A>(
+  register: (callback: (_: Effect.Effect<R, E, A>) => void) => Maybe<Effect.Effect<R, E, A>>,
+) => Fx<R, E, A> = flow(Effect.asyncMaybe, fromEffect)
+
+export const clock: Fx<never, never, Clock> = fromEffect(Effect.clock)
+
+export const environment = <R>(): Fx<R, never, Env<R>> => fromEffect(Effect.environment<R>())
+
+export const service = <R>(tag: Tag<R>): Fx<R, never, R> => fromEffect(Effect.service<R>(tag))
+
+export const environmentWith = flow(Effect.environmentWith, fromEffect)
+export const environmentWithEffect = flow(Effect.environmentWithEffect, fromEffect)
+
+export const descriptor: Fx<never, never, Fiber.Descriptor> = fromEffect(Effect.descriptor)
+
+export const descriptorWith = flow(Effect.descriptorWith, fromEffect)
+
+export const fromFiber = flow(Effect.fromFiber, fromEffect)
+export const fromFiberEffect = flow(Effect.fromFiberEffect, fromEffect)
+
+export const fromMaybe = flow(Effect.fromMaybe, fromEffect)

package/src/fromIterable.ts

@@ -0,0 +1,15 @@
+import * as Effect from '@effect/core/io/Effect'
+
+import { Emitter, Fx } from './Fx.js'
+
+export function fromIterable<A>(iterable: Iterable<A>): Fx<never, never, A> {
+  return new FromIterable(iterable)
+}
+
+export class FromIterable<A> implements Fx<never, never, A> {
+  constructor(readonly iterable: Iterable<A>) {}
+
+  run<R2>(emitter: Emitter<R2, never, A>) {
+    return Effect.zipRight(emitter.end)(Effect.forEachDiscard(this.iterable, emitter.emit))
+  }
+}

package/src/hold.test.ts

@@ -0,0 +1,49 @@
+import { deepStrictEqual } from 'assert'
+
+import * as Effect from '@effect/core/io/Effect'
+import * as Fiber from '@effect/core/io/Fiber'
+import { pipe } from '@fp-ts/data/Function'
+import * as Duration from '@tsplus/stdlib/data/Duration'
+
+import * as Fx from './index.js'
+
+describe(import.meta.url, () => {
+  describe('hold', () => {
+    it('emits values to late observers', async () => {
+      const value = Math.random()
+
+      let started = 0
+      const fx = pipe(
+        Fx.fromEffect(Effect.sync(() => started++)),
+        Fx.flatMap(() =>
+          Fx.mergeAll([
+            Fx.at(Duration.millis(0))(value),
+            Fx.at(Duration.millis(100))(value + 1),
+            Fx.at(Duration.millis(200))(value + 2),
+          ]),
+        ),
+        Fx.hold,
+      )
+
+      const test = Effect.gen(function* ($) {
+        const a = yield* $(Effect.fork(Fx.runCollect(fx)))
+
+        yield* $(Effect.sleep(Duration.millis(50)))
+
+        const b = yield* $(Effect.fork(Fx.runCollect(fx)))
+
+        yield* $(Effect.sleep(Duration.millis(100)))
+
+        const c = yield* $(Effect.fork(Fx.runCollect(fx)))
+
+        deepStrictEqual(yield* $(Fiber.join(a)), [value, value + 1, value + 2])
+        deepStrictEqual(yield* $(Fiber.join(b)), [value, value + 1, value + 2])
+        deepStrictEqual(yield* $(Fiber.join(c)), [value + 1, value + 2])
+
+        deepStrictEqual(started, 1)
+      })
+
+      await Effect.unsafeRunPromise(test)
+    })
+  })
+})

package/src/hold.ts

@@ -0,0 +1,132 @@
+import { Cause } from '@effect/core/io/Cause'
+import * as Effect from '@effect/core/io/Effect'
+import * as Fiber from '@effect/core/io/Fiber'
+import * as FiberId from '@effect/core/io/FiberId'
+import { Scope } from '@effect/core/io/Scope'
+import { pipe } from '@fp-ts/data/Function'
+import * as Duration from '@tsplus/stdlib/data/Duration'
+import * as Maybe from '@tsplus/stdlib/data/Maybe'
+
+import { Emitter, Fx } from './Fx.js'
+import { Multicast, MulticastObserver } from './multicast.js'
+
+export function hold<R, E, A>(fx: Fx<R, E, A>): Fx<R, E, A> {
+  return new Hold(fx)
+}
+
+export class Hold<R, E, A> extends Multicast<R, E, A> {
+  protected _value: Maybe.Maybe<A> = Maybe.none
+  protected _pendingEmitters: Array<readonly [Emitter<unknown, E, A>, A[]]> = []
+  protected _scheduledFiber: Fiber.RealFiber<any, any> | undefined
+
+  constructor(readonly fx: Fx<R, E, A>) {
+    super(fx)
+  }
+
+  run<R2>(emitter: Emitter<R2, E, A>): Effect.Effect<R | R2 | Scope, never, unknown> {
+    if (this.shouldScheduleFlush()) {
+      return pipe(
+        this.scheduleFlush(emitter),
+        Effect.flatMap(() => super.run(emitter)),
+      )
+    }
+
+    return super.run(emitter)
+  }
+
+  emit(value: A) {
+    return Effect.suspendSucceed(() => {
+      this.addValue(value)
+
+      return pipe(
+        this.flushPending(),
+        Effect.flatMap(() => super.emit(value)),
+      )
+    })
+  }
+
+  failCause(cause: Cause<E>) {
+    return Effect.suspendSucceed(() =>
+      pipe(
+        this.flushPending(),
+        Effect.flatMap(() => super.failCause(cause)),
+      ),
+    )
+  }
+
+  get end() {
+    return Effect.suspendSucceed(() =>
+      pipe(
+        this.flushPending(),
+        Effect.flatMap(() => super.end),
+      ),
+    )
+  }
+
+  protected shouldScheduleFlush() {
+    return Maybe.isSome(this._value) && this.observers.length > 0
+  }
+
+  protected scheduleFlush<R>(observer: Emitter<R, E, A>) {
+    this._pendingEmitters.push([
+      observer,
+      pipe(
+        this._value,
+        Maybe.fold(
+          () => [],
+          (a) => [a],
+        ),
+      ),
+    ])
+
+    const interrupt = this._scheduledFiber
+      ? this._scheduledFiber.interruptAsFork(new FiberId.None())
+      : Effect.unit
+
+    this._scheduledFiber = undefined
+
+    return pipe(
+      interrupt,
+      Effect.flatMap(() => this.flushPending()),
+      Effect.delay(Duration.millis(0)),
+      Effect.forkScoped,
+      Effect.tap((fiber: Fiber.RealFiber<any, any>) =>
+        Effect.sync(() => (this._scheduledFiber = fiber)),
+      ),
+    )
+  }
+
+  protected flushPending() {
+    if (this._pendingEmitters.length === 0) {
+      return Effect.unit
+    }
+
+    const pendingEmitters = this._pendingEmitters
+    this._pendingEmitters = []
+
+    return Effect.forEachDiscard(pendingEmitters, (pending) =>
+      Effect.suspendSucceed(() => {
+        const [emitter, values] = pending
+        const observer = this.findObserver(emitter)
+
+        if (!observer) {
+          return Effect.unit
+        }
+
+        return Effect.forEachDiscard(values, (value) => this.runEvent(value, observer))
+      }),
+    )
+  }
+
+  protected addValue(value: A) {
+    this._value = Maybe.some(value)
+
+    this._pendingEmitters.forEach(([, values]) => {
+      values.push(value)
+    })
+  }
+
+  protected findObserver(emitter: Emitter<unknown, E, A>): MulticastObserver<E, A> | undefined {
+    return this.observers.find((o) => o.emitter === emitter)
+  }
+}

package/src/index.ts

@@ -1,36 +1,40 @@
-export * as Atomic from './Atomic/index.js'
-export * as Cause from './Cause/index.js'
-export * as Clock from './Clock/index.js'
-export * as Disposable from './Disposable/index.js'
-export * as Duration from './Duration/index.js'
-export * as Env from './Env/index.js'
-export * as Exit from './Exit/index.js'
-export * as Fiber from './Fiber/index.js'
-export * as FiberContext from './FiberContext/index.js'
-export * as FiberId from './FiberId/index.js'
-export * as FiberRef from './FiberRef/index.js'
-export * as FiberRefs from './FiberRefs/index.js'
-export * as FiberRuntime from './FiberRuntime/index.js'
-export * as FiberStatus from './FiberStatus/index.js'
-export * as Finalizer from './Finalizer/index.js'
-export * as Future from './Future/index.js'
-export * as Fx from './Fx/index.js'
-export * from './Fx/index.js'
-export * as ImmutableMap from './ImmutableMap/index.js'
-export * as Layer from './Layer/index.js'
-export * as Logger from './Logger/index.js'
-export * as Platform from './Platform/index.js'
-export * as Runtime from './Runtime/index.js'
-export * as Schedule from './Schedule/index.js'
-export * as Scheduler from './Scheduler/index.js'
-export * as Scope from './Scope/index.js'
-export * as Semaphore from './Semaphore/index.js'
-export * as Service from './Service/index.js'
-export * as Stack from './Stack/index.js'
-export * as StackFrame from './StackFrame/index.js'
-export * as Supervisor from './Supervisor/index.js'
-export * as Tagged from './Tagged/index.js'
-export * as Time from './Time/index.js'
-export * as Timeline from './Timeline/index.js'
-export * as Timer from './Timer/index.js'
-export * as Trace from './Trace/index.js'
+export * from './combine.js'
+export * from './continueWith.js'
+export * from './debounce.js'
+export * from './delay.js'
+export * from './during.js'
+export * from './filterLoop.js'
+export * from './filterMap.js'
+export * from './flatMap.js'
+export * from './flatMapConcurrently.js'
+export * from './fromEffect.js'
+export * from './fromIterable.js'
+export * from './Fx.js'
+export * from './hold.js'
+export * from './mapCause.js'
+export * from './mapEffect.js'
+export * from './merge.js'
+export * from './multicast.js'
+export * from './orElse.js'
+export * from './periodic.js'
+export * from './provide.js'
+export * from './runCollect.js'
+export * from './runDrain.js'
+export * from './runObserve.js'
+export * from './runReduce.js'
+export * from './scheduled.js'
+export * from './since.js'
+export * from './skipRepeats.js'
+export * from './skipWhile.js'
+export * from './slice.js'
+export * from './snapshot.js'
+export * from './suspendSucceed.js'
+export * from './switchMap.js'
+export * from './takeWhile.js'
+export * from './tapEffect.js'
+export * from './throttle.js'
+export * from './transform.js'
+export * from './until.js'
+export * from './withEmitter.js'
+export * from './zip.js'
+export * from './zipIterable.js'

package/src/mapCause.test.ts

@@ -0,0 +1,34 @@
+import { deepEqual } from 'assert'
+
+import * as Cause from '@effect/core/io/Cause'
+import * as Effect from '@effect/core/io/Effect'
+import * as Exit from '@effect/core/io/Exit'
+import { pipe } from '@fp-ts/data/Function'
+
+import * as Fx from './index.js'
+
+describe(import.meta.url, () => {
+  describe(Fx.mapCause.name, () => {
+    it('maps the cause', async () => {
+      const value = Math.random()
+      const cause = Cause.fail(value)
+      const test = pipe(Fx.failCause(cause), Fx.mapCause(Cause.map((x) => x + 1)), Fx.runDrain)
+
+      deepEqual(await Effect.unsafeRunPromiseExit(test), Exit.fail(value + 1))
+    })
+  })
+
+  describe(Fx.mapError.name, () => {
+    it('maps the error', async () => {
+      const value = Math.random()
+      const cause = Cause.fail(value)
+      const test = pipe(
+        Fx.failCause(cause),
+        Fx.mapError((x) => x + 1),
+        Fx.runDrain,
+      )
+
+      deepEqual(await Effect.unsafeRunPromiseExit(test), Exit.fail(value + 1))
+    })
+  })
+})

package/src/mapCause.ts

@@ -0,0 +1,16 @@
+import * as Cause from '@effect/core/io/Cause'
+import { flow } from '@fp-ts/data/Function'
+
+import { Emitter, Fx } from './Fx.js'
+
+export function mapCause<E, E2>(f: (cause: Cause.Cause<E>) => Cause.Cause<E2>) {
+  return <R, A>(fx: Fx<R, E, A>): Fx<R, E2, A> => mapCause_(fx, f)
+}
+
+export function mapError<E, E2>(f: (error: E) => E2) {
+  return <R, A>(fx: Fx<R, E, A>): Fx<R, E2, A> => mapCause_(fx, Cause.map(f))
+}
+
+function mapCause_<R, E, A, E2>(fx: Fx<R, E, A>, f: (cause: Cause.Cause<E>) => Cause.Cause<E2>) {
+  return Fx((emitter) => fx.run(Emitter(emitter.emit, flow(f, emitter.failCause), emitter.end)))
+}

package/src/mapEffect.test.ts

@@ -0,0 +1,21 @@
+import { deepEqual } from 'assert'
+
+import * as Effect from '@effect/core/io/Effect'
+import { pipe } from '@fp-ts/data/Function'
+
+import * as Fx from './index.js'
+
+describe(import.meta.url, () => {
+  describe(Fx.mapEffect.name, () => {
+    it('applies an Effect to the output value of a Fx', async () => {
+      const value = Math.random()
+      const test = pipe(
+        Fx.succeed(value),
+        Fx.mapEffect((a) => Effect.succeed(a + 1)),
+        Fx.runCollect,
+      )
+
+      deepEqual(await Effect.unsafeRunPromise(test), [value + 1])
+    })
+  })
+})

package/src/mapEffect.ts

@@ -0,0 +1,17 @@
+import * as Effect from '@effect/core/io/Effect'
+import { flow } from '@fp-ts/data/Function'
+
+import { Emitter, Fx } from './Fx.js'
+
+export const mapEffect =
+  <A, R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>) =>
+  <R, E>(fx: Fx<R, E, A>): Fx<R | R2, E | E2, B> =>
+    Fx((emitter) =>
+      fx.run(
+        Emitter(
+          flow(f, Effect.foldCauseEffect(emitter.failCause, emitter.emit)),
+          emitter.failCause,
+          emitter.end,
+        ),
+      ),
+    )

package/src/merge.test.ts

@@ -0,0 +1,21 @@
+import { deepStrictEqual } from 'assert'
+
+import * as Effect from '@effect/core/io/Effect'
+import { pipe } from '@fp-ts/data/Function'
+
+import * as Fx from './index.js'
+
+describe(import.meta.url, () => {
+  describe(Fx.mergeAll.name, () => {
+    it('merges together emits', async () => {
+      const result = await pipe(
+        Fx.mergeAll([Fx.fromIterable([1, 2, 3]), Fx.fromIterable([4, 5, 6])]),
+        Fx.runCollect,
+
+        Effect.unsafeRunPromise,
+      )
+
+      deepStrictEqual(result, [1, 2, 3, 4, 5, 6])
+    })
+  })
+})

package/src/merge.ts

@@ -0,0 +1,29 @@
+import * as Effect from '@effect/core/io/Effect'
+
+import { Emitter, Fx } from './Fx.js'
+import { withDynamicCountdownLatch } from './_internal.js'
+
+export function merge<R2, E2, B>(second: Fx<R2, E2, B>) {
+  return <R, E, A>(first: Fx<R, E, A>): Fx<R | R2, E | E2, A | B> => mergeAll([first, second])
+}
+
+export function mergeAll<FX extends ReadonlyArray<Fx<any, any, any>>>(
+  fx: readonly [...FX],
+): Fx<Fx.ResourcesOf<FX[number]>, Fx.ErrorsOf<FX[number]>, Fx.OutputOf<FX[number]>>
+
+export function mergeAll<R, E, A>(iterable: Iterable<Fx<R, E, A>>): Fx<R, E, A>
+
+export function mergeAll<R, E, A>(iterable: Iterable<Fx<R, E, A>>): Fx<R, E, A> {
+  return Fx((emitter) => {
+    const array = Array.from(iterable)
+
+    return withDynamicCountdownLatch(
+      array.length,
+      ({ latch }) =>
+        Effect.forEachDiscard(array, (fx) =>
+          Effect.forkScoped(fx.run(Emitter(emitter.emit, emitter.failCause, latch.countDown))),
+        ),
+      emitter.end,
+    )
+  })
+}

package/src/multicast.test.ts

@@ -0,0 +1,52 @@
+import { deepStrictEqual } from 'assert'
+
+import * as Effect from '@effect/core/io/Effect'
+import { pipe } from '@fp-ts/data/Function'
+import * as Duration from '@tsplus/stdlib/data/Duration'
+
+import * as Fx from './index.js'
+
+describe(import.meta.url, () => {
+  describe('multicast', () => {
+    it('should not change the underlying stream', async () => {
+      const values = [1, 2, 3]
+      let started = 0
+      const test = pipe(
+        Fx.suspendSucceed(() => {
+          started++
+          return pipe(
+            Fx.fromIterable(values),
+            Fx.flatMap((a) =>
+              pipe(
+                Fx.fromIterable([a, a + 1]),
+                Fx.merge(pipe(Fx.fromIterable([a * a, a ** a]), Fx.delay(Duration.millis(50)))),
+              ),
+            ),
+          )
+        }),
+        Fx.multicast,
+      )
+      const events = pipe(test, Fx.runCollect, Effect.unsafeRunPromise)
+      const events2 = pipe(test, Fx.runCollect, Effect.unsafeRunPromise)
+
+      deepStrictEqual(await events, [
+        1,
+        1 + 1,
+        2,
+        2 + 1,
+        3,
+        3 + 1,
+        1 * 1,
+        2 * 2,
+        3 * 3,
+        1 ** 1,
+        2 ** 2,
+        3 ** 3,
+      ])
+
+      deepStrictEqual(await events, await events2)
+
+      deepStrictEqual(started, 1)
+    })
+  })
+})