@typed/fx 0.0.35 → 1.0.2

package/src/operator/zip.ts

@@ -0,0 +1,92 @@
+import * as Effect from '@effect/io/Effect'
+import { pipe } from '@fp-ts/data/Function'
+
+import { Fx } from '../Fx.js'
+import { withRefCounter } from '../_internal/RefCounter.js'
+
+export function zipAll<Streams extends readonly Fx<any, any, any>[]>(
+  ...streams: Streams
+): Fx<
+  Fx.ResourcesOf<Streams[number]>,
+  Fx.ErrorsOf<Streams[number]>,
+  {
+    readonly [K in keyof Streams]: Fx.OutputOf<Streams[K]>
+  }
+> {
+  return new ZipAllFx(streams)
+}
+
+export function zip<R2, E2, B>(second: Fx<R2, E2, B>) {
+  return <R, E, A>(first: Fx<R, E, A>): Fx<R | R2, E | E2, readonly [A, B]> => zipAll(first, second)
+}
+
+class ZipAllFx<Streams extends readonly Fx<any, any, any>[]>
+  extends Fx.Variance<
+    Fx.ResourcesOf<Streams[number]>,
+    Fx.ErrorsOf<Streams[number]>,
+    {
+      readonly [K in keyof Streams]: Fx.OutputOf<Streams[K]>
+    }
+  >
+  implements
+    Fx<
+      Fx.ResourcesOf<Streams[number]>,
+      Fx.ErrorsOf<Streams[number]>,
+      {
+        readonly [K in keyof Streams]: Fx.OutputOf<Streams[K]>
+      }
+    >
+{
+  constructor(readonly streams: Streams) {
+    super()
+  }
+
+  run<R2>(
+    sink: Fx.Sink<
+      R2,
+      Fx.ErrorsOf<Streams[number]>,
+      {
+        readonly [K in keyof Streams]: Fx.OutputOf<Streams[K]>
+      }
+    >,
+  ) {
+    const l = this.streams.length
+
+    return withRefCounter(
+      l,
+      (counter) => {
+        const results = new Map<number, any>()
+
+        const emitIfReady = Effect.gen(function* ($) {
+          if (results.size !== l) {
+            return
+          }
+
+          const output = Array.from({ length: l }, (_, i) => results.get(i)) as any
+
+          results.clear()
+
+          yield* $(sink.event(output))
+        })
+
+        return pipe(
+          this.streams,
+          Effect.forEachParWithIndex((s, i) =>
+            s.run(
+              Fx.Sink(
+                (a) =>
+                  pipe(
+                    Effect.sync(() => results.set(i, a)),
+                    Effect.zipRight(emitIfReady),
+                  ),
+                sink.error,
+                counter.decrement,
+              ),
+            ),
+          ),
+        )
+      },
+      sink.end,
+    )
+  }
+}

package/src/operator/zipItems.test.ts

@@ -0,0 +1,25 @@
+import { deepStrictEqual } from 'assert'
+
+import * as Effect from '@effect/io/Effect'
+import { pipe } from '@fp-ts/data/Function'
+import { describe, it } from 'vitest'
+
+import { fromArray } from '../constructor/fromArray.js'
+import { collectAll } from '../run/collectAll.js'
+
+import { zipItems } from './zipItems.js'
+
+describe(import.meta.url, () => {
+  describe(zipItems.name, () => {
+    it('zips a stream together with an iterable', async () => {
+      const test = pipe(
+        fromArray([1, 2, 3]),
+        zipItems([3, 4], (x, y) => x + y),
+        collectAll,
+      )
+      const events = await Effect.unsafeRunPromise(test)
+
+      deepStrictEqual(events, [4, 6])
+    })
+  })
+})

package/src/operator/zipItems.ts

