@typed/fx 0.0.2 → 0.0.4

package/src/Stream/flatMap.ts

@@ -0,0 +1,102 @@
+import { flow, pipe } from 'hkt-ts'
+
+import { Stream } from './Stream.js'
+import { MapStream } from './map.js'
+
+import { AtomicCounter, decrement } 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 { lazy, span, unit } from '@/Fx/index.js'
+import { Scheduler } from '@/Scheduler/Scheduler.js'
+import { Sink } from '@/Sink/Sink.js'
+
+export function flatMap<A, R2, E2, B>(
+  f: (a: A) => Stream<R2, E2, B>,
+): <R, E>(stream: Stream<R, E, A>) => Stream<R | R2, E | E2, B> {
+  return (stream) => FlatMapStream.make(stream, f)
+}
+
+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>) {}
+
+  fork<E3>(sink: Sink<E | E2, B, E3>, scheduler: Scheduler, context: FiberContext<Live>) {
+    const { stream, f } = this
+
+    return pipe(
+      Fx.getEnv<R | R2>(),
+      Fx.flatMap((env) =>
+        stream.fork(new FlatMapSink(sink, scheduler, context, f, env), scheduler, context),
+      ),
+      span('Stream.flatMap'),
+    )
+  }
+
+  static make<R, E, A, R2, E2, B>(
+    stream: Stream<R, E, A>,
+    f: (a: A) => Stream<R2, E2, B>,
+  ): Stream<R | R2, E | E2, B> {
+    if (stream instanceof MapStream) {
+      return FlatMapStream.make(stream.stream, flow(stream.f, f))
+    }
+
+    return new FlatMapStream(stream, f)
+  }
+}
+
+class FlatMapSink<R, E, A, R2, E2, B, E3> implements Sink<E | E2, A, E3> {
+  protected _running = AtomicCounter()
+  protected _ended = false
+
+  constructor(
+    readonly 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>,
+  ) {}
+
+  event = (a: A) => {
+    return pipe(
+      this.f(a).fork(this.innerSink(), this.scheduler, this.context.fork()),
+      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) {
+        this.sink.end
+      }
+
+      return unit
+    })
+  }
+
+  protected innerSink(): Sink<E | E2, B, E3> {
+    return {
+      event: this.sink.event,
+      error: this.error,
+      end: lazy(() => {
+        decrement(this._running)
+        return this.endIfCompleted()
+      }),
+    }
+  }
+}

package/src/Stream/flatMapFx.ts

@@ -0,0 +1,12 @@
+import { flow, pipe } from 'hkt-ts/function'
+
+import { Stream } from './Stream.js'
+import { flatMap } from './flatMap.js'
+import { makeFromFx } from './fromFx.js'
+
+import { Fx } from '@/Fx/Fx.js'
+
+export function flatMapFx<A, R2, E2, B>(f: (a: A) => Fx<R2, E2, B>, span = 'Stream.flatMapFx') {
+  return <R, E>(stream: Stream<R, E, A>): Stream<R | R2, E | E2, B> =>
+    pipe(stream, flatMap(flow(f, makeFromFx(span))))
+}

package/src/Stream/fromCallback.test.ts

@@ -0,0 +1,35 @@
+import { deepStrictEqual } from 'assert'
+
+import { pipe } from 'hkt-ts'
+
+import { collect } from './drain.js'
+import { fromCallback } from './fromCallback.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, () => {
+  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('should be collectable', async () => {
+      await pipe(
+        Fx.Fx(function* () {
+          const events: readonly number[] = yield* collect(stream)
+
+          deepStrictEqual(events, [value, value + 1, value + 2])
+        }),
+        Fx.provideService(Scheduler, RootScheduler()),
+        Fx.runMain,
+      )
+    })
+  })
+})

package/src/Stream/fromCallback.ts

