@typed/fx 0.0.6 → 0.0.9

package/src/Stream/hold.ts

@@ -1,117 +0,0 @@
-import { pipe } from 'hkt-ts'
-import { Just, Maybe, Nothing, isJust, toArray } from 'hkt-ts/Maybe'
-
-import { Stream } from './Stream.js'
-import { MulticastStream } from './multicast.js'
-
-import { Cause } from '@/Cause/index.js'
-import { Fiber } from '@/Fiber/Fiber.js'
-import { FiberContext } from '@/FiberContext/FiberContext.js'
-import { FiberId } from '@/FiberId/FiberId.js'
-import { getServiceFromFiberRefs } from '@/FiberRef/builtins.js'
-import * as Fx from '@/Fx/index.js'
-import { Scheduler } from '@/Scheduler/Scheduler.js'
-import { Sink } from '@/Sink/Sink.js'
-
-export function hold<R, E, A>(stream: Stream<R, E, A>) {
-  return new HoldStream(stream)
-}
-
-export class HoldStream<R, E, A> extends MulticastStream<R, E, A> implements Stream<R, E, A> {
-  protected value: Maybe<A> = Nothing
-  protected pendingSinks: Array<readonly [Sink<E, A, never>, FiberContext<FiberId.Live>, A[]]> = []
-  protected scheduledFiber: Fiber<any, any> | undefined
-
-  constructor(readonly stream: Stream<R, E, A>) {
-    super(stream)
-  }
-
-  fork<E2>(sink: Sink<E, A, E2>, scheduler: Scheduler, context: FiberContext<FiberId.Live>) {
-    if (this.shouldScheduleFlush()) {
-      return pipe(
-        this.scheduleFlush(sink, scheduler, context),
-        Fx.flatMap(() => super.fork(sink, scheduler, context)),
-      )
-    }
-
-    return super.fork(sink, scheduler, context)
-  }
-
-  event = (value: A) => {
-    this.addValue(value)
-
-    return pipe(
-      this.flushPending(),
-      Fx.flatMap(() => super.event(value)),
-    )
-  }
-
-  error = (cause: Cause<E>) => {
-    return pipe(
-      this.flushPending(),
-      Fx.flatMap(() => super.error(cause)),
-    )
-  }
-
-  get end() {
-    return pipe(
-      this.flushPending(),
-      Fx.flatMap(() => super.end),
-    )
-  }
-
-  shouldScheduleFlush() {
-    return isJust(this.value) && this.observers.length > 0
-  }
-
-  flushPending(): Fx.Of<unknown> {
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
-    const that = this
-
-    if (this.pendingSinks.length > 0) {
-      return Fx.zipAll(
-        this.pendingSinks.map((observer) =>
-          observer[2].length > 0
-            ? pipe(
-                Fx.Fx(function* () {
-                  that.pendingSinks.splice(that.pendingSinks.indexOf(observer), 1)
-
-                  for (const a of observer[2]) {
-                    yield* Fx.forkJoinInContext(observer[1].fork())(observer[0].event(a))
-                  }
-                }),
-              )
-            : Fx.unit,
-        ),
-      )
-    }
-
-    return Fx.unit
-  }
-
-  scheduleFlush<E2>(
-    sink: Sink<E, A, E2>,
-    scheduler: Scheduler,
-    context: FiberContext<FiberId.Live>,
-  ): Fx.Of<unknown> {
-    this.pendingSinks.push([sink as any, context, [...toArray(this.value)]])
-
-    const fx = this.scheduledFiber ? this.scheduledFiber.interruptAs(FiberId.None) : Fx.unit
-
-    this.scheduledFiber = scheduler.asap(
-      this.flushPending(),
-      { get: getServiceFromFiberRefs(context.fiberRefs.fork()) },
-      context.fork(),
-    )
-
-    return fx
-  }
-
-  protected addValue(value: A) {
-    this.value = Just(value)
-
-    this.pendingSinks.forEach(([, , values]) => {
-      values.push(value)
-    })
-  }
-}

package/src/Stream/index.ts

@@ -1,22 +0,0 @@
-export * from './acquirePermit.js'
-export * from './bimap.js'
-export * from './continueWith.js'
-export * from './drain.js'
-export * from './empty.js'
-export * from './flatMap.js'
-export * from './flatMapConcurrently.js'
-export * from './flatMapFx.js'
-export * from './fromCallback.js'
-export * from './fromFx.js'
-export * from './hkt.js'
-export * from './hold.js'
-export * from './lazy.js'
-export * from './map.js'
-export * from './merge.js'
-export * from './multicast.js'
-export * from './periodic.js'
-export * from './setFiberRefLocally.js'
-export * from './scan.js'
-export * from './scheduled.js'
-export * from './Stream.js'
-export * from './tap.js'

