@typed/fx 0.0.6 → 0.0.9

package/src/index.ts

@@ -1,36 +1,37 @@
-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 './drain.js'
+export * from './during.js'
+export * from './empty.js'
+export * from './flatMap.js'
+export * from './flatMapConcurrently.js'
+export * from './from.js'
+export * from './fromCallback.js'
+export * from './fromEffect.js'
+export * from './hold.js'
+export * from './loop.js'
+export * from './map.js'
+export * from './merge.js'
+export * from './never.js'
+export * from './observe.js'
+export * from './orElse.js'
+export * from './periodic.js'
+export * from './provide.js'
+export * from './reduce.js'
+export * from './scheduled.js'
+export * from './since.js'
+export * as Sink from './Sink.js'
+export * from './skipRepeats.js'
+export * from './slice.js'
+export * from './snapshot.js'
+export * from './Fx.js'
+export * from './suspendSucceed.js'
+export * from './switchMap.js'
+export * from './tap.js'
+export * from './throttle.js'
+export * from './TSemaphore.js'
+export * from './until.js'
+export * from './transform.js'
+export * from './zipItems.js'

package/src/loop.ts

@@ -0,0 +1,37 @@
+import { Fx } from './Fx.js'
+import { Sink } from './Sink.js'
+
+export function loop<A, B, C>(seed: A, f: (a: A, b: B) => readonly [C, A]) {
+  return <R, E, E1>(fx: Fx<R, E, B, E1>): Fx<R, E, C, E1> => new LoopFx(fx, seed, f)
+}
+
+export function scan<A, B>(seed: A, f: (a: A, b: B) => A) {
+  return loop(seed, (a, b: B) => {
+    const x = f(a, b)
+    return [x, x]
+  })
+}
+
+class LoopFx<R, E, E1, A, B, C> implements Fx<R, E, C, E1> {
+  constructor(
+    readonly fx: Fx<R, E, B, E1>,
+    readonly seed: A,
+    readonly f: (a: A, b: B) => readonly [C, A],
+  ) {}
+
+  readonly run: Fx<R, E, C, E1>['run'] = (sink) => {
+    let acc = this.seed
+
+    return this.fx.run(
+      Sink(
+        (b) => {
+          const [c, a] = this.f(acc, b)
+          acc = a
+          return sink.event(c)
+        },
+        sink.error,
+        sink.end,
+      ),
+    )
+  }
+}

package/src/map.ts

