@typed/fx 0.0.1

package/src/Schedule/ScheduleState.ts

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

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

package/src/Scheduler/RootScheduler.ts

@@ -0,0 +1,84 @@
+import { Scheduler } from './Scheduler.js'
+import { callbackScheduler } from './callbackScheduler.js'
+import { scheduled } from './scheduled.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 { CurrentEnv } from '@/FiberRef/FiberRef.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 { 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,
+  ): 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>(
+    fx: Fx<R, E, A>,
+    schedule: Schedule,
+    env: Env<R>,
+    context: FiberContext,
+  ) => {
+    setFiberRef(CurrentEnv, env)(context.fiberRefs)
+
+    const runtime = new FiberRuntime(scheduled(fx, schedule, this.timer, this.runAt), 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

@@ -0,0 +1,21 @@
+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 { 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) => Live<E, A>
+
+  readonly schedule: <R, E, A>(
+    fx: Fx<R, E, A>,
+    schedule: Schedule,
+    env: Env<R>,
+    context: FiberContext,
+  ) => Live<E, ScheduleState>
+}
+
+export const Scheduler = Service<Scheduler>('Scheduler')

package/src/Scheduler/callbackScheduler.ts

@@ -0,0 +1,43 @@
+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() {
+    timeline.getReadyTasks(Clock.timeToUnixTime(timer.getCurrentTime())(timer)).forEach((f) => f())
+
+    scheduleNextRun()
+  }
+
+  return [Disposable(() => disposable.dispose()), timeline.add] as const
+}

package/src/Scheduler/scheduled.ts

@@ -0,0 +1,32 @@
+import * as Clock from '@/Clock/Clock.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'
+
+/**
+ * Runs an Fx on a given Schedule
+ */
+export function scheduled<R, E, A>(
+  fx: Fx<R, E, A>,
+  schedule: Schedule,
+  clock: Clock.Clock,
+  runAt: (fx: Fx<R, E, A>, delay: Delay) => Fx<R, E, A>,
+): 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
+    }
+
+    // Return the final state
+    return state
+  })
+}

package/src/Scope/Closeable.test.ts

@@ -0,0 +1,98 @@
+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 { 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 = 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

@@ -0,0 +1,35 @@
+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

@@ -0,0 +1,15 @@
+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'],
+}

package/src/Scope/LocalScope.ts

@@ -0,0 +1,93 @@
+import * as Maybe from 'hkt-ts/Maybe'
+import { First } from 'hkt-ts/Typeclass/Associative'
+import { pipe } from 'hkt-ts/function'
+import { NonNegativeInteger } from 'hkt-ts/number'
+
+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 { Fx, Of, lazy, success, 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(NonNegativeInteger(1))
+  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)
+
+    // Mutually track resources
+    extended.ensuring(() => this.release)
+    extended.ensuring(this.ensuring(() => extended.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 (decrement(this._refCount) > 0 || Maybe.isNothing(this._exit) || this.isClosed) {
+      return success(false)
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const that = this
+    const exit = this._exit.value
+
+    return Fx(function* () {
+      that._state = Closing(exit)
+
+      yield* that._releaseMap.releaseAll(exit)
+
+      that._state = Closed(exit)
+
+      return true
+    })
+  })
+
+  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

@@ -0,0 +1,95 @@
+/* eslint-disable @typescript-eslint/no-this-alias */
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+
+import { Just, Maybe, Nothing } from 'hkt-ts/Maybe'
+import { pipe } from 'hkt-ts/function'
+
+import { Exit } from '@/Exit/Exit.js'
+import {
+  FinalizationStrategy,
+  Finalizer,
+  FinalizerKey,
+  finalizationStrategyToConcurrency,
+} from '@/Finalizer/Finalizer.js'
+import { Fx, Of, lazy, mapTo, unit, withConcurrency, zipAll } from '@/Fx/Fx.js'
+
+let nextId = 0
+
+/**
+ * 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<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<any, any>): Of<void> => {
+    const toBeReleased = () =>
+      Array.from(this.finalizers.keys())
+        .reverse()
+        .map((key) => this.release(key, exit))
+
+    const isEmpty = () => this.isEmpty()
+
+    if (this.strategy.strategy === 'Sequential') {
+      return Fx(function* () {
+        while (!isEmpty()) {
+          for (const fx of toBeReleased()) {
+            yield* fx
+          }
+        }
+      })
+    }
+
+    const releaseAll_ = () =>
+      pipe(
+        zipAll(toBeReleased()),
+        withConcurrency(finalizationStrategyToConcurrency(this.strategy)),
+        mapTo(undefined),
+      )
+
+    return Fx(function* () {
+      yield* releaseAll_()
+
+      while (!isEmpty()) {
+        yield* releaseAll_()
+      }
+    })
+  }
+}

package/src/Scope/Scope.ts

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,45 @@
+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

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