@typed/fx 0.0.6 → 0.0.9

package/src/Stream/scan.ts

@@ -1,46 +0,0 @@
-import { Stream } from './Stream.js'
-
-import { FiberContext } from '@/FiberContext/FiberContext.js'
-import { Live } from '@/FiberId/FiberId.js'
-import { lazy } from '@/Fx/index.js'
-import { Scheduler } from '@/Scheduler/index.js'
-import { Sink, addTrace } from '@/Sink/Sink.js'
-
-export function scan<A, B>(f: (b: B, a: A) => B, b: B, __trace?: string) {
-  return <R, E>(stream: Stream<R, E, A>) => ScanStream.make(stream, f, b, __trace)
-}
-
-export class ScanStream<R, E, A, B> implements Stream<R, E, B> {
-  protected state: B
-
-  constructor(
-    readonly stream: Stream<R, E, A>,
-    readonly f: (b: B, a: A) => B,
-    readonly b: B,
-    readonly __trace?: string,
-  ) {
-    this.state = b
-  }
-
-  readonly fork = <E2>(sink: Sink<E, B, E2>, scheduler: Scheduler, context: FiberContext<Live>) =>
-    this.stream.fork(
-      addTrace(
-        {
-          ...sink,
-          event: (a) => lazy(() => sink.event((this.state = this.f(this.state, a)))),
-        },
-        this.__trace,
-      ),
-      scheduler,
-      context,
-    )
-
-  static make<R, E, A, B>(
-    stream: Stream<R, E, A>,
-    f: (b: B, a: A) => B,
-    b: B,
-    __trace?: string,
-  ): Stream<R, E, B> {
-    return new ScanStream(stream, f, b, __trace)
-  }
-}

package/src/Stream/scheduled.test.ts

@@ -1,42 +0,0 @@
-import { deepStrictEqual } from 'assert'
-
-import { NonNegativeInteger } from 'hkt-ts/number'
-
-import { collectAll } from './_internal.test.js'
-import { at, scheduled } from './scheduled.js'
-
-import * as Fx from '@/Fx/index.js'
-import * as Schedule from '@/Schedule/index.js'
-import { Delay } from '@/Time/index.js'
-import { testSuite } from '@/_internal/suite.js'
-
-testSuite(import.meta.url, () => {
-  describe(scheduled.name, () => {
-    it('runs Fx on Schedule', async () => {
-      const value = Math.random()
-
-      deepStrictEqual(await collectAll(scheduled(Schedule.once)(Fx.now(value))), [value])
-
-      deepStrictEqual(await collectAll(scheduled(Schedule.delayed(Delay(1)))(Fx.now(value))), [
-        value,
-      ])
-
-      deepStrictEqual(
-        await collectAll(
-          scheduled(Schedule.periodic(Delay(1)).and(Schedule.retries(NonNegativeInteger(1))))(
-            Fx.now(value),
-          ),
-        ),
-        [value, value],
-      )
-    })
-  })
-
-  describe(at.name, () => {
-    it('runs Fx at a given time', async () => {
-      const value = Math.random()
-
-      deepStrictEqual(await collectAll(at(Delay(5))(value)), [value])
-    })
-  })
-})

package/src/Stream/scheduled.ts

@@ -1,55 +0,0 @@
-import { pipe } from 'hkt-ts'
-import { NonNegativeInteger } from 'hkt-ts/number'
-
-import { Stream } from './Stream.js'
-
-import { Env } from '@/Env/Env.js'
-import { FiberContext } from '@/FiberContext/FiberContext.js'
-import * as Fx from '@/Fx/index.js'
-import * as Schedule from '@/Schedule/Schedule.js'
-import { Scheduler } from '@/Scheduler/Scheduler.js'
-import { Sink } from '@/Sink/Sink.js'
-import { Delay } from '@/Time/index.js'
-import { FiberId } from '@/index.js'
-
-export function scheduled(schedule: Schedule.Schedule, __trace?: string) {
-  return <R, E, A>(fx: Fx.Fx<R, E, A>): Stream<R, E, A> =>
-    Stream(<E2>(sink: Sink<E, A, E2>, scheduler: Scheduler, context: FiberContext<FiberId.Live>) =>
-      pipe(
-        Fx.asksEnv(
-          (env: Env<R>) =>
-            scheduler.schedule(
-              Fx.matchCause(sink.error, sink.event, __trace)(fx),
-              env,
-              schedule,
-              context,
-              () => sink.end,
-            ),
-          __trace,
-        ),
-      ),
-    )
-}
-
-export function at(delay: Delay, __trace?: string) {
-  return <A>(value: A): Stream<never, never, A> =>
-    scheduled(Schedule.delayed(delay), __trace)(Fx.now(value))
-}
-
-export function repeated(period: Delay, __trace?: string) {
-  return <A>(value: A): Stream<never, never, A> =>
-    scheduled(Schedule.periodic(period), __trace)(Fx.now(value))
-}
-
-export const exponential = (delay: Delay, __trace?: string) =>
-  scheduled(Schedule.exponential(delay), __trace)
-
-export const forever = scheduled(Schedule.forever, 'Scheduled.forever')
-
-export const recurring = (amount: NonNegativeInteger, __trace?: string) =>
-  scheduled(Schedule.recurring(amount), __trace)
-
-export const retries = (amount: NonNegativeInteger, __trace?: string) =>
-  scheduled(Schedule.retries(amount), __trace)
-
-export const spaced = (delay: Delay, __trace?: string) => scheduled(Schedule.spaced(delay), __trace)