package/src/Stream/lazy.ts

@@ -1,5 +0,0 @@
-import { Stream } from './Stream.js'
-
-export function lazy<R, E, A>(f: () => Stream<R, E, A>): Stream<R, E, A> {
-  return Stream((sink, scheduler, context) => f().fork(sink, scheduler, context))
-}

package/src/Stream/logging.test.ts

@@ -1,29 +0,0 @@
-import { flow, pipe } from 'hkt-ts'
-
-import { continueWith } from './continueWith.js'
-import { flatMap } from './flatMap.js'
-import { now } from './fromFx.js'
-import { runMain } from './run.js'
-import { tap } from './tap.js'
-
-import * as Fx from '@/Fx/index.js'
-import { RootScheduler } from '@/Scheduler/RootScheduler.js'
-import { testSuite } from '@/_internal/suite.js'
-
-testSuite(import.meta.url, () => {
-  describe('Logging Streams', () => {
-    it('should log the stream', async () => {
-      const stream = pipe(
-        now(1, 'now1'),
-        continueWith(() => now(2, 'now2'), 'continueWith'),
-        flatMap((n) => now(n + 1, 'now+1'), 'flatMap'),
-        tap(
-          flow((n) => String(n), Fx.log),
-          'tap',
-        ),
-      )
-
-      await runMain(RootScheduler())(stream)
-    })
-  })
-})

package/src/Stream/map.ts

@@ -1,49 +0,0 @@
-import { flow } from 'hkt-ts/function'
-
-import { Stream } from './Stream.js'
-
-import { FiberContext } from '@/FiberContext/FiberContext.js'
-import { Live } from '@/FiberId/FiberId.js'
-import { Scheduler } from '@/Scheduler/Scheduler.js'
-import { Sink, addTrace } from '@/Sink/Sink.js'
-
-export function map<A, B>(
-  f: (a: A) => B,
-  __trace?: string,
-): <R, E>(stream: Stream<R, E, A>) => Stream<R, E, B> {
-  return (stream) => MapStream.make(stream, f, __trace)
-}
-
-export class MapStream<R, E, A, B> implements Stream<R, E, B> {
-  constructor(
-    readonly stream: Stream<R, E, A>,
-    readonly f: (a: A) => B,
-    readonly __trace?: string,
-  ) {}
-
-  fork<E2>(sink: Sink<E, B, E2>, scheduler: Scheduler, context: FiberContext<Live>) {
-    return this.stream.fork(
-      addTrace(
-        {
-          ...sink,
-          event: flow(this.f, sink.event),
-        },
-        this.__trace,
-      ),
-      scheduler,
-      context,
-    )
-  }
-
-  static make<R, E, A, B>(
-    stream: Stream<R, E, A>,
-    f: (a: A) => B,
-    __trace?: string,
-  ): Stream<R, E, B> {
-    if (stream instanceof MapStream) {
-      return MapStream.make(stream.stream, flow(stream.f, f), __trace)
-    }
-
-    return new MapStream(stream, f, __trace)
-  }
-}

package/src/Stream/merge.test.ts

@@ -1,31 +0,0 @@
-import { deepStrictEqual } from 'assert'
-
-import { pipe } from 'hkt-ts/function'
-
-import { collectAll } from './_internal.test.js'
-import { fromCallback } from './fromCallback.js'
-import { merge } from './merge.js'
-
-import { testSuite } from '@/_internal/suite.js'
-
-testSuite(import.meta.url, () => {
-  const stream = pipe(
-    fromCallback<never, number>(async ({ event, end }) => {
-      await event(1)
-      await event(2)
-      await event(3)
-      await end()
-    }),
-    merge(
-      fromCallback<never, number>(async ({ event, end }) => {
-        await event(4)
-        await event(5)
-        await end()
-      }),
-    ),
-  )
-
-  it('merges together 2 streams concurrenctly', async () => {
-    deepStrictEqual(await collectAll(stream), [1, 4, 2, 5, 3])
-  })
-})

package/src/Stream/merge.ts

