@typed/fx 0.0.1

package/src/FiberRuntime/Frame.ts

@@ -0,0 +1,28 @@
+import * as Exit from '@/Exit/Exit.js'
+import * as Fx from '@/Fx/Fx.js'
+
+export type Frame = ExitFrame | ValueFrame
+
+export interface ExitFrame {
+  readonly tag: 'Exit'
+  readonly step: (exit: Exit.AnyExit) => Fx.AnyFx
+}
+
+export function ExitFrame(step: (a: Exit.AnyExit) => Fx.AnyFx): ExitFrame {
+  return {
+    tag: 'Exit',
+    step,
+  }
+}
+
+export interface ValueFrame {
+  readonly tag: 'Value'
+  readonly step: (a: any) => Fx.AnyFx
+}
+
+export function ValueFrame(step: (a: any) => Fx.AnyFx): ValueFrame {
+  return {
+    tag: 'Value',
+    step,
+  }
+}

package/src/FiberRuntime/index.ts

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

package/src/FiberStatus/index.ts

@@ -0,0 +1,37 @@
+import { AnyExit } from '@/Exit/Exit.js'
+
+export type FiberStatus = Suspended | Running | Done
+
+export interface Suspended {
+  readonly tag: 'Suspended'
+  readonly isInterruptable: boolean
+}
+export const Suspended = (isInterruptable: () => boolean): Suspended => ({
+  tag: 'Suspended',
+  get isInterruptable() {
+    return isInterruptable()
+  },
+})
+
+export interface Running {
+  readonly tag: 'Running'
+  readonly isInterruptable: boolean
+}
+export const Running = (isInterruptable: () => boolean): Running => ({
+  tag: 'Running',
+  get isInterruptable() {
+    return isInterruptable()
+  },
+})
+
+export interface Done {
+  readonly tag: 'Done'
+  readonly isInterruptable: false
+  readonly exit: AnyExit
+}
+
+export const Done = (exit: AnyExit): Done => ({
+  tag: 'Done',
+  isInterruptable: false,
+  exit,
+})

package/src/Finalizer/Finalizer.ts

@@ -0,0 +1,48 @@
+import { Branded } from 'hkt-ts/Branded'
+import { NonNegativeInteger } from 'hkt-ts/number'
+
+import { Exit } from '@/Exit/Exit.js'
+import { Fx } from '@/Fx/Fx.js'
+
+export interface Finalizer<R = never, E = never> {
+  (exit: Exit<any, any>): Fx<R, E, any>
+}
+
+export type FinalizerKey = Branded<{ readonly FinalizerKey: FinalizerKey }, symbol>
+export const FinalizerKey = Branded<FinalizerKey>()
+
+export type FinalizationStrategy = SequentialStrategy | ConcurrentStrategy | ConcurrentNStrategy
+
+export interface SequentialStrategy {
+  readonly strategy: 'Sequential'
+}
+export const SequentialStrategy: SequentialStrategy = { strategy: 'Sequential' }
+
+export interface ConcurrentStrategy {
+  readonly strategy: 'Concurrent'
+}
+export const ConcurrentStrategy: ConcurrentStrategy = { strategy: 'Concurrent' }
+
+export interface ConcurrentNStrategy {
+  readonly strategy: 'ConcurrentN'
+  readonly concurrency: NonNegativeInteger
+}
+
+export const ConcurrentNStrategy = (concurency: NonNegativeInteger): ConcurrentNStrategy => ({
+  strategy: 'ConcurrentN',
+  concurrency: concurency,
+})
+
+export function finalizationStrategyToConcurrency(
+  strategy: FinalizationStrategy,
+): NonNegativeInteger {
+  if (strategy.strategy === 'Sequential') {
+    return NonNegativeInteger(1)
+  }
+
+  if (strategy.strategy === 'Concurrent') {
+    return NonNegativeInteger(Number.MAX_SAFE_INTEGER)
+  }
+
+  return strategy.concurrency
+}

package/src/Finalizer/index.ts

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

package/src/Future/Future.ts

