@typed/fx 0.0.4 → 0.0.8

package/src/Stream/hkt.ts

@@ -1,18 +1,24 @@
 import { HKT3, Params } from 'hkt-ts'
+import * as AB from 'hkt-ts/Typeclass/AssociativeBoth'
+import * as AF from 'hkt-ts/Typeclass/AssociativeFlatten'
 import * as B from 'hkt-ts/Typeclass/Bicovariant'
+import { Bottom3 } from 'hkt-ts/Typeclass/Bottom'
 import * as C from 'hkt-ts/Typeclass/Covariant'
+import * as FM from 'hkt-ts/Typeclass/FilterMap'
+import * as IB from 'hkt-ts/Typeclass/IdentityBoth'
+import { IdentityFlatten3 } from 'hkt-ts/Typeclass/IdentityFlatten'
+import * as T from 'hkt-ts/Typeclass/Top'
+import { NonNegativeInteger } from 'hkt-ts/number'
 
 import { Stream } from './Stream.js'
-import { bimap } from './bimap.js'
-import { map } from './map.js'
+import { bimap, filterMap, map } from './bimap.js'
+import { join } from './flatMap.js'
+import { mergeConcurrently } from './flatMapConcurrently.js'
+import { fromFx } from './fromFx.js'
+
+import * as Fx from '@/Fx/index.js'
 
-// TODO: AssociativeBoth
 // TOOD: AssociativeEither
-// TODO: Top
-// TODO: Bottom
-// TODO: FilterMap
-// TODO: AssociativeFlatten
-// TODO: IdentityBoth
 // TODO: IdentityEither
 // TODO: IdentityFlatten
 
@@ -24,8 +30,6 @@ export const Bicovariant: B.Bicovariant3<StreamHKT> = {
   bimap,
 }
 
-export const mapLeft = B.mapLeft(Bicovariant)
-
 export const Covariant: C.Covariant3<StreamHKT> = {
   map,
 }
@@ -34,3 +38,48 @@ export const bindTo = C.bindTo(Covariant)
 export const flap = C.flap(Covariant)
 export const mapTo = C.mapTo(Covariant)
 export const tupled = C.tupled(Covariant)
+
+export const Top: T.Top3<StreamHKT> = {
+  top: fromFx(Fx.top),
+}
+
+export const Bottom: Bottom3<StreamHKT> = {
+  bottom: fromFx(Fx.bottom),
+}
+
+export const Flatten: AF.AssociativeFlatten3<StreamHKT> = {
+  flatten: join,
+}
+
+export const IdentityFlatten: IdentityFlatten3<StreamHKT> = {
+  ...Flatten,
+  ...Top,
+}
+
+export const makeFlattenConcurrently = (
+  concurrencyLevel: NonNegativeInteger,
+): AF.AssociativeFlatten3<StreamHKT> => ({
+  flatten: mergeConcurrently(concurrencyLevel),
+})
+
+export const AssociativeBoth = AF.makeAssociativeBoth<StreamHKT>({
+  ...Flatten,
+  ...Covariant,
+})
+
+export const zipLeftSeq = AB.zipLeft<StreamHKT>({ ...AssociativeBoth, ...Covariant })
+export const zipRightSeq = AB.zipRight<StreamHKT>({ ...AssociativeBoth, ...Covariant })
+
+export const IdentityBoth: IB.IdentityBoth3<StreamHKT> = {
+  ...AssociativeBoth,
+  ...Top,
+}
+
+export const structSeq = IB.struct<StreamHKT>({ ...IdentityBoth, ...Covariant })
+
+export const FilterMap: FM.FilterMap3<StreamHKT> = {
+  filterMap,
+}
+
+export const compact = FM.compact(FilterMap)
+export const filter = FM.filter(FilterMap)

package/src/Stream/hold.test.ts

@@ -0,0 +1,52 @@
+import { deepStrictEqual } from 'assert'
+
+import { pipe } from 'hkt-ts/function'
+
+import { Stream } from './Stream.js'
+import { collect } from './drain.js'
+import { fromCallback } from './fromCallback.js'
+import { hold } from './hold.js'
+
+import { provideService, runMain } from '@/Fx/index.js'
+import { RootScheduler } from '@/Scheduler/RootScheduler.js'
+import { Scheduler } from '@/Scheduler/index.js'
+import { testSuite } from '@/_internal/suite.js'
+
+testSuite(import.meta.url, () => {
+  describe(hold.name, () => {
+    const scheduler = RootScheduler()
+    const collectAll = <E, A>(stream: Stream<never, E, A>) =>
+      pipe(stream, collect, provideService(Scheduler, scheduler), runMain)
+
+    it('emits previous event to late subscribers', async () => {
+      let started = 0
+      const value = Math.random()
+      const stream = hold(
+        fromCallback<never, number>(async ({ event, end }) => {
+          started++
+          event(value)
+          await new Promise((resolve) => setTimeout(resolve, 50))
+          event(value + 1)
+          await new Promise((resolve) => setTimeout(resolve, 100))
+          event(value + 2)
+          end()
+        }),
+      )
+
+      const a = collectAll(stream)
+
+      await new Promise((resolve) => setTimeout(resolve, 25))
+
+      const b = collectAll(stream)
+
+      await new Promise((resolve) => setTimeout(resolve, 50))
+
+      const c = collectAll(stream)
+
+      deepStrictEqual(await a, [value, value + 1, value + 2])
+      deepStrictEqual(await b, [value, value + 1, value + 2])
+      deepStrictEqual(await c, [value + 1, value + 2])
+      deepStrictEqual(started, 1)
+    })
+  })
+})

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 { fromFiberRefs } from '@/Env/Env.js'
+import { Fiber } from '@/Fiber/Fiber.js'
+import { FiberContext } from '@/FiberContext/FiberContext.js'
+import { FiberId } from '@/FiberId/FiberId.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(),
+      fromFiberRefs(context.fiberRefs),
+      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,27 @@
+export * from './acquirePermit.js'
 export * from './bimap.js'
 export * from './continueWith.js'
+export * from './delay.js'
 export * from './drain.js'
 export * from './empty.js'
 export * from './flatMap.js'
+export * from './flatMapConcurrently.js'
 export * from './flatMapFx.js'
+export * from './foldMap.js'
+export * from './fromArray.js'
 export * from './fromCallback.js'
 export * from './fromFx.js'
 export * from './hkt.js'
-export * from './map.js'
+export * from './hold.js'
+export * from './lazy.js'
+export * from './merge.js'
+export * from './multicast.js'
 export * from './periodic.js'
+export * from './provide.js'
+export * from './run.js'
+export * from './setFiberRefLocally.js'
+export * from './skipRepeats.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/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,107 @@
+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

@@ -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)