@@ -1,76 +0,0 @@
-import { NonNegativeInteger } from 'hkt-ts/number'
-
-import { ErrorsOf, OutputOf, ResourcesOf, Stream } from './Stream.js'
-import { empty } from './empty.js'
-
-import { AtomicCounter, decrement } from '@/Atomic/AtomicCounter.js'
-import { Fiber } from '@/Fiber/Fiber.js'
-import { both } from '@/Fiber/hkt.js'
-import { FiberContext } from '@/FiberContext/FiberContext.js'
-import { Live } from '@/FiberId/FiberId.js'
-import * as Fx from '@/Fx/index.js'
-import { Scheduler } from '@/Scheduler/Scheduler.js'
-import { Sink, addTrace } from '@/Sink/Sink.js'
-
-export function merge<R2, E2, B>(second: Stream<R2, E2, B>, __trace?: string) {
-  return <R, E, A>(first: Stream<R, E, A>): Stream<R | R2, E | E2, A | B> =>
-    MergeStream.make(first, second, __trace)
-}
-
-export function mergeArray<Streams extends ReadonlyArray<Stream<any, any, any>>>(
-  streams: readonly [...Streams],
-  __trace?: string,
-): Stream<ResourcesOf<Streams[number]>, ErrorsOf<Streams[number]>, OutputOf<Streams[number]>> {
-  if (streams.length === 0) {
-    return empty
-  }
-
-  const [first, ...rest] = streams
-
-  return rest.reduce((acc, stream) => merge(stream, __trace)(acc), first)
-}
-
-export class MergeStream<R, E, A, R2, E2, B> implements Stream<R | R2, E | E2, A | B> {
-  constructor(
-    readonly first: Stream<R, E, A>,
-    readonly second: Stream<R2, E2, B>,
-    readonly __trace?: string,
-  ) {}
-
-  fork = <E3>(sink: Sink<E | E2, A | B, E3>, scheduler: Scheduler, context: FiberContext<Live>) => {
-    const { first, second, __trace } = this
-    const mergeSink = addTrace(
-      new MergeSink<E | E2, A | B, E3>(sink, AtomicCounter(NonNegativeInteger(2))),
-      __trace,
-    )
-
-    return Fx.Fx(function* () {
-      const firstFiber: Fiber<E3, any> = yield* first.fork(mergeSink, scheduler, context)
-      const secondFiber: Fiber<E3, any> = yield* second.fork(mergeSink, scheduler, context.fork())
-
-      return both(secondFiber)(firstFiber)
-    })
-  }
-
-  static make<R, E, A, R2, E2, B>(
-    first: Stream<R, E, A>,
-    second: Stream<R2, E2, B>,
-    __trace?: string,
-  ): Stream<R | R2, E | E2, A | B> {
-    return new MergeStream(first, second, __trace)
-  }
-}
-
-class MergeSink<E, A, E2> implements Sink<E, A, E2> {
-  constructor(readonly sink: Sink<E, A, E2>, readonly refCount: AtomicCounter) {}
-
-  event = this.sink.event
-  error = this.sink.error
-  end = Fx.lazy(() => {
-    if (decrement(this.refCount) === 0) {
-      return this.sink.end
-    }
-
-    return Fx.unit
-  })
-}

package/src/Stream/multicast.test.ts

@@ -1,32 +0,0 @@
-import { deepStrictEqual } from 'assert'
-
-import { collectAll } from './_internal.test.js'
-import { fromCallback } from './fromCallback.js'
-import { multicast } from './multicast.js'
-
-import { testSuite } from '@/_internal/suite.js'
-
-testSuite(import.meta.url, () => {
-  describe(multicast.name, () => {
-    it('effeciently shares underlying stream', async () => {
-      let started = 0
-      const value = Math.random()
-      const stream = multicast(
-        fromCallback<never, number>(async ({ event, end }) => {
-          started++
-          event(value)
-          event(value + 1)
-          event(value + 2)
-          end()
-        }),
-      )
-
-      const a = collectAll(stream)
-      const b = collectAll(stream)
-
-      deepStrictEqual(await a, [value, value + 1, value + 2])
-      deepStrictEqual(await b, [value, value + 1, value + 2])
-      deepStrictEqual(started, 1)
-    })
-  })
-})

package/src/Stream/multicast.ts