package/src/Stream/setFiberRefLocally.ts

@@ -1,44 +0,0 @@
-import { pipe } from 'hkt-ts'
-
-import { Stream } from './Stream.js'
-
-import { FiberContext } from '@/FiberContext/FiberContext.js'
-import { FiberId } from '@/FiberId/FiberId.js'
-import { FiberRef } from '@/FiberRef/FiberRef.js'
-import * as FiberRefs from '@/FiberRefs/FiberRefs.js'
-import { flatMap, fromLazy } from '@/Fx/Fx.js'
-import { Scheduler } from '@/Scheduler/Scheduler.js'
-import { Sink } from '@/Sink/Sink.js'
-
-export function setFiberRefLocally<R, E, A>(fiberRef: FiberRef<R, E, A>, value: () => A) {
-  return <R2, E2, A2>(fx: Stream<R2, E2, A2>) => new SetFiberRefLocallyStream(fx, fiberRef, value)
-}
-
-export class SetFiberRefLocallyStream<R, E, A, R2, E2, A2> implements Stream<R2, E2, A2> {
-  constructor(
-    readonly stream: Stream<R2, E2, A2>,
-    readonly fiberRef: FiberRef<R, E, A>,
-    readonly value: () => A,
-  ) {}
-
-  fork<E3>(sink: Sink<E2, A2, E3>, scheduler: Scheduler, context: FiberContext<FiberId.Live>) {
-    return pipe(
-      fromLazy(() => FiberRefs.setFiberRefLocally(this.fiberRef, this.value())(context.fiberRefs)),
-      flatMap(() =>
-        this.stream.fork(
-          {
-            ...sink,
-            end: pipe(
-              sink.end,
-              flatMap(() =>
-                fromLazy(() => FiberRefs.popLocalFiberRef(this.fiberRef)(context.fiberRefs)),
-              ),
-            ),
-          },
-          scheduler,
-          context,
-        ),
-      ),
-    )
-  }
-}

package/src/Stream/switchMap.test.ts

@@ -1,43 +0,0 @@
-import { deepStrictEqual } from 'assert'
-
-import { pipe } from 'hkt-ts'
-
-import { collectAll } from './_internal.test.js'
-import { now } from './fromFx.js'
-import { merge } from './merge.js'
-import { at } from './scheduled.js'
-import { switchMap } from './switchMap.js'
-
-import { Delay } from '@/Time/index.js'
-import { testSuite } from '@/_internal/suite.js'
-
-testSuite(import.meta.url, () => {
-  describe(switchMap.name, () => {
-    const value = Math.random()
-    const stream = pipe(
-      now(value),
-      switchMap((a) => now(a + 1)),
-    )
-
-    it('is collectable', async () => {
-      const events = await collectAll(stream)
-      deepStrictEqual(events, [value + 1])
-    })
-
-    it('is collectable with multiple subscribers', async () => {
-      const events = await Promise.all([collectAll(stream), collectAll(stream)])
-      deepStrictEqual(events, [[value + 1], [value + 1]])
-    })
-
-    it('cancels the previous stream', async () => {
-      const stream = pipe(
-        at(Delay(0))(1),
-        merge(at(Delay(50))(5)),
-        switchMap((a) => pipe(now(a), merge(at(Delay(100))(a + 1)))),
-      )
-
-      const events = await collectAll(stream)
-      deepStrictEqual(events, [1, 5, 6])
-    })
-  })
-})

package/src/Stream/switchMap.ts

