@typed/fx 0.0.6 → 0.0.9

package/src/Fx/scheduler.ts

@@ -1,76 +0,0 @@
-import { pipe } from 'hkt-ts'
-import { isRight } from 'hkt-ts/Either'
-
-import { join } from './join.js'
-
-import * as Cause from '@/Cause/Cause.js'
-import { Exit } from '@/Exit/Exit.js'
-import { Live } from '@/Fiber/Fiber.js'
-import * as Fx from '@/Fx/Fx.js'
-import * as Schedule from '@/Schedule/Schedule.js'
-import { ScheduleState } from '@/Schedule/ScheduleState.js'
-import { Scheduler } from '@/Scheduler/Scheduler.js'
-import { Delay, Time } from '@/Time/index.js'
-
-/**
- * Runs an Fx on a given Schedule
- */
-export function retry(schedule: Schedule.Schedule) {
-  return <R, E, A>(fx: Fx.Fx<R, E, A>): Fx.Fx<R | Scheduler, E, A> => {
-    return Fx.Fx(function* () {
-      const timer = yield* Fx.getTimer
-      let [state, decision] = schedule.step(timer.getCurrentTime(), new ScheduleState())
-
-      const errors: Array<Cause.Cause<E>> = []
-
-      while (decision.tag === 'Continue') {
-        // Schedule a Task to run the next iteration of this Fx
-        const exit: Exit<E, A> = yield* delayed(decision.delay)(Fx.attempt(fx))
-
-        if (isRight(exit)) {
-          return exit.right
-        }
-
-        errors.push(exit.left)
-
-        // Calculate if we should continue or not
-        const [nextState, nextDecision] = schedule.step(timer.getCurrentTime(), state)
-        state = nextState
-        decision = nextDecision
-      }
-
-      return yield* Fx.fromCause<E>(
-        errors.reduce(Cause.makeSequentialAssociative<any>().concat, Cause.Empty),
-      )
-    })
-  }
-}
-
-export function schedule(schedule: Schedule.Schedule) {
-  return <R, E, A>(fx: Fx.Fx<R, E, A>): Fx.Fx<R | Scheduler, never, Live<E, ScheduleState>> =>
-    pipe(
-      Fx.ask(Scheduler),
-      Fx.bindTo('scheduler'),
-      Fx.bind('env', () => Fx.getEnv<R>()),
-      Fx.bind('context', () => Fx.getFiberContext),
-      Fx.map(({ scheduler, env, context }) =>
-        scheduler.schedule(fx, env, schedule, context.fork()),
-      ),
-    )
-}
-
-export const delayed =
-  (delay: Delay) =>
-  <R, E, A>(fx: Fx.Fx<R, E, A>): Fx.Fx<R | Scheduler, E, A> =>
-    pipe(
-      sleep(delay),
-      Fx.flatMap(() => fx),
-    )
-
-export const sleep = (delay: Delay): Fx.RIO<Scheduler, Time> =>
-  pipe(
-    Fx.unit,
-    schedule(Schedule.delayed(delay)),
-    Fx.flatMap(join),
-    Fx.flatMap(() => Fx.getCurrentTime),
-  )

package/src/Fx/scoped.ts