@@ -0,0 +1,83 @@
+import * as Effect from '@effect/core/io/Effect'
+import { flow, identity, pipe } from '@fp-ts/data/Function'
+import { Predicate } from '@fp-ts/data/Predicate'
+import { Refinement } from '@fp-ts/data/Refinement'
+import * as Maybe from '@tsplus/stdlib/data/Maybe'
+
+import { Fx } from './Fx.js'
+import * as Sink from './Sink.js'
+import { FromEffectFx } from './fromEffect.js'
+
+export function map<A, B>(f: (a: A) => B) {
+  return <R, E, E1>(fx: Fx<R, E, A, E1>): Fx<R, E, B, E1> => MapFx.make(fx, f)
+}
+
+export function as<B>(b: B) {
+  return <R, E, A, E1>(fx: Fx<R, E, A, E1>): Fx<R, E, B, E1> => map(() => b)(fx)
+}
+
+export function asUnit<R, E, A, E1>(fx: Fx<R, E, A, E1>): Fx<R, E, void, E1> {
+  return as<void>(undefined)(fx)
+}
+
+export class MapFx<R, E, A, B, E1> implements Fx<R, E, B, E1> {
+  constructor(readonly fx: Fx<R, E, A, E1>, readonly f: (a: A) => B) {}
+
+  run<R2, E2, C>(sink: Sink.Sink<E, B, R2, E2, C>): Effect.Effect<R | R2, E1 | E2, C> {
+    return this.fx.run(Sink.mapInputEvent(this.f)(sink))
+  }
+
+  static make = <R, E, A, B, E1>(fx: Fx<R, E, A, E1>, f: (a: A) => B): Fx<R, E, B, E1> => {
+    if (fx instanceof MapFx) {
+      return new MapFx(fx.fx, flow(fx.f, f))
+    }
+
+    if (fx instanceof FromEffectFx) {
+      return new FromEffectFx(pipe(fx.effect, Effect.map(f)))
+    }
+
+    if (fx instanceof FilterMapFx) {
+      return FilterMapFx.make(fx.fx, flow(fx.f, Maybe.map(f)))
+    }
+
+    return new MapFx(fx, f)
+  }
+}
+
+export function filterMap<A, B>(f: (a: A) => Maybe.Maybe<B>) {
+  return <R, E, E1>(fx: Fx<R, E, A, E1>): Fx<R, E, B, E1> => FilterMapFx.make(fx, f)
+}
+
+export function filter<A, B extends A>(
+  predicate: Refinement<A, B>,
+): <R, E, E1>(fx: Fx<R, E, A, E1>) => Fx<R, E, B, E1>
+export function filter<A>(
+  predicate: Predicate<A>,
+): <R, E, E1>(fx: Fx<R, E, A, E1>) => Fx<R, E, A, E1>
+
+export function filter<A>(predicate: Predicate<A>) {
+  return filterMap((a: A) => Maybe.fromPredicate(a, predicate))
+}
+
+export function compact<R, E, A, E1>(fx: Fx<R, E, Maybe.Maybe<A>, E1>): Fx<R, E, A, E1> {
+  return pipe(fx, filterMap(identity))
+}
+
+export class FilterMapFx<R, E, A, E1, B> implements Fx<R, E, B, E1> {
+  constructor(readonly fx: Fx<R, E, A, E1>, readonly f: (a: A) => Maybe.Maybe<B>) {}
+
+  run<R2, E2, C>(sink: Sink.Sink<E, B, R2, E2, C>): Effect.Effect<R | R2, E1 | E2, C> {
+    return this.fx.run(pipe(sink, Sink.filterMap(this.f)))
+  }
+
+  static make = <R, E, A, E1, B>(
+    fx: Fx<R, E, A, E1>,
+    f: (a: A) => Maybe.Maybe<B>,
+  ): Fx<R, E, B, E1> => {
+    if (fx instanceof FilterMapFx) {
+      return new FilterMapFx(fx.fx, flow(fx.f, Maybe.flatMap(f)))
+    }
+
+    return new FilterMapFx(fx, f)
+  }
+}

package/src/merge.test.ts

@@ -0,0 +1,41 @@
+import { deepStrictEqual } from 'assert'
+
+import { unsafeRunPromise } from '@effect/core/io/Effect'
+import { pipe } from '@fp-ts/data/Function'
+import * as Duration from '@tsplus/stdlib/data/Duration'
+
+import { delay } from './delay.js'
+import { flatMap } from './flatMap.js'
+import { from } from './from.js'
+import { merge } from './merge.js'
+import { collectAll } from './reduce.js'
+
+describe(import.meta.url, () => {
+  describe('merge', () => {
+    it('merges 2 fx together', async () => {
+      const values = [1, 2, 3]
+      const test = pipe(
+        from(values),
+        flatMap((a) =>
+          pipe(from([a, a + 1]), merge(pipe(from([a * a, a ** a]), delay(Duration.millis(10))))),
+        ),
+      )
+      const events = await pipe(test, collectAll, unsafeRunPromise)
+
+      deepStrictEqual(events, [
+        values[0],
+        values[0] + 1,
+        values[1],
+        values[1] + 1,
+        values[2],
+        values[2] + 1,
+        values[0] * values[0],
+        values[1] * values[1],
+        values[2] * values[2],
+        values[0] ** values[0],
+        values[1] ** values[1],
+        values[2] ** values[2],
+      ])
+    })
+  })
+})