@@ -1,159 +0,0 @@
-import { flow, pipe } from 'hkt-ts'
-import { isRight } from 'hkt-ts/Either'
-import { isJust } from 'hkt-ts/Maybe'
-
-import { Stream } from './Stream.js'
-import { MapStream } from './map.js'
-
-import { Cause } from '@/Cause/index.js'
-import { Disposable, Settable, settable } from '@/Disposable/Disposable.js'
-import { Env } from '@/Env/Env.js'
-import { Fiber } from '@/Fiber/Fiber.js'
-import { FiberContext } from '@/FiberContext/FiberContext.js'
-import { Live } from '@/FiberId/FiberId.js'
-import * as FiberRefs from '@/FiberRefs/index.js'
-import * as Fx from '@/Fx/index.js'
-import { access, lazy, unit } from '@/Fx/index.js'
-import { Scheduler } from '@/Scheduler/Scheduler.js'
-import { Lock } from '@/Semaphore/Semaphore.js'
-import * as Sink from '@/Sink/Sink.js'
-import { None, and } from '@/Supervisor/Supervisor.js'
-
-export function switchMap<A, R2, E2, B>(
-  f: (a: A) => Stream<R2, E2, B>,
-  __trace?: string,
-): <R, E>(stream: Stream<R, E, A>) => Stream<R | R2, E | E2, B> {
-  return (stream) => SwitchMapStream.make(stream, f, __trace)
-}
-
-export function switchLatest<R, E, R2, E2, A>(
-  stream: Stream<R, E, Stream<R2, E2, A>>,
-  __trace?: string,
-): Stream<R | R2, E | E2, A> {
-  return switchMap((a: Stream<R2, E2, A>) => a, __trace)(stream)
-}
-
-export class SwitchMapStream<R, E, A, R2, E2, B> implements Stream<R | R2, E | E2, B> {
-  constructor(
-    readonly stream: Stream<R, E, A>,
-    readonly f: (a: A) => Stream<R2, E2, B>,
-    readonly __trace?: string,
-  ) {}
-
-  fork<E3>(sink: Sink.Sink<E | E2, B, E3>, scheduler: Scheduler, context: FiberContext<Live>) {
-    const { stream, f } = this
-
-    return access((env: Env<R | R2>) =>
-      stream.fork(
-        new SwitchMapSink(sink, scheduler, context, f, env, this.__trace),
-        scheduler,
-        context,
-      ),
-    )
-  }
-
-  static make<R, E, A, R2, E2, B>(
-    stream: Stream<R, E, A>,
-    f: (a: A) => Stream<R2, E2, B>,
-    __trace?: string,
-  ): Stream<R | R2, E | E2, B> {
-    if (stream instanceof MapStream) {
-      return SwitchMapStream.make(stream.stream, flow(stream.f, f), __trace)
-    }
-
-    return new SwitchMapStream(stream, f, __trace)
-  }
-}
-
-class SwitchMapSink<R, E, A, R2, E2, B, E3> implements Sink.Sink<E | E2, A, E3> {
-  protected _ended = false
-  protected _fibers: Array<Fiber<E3, any>> = []
-  protected _lock = new Lock()
-
-  protected _supervisor = None.extend({
-    onEnd: () => (fiber, exit) => {
-      const parentContext = fiber.context.parent
-
-      // Merge FiberRefs upon successful completion
-      if (isRight(exit) && isJust(parentContext)) {
-        FiberRefs.join(parentContext.value.fiberRefs, fiber.context.fiberRefs)
-      }
-    },
-  })
-
-  constructor(
-    readonly sink: Sink.Sink<E | E2, B, E3>,
-    readonly scheduler: Scheduler,
-    readonly context: FiberContext<Live>,
-    readonly f: (a: A) => Stream<R2, E2, B>,
-    readonly env: Env<R | R2>,
-    readonly __trace?: string,
-  ) {}
-
-  event = (a: A): Fx.IO<E3, unknown> =>
-    Fx.lazy(() => {
-      const forked = this.context.fork({
-        supervisor: and(this._supervisor)(this.context.supervisor),
-      })
-
-      const cleanup: Fx.Of<unknown> = Fx.zipAll(this._fibers.map((f) => f.interruptAs(forked.id)))
-      const disposable = settable()
-      const sink = this.innerSink(disposable)
-
-      return pipe(
-        cleanup, // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        Fx.flatMap(() => this.f(a).fork(Sink.addTrace(sink, this.__trace), this.scheduler, forked)),
-        Fx.tapLazy((fiber) => {
-          this._fibers.push(fiber)
-
-          disposable.add(
-            Disposable(() => {
-              this._fibers.splice(this._fibers.indexOf(fiber), 1)
-            }),
-          )
-        }),
-        Fx.flatMap((fiber) =>
-          pipe(
-            fiber,
-            Fx.join,
-            Fx.tapLazy(() => disposable.dispose()),
-          ),
-        ),
-        (x) => x,
-        Fx.provide(this.env),
-      )
-    })
-
-  error = (cause: Cause<E | E2>) => {
-    return lazy(() => {
-      this._ended = true
-
-      return this.sink.error(cause)
-    })
-  }
-
-  end = lazy(() => {
-    this._ended = true
-
-    return this.endIfCompleted()
-  })
-
-  protected endIfCompleted() {
-    if (this._ended && this._fibers.length === 0) {
-      return this.sink.end
-    }
-
-    return unit
-  }
-
-  protected innerSink(disposable: Settable): Sink.Sink<E | E2, B, E3> {
-    return {
-      event: this.sink.event,
-      error: this.error,
-      end: lazy(() => {
-        disposable.dispose()
-        return this.endIfCompleted()
-      }),
-    }
-  }
-}