@@ -1,66 +0,0 @@
-import { pipe } from 'hkt-ts/function'
-
-import * as Fx from './Fx.js'
-
-import { ConcurrentStrategy, FinalizationStrategy } from '@/Finalizer/Finalizer.js'
-import { Scope } from '@/Scope/Scope.js'
-
-/**
- * Run a Scoped Fx within an isolated Scope, cleaning up those resources as soon as complete.
- */
-export function scoped<R, E, A>(
-  scoped: Fx.Fx<R | Scope, E, A>,
-  strategy: FinalizationStrategy = ConcurrentStrategy,
-): Fx.Fx<Exclude<R, Scope>, E, A> {
-  return pipe(
-    Fx.getFiberContext,
-    Fx.flatMap(({ scope: fiberScope }) => {
-      const scope = fiberScope.fork(strategy)
-
-      return pipe(scoped, Fx.provideService(Scope, scope), Fx.ensuring(scope.close))
-    }),
-  )
-}
-
-/**
- * Track a Resource within a given Scoped environment
- */
-export function managed<R, E, A, R2>(
-  acquire: Fx.Fx<R, E, A>,
-  release: (value: A) => Fx.Fx<R2, never, any>,
-): Fx.Fx<R | R2 | Scope, E, A> {
-  return pipe(
-    Fx.ask(Scope),
-    Fx.bindTo('scope'),
-    Fx.bind('env', () => Fx.getEnv<R | R2>()),
-    Fx.bind('a', () => acquire),
-    Fx.tap(({ scope, env, a }) =>
-      Fx.fromLazy(() => scope.ensuring(() => pipe(a, release, Fx.provide(env)))),
-    ),
-    Fx.map(({ a }) => a),
-    Fx.uninterruptable,
-  )
-}
-
-/**
- * Perform an effect with an aquired resource with the release of that resource.
- */
-export function bracket<R, E, A, R2, E2, B, R3>(
-  acquire: Fx.Fx<R, E, A>,
-  withResource: (a: A) => Fx.Fx<R2, E2, B>,
-  release: (a: A) => Fx.Fx<R3, never, unknown>,
-): Fx.Fx<Scope | R | R2 | R3, E | E2, B> {
-  return pipe(managed(acquire, release), Fx.flatMap(withResource))
-}
-
-/**
- * Run a Scoped Fx within an isolated Scope, cleaning up those resources as soon as complete.
- */
-export function fiberScoped<R, E, A>(
-  scoped: Fx.Fx<R | Scope, E, A>,
-): Fx.Fx<Exclude<R, Scope>, E, A> {
-  return pipe(
-    Fx.getFiberContext,
-    Fx.flatMap(({ scope }) => pipe(scoped, Fx.provideService(Scope, scope))),
-  )
-}

package/src/ImmutableMap/ImmutableMap.ts

@@ -1,55 +0,0 @@
-import { Just, Maybe, Nothing } from 'hkt-ts/Maybe'
-
-/**
- * ImmutableMap is a small wrapper around ReadonlyMap that makes it a little
- * easier to deal wih immutable data.
- */
-export interface ImmutableMap<K, V> extends Iterable<readonly [K, V]> {
-  readonly has: (key: K) => boolean
-  readonly get: (key: K) => Maybe<V>
-  readonly set: (key: K, value: V) => ImmutableMap<K, V>
-  readonly remove: (key: K) => ImmutableMap<K, V>
-  readonly keys: () => Iterable<K>
-  readonly values: () => Iterable<V>
-}
-
-export function ImmutableMap<K, V>(cache: ReadonlyMap<K, V> = new Map()): ImmutableMap<K, V> {
-  return new ImmutableMapImpl<K, V>(cache)
-}
-
-class ImmutableMapImpl<K, V> implements ImmutableMap<K, V> {
-  constructor(readonly cache: ReadonlyMap<K, V> = new Map()) {}
-
-  readonly has = (key: K) => this.cache.has(key)
-
-  /**
-   * Retrieves the current value of the key, if it exists.
-   */
-  readonly get = (key: K): Maybe<V> => {
-    // Attempt to get the value from the cache
-    if (this.cache.has(key)) {
-      return Just(this.cache.get(key) as V)
-    }
-
-    return Nothing
-  }
-
-  /**
-   * Sets the value of the key, returning a new ImmutableMap with the new value.
-   */
-  readonly set = (key: K, value: V): ImmutableMap<K, V> =>
-    ImmutableMap(new Map([...this.cache, [key, value]]))
-
-  /**
-   * Removes the key from the map, returning a new ImmutableMap with the key removed.
-   */
-  readonly remove = (key: K): ImmutableMap<K, V> =>
-    ImmutableMap(new Map([...this.cache].filter(([k]) => k !== key)));
-
-  *[Symbol.iterator]() {
-    return yield* this.cache
-  }
-
-  readonly keys = () => this.cache.keys()
-  readonly values = () => this.cache.values()
-}

