@typed/fx 0.0.8 → 0.0.9

package/src/Runtime/Runtime.ts

@@ -1,46 +0,0 @@
-import { match } from 'hkt-ts/Either'
-
-import { CauseError } from '@/Cause/CauseError.js'
-import { Exit } from '@/Exit/Exit.js'
-import { Live } from '@/Fiber/Fiber.js'
-import { FiberContext } from '@/FiberContext/FiberContext.js'
-import { FiberRuntime } from '@/FiberRuntime/FiberRuntime.js'
-import { Fx } from '@/Fx/Fx.js'
-
-export interface Runtime<R> {
-  readonly runFiber: <E = never, A = any>(fx: Fx<R, E, A>) => Live<E, A>
-  readonly runExit: <E = never, A = any>(fx: Fx<R, E, A>) => Promise<Exit<E, A>>
-  readonly run: <E = never, A = any>(fx: Fx<R, E, A>) => Promise<A>
-}
-
-export function Runtime<R = never>(context: FiberContext): Runtime<R> {
-  return {
-    runFiber: <E, A>(fx: Fx<R, E, A>) => {
-      const r = new FiberRuntime(fx, context.fork())
-
-      r.startAsync()
-
-      return r
-    },
-    runExit: <E, A>(fx: Fx<R, E, A>) =>
-      new Promise<Exit<E, A>>((resolve) => {
-        const r = new FiberRuntime(fx, context.fork())
-
-        r.addObserver(resolve)
-        r.startSync()
-
-        return r
-      }),
-    run: <E, A>(fx: Fx<R, E, A>) =>
-      new Promise<A>((resolve, reject) => {
-        const r = new FiberRuntime(fx, context.fork())
-
-        r.addObserver(
-          match((cause) => reject(new CauseError(cause, context.platform.renderer)), resolve),
-        )
-        r.startSync()
-
-        return r
-      }),
-  }
-}

package/src/Runtime/index.ts

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

package/src/Schedule/Decision.ts

@@ -1,44 +0,0 @@
-import { Associative } from 'hkt-ts/Typeclass/Associative'
-
-import { Delay } from '@/Time/index.js'
-
-export type Decision = Continue | Done
-
-export class Continue {
-  readonly tag = 'Continue'
-
-  constructor(readonly delay: Delay) {}
-}
-
-export const Done = new (class Done {
-  readonly tag = 'Done'
-})()
-export type Done = typeof Done
-
-export const DecisionUnionAssociative: Associative<Decision> = {
-  concat: (f, s) => {
-    if (f.tag === 'Done' && s.tag === 'Done') {
-      return Done
-    }
-
-    if (f.tag === 'Done') {
-      return s
-    }
-
-    if (s.tag === 'Done') {
-      return f
-    }
-
-    return new Continue(Delay(Math.min(f.delay, s.delay)))
-  },
-}
-
-export const DecisionIntersectionAssociative: Associative<Decision> = {
-  concat: (f, s) => {
-    if (f.tag === 'Done' || s.tag === 'Done') {
-      return Done
-    }
-
-    return new Continue(Delay(Math.max(f.delay, s.delay)))
-  },
-}

package/src/Schedule/Schedule.ts