package/src/Stream/tap.ts

@@ -1,24 +0,0 @@
-import { pipe } from 'hkt-ts/function'
-
-import { Stream } from './Stream.js'
-import { flatMapFx } from './flatMapFx.js'
-
-import { Fx, fromLazy, map } from '@/Fx/Fx.js'
-
-export const tap =
-  <A, R2, E2, B>(f: (a: A) => Fx<R2, E2, B>, __trace?: string) =>
-  <R, E>(stream: Stream<R, E, A>): Stream<R | R2, E | E2, A> =>
-    pipe(
-      stream,
-      flatMapFx(
-        (a) =>
-          pipe(
-            f(a),
-            map(() => a),
-          ),
-        __trace,
-      ),
-    )
-
-export const tapLazy = <A, B>(f: (a: A) => B, __trace?: string) =>
-  tap((a: A) => fromLazy(() => f(a)), __trace)

package/src/Supervisor/Supervisor.ts

@@ -1,63 +0,0 @@
-import { constVoid } from 'hkt-ts'
-
-import { AnyExit } from '@/Exit/Exit.js'
-import { AnyLiveFiber } from '@/Fiber/Fiber.js'
-import { AnyFx, Of, unit, zipAll } from '@/Fx/Fx.js'
-import { AnyInstruction } from '@/Fx/Instruction.js'
-
-export class Supervisor<A> {
-  constructor(
-    readonly value: Of<A>,
-    readonly onStart: (fiber: AnyLiveFiber, fx: AnyFx) => void = constVoid,
-    readonly onEnd: (fiber: AnyLiveFiber, exit: AnyExit) => void = constVoid,
-    readonly onInstruction: (fiber: AnyLiveFiber, instruction: AnyInstruction) => void = constVoid,
-    readonly onSuspended: (fiber: AnyLiveFiber) => void = constVoid,
-    readonly onRunning: (fiber: AnyLiveFiber) => void = constVoid,
-  ) {}
-
-  readonly extend = <B = A>(
-    overrides: Partial<{
-      readonly [K in keyof Supervisor<A>]: (parent: Supervisor<A>[K]) => Supervisor<B>[K]
-    }>,
-  ): Supervisor<B> =>
-    new Supervisor(
-      (overrides.value ? overrides.value(this.value) : this.value) as Of<B>,
-      overrides.onStart ? overrides.onStart(this.onStart) : this.onStart,
-      overrides.onEnd ? overrides.onEnd(this.onEnd) : this.onEnd,
-      overrides.onInstruction ? overrides.onInstruction(this.onInstruction) : this.onInstruction,
-      overrides.onSuspended ? overrides.onSuspended(this.onSuspended) : this.onSuspended,
-      overrides.onRunning ? overrides.onRunning(this.onRunning) : this.onRunning,
-    )
-}
-
-export const None = new (class None extends Supervisor<any> {})(unit)
-export type None = typeof None
-
-export const isNone = <A>(supervisor: Supervisor<A>): supervisor is None => supervisor === None
-
-export function and<B>(second: Supervisor<B>) {
-  return <A>(first: Supervisor<A>) =>
-    new Supervisor<readonly [A, B]>(
-      zipAll([first.value, second.value]),
-      (fiber, fx) => {
-        first.onStart(fiber, fx)
-        second.onStart(fiber, fx)
-      },
-      (fiber, exit) => {
-        first.onEnd(fiber, exit)
-        second.onEnd(fiber, exit)
-      },
-      (fiber, instr) => {
-        first.onInstruction(fiber, instr)
-        second.onInstruction(fiber, instr)
-      },
-      (fiber) => {
-        first.onSuspended(fiber)
-        second.onSuspended(fiber)
-      },
-      (fiber) => {
-        first.onRunning(fiber)
-        second.onRunning(fiber)
-      },
-    )
-}