package/src/ImmutableMap/index.ts

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

package/src/Layer/Layer.ts

@@ -1,50 +0,0 @@
-import { pipe } from 'hkt-ts/function'
-
-import * as Fx from '@/Fx/Fx.js'
-import { Scope } from '@/Scope/Scope.js'
-import { Service } from '@/Service/Service.js'
-
-export interface Layer<R, E, A> {
-  readonly service: Service<A>
-  readonly build: (scope: Scope) => Fx.Fx<R, E, A>
-}
-
-export type AnyLayer =
-  | Layer<any, any, any>
-  | Layer<never, never, any>
-  | Layer<never, any, any>
-  | Layer<any, never, any>
-
-/* eslint-disable @typescript-eslint/no-unused-vars */
-export type ResourcesOf<T> = T extends Layer<infer _R, infer _E, infer _A> ? _R : never
-export type ErrorsOf<T> = T extends Layer<infer _R, infer _E, infer _A> ? _E : never
-export type OutputOf<T> = T extends Layer<infer _R, infer _E, infer _A> ? _A : never
-/* eslint-enable @typescript-eslint/no-unused-vars */
-
-export function Layer<R, E, A>(
-  service: Service<A>,
-  build: Layer<R, E, A>['build'],
-): Layer<R, E, A> {
-  return {
-    service,
-    build,
-  }
-}
-
-export function fromFx<S, R, E, A extends S>(
-  s: Service<S>,
-  fx: Fx.Fx<R | Scope, E, A>,
-): Layer<R, E, S> {
-  return Layer(s, (scope) => pipe(fx, Fx.provideService(Scope, scope)))
-}
-
-export function orElse<E, A, R2, E2, B extends A>(orElse: (e: E) => Layer<R2, E2, B>) {
-  return <R>(layer: Layer<R, E, A>): Layer<R | R2, E2, A> => {
-    return Layer(layer.service, (scope) =>
-      pipe(
-        layer.build(scope),
-        Fx.orElse((e) => orElse(e).build(scope)),
-      ),
-    )
-  }
-}

package/src/Layer/index.ts

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

package/src/Logger/Console.test.ts

@@ -1,14 +0,0 @@
-import { addCustomTrace } from '@/Fx/index.js'
-import { annotate, logTrace, span } from '@/Fx/logging.js'
-import { runMain } from '@/Fx/run.js'
-import { testSuite } from '@/_internal/suite.js'
-
-testSuite(import.meta.url, () => {
-  it('allows logging to the console', async () => {
-    const test = addCustomTrace('outer')(
-      span('foo')(annotate('bar', 'baz')(addCustomTrace('inner')(logTrace('test')))),
-    )
-
-    await runMain(test)
-  })
-})

package/src/Logger/Console.ts

