@typed/fx 0.0.3 → 0.0.4

package/src/Service/Id.ts

@@ -1,6 +1,8 @@
+import { pipe } from 'hkt-ts/function'
+
 import { Service } from './Service.js'
 
-import { Fx, RIO, ask } from '@/Fx/Fx.js'
+import { Fx, RIO, ask, flatMap, fromLazy } from '@/Fx/Fx.js'
 import * as Layer from '@/Layer/Layer.js'
 import { Scope } from '@/Scope/Scope.js'
 
@@ -39,6 +41,21 @@ export class Id {
     return ask(this.id())
   }
 
+  /**
+   * Retrieve this service at Runtime, requiring it from the given Environment.
+   */
+  static with<
+    S extends {
+      readonly id: () => Service<any>
+      new (...args: any): any
+    },
+    R2,
+    E2,
+    B,
+  >(this: S, f: (s: InstanceOf<S>) => Fx<R2, E2, B>): Fx<R2 | InstanceOf<S>, E2, B> {
+    return pipe(ask(this.id()), flatMap(f))
+  }
+
   /**
    * Construct a Layer that provides this service.
    */
@@ -49,9 +66,24 @@ export class Id {
     },
     R,
     E,
-  >(this: S, provider: Fx<R | Scope, E, InstanceOf<S>>): Layer.Layer<R, E, InstanceOf<S>> {
+  >(
+    this: S,
+    provider: Fx<R, E, InstanceOf<S>> | Fx<R | Scope, E, InstanceOf<S>>,
+  ): Layer.Layer<R, E, InstanceOf<S>> {
     return Layer.fromFx(this.id(), provider)
   }
+
+  static layerOf<
+    S extends {
+      readonly id: () => Service<any>
+      new (...args: any): any
+    },
+  >(this: S, ...args: ConstructorParameters<S>): Layer.Layer<never, never, InstanceOf<S>> {
+    return Layer.fromFx(
+      this.id(),
+      fromLazy(() => new this(...(args as any))),
+    )
+  }
 }
 
 /**

package/src/Service/fn.ts

@@ -0,0 +1,41 @@
+import { ArgsOf } from 'hkt-ts'
+
+import { Id, InstanceOf } from './Id.js'
+import { Service } from './Service.js'
+import { tagged } from './tagged.js'
+
+import type { AnyFx, ErrorsOf, Fx, OutputOf, ResourcesOf } from '@/Fx/Fx.js'
+
+export const fn =
+  <F extends (...args: any) => AnyFx>() =>
+  <ServiceName extends string>(name: ServiceName) =>
+    class Fn extends tagged(name) {
+      constructor(readonly f: F) {
+        super()
+      }
+
+      static apply<
+        T extends {
+          readonly id: () => Service<any>
+          new (...args: any): { readonly f: F }
+        } & { readonly with: typeof Id['with'] },
+      >(
+        this: T,
+        ...args: ArgsOf<F>
+      ): Fx<
+        InstanceOf<T> | ResourcesOf<ReturnType<F>>,
+        ErrorsOf<ReturnType<F>>,
+        OutputOf<ReturnType<F>>
+      > {
+        return this.with((s) => s.f(...(args as any)))
+      }
+
+      static make<
+        T extends {
+          readonly id: () => Service<any>
+          new (...args: any): { readonly f: F }
+        },
+      >(this: T, fn: F): InstanceOf<T> {
+        return new this(fn) as InstanceOf<T>
+      }
+    }

package/src/Service/index.ts

@@ -1,3 +1,4 @@
 export * from './Service.js'
 export * from './Id.js'
 export * from './tagged.js'
+export * from './fn.js'

package/src/Sink/Sink.ts

@@ -2,21 +2,21 @@ import { flow, pipe } from 'hkt-ts'
 import { Left, Right } from 'hkt-ts/Either'
 
 import { Cause } from '@/Cause/Cause.js'
-import { Fx, IO, getEnv, provide, unit } from '@/Fx/Fx.js'
+import { Fx, IO, access, flatMap, fromLazy, provide, unit } from '@/Fx/Fx.js'
 import { Closeable } from '@/Scope/Closeable.js'
 
-export interface Sink<E, A> {
-  readonly event: (a: A) => IO<E, any>
-  readonly error: (cause: Cause<E>) => IO<E, any>
-  readonly end: IO<E, any>
+export interface Sink<in E, in A, out E2 = never> {
+  readonly event: (a: A) => IO<E2, any>
+  readonly error: (cause: Cause<E>) => IO<E2, any>
+  readonly end: IO<E2, any>
 }
 
 export class Drain<E, A> implements Sink<E, A> {
   constructor(readonly scope: Closeable) {}
 
-  readonly event: Sink<E, A>['event'] = () => unit as IO<E, any>
-  readonly error: Sink<E, A>['error'] = (cause) => this.scope.close(Left(cause)) as IO<E, any>
-  readonly end: Sink<E, A>['end'] = this.scope.close(Right(undefined)) as IO<E, any>
+  readonly event: Sink<E, A>['event'] = () => unit
+  readonly error: Sink<E, A>['error'] = (cause) => this.scope.close(Left(cause))
+  readonly end: Sink<E, A>['end'] = this.scope.close(Right(undefined))
 }
 
 export interface SinkFx<
@@ -46,20 +46,34 @@ export function makeDrain<
 >(
   scope: Closeable,
   fx: SinkFx<E, A, R2, E2, R3, E3, R4, E4>,
-): Fx<R2 | R3 | R4, never, Sink<E | E2 | E3 | E4, A>> {
-  return Fx(function* () {
-    const env = yield* getEnv<R2 | R3 | R4>()
-    const drain = new Drain<E, A>(scope)
+): Fx<R2 | R3 | R4, never, Sink<E, A, E2 | E3 | E4>> {
+  return access((env) =>
+    fromLazy(() => {
+      const drain = new Drain<E, A>(scope)
 
-    type O = Sink<E | E2 | E3 | E4, A>
+      type O = Sink<E, A, E2 | E3 | E4>
 
-    // TODO: Should drain always be called for error + end?
-    const sink: O = {
-      event: (fx.event ? flow(fx.event, provide(env)) : drain.event) as O['event'],
-      error: (fx.error ? flow(fx.error, provide(env)) : drain.error) as O['error'],
-      end: (fx.end ? pipe(fx.end, provide(env)) : drain.end) as O['end'],
-    }
+      const sink: O = {
+        event: fx.event ? flow(fx.event, provide(env)) : drain.event,
+        error: fx.error
+          ? (a) =>
+              pipe(
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                fx.error!(a as any),
+                provide(env),
+                flatMap(() => drain.error(a)),
+              )
+          : drain.error,
+        end: fx.end
+          ? pipe(
+              fx.end,
+              provide(env),
+              flatMap(() => drain.end),
+            )
+          : drain.end,
+      }
 
-    return sink
-  })
+      return sink
+    }),
+  )
 }

package/src/Stream/Stream.ts

@@ -1,21 +1,57 @@
-import { Live } from '@/Fiber/Fiber.js'
+import { Fiber } from '@/Fiber/Fiber.js'
 import { FiberContext } from '@/FiberContext/FiberContext.js'
+import { FiberId } from '@/FiberId/FiberId.js'
 import * as Fx from '@/Fx/Fx.js'
 import { Scheduler } from '@/Scheduler/Scheduler.js'
 import { Sink } from '@/Sink/Sink.js'
 
-export interface Stream<R, E, A> {
-  readonly fork: <E2>(
-    sink: Sink<E | E2, A>,
+/**
+ * TODOS:
+ * - Scan
+ * - Loop
+ * - zipItems
+ * - withItems
+ * - switchLatest
+ * - concatMap
+ * - mergeConcurrently
+ * - merge/mergeArray
+ * - combine/combineArray
+ * - zip/zipArray
+ * - sample
+ * - snapshot
+ * - skipRepeats
+ * - slice/take/skip
+ * - takeWhile/skipWhile
+ * - takeUntil/skipUntil
+ * - takeAfter/skipAfter
+ * - 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>(
+    sink: Sink<E, A, E2>,
     scheduler: Scheduler,
-    context: FiberContext,
-  ) => Fx.RIO<R, Live<E | E2, any>>
+    context: FiberContext<FiberId.Live>,
+  ) => Fx.RIO<R, Fiber<E2, any>>
 }
 
 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> {}
 
-export function Stream<R, E, A>(fork: Stream<R, E, A>['fork']) {
+export function Stream<R, E, A>(fork: Stream<R, E, A>['fork']): Stream<R, E, A> {
   return { fork }
 }

package/src/Stream/_internal.test.ts

@@ -0,0 +1,12 @@
+import { pipe } from 'hkt-ts/function'
+
+import { Stream } from './Stream.js'
+import { collect } from './drain.js'
+
+import * as Fx from '@/Fx/Fx.js'
+import { runMain } from '@/Fx/run.js'
+import { RootScheduler } from '@/Scheduler/RootScheduler.js'
+import { Scheduler } from '@/Scheduler/index.js'
+
+export const collectAll = <E, A>(stream: Stream<never, E, A>) =>
+  pipe(collect(stream), Fx.provideService(Scheduler, RootScheduler()), runMain)

package/src/Stream/bimap.ts

@@ -0,0 +1,59 @@
+import { flow } 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 { Scheduler } from '@/Scheduler/Scheduler.js'
+import { Sink } from '@/Sink/Sink.js'
+
+export function bimap<A, B, C, D>(
+  f: (a: A) => B,
+  g: (c: C) => D,
+): <R>(stream: Stream<R, A, C>) => Stream<R, B, D> {
+  return (stream) => BimapStream.make(stream, f, g)
+}
+
+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) {}
+
+  fork = <E2>(sink: Sink<B, D, E2>, scheduler: Scheduler, context: FiberContext<Live>) => {
+    return this.stream.fork<E2>(
+      new BimapSink(sink, scheduler, context, this.f, this.g),
+      scheduler,
+      context,
+    )
+  }
+
+  static make<R, A, B, C, D>(
+    stream: Stream<R, A, C>,
+    f: (a: A) => B,
+    g: (c: C) => D,
+  ): Stream<R, B, D> {
+    if (stream instanceof MapStream) {
+      return BimapStream.make(stream.stream, f, flow(stream.f, g))
+    }
+
+    if (stream instanceof BimapStream) {
+      return BimapStream.make(stream.stream, flow(stream.f, f), flow(stream.g, g))
+    }
+
+    return new BimapStream(stream, f, g)
+  }
+}
+
+class BimapSink<A, B, C, D, E> implements Sink<A, C, E> {
+  constructor(
+    readonly sink: Sink<B, D, E>,
+    readonly scheduler: Scheduler,
+    readonly context: FiberContext<Live>,
+    readonly f: (a: A) => B,
+    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))
+  end = this.sink.end
+}

package/src/Stream/continueWith.test.ts

@@ -0,0 +1,23 @@
+import { deepStrictEqual } from 'assert'
+
+import { pipe } from 'hkt-ts'
+
+import { collectAll } from './_internal.test.js'
+import { continueWith } from './continueWith.js'
+import { now } from './fromFx.js'
+
+import { testSuite } from '@/_internal/suite.js'
+
+testSuite(import.meta.url, () => {
+  describe(continueWith.name, () => {
+    const stream = pipe(
+      now(1),
+      continueWith(() => now(2)),
+    )
+    it('should continue with the provided stream', async () => {
+      const events = await collectAll(stream)
+
+      deepStrictEqual(events, [1, 2])
+    })
+  })
+})

package/src/Stream/continueWith.ts

@@ -0,0 +1,65 @@
+import { pipe } from 'hkt-ts'
+
+import { Stream } from './Stream.js'
+import { now } from './fromFx.js'
+
+import { Env } from '@/Env/Env.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 continueWith<R2, E2, B>(f: () => Stream<R2, E2, B>) {
+  return <R, E, A>(stream: Stream<R, E, A>): Stream<R | R2, E | E2, A | B> =>
+    new ContinueWith(stream, f)
+}
+
+export const startWith =
+  <B>(value: B) =>
+  <R, E, A>(stream: Stream<R, E, A>) =>
+    pipe(
+      now(value),
+      continueWith(() => stream),
+    )
+
+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>) {}
+
+  fork = <E3>(
+    sink: Sink<E | E2, A | B, E3>,
+    scheduler: Scheduler,
+    context: FiberContext<FiberId.Live>,
+  ) => {
+    return Fx.access((env: Env<R | R2>) =>
+      this.stream.fork(
+        new ContinueWithSink(sink, scheduler, context, env, this.f),
+        scheduler,
+        context,
+      ),
+    )
+  }
+}
+
+export class ContinueWithSink<R, E, A, R2, E2, B, E3> implements Sink<E | E2, A | B, E3> {
+  constructor(
+    readonly sink: Sink<E | E2, A | B, E3>,
+    readonly scheduler: Scheduler,
+    readonly context: FiberContext<FiberId.Live>,
+    readonly env: Env<R | R2>,
+    readonly f: () => Stream<R2, E2, B>,
+  ) {}
+
+  event = this.sink.event
+  error = this.sink.error
+  end = Fx.lazy(() =>
+    pipe(
+      this.f().fork(
+        this.sink,
+        this.scheduler,
+        this.context.fork({ fiberRefs: this.context.fiberRefs }),
+      ),
+      Fx.provide(this.env),
+    ),
+  )
+}

package/src/Stream/drain.ts

@@ -4,8 +4,7 @@ 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'
@@ -13,7 +12,7 @@ import { Drain, Sink, 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<E, any>> {
   return pipe(
     Fx.Do,
     Fx.bind('fiberContext', () => Fx.getFiberContext),
@@ -25,8 +24,8 @@ export function drain<R, E, A>(
 
 export function fork<R, E, A, E2 = never>(
   stream: Stream<R, E, A>,
-  sink: Sink<E | E2, A>,
-  context: FiberContext,
+  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))
 }
@@ -46,28 +45,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))),
+      Fx.flatMap(Fx.join),
+    )
+
+    return events
+  }, __trace)
 }

package/src/Stream/empty.ts

@@ -0,0 +1,8 @@
+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'))),
+)

package/src/Stream/flatMap.test.ts

@@ -0,0 +1,43 @@
+import { deepStrictEqual } from 'assert'
+
+import { pipe } from 'hkt-ts'
+
+import { collect, observe } from './drain.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, () => {
+  describe(flatMap.name, () => {
+    const value = Math.random()
+    const stream = pipe(
+      fromFx(Fx.success(value)),
+      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)
+
+          deepStrictEqual(events, [value + 1])
+        }),
+        Fx.provideService(Scheduler, RootScheduler()),
+        Fx.runMain,
+      )
+    })
+  })
+})

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))))
+}