package/src/Supervisor/index.ts

@@ -1,2 +0,0 @@
-export * from './Supervisor.js'
-export * from './trackIn.js'

package/src/Supervisor/maxFailures.ts

@@ -1,86 +0,0 @@
-import { pipe } from 'hkt-ts'
-import { isRight } from 'hkt-ts/Either'
-import * as Maybe from 'hkt-ts/Maybe'
-import { First } from 'hkt-ts/Typeclass/Associative'
-import { NonNegativeInteger } from 'hkt-ts/number'
-
-import { Supervisor } from './Supervisor.js'
-
-import { Atomic, update } from '@/Atomic/Atomic.js'
-import * as Exit from '@/Exit/Exit.js'
-import { AnyLiveFiber } from '@/Fiber/Fiber.js'
-import { FiberId } from '@/FiberId/index.js'
-import { FiberRuntime } from '@/FiberRuntime/FiberRuntime.js'
-import { AnyFx, fromLazy } from '@/Fx/index.js'
-import { ImmutableMap } from '@/ImmutableMap/ImmutableMap.js'
-
-const concatExitSeq = Exit.makeSequentialAssociative<any, any>(First).concat
-
-export interface FiberFailureState {
-  readonly fx: AnyFx
-  readonly fiber: AnyLiveFiber
-  readonly exit: Maybe.Maybe<Exit.AnyExit>
-  readonly failures: NonNegativeInteger
-}
-
-export interface FiberFailuresState extends ImmutableMap<FiberId.Live, FiberFailureState> {}
-
-export function maxFailures(maxFailures: NonNegativeInteger): Supervisor<FiberFailuresState> {
-  const state = Atomic<FiberFailuresState>(ImmutableMap())
-
-  return new Supervisor(
-    fromLazy(state.get),
-    (fiber, fx) => {
-      pipe(
-        state,
-        update((fibers) => {
-          return fibers.has(fiber.id)
-            ? fibers
-            : fibers.set(fiber.id, {
-                fx,
-                fiber,
-                exit: Maybe.Nothing,
-                failures: NonNegativeInteger(0),
-              })
-        }),
-      )
-    },
-    (fiber, exit) => {
-      pipe(
-        state,
-        update((fibers) =>
-          pipe(
-            fibers.get(fiber.id),
-            Maybe.match(
-              () => fibers,
-              (s) => {
-                const nextIteration = NonNegativeInteger(s.failures + 1)
-
-                // If we succeeded, remove the fiber from state.
-                if (isRight(exit) || nextIteration > maxFailures) {
-                  return fibers.remove(fiber.id)
-                }
-
-                // Retry this Fx
-                const nextFiber = new FiberRuntime(s.fx, s.fiber.context.fork())
-
-                nextFiber.startAsync()
-
-                return fibers.set(fiber.id, {
-                  ...s,
-                  exit: pipe(
-                    s.exit,
-                    Maybe.map((e) => concatExitSeq(e, exit)),
-                    Maybe.orElse(() => Maybe.Just(exit)),
-                  ),
-                  fiber: nextFiber,
-                  failures: nextIteration,
-                })
-              },
-            ),
-          ),
-        ),
-      )
-    },
-  )
-}

package/src/Supervisor/trackIn.ts

@@ -1,33 +0,0 @@
-import { pipe } from 'hkt-ts/function'
-
-import { Supervisor } from './Supervisor.js'
-
-import { Atomic, update } from '@/Atomic/Atomic.js'
-import { AnyLiveFiber } from '@/Fiber/Fiber.js'
-import { FiberId } from '@/FiberId/FiberId.js'
-import { fromLazy } from '@/Fx/Fx.js'
-
-export function trackIn(
-  fibers: Atomic<ReadonlyMap<FiberId.Live, AnyLiveFiber>> = Atomic<
-    ReadonlyMap<FiberId.Live, AnyLiveFiber>
-  >(new Map()),
-): Supervisor<ReadonlyMap<FiberId.Live, AnyLiveFiber>> {
-  return new Supervisor(
-    fromLazy(() => fibers.get()),
-    (fiber) => {
-      pipe(
-        fibers,
-        update((fibers) => new Map([...fibers, [fiber.id, fiber]])),
-      )
-    },
-    (fiber) => {
-      pipe(
-        fibers,
-        update(
-          (fibers) =>
-            new Map([...fibers].filter(([id]) => id.sequenceNumber !== fiber.id.sequenceNumber)),
-        ),
-      )
-    },
-  )
-}