@@ -0,0 +1,65 @@
+import { flow, pipe } from 'hkt-ts'
+
+import { Stream } from './Stream.js'
+
+import { Cause } from '@/Cause/index.js'
+import { Fiber, Synthetic } from '@/Fiber/Fiber.js'
+import { FiberContext } from '@/FiberContext/FiberContext.js'
+import { FiberId } from '@/FiberId/FiberId.js'
+import * as FiberRefs from '@/FiberRefs/FiberRefs.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 { closeOrWait, wait } from '@/Scope/Closeable.js'
+import { Sink } from '@/Sink/Sink.js'
+import { Exit } from '@/index.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, A>(
+  f: <E2>(sink: CallbackSink<E | E2, A>) => Finalizer | void | Promise<Finalizer | void>,
+): Stream<never, E, A> {
+  return new FromCallback<E, A>(f)
+}
+
+export class FromCallback<E, A> implements Stream<never, E, A> {
+  constructor(
+    readonly f: <E2>(sink: CallbackSink<E | E2, A>) => Finalizer | void | Promise<Finalizer | void>,
+  ) {}
+
+  fork = <E2>(
+    sink: Sink<E, A, E2>,
+    _: Scheduler,
+    context: FiberContext<FiberId.Live>,
+  ): Fx.RIO<never, Fiber<E2, any>> =>
+    Fx.fromPromise(async () => {
+      const runtime = Runtime(context)
+      const cbSink = {
+        event: flow(sink.event, runtime.run),
+        error: flow(sink.error, runtime.run),
+        end: () => pipe(sink.end, runtime.run),
+      }
+      const finalizer = await this.f(cbSink)
+
+      if (finalizer) {
+        context.scope.ensuring(finalizer)
+      }
+
+      const synthetic = Synthetic({
+        id: new FiberId.Synthetic([context.id]),
+        exit: wait(context.scope),
+        inheritFiberRefs: pipe(
+          Fx.getFiberRefs,
+          Fx.flatMap((refs) => Fx.fromLazy(() => FiberRefs.join(refs, context.fiberRefs))),
+        ),
+        interruptAs: (id) => closeOrWait(context.scope)(Exit.interrupt(id)),
+      })
+
+      return synthetic
+    })
+}

package/src/Stream/fromFx.test.ts

@@ -5,7 +5,6 @@ import { pipe } from 'hkt-ts'
 import { collect, observe } from './drain.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'
@@ -21,18 +20,18 @@ describe(new URL(import.meta.url).pathname, () => {
         observe((n) => Fx.fromLazy(() => deepStrictEqual(n, value))),
         Fx.flatMap(Fx.join),
         Fx.provideService(Scheduler, RootScheduler()),
-        runTest,
+        Fx.runMain,
       ))
 
     it('should be collectable', async () => {
       await pipe(
         Fx.Fx(function* () {
-          const events = yield* collect(stream)
+          const events: readonly number[] = yield* collect(stream)
 
           deepStrictEqual(events, [value])
         }),
         Fx.provideService(Scheduler, RootScheduler()),
-        runTest,
+        Fx.runMain,
       )
     })
   })

package/src/Stream/fromFx.ts

@@ -4,24 +4,42 @@ import { Stream } from './Stream.js'
 
 import { Env } from '@/Env/Env.js'
 import * as Fx from '@/Fx/Fx.js'
+import { span } from '@/index.js'
 
-export function fromFx<R, E, A>(fx: Fx.Fx<R, E, A>): 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),
+/**
+ * Constructs a Stream from an Fx that runs within a LogSpan enabling
+ */
+export function makeFromFx(logSpan: string) {
+  return <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),
+                ),
+              ),
             ),
+            env,
+            context,
+            span(logSpan),
           ),
-        ),
-        env,
-        context,
+        __trace,
       ),
-    ),
-  )
+    )
+  }
 }
+
+export const fromFx = makeFromFx('Stream.fromFx')
+export const now = flow(Fx.now, makeFromFx('Stream.now'))
+export const fromCause = flow(Fx.fromCause, makeFromFx(`Stream.fromCause`))
+export const fromExit = flow(Fx.fromExit, makeFromFx(`Stream.fromExit`))
+export const fromPromise = flow(Fx.fromPromise, makeFromFx(`Stream.fromPromise`))
+export const fromLazy = flow(Fx.fromLazy, makeFromFx(`Stream.fromLazy`))
+export const fromEither = flow(Fx.fromEither, makeFromFx(`Stream.fromEither`))
+export const never = makeFromFx(`Stream.never`)(Fx.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)

package/src/Stream/index.ts

@@ -1,3 +1,14 @@
+export * from './bimap.js'
+export * from './continueWith.js'
 export * from './drain.js'
+export * from './empty.js'
+export * from './flatMap.js'
+export * from './flatMapFx.js'
+export * from './fromCallback.js'
 export * from './fromFx.js'
+export * from './hkt.js'
+export * from './map.js'
+export * from './periodic.js'
+export * from './scheduled.js'
 export * from './Stream.js'
+export * from './tap.js'

package/src/Stream/logging.test.ts

@@ -0,0 +1,24 @@
+import { flow, pipe } from 'hkt-ts'
+
+import { continueWith } from './continueWith.js'
+import { now } from './fromFx.js'
+import { runMain } from './run.js'
+import { tap } from './tap.js'
+
+import * as Fx from '@/Fx/index.js'
+import { RootScheduler } from '@/Scheduler/RootScheduler.js'
+import { testSuite } from '@/_internal/suite.js'
+
+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)),
+      )
+
+      await runMain(RootScheduler())(stream)
+    })
+  })
+})

