@typed/fx 0.0.8 → 0.0.10

package/src/FiberRuntime/Frame.ts

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

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

package/src/FiberStatus/index.ts

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

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

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

package/src/Future/Future.ts

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

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

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

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

package/src/Future/wait.ts

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

@@ -1,131 +0,0 @@
-import { deepStrictEqual } from 'assert'
-
-import { pipe } from 'hkt-ts/function'
-
-import * as Fx from './Fx.js'
-import { runMain, runMainFiber } from './run.js'
-
-import { FiberId } from '@/FiberId/FiberId.js'
-import { FiberRuntime } from '@/FiberRuntime/FiberRuntime.js'
-import { RootScheduler } from '@/Scheduler/RootScheduler.js'
-import { Scheduler } from '@/Scheduler/Scheduler.js'
-import { Delay } from '@/Time/index.js'
-import { Exit, sleep } from '@/index.js'
-
-describe(new URL(import.meta.url).pathname, () => {
-  describe(Fx.Fx.name, () => {
-    describe('Sync', () => {
-      it('allows running sync effects', async () => {
-        const value = Math.random()
-        const test = Fx.now(value)
-
-        deepStrictEqual(await runMain(test), value)
-      })
-
-      it('allows using try/catch locally', async () => {
-        const error = new Error('foo')
-        const value = Math.random()
-        const test = Fx.access(() =>
-          // eslint-disable-next-line require-yield
-          Fx.Fx(function* () {
-            try {
-              throw new Error('foo')
-            } catch (e) {
-              deepStrictEqual(e, error)
-
-              return value
-            }
-          }),
-        )
-
-        deepStrictEqual(await runMain(test), value)
-      })
-
-      it('allows using try/catch within nested Fx', async () => {
-        const error = new Error('foo')
-        const value = Math.random()
-        const test = Fx.Fx(function* () {
-          try {
-            yield* Fx.access(() =>
-              // eslint-disable-next-line require-yield
-              Fx.Fx(function* () {
-                throw new Error('foo')
-              }),
-            )
-          } catch (e) {
-            deepStrictEqual(e, error)
-
-            return value
-          }
-        })
-
-        deepStrictEqual(await runMain(test), value)
-      })
-    })
-  })
-
-  describe('Interruption', () => {
-    it('asynchronous work allows being interrupted', async () => {
-      const fiber = runMainFiber(Fx.never)
-
-      deepStrictEqual(await runMain(fiber.interruptAs(FiberId.None)), Exit.interrupt(FiberId.None))
-    })
-
-    it('allows marking regions as uninterruptable', async () => {
-      const value = Math.random()
-      const test = pipe(
-        sleep(Delay(100)),
-        Fx.flatMap(() => Fx.success(value)),
-        Fx.provideService(Scheduler, RootScheduler()),
-        Fx.uninterruptable,
-      )
-
-      const fiber = new FiberRuntime(test)
-      fiber.startSync()
-
-      deepStrictEqual(await runMain(fiber.interruptAs(FiberId.None)), Exit.success(value))
-    })
-  })
-
-  it('runs Fib', async () => {
-    const fib = (n: number): Fx.Of<number> => {
-      if (n < 2) {
-        return Fx.now(n)
-      }
-
-      return pipe(
-        fib(n - 1),
-        Fx.flatMap((a) =>
-          pipe(
-            fib(n - 2),
-            Fx.map((b) => a + b),
-          ),
-        ),
-      )
-    }
-
-    console.time('Fx: Fib25 Construction')
-    const program = fib(25)
-    console.timeEnd('Fx: Fib25 Construction')
-    for (let i = 0; i < 5; i++) {
-      console.time('Fib25')
-      await runMain(program)
-      console.timeEnd('Fib25')
-    }
-  })
-
-  it.skip('runs Fib w/ generators', async () => {
-    const fib = (n: number): Fx.Of<number> =>
-      Fx.Fx(function* () {
-        if (n < 2) {
-          return n
-        }
-
-        return (yield* fib(n - 1)) + (yield* fib(n - 2))
-      })
-
-    console.time('Fib25')
-    deepStrictEqual(await runMain(fib(25)), 75025)
-    console.timeEnd('Fib25')
-  })
-})