@typed/fx 0.0.3 → 0.0.6

package/src/Stream/drain.ts

@@ -4,31 +4,31 @@ import { Stream } from './Stream.js'
 
 import { Fiber } from '@/Fiber/Fiber.js'
 import { FiberContext } from '@/FiberContext/FiberContext.js'
-import { FiberRef } from '@/FiberRef/FiberRef.js'
-import { update } from '@/FiberRef/operations.js'
+import { FiberId } from '@/FiberId/FiberId.js'
 import * as Fx from '@/Fx/index.js'
 import { Scheduler } from '@/Scheduler/Scheduler.js'
-import { Drain, Sink, makeDrain } from '@/Sink/Sink.js'
+import { Drain, Sink, addTrace, makeDrain } from '@/Sink/Sink.js'
 
 export function drain<R, E, A>(
   stream: Stream<R, E, A>,
   __trace?: string,
-): Fx.Fx<R | Scheduler, never, Fiber<E, A>> {
+): Fx.Fx<R | Scheduler, never, Fiber<never, any>> {
   return pipe(
     Fx.Do,
     Fx.bind('fiberContext', () => Fx.getFiberContext),
     Fx.let('context', ({ fiberContext }) => fiberContext.fork()),
     Fx.let('sink', ({ context }) => new Drain<E, A>(context.scope)),
-    Fx.flatMap(({ sink, context }) => fork(stream, sink, context), __trace),
+    Fx.flatMap(({ sink, context }) => fork(stream, sink, context, __trace), __trace),
   )
 }
 
 export function fork<R, E, A, E2 = never>(
   stream: Stream<R, E, A>,
-  sink: Sink<E | E2, A>,
-  context: FiberContext,
-): Fx.Fx<R | Scheduler, never, Fiber<E | E2, A>> {
-  return Fx.asks(Scheduler)((scheduler) => stream.fork(sink, scheduler, context))
+  sink: Sink<E, A, E2>,
+  context: FiberContext<FiberId.Live>,
+  __trace?: string,
+): Fx.Fx<R | Scheduler, never, Fiber<E2, A>> {
+  return Fx.asks(Scheduler)((scheduler) => stream.fork(addTrace(sink, __trace), scheduler, context))
 }
 
 export function observe<A, R2, E2, B>(f: (a: A) => Fx.Fx<R2, E2, B>, __trace?: string) {
@@ -38,7 +38,7 @@ export function observe<A, R2, E2, B>(f: (a: A) => Fx.Fx<R2, E2, B>, __trace?: s
       Fx.bind('fiberContext', () => Fx.getFiberContext),
       Fx.let('context', ({ fiberContext }) => fiberContext.fork()),
       Fx.bind('sink', ({ context }) => makeDrain<E, A, R2, E2>(context.scope, { event: f })),
-      Fx.flatMap(({ sink, context }) => fork(stream, sink, context), __trace),
+      Fx.flatMap(({ sink, context }) => fork(stream, sink, context, __trace), __trace),
     )
 }
 
@@ -46,28 +46,15 @@ export function collect<R, E, A>(
   stream: Stream<R, E, A>,
   __trace?: string,
 ): Fx.Fx<R | Scheduler, E, readonly A[]> {
-  return pipe(
-    Fx.fromLazy(() => FiberRef.make(Fx.now<readonly A[]>([]))),
-    Fx.bindTo('fiberRef'),
-    Fx.bind('fiberContext', () => Fx.getFiberContext),
-    Fx.let('context', ({ fiberContext }) => fiberContext.fork()),
-    Fx.bind('sink', ({ context, fiberRef }) =>
-      makeDrain<E, A, R, E>(context.scope, {
-        event: (a) =>
-          pipe(
-            fiberRef,
-            update((as) => [...as, a]),
-          ),
-      }),
-    ),
-    Fx.flatMap(
-      ({ sink, context, fiberRef }) =>
-        pipe(
-          fork(stream, sink, context),
-          Fx.flatMap(Fx.join),
-          Fx.flatMap(() => Fx.getFiberRef(fiberRef)),
-        ),
-      __trace,
-    ),
-  )
+  return Fx.Fx(function* () {
+    const events: A[] = []
+
+    yield* pipe(
+      stream,
+      observe((a) => Fx.fromLazy(() => events.push(a)), __trace),
+      Fx.flatMap(Fx.join),
+    )
+
+    return events
+  }, __trace)
 }

package/src/Stream/empty.ts