package/src/merge.ts

@@ -0,0 +1,50 @@
+import * as Effect from '@effect/core/io/Effect'
+import { flow, pipe } from '@fp-ts/data/Function'
+
+import { Fx } from './Fx.js'
+import { Sink } from './Sink.js'
+import { refCountDeferred } from './_internal.js'
+
+export function merge<R2, E2, B, E3>(other: Fx<R2, E2, B, E3>) {
+  return <R, E, A, E1>(self: Fx<R, E, A, E1>): Fx<R | R2, E | E2, A | B, E1 | E3> =>
+    mergeAll([self, other])
+}
+
+export function mergeAll<FX extends ReadonlyArray<Fx<any, any, any, any>>>(
+  fx: readonly [...FX],
+): Fx<
+  Fx.ResourcesOf<FX[number]>,
+  Fx.ErrorsOf<FX[number]>,
+  Fx.OutputOf<FX[number]>,
+  Fx.ReturnErrorsOf<FX[number]>
+>
+
+export function mergeAll<R2, E2, B, E3>(fx: Iterable<Fx<R2, E2, B, E3>>): Fx<R2, E2, B, E3>
+
+export function mergeAll<R2, E2, B, E3>(fx: Iterable<Fx<R2, E2, B, E3>>): Fx<R2, E2, B, E3> {
+  return Fx(<R4, E4, C>(sink: Sink<E2, B, R4, E4, C>) =>
+    Effect.gen(function* ($) {
+      const array = Array.from(fx)
+      const deferred = yield* $(refCountDeferred<E3 | E4, C>(true, array.length))
+
+      yield* $(
+        Effect.forEachDiscard(array, (fx) =>
+          Effect.fork(
+            fx.run(
+              Sink(
+                sink.event,
+                flow(sink.error, deferred.error),
+                pipe(
+                  deferred.decrement,
+                  Effect.flatMap(() => deferred.endIfComplete(sink.end)),
+                ),
+              ),
+            ),
+          ),
+        ),
+      )
+
+      return yield* $(deferred.await)
+    }),
+  )
+}

package/src/multicast.test.ts

@@ -0,0 +1,58 @@
+import { deepStrictEqual } from 'assert'
+
+import { unsafeRunPromise } from '@effect/core/io/Effect'
+import { pipe } from '@fp-ts/data/Function'
+import * as Duration from '@tsplus/stdlib/data/Duration'
+
+import { delay } from './delay.js'
+import { flatMap } from './flatMap.js'
+import { from } from './from.js'
+import { merge } from './merge.js'
+import { multicast } from './multicast.js'
+import { collectAll } from './reduce.js'
+import { suspendSucceed } from './suspendSucceed.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(
+        suspendSucceed(() => {
+          started++
+          return pipe(
+            from(values),
+            flatMap((a) =>
+              pipe(
+                from([a, a + 1]),
+                merge(pipe(from([a * a, a ** a]), delay(Duration.millis(50)))),
+              ),
+            ),
+          )
+        }),
+        multicast,
+      )
+      const events = pipe(test, collectAll, unsafeRunPromise)
+      const events2 = pipe(test, collectAll, unsafeRunPromise)
+
+      deepStrictEqual(await events, [
+        values[0],
+        values[0] + 1,
+        values[1],
+        values[1] + 1,
+        values[2],
+        values[2] + 1,
+        values[0] * values[0],
+        values[1] * values[1],
+        values[2] * values[2],
+        values[0] ** values[0],
+        values[1] ** values[1],
+        values[2] ** values[2],
+      ])
+
+      deepStrictEqual(await events, await events2)
+
+      deepStrictEqual(started, 1)
+    })
+  })
+})

package/src/multicast.ts