@@ -1,148 +0,0 @@
-import { Just, match } from 'hkt-ts/Maybe'
-import { makeAssociative } from 'hkt-ts/Tuple'
-import * as Associative from 'hkt-ts/Typeclass/Associative'
-import { Identity } from 'hkt-ts/Typeclass/Identity'
-import { pipe } from 'hkt-ts/function'
-import { NonNegativeInteger } from 'hkt-ts/number'
-
-import {
-  Continue,
-  Decision,
-  DecisionIntersectionAssociative,
-  DecisionUnionAssociative,
-  Done,
-} from './Decision.js'
-import {
-  ScheduleState,
-  ScheduleStateIntersectionAssociative,
-  ScheduleStateUnionAssociative,
-} from './ScheduleState.js'
-
-import { Delay, Time } from '@/Time/index.js'
-
-const asap = Delay(0)
-const max = Delay(Number.MAX_SAFE_INTEGER)
-
-const stateDecisionUnionAssociative = makeAssociative<ScheduleState, Decision>(
-  ScheduleStateUnionAssociative,
-  DecisionUnionAssociative,
-)
-
-const stateDecisionIntersectionAssociative = makeAssociative(
-  ScheduleStateIntersectionAssociative,
-  DecisionIntersectionAssociative,
-)
-
-export interface Schedule {
-  readonly step: (now: Time, state: ScheduleState) => readonly [ScheduleState, Decision]
-  readonly and: (schedule: Schedule) => Schedule
-  readonly or: (schedule: Schedule) => Schedule
-}
-
-export function Schedule(step: Schedule['step']): Schedule {
-  const schedule: Schedule = {
-    step,
-    and: (other) => and(other)(schedule),
-    or: (other) => or(other)(schedule),
-  }
-
-  return schedule
-}
-
-export const never: Schedule = Schedule((now, state) => [state.step(now), Done])
-
-export const forever: Schedule = Schedule((now, state) => [
-  state.step(now, Just(asap)),
-  new Continue(asap),
-])
-
-export const recurring = (amount: NonNegativeInteger): Schedule =>
-  Schedule((now, state) => [state.step(now), state.iteration < amount ? new Continue(asap) : Done])
-
-export const periodic = (delay: Delay): Schedule =>
-  Schedule((now, state) => [
-    state.step(now, Just(delay)),
-    new Continue(
-      pipe(
-        state.time,
-        match(
-          () => delay,
-          (prev) => accountForTimeDrift(prev, now, delay),
-        ),
-      ),
-    ),
-  ])
-
-const accountForTimeDrift = (previous: Time, now: Time, delay: Delay): Delay => {
-  const expectedTime = previous + delay
-  const drift = expectedTime > now ? expectedTime - now : 0
-
-  return Delay(drift)
-}
-
-export const delayed = (delay: Delay): Schedule => periodic(delay).and(once)
-
-export const spaced = (delay: Delay): Schedule =>
-  Schedule((now, state) => {
-    const spacedDelay = pipe(
-      state.previousDelay,
-      match(
-        () => delay,
-        (n) => Delay(n + delay),
-      ),
-    )
-
-    return [state.step(now, Just(spacedDelay)), new Continue(spacedDelay)]
-  })
-
-export const exponential = (delay: Delay): Schedule =>
-  Schedule((now, state) => {
-    const exponentialDelay = Delay(delay ** (state.iteration + 1))
-
-    return [state.step(now, Just(exponentialDelay)), new Continue(exponentialDelay)]
-  })
-
-export const retries = (retries: NonNegativeInteger): Schedule =>
-  recurring(NonNegativeInteger(retries + 1))
-
-export const once = recurring(NonNegativeInteger(1))
-
-export const or =
-  (second: Schedule) =>
-  (first: Schedule): Schedule =>
-    UnionAssociative.concat(first, second)
-
-export const union = (...schedules: ReadonlyArray<Schedule>): Schedule =>
-  schedules.length === 0 ? never : schedules.reduce((x, y) => or(y)(x))
-
-export const and =
-  (second: Schedule) =>
-  (first: Schedule): Schedule =>
-    IntersectionAssociative.concat(first, second)
-
-export const intersect = (...schedules: ReadonlyArray<Schedule>): Schedule =>
-  schedules.length === 0 ? once : schedules.reduce((x, y) => and(y)(x))
-
-export const UnionAssociative: Associative.Associative<Schedule> = {
-  concat: (f, s) =>
-    Schedule((now, state) =>
-      stateDecisionUnionAssociative.concat(f.step(now, state), s.step(now, state)),
-    ),
-}
-
-export const UnionIdentity: Identity<Schedule> = {
-  ...UnionAssociative,
-  id: Schedule((now, state) => [state.step(now, Just(max)), new Continue(max)]),
-}
-
-export const IntersectionAssociative: Associative.Associative<Schedule> = {
-  concat: (f, s) =>
-    Schedule((now, state) =>
-      stateDecisionIntersectionAssociative.concat(f.step(now, state), s.step(now, state)),
-    ),
-}
-
-export const IntersectionIdentity: Identity<Schedule> = {
-  ...IntersectionAssociative,
-  id: forever,
-}

package/src/Schedule/ScheduleState.ts