@@ -1,114 +0,0 @@
-import { pipe } from 'hkt-ts'
-
-import { Stream } from './Stream.js'
-
-import { Cause } from '@/Cause/Cause.js'
-import { fromScope } from '@/Fiber/fromScope.js'
-import { FiberContext } from '@/FiberContext/FiberContext.js'
-import { FiberId } from '@/FiberId/index.js'
-import * as Fx from '@/Fx/index.js'
-import { Scheduler } from '@/Scheduler/index.js'
-import { Sink } from '@/Sink/Sink.js'
-import { Fiber } from '@/index.js'
-
-export function multicast<R, E, A>(stream: Stream<R, E, A>) {
-  return new MulticastStream(stream)
-}
-
-type Observer<E, A, E2> = {
-  sink: Sink<E, A, E2>
-  scheduler: Scheduler
-  context: FiberContext<FiberId.Live>
-}
-
-// TODO: how to create a synthetic fiber around multicasted streams?
-
-export class MulticastStream<R, E, A> implements Stream<R, E, A>, Sink<E, A, any> {
-  protected observers: Array<Observer<E, A, any>> = []
-  protected fiber: Fiber.Fiber<any, any> | undefined
-
-  constructor(readonly stream: Stream<R, E, A>) {
-    this.event = this.event.bind(this)
-    this.error = this.error.bind(this)
-  }
-
-  fork<E2>(sink: Sink<E, A, E2>, scheduler: Scheduler, context: FiberContext<FiberId.Live>) {
-    return Fx.lazy(() => {
-      const observer: Observer<E, A, E2> = {
-        sink,
-        scheduler,
-        context,
-      }
-
-      const l = this.observers.length
-
-      this.observers.push(observer)
-
-      if (l === 0) {
-        return pipe(
-          this.stream.fork(this, scheduler, context),
-          Fx.tapLazy((fiber) => (this.fiber = fiber)),
-          Fx.map(() => this.createFiber(observer)),
-        )
-      }
-
-      return Fx.fromLazy(() => this.createFiber(observer))
-    })
-  }
-
-  event(a: A) {
-    return Fx.zipAll(
-      this.observers.map(({ sink, context }) =>
-        pipe(sink.event(a), Fx.forkJoinInContext(context.fork())),
-      ),
-    )
-  }
-
-  error(cause: Cause<E>) {
-    return pipe(
-      Fx.zipAll(
-        this.observers.map(({ sink, context }) =>
-          pipe(sink.error(cause), Fx.forkJoinInContext(context.fork())),
-        ),
-      ),
-      Fx.tap((): Fx.Of<any> => (this.fiber ? this.fiber.interruptAs(FiberId.None) : Fx.unit)),
-      Fx.tapLazy(() => (this.observers = [])),
-    )
-  }
-
-  get end() {
-    return pipe(
-      Fx.lazy(() =>
-        Fx.zipAll(
-          this.observers.map(({ sink, context }) =>
-            pipe(sink.end, Fx.forkJoinInContext(context.fork())),
-          ),
-        ),
-      ),
-      Fx.tapLazy(() => (this.observers = [])),
-    )
-  }
-
-  protected createFiber = <E2>(observer: Observer<E, A, E2>) => {
-    const { context } = observer
-    context.scope.ensuring(() =>
-      pipe(
-        Fx.fromLazy(() => {
-          const index = this.observers.indexOf(observer)
-
-          if (index >= 0) {
-            this.observers.splice(index, 1)
-          }
-        }),
-        Fx.flatMap(
-          (): Fx.Of<any> =>
-            this.observers.length === 0 && this.fiber
-              ? this.fiber.interruptAs(context.id)
-              : Fx.unit,
-        ),
-      ),
-    )
-
-    return fromScope(new FiberId.Synthetic([context.id]), context.fiberRefs, context.scope)
-  }
-}

package/src/Stream/orElse.ts

