@typed/fx 0.0.4 → 0.0.8

package/src/Stream/provide.test.ts

@@ -0,0 +1,78 @@
+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

@@ -0,0 +1,34 @@
+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,4 +1,4 @@
-import { flow, pipe } from 'hkt-ts/function'
+import { pipe } from 'hkt-ts/function'
 
 import { Stream } from './Stream.js'
 import { drain } from './drain.js'
@@ -7,8 +7,11 @@ 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> =>
+  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) => flow(run(scheduler), Fx.runMain)
+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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,46 @@
+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

@@ -3,7 +3,7 @@ import { deepStrictEqual } from 'assert'
 import { NonNegativeInteger } from 'hkt-ts/number'
 
 import { collectAll } from './_internal.test.js'
-import { scheduled } from './scheduled.js'
+import { at, scheduled } from './scheduled.js'
 
 import * as Fx from '@/Fx/index.js'
 import * as Schedule from '@/Schedule/index.js'
@@ -31,4 +31,12 @@ testSuite(import.meta.url, () => {
       )
     })
   })
+
+  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,21 +1,55 @@
+import { pipe } from 'hkt-ts'
+import { NonNegativeInteger } from 'hkt-ts/number'
+
 import { Stream } from './Stream.js'
 
 import { Env } from '@/Env/Env.js'
-import * as Fx from '@/Fx/Fx.js'
-import { span } from '@/Fx/logging.js'
-import { Schedule } from '@/Schedule/Schedule.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) {
+export function scheduled(schedule: Schedule.Schedule, __trace?: string) {
   return <R, E, A>(fx: Fx.Fx<R, E, A>): Stream<R, E, A> =>
-    Stream((sink, scheduler, context) =>
-      Fx.asksEnv((env: Env<R>) =>
-        scheduler.schedule(
-          Fx.matchCause(sink.error, sink.event)(fx),
-          env,
-          schedule,
-          context,
-          span('Stream.scheduled'),
+    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

@@ -0,0 +1,38 @@
+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

@@ -0,0 +1,41 @@
+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

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,145 @@
+import { flow, pipe } from 'hkt-ts'
+
+import { Stream } from './Stream.js'
+import { MapStream } from './bimap.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 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 * as Supervisor from '@/Supervisor/index.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()
+
+  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: Supervisor.and(Supervisor.inheritFiberRefs)(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

@@ -3,10 +3,10 @@ import { pipe } from 'hkt-ts/function'
 import { Stream } from './Stream.js'
 import { flatMapFx } from './flatMapFx.js'
 
-import { Fx, map } from '@/Fx/Fx.js'
+import { Fx, fromLazy, map } from '@/Fx/Fx.js'
 
 export const tap =
-  <A, R2, E2, B>(f: (a: A) => Fx<R2, E2, B>) =>
+  <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,
@@ -16,6 +16,9 @@ export const tap =
             f(a),
             map(() => a),
           ),
-        'Stream.tap',
+        __trace,
       ),
     )
+
+export const tapLazy = <A, B>(f: (a: A) => B, __trace?: string) =>
+  tap((a: A) => fromLazy(() => f(a)), __trace)

package/src/Supervisor/index.ts

@@ -1,2 +1,4 @@
+export * from './inheritFiberRefs.js'
+export * from './maxFailures.js'
 export * from './Supervisor.js'
 export * from './trackIn.js'

package/src/Supervisor/inheritFiberRefs.ts

@@ -0,0 +1,17 @@
+import { isRight } from 'hkt-ts/Either'
+import { isJust } from 'hkt-ts/Maybe'
+
+import { None } from './Supervisor.js'
+
+import { join } from '@/FiberRefs/FiberRefs.js'
+
+export const inheritFiberRefs = None.extend({
+  onEnd: () => (fiber, exit) => {
+    const parentContext = fiber.context.parent
+
+    // Merge FiberRefs upon successful completion
+    if (isRight(exit) && isJust(parentContext)) {
+      join(parentContext.value.fiberRefs, fiber.context.fiberRefs)
+    }
+  },
+})

package/src/Timeline/index.ts

@@ -51,6 +51,7 @@ class TimelineImpl<A> implements Timeline<A> {
 
   readonly add = (time: UnixTime, a: A): Disposable => {
     insertByTime(time, a, this.timeSlots)
+
     this.onUpdated?.()
 
     return Disposable(() => this.remove(time, a))