@@ -1,83 +0,0 @@
-import { Just, Maybe, Nothing, makeAssociative, match } from 'hkt-ts/Maybe'
-import { Associative } from 'hkt-ts/Typeclass/Associative'
-import { pipe } from 'hkt-ts/function'
-import { NonNegativeInteger } from 'hkt-ts/number'
-
-import { Delay, Time } from '@/Time/index.js'
-
-const minDelayAssociative = Delay.makeAssociative({
-  concat: Math.min,
-})
-const maybeMinDelayAssociative = makeAssociative(minDelayAssociative)
-
-const maxDelayAssociative = Delay.makeAssociative({
-  concat: Math.max,
-})
-const maybeMaxDelayAssociative = makeAssociative(maxDelayAssociative)
-
-const maxTimeAssociative = Time.makeAssociative({
-  concat: Math.max,
-})
-const maybeMaxTimeAssociative = makeAssociative(maxTimeAssociative)
-
-/**
- * TODO: ScheduleState should track Exit values to allow exiting early w/ custom logic
- */
-export class ScheduleState {
-  constructor(
-    /**
-     * The Time at which the Schedule was last run
-     */
-    readonly time: Maybe<Time> = Nothing,
-    /**
-     * The number of iterations this Schedule has been through
-     */
-    readonly iteration: NonNegativeInteger = NonNegativeInteger(0),
-    /**
-     * The previousDelay of this Schedule, if any
-     */
-    readonly previousDelay: Maybe<Delay> = Nothing,
-    /**
-     * The cumulative delay of this Schedule, will remain 0 if no delay is applied.
-     */
-    readonly cumulativeDelay: Delay = Delay(0),
-  ) {}
-
-  readonly step = (now: Time, delay: Maybe<Delay> = Nothing): ScheduleState =>
-    new ScheduleState(
-      Just(now),
-      NonNegativeInteger(this.iteration + 1),
-      delay,
-      pipe(
-        delay,
-        match(
-          () => this.cumulativeDelay,
-          (d) => Delay(this.cumulativeDelay + d),
-        ),
-      ),
-    )
-
-  readonly or = (state: ScheduleState): ScheduleState =>
-    new ScheduleState(
-      maybeMaxTimeAssociative.concat(this.time, state.time),
-      NonNegativeInteger(Math.max(this.iteration, state.iteration)),
-      maybeMinDelayAssociative.concat(this.previousDelay, state.previousDelay),
-      minDelayAssociative.concat(this.cumulativeDelay, state.cumulativeDelay),
-    )
-
-  readonly and = (state: ScheduleState): ScheduleState =>
-    new ScheduleState(
-      maybeMaxTimeAssociative.concat(this.time, state.time),
-      NonNegativeInteger(Math.max(this.iteration, state.iteration)),
-      maybeMaxDelayAssociative.concat(this.previousDelay, state.previousDelay),
-      maxDelayAssociative.concat(this.cumulativeDelay, state.cumulativeDelay),
-    )
-}
-
-export const ScheduleStateUnionAssociative: Associative<ScheduleState> = {
-  concat: (f, s) => f.or(s),
-}
-
-export const ScheduleStateIntersectionAssociative: Associative<ScheduleState> = {
-  concat: (f, s) => f.and(s),
-}

package/src/Schedule/index.ts

@@ -1,3 +0,0 @@
-export * from './Decision.js'
-export * from './Schedule.js'
-export * from './ScheduleState.js'

package/src/Scheduler/RootScheduler.ts

