@typed/fx 0.0.6 → 0.0.9

package/src/Stream/flatMap.test.ts

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

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

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

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

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

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

@@ -1,84 +0,0 @@
-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,17 +0,0 @@
-import { deepStrictEqual } from 'assert'
-
-import { collectAll } from './_internal.test.js'
-import { fromFx } from './fromFx.js'
-
-import * as Fx from '@/Fx/index.js'
-
-describe(new URL(import.meta.url).pathname, () => {
-  describe(fromFx.name, () => {
-    const value = Math.random()
-    const stream = fromFx(Fx.success(value))
-
-    it('is collectable', async () => {
-      deepStrictEqual(await collectAll(stream), [value])
-    })
-  })
-})

package/src/Stream/fromFx.ts

@@ -1,62 +0,0 @@
-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'
-
-/**
- * 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),
-              ),
-              __trace,
-            ),
-          ),
-          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

@@ -1,36 +0,0 @@
-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/hold.test.ts

@@ -1,52 +0,0 @@
-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)
-    })
-  })
-})