@typed/fx 0.0.3 → 0.0.6

package/src/Semaphore/Semaphore.ts

@@ -1,31 +1,32 @@
-import { constant } from 'hkt-ts/function'
+import { constant, pipe } from 'hkt-ts/function'
 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, fromLazy, unit } from '@/Fx/Fx.js'
+import * as Fx from '@/Fx/Fx.js'
 import { fiberScoped, managed, scoped } from '@/Fx/scoped.js'
 
 export class Semaphore {
   protected waiting = MutableFutureQueue<never, never, void>()
-  protected running = 0
+  protected running = AtomicCounter()
 
   constructor(readonly maxPermits: NonNegativeInteger) {}
 
   // Retrieve the number of permits still available
   get available(): NonNegativeInteger {
-    return NonNegativeInteger(Math.max(0, this.maxPermits - this.running))
+    return NonNegativeInteger(Math.max(0, this.maxPermits - this.running.get()))
   }
 
   get acquired(): NonNegativeInteger {
-    return NonNegativeInteger(this.running)
+    return this.running.get()
   }
 
-  readonly prepare = fromLazy(() => {
+  readonly prepare = Fx.fromLazy(() => {
     if (this.available > 0) {
       return new Acquisition(
-        fromLazy(() => {
-          this.running++
+        Fx.fromLazy(() => {
+          increment(this.running)
         }),
         this.release,
       )
@@ -36,28 +37,24 @@ export class Semaphore {
     // eslint-disable-next-line @typescript-eslint/no-this-alias
     const that = this
     const acquisition = new Acquisition(
-      Fx(function* () {
-        yield* wait(future)
-
-        that.running++
-      }),
+      pipe(
+        wait(future),
+        Fx.tapLazy(() => increment(that.running)),
+      ),
       this.release,
     )
 
     return acquisition
   })
 
-  protected release = fromLazy(() => {
-    this.running = Math.max(0, this.running - 1)
-
-    if (this.waiting.size() > 0) {
-      this.waiting.next(unit)
-    }
+  protected release = Fx.fromLazy(() => {
+    decrement(this.running)
+    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>) {}
 }
 
 /**
@@ -74,24 +71,21 @@ export class Lock extends Semaphore {
  * Must be used with Fx.scoped() to release the permit at the desired time.
  */
 export function acquirePermit(semaphore: Semaphore) {
-  return Fx(function* () {
-    const { acquire, release } = yield* semaphore.prepare
-
-    return yield* managed(acquire, constant(release))
-  })
+  return pipe(
+    semaphore.prepare,
+    Fx.flatMap(({ acquire, release }) => managed(acquire, constant(release))),
+  )
 }
 
 /**
  * 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>) =>
-    scoped(
-      Fx(function* () {
-        yield* acquirePermit(semaphore)
-
-        return yield* fx
-      }),
+  return <R, E, A>(fx: Fx.Fx<R, E, A>) =>
+    pipe(
+      acquirePermit(semaphore),
+      Fx.flatMap(() => fx),
+      scoped,
     )
 }
 
@@ -99,12 +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>) =>
-    fiberScoped(
-      Fx(function* () {
-        yield* acquirePermit(semaphore)
-
-        return yield* fx
-      }),
+  return <R, E, A>(fx: Fx.Fx<R, E, A>) =>
+    pipe(
+      acquirePermit(semaphore),
+      Fx.flatMap(() => fx),
+      fiberScoped,
     )
 }

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, addCustomTrace, 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,44 @@ 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
+    }),
+  )
+}
+
+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

@@ -1,21 +1,55 @@
-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:
+ * - Loop
+ * - zipItems
+ * - withItems
+ * - concatMap
+ * - combine/combineArray
+ * - zip/zipArray
+ * - sample
+ * - snapshot
+ * - skipRepeats
+ * - slice/take/skip
+ * - takeWhile/skipWhile
+ * - takeUntil/skipUntil
+ * - takeAfter/skipAfter
+ * - since
+ * - during
+ * - until
+ * - delay
+ * - throttle
+ * - debounce
+ * - reduce
+ * - Fusion/Commutation
+ * - Unique Identification for streams to add to tracing
+ *    - How to build a dynamic stream graph?
+ */
+
+export interface Stream<out R = never, out E = never, out A = unknown> {
+  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>>
 }
 
+/* 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> {}
 
-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/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

@@ -0,0 +1,66 @@
+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,
+  __trace?: string,
+): <R>(stream: Stream<R, A, C>) => Stream<R, B, D> {
+  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,
+    readonly __trace?: string,
+  ) {}
+
+  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,
+    )
+  }
+
+  static make<R, A, B, C, 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), __trace)
+    }
+
+    if (stream instanceof BimapStream) {
+      return BimapStream.make(stream.stream, flow(stream.f, f), flow(stream.g, g), __trace)
+    }
+
+    return new BimapStream(stream, f, g, __trace)
+  }
+}
+
+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 = flow(this.g, this.sink.event)
+  error = flow(Cause.map(this.f), this.sink.error)
+  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,69 @@
+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, addTrace } from '@/Sink/Sink.js'
+
+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, __trace)
+}
+
+export const startWith =
+  <B>(value: B, __trace?: string) =>
+  <R, E, A>(stream: Stream<R, E, A>) =>
+    pipe(
+      now(value),
+      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>,
+    readonly __trace?: string,
+  ) {}
+
+  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(
+        addTrace(new ContinueWithSink(sink, scheduler, context, env, this.f), this.__trace),
+        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),
+    ),
+  )
+}