package/src/Stream/map.ts

@@ -0,0 +1,35 @@
+import { flow } from 'hkt-ts/function'
+
+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'
+
+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 class MapStream<R, E, A, B> implements Stream<R, E, B> {
+  constructor(readonly stream: Stream<R, E, A>, readonly f: (a: A) => B) {}
+
+  fork<E2>(sink: Sink<E, B, E2>, scheduler: Scheduler, context: FiberContext<Live>) {
+    return this.stream.fork(
+      {
+        ...sink,
+        event: flow(this.f, sink.event),
+      },
+      scheduler,
+      context,
+    )
+  }
+
+  static make<R, E, A, B>(stream: Stream<R, E, A>, f: (a: A) => B): Stream<R, E, B> {
+    if (stream instanceof MapStream) {
+      return MapStream.make(stream.stream, flow(stream.f, f))
+    }
+
+    return new MapStream(stream, f)
+  }
+}

package/src/Stream/periodic.ts

@@ -0,0 +1,9 @@
+import { Stream } from './Stream.js'
+import { scheduled } from './scheduled.js'
+
+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)

package/src/Stream/run.ts

@@ -0,0 +1,14 @@
+import { flow, pipe } from 'hkt-ts/function'
+
+import { Stream } from './Stream.js'
+import { drain } from './drain.js'
+
+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> =>
+    pipe(drain(stream), Fx.flatMap(Fx.join), Fx.provideService(Scheduler, scheduler))
+}
+
+export const runMain = (scheduler: Scheduler) => flow(run(scheduler), Fx.runMain)

package/src/Stream/scheduled.test.ts

@@ -0,0 +1,34 @@
+import { deepStrictEqual } from 'assert'
+
+import { NonNegativeInteger } from 'hkt-ts/number'
+
+import { collectAll } from './_internal.test.js'
+import { scheduled } from './scheduled.js'
+
+import * as Fx from '@/Fx/index.js'
+import * as Schedule from '@/Schedule/index.js'
+import { Delay } from '@/Time/index.js'
+import { testSuite } from '@/_internal/suite.js'
+
+testSuite(import.meta.url, () => {
+  describe(scheduled.name, () => {
+    it('runs Fx on Schedule', async () => {
+      const value = Math.random()
+
+      deepStrictEqual(await collectAll(scheduled(Schedule.once)(Fx.now(value))), [value])
+
+      deepStrictEqual(await collectAll(scheduled(Schedule.delayed(Delay(1)))(Fx.now(value))), [
+        value,
+      ])
+
+      deepStrictEqual(
+        await collectAll(
+          scheduled(Schedule.periodic(Delay(1)).and(Schedule.retries(NonNegativeInteger(1))))(
+            Fx.now(value),
+          ),
+        ),
+        [value, value],
+      )
+    })
+  })
+})

package/src/Stream/scheduled.ts

@@ -0,0 +1,21 @@
+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'
+
+export function scheduled(schedule: Schedule) {
+  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'),
+        ),
+      ),
+    )
+}

package/src/Stream/tap.ts

@@ -0,0 +1,21 @@
+import { pipe } from 'hkt-ts/function'
+
+import { Stream } from './Stream.js'
+import { flatMapFx } from './flatMapFx.js'
+
+import { Fx, map } from '@/Fx/Fx.js'
+
+export const tap =
+  <A, R2, E2, B>(f: (a: A) => Fx<R2, E2, B>) =>
+  <R, E>(stream: Stream<R, E, A>): Stream<R | R2, E | E2, A> =>
+    pipe(
+      stream,
+      flatMapFx(
+        (a) =>
+          pipe(
+            f(a),
+            map(() => a),
+          ),
+        'Stream.tap',
+      ),
+    )

package/src/Supervisor/Supervisor.ts

@@ -14,6 +14,20 @@ export class Supervisor<A> {
     readonly onSuspended: (fiber: AnyLiveFiber) => void = constVoid,
     readonly onRunning: (fiber: AnyLiveFiber) => void = constVoid,
   ) {}
+
+  readonly extend = <B = A>(
+    overrides: Partial<{
+      readonly [K in keyof Supervisor<A>]: (parent: Supervisor<A>[K]) => Supervisor<B>[K]
+    }>,
+  ): Supervisor<B> =>
+    new Supervisor(
+      (overrides.value ? overrides.value(this.value) : this.value) as Of<B>,
+      overrides.onStart ? overrides.onStart(this.onStart) : this.onStart,
+      overrides.onEnd ? overrides.onEnd(this.onEnd) : this.onEnd,
+      overrides.onInstruction ? overrides.onInstruction(this.onInstruction) : this.onInstruction,
+      overrides.onSuspended ? overrides.onSuspended(this.onSuspended) : this.onSuspended,
+      overrides.onRunning ? overrides.onRunning(this.onRunning) : this.onRunning,
+    )
 }
 
 export const None = new (class None extends Supervisor<any> {})(unit)