@@ -0,0 +1,98 @@
+import * as Cause from '@effect/core/io/Cause'
+import * as Deferred from '@effect/core/io/Deferred'
+import * as Effect from '@effect/core/io/Effect'
+import * as Fiber from '@effect/core/io/Fiber'
+import { pipe } from '@fp-ts/data/Function'
+import { Env } from '@tsplus/stdlib/service/Env'
+
+import { Fx } from './Fx.js'
+import { Sink } from './Sink.js'
+import { asap } from './_internal.js'
+
+export function multicast<R, E, A, E1 = never>(self: Fx<R, E, A, E1>): Fx<R, E, A, E1> {
+  return new Multicast(self)
+}
+
+export type MulticastObserver<E, A> = readonly [
+  Sink<E, A, any, any, any>,
+  Env<any>,
+  Deferred.Deferred<any, any>,
+]
+
+export class Multicast<R, E, A, E1> implements Fx<R, E, A, E1>, Sink<E, A, any, any, any> {
+  protected sinks: Array<MulticastObserver<E, A>> = []
+  protected fiber: Fiber.Fiber<any, any> | undefined
+
+  constructor(readonly fx: Fx<R, E, A, E1>) {
+    this.run = this.run.bind(this)
+    this.event = this.event.bind(this)
+    this.error = this.error.bind(this)
+    this.runEvent = this.runEvent.bind(this)
+    this.runError = this.runError.bind(this)
+    this.runEnd = this.runEnd.bind(this)
+  }
+
+  run<R2, E2, B>(sink: Sink<E, A, R2, E2, B>): Effect.Effect<R | R2, E1 | E2, B> {
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const that = this
+
+    return Effect.gen(function* ($) {
+      const env = yield* $(Effect.environment<R | R2>())
+      const deferred = yield* $(Deferred.make<E2, B>())
+
+      that.sinks.push([sink, env, deferred])
+
+      if (!that.fiber) {
+        that.fiber = yield* $(Effect.fork(Effect.schedule(asap)(that.fx.run(that))))
+      }
+
+      return yield* $(deferred.await)
+    })
+  }
+
+  event(a: A) {
+    return Effect.forEachDiscard(this.sinks.slice(), (o) => this.runEvent(a, o))
+  }
+
+  error(e: Cause.Cause<E>): Effect.Effect<never, any, void> {
+    return pipe(
+      Effect.forEachDiscard(this.sinks.slice(), (o) => this.runError(e, o)),
+      Effect.tap(() => Effect.sync(() => (this.fiber = undefined))),
+    )
+  }
+
+  public get end(): Sink<E, A, any, any, any>['end'] {
+    return pipe(
+      Effect.forEachDiscard(this.sinks.slice(), (o) => this.runEnd(o)),
+      Effect.tap(() => Effect.sync(() => (this.fiber = undefined))),
+    )
+  }
+
+  protected runEvent(a: A, observer: MulticastObserver<E, A>) {
+    return pipe(
+      observer[0].event(a),
+      Effect.provideEnvironment(observer[1]),
+      Effect.onError((c) => (Cause.isEmpty(c) ? Effect.unit : this.runError(c, observer))),
+    )
+  }
+
+  protected runError(e: Cause.Cause<E>, observer: MulticastObserver<E, A>) {
+    this.sinks.splice(this.sinks.indexOf(observer), 1)
+
+    return pipe(
+      observer[0].error(e),
+      Effect.intoDeferred(observer[2]),
+      Effect.provideEnvironment(observer[1]),
+    )
+  }
+
+  protected runEnd(observer: MulticastObserver<E, A>) {
+    this.sinks.splice(this.sinks.indexOf(observer), 1)
+
+    return pipe(
+      observer[0].end,
+      Effect.intoDeferred(observer[2]),
+      Effect.provideEnvironment(observer[1]),
+    )
+  }
+}

package/src/never.ts

