@typed/fx 0.0.3 → 0.0.4

package/src/Fx/Fx.test.ts

@@ -2,27 +2,32 @@ import { deepStrictEqual } from 'assert'
 
 import { pipe } from 'hkt-ts/function'
 
-import { Fx, IO, Of, access, flatMap, map, now } from './Fx.js'
+import * as Fx from './Fx.js'
+import { runMain, runMainFiber } from './run.js'
 
-import { CauseError } from '@/Cause/CauseError.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.name, () => {
+  describe(Fx.Fx.name, () => {
     describe('Sync', () => {
       it('allows running sync effects', async () => {
         const value = Math.random()
-        const test = now(value)
+        const test = Fx.now(value)
 
-        deepStrictEqual(await runTest(test), value)
+        deepStrictEqual(await runMain(test), value)
       })
 
       it('allows using try/catch locally', async () => {
         const error = new Error('foo')
         const value = Math.random()
-        const test = access(() =>
+        const test = Fx.access(() =>
           // eslint-disable-next-line require-yield
-          Fx(function* () {
+          Fx.Fx(function* () {
             try {
               throw new Error('foo')
             } catch (e) {
@@ -33,17 +38,17 @@ describe(new URL(import.meta.url).pathname, () => {
           }),
         )
 
-        deepStrictEqual(await runTest(test), 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(function* () {
+        const test = Fx.Fx(function* () {
           try {
-            yield* access(() =>
+            yield* Fx.access(() =>
               // eslint-disable-next-line require-yield
-              Fx(function* () {
+              Fx.Fx(function* () {
                 throw new Error('foo')
               }),
             )
@@ -54,38 +59,64 @@ describe(new URL(import.meta.url).pathname, () => {
           }
         })
 
-        deepStrictEqual(await runTest(test), 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): Of<number> => {
+    const fib = (n: number): Fx.Of<number> => {
       if (n < 2) {
-        return now(n)
+        return Fx.now(n)
       }
 
       return pipe(
         fib(n - 1),
-        flatMap((a) =>
+        Fx.flatMap((a) =>
           pipe(
             fib(n - 2),
-            map((b) => a + b),
+            Fx.map((b) => a + b),
           ),
         ),
       )
     }
 
+    console.time('Fx: Fib25 Construction')
+    const program = fib(25)
+    console.timeEnd('Fx: Fib25 Construction')
     for (let i = 0; i < 10; i++) {
       console.time('Fib25')
-      deepStrictEqual(await runTest(fib(25)), 75025)
+      await runMain(program)
       console.timeEnd('Fib25')
     }
   })
 
-  it.skip('runs Fib w/ generators', async () => {
-    const fib = (n: number): Of<number> =>
-      Fx(function* () {
+  it('runs Fib w/ generators', async () => {
+    const fib = (n: number): Fx.Of<number> =>
+      Fx.Fx(function* () {
         if (n < 2) {
           return n
         }
@@ -94,17 +125,7 @@ describe(new URL(import.meta.url).pathname, () => {
       })
 
     console.time('Fib25')
-    deepStrictEqual(await runTest(fib(25)), 75025)
+    deepStrictEqual(await runMain(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()
-  })
-}

package/src/Fx/Fx.ts

@@ -1,6 +1,6 @@
 import { HKT3, Lazy, Params, Variance, constant, flow, identity, pipe } from 'hkt-ts'
 import * as Either from 'hkt-ts/Either'
-import { Maybe } from 'hkt-ts/Maybe'
+import * as Maybe from 'hkt-ts/Maybe'
 import { ReadonlyRecord } from 'hkt-ts/Record'
 import * as AB from 'hkt-ts/Typeclass/AssociativeBoth'
 import * as AE from 'hkt-ts/Typeclass/AssociativeEither'
@@ -16,7 +16,6 @@ import { Unary } from 'hkt-ts/Unary'
 import { NonNegativeInteger } from 'hkt-ts/number'
 
 import {
-  Access,
   AddTrace,
   BothFx,
   DeleteFiberRef,
@@ -26,6 +25,7 @@ import {
   Fork,
   FromCause,
   FromLazy,
+  GetEnv,
   GetFiberContext,
   GetFiberRef,
   GetTrace,
@@ -48,7 +48,7 @@ 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'
+import * as Exit from '@/Exit/index.js'
 import type * as Fiber from '@/Fiber/Fiber.js'
 import type { FiberContext } from '@/FiberContext/FiberContext.js'
 import { FiberId } from '@/FiberId/FiberId.js'
@@ -91,11 +91,7 @@ export interface Of<A> extends IO<never, A> {}
 
 export interface RIO<R, A> extends Fx<R, never, A> {}
 
-export type AnyFx =
-  | Fx<any, any, any>
-  | Fx<never, never, any>
-  | Fx<never, any, any>
-  | Fx<any, never, any>
+export type AnyFx = Fx<any, any, any>
 
 export const now = <A>(a: A, __trace?: string): Of<A> => Now.make(a, __trace)
 export const success = now
@@ -112,12 +108,12 @@ export const flatMap =
   <R, E>(fx: Fx<R, E, A>) =>
     FlatMap.make(fx, f, __trace)
 
+export const getEnv = <R>(__trace?: string): RIO<R, Env<R>> => GetEnv.make<R>(__trace)
+
 export const access = <R = never, R2 = never, E = never, A = any>(
   f: (r: Env<R>) => Fx<R2, E, A>,
   __trace?: string,
-): Fx<R | R2, E, A> => Access.make(f, __trace)
-
-export const getEnv = <R>(__trace?: string): RIO<R, Env<R>> => access(now, __trace)
+): Fx<R | R2, E, A> => pipe(getEnv<R>(), flatMap(f, __trace))
 
 export const provide =
   <R>(env: Env<R>, __trace?: string) =>
@@ -143,7 +139,7 @@ export const provideLayers =
     E | Layer.ErrorsOf<Layers[number]>,
     A
   > =>
-    layers.reduceRight((fx, l) => pipe(fx, provideLayer(l)), fx) as any
+    layers.reduce((fx, l) => pipe(fx, provideLayer(l)), fx) as any
 
 export const ask = <S>(s: Service<S>, __trace?: string): RIO<S, S> =>
   access((e) => e.get(s), __trace)
@@ -157,7 +153,7 @@ export const asksEnv = <R, A>(f: (env: Env<R>) => A, __trace?: string): Fx<R, ne
   access((e) => now(f(e)), __trace)
 
 export const ensuring =
-  <E, A, R2, E2, B>(ensure: (a: Exit<E, A>) => Fx<R2, E2, B>, __trace?: string) =>
+  <E, A, R2, E2, B>(ensure: (a: Exit.Exit<E, A>) => Fx<R2, E2, B>, __trace?: string) =>
   <R>(fx: Fx<R, E, A>): Fx<R | R2, E | E2, A> =>
     pipe(
       fx,
@@ -182,9 +178,12 @@ export const ensuring =
 export const fromCause = <E>(cause: Cause.Cause<E>, __trace?: string): IO<E, never> =>
   FromCause.make(cause, __trace)
 
-export const fromExit = <E, A>(exit: Exit<E, A>, __trace?: string): IO<E, A> =>
+export const fromExit = <E, A>(exit: Exit.Exit<E, A>, __trace?: string): IO<E, A> =>
   (exit.tag === 'Left' ? fromCause(exit.left, __trace) : now(exit.right, __trace)) as IO<E, A>
 
+export const fromEither = <E, A>(e: Either.Either<E, A>, __trace?: string): IO<E, A> =>
+  fromExit(Exit.fromEither(e), __trace)
+
 export const interrupted = (id: FiberId, __trace?: string) =>
   fromCause(Cause.interrupted(id), __trace)
 
@@ -194,14 +193,16 @@ export const map =
     MapFx.make(fx, f, __trace)
 
 export const tap =
-  <A, B>(f: Unary<A, B>, __trace?: string) =>
-  <R, E>(fx: Fx<R, E, A>): Fx<R, E, A> =>
-    MapFx.make(
+  <A, R2, E2, B>(f: Unary<A, Fx<R2, E2, B>>, __trace?: string) =>
+  <R, E>(fx: Fx<R, E, A>): Fx<R | R2, E | E2, A> =>
+    FlatMap.make(
       fx,
-      (a) => {
-        f(a)
-        return a
-      },
+      (a) =>
+        pipe(
+          a,
+          f,
+          map(() => a),
+        ),
       __trace,
     )
 
@@ -244,15 +245,35 @@ export const orElse =
   <R, A>(fx: Fx<R, E, A>): Fx<R | R2, E2, A | B> =>
     Match.make(
       fx,
-      (cause) =>
-        cause.tag === 'Expected' ? onLeft(cause.error) : (fromCause(cause) as Fx<R2, E2, B>),
+      (cause) => pipe(findExpectedCause(cause), Either.match(onLeft, fromCause)),
       now,
       __trace,
     )
 
+function findExpectedCause<E>(cause: Cause.Cause<E>): Either.Either<E, Cause.Cause<never>> {
+  if (cause.tag === 'Expected') {
+    return Either.Left(cause.error)
+  }
+  if (cause.tag === 'Sequential' || cause.tag === 'Parallel') {
+    return pipe(
+      cause.left,
+      findExpectedCause,
+      Either.flatMap(() => findExpectedCause(cause.right)),
+    )
+  }
+  if (cause.tag === 'Traced') {
+    return findExpectedCause(cause.cause)
+  }
+
+  return Either.Right(cause)
+}
+
 export const mapLeft = <E, E2>(f: (e: E) => E2) => orElseCause(flow(Cause.map(f), fromCause))
 
-export const attempt = <R, E, A>(fx: Fx<R, E, A>, __trace?: string): Fx<R, never, Exit<E, A>> =>
+export const attempt = <R, E, A>(
+  fx: Fx<R, E, A>,
+  __trace?: string,
+): Fx<R, never, Exit.Exit<E, A>> =>
   pipe(fx, matchCause(flow(Either.Left, now), flow(Either.Right, now), __trace))
 
 export const bimap =
@@ -349,7 +370,7 @@ export const either =
     EitherFx.make(first, second, __trace) as Fx<R | R2, E | E2, Either.Either<A, B>>
 
 export const forkInContext =
-  (context: FiberContext, __trace?: string) =>
+  (context: FiberContext<FiberId.Live>, __trace?: string) =>
   <R, E, A>(fx: Fx<R, E, A>): Fx<R, never, Fiber.Live<E, A>> =>
     Fork.make(fx, context, __trace)
 
@@ -378,7 +399,7 @@ export const modifyFiberRef =
 export const deleteFiberRef = <R, E, A>(
   ref: FiberRef<R, E, A>,
   __trace?: string,
-): Fx<R, E, Maybe<A>> => DeleteFiberRef.make(ref, __trace)
+): Fx<R, E, Maybe.Maybe<A>> => DeleteFiberRef.make(ref, __trace)
 
 export const fiberRefLocally =
   <R2, E2, B>(ref: FiberRef<R2, E2, B>, value: B) =>
@@ -406,20 +427,23 @@ export function Fx<G extends AnyGenerator>(
     return pipe(
       runFxGenerator(gen, gen.next()),
       // Allow running Gen.throw to attempt to use try/catch to handle any errors
-      orElseCause(
-        (cause) =>
-          (Cause.shouldRethrow(cause)
+      orElseCause((cause) => {
+        const error = getCauseError(cause)
+
+        return (
+          Cause.shouldRethrow(cause)
             ? pipe(
-                lazy(() => runFxGenerator(gen, gen.throw(getCauseError(cause)))),
+                lazy(() => runFxGenerator(gen, gen.throw(error))),
                 orElseCause((inner) =>
                   // Ensure the the most useful error is continued up the stack
-                  DeepEquals.equals(getCauseError(inner), getCauseError(cause))
+                  DeepEquals.equals(getCauseError(inner), error)
                     ? fromCause(cause)
                     : fromCause(Cause.sequential(cause, inner)),
                 ),
               )
-            : fromCause(cause)) as Fx<ResourcesOf<YieldOf<G>>, ErrorsOf<YieldOf<G>>, ReturnOf<G>>,
-      ),
+            : fromCause(cause)
+        ) as Fx<ResourcesOf<YieldOf<G>>, ErrorsOf<YieldOf<G>>, ReturnOf<G>>
+      }),
     )
   }, __trace) as Fx<ResourcesOf<YieldOf<G>>, ErrorsOf<YieldOf<G>>, ReturnOf<G>>
 }
@@ -451,7 +475,7 @@ export function async<R, E, A, R2 = never, E2 = never>(
         either,
         Either.match(
           // eslint-disable-next-line @typescript-eslint/no-unused-vars
-          (finalizer) => ensuring((_: Exit<E, A>) => finalizer)(wait(future)),
+          (finalizer) => ensuring((_: Exit.Exit<E, A>) => finalizer)(wait(future)),
           identity,
         ),
       )