@@ -0,0 +1,36 @@
+import { Fx } from '../Fx.js'
+import { withEarlyExit } from '../_internal/earlyExit.js'
+
+export function zipItems<B, A, C>(items: Iterable<B>, f: (b: B, a: A) => C) {
+  return <R, E>(fx: Fx<R, E, A>): Fx<R, E, C> => new ZipItemsFx(fx, items, f)
+}
+
+class ZipItemsFx<R, E, A, B, C> extends Fx.Variance<R, E, C> implements Fx<R, E, C> {
+  constructor(
+    readonly fx: Fx<R, E, A>,
+    readonly items: Iterable<B>,
+    readonly f: (b: B, a: A) => C,
+  ) {
+    super()
+  }
+
+  run<R2>(sink: Fx.Sink<R2, E, C>) {
+    return withEarlyExit((earlyExit) => {
+      const iterator = this.items[Symbol.iterator]()
+      let next = iterator.next()
+
+      return this.fx.run({
+        ...sink,
+        event: (a) => {
+          if (next.done) {
+            return earlyExit
+          }
+
+          const b = next.value
+          next = iterator.next()
+          return sink.event(this.f(b, a))
+        },
+      })
+    }, sink.end)
+  }
+}

package/src/run/collectAll.ts

@@ -0,0 +1,17 @@
+import * as Effect from '@effect/io/Effect'
+import { pipe } from '@fp-ts/data/Function'
+
+import { Fx } from '../Fx.js'
+
+import { reduce } from './reduce.js'
+
+export const collectAll = <R, E, A>(fx: Fx<R, E, A>): Effect.Effect<R, E, readonly A[]> =>
+  Effect.suspendSucceed(() =>
+    pipe(
+      fx,
+      reduce([] as A[], (acc, a) => {
+        acc.push(a)
+        return acc
+      }),
+    ),
+  )

package/src/run/collectN.ts

@@ -0,0 +1,21 @@
+import * as Effect from '@effect/io/Effect'
+import { pipe } from '@fp-ts/data/Function'
+
+import { Fx } from '../Fx.js'
+import { take } from '../operator/take.js'
+
+import { reduce } from './reduce.js'
+
+export const collectN =
+  (amount: number) =>
+  <R, E, A>(fx: Fx<R, E, A>): Effect.Effect<R, E, readonly A[]> =>
+    Effect.suspendSucceed(() =>
+      pipe(
+        fx,
+        take(amount),
+        reduce([] as A[], (acc, a) => {
+          acc.push(a)
+          return acc
+        }),
+      ),
+    )

package/src/run/drain.ts

@@ -0,0 +1,7 @@
+import * as Effect from '@effect/io/Effect'
+
+import { Fx } from '../Fx.js'
+
+import { observe } from './observe.js'
+
+export const drain: <R, E, A>(fx: Fx<R, E, A>) => Effect.Effect<R, E, void> = observe(Effect.unit)

package/src/run/index.ts

@@ -0,0 +1,7 @@
+export * from './collectAll.js'
+export * from './collectN.js'
+export * from './drain.js'
+export * from './observe.js'
+export * from './reduce.js'
+export * from './run.js'
+export * from './unsafe.js'

package/src/run/observe.ts

@@ -0,0 +1,19 @@
+import * as Effect from '@effect/io/Effect'
+import { Scope } from '@effect/io/Scope'
+import { flow } from '@fp-ts/data/Function'
+
+import { Fx } from '../Fx.js'
+
+import { run_ } from './run.js'
+
+export function observe<A, R2, E2, B>(
+  f: (a: A) => Effect.Effect<R2, E2, B>,
+): <R, E>(fx: Fx<R, E, A>) => Effect.Effect<R | R2, E2 | E, void> {
+  return flow(observe_(f), Effect.scoped)
+}
+
+export function observe_<A, R2, E2, B>(
+  f: (a: A) => Effect.Effect<R2, E2, B>,
+): <R, E>(fx: Fx<R, E, A>) => Effect.Effect<R | R2 | Scope, E | E2, void> {
+  return run_(f, Effect.failCause, Effect.unit())
+}

package/src/run/reduce.ts

@@ -0,0 +1,20 @@
+import * as Effect from '@effect/io/Effect'
+import { pipe } from '@fp-ts/data/Function'
+
+import { Fx } from '../Fx.js'
+
+import { observe } from './observe.js'
+
+export const reduce: <B, A>(
+  seed: B,
+  f: (acc: B, a: A) => B,
+) => <R, E>(fx: Fx<R, E, A>) => Effect.Effect<R, E, B> = (seed, f) => (fx) =>
+  Effect.suspendSucceed(() => {
+    let acc = seed
+
+    return pipe(
+      fx,
+      observe((a) => Effect.sync(() => (acc = f(acc, a)))),
+      Effect.map(() => acc),
+    )
+  })