@@ -0,0 +1,5 @@
+import * as Effect from '@effect/core/io/Effect'
+
+import { fromEffect } from './fromEffect.js'
+
+export const never = fromEffect(Effect.never)

package/src/observe.ts

@@ -0,0 +1,24 @@
+import * as Effect from '@effect/core/io/Effect'
+import { Fiber } from '@effect/core/io/Fiber'
+
+import { Fx } from './Fx.js'
+import { Sink } from './Sink.js'
+
+export function observeNow<A, R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>) {
+  return <R, E, E1>(fx: Fx<R, E, A, E1>): Effect.Effect<R | R2, E | E1 | E2, void> =>
+    fx.run(Sink<E, A, R | R2, E | E1 | E2, void>(f, Effect.failCause, Effect.unit))
+}
+
+export function observe<A, R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>) {
+  return <R, E, E1>(
+    fx: Fx<R, E, A, E1>,
+  ): Effect.Effect<R | R2, never, Fiber.Runtime<E | E1 | E2, void>> =>
+    Effect.fork(observeNow(f)(fx))
+}
+
+export function observeDaemon<A, R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>) {
+  return <R, E, E1>(
+    fx: Fx<R, E, A, E1>,
+  ): Effect.Effect<R | R2, never, Fiber.Runtime<E | E1 | E2, void>> =>
+    Effect.forkDaemon(observeNow(f)(fx))
+}

package/src/orElse.ts

@@ -0,0 +1,46 @@
+import * as Cause from '@effect/core/io/Cause'
+import { Effect } from '@effect/core/io/Effect'
+import { pipe } from '@fp-ts/data/Function'
+import * as Either from '@tsplus/stdlib/data/Either'
+
+import { Fx } from './Fx.js'
+import { Sink } from './Sink.js'
+import { fromEffect } from './fromEffect.js'
+
+export function orElseCause<E, R2, E2, B, E3>(f: (e: Cause.Cause<E>) => Fx<R2, E2, B, E3>) {
+  return <R, A, E1>(fx: Fx<R, E, A, E1>): Fx<R | R2, E | E2, A | B, E1 | E3> =>
+    Fx((sink) => fx.run(Sink(sink.event, (e) => f(e).run(sink), sink.end)))
+}
+
+export function orElse<E, R2, E2, B, E3>(f: (e: E) => Fx<R2, E2, B, E3>) {
+  return <R, A, E1>(fx: Fx<R, E, A, E1>): Fx<R | R2, E | E2, A | B, E1 | E3> =>
+    Fx((sink) =>
+      fx.run(
+        Sink(
+          sink.event,
+          (e) =>
+            pipe(
+              Cause.failureOrCause(e),
+              Either.fold((e) => f(e).run(sink), sink.error),
+            ),
+          sink.end,
+        ),
+      ),
+    )
+}
+
+export function orElseCauseEffect<E, R2, E2, B>(f: (e: Cause.Cause<E>) => Effect<R2, E2, B>) {
+  return <R, A, E1>(fx: Fx<R, E, A, E1>): Fx<R | R2, E | E2, A | B, E1> =>
+    pipe(
+      fx,
+      orElseCause((e) => fromEffect(f(e))),
+    )
+}
+
+export function orElseEffect<E, R2, E2, B>(f: (e: E) => Effect<R2, E2, B>) {
+  return <R, A, E1>(fx: Fx<R, E, A, E1>): Fx<R | R2, E | E2, A | B, E1> =>
+    pipe(
+      fx,
+      orElse((e: E) => fromEffect(f(e))),
+    )
+}

package/src/periodic.test.ts

@@ -0,0 +1,20 @@
+import { deepStrictEqual } from 'assert'
+
+import { unsafeRunPromise } from '@effect/core/io/Effect'
+import { pipe } from '@fp-ts/data/Function'
+import { millis } from '@tsplus/stdlib/data/Duration'
+
+import { periodic } from './periodic.js'
+import { collectAll } from './reduce.js'
+import { take } from './slice.js'
+
+describe(import.meta.url, () => {
+  describe('periodic', () => {
+    it('emits a value every period', async () => {
+      const test = pipe(periodic(millis(100)), take(3), collectAll)
+      const events = await unsafeRunPromise(test)
+
+      deepStrictEqual(events, [undefined, undefined, undefined])
+    })
+  })
+})