@@ -0,0 +1,7 @@
+import { Stream } from './Stream.js'
+
+import * as Fx from '@/Fx/Fx.js'
+
+export const empty = Stream<never, never, never>((sink, scheduler, context) =>
+  Fx.asksEnv((env) => scheduler.asap(sink.end, env, context)),
+)

package/src/Stream/flatMap.test.ts

@@ -0,0 +1,30 @@
+import { deepStrictEqual } from 'assert'
+
+import { pipe } from 'hkt-ts'
+
+import { collectAll } from './_internal.test.js'
+import { flatMap } from './flatMap.js'
+import { fromFx } from './fromFx.js'
+
+import * as Fx from '@/Fx/index.js'
+import { testSuite } from '@/_internal/suite.js'
+
+testSuite(import.meta.url, () => {
+  describe(flatMap.name, () => {
+    const value = Math.random()
+    const stream = pipe(
+      fromFx(Fx.success(value)),
+      flatMap((a) => fromFx(Fx.success(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]])
+    })
+  })
+})

package/src/Stream/flatMap.ts

@@ -0,0 +1,137 @@
+import { flow, pipe } from 'hkt-ts'
+import { isRight } from 'hkt-ts/Either'
+import { isJust } from 'hkt-ts/Maybe'
+
+import { Stream } from './Stream.js'
+import { MapStream } from './map.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, 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 flatMap<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) => FlatMapStream.make(stream, f, __trace)
+}
+
+export function join<R, E, R2, E2, A>(
+  stream: Stream<R, E, Stream<R2, E2, A>>,
+  __trace?: string,
+): Stream<R | R2, E | E2, A> {
+  return flatMap((a: Stream<R2, E2, A>) => a, __trace)(stream)
+}
+
+export class FlatMapStream<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 FlatMapSink(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 FlatMapStream.make(stream.stream, flow(stream.f, f), __trace)
+    }
+
+    return new FlatMapStream(stream, f, __trace)
+  }
+}
+
+class FlatMapSink<R, E, A, R2, E2, B, E3> implements Sink.Sink<E | E2, 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<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.lazy(() => {
+      const forked = this.context.fork({
+        supervisor: and(this.supervisor)(this.context.supervisor),
+      })
+
+      increment(this._running)
+
+      return pipe(
+        this.f(a).fork(Sink.addTrace(this.innerSink(), this.__trace), this.scheduler, forked),
+        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() {
+    return lazy(() => {
+      if (this._ended && this._running.get() === 0) {
+        return this.sink.end
+      }
+
+      return unit
+    })
+  }
+
+  protected innerSink(): Sink.Sink<E | E2, B, E3> {
+    return {
+      event: this.sink.event,
+      error: this.error,
+      end: lazy(() => {
+        decrement(this._running)
+        return this.endIfCompleted()
+      }),
+    }
+  }
+}

package/src/Stream/flatMapConcurrently.test.ts

@@ -0,0 +1,77 @@
+import { deepStrictEqual } from 'assert'
+
+import { pipe } from 'hkt-ts'
+import { NonNegativeInteger } from 'hkt-ts/number'
+
+import { collectAll } from './_internal.test.js'
+import { flatMapConcurrently } from './flatMapConcurrently.js'
+import { fromCallback } from './fromCallback.js'
+import { merge } from './merge.js'
+
+import { testSuite } from '@/_internal/suite.js'
+
+testSuite(import.meta.url, () => {
+  describe(flatMapConcurrently.name, () => {
+    const value = 42
+    const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms))
+
+    const stream = (level: number) =>
+      pipe(
+        fromCallback<never, number>(async ({ event, end }) => {
+          event(value)
+          event(value + 5)
+          event(value + 10)
+          end()
+        }),
+        merge(
+          fromCallback<never, number>(async ({ event, end }) => {
+            event(value + 15)
+            event(value + 20)
+            end()
+          }),
+        ),
+        flatMapConcurrently(
+          (a) =>
+            fromCallback<never, number>(async ({ event, end }) => {
+              event(a + 1)
+              await sleep(10)
+              event(a + 2)
+              end()
+            }),
+          NonNegativeInteger(level),
+        ),
+      )
+
+    it('it should control concurrency', async () => {
+      const noConcurrency = await collectAll(stream(Infinity))
+
+      deepStrictEqual(noConcurrency, [
+        value + 1,
+        value + 5 + 1,
+        value + 10 + 1,
+        value + 15 + 1,
+        value + 20 + 1,
+        value + 2,
+        value + 5 + 2,
+        value + 10 + 2,
+        value + 15 + 2,
+        value + 20 + 2,
+      ])
+
+      const withConcurrency = await collectAll(stream(1))
+
+      deepStrictEqual(withConcurrency, [
+        value + 1,
+        value + 2,
+        value + 5 + 1,
+        value + 5 + 2,
+        value + 10 + 1,
+        value + 10 + 2,
+        value + 15 + 1,
+        value + 15 + 2,
+        value + 20 + 1,
+        value + 20 + 2,
+      ])
+    })
+  })
+})

