@typed/fx 0.0.6 → 0.0.9

package/src/Scope/LocalScope.ts

@@ -1,96 +0,0 @@
-import { mapTo } from 'hkt-ts/Either'
-import * as Maybe from 'hkt-ts/Maybe'
-import { First } from 'hkt-ts/Typeclass/Associative'
-import { pipe } from 'hkt-ts/function'
-
-import { Closeable } from './Closeable.js'
-import { ReleaseMap } from './ReleaseMap.js'
-import { Closed, Closing, Open, ScopeState } from './ScopeState.js'
-
-import { AtomicCounter, decrement, increment } from '@/Atomic/AtomicCounter.js'
-import { Exit, makeSequentialAssociative } from '@/Exit/Exit.js'
-import { FinalizationStrategy, Finalizer } from '@/Finalizer/Finalizer.js'
-import { Of, flatMap, fromExit, fromLazy, lazy, success, uninterruptable, unit } from '@/Fx/Fx.js'
-
-const { concat: concatExits } = makeSequentialAssociative<any, any>(First)
-
-export class LocalScope implements Closeable {
-  protected _state: ScopeState = Open
-  protected _releaseMap = new ReleaseMap(this.strategy)
-  protected _refCount = AtomicCounter()
-  protected _exit: Maybe.Maybe<Exit<any, any>> = Maybe.Nothing
-
-  constructor(readonly strategy: FinalizationStrategy) {}
-
-  get state(): ScopeState {
-    return this._state
-  }
-
-  readonly ensuring: (finalizer: Finalizer) => Finalizer = (finalizer) => {
-    if (this.isClosed) {
-      return (() => unit) as Finalizer
-    }
-
-    const key = this._releaseMap.add(finalizer)
-
-    return (exit) => this._releaseMap.release(key, exit)
-  }
-
-  readonly fork = (strategy: FinalizationStrategy = this.strategy): LocalScope => {
-    if (this.isClosed) {
-      throw new Error(`Unable to Fork a Closed Scope`)
-    }
-
-    const extended = new LocalScope(strategy)
-
-    extended.ensuring(() => {
-      decrement(this._refCount)
-
-      return this.release
-    })
-
-    increment(this._refCount)
-
-    return extended
-  }
-
-  readonly close = (exit: Exit<any, any>): Of<boolean> =>
-    lazy(() => {
-      if (!this.isClosed) {
-        this.setExit(exit)
-      }
-
-      return this.release
-    })
-
-  // Internals
-
-  protected release = lazy(() => {
-    if (this._refCount.get() > 0 || Maybe.isNothing(this._exit) || this.isClosed) {
-      return success(false)
-    }
-
-    const exit = this._exit.value
-
-    return pipe(
-      fromLazy(() => (this._state = Closing(exit))),
-      flatMap(() => this._releaseMap.releaseAll(exit)),
-      flatMap((exit) =>
-        pipe(
-          fromLazy(() => (this._state = Closed(exit))),
-          flatMap(() => pipe(exit, mapTo(true), fromExit) as Of<boolean>),
-        ),
-      ),
-      uninterruptable,
-    )
-  })
-
-  protected get isClosed() {
-    return this.state.tag === 'Closed'
-  }
-
-  // Accumulate Exit values
-  protected setExit(exit: Exit<any, any>) {
-    this._exit = pipe(this._exit, Maybe.reduce(exit, concatExits), Maybe.Just)
-  }
-}

package/src/Scope/ReleaseMap.ts

