@typed/fx 0.0.4 → 0.0.6

package/src/Stream/hold.ts

@@ -0,0 +1,117 @@
+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,14 +1,22 @@
+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

@@ -0,0 +1,5 @@
+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,6 +1,7 @@
 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'
@@ -13,9 +14,13 @@ testSuite(import.meta.url, () => {
   describe('Logging Streams', () => {
     it('should log the stream', async () => {
       const stream = pipe(
-        now(1),
-        continueWith(() => now(2)),
-        tap(flow(String, Fx.log)),
+        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

@@ -5,31 +5,45 @@ 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 } from '@/Sink/Sink.js'
+import { Sink, addTrace } from '@/Sink/Sink.js'
 
-export function map<A, B>(f: (a: A) => B): <R, E>(stream: Stream<R, E, A>) => Stream<R, E, B> {
-  return (stream) => MapStream.make(stream, f)
+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) {}
+  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(
-      {
-        ...sink,
-        event: flow(this.f, sink.event),
-      },
+      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): Stream<R, E, B> {
+  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))
+      return MapStream.make(stream.stream, flow(stream.f, f), __trace)
     }
 
-    return new MapStream(stream, f)
+    return new MapStream(stream, f, __trace)
   }
 }

package/src/Stream/merge.test.ts

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

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

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

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

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

@@ -5,5 +5,5 @@ 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): Stream<never, never, void> =>
-  scheduled(Schedule.periodic(period))(Fx.unit)
+export const periodic = (period: Delay, __trace?: string): Stream<never, never, void> =>
+  scheduled(Schedule.periodic(period), __trace)(Fx.unit)

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