@@ -1,90 +0,0 @@
-import { Scheduler } from './Scheduler.js'
-import { callbackScheduler } from './callbackScheduler.js'
-import { runSchedule } from './runSchedule.js'
-
-import { delayToUnixTime } from '@/Clock/index.js'
-import { Disposable } from '@/Disposable/Disposable.js'
-import { Env } from '@/Env/Env.js'
-import { Live } from '@/Fiber/index.js'
-import { FiberContext } from '@/FiberContext/FiberContext.js'
-import * as FiberId from '@/FiberId/index.js'
-import { CurrentEnv } from '@/FiberRef/builtins.js'
-import { setFiberRef } from '@/FiberRefs/FiberRefs.js'
-import { FiberRuntime } from '@/FiberRuntime/FiberRuntime.js'
-import { Pending } from '@/Future/Future.js'
-import { complete } from '@/Future/complete.js'
-import { wait } from '@/Future/wait.js'
-import { Fx } from '@/Fx/Fx.js'
-import { Schedule } from '@/Schedule/Schedule.js'
-import { ScheduleState } from '@/Schedule/ScheduleState.js'
-import { Delay } from '@/Time/index.js'
-import { SetTimeoutTimer } from '@/Timer/SetTimeoutTimer.js'
-import { Timer } from '@/Timer/Timer.js'
-
-export function RootScheduler(timer: Timer = SetTimeoutTimer()): Scheduler {
-  return new RootSchedulerImpl(timer)
-}
-
-class RootSchedulerImpl implements Scheduler {
-  readonly dispose: Disposable['dispose']
-
-  protected readonly runAt: <R, E, A>(fx: Fx<R, E, A>, delay: Delay) => Fx<R, E, A>
-
-  constructor(readonly timer: Timer) {
-    const [disposable, addTask] = callbackScheduler(timer)
-
-    this.dispose = disposable.dispose
-
-    this.runAt = <R, E, A>(fx: Fx<R, E, A>, delay: Delay): Fx<R, E, A> => {
-      const task = new ScheduledTask(fx)
-
-      addTask(delayToUnixTime(delay)(this.timer), task.start)
-
-      return task.wait
-    }
-  }
-
-  readonly asap: Scheduler['asap'] = <R, E, A>(
-    fx: Fx<R, E, A>,
-    env: Env<R>,
-    context: FiberContext<FiberId.Live>,
-  ): Live<E, A> => {
-    setFiberRef(CurrentEnv, env)(context.fiberRefs)
-
-    const runtime = new FiberRuntime(this.runAt(fx, Delay(0)), context)
-
-    // Safe to call sync since it will be run by the Timeline.
-    runtime.startSync()
-
-    return runtime
-  }
-
-  readonly schedule: Scheduler['schedule'] = <R, E, A, B>(
-    fx: Fx<R, E, A>,
-    env: Env<R>,
-    schedule: Schedule,
-    context: FiberContext<FiberId.Live>,
-    onEnd?: (state: ScheduleState) => Fx<R, E, B>,
-  ) => {
-    setFiberRef(CurrentEnv, env)(context.fiberRefs)
-
-    const runtime = new FiberRuntime(
-      runSchedule(fx, schedule, this.timer, this.runAt, onEnd),
-      context,
-    )
-
-    // Safe to call sync since it will be run by the Timeline.
-    runtime.startSync()
-
-    return runtime
-  }
-}
-
-class ScheduledTask<R, E, A> {
-  readonly future = Pending<R, E, A>()
-
-  constructor(readonly fx: Fx<R, E, A>) {}
-
-  readonly wait = wait(this.future)
-  readonly start = () => complete(this.future)(this.fx)
-}

package/src/Scheduler/Scheduler.ts

@@ -1,27 +0,0 @@
-import { Disposable } from '@/Disposable/Disposable.js'
-import { Env } from '@/Env/Env.js'
-import { Live } from '@/Fiber/Fiber.js'
-import { FiberContext } from '@/FiberContext/FiberContext.js'
-import { FiberId } from '@/FiberId/FiberId.js'
-import { Fx } from '@/Fx/Fx.js'
-import { Schedule } from '@/Schedule/Schedule.js'
-import { ScheduleState } from '@/Schedule/ScheduleState.js'
-import { Service } from '@/Service/Service.js'
-
-export interface Scheduler extends Disposable {
-  readonly asap: <R, E, A>(
-    fx: Fx<R, E, A>,
-    env: Env<R>,
-    context: FiberContext<FiberId.Live>,
-  ) => Live<E, A>
-
-  readonly schedule: <R, E, A, B>(
-    fx: Fx<R, E, A>,
-    env: Env<R>,
-    schedule: Schedule,
-    context: FiberContext<FiberId.Live>,
-    onEnd?: (state: ScheduleState) => Fx<R, E, B>,
-  ) => Live<E, ScheduleState>
-}
-
-export const Scheduler = Service<Scheduler>('Scheduler')

package/src/Scheduler/callbackScheduler.ts