package/src/periodic.ts

@@ -0,0 +1,11 @@
+import { unit } from '@effect/core/io/Effect'
+import * as Schedule from '@effect/core/io/Schedule'
+import { pipe } from '@fp-ts/data/Function'
+import { Duration } from '@tsplus/stdlib/data/Duration'
+
+import { Fx } from './Fx.js'
+import { scheduled } from './scheduled.js'
+
+export function periodic(delay: Duration): Fx<never, never, void> {
+  return pipe(unit, scheduled(Schedule.delayed(() => delay)(Schedule.repeatForever)))
+}

package/src/provide.ts

@@ -0,0 +1,50 @@
+import * as Effect from '@effect/core/io/Effect'
+import { Layer } from '@effect/core/io/Layer'
+import { pipe } from '@fp-ts/data/Function'
+import * as Env from '@tsplus/stdlib/service/Env'
+import { Tag } from '@tsplus/stdlib/service/Tag'
+
+import { Fx } from './Fx.js'
+import { Sink } from './Sink.js'
+
+export const provideEnvironment =
+  <R>(env: Env.Env<R>) =>
+  <E, A, E1>(fx: Fx<R, E, A, E1>): Fx<never, E, A, E1> =>
+    Fx(
+      <R2, E2, B>(sink: Sink<E, A, R2, E2, B>): Effect.Effect<R2, E1 | E2, B> =>
+        pipe(
+          fx.run(sink),
+          Effect.provideSomeEnvironment((e: Env.Env<R2>): Env.Env<R | R2> => e.merge<R2, R>(env)),
+        ),
+    )
+
+export const provideSomeEnvironment =
+  <R3>(env: Env.Env<R3>) =>
+  <R, E, A, E1>(fx: Fx<R | R3, E, A, E1>): Fx<R, E, A, E1> =>
+    Fx(
+      <R2, E2, B>(sink: Sink<E, A, R2, E2, B>): Effect.Effect<R | R2, E1 | E2, B> =>
+        pipe(
+          fx.run(sink),
+          Effect.provideSomeEnvironment((e) => e.merge(env)),
+        ),
+    )
+
+export const provideLayer =
+  <RI, E3, RO>(layer: Layer<RI, E3, RO>) =>
+  <E, A, E1>(fx: Fx<RO, E, A, E1>): Fx<RI, E, A, E1 | E3> =>
+    Fx((sink) => pipe(fx.run(sink), Effect.provideSomeLayer(layer)))
+
+export const provideSomeLayer =
+  <RI, E3, RO>(layer: Layer<RI, E3, RO>) =>
+  <R, E, A, E1>(fx: Fx<R | RO, E, A, E1>): Fx<R | RI, E, A, E1 | E3> =>
+    Fx((sink) => pipe(fx.run(sink), Effect.provideSomeLayer(layer)))
+
+export const provideService =
+  <T>(tag: Tag<T>, resource: T) =>
+  <R, E, A, E1>(fx: Fx<R | T, E, A, E1>): Fx<R, E, A, E1> =>
+    Fx((sink) => pipe(fx.run(sink), Effect.provideService(tag, resource)))
+
+export const provideServiceEffect =
+  <T, R3, E3>(tag: Tag<T>, effect: Effect.Effect<R3, E3, T>) =>
+  <R, E, A, E1>(fx: Fx<R | T, E, A, E1>): Fx<R | R3, E, A, E1 | E3> =>
+    Fx((sink) => pipe(fx.run(sink), Effect.provideServiceEffect(tag, effect)))