@@ -1,113 +0,0 @@
-/* eslint-disable @typescript-eslint/no-this-alias */
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
-
-import * as A from 'hkt-ts/Array'
-import { Just, Maybe, Nothing } from 'hkt-ts/Maybe'
-import { First } from 'hkt-ts/Typeclass/Associative'
-import { pipe } from 'hkt-ts/function'
-
-import * as Exit from '@/Exit/Exit.js'
-import {
-  FinalizationStrategy,
-  Finalizer,
-  FinalizerKey,
-  finalizationStrategyToConcurrency,
-} from '@/Finalizer/Finalizer.js'
-import { Fx, Of, attempt, lazy, unit, withConcurrency, zipAll } from '@/Fx/Fx.js'
-
-let nextId = 0
-
-const concatExitSeq = Exit.makeSequentialAssociative<any, any>(First).concat
-const concatExitPar = Exit.makeParallelAssociative<any, any>(First).concat
-
-/**
- * ReleaseMap is an underlying class utilizing in the implementation of Managed. It allows
- * tracking multiple Finalizers and closing them.
- */
-export class ReleaseMap {
-  protected finalizers: Map<FinalizerKey, Finalizer> = new Map()
-
-  constructor(readonly strategy: FinalizationStrategy) {}
-
-  readonly isEmpty = () => this.finalizers.size === 0
-
-  readonly add = (finalizer: Finalizer): FinalizerKey => {
-    const id = FinalizerKey(Symbol(nextId++))
-
-    this.finalizers.set(id, finalizer)
-
-    return id
-  }
-
-  readonly remove = (key: FinalizerKey): Maybe<Finalizer> => {
-    if (!this.finalizers.has(key)) {
-      return Nothing
-    }
-
-    const finalizer = this.finalizers.get(key)!
-
-    this.finalizers.delete(key)
-
-    return Just(finalizer)
-  }
-
-  readonly release = (key: FinalizerKey, exit: Exit.Exit<any, any>): Of<void> =>
-    lazy(() =>
-      this.finalizers.has(key)
-        ? lazy(() => {
-            const finalize = this.finalizers.get(key)!(exit) as Of<void>
-
-            this.remove(key)
-
-            return finalize
-          })
-        : unit,
-    )
-
-  readonly releaseAll = (exit: Exit.AnyExit): Of<Exit.AnyExit> => {
-    const toBeReleased = () =>
-      Array.from(this.finalizers.keys())
-        .reverse()
-        .map((key) => attempt(this.release(key, exit)))
-
-    const isEmpty = () => this.isEmpty()
-
-    if (this.strategy.strategy === 'Sequential') {
-      return Fx(function* () {
-        const exits: Array<Exit.AnyExit> = []
-
-        while (!isEmpty()) {
-          for (const fx of toBeReleased()) {
-            exits.push(yield* fx)
-          }
-        }
-
-        if (A.isNonEmpty(exits)) {
-          return exits.reduce(concatExitSeq, exit)
-        }
-
-        return exit
-      })
-    }
-
-    const releaseAll_ = () =>
-      pipe(
-        zipAll(toBeReleased()),
-        withConcurrency(finalizationStrategyToConcurrency(this.strategy)),
-      )
-
-    return Fx(function* () {
-      const exits: Array<Exit.AnyExit> = []
-
-      while (!isEmpty()) {
-        exits.push((yield* releaseAll_()).reduce(concatExitPar as any))
-      }
-
-      if (A.isNonEmpty(exits)) {
-        return exits.reduce(concatExitSeq, exit)
-      }
-
-      return exit
-    })
-  }
-}

package/src/Scope/Scope.ts

@@ -1,13 +0,0 @@
-import type { Closeable } from './Closeable.js'
-import { ScopeState } from './ScopeState.js'
-
-import { FinalizationStrategy, Finalizer } from '@/Finalizer/Finalizer.js'
-import { Service } from '@/Service/Service.js'
-
-export interface Scope {
-  readonly state: ScopeState
-  readonly ensuring: (finalizer: Finalizer) => Finalizer
-  readonly fork: (strategy?: FinalizationStrategy) => Closeable
-}
-
-export const Scope = Service<Scope>('Scope')

package/src/Scope/ScopeState.ts