@@ -1,123 +0,0 @@
-import { pipe } from 'hkt-ts'
-import { isRight } from 'hkt-ts/Either'
-import { isJust } from 'hkt-ts/Maybe'
-
-import { Stream } from './Stream.js'
-
-import { AtomicCounter, decrement, increment } from '@/Atomic/AtomicCounter.js'
-import { Cause } from '@/Cause/index.js'
-import { Env } from '@/Env/Env.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, provideService, unit } from '@/Fx/index.js'
-import { Scheduler } from '@/Scheduler/Scheduler.js'
-import * as Sink from '@/Sink/Sink.js'
-import { None, and } from '@/Supervisor/Supervisor.js'
-
-export function orElse<E, R2, E2, B>(
-  f: (cause: Cause<E>) => Stream<R2, E2, B>,
-  __trace?: string,
-): <R, A>(stream: Stream<R, E, A>) => Stream<R | R2, E2, A | B> {
-  return (stream) => OrElseStream.make(stream, f, __trace)
-}
-
-export class OrElseStream<R, E, A, R2, E2, B> implements Stream<R | R2, E2, A | B> {
-  constructor(
-    readonly stream: Stream<R, E, A>,
-    readonly f: (cause: Cause<E>) => Stream<R2, E2, B>,
-    readonly __trace?: string,
-  ) {}
-
-  fork<E3>(sink: Sink.Sink<E2, A | B, E3>, scheduler: Scheduler, context: FiberContext<Live>) {
-    const { stream, f } = this
-
-    return access((env: Env<R | R2>) =>
-      pipe(
-        stream.fork(
-          new OrElseSink(sink, scheduler, context, f, env, this.__trace),
-          scheduler,
-          context,
-        ),
-        provideService(Scheduler, scheduler),
-      ),
-    )
-  }
-
-  static make<R, E, A, R2, E2, B>(
-    stream: Stream<R, E, A>,
-    f: (cause: Cause<E>) => Stream<R2, E2, B>,
-    __trace?: string,
-  ): Stream<R | R2, E2, A | B> {
-    return new OrElseStream(stream, f, __trace)
-  }
-}
-
-class OrElseSink<R, E, A, R2, E2, B, E3> implements Sink.Sink<E, A, E3> {
-  protected _running = AtomicCounter()
-  protected _ended = false
-  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<E2, A | B, E3>,
-    readonly scheduler: Scheduler,
-    readonly context: FiberContext<Live>,
-    readonly f: (cause: Cause<E>) => Stream<R2, E2, B>,
-    readonly env: Env<R | R2>,
-    readonly __trace?: string,
-  ) {}
-
-  event = this.sink.event
-
-  error = (cause: Cause<E>) => {
-    return lazy(() => {
-      const forked = this.context.fork({
-        supervisor: and(this.supervisor)(this.context.supervisor),
-      })
-
-      increment(this._running)
-
-      return pipe(
-        this.f(cause).fork(Sink.addTrace(this.innerSink(), this.__trace), this.scheduler, forked),
-        Fx.provide(this.env),
-      )
-    })
-  }
-
-  end = lazy(() => {
-    this._ended = true
-
-    return this.endIfCompleted()
-  })
-
-  protected endIfCompleted() {
-    return lazy(() => {
-      if (this._ended && this._running.get() === 0) {
-        return this.sink.end
-      }
-
-      return unit
-    })
-  }
-
-  protected innerSink(): Sink.Sink<E2, B, E3> {
-    return {
-      event: this.sink.event,
-      error: this.sink.error,
-      end: lazy(() => {
-        decrement(this._running)
-        return this.endIfCompleted()
-      }),
-    }
-  }
-}

package/src/Stream/periodic.ts

@@ -1,9 +0,0 @@
-import { Stream } from './Stream.js'
-import { scheduled } from './scheduled.js'
-
-import * as Fx from '@/Fx/Fx.js'
-import * as Schedule from '@/Schedule/index.js'
-import { Delay } from '@/Time/index.js'
-
-export const periodic = (period: Delay, __trace?: string): Stream<never, never, void> =>
-  scheduled(Schedule.periodic(period), __trace)(Fx.unit)

package/src/Stream/run.ts

@@ -1,14 +0,0 @@
-import { flow, pipe } from 'hkt-ts/function'
-
-import { Stream } from './Stream.js'
-import { drain } from './drain.js'
-
-import * as Fx from '@/Fx/index.js'
-import { Scheduler } from '@/Scheduler/Scheduler.js'
-
-export function run(scheduler: Scheduler) {
-  return <E, A>(stream: Stream<never, E, A>): Fx.Fx<never, E, unknown> =>
-    pipe(drain(stream), Fx.flatMap(Fx.join), Fx.provideService(Scheduler, scheduler))
-}
-
-export const runMain = (scheduler: Scheduler) => flow(run(scheduler), Fx.runMain)

package/src/Stream/scan.test.ts

@@ -1,28 +0,0 @@
-import { deepStrictEqual } from 'assert'
-
-import { pipe } from 'hkt-ts'
-
-import { collectAll } from './_internal.test.js'
-import { continueWith } from './continueWith.js'
-import { flatMap } from './flatMap.js'
-import { now } from './fromFx.js'
-import { scan } from './scan.js'
-
-import { testSuite } from '@/_internal/suite.js'
-
-testSuite(import.meta.url, () => {
-  describe(scan.name, () => {
-    const stream = pipe(
-      now(1),
-      continueWith(() => now(2)),
-      flatMap((n) => now(n + 1)),
-      scan((acc, n) => acc + n, 0),
-    )
-
-    it('accumulates values', async () => {
-      const values = await collectAll(stream)
-
-      deepStrictEqual(values, [2, 5])
-    })
-  })
-})