package/src/Supervisor/index.ts

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

package/src/Supervisor/maxFailures.ts

@@ -0,0 +1,86 @@
+import { pipe } from 'hkt-ts'
+import { isRight } from 'hkt-ts/Either'
+import * as Maybe from 'hkt-ts/Maybe'
+import { First } from 'hkt-ts/Typeclass/Associative'
+import { NonNegativeInteger } from 'hkt-ts/number'
+
+import { Supervisor } from './Supervisor.js'
+
+import { Atomic, update } from '@/Atomic/Atomic.js'
+import * as Exit from '@/Exit/Exit.js'
+import { AnyLiveFiber } from '@/Fiber/Fiber.js'
+import { FiberId } from '@/FiberId/index.js'
+import { FiberRuntime } from '@/FiberRuntime/FiberRuntime.js'
+import { AnyFx, fromLazy } from '@/Fx/index.js'
+import { ImmutableMap } from '@/ImmutableMap/ImmutableMap.js'
+
+const concatExitSeq = Exit.makeSequentialAssociative<any, any>(First).concat
+
+export interface FiberFailureState {
+  readonly fx: AnyFx
+  readonly fiber: AnyLiveFiber
+  readonly exit: Maybe.Maybe<Exit.AnyExit>
+  readonly failures: NonNegativeInteger
+}
+
+export interface FiberFailuresState extends ImmutableMap<FiberId.Live, FiberFailureState> {}
+
+export function maxFailures(maxFailures: NonNegativeInteger): Supervisor<FiberFailuresState> {
+  const state = Atomic<FiberFailuresState>(ImmutableMap())
+
+  return new Supervisor(
+    fromLazy(state.get),
+    (fiber, fx) => {
+      pipe(
+        state,
+        update((fibers) => {
+          return fibers.has(fiber.id)
+            ? fibers
+            : fibers.set(fiber.id, {
+                fx,
+                fiber,
+                exit: Maybe.Nothing,
+                failures: NonNegativeInteger(0),
+              })
+        }),
+      )
+    },
+    (fiber, exit) => {
+      pipe(
+        state,
+        update((fibers) =>
+          pipe(
+            fibers.get(fiber.id),
+            Maybe.match(
+              () => fibers,
+              (s) => {
+                const nextIteration = NonNegativeInteger(s.failures + 1)
+
+                // If we succeeded, remove the fiber from state.
+                if (isRight(exit) || nextIteration > maxFailures) {
+                  return fibers.remove(fiber.id)
+                }
+
+                // Retry this Fx
+                const nextFiber = new FiberRuntime(s.fx, s.fiber.context.fork())
+
+                nextFiber.startAsync()
+
+                return fibers.set(fiber.id, {
+                  ...s,
+                  exit: pipe(
+                    s.exit,
+                    Maybe.map((e) => concatExitSeq(e, exit)),
+                    Maybe.orElse(() => Maybe.Just(exit)),
+                  ),
+                  fiber: nextFiber,
+                  failures: nextIteration,
+                })
+              },
+            ),
+          ),
+        ),
+      )
+    },
+  )
+}

package/src/Supervisor/trackIn.ts

@@ -0,0 +1,33 @@
+import { pipe } from 'hkt-ts/function'
+
+import { Supervisor } from './Supervisor.js'
+
+import { Atomic, update } from '@/Atomic/Atomic.js'
+import { AnyLiveFiber } from '@/Fiber/Fiber.js'
+import { FiberId } from '@/FiberId/FiberId.js'
+import { fromLazy } from '@/Fx/Fx.js'
+
+export function trackIn(
+  fibers: Atomic<ReadonlyMap<FiberId.Live, AnyLiveFiber>> = Atomic<
+    ReadonlyMap<FiberId.Live, AnyLiveFiber>
+  >(new Map()),
+): Supervisor<ReadonlyMap<FiberId.Live, AnyLiveFiber>> {
+  return new Supervisor(
+    fromLazy(() => fibers.get()),
+    (fiber) => {
+      pipe(
+        fibers,
+        update((fibers) => new Map([...fibers, [fiber.id, fiber]])),
+      )
+    },
+    (fiber) => {
+      pipe(
+        fibers,
+        update(
+          (fibers) =>
+            new Map([...fibers].filter(([id]) => id.sequenceNumber !== fiber.id.sequenceNumber)),
+        ),
+      )
+    },
+  )
+}