@@ -1,45 +0,0 @@
-import { Just, Maybe, Nothing } from 'hkt-ts/Maybe'
-
-import { Exit } from '@/Exit/Exit.js'
-
-export type ScopeState = Open | Closing | Closed
-
-export interface Open {
-  readonly tag: 'Open'
-}
-
-export const Open: Open = { tag: 'Open' }
-
-export interface Closing {
-  readonly tag: 'Closing'
-  readonly exit: Exit<any, any>
-}
-
-export function Closing(exit: Exit<any, any>): Closing {
-  return {
-    tag: 'Closing',
-    exit,
-  }
-}
-
-export interface Closed {
-  readonly tag: 'Closed'
-  readonly exit: Exit<any, any>
-}
-
-export function Closed(exit: Exit<any, any>): Closed {
-  return {
-    tag: 'Closed',
-    exit,
-  }
-}
-
-export function getExit(state: ScopeState): Maybe<Exit<any, any>> {
-  switch (state.tag) {
-    case 'Closing':
-    case 'Closed':
-      return Just(state.exit)
-    default:
-      return Nothing
-  }
-}

package/src/Scope/index.ts

@@ -1,6 +0,0 @@
-export * from './Closeable.js'
-export * from './GlobalScope.js'
-export * from './LocalScope.js'
-export * from './ReleaseMap.js'
-export * from './Scope.js'
-export * from './ScopeState.js'

package/src/Semaphore/Semaphore.ts

@@ -1,102 +0,0 @@
-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 * 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 = AtomicCounter()
-
-  constructor(readonly maxPermits: NonNegativeInteger) {}
-
-  // Retrieve the number of permits still available
-  get available(): NonNegativeInteger {
-    return NonNegativeInteger(Math.max(0, this.maxPermits - this.running.get()))
-  }
-
-  get acquired(): NonNegativeInteger {
-    return this.running.get()
-  }
-
-  readonly prepare = Fx.fromLazy(() => {
-    if (this.available > 0) {
-      return new Acquisition(
-        Fx.fromLazy(() => {
-          increment(this.running)
-        }),
-        this.release,
-      )
-    }
-
-    const [future] = this.waiting.waitFor(1)
-
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
-    const that = this
-    const acquisition = new Acquisition(
-      pipe(
-        wait(future),
-        Fx.tapLazy(() => increment(that.running)),
-      ),
-      this.release,
-    )
-
-    return acquisition
-  })
-
-  protected release = Fx.fromLazy(() => {
-    decrement(this.running)
-    this.waiting.next(Fx.unit)
-  })
-}
-
-export class Acquisition {
-  constructor(readonly acquire: Fx.Of<void>, readonly release: Fx.Of<void>) {}
-}
-
-/**
- * Specialization of Semaphore which only allows 1 permit.
- */
-export class Lock extends Semaphore {
-  constructor() {
-    super(NonNegativeInteger(1))
-  }
-}
-
-/**
- * Acquire a permit from a given semaphore, blocking until it is available.
- * Must be used with Fx.scoped() to release the permit at the desired time.
- */
-export function acquirePermit(semaphore: Semaphore) {
-  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.Fx<R, E, A>) =>
-    pipe(
-      acquirePermit(semaphore),
-      Fx.flatMap(() => fx),
-      scoped,
-    )
-}
-
-/**
- * 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.Fx<R, E, A>) =>
-    pipe(
-      acquirePermit(semaphore),
-      Fx.flatMap(() => fx),
-      fiberScoped,
-    )
-}

package/src/Semaphore/index.ts

@@ -1 +0,0 @@
-export * from './Semaphore.js'

package/src/Service/Id.ts

@@ -1,119 +0,0 @@
-import { pipe } from 'hkt-ts/function'
-
-import { Service } from './Service.js'
-
-import { Fx, RIO, ask, flatMap, fromLazy } from '@/Fx/Fx.js'
-import * as Layer from '@/Layer/Layer.js'
-import { Scope } from '@/Scope/Scope.js'
-
-const idCache = new WeakMap<object, Service<any>>()
-
-export type InstanceOf<T> = T extends new (...args: any) => infer R ? R : T
-
-/**
- * Extendable class for constructing a Service
- */
-export class Id {
-  readonly name: string = this.constructor.name
-
-  /**
-   * The ID of the Service.
-   *
-   * Unfortunately, in order to get type-inference the way we'd like this must
-   * currently be a method to access the "this" type in sub-classes.
-   */
-  static id<S extends { readonly name: string }>(this: S): Service<InstanceOf<S>> {
-    return getCachedId(this)
-  }
-
-  // Replicate the same ID to the instance.
-  readonly id: Service<this> = (this.constructor as any).id()
-
-  /**
-   * Retrieve this service at Runtime, requiring it from the given Environment.
-   */
-  static ask<
-    S extends {
-      readonly id: () => Service<any>
-      new (...args: any): any
-    },
-  >(this: S): RIO<InstanceOf<S>, InstanceOf<S>> {
-    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.
-   */
-  static layer<
-    S extends {
-      readonly id: () => Service<any>
-      new (...args: any): any
-    },
-    R,
-    E,
-  >(
-    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))),
-    )
-  }
-}
-
-/**
- * Helper for constructing IDs that are tied to a particular object, which much have
- * a name to create the Service Key. Particularly useful for creating Class declarations for Services.
- *
- * @example
- * import * as S from '@typed/fx/Service'
- * import * as Fx from '@typed/fx/Fx'
- *
- * class Foo {
- *   static id = S.getCachedId(this)
- *
- *   constructor(readonly foo: string) {}
- * }
- *
- * const program = Fx.Fx(function*(){
- *   const { foo }: Foo = yield* Fx.ask(Foo.id)
- *a
- *   return foo // string
- * })
- */
-export function getCachedId<S extends { readonly name: string }>(key: S): Service<InstanceOf<S>> {
-  if (idCache.has(key)) {
-    return idCache.get(key) as Service<InstanceOf<S>>
-  }
-
-  const s = Service<InstanceOf<S>>(key.name)
-
-  idCache.set(key, s)
-
-  return s
-}