@@ -1,44 +0,0 @@
-import * as Clock from '@/Clock/Clock.js'
-import { Disposable } from '@/Disposable/Disposable.js'
-import { UnixTime } from '@/Time/index.js'
-import * as Timeline from '@/Timeline/index.js'
-import { Timer } from '@/Timer/Timer.js'
-
-export function callbackScheduler(
-  timer: Timer,
-): readonly [Disposable, (time: UnixTime, f: () => void) => Disposable] {
-  const timeline = Timeline.Timeline<() => void>(scheduleNextRun)
-  let disposable: Disposable = Disposable.None
-  let nextArrival: UnixTime | null = null
-
-  function scheduleNextRun() {
-    // If the timeline is empty, lets cleanup our resources
-    if (timeline.isEmpty()) {
-      disposable.dispose()
-      nextArrival = null
-
-      return
-    }
-
-    // Get the time of the next arrival currently in the Timeline
-    const next = timeline.nextArrival()
-    const needToScheduleEarlierTime = !nextArrival || nextArrival > next
-
-    // If we need to create or schedule an earlier time, cleanup the old timer
-    // and schedule the new one.
-    if (needToScheduleEarlierTime) {
-      disposable.dispose()
-      disposable = timer.setTimer(runReadyTasks, Clock.unixTimeToDelay(next)(timer))
-      nextArrival = next
-    }
-  }
-
-  function runReadyTasks() {
-    nextArrival = null
-    timeline.getReadyTasks(Clock.timeToUnixTime(timer.getCurrentTime())(timer)).forEach((f) => f())
-
-    scheduleNextRun()
-  }
-
-  return [Disposable(() => disposable.dispose()), timeline.add] as const
-}

package/src/Scheduler/index.ts

@@ -1,2 +0,0 @@
-export * from './RootScheduler.js'
-export * from './Scheduler.js'

package/src/Scheduler/runSchedule.ts

@@ -1,35 +0,0 @@
-import * as Clock from '@/Clock/Clock.js'
-import { Fx, unit } from '@/Fx/Fx.js'
-import { Schedule } from '@/Schedule/Schedule.js'
-import { ScheduleState } from '@/Schedule/ScheduleState.js'
-import { Delay } from '@/Time/index.js'
-
-/**
- * Runs an Fx on a given Schedule
- */
-export function runSchedule<R, E, A, B>(
-  fx: Fx<R, E, A>,
-  schedule: Schedule,
-  clock: Clock.Clock,
-  runAt: (fx: Fx<R, E, A>, delay: Delay) => Fx<R, E, A>,
-  onEnd?: (state: ScheduleState) => Fx<R, E, B>,
-): Fx<R, E, ScheduleState> {
-  return Fx(function* () {
-    let [state, decision] = schedule.step(clock.getCurrentTime(), new ScheduleState())
-
-    while (decision.tag === 'Continue') {
-      // Schedule a Task to run the next iteration of this Fx
-      yield* runAt(fx, decision.delay)
-
-      // Calculate if we should continue or not
-      const [nextState, nextDecision] = schedule.step(clock.getCurrentTime(), state)
-      state = nextState
-      decision = nextDecision
-    }
-
-    yield* onEnd?.(state) ?? unit
-
-    // Return the final state
-    return state
-  })
-}

package/src/Scope/Closeable.test.ts