@@ -1,100 +0,0 @@
-import { pipe } from 'hkt-ts'
-
-import { LogAnnotation } from './LogAnnotation.js'
-import { LogLevel } from './LogLevel.js'
-import { LogSpan } from './LogSpan.js'
-import { Logger } from './Logger.js'
-
-import { Clock, timeToUnixTime } from '@/Clock/index.js'
-import { format, fromTime } from '@/Duration/Duration.js'
-import * as Fx from '@/Fx/Fx.js'
-import { Time } from '@/Time/index.js'
-import * as Trace from '@/Trace/index.js'
-
-export const Console: Logger<string, void> = {
-  log: (input, level, id, logSpans, logAnnotations, trace) =>
-    Fx.lazy(() => {
-      if (level === LogLevel.None) {
-        return Fx.unit
-      }
-
-      return pipe(
-        Fx.getPlatform,
-        Fx.flatMap((platform) =>
-          Fx.lazy(() => {
-            const now = platform.timer.getCurrentTime()
-
-            const message = [
-              `timestamp=${getIsoString(now, platform.timer)}`,
-              `level=${formatLogLevel(level)}`,
-              `fiber=${id.sequenceNumber}`,
-              ...logSpans.map(formatLogSpan(now)),
-              ...logAnnotations.map(formatlogAnnotation),
-              `message=${input}`,
-            ].join('; ')
-
-            logWithLevel(
-              trace.tag !== 'EmptyTrace'
-                ? message + '\n    ' + Trace.debug(trace).replaceAll('\n', '\n    ')
-                : message,
-              level,
-            )
-
-            return Fx.unit
-          }),
-        ),
-      )
-    }),
-}
-
-function formatLogLevel(level: LogLevel) {
-  switch (level) {
-    case LogLevel.None:
-      return 'none'
-    case LogLevel.Fatal:
-      return 'fatal'
-    case LogLevel.Error:
-      return 'error'
-    case LogLevel.Warn:
-      return 'warn'
-    case LogLevel.Info:
-      return 'info'
-    case LogLevel.Log:
-      return 'log'
-    case LogLevel.Trace:
-      return 'trace'
-    case LogLevel.Debug:
-      return 'debug'
-  }
-}
-
-function logWithLevel(message: string, level: LogLevel) {
-  switch (level) {
-    case LogLevel.Fatal:
-    case LogLevel.Error:
-      return console.error(message)
-    case LogLevel.Warn:
-      return console.warn(message)
-    case LogLevel.Info:
-      return console.info(message)
-    case LogLevel.Log:
-    case LogLevel.Trace:
-      return console.log(message)
-    case LogLevel.Debug:
-      return console.debug(message)
-  }
-}
-
-function getIsoString(time: Time, clock: Clock) {
-  return new Date(timeToUnixTime(time)(clock)).toISOString()
-}
-
-function formatLogSpan(now: Time) {
-  return (span: LogSpan) => {
-    return `${span.label}=${format(fromTime(Time(now - span.start)))}`
-  }
-}
-
-function formatlogAnnotation(annotation: LogAnnotation) {
-  return `${annotation.label}=${annotation.value}`
-}

package/src/Logger/LogAnnotation.ts

@@ -1,8 +0,0 @@
-export interface LogAnnotation {
-  readonly label: string
-  readonly value: string
-}
-
-export function LogAnnotation(label: string, value: string): LogAnnotation {
-  return { label, value }
-}

package/src/Logger/LogLevel.ts

@@ -1,10 +0,0 @@
-export enum LogLevel {
-  None,
-  Fatal,
-  Error,
-  Warn,
-  Info,
-  Log,
-  Trace,
-  Debug,
-}

package/src/Logger/LogSpan.ts

@@ -1,10 +0,0 @@
-import { Time } from '@/Time/index.js'
-
-export interface LogSpan {
-  readonly label: string
-  readonly start: Time
-}
-
-export function LogSpan(label: string, start: Time): LogSpan {
-  return { label, start }
-}

package/src/Logger/Logger.ts