package/src/Service/Service.ts

@@ -1,31 +0,0 @@
-import { Tagged } from '@/Tagged/index.js'
-
-/**
- * The Definition/ID of a Service
- */
-export type Service<S> = Tagged<
-  {
-    readonly Service: S
-  },
-  symbol
->
-
-/**
- * Construct a Service, the provided name is used for debugging purposes and is required.
- */
-export const Service = <S>(name: string): Service<S> => Tagged<Service<S>>()(Symbol(name))
-
-/**
- * Extract the output of a Service
- */
-export type OutputOf<T> = [T] extends [Service<infer S>] ? S : never
-
-const symbolRegex = /^Symbol/i
-const serviceText = 'Service'
-
-/**
- * Format a Service's into a string.
- */
-export function formatService<A>(service: Service<A>) {
-  return service.toString().replace(symbolRegex, serviceText)
-}

package/src/Service/fn.ts

@@ -1,41 +0,0 @@
-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,4 +0,0 @@
-export * from './Service.js'
-export * from './Id.js'
-export * from './tagged.js'
-export * from './fn.js'

package/src/Service/tagged.ts

@@ -1,10 +0,0 @@
-import { Id } from './Id.js'
-
-/**
- * Sometimes it is necessary to tag a Service to ensure it is considered different from another at the type-level.
- */
-export const tagged = <Tag extends string>(tag: Tag) =>
-  class TaggedService extends Id {
-    static tag: Tag = tag
-    readonly tag: Tag = tag
-  }

package/src/Sink/Sink.ts

@@ -1,89 +0,0 @@
-import { flow, pipe } from 'hkt-ts'
-import { Left, Right } from 'hkt-ts/Either'
-
-import { Cause } from '@/Cause/Cause.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> {
-  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
-  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<
-  E,
-  A,
-  R2 = never,
-  E2 = never,
-  R3 = never,
-  E3 = never,
-  R4 = never,
-  E4 = never,
-> {
-  readonly event?: (a: A) => Fx<R2, E2, any>
-  readonly error?: (cause: Cause<E>) => Fx<R3, E3, any>
-  readonly end?: Fx<R4, E4, any>
-}
-
-export function makeDrain<
-  E,
-  A,
-  R2 = never,
-  E2 = never,
-  R3 = never,
-  E3 = never,
-  R4 = never,
-  E4 = never,
->(
-  scope: Closeable,
-  fx: SinkFx<E, A, R2, E2, R3, E3, R4, E4>,
-): 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, A, E2 | E3 | E4>
-
-      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
-    }),
-  )
-}
-
-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)),
-  }
-}