@typed/fx 0.0.8 → 0.0.9

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,107 +0,0 @@
-import { pipe } from 'hkt-ts'
-
-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 Fx from '@/Fx/index.js'
-import { access, lazy, unit } from '@/Fx/index.js'
-import { Scheduler } from '@/Scheduler/Scheduler.js'
-import * as Sink from '@/Sink/Sink.js'
-import * as Supervisor from '@/Supervisor/index.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>) =>
-      stream.fork(
-        new OrElseSink(sink, scheduler, context, f, env, this.__trace),
-        scheduler,
-        context,
-      ),
-    )
-  }
-
-  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
-
-  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: Supervisor.and(Supervisor.inheritFiberRefs)(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/provide.test.ts

@@ -1,78 +0,0 @@
-import { deepStrictEqual } from 'assert'
-
-import { pipe } from 'hkt-ts'
-
-import { collectAll } from './_internal.test.js'
-
-import * as Stream from './index.js'
-
-import { Env } from '@/Env/Env.js'
-import * as Fx from '@/Fx/index.js'
-import { Id } from '@/Service/Id.js'
-import { testSuite } from '@/_internal/suite.js'
-
-testSuite(import.meta.url, () => {
-  const value = Math.random()
-  class Foo extends Id {
-    constructor(readonly foo: typeof value) {
-      super()
-    }
-  }
-
-  describe('provide', () => {
-    it('should provide the environment', async () => {
-      const stream = pipe(
-        Stream.now(value),
-        Stream.flatMapFx((a) =>
-          pipe(
-            Foo.ask(),
-            Fx.flatMap((foo) => Fx.now(a + foo.foo)),
-          ),
-        ),
-        Stream.provide(Env(Foo.id(), new Foo(value))),
-      )
-
-      const events = await collectAll(stream)
-
-      deepStrictEqual(events, [value * 2])
-    })
-  })
-
-  describe('provideService', () => {
-    it('should provide the service', async () => {
-      const stream = pipe(
-        Stream.now(value),
-        Stream.flatMapFx((a) =>
-          pipe(
-            Foo.ask(),
-            Fx.flatMap((foo) => Fx.now(a + foo.foo)),
-          ),
-        ),
-        Stream.provideService(Foo.id(), new Foo(value)),
-      )
-
-      const events = await collectAll(stream)
-
-      deepStrictEqual(events, [value * 2])
-    })
-  })
-
-  describe('provideLayer', () => {
-    it('should provide the layer', async () => {
-      const stream = pipe(
-        Stream.now(value),
-        Stream.flatMapFx((a) =>
-          pipe(
-            Foo.ask(),
-            Fx.flatMap((foo) => Fx.now(a + foo.foo)),
-          ),
-        ),
-        Stream.provideLayer(Foo.layerOf(value)),
-      )
-
-      const events = await collectAll(stream)
-
-      deepStrictEqual(events, [value * 2])
-    })
-  })
-})

package/src/Stream/provide.ts

@@ -1,34 +0,0 @@
-import { pipe } from 'hkt-ts'
-
-import { Stream } from './Stream.js'
-
-import { Env } from '@/Env/Env.js'
-import * as Fx from '@/Fx/index.js'
-import { Layer } from '@/Layer/Layer.js'
-import { Service } from '@/Service/Service.js'
-
-export function provide<R>(env: Env<R>) {
-  return <E, A>(stream: Stream<R, E, A>): Stream<never, E, A> =>
-    Stream((sink, scheduler, context) => Fx.provide(env)(stream.fork(sink, scheduler, context)))
-}
-
-export function provideService<S, I extends S>(service: Service<S>, impl: I) {
-  return <R, E, A>(stream: Stream<R, E, A>): Stream<Exclude<R, S>, E, A> =>
-    Stream((sink, scheduler, context) =>
-      pipe(stream.fork(sink, scheduler, context), Fx.provideService(service, impl)),
-    )
-}
-
-export function provideLayer<R2, E2, S>(layer: Layer<R2, E2, S>) {
-  return <R, E, A>(stream: Stream<R | S, E, A>): Stream<Exclude<R | R2, S>, E | E2, A> =>
-    Stream((sink, scheduler, context) =>
-      pipe(
-        Fx.getFiberContext,
-        Fx.flatMap((c) => stream.fork(sink, scheduler, c.fork())),
-        Fx.provideLayer(layer),
-        Fx.orElseCause((cause) => Fx.fork(sink.error(cause))),
-        Fx.flatMap((f) => Fx.join(f)),
-        Fx.forkInContext(context),
-      ),
-    )
-}

package/src/Stream/run.ts

@@ -1,17 +0,0 @@
-import { 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<Scheduler, E, A>): Fx.Fx<never, E, unknown> =>
-    pipe(drain(stream), Fx.flatMap(Fx.join), Fx.provideService(Scheduler, scheduler))
-}
-
-export const runMain =
-  (scheduler: Scheduler) =>
-  <E, A>(stream: Stream<Scheduler, E, A>): Promise<unknown> =>
-    pipe(stream, 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])
-    })
-  })
-})

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,38 +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(() => {
-        // SetFiberRef
-        FiberRefs.setFiberRefLocally(this.fiberRef, this.value())(context.fiberRefs)
-
-        // Ensure it is popped off when the stream ends
-        context.scope.ensuring(() =>
-          fromLazy(() => FiberRefs.popLocalFiberRef(this.fiberRef)(context.fiberRefs)),
-        )
-      }),
-      flatMap(() => this.stream.fork(sink, scheduler, context)),
-    )
-  }
-}

package/src/Stream/skipRepeats.ts

@@ -1,41 +0,0 @@
-import { Maybe } from 'hkt-ts'
-import { DeepEquals, Eq } from 'hkt-ts/Typeclass/Eq'
-
-import { Stream } from './Stream.js'
-
-import { unit } from '@/Fx/index.js'
-import { Sink, addTrace } from '@/Sink/Sink.js'
-
-export function skipRepeatsWith<A>(
-  E: Eq<A>,
-  __trace?: string,
-): <R, E>(stream: Stream<R, E, A>) => Stream<R, E, A> {
-  return (stream) =>
-    Stream((sink, scheduler, context) =>
-      stream.fork(addTrace(new SkipRepeatsSink(sink, E), __trace), scheduler, context),
-    )
-}
-
-export function skipRepeats<R, E, A>(stream: Stream<R, E, A>, __trace?: string): Stream<R, E, A> {
-  return skipRepeatsWith<A>(DeepEquals, __trace)(stream)
-}
-
-class SkipRepeatsSink<E, A, E2> implements Sink<E, A, E2> {
-  constructor(readonly sink: Sink<E, A, E2>, readonly E: Eq<A>) {}
-
-  protected last: Maybe.Maybe<A> = Maybe.Nothing
-  protected elem = Maybe.contains(this.E)
-
-  event(value: A) {
-    if (this.elem(value)(this.last)) {
-      return unit
-    }
-
-    this.last = Maybe.Just(value)
-
-    return this.sink.event(value)
-  }
-
-  error = this.sink.error
-  end = this.sink.end
-}

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])
-    })
-  })
-})