@@ -1,85 +0,0 @@
-import { HKT2, Params, pipe } from 'hkt-ts'
-import { Either } from 'hkt-ts/Either'
-import { Just, Maybe, Nothing } from 'hkt-ts/Maybe'
-import * as C from 'hkt-ts/Typeclass/Covariant'
-import * as D from 'hkt-ts/Typeclass/Divariant'
-import { Unary } from 'hkt-ts/Unary'
-
-import { LogAnnotation } from './LogAnnotation.js'
-import { LogLevel } from './LogLevel.js'
-import { LogSpan } from './LogSpan.js'
-
-import { FiberId } from '@/FiberId/FiberId.js'
-import * as Fx from '@/Fx/Fx.js'
-import { Trace } from '@/Trace/Trace.js'
-
-// TODO: Console as a Logger
-// TODO: Build into Fx runtime
-
-export interface Logger<A, B> {
-  readonly log: (
-    input: A,
-    level: LogLevel,
-    id: FiberId.Live,
-    logSpans: ReadonlyArray<LogSpan>,
-    logAnnotations: ReadonlyArray<LogAnnotation>,
-    trace: Trace,
-  ) => Fx.Of<B>
-}
-
-export function Logger<A, B>(log: Logger<A, B>['log']): Logger<A, B> {
-  return { log }
-}
-
-export function both<A, C>(second: Logger<A, C>) {
-  return <B>(first: Logger<A, B>): Logger<A, readonly [B, C]> =>
-    Logger((...args) => Fx.both(second.log(...args))(first.log(...args)))
-}
-
-export function either<A, C>(second: Logger<A, C>) {
-  return <B>(first: Logger<A, B>): Logger<A, Either<B, C>> =>
-    Logger((...args) => Fx.either(second.log(...args))(first.log(...args)))
-}
-
-export interface LoggerHKT extends HKT2 {
-  readonly type: Logger<this[Params.E], this[Params.A]>
-}
-
-export const Divariant: D.Divariant2<LoggerHKT> = {
-  dimap:
-    <A, B, C, D>(f: Unary<A, B>, g: Unary<C, D>) =>
-    (logger: Logger<B, C>) =>
-      Logger((i: A, level, id, logSpans, logAnnotations, trace) =>
-        Fx.map(g)(logger.log(f(i), level, id, logSpans, logAnnotations, trace)),
-      ),
-}
-
-export const dimap = Divariant.dimap
-
-export const contramap = D.contramap(Divariant)
-export const map = D.map(Divariant)
-
-export const Covariant: C.Covariant2<LoggerHKT> = {
-  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)
-
-export const filterLogLevel =
-  (predicate: (level: LogLevel) => boolean) =>
-  <A, B>(logger: Logger<A, B>): Logger<A, Maybe<B>> => ({
-    log: (...args): Fx.Of<Maybe<B>> =>
-      Fx.lazy(() => {
-        if (predicate(args[1])) {
-          return pipe(
-            logger.log(...args),
-            Fx.map((a) => Just(a) as Maybe<B>),
-          )
-        }
-
-        return Fx.now<Maybe<B>>(Nothing)
-      }),
-  })

package/src/Logger/index.ts

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

package/src/Node/Runtime.ts

@@ -1,26 +0,0 @@
-import { gracefulShutdown } from './gracefulShutdown.js'
-
-import { Atomic } from '@/Atomic/index.js'
-import { AnyLiveFiber } from '@/Fiber/Fiber.js'
-import { FiberContext } from '@/FiberContext/FiberContext.js'
-import { FiberId } from '@/FiberId/FiberId.js'
-import { MainPlatform } from '@/Fx/run.js'
-import { Runtime } from '@/Runtime/Runtime.js'
-import { GlobalScope } from '@/Scope/GlobalScope.js'
-
-export const NodeFibers = Atomic<ReadonlyMap<FiberId.Live, AnyLiveFiber>>(new Map())
-export const NodeSupervisor = gracefulShutdown(NodeFibers)
-export const NodeRuntime = Runtime(
-  FiberContext({
-    platform: MainPlatform,
-    id: FiberId.None,
-    scope: GlobalScope,
-    supervisor: NodeSupervisor,
-  }),
-)
-
-export const {
-  run: runMainNode,
-  runExit: runMainNodeExit,
-  runFiber: runMainNodeFiber,
-} = NodeRuntime

package/src/Node/gracefulShutdown.ts

