@typed/fx 0.0.4 → 0.0.8

package/src/Semaphore/Semaphore.ts

@@ -4,7 +4,7 @@ import { NonNegativeInteger } from 'hkt-ts/number'
 import { AtomicCounter, decrement, increment } from '@/Atomic/AtomicCounter.js'
 import { MutableFutureQueue } from '@/Future/MutableFutureQueue.js'
 import { wait } from '@/Future/wait.js'
-import { Fx, Of, flatMap, fromLazy, tap, unit } from '@/Fx/Fx.js'
+import * as Fx from '@/Fx/Fx.js'
 import { fiberScoped, managed, scoped } from '@/Fx/scoped.js'
 
 export class Semaphore {
@@ -22,10 +22,10 @@ export class Semaphore {
     return this.running.get()
   }
 
-  readonly prepare = fromLazy(() => {
+  readonly prepare = Fx.fromLazy(() => {
     if (this.available > 0) {
       return new Acquisition(
-        fromLazy(() => {
+        Fx.fromLazy(() => {
           increment(this.running)
         }),
         this.release,
@@ -39,11 +39,7 @@ export class Semaphore {
     const acquisition = new Acquisition(
       pipe(
         wait(future),
-        tap(() =>
-          fromLazy(() => {
-            increment(that.running)
-          }),
-        ),
+        Fx.tapLazy(() => increment(that.running)),
       ),
       this.release,
     )
@@ -51,17 +47,14 @@ export class Semaphore {
     return acquisition
   })
 
-  protected release = fromLazy(() => {
+  protected release = Fx.fromLazy(() => {
     decrement(this.running)
-
-    if (this.waiting.size() > 0) {
-      this.waiting.next(unit)
-    }
+    this.waiting.next(Fx.unit)
   })
 }
 
 export class Acquisition {
-  constructor(readonly acquire: Of<void>, readonly release: Of<void>) {}
+  constructor(readonly acquire: Fx.Of<void>, readonly release: Fx.Of<void>) {}
 }
 
 /**
@@ -80,7 +73,7 @@ export class Lock extends Semaphore {
 export function acquirePermit(semaphore: Semaphore) {
   return pipe(
     semaphore.prepare,
-    flatMap(({ acquire, release }) => managed(acquire, constant(release))),
+    Fx.flatMap(({ acquire, release }) => managed(acquire, constant(release))),
   )
 }
 
@@ -88,10 +81,10 @@ export function acquirePermit(semaphore: Semaphore) {
  * Acquire a permit from a given semaphore, run an Fx, and then release the permit.
  */
 export function acquire(semaphore: Semaphore) {
-  return <R, E, A>(fx: Fx<R, E, A>) =>
+  return <R, E, A>(fx: Fx.Fx<R, E, A>) =>
     pipe(
       acquirePermit(semaphore),
-      flatMap(() => fx),
+      Fx.flatMap(() => fx),
       scoped,
     )
 }
@@ -100,10 +93,10 @@ export function acquire(semaphore: Semaphore) {
  * Acquire a permit from a given semaphore, run an Fx, and then release the permit.
  */
 export function acquireFiber(semaphore: Semaphore) {
-  return <R, E, A>(fx: Fx<R, E, A>) =>
+  return <R, E, A>(fx: Fx.Fx<R, E, A>) =>
     pipe(
       acquirePermit(semaphore),
-      flatMap(() => fx),
+      Fx.flatMap(() => fx),
       fiberScoped,
     )
 }

package/src/Sink/Sink.ts

@@ -2,7 +2,7 @@ import { flow, pipe } from 'hkt-ts'
 import { Left, Right } from 'hkt-ts/Either'
 
 import { Cause } from '@/Cause/Cause.js'
-import { Fx, IO, access, flatMap, fromLazy, provide, unit } from '@/Fx/Fx.js'
+import { Fx, IO, access, addCustomTrace, flatMap, fromLazy, provide, unit } from '@/Fx/Fx.js'
 import { Closeable } from '@/Scope/Closeable.js'
 
 export interface Sink<in E, in A, out E2 = never> {
@@ -77,3 +77,13 @@ export function makeDrain<
     }),
   )
 }
+
+export function addTrace<E, A, E2>(sink: Sink<E, A, E2>, trace?: string): Sink<E, A, E2> {
+  if (trace === undefined) return sink
+
+  return {
+    event: flow(sink.event, addCustomTrace(trace)),
+    error: flow(sink.error, addCustomTrace(trace)),
+    end: pipe(sink.end, addCustomTrace(trace)),
+  }
+}

package/src/Stream/Stream.ts

@@ -7,19 +7,13 @@ import { Sink } from '@/Sink/Sink.js'
 
 /**
  * TODOS:
- * - Scan
  * - Loop
  * - zipItems
  * - withItems
- * - switchLatest
- * - concatMap
- * - mergeConcurrently
- * - merge/mergeArray
  * - combine/combineArray
  * - zip/zipArray
  * - sample
  * - snapshot
- * - skipRepeats
  * - slice/take/skip
  * - takeWhile/skipWhile
  * - takeUntil/skipUntil
@@ -27,27 +21,27 @@ import { Sink } from '@/Sink/Sink.js'
  * - since
  * - during
  * - until
- * - delay
  * - throttle
  * - debounce
- * - orElse
- * - multicast
- * - hold
- * - reduce
- * - run
  * - Fusion/Commutation
  * - Unique Identification for streams to add to tracing
  *    - How to build a dynamic stream graph?
  */
 
-export interface Stream<R = never, E = never, A = unknown> {
-  readonly fork: <E2 = never>(
+export interface Stream<out R = never, out E = never, out A = unknown> {
+  fork<E2 = never>(
     sink: Sink<E, A, E2>,
     scheduler: Scheduler,
     context: FiberContext<FiberId.Live>,
-  ) => Fx.RIO<R, Fiber<E2, any>>
+  ): Fx.RIO<R, Fiber<E2, any>>
 }
 
+/* eslint-disable @typescript-eslint/no-unused-vars */
+export type ResourcesOf<T> = T extends Stream<infer R, infer _, infer __> ? R : never
+export type ErrorsOf<T> = T extends Stream<infer _, infer E, infer __> ? E : never
+export type OutputOf<T> = T extends Stream<infer _, infer __, infer A> ? A : never
+/* eslint-enable @typescript-eslint/no-unused-vars */
+
 export interface RIO<R, A> extends Stream<R, never, A> {}
 export interface IO<E, A> extends Stream<never, E, A> {}
 export interface Of<A> extends Stream<never, never, A> {}

package/src/Stream/acquirePermit.ts

@@ -0,0 +1,32 @@
+import { pipe } from 'hkt-ts/function'
+
+import { Stream } from './Stream.js'
+
+import { FiberContext } from '@/FiberContext/FiberContext.js'
+import { Live } from '@/FiberId/FiberId.js'
+import * as Fx from '@/Fx/Fx.js'
+import { Scheduler } from '@/Scheduler/index.js'
+import * as Semaphore from '@/Semaphore/index.js'
+import { Sink } from '@/Sink/Sink.js'
+
+export function acquirePermit(semaphore: Semaphore.Semaphore) {
+  return <R, E, A>(stream: Stream<R, E, A>): Stream<R, E, A> =>
+    new AcquirePermitStream(stream, semaphore)
+}
+
+export class AcquirePermitStream<R, E, A> implements Stream<R, E, A> {
+  constructor(readonly stream: Stream<R, E, A>, readonly semaphore: Semaphore.Semaphore) {}
+
+  fork = <E2>(sink: Sink<E, A, E2>, scheduler: Scheduler, context: FiberContext<Live>) =>
+    pipe(
+      this.semaphore.prepare,
+      Fx.flatMap(({ acquire, release }) =>
+        pipe(
+          acquire,
+          Fx.uninterruptable,
+          Fx.tapLazy(() => context.scope.ensuring(() => release)),
+          Fx.flatMap(() => this.stream.fork(sink, scheduler, context)),
+        ),
+      ),
+    )
+}

package/src/Stream/bimap.ts

@@ -1,26 +1,33 @@
-import { flow } from 'hkt-ts/function'
+import { Maybe } from 'hkt-ts'
+import { flow, pipe } from 'hkt-ts/function'
 
 import { Stream } from './Stream.js'
-import { MapStream } from './map.js'
 
 import * as Cause from '@/Cause/index.js'
 import { FiberContext } from '@/FiberContext/FiberContext.js'
 import { Live } from '@/FiberId/FiberId.js'
+import { unit } from '@/Fx/Fx.js'
 import { Scheduler } from '@/Scheduler/Scheduler.js'
-import { Sink } from '@/Sink/Sink.js'
+import { Sink, addTrace } from '@/Sink/Sink.js'
 
 export function bimap<A, B, C, D>(
   f: (a: A) => B,
   g: (c: C) => D,
+  __trace?: string,
 ): <R>(stream: Stream<R, A, C>) => Stream<R, B, D> {
-  return (stream) => BimapStream.make(stream, f, g)
+  return (stream) => BimapStream.make(stream, f, g, __trace)
 }
 
 export class BimapStream<R, A, B, C, D> implements Stream<R, B, D> {
-  constructor(readonly stream: Stream<R, A, C>, readonly f: (a: A) => B, readonly g: (c: C) => D) {}
+  constructor(
+    readonly stream: Stream<R, A, C>,
+    readonly f: (a: A) => B,
+    readonly g: (c: C) => D,
+    readonly __trace?: string,
+  ) {}
 
-  fork = <E2>(sink: Sink<B, D, E2>, scheduler: Scheduler, context: FiberContext<Live>) => {
-    return this.stream.fork<E2>(
+  fork = <E>(sink: Sink<B, D, E>, scheduler: Scheduler, context: FiberContext<Live>) => {
+    return this.stream.fork<E>(
       new BimapSink(sink, scheduler, context, this.f, this.g),
       scheduler,
       context,
@@ -31,16 +38,17 @@ export class BimapStream<R, A, B, C, D> implements Stream<R, B, D> {
     stream: Stream<R, A, C>,
     f: (a: A) => B,
     g: (c: C) => D,
+    __trace?: string,
   ): Stream<R, B, D> {
     if (stream instanceof MapStream) {
-      return BimapStream.make(stream.stream, f, flow(stream.f, g))
+      return BimapStream.make(stream.stream, f, flow(stream.f, g), __trace)
     }
 
     if (stream instanceof BimapStream) {
-      return BimapStream.make(stream.stream, flow(stream.f, f), flow(stream.g, g))
+      return BimapStream.make(stream.stream, flow(stream.f, f), flow(stream.g, g), __trace)
     }
 
-    return new BimapStream(stream, f, g)
+    return new BimapStream(stream, f, g, __trace)
   }
 }
 
@@ -53,7 +61,151 @@ class BimapSink<A, B, C, D, E> implements Sink<A, C, E> {
     readonly g: (c: C) => D,
   ) {}
 
-  event = (c: C) => this.sink.event(this.g(c))
-  error = (cause: Cause.Cause<A>) => this.sink.error(Cause.map(this.f)(cause))
+  event = flow(this.g, this.sink.event)
+  error = flow(Cause.map(this.f), this.sink.error)
   end = this.sink.end
 }
+
+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,
+    readonly __trace?: string,
+  ) {}
+
+  fork<E2>(sink: Sink<E, B, E2>, scheduler: Scheduler, context: FiberContext<Live>) {
+    return this.stream.fork(
+      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,
+    __trace?: string,
+  ): Stream<R, E, B> {
+    if (stream instanceof MapStream) {
+      return MapStream.make(stream.stream, flow(stream.f, f), __trace)
+    }
+
+    if (stream instanceof MapLeftStream) {
+      return BimapStream.make(stream.stream, stream.f, f, __trace)
+    }
+
+    if (stream instanceof FilterMapStream) {
+      return FilterMapStream.make(stream.stream, flow(stream.f, Maybe.map(f)), __trace)
+    }
+
+    return new MapStream(stream, f, __trace)
+  }
+}
+
+export function mapLeft<E1, E2>(
+  f: (error: E1) => E2,
+  __trace?: string,
+): <R, A>(stream: Stream<R, E1, A>) => Stream<R, E2, A> {
+  return (stream) => MapLeftStream.make(stream, f, __trace)
+}
+
+export class MapLeftStream<R, E1, A, E2> implements Stream<R, E2, A> {
+  constructor(
+    readonly stream: Stream<R, E1, A>,
+    readonly f: (error: E1) => E2,
+    readonly __trace?: string,
+  ) {}
+
+  fork<E3>(sink: Sink<E2, A, E3>, scheduler: Scheduler, context: FiberContext<Live>) {
+    return this.stream.fork(
+      addTrace(
+        {
+          ...sink,
+          error: flow(Cause.map(this.f), sink.error),
+        },
+        this.__trace,
+      ),
+      scheduler,
+      context,
+    )
+  }
+
+  static make<R, E1, A, E2>(
+    stream: Stream<R, E1, A>,
+    f: (e: E1) => E2,
+    __trace?: string,
+  ): Stream<R, E2, A> {
+    if (stream instanceof MapLeftStream) {
+      return MapLeftStream.make(stream.stream, flow(stream.f, f), __trace)
+    }
+
+    if (stream instanceof MapStream) {
+      return BimapStream.make(stream.stream, f, stream.f, __trace)
+    }
+
+    return new MapLeftStream(stream, f, __trace)
+  }
+}
+
+export function filterMap<A, B>(
+  f: (a: A) => Maybe.Maybe<B>,
+  __trace?: string,
+): <R, E>(stream: Stream<R, E, A>) => Stream<R, E, B> {
+  return (stream) => FilterMapStream.make(stream, f, __trace)
+}
+
+export class FilterMapStream<R, E, A, B> implements Stream<R, E, B> {
+  constructor(
+    readonly stream: Stream<R, E, A>,
+    readonly f: (a: A) => Maybe.Maybe<B>,
+    readonly __trace?: string,
+  ) {}
+
+  fork<E2>(sink: Sink<E, B, E2>, scheduler: Scheduler, context: FiberContext<Live>) {
+    return this.stream.fork(
+      addTrace(
+        {
+          ...sink,
+          event: (a) =>
+            pipe(
+              a,
+              this.f,
+              Maybe.match(() => unit, sink.event),
+            ),
+        },
+        this.__trace,
+      ),
+      scheduler,
+      context,
+    )
+  }
+
+  static make<R, E, A, B>(
+    stream: Stream<R, E, A>,
+    f: (a: A) => Maybe.Maybe<B>,
+    __trace?: string,
+  ): Stream<R, E, B> {
+    if (stream instanceof MapStream) {
+      return FilterMapStream.make(stream.stream, flow(stream.f, f), __trace)
+    }
+
+    if (stream instanceof FilterMapStream) {
+      return FilterMapStream.make(stream.stream, flow(stream.f, Maybe.flatMap(f)), __trace)
+    }
+
+    return new FilterMapStream(stream, f, __trace)
+  }
+}

package/src/Stream/continueWith.ts

@@ -8,23 +8,27 @@ 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'
+import { Sink, addTrace } from '@/Sink/Sink.js'
 
-export function continueWith<R2, E2, B>(f: () => Stream<R2, E2, B>) {
+export function continueWith<R2, E2, B>(f: () => Stream<R2, E2, B>, __trace?: string) {
   return <R, E, A>(stream: Stream<R, E, A>): Stream<R | R2, E | E2, A | B> =>
-    new ContinueWith(stream, f)
+    new ContinueWith(stream, f, __trace)
 }
 
 export const startWith =
-  <B>(value: B) =>
+  <B>(value: B, __trace?: string) =>
   <R, E, A>(stream: Stream<R, E, A>) =>
     pipe(
       now(value),
-      continueWith(() => stream),
+      continueWith(() => stream, __trace),
     )
 
 export class ContinueWith<R, E, A, R2, E2, B> implements Stream<R | R2, E | E2, A | B> {
-  constructor(readonly stream: Stream<R, E, A>, readonly f: () => Stream<R2, E2, B>) {}
+  constructor(
+    readonly stream: Stream<R, E, A>,
+    readonly f: () => Stream<R2, E2, B>,
+    readonly __trace?: string,
+  ) {}
 
   fork = <E3>(
     sink: Sink<E | E2, A | B, E3>,
@@ -33,7 +37,7 @@ export class ContinueWith<R, E, A, R2, E2, B> implements Stream<R | R2, E | E2,
   ) => {
     return Fx.access((env: Env<R | R2>) =>
       this.stream.fork(
-        new ContinueWithSink(sink, scheduler, context, env, this.f),
+        addTrace(new ContinueWithSink(sink, scheduler, context, env, this.f), this.__trace),
         scheduler,
         context,
       ),

package/src/Stream/delay.ts

@@ -0,0 +1,43 @@
+import { Stream } from './Stream.js'
+
+import { Env } from '@/Env/Env.js'
+import { FiberContext } from '@/FiberContext/FiberContext.js'
+import { FiberId } from '@/FiberId/FiberId.js'
+import { access, fromLazy } from '@/Fx/index.js'
+import { delayed } from '@/Schedule/Schedule.js'
+import { Scheduler } from '@/Scheduler/Scheduler.js'
+import { Sink } from '@/Sink/Sink.js'
+import { Delay } from '@/Time/index.js'
+
+export function delay(delay: Delay) {
+  return <R, E, A>(stream: Stream<R, E, A>): Stream<R, E, A> =>
+    Stream((sink, scheduler, context) =>
+      access((env: Env<R>) =>
+        stream.fork(new DelaySink(sink, scheduler, context, env, delay), scheduler, context),
+      ),
+    )
+}
+
+class DelaySink<E, A, E2> implements Sink<E, A, E2> {
+  constructor(
+    readonly sink: Sink<E, A, E2>,
+    readonly scheduler: Scheduler,
+    readonly context: FiberContext<FiberId.Live>,
+    readonly env: Env<any>,
+    readonly delay: Delay,
+  ) {}
+
+  event(value: A) {
+    return fromLazy(() =>
+      this.scheduler.schedule(
+        this.sink.event(value),
+        this.env,
+        delayed(this.delay),
+        this.context.fork(),
+      ),
+    )
+  }
+
+  error = this.sink.error
+  end = this.sink.end
+}

package/src/Stream/drain.ts

@@ -7,18 +7,18 @@ 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 { 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, any>> {
+): 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),
   )
 }
 
@@ -26,8 +26,9 @@ export function fork<R, E, A, E2 = never>(
   stream: Stream<R, E, A>,
   sink: Sink<E, A, E2>,
   context: FiberContext<FiberId.Live>,
-): Fx.Fx<R | Scheduler, never, Fiber<E | E2, A>> {
-  return Fx.asks(Scheduler)((scheduler) => stream.fork(sink, scheduler, context))
+  __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) {
@@ -37,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),
     )
 }
 
@@ -50,7 +51,7 @@ export function collect<R, E, A>(
 
     yield* pipe(
       stream,
-      observe((a) => Fx.fromLazy(() => events.push(a))),
+      observe((a) => Fx.fromLazy(() => events.push(a)), __trace),
       Fx.flatMap(Fx.join),
     )
 

package/src/Stream/empty.ts

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

package/src/Stream/flatMap.test.ts

@@ -2,13 +2,11 @@ import { deepStrictEqual } from 'assert'
 
 import { pipe } from 'hkt-ts'
 
-import { collect, observe } from './drain.js'
+import { collectAll } from './_internal.test.js'
 import { flatMap } from './flatMap.js'
 import { fromFx } from './fromFx.js'
 
 import * as Fx from '@/Fx/index.js'
-import { RootScheduler } from '@/Scheduler/RootScheduler.js'
-import { Scheduler } from '@/Scheduler/Scheduler.js'
 import { testSuite } from '@/_internal/suite.js'
 
 testSuite(import.meta.url, () => {
@@ -19,25 +17,14 @@ testSuite(import.meta.url, () => {
       flatMap((a) => fromFx(Fx.success(a + 1))),
     )
 
-    it('should create a Stream', () =>
-      pipe(
-        stream,
-        observe((n) => Fx.fromLazy(() => deepStrictEqual(n, value + 1))),
-        Fx.flatMap(Fx.join),
-        Fx.provideService(Scheduler, RootScheduler()),
-        Fx.runMain,
-      ))
-
-    it('should be collectable', async () => {
-      await pipe(
-        Fx.Fx(function* () {
-          const events: readonly number[] = yield* collect(stream)
+    it('is collectable', async () => {
+      const events = await collectAll(stream)
+      deepStrictEqual(events, [value + 1])
+    })
 
-          deepStrictEqual(events, [value + 1])
-        }),
-        Fx.provideService(Scheduler, RootScheduler()),
-        Fx.runMain,
-      )
+    it('is collectable with multiple subscribers', async () => {
+      const events = await Promise.all([collectAll(stream), collectAll(stream)])
+      deepStrictEqual(events, [[value + 1], [value + 1]])
     })
   })
 })