package/src/Stream/flatMapConcurrently.ts

@@ -0,0 +1,30 @@
+import { flow, pipe } from 'hkt-ts/function'
+import { NonNegativeInteger } from 'hkt-ts/number'
+
+import { Stream } from './Stream.js'
+import { acquirePermit } from './acquirePermit.js'
+import { flatMap } from './flatMap.js'
+import { lazy } from './lazy.js'
+
+import { Semaphore } from '@/Semaphore/index.js'
+
+export function flatMapConcurrently<A, R2, E2, B>(
+  f: (a: A) => Stream<R2, E2, B>,
+  concurrencyLevel: NonNegativeInteger,
+  __trace?: string,
+) {
+  return <R, E>(stream: Stream<R, E, A>) =>
+    lazy(() => {
+      const semaphore = new Semaphore(concurrencyLevel)
+
+      return pipe(stream, flatMap(flow(f, acquirePermit(semaphore)), __trace))
+    })
+}
+
+export function mergeConcurrently(concurrencyLevel: NonNegativeInteger, __trace?: string) {
+  return <R, E, R2, E2, A>(stream: Stream<R, E, Stream<R2, E2, A>>) =>
+    pipe(
+      stream,
+      flatMapConcurrently((a) => a, concurrencyLevel, __trace),
+    )
+}

package/src/Stream/flatMapFx.ts

@@ -0,0 +1,45 @@
+import { pipe } from 'hkt-ts/function'
+import { NonNegativeInteger } from 'hkt-ts/number'
+
+import { Stream } from './Stream.js'
+import { flatMap } from './flatMap.js'
+import { flatMapConcurrently } from './flatMapConcurrently.js'
+import { fromFx } from './fromFx.js'
+
+import { Fx } from '@/Fx/Fx.js'
+
+export function flatMapFx<A, R2, E2, B>(f: (a: A) => Fx<R2, E2, B>, __trace?: string) {
+  return <R, E>(stream: Stream<R, E, A>): Stream<R | R2, E | E2, B> =>
+    pipe(
+      stream,
+      flatMap((a) => fromFx(f(a), __trace), __trace),
+    )
+}
+
+export function joinFx<R, E, A>(stream: Stream<R, E, Fx<R, E, A>>, __trace?: string) {
+  return pipe(
+    stream,
+    flatMapFx((x) => x, __trace),
+  )
+}
+
+export function flatMapFxConcurrently<A, R2, E2, B>(
+  f: (a: A) => Fx<R2, E2, B>,
+  concurrencyLevel: NonNegativeInteger,
+  __trace?: string,
+) {
+  return <R, E>(stream: Stream<R, E, A>): Stream<R | R2, E | E2, B> =>
+    pipe(
+      stream,
+      flatMapConcurrently((a) => fromFx(f(a), __trace), concurrencyLevel, __trace),
+    )
+}
+
+export function mergeFxConcurrently(concurrencyLevel: NonNegativeInteger, __trace?: string) {
+  return <R, E, R2, E2, A>(stream: Stream<R, E, Fx<R2, E2, A>>) => {
+    return pipe(
+      stream,
+      flatMapFxConcurrently((x) => x, concurrencyLevel, __trace),
+    )
+  }
+}

package/src/Stream/fromCallback.test.ts

@@ -0,0 +1,22 @@
+import { deepStrictEqual } from 'assert'
+
+import { collectAll } from './_internal.test.js'
+import { fromCallback } from './fromCallback.js'
+
+import { testSuite } from '@/_internal/suite.js'
+
+testSuite(import.meta.url, () => {
+  describe(fromCallback.name, () => {
+    const value = Math.random()
+    const stream = fromCallback<never, number>(async ({ event, end }) => {
+      await event(value)
+      await event(value + 1)
+      await event(value + 2)
+      await end()
+    })
+
+    it('is collectable', async () => {
+      deepStrictEqual(await collectAll(stream), [value, value + 1, value + 2])
+    })
+  })
+})