@@ -1,54 +0,0 @@
-import process from 'node:process'
-
-import { Atomic } from '@/Atomic/Atomic.js'
-import * as Duration from '@/Duration/Duration.js'
-import { AnyLiveFiber } from '@/Fiber/Fiber.js'
-import { FiberId } from '@/FiberId/FiberId.js'
-import { runMain, zipAll } from '@/Fx/index.js'
-import { trackIn } from '@/Supervisor/trackIn.js'
-
-const DELAY = Duration.toMilliseconds(Duration.Duration(1, Duration.Unit.Hour)).value
-
-export function gracefulShutdown(
-  fibers: Atomic<ReadonlyMap<FiberId.Live, AnyLiveFiber>> = Atomic<
-    ReadonlyMap<FiberId.Live, AnyLiveFiber>
-  >(new Map()),
-) {
-  // Used to forcefully keep the process (e.g. Node.js) alive even when fibers are idle.
-  let id: ReturnType<typeof setTimeout> | undefined
-
-  const gracefulExit = () =>
-    void runMain(
-      zipAll(Array.from(fibers.get().values()).map((fiber) => fiber.interruptAs(FiberId.None))),
-    ).then(
-      () => process.exit(0),
-      () => process.exit(1),
-    )
-
-  return trackIn(fibers).extend({
-    onStart: (parent) => (fiber, fx) => {
-      parent(fiber, fx)
-
-      if (!id) {
-        // Force the process to stay alive, even when fibers are idle.
-        id = setTimeout(() => {
-          id = undefined
-        }, DELAY)
-
-        // Add a listener to the process to gracefully exit when the process is killed.
-        process.addListener('SIGTERM', gracefulExit)
-        process.addListener('SIGINT', gracefulExit)
-      }
-    },
-    onEnd: (parent) => (fiber, exit) => {
-      parent(fiber, exit)
-
-      if (fibers.get().size === 0 && id) {
-        clearTimeout(id)
-        id = undefined
-        process.removeListener('SIGTERM', gracefulExit)
-        process.removeListener('SIGINT', gracefulExit)
-      }
-    },
-  })
-}

package/src/Node/index.ts

@@ -1,2 +0,0 @@
-export * from './gracefulShutdown.js'
-export * from './Runtime.js'

package/src/Platform/Platform.ts

@@ -1,48 +0,0 @@
-import { NonNegativeInteger } from 'hkt-ts/number'
-
-import { AtomicCounter } from '@/Atomic/AtomicCounter.js'
-import { Renderer, defaultRenderer } from '@/Cause/Renderer.js'
-import { SetTimeoutTimer } from '@/Timer/SetTimeoutTimer.js'
-import * as Timer from '@/Timer/Timer.js'
-
-export interface Platform {
-  readonly sequenceNumber: AtomicCounter
-  readonly maxOpCount: NonNegativeInteger
-  readonly maxTraceCount: NonNegativeInteger
-  readonly timer: Timer.Timer
-  readonly renderer: Renderer<any>
-  readonly reportFailure: (message: string) => void
-  readonly fork: () => Platform
-}
-
-export function Platform(
-  sequenceNumber: AtomicCounter = AtomicCounter(),
-  maxOpCount: NonNegativeInteger = NonNegativeInteger(500),
-  maxTraceCount: NonNegativeInteger = NonNegativeInteger(50),
-  timer: Timer.Timer = SetTimeoutTimer(),
-  renderer: Renderer<any> = defaultRenderer,
-  reportFailure: (message: string) => void = console.error,
-): Platform {
-  const platform: Platform = {
-    sequenceNumber,
-    maxOpCount,
-    maxTraceCount,
-    timer,
-    renderer,
-    reportFailure,
-    fork: () => fork(platform),
-  }
-
-  return platform
-}
-
-export function fork(platform: Platform, overrides?: Partial<Omit<Platform, 'fork'>>): Platform {
-  return Platform(
-    overrides?.sequenceNumber ?? platform.sequenceNumber,
-    overrides?.maxOpCount ?? platform.maxOpCount,
-    overrides?.maxTraceCount ?? platform.maxTraceCount,
-    overrides?.timer ?? Timer.fork(platform.timer),
-    overrides?.renderer ?? platform.renderer,
-    overrides?.reportFailure ?? platform.reportFailure,
-  )
-}

package/src/Platform/TestPlatform.ts

@@ -1,14 +0,0 @@
-import { Platform } from './Platform.js'
-
-import { TestTimer } from '@/Timer/TestTimer.js'
-
-export interface TestPlatform extends Platform {
-  readonly timer: TestTimer
-}
-
-export function TestPlatform(timer: TestTimer = TestTimer()): TestPlatform {
-  return {
-    ...Platform(undefined, undefined, undefined, timer),
-    timer,
-  }
-}

package/src/Platform/index.ts

@@ -1,2 +0,0 @@
-export * from './Platform.js'
-export * from './TestPlatform.js'