@typed/fx 0.0.2 → 0.0.3

package/src/Fx/Fx.ts

@@ -45,6 +45,7 @@ import {
 
 import { getCauseError } from '@/Cause/CauseError.js'
 import * as Cause from '@/Cause/index.js'
+import { timeToDate, timeToUnixTime } from '@/Clock/index.js'
 import { settable } from '@/Disposable/Disposable.js'
 import type { Env } from '@/Env/Env.js'
 import { Exit } from '@/Exit/index.js'
@@ -282,6 +283,61 @@ export const interruptable = <R, E, A>(fx: Fx<R, E, A>) => SetInterruptStatus.ma
 
 export const getFiberContext = GetFiberContext.make()
 
+export const getFiberId = pipe(
+  getFiberContext,
+  map((c) => c.id),
+)
+
+export const getFiberRefs = pipe(
+  getFiberContext,
+  map((c) => c.fiberRefs),
+)
+
+export const getPlatform = pipe(
+  getFiberContext,
+  map((c) => c.platform),
+)
+
+export const getTimer = pipe(
+  getPlatform,
+  map((p) => p.timer),
+)
+
+export const getCurrentTime = pipe(
+  getTimer,
+  flatMap((t) => fromLazy(() => t.getCurrentTime())),
+)
+
+export const getCurrentUnixTime = pipe(
+  getTimer,
+  flatMap((t) => fromLazy(() => timeToUnixTime(t.getCurrentTime())(t))),
+)
+
+export const getCurrentDate = pipe(
+  getTimer,
+  flatMap((t) => fromLazy(() => timeToDate(t.getCurrentTime())(t))),
+)
+
+export const getLogger = pipe(
+  getFiberContext,
+  map((c) => c.logger),
+)
+
+export const getParentContext = pipe(
+  getFiberContext,
+  map((c) => c.parent),
+)
+
+export const getFiberScope = pipe(
+  getFiberContext,
+  map((c) => c.scope),
+)
+
+export const getSupervisor = pipe(
+  getFiberContext,
+  map((c) => c.supervisor),
+)
+
 export const both =
   <R2, E2, B>(second: Fx<R2, E2, B>, __trace?: string) =>
   <R, E, A>(first: Fx<R2, E, A>): Fx<R | R2, E | E2, readonly [A, B]> =>

package/src/Fx/index.ts

@@ -1,4 +1,6 @@
 export * from './Fx.js'
 export * from './join.js'
 export * from './logging.js'
+export * from './run.js'
+export * from './scheduler.js'
 export * from './scoped.js'

package/src/Fx/run.ts

@@ -0,0 +1,27 @@
+import { pipe } from 'hkt-ts'
+
+import { Of, getFiberContext, map } from './Fx.js'
+
+import { FiberContext } from '@/FiberContext/FiberContext.js'
+import { FiberId } from '@/FiberId/FiberId.js'
+import { Platform } from '@/Platform/Platform.js'
+import { Runtime } from '@/Runtime/index.js'
+import { GlobalScope } from '@/Scope/GlobalScope.js'
+
+export const MainPlatform = Platform()
+export const MainRuntime = Runtime(
+  FiberContext({
+    platform: MainPlatform,
+    id: FiberId.None as any,
+    scope: GlobalScope,
+  }),
+)
+
+export const { run: runMain, runExit: runMainExit, runFiber: runMainFiber } = MainRuntime
+
+export function getRuntime<R>(overrides?: Partial<FiberContext>): Of<Runtime<R>> {
+  return pipe(
+    getFiberContext,
+    map((c) => Runtime({ ...c, ...overrides })),
+  )
+}

package/src/Fx/scheduler.ts

@@ -0,0 +1,76 @@
+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, schedule, env, 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/Runtime/Runtime.ts

@@ -0,0 +1,44 @@
+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, A>(fx: Fx<R, E, A>) => Live<E, A>
+  readonly runExit: <E, A>(fx: Fx<R, E, A>) => Promise<Exit<E, A>>
+  readonly run: <E, A>(fx: Fx<R, E, A>) => Promise<A>
+}
+
+export function Runtime<R>(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.renderer)), resolve))
+        r.startSync()
+
+        return r
+      }),
+  }
+}

package/src/Runtime/index.ts

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