package/src/run/run.ts

@@ -0,0 +1,49 @@
+import { Cause } from '@effect/io/Cause'
+import * as Deferred from '@effect/io/Deferred'
+import * as Effect from '@effect/io/Effect'
+import * as Fiber from '@effect/io/Fiber'
+import { Scope } from '@effect/io/Scope'
+import { flow, pipe } from '@fp-ts/data/Function'
+
+import { Fx, Sink } from '../Fx.js'
+
+export function run<A, R2, E2, E, R3, E3, B, R4, E4>(
+  event: (a: A) => Effect.Effect<R2, E2, any>,
+  error: (cause: Cause<E>) => Effect.Effect<R3, E3, B>,
+  end: Effect.Effect<R4, E4, B>,
+): <R>(fx: Fx<R, E, A>) => Effect.Effect<R | R2 | R3 | R4, E2 | E3 | E4, B> {
+  return flow(run_(event, error, end), Effect.scoped)
+}
+
+export function run_<A, R2, E2, E, R3, E3, B, R4, E4>(
+  event: (a: A) => Effect.Effect<R2, E2, any>,
+  error: (cause: Cause<E>) => Effect.Effect<R3, E3, B>,
+  end: Effect.Effect<R4, E4, B>,
+) {
+  return <R>(fx: Fx<R, E, A>): Effect.Effect<R | R2 | R3 | R4 | Scope, E2 | E3 | E4, B> =>
+    Effect.gen(function* ($) {
+      const deferred = yield* $(Deferred.make<E2 | E3 | E4, B>())
+      const sink = Sink(
+        flow(
+          event,
+          Effect.matchCauseEffect(
+            (cause) =>
+              Effect.sync(() =>
+                pipe(deferred, Deferred.unsafeDone<E2 | E3 | E4, B>(Effect.failCause(cause))),
+              ),
+            Effect.unit,
+          ),
+        ),
+        flow(error, Effect.intoDeferred(deferred)),
+        pipe(end, Effect.intoDeferred(deferred)),
+      )
+
+      const fiber = yield* $(Effect.forkScoped(fx.run(sink)))
+
+      const c = yield* $(Deferred.await(deferred))
+
+      yield* $(Fiber.interrupt(fiber))
+
+      return c
+    })
+}

package/src/run/unsafe.ts

@@ -0,0 +1,38 @@
+import {Cancel} from '@effect/io/Runtime'
+import * as Effect from '@effect/io/Effect'
+import * as Exit from '@effect/io/Exit'
+import * as Fiber from '@effect/io/Fiber'
+import * as Scope from '@effect/io/Scope'
+
+import { Fx } from '../Fx.js'
+
+import { drain } from './drain.js'
+
+export const unsafeRunAsync = <E, A>(fx: Fx<never, E, A>): Cancel<E, void> => Effect.unsafeRun(drain(fx))
+
+export const unsafeRunAsyncWith =
+  <E>(f: (exit: Exit.Exit<E, void>) => void) =>
+  <A>(fx: Fx<never, E, A>): Cancel<E, void> =>
+    Effect.unsafeRun(drain(fx), f)
+
+export const unsafeFork = <E, A>(fx: Fx<never, E, A>): Fiber.RuntimeFiber<E, void> =>
+  Effect.unsafeFork(drain(fx))
+
+export const unsafeRunPromise = <E, A>(fx: Fx<never, E, A>): Promise<void> =>
+  Effect.unsafeRunPromise(drain(fx))
+
+export const unsafeRunPromiseExit = <E, A>(fx: Fx<never, E, A>): Promise<Exit.Exit<E, void>> =>
+  Effect.unsafeRunPromiseExit(drain(fx))
+
+export const fork = <R, E, A>(
+  fx: Fx<R, E, A>,
+): Effect.Effect<R, never, Fiber.RuntimeFiber<E, void>> => Effect.fork(drain(fx))
+
+export const forkDaemon = <R, E, A>(
+  fx: Fx<R, E, A>,
+): Effect.Effect<R, never, Fiber.RuntimeFiber<E, void>> => Effect.forkDaemon(drain(fx))
+
+export const forkScoped = <R, E, A>(
+  fx: Fx<R, E, A>,
+): Effect.Effect<R | Scope.Scope, never, Fiber.RuntimeFiber<E, void>> =>
+  Effect.forkScoped(drain(fx))