@@ -1,102 +0,0 @@
-import { deepStrictEqual } from 'assert'
-
-import { Right } from 'hkt-ts/Either'
-import { constant } from 'hkt-ts/function'
-
-import { Closeable, wait } from './Closeable.js'
-import { Closed, Closing, Open, ScopeState } from './ScopeState.js'
-
-import { CauseError } from '@/Cause/CauseError.js'
-import { FiberContext } from '@/FiberContext/FiberContext.js'
-import { FiberId } from '@/FiberId/FiberId.js'
-import { FiberRuntime } from '@/FiberRuntime/FiberRuntime.js'
-import { Finalizer } from '@/Finalizer/Finalizer.js'
-import { Fx, IO, fork, fromLazy } from '@/Fx/Fx.js'
-import { join } from '@/Fx/join.js'
-
-describe(new URL(import.meta.url).pathname, () => {
-  describe(wait.name, () => {
-    describe('given a Closing scope', () => {
-      it('returns the Exit value', async () => {
-        const exit = Right(42)
-        const scope = stateCloseable(Closing(exit))
-        const actual = await runTest(wait(scope))
-
-        deepStrictEqual(actual, exit)
-      })
-    })
-
-    describe('given a Closed scope', () => {
-      it('returns the Exit value', async () => {
-        const exit = Right(42)
-        const scope = stateCloseable(Closed(exit))
-        const actual = await runTest(wait(scope))
-
-        deepStrictEqual(actual, exit)
-      })
-    })
-
-    describe('given an Open scope', () => {
-      it('awaits the closed value', async () => {
-        const exit = Right(42)
-        const scope = stateCloseable(Open)
-        const test = Fx(function* () {
-          const fiber = yield* fork(wait(scope))
-
-          yield* scope.close(exit)
-
-          deepStrictEqual(yield* join(fiber), exit)
-        })
-
-        await runTest(test)
-      })
-    })
-  })
-})
-
-const stateCloseable = (_state: ScopeState): Closeable => {
-  const finalizers = new Set<Finalizer>()
-
-  const scope: Closeable = {
-    get state() {
-      return _state
-    },
-    ensuring(f) {
-      finalizers.add(f)
-
-      return constant(fromLazy(() => finalizers.delete(f)))
-    },
-    fork: () => scope,
-    close: (exit) =>
-      Fx(function* () {
-        if (_state.tag !== 'Open') {
-          return false
-        }
-
-        _state = Closing(exit)
-
-        for (const f of Array.from(finalizers).reverse()) {
-          yield* f(exit)
-        }
-
-        _state = Closed(exit)
-
-        return true
-      }),
-  }
-
-  return scope
-}
-
-function runTest<E, A>(
-  io: IO<E, A>,
-  context: FiberContext<FiberId.Live> = FiberContext(),
-): Promise<A> {
-  return new Promise((resolve, reject) => {
-    const runtime = new FiberRuntime(io, context)
-    runtime.addObserver((exit) =>
-      exit.tag === 'Right' ? resolve(exit.right) : reject(new CauseError(exit.left)),
-    )
-    runtime.startSync()
-  })
-}

package/src/Scope/Closeable.ts

@@ -1,35 +0,0 @@
-import { Left, Right } from 'hkt-ts/Either'
-import { pipe } from 'hkt-ts/function'
-
-import { Scope } from './Scope.js'
-
-import { AnyExit, Exit } from '@/Exit/Exit.js'
-import { Of, async, flatMap, fromLazy, lazy, success } from '@/Fx/Fx.js'
-import { Service } from '@/Service/index.js'
-
-export interface Closeable extends Scope {
-  readonly close: (exit: Exit<any, any>) => Of<boolean> // Whether or not the scope has closed
-}
-
-export const Closeable = Service<Closeable>('Closeable')
-
-export function wait(scope: Closeable) {
-  return async<never, never, Exit<any, any>>((cb) => {
-    if (scope.state.tag === 'Open') {
-      const finalizer = scope.ensuring((exit) => fromLazy(() => cb(success(exit))))
-
-      return Left(lazy(() => finalizer(Right(undefined))))
-    }
-
-    return Right(success(scope.state.exit))
-  })
-}
-
-export function closeOrWait(scope: Closeable) {
-  return (exit: AnyExit) => {
-    return pipe(
-      scope.close(exit),
-      flatMap((closed) => (closed ? success(exit) : wait(scope))),
-    )
-  }
-}

package/src/Scope/GlobalScope.ts

@@ -1,15 +0,0 @@
-import { constant } from 'hkt-ts'
-
-import { Closeable } from './Closeable.js'
-import { LocalScope } from './LocalScope.js'
-import { Open } from './ScopeState.js'
-
-import { FinalizationStrategy, SequentialStrategy } from '@/Finalizer/Finalizer.js'
-import { success, unit } from '@/Fx/Fx.js'
-
-export const GlobalScope: Closeable = {
-  state: Open,
-  ensuring: constant(constant(unit)),
-  fork: (s: FinalizationStrategy = SequentialStrategy) => new LocalScope(s),
-  close: constant(success(false)) as Closeable['close'],
-}