@@ -0,0 +1,72 @@
+import { Atomic } from '@/Atomic/Atomic.js'
+import { Disposable } from '@/Disposable/Disposable.js'
+import type { Fx } from '@/Fx/Fx.js'
+
+export interface Future<R, E, A> {
+  readonly state: Atomic<FutureState<R, E, A>>
+}
+
+export type AnyFuture =
+  | Future<any, any, any>
+  | Future<never, never, any>
+  | Future<never, any, any>
+  | Future<any, never, any>
+
+export type FutureState<R, E, A> = Pending<R, E, A> | Resolved<R, E, A>
+
+export interface Pending<R, E, A> {
+  readonly tag: 'Pending'
+  readonly observers: ReadonlySet<Observer<R, E, A>>
+}
+
+export function Pending<R, E, A>(): Future<R, E, A> {
+  return {
+    state: Atomic<FutureState<R, E, A>>({ tag: 'Pending', observers: new Set() }),
+  }
+}
+
+export function addObserver<R, E, A>(
+  future: Future<R, E, A>,
+  observer: Observer<R, E, A>,
+): Disposable {
+  return future.state.modify((state): readonly [Disposable, FutureState<R, E, A>] => {
+    if (state.tag === 'Resolved') {
+      return [Disposable.None, state]
+    }
+
+    const updated: FutureState<R, E, A> = {
+      ...state,
+      observers: new Set([...state.observers, observer]),
+    }
+
+    return [Disposable(() => removeObserver(future, observer)), updated]
+  })
+}
+
+function removeObserver<R, E, A>(future: Future<R, E, A>, observer: Observer<R, E, A>) {
+  return future.state.modify((state) => {
+    if (state.tag === 'Resolved') {
+      return [undefined, state]
+    }
+
+    return [
+      undefined,
+      { ...state, observer: new Set([...state.observers].filter((x) => x !== observer)) },
+    ]
+  })
+}
+
+export interface Observer<R, E, A> {
+  (fx: Fx<R, E, A>): void
+}
+
+export interface Resolved<R, E, A> {
+  readonly tag: 'Resolved'
+  readonly fx: Fx<R, E, A>
+}
+
+export function Resolved<R, E, A>(fx: Fx<R, E, A>): Future<R, E, A> {
+  return {
+    state: Atomic<FutureState<R, E, A>>({ tag: 'Resolved', fx }),
+  }
+}

package/src/Future/MutableFutureQueue.ts

@@ -0,0 +1,58 @@
+import { pipe } from 'hkt-ts/function'
+
+import { Future, Pending } from './Future.js'
+import { complete } from './complete.js'
+
+import { Fx } from '@/Fx/Fx.js'
+
+/**
+ * A Future Queue is a synchronously-used, mutable, Queue for managing Futures that need to be handled in FIFO ordering.
+ */
+export interface MutableFutureQueue<R, E, A> {
+  readonly size: () => number
+  readonly next: (value: Fx<R, E, A>) => boolean
+  readonly all: (value: Fx<R, E, A>) => boolean
+  readonly waitFor: (amount: number) => ReadonlyArray<Future<R, E, A>>
+}
+
+/**
+ * Constructs a FutureQueue
+ */
+export function MutableFutureQueue<R, E, A>(): MutableFutureQueue<R, E, A> {
+  const queue: Array<Future<R, E, A>> = []
+
+  function next(fx: Fx<R, E, A>): boolean {
+    if (queue.length > 0) {
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      return pipe(fx, complete(queue.shift()!))
+    }
+
+    return false
+  }
+
+  function waitFor(amount: number): ReadonlyArray<Future<R, E, A>> {
+    const pendingFutures = Array.from({ length: amount }, () => Pending<R, E, A>())
+
+    queue.push(...pendingFutures)
+
+    return pendingFutures
+  }
+
+  function all(Fx: Fx<R, E, A>): boolean {
+    if (queue.length > 0) {
+      queue.forEach((f) => complete(f)(Fx))
+      queue.splice(0, queue.length) // Clear the Queue
+
+      return true
+    }
+
+    return false
+  }
+
+  return {
+    size: () => queue.length,
+    next,
+    waitFor,
+    all,
+  } as const
+}

package/src/Future/complete.ts