package/src/typeclass/Alternative.ts

@@ -0,0 +1,15 @@
+import * as A from '@fp-ts/core/typeclass/Alternative'
+
+import { CoproductRace, CoproductOrElse } from './Coproduct.js'
+import { SemiAlternativeRace, SemiAlternativeOrElse } from './SemiAlternative.js'
+import { FxTypeLambda } from './TypeLambda.js'
+
+export const ApplicativeRace: A.Alternative<FxTypeLambda> = {
+  ...SemiAlternativeRace,
+  ...CoproductRace,
+}
+
+export const ApplicativeOrElse: A.Alternative<FxTypeLambda> = {
+  ...SemiAlternativeOrElse,
+  ...CoproductOrElse,
+}

package/src/typeclass/Applicative.ts

@@ -0,0 +1,15 @@
+import * as A from '@fp-ts/core/typeclass/Applicative'
+
+import { Fx } from '../Fx.js'
+import { combineAll } from '../operator/combine.js'
+
+import { Of } from './Of.js'
+import { SemiApplicative } from './SemiApplicative.js'
+import { FxTypeLambda } from './TypeLambda.js'
+
+export const Applicative: A.Applicative<FxTypeLambda> = {
+  ...SemiApplicative,
+  ...Of,
+  productAll: <R, E, A>(collection: Iterable<Fx<R, E, A>>) =>
+    combineAll<readonly Fx<R, E, A>[]>(...collection),
+}

package/src/typeclass/Bicovariant.ts

@@ -0,0 +1,15 @@
+import * as B from '@fp-ts/core/typeclass/Bicovariant'
+import { pipe } from '@fp-ts/data/Function'
+
+import { Fx } from '../Fx.js'
+import { map } from '../operator/map.js'
+import { mapError } from '../operator/mapError.js'
+
+import { FxTypeLambda } from './TypeLambda.js'
+
+export const Bicovariant: B.Bicovariant<FxTypeLambda> = {
+  bimap: (f, g) => (fa) => pipe(fa, mapError(f), map(g)),
+}
+
+export const mapLeft: <E1, E2>(f: (e: E1) => E2) => <R, A>(self: Fx<R, E1, A>) => Fx<R, E2, A> =
+  B.mapLeft(Bicovariant)

package/src/typeclass/Chainable.ts

@@ -0,0 +1,20 @@
+import * as C from '@fp-ts/core/typeclass/Chainable'
+
+import { Covariant } from './Covariant.js'
+import { FlatMap, SwitchMap, ExhaustMap } from './FlatMap.js'
+import { FxTypeLambda } from './TypeLambda.js'
+
+export const Chainable: C.Chainable<FxTypeLambda> = {
+  ...FlatMap,
+  ...Covariant,
+}
+
+export const Switchable: C.Chainable<FxTypeLambda> = {
+  ...SwitchMap,
+  ...Covariant,
+}
+
+export const Exhaustable: C.Chainable<FxTypeLambda> = {
+  ...ExhaustMap,
+  ...Covariant,
+}

package/src/typeclass/Coproduct.ts

@@ -0,0 +1,25 @@
+import * as Cause from '@effect/io/Cause'
+import * as CP from '@fp-ts/core/typeclass/Coproduct'
+
+import { Fx } from '../Fx.js'
+import { failCause } from '../constructor/failCause.js'
+import { never } from '../constructor/never.js'
+import { orElse } from '../operator/orElse.js'
+import { raceAll } from '../operator/race.js'
+
+import { SemiCoproductRace, SemiCoproductOrElse } from './SemiCoproduct.js'
+import { FxTypeLambda } from './TypeLambda.js'
+
+export const CoproductRace: CP.Coproduct<FxTypeLambda> = {
+  ...SemiCoproductRace,
+  zero: () => never,
+  coproductAll: <R, E, A>(collection: Iterable<Fx<R, E, A>>) =>
+    raceAll<readonly Fx<R, E, A>[]>(...collection),
+}
+
+export const CoproductOrElse: CP.Coproduct<FxTypeLambda> = {
+  ...SemiCoproductOrElse,
+  zero: () => failCause(Cause.empty),
+  coproductAll: <R, E, A>(collection: Iterable<Fx<R, E, A>>) =>
+    Array.from(collection).reduce((acc, fx) => orElse(fx)(acc), CoproductOrElse.zero()),
+}