package/src/Stream/fromCallback.ts

@@ -0,0 +1,84 @@
+import { flow, pipe } from 'hkt-ts'
+import { Left, Right } from 'hkt-ts/Either'
+
+import { Stream } from './Stream.js'
+
+import { Cause } from '@/Cause/index.js'
+import { Fiber } from '@/Fiber/Fiber.js'
+import { fromScope } from '@/Fiber/fromScope.js'
+import { FiberContext } from '@/FiberContext/FiberContext.js'
+import { FiberId } from '@/FiberId/FiberId.js'
+import { Finalizer } from '@/Finalizer/Finalizer.js'
+import * as Fx from '@/Fx/index.js'
+import { Runtime } from '@/Runtime/Runtime.js'
+import { Scheduler } from '@/Scheduler/Scheduler.js'
+import { Sink, addTrace } from '@/Sink/Sink.js'
+
+export interface CallbackSink<E, A> {
+  readonly event: (a: A) => Promise<any>
+  readonly error: (cause: Cause<E>) => Promise<any>
+  readonly end: () => Promise<any>
+}
+
+export function fromCallback<E = never, A = unknown>(
+  f: (sink: CallbackSink<E, A>) => Finalizer | void | Promise<Finalizer | void>,
+  __trace?: string,
+): Stream<never, E, A> {
+  return new FromCallback<E, A>(f, __trace)
+}
+
+export class FromCallback<E, A> implements Stream<never, E, A> {
+  constructor(
+    readonly f: (sink: CallbackSink<E, A>) => Finalizer | void | Promise<Finalizer | void>,
+    readonly __trace?: string,
+  ) {}
+
+  fork = <E2>(
+    sink: Sink<E, A, E2>,
+    _: Scheduler,
+    context: FiberContext<FiberId.Live>,
+  ): Fx.RIO<never, Fiber<E2, any>> => {
+    return Fx.lazy(() => {
+      const { f, __trace } = this
+
+      const runtime = Runtime(context)
+      const tracedSink = addTrace(sink, __trace)
+      const cbSink: CallbackSink<E, A> = {
+        event: flow(tracedSink.event, runtime.run),
+        error: (cause) =>
+          pipe(
+            cause,
+            tracedSink.error,
+            Fx.tap(() => context.scope.close(Left(cause))),
+            runtime.run,
+          ),
+        end: () =>
+          pipe(
+            tracedSink.end,
+            Fx.tap(() => context.scope.close(Right(undefined))),
+            runtime.run,
+          ),
+      }
+
+      const synthetic = fromScope(
+        new FiberId.Synthetic([context.id]),
+        context.fiberRefs,
+        context.scope,
+      )
+
+      return pipe(
+        Fx.fromPromise(async () => await f(cbSink)),
+        Fx.tap(
+          (finalizer) =>
+            (finalizer &&
+              (context.scope.state.tag === 'Open'
+                ? Fx.fromLazy(() => context.scope.ensuring(finalizer))
+                : finalizer(context.scope.state.exit))) ??
+            Fx.unit,
+        ),
+        Fx.fork,
+        Fx.map(() => synthetic),
+      )
+    })
+  }
+}

package/src/Stream/fromFx.test.ts

@@ -1,39 +1,17 @@
 import { deepStrictEqual } from 'assert'
 
-import { pipe } from 'hkt-ts'
-
-import { collect, observe } from './drain.js'
+import { collectAll } from './_internal.test.js'
 import { fromFx } from './fromFx.js'
 
-import { runTest } from '@/Fx/Fx.test.js'
 import * as Fx from '@/Fx/index.js'
-import { RootScheduler } from '@/Scheduler/RootScheduler.js'
-import { Scheduler } from '@/Scheduler/Scheduler.js'
 
 describe(new URL(import.meta.url).pathname, () => {
   describe(fromFx.name, () => {
     const value = Math.random()
     const stream = fromFx(Fx.success(value))
 
-    it('should create a Stream', () =>
-      pipe(
-        stream,
-        observe((n) => Fx.fromLazy(() => deepStrictEqual(n, value))),
-        Fx.flatMap(Fx.join),
-        Fx.provideService(Scheduler, RootScheduler()),
-        runTest,
-      ))
-
-    it('should be collectable', async () => {
-      await pipe(
-        Fx.Fx(function* () {
-          const events = yield* collect(stream)
-
-          deepStrictEqual(events, [value])
-        }),
-        Fx.provideService(Scheduler, RootScheduler()),
-        runTest,
-      )
+    it('is collectable', async () => {
+      deepStrictEqual(await collectAll(stream), [value])
     })
   })
 })

package/src/Stream/fromFx.ts

@@ -1,27 +1,62 @@
 import { flow, pipe } from 'hkt-ts'
+import { Either } from 'hkt-ts/Either'
 
 import { Stream } from './Stream.js'
 
+import { Cause } from '@/Cause/Cause.js'
 import { Env } from '@/Env/Env.js'
+import * as Exit from '@/Exit/Exit.js'
+import { FiberId } from '@/FiberId/index.js'
 import * as Fx from '@/Fx/Fx.js'
 
-export function fromFx<R, E, A>(fx: Fx.Fx<R, E, A>): Stream<R, E, A> {
+/**
+ * Constructs a Stream from an Fx that runs within a LogSpan enabling
+ */
+export function fromFx<R, E, A>(fx: Fx.Fx<R, E, A>, __trace?: string): Stream<R, E, A> {
   return Stream((sink, scheduler, context) =>
-    Fx.asksEnv((env: Env<R>) =>
-      scheduler.asap(
-        pipe(
-          fx,
-          Fx.matchCause(
-            sink.error,
-            flow(
-              sink.event,
-              Fx.flatMap(() => sink.end),
+    Fx.asksEnv(
+      (env: Env<R>) =>
+        scheduler.asap(
+          pipe(
+            fx,
+            Fx.matchCause(
+              sink.error,
+              flow(
+                sink.event,
+                Fx.flatMap(() => sink.end),
+              ),
+              __trace,
             ),
           ),
+          env,
+          context,
         ),
-        env,
-        context,
-      ),
+      __trace,
     ),
   )
 }
+
+export const now = <A>(value: A, __trace?: string) => fromFx(Fx.now(value), __trace)
+
+export const fromCause = <E>(cause: Cause<E>, __trace?: string) =>
+  fromFx(Fx.fromCause(cause), __trace)
+
+export const fromExit = <E, A>(exit: Exit.Exit<E, A>, __trace?: string) =>
+  fromFx(Fx.fromExit(exit), __trace)
+
+export const interrupt = (id: FiberId, __trace?: string) => fromExit(Exit.interrupt(id), __trace)
+
+export const unexpected = (error: unknown, __trace?: string) =>
+  fromExit(Exit.unexpected(error), __trace)
+
+export const expected = <E>(error: E, __trace?: string) => fromExit(Exit.expected(error), __trace)
+
+export const fromPromise = <A>(promise: () => Promise<A>, __trace?: string) =>
+  fromFx(Fx.fromPromise(promise), __trace)
+
+export const fromLazy = <A>(lazy: () => A, __trace?: string) => fromFx(Fx.fromLazy(lazy), __trace)
+
+export const fromEither = <E, A>(either: Either<E, A>, __trace?: string) =>
+  fromFx(Fx.fromEither(either), __trace)
+
+export const never = fromFx(Fx.never, 'never')

package/src/Stream/hkt.ts

@@ -0,0 +1,36 @@
+import { HKT3, Params } from 'hkt-ts'
+import * as B from 'hkt-ts/Typeclass/Bicovariant'
+import * as C from 'hkt-ts/Typeclass/Covariant'
+
+import { Stream } from './Stream.js'
+import { bimap } from './bimap.js'
+import { map } from './map.js'
+
+// TODO: AssociativeBoth
+// TOOD: AssociativeEither
+// TODO: Top
+// TODO: Bottom
+// TODO: FilterMap
+// TODO: AssociativeFlatten
+// TODO: IdentityBoth
+// TODO: IdentityEither
+// TODO: IdentityFlatten
+
+export interface StreamHKT extends HKT3 {
+  readonly type: Stream<this[Params.R], this[Params.E], this[Params.A]>
+}
+
+export const Bicovariant: B.Bicovariant3<StreamHKT> = {
+  bimap,
+}
+
+export const mapLeft = B.mapLeft(Bicovariant)
+
+export const Covariant: C.Covariant3<StreamHKT> = {
+  map,
+}
+
+export const bindTo = C.bindTo(Covariant)
+export const flap = C.flap(Covariant)
+export const mapTo = C.mapTo(Covariant)
+export const tupled = C.tupled(Covariant)