@@ -0,0 +1,16 @@
+import type { Future } from './Future.js'
+
+import type { Fx } from '@/Fx/Fx.js'
+
+export function complete<R, E, A>(future: Future<R, E, A>) {
+  return (fx: Fx<R, E, A>) =>
+    future.state.modify<boolean>((s) => {
+      if (s.tag === 'Resolved') {
+        return [false, s]
+      }
+
+      s.observers.forEach((o) => o(fx))
+
+      return [true, { tag: 'Resolved', fx }]
+    })
+}

package/src/Future/index.ts

@@ -0,0 +1,3 @@
+export * from './complete.js'
+export * from './Future.js'
+export * from './wait.js'

package/src/Future/wait.ts

@@ -0,0 +1,8 @@
+import type { Future } from './Future.js'
+
+import type { Fx } from '@/Fx/Fx.js'
+import { Wait } from '@/Fx/Instruction.js'
+
+export function wait<R, E, A>(future: Future<R, E, A>): Fx<R, E, A> {
+  return Wait.make(future)
+}

package/src/Fx/Fx.test.ts

@@ -0,0 +1,110 @@
+import { deepStrictEqual } from 'assert'
+
+import { pipe } from 'hkt-ts/function'
+
+import { Fx, IO, Of, access, flatMap, map, now } from './Fx.js'
+
+import { CauseError } from '@/Cause/CauseError.js'
+import { FiberRuntime } from '@/FiberRuntime/FiberRuntime.js'
+
+describe(new URL(import.meta.url).pathname, () => {
+  describe(Fx.name, () => {
+    describe('Sync', () => {
+      it('allows running sync effects', async () => {
+        const value = Math.random()
+        const test = now(value)
+
+        deepStrictEqual(await runTest(test), value)
+      })
+
+      it('allows using try/catch locally', async () => {
+        const error = new Error('foo')
+        const value = Math.random()
+        const test = access(() =>
+          // eslint-disable-next-line require-yield
+          Fx(function* () {
+            try {
+              throw new Error('foo')
+            } catch (e) {
+              deepStrictEqual(e, error)
+
+              return value
+            }
+          }),
+        )
+
+        deepStrictEqual(await runTest(test), value)
+      })
+
+      it('allows using try/catch within nested Fx', async () => {
+        const error = new Error('foo')
+        const value = Math.random()
+        const test = Fx(function* () {
+          try {
+            yield* access(() =>
+              // eslint-disable-next-line require-yield
+              Fx(function* () {
+                throw new Error('foo')
+              }),
+            )
+          } catch (e) {
+            deepStrictEqual(e, error)
+
+            return value
+          }
+        })
+
+        deepStrictEqual(await runTest(test), value)
+      })
+    })
+  })
+
+  it('runs Fib', async () => {
+    const fib = (n: number): Of<number> => {
+      if (n < 2) {
+        return now(n)
+      }
+
+      return pipe(
+        fib(n - 1),
+        flatMap((a) =>
+          pipe(
+            fib(n - 2),
+            map((b) => a + b),
+          ),
+        ),
+      )
+    }
+
+    for (let i = 0; i < 10; i++) {
+      console.time('Fib25')
+      deepStrictEqual(await runTest(fib(25)), 75025)
+      console.timeEnd('Fib25')
+    }
+  })
+
+  it.skip('runs Fib w/ generators', async () => {
+    const fib = (n: number): Of<number> =>
+      Fx(function* () {
+        if (n < 2) {
+          return n
+        }
+
+        return (yield* fib(n - 1)) + (yield* fib(n - 2))
+      })
+
+    console.time('Fib25')
+    deepStrictEqual(await runTest(fib(25)), 75025)
+    console.timeEnd('Fib25')
+  })
+})
+
+export function runTest<E, A>(io: IO<E, A>): Promise<A> {
+  return new Promise((resolve, reject) => {
+    const runtime = new FiberRuntime(io)
+    runtime.addObserver((exit) =>
+      exit.tag === 'Right' ? resolve(exit.right) : reject(new CauseError(exit.left)),
+    )
+    runtime.startSync()
+  })
+}