package/src/typeclass/Covariant.ts

@@ -0,0 +1,25 @@
+import * as C from '@fp-ts/core/typeclass/Covariant'
+
+import { Fx } from '../Fx.js'
+import { map } from '../operator/map.js'
+
+import { FxTypeLambda } from './TypeLambda.js'
+
+export const Covariant: C.Covariant<FxTypeLambda> = C.make((f) => map(f))
+
+export const flap: <A>(a: A) => <R, E, B>(self: Fx<R, E, (a: A) => B>) => Fx<R, E, B> =
+  C.flap(Covariant)
+
+export const imap: <A, B>(
+  to: (a: A) => B,
+  from: (b: B) => A,
+) => <R, E>(self: Fx<R, E, A>) => Fx<R, E, B> = C.imap<FxTypeLambda>(Covariant.map)
+
+const let_: <N extends string, A extends object, B>(
+  name: Exclude<N, keyof A>,
+  f: (a: A) => B,
+) => <R, E>(
+  self: Fx<R, E, A>,
+) => Fx<R, E, { readonly [K in N | keyof A]: K extends keyof A ? A[K] : B }> = C.let(Covariant)
+
+export { let_ as let }

package/src/typeclass/FlatMap.ts

@@ -0,0 +1,19 @@
+import * as F from '@fp-ts/core/typeclass/FlatMap'
+
+import { exhaustMap } from '../operator/exhaustMap.js'
+import { flatMap } from '../operator/flatMap.js'
+import { switchMap } from '../operator/switchMap.js'
+
+import { FxTypeLambda } from './TypeLambda.js'
+
+export const FlatMap: F.FlatMap<FxTypeLambda> = {
+  flatMap,
+}
+
+export const SwitchMap: F.FlatMap<FxTypeLambda> = {
+  flatMap: switchMap,
+}
+
+export const ExhaustMap: F.FlatMap<FxTypeLambda> = {
+  flatMap: exhaustMap,
+}

package/src/typeclass/Monad.ts

@@ -0,0 +1,24 @@
+import * as M from '@fp-ts/core/typeclass/Monad'
+
+import { Covariant } from './Covariant.js'
+import { FlatMap, SwitchMap, ExhaustMap } from './FlatMap.js'
+import { Pointed } from './Pointed.js'
+import { FxTypeLambda } from './TypeLambda.js'
+
+export const Monad: M.Monad<FxTypeLambda> = {
+  ...FlatMap,
+  ...Covariant,
+  ...Pointed,
+}
+
+export const MonadSwitch: M.Monad<FxTypeLambda> = {
+  ...SwitchMap,
+  ...Covariant,
+  ...Pointed,
+}
+
+export const MonadExhaust: M.Monad<FxTypeLambda> = {
+  ...ExhaustMap,
+  ...Covariant,
+  ...Pointed,
+}

package/src/typeclass/Of.ts

@@ -0,0 +1,9 @@
+import * as O from '@fp-ts/core/typeclass/Of'
+
+import { succeed } from '../constructor/succeed.js'
+
+import { FxTypeLambda } from './TypeLambda.js'
+
+export const Of: O.Of<FxTypeLambda> = {
+  of: succeed,
+}

package/src/typeclass/Pointed.ts

@@ -0,0 +1,10 @@
+import * as P from '@fp-ts/core/typeclass/Pointed'
+
+import { Covariant } from './Covariant.js'
+import { Of } from './Of.js'
+import { FxTypeLambda } from './TypeLambda.js'
+
+export const Pointed: P.Pointed<FxTypeLambda> = {
+  ...Of,
+  ...Covariant,
+}

package/src/typeclass/Product.ts

@@ -0,0 +1,13 @@
+import * as P from '@fp-ts/core/typeclass/Product'
+
+import { combineAll } from '../operator/combine.js'
+
+import { Of } from './Of.js'
+import { SemiProduct } from './SemiProduct.js'
+import { FxTypeLambda } from './TypeLambda.js'
+
+export const Product: P.Product<FxTypeLambda> = {
+  ...SemiProduct,
+  ...Of,
+  productAll: (iterable) => combineAll(...Array.from(iterable)),
+}

package/src/typeclass/SemiAlternative.ts

@@ -0,0 +1,15 @@
+import * as SA from '@fp-ts/core/typeclass/SemiAlternative'
+
+import { Covariant } from './Covariant.js'
+import { SemiCoproductRace, SemiCoproductOrElse } from './SemiCoproduct.js'
+import { FxTypeLambda } from './TypeLambda.js'
+
+export const SemiAlternativeRace: SA.SemiAlternative<FxTypeLambda> = {
+  ...SemiCoproductRace,
+  ...Covariant,
+}
+
+export const SemiAlternativeOrElse: SA.SemiAlternative<FxTypeLambda> = {
+  ...SemiCoproductOrElse,
+  ...Covariant,
+}

package/src/typeclass/SemiApplicative.ts

@@ -0,0 +1,10 @@
+import * as SA from '@fp-ts/core/typeclass/SemiApplicative'
+
+import { Covariant } from './Covariant.js'
+import { SemiProduct } from './SemiProduct.js'
+import { FxTypeLambda } from './TypeLambda.js'
+
+export const SemiApplicative: SA.SemiApplicative<FxTypeLambda> = {
+  ...SemiProduct,
+  ...Covariant,
+}

package/src/typeclass/SemiCoproduct.ts

@@ -0,0 +1,20 @@
+import * as SCP from '@fp-ts/core/typeclass/SemiCoproduct'
+
+import { orElse } from '../operator/orElse.js'
+import { race, raceAll } from '../operator/race.js'
+
+import { Covariant } from './Covariant.js'
+import { FxTypeLambda } from './TypeLambda.js'
+
+export const SemiCoproductRace: SCP.SemiCoproduct<FxTypeLambda> = {
+  coproduct: race,
+  coproductMany: (collection) => (fx) => raceAll(fx, ...collection),
+  imap: Covariant.imap,
+}
+
+export const SemiCoproductOrElse: SCP.SemiCoproduct<FxTypeLambda> = {
+  coproduct: orElse,
+  coproductMany: (collection) => (fx) =>
+    Array.from(collection).reduce((acc, fx) => orElse(fx)(acc), fx),
+  imap: Covariant.imap,
+}

package/src/typeclass/SemiProduct.ts

@@ -0,0 +1,12 @@
+import * as SP from '@fp-ts/core/typeclass/SemiProduct'
+
+import { combine } from '../operator/combine.js'
+
+import { Covariant } from './Covariant.js'
+import { FxTypeLambda } from './TypeLambda.js'
+
+export const SemiProduct: SP.SemiProduct<FxTypeLambda> = {
+  product: combine,
+  productMany: SP.productMany<FxTypeLambda>(Covariant, combine),
+  imap: Covariant.imap,
+}

package/src/typeclass/TypeLambda.ts

@@ -0,0 +1,7 @@
+import { TypeLambda } from '@fp-ts/core/HKT'
+
+import { Fx } from '../Fx.js'
+
+export interface FxTypeLambda extends TypeLambda {
+  readonly type: Fx<this['Out2'], this['Out1'], this['Target']>
+}

package/src/typeclass/index.ts

@@ -0,0 +1,16 @@
+export * from './Alternative.js'
+export * from './Applicative.js'
+export * from './Bicovariant.js'
+export * from './Chainable.js'
+export * from './Coproduct.js'
+export * from './Covariant.js'
+export * from './FlatMap.js'
+export * from './Monad.js'
+export * from './Of.js'
+export * from './Pointed.js'
+export * from './Product.js'
+export * from './SemiAlternative.js'
+export * from './SemiApplicative.js'
+export * from './SemiCoproduct.js'
+export * from './SemiProduct.js'
+export * from './TypeLambda.js'

package/tsconfig.build.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": ["src/**/*.test.ts"]
+}