@typed/fx 0.0.1

package/src/Fx/Instruction.ts

@@ -0,0 +1,468 @@
+import { Either } from 'hkt-ts/Either'
+import { Maybe } from 'hkt-ts/Maybe'
+import { Lazy, flow } from 'hkt-ts/function'
+import { NonNegativeInteger } from 'hkt-ts/number'
+
+import type { Fx } from './Fx.js'
+
+import { Cause } from '@/Cause/Cause.js'
+import type { Env } from '@/Env/Env.js'
+import type { Live } from '@/Fiber/Fiber.js'
+import type { FiberContext } from '@/FiberContext/FiberContext.js'
+import type { FiberRef } from '@/FiberRef/FiberRef.js'
+import type { Future } from '@/Future/index.js'
+import type { Layer } from '@/Layer/Layer.js'
+import { Service } from '@/Service/Service.js'
+import { Trace } from '@/Trace/Trace.js'
+
+export type Instruction<R, E, A> =
+  | Access<R, R, E, A>
+  | AddTrace<R, E, A>
+  | BothFx<R, E, any, R, E, any>
+  | DeleteFiberRef<R, E, any, A>
+  | EitherFx<R, E, any, R, E, any>
+  | FiberRefLocally<any, any, any, R, E, A>
+  | FlatMap<R, E, any, R, E, A>
+  | Fork<R, any, A>
+  | FromCause<E>
+  | FromLazy<A>
+  | GetFiberContext
+  | GetFiberRef<R, E, A>
+  | GetInterruptStatus
+  | GetTrace
+  | LazyFx<R, E, A>
+  | MapFx<R, E, any, A>
+  | Match<R, E, any, R, E, A, R, E, A>
+  | ModifyFiberRef<R, E, any, A>
+  | Now<A>
+  | Provide<any, E, A>
+  | ProvideService<R, E, A, any>
+  | ProvideLayer<R, E, A, R, E, any>
+  | SetConcurrencyLevel<R, E, A>
+  | SetInterruptStatus<R, E, A>
+  | Wait<R, E, A>
+
+export type AnyInstruction =
+  | Instruction<any, any, any>
+  | Instruction<never, never, any>
+  | Instruction<never, any, any>
+  | Instruction<any, never, any>
+
+export abstract class Instr<R, E, A> {
+  readonly _R!: () => R
+  readonly _E!: () => E
+  readonly _A!: () => A
+
+  readonly instr: this
+
+  constructor(readonly __trace?: string) {
+    this.instr = this
+  }
+
+  *[Symbol.iterator](): Generator<this, A, A> {
+    return yield this
+  }
+}
+
+export class Now<A> extends Instr<never, never, A> {
+  readonly tag = 'Now'
+  constructor(readonly value: A, readonly __trace?: string) {
+    super(__trace)
+  }
+
+  static make<A>(value: A, __trace?: string): Fx<never, never, A> {
+    return new Now(value, __trace)
+  }
+}
+
+export class FromLazy<A> extends Instr<never, never, A> {
+  readonly tag = 'FromLazy'
+  constructor(readonly f: Lazy<A>, readonly __trace?: string) {
+    super(__trace)
+  }
+
+  static make<A>(f: Lazy<A>, __trace?: string): Fx<never, never, A> {
+    return new FromLazy(f, __trace)
+  }
+}
+
+export class FromCause<E> extends Instr<never, E, never> {
+  readonly tag = 'FromCause'
+  constructor(readonly cause: Cause<E>, readonly __trace?: string) {
+    super(__trace)
+  }
+
+  static make<E>(cause: Cause<E>, __trace?: string): Fx<never, E, never> {
+    return new FromCause(cause, __trace)
+  }
+}
+
+export class MapFx<R, E, A, B> extends Instr<R, E, B> {
+  readonly tag = 'Map'
+
+  constructor(readonly fx: Fx<R, E, A>, readonly f: (a: A) => B, readonly __trace?: string) {
+    super(__trace)
+  }
+
+  static make<R, E, A, B>(fx: Fx<R, E, A>, f: (a: A) => B, __trace?: string): Fx<R, E, B> {
+    const prev = fx.instr
+
+    if (prev.tag === 'Now') {
+      return new Now(f(prev.value), __trace) as Fx<R, E, B>
+    }
+
+    if (prev.tag === 'Map') {
+      return new MapFx(prev.fx as Fx<any, any, any>, flow(prev.f, f), __trace)
+    }
+
+    return new MapFx(fx, f, __trace)
+  }
+}
+
+export class FlatMap<R, E, A, R2, E2, B> extends Instr<R | R2, E | E2, B> {
+  readonly tag = 'FlatMap'
+
+  constructor(
+    readonly fx: Fx<R, E, A>,
+    readonly f: (a: A) => Fx<R2, E2, B>,
+    readonly __trace?: string,
+  ) {
+    super(__trace)
+  }
+
+  static make<R, E, A, R2, E2, B>(
+    fx: Fx<R, E, A>,
+    f: (a: A) => Fx<R2, E2, B>,
+    __trace?: string,
+  ): Fx<R | R2, E | E2, B> {
+    const prev = fx.instr
+
+    if (prev.tag === 'Now') {
+      return f(prev.value) as Fx<R | R2, E | E2, B>
+    }
+
+    if (prev.tag === 'Map') {
+      return new FlatMap(prev.fx as Fx<any, any, any>, flow(prev.f, f), __trace) as Fx<
+        R | R2,
+        E | E2,
+        B
+      >
+    }
+
+    return new FlatMap(fx, f, __trace) as Fx<R | R2, E | E2, B>
+  }
+}
+
+export class Match<R, E, A, R2, E2, B, R3, E3, C> extends Instr<R | R2 | R3, E2 | E3, B | C> {
+  readonly tag = 'Match'
+
+  constructor(
+    readonly fx: Fx<R, E, A>,
+    readonly onLeft: (cause: Cause<E>) => Fx<R2, E2, B>,
+    readonly onRight: (a: A) => Fx<R3, E3, C>,
+    readonly __trace?: string,
+  ) {
+    super(__trace)
+  }
+
+  static make<R, E, A, R2, E2, B, R3, E3, C>(
+    fx: Fx<R, E, A>,
+    onLeft: (cause: Cause<E>) => Fx<R2, E2, B>,
+    onRight: (a: A) => Fx<R3, E3, C>,
+    __trace?: string,
+  ): Fx<R | R2 | R3, E2 | E3, B | C> {
+    const prev = fx.instr
+
+    if (prev.tag === 'Now') {
+      return onRight(prev.value) as Fx<R | R2 | R3, E2 | E3, B | C>
+    }
+
+    if (prev.tag === 'FromCause') {
+      return onLeft(prev.cause) as Fx<R | R2 | R3, E2 | E3, B | C>
+    }
+
+    if (prev.tag === 'Map') {
+      return new Match(prev.fx as Fx<any, any, any>, onLeft, flow(prev.f, onRight), __trace) as any
+    }
+
+    return new Match(fx, onLeft, onRight, __trace) as any
+  }
+}
+
+export class Access<R, R2, E, A> extends Instr<R | R2, E, A> {
+  readonly tag = 'Access'
+
+  constructor(readonly f: (r: Env<R>) => Fx<R2, E, A>, readonly __trace?: string) {
+    super(__trace)
+  }
+
+  static make<R, R2, E, A>(f: (r: Env<R>) => Fx<R2, E, A>, __trace?: string): Fx<R | R2, E, A> {
+    return new Access(f, __trace) as Fx<R | R2, E, A>
+  }
+}
+
+export class Provide<R, E, A> extends Instr<never, E, A> {
+  readonly tag = 'Provide'
+
+  constructor(readonly fx: Fx<R, E, A>, readonly env: Env<R>, readonly __trace?: string) {
+    super(__trace)
+  }
+
+  static make<R, E, A>(fx: Fx<R, E, A>, env: Env<R>, __trace?: string): Fx<never, E, A> {
+    return new Provide(fx, env, __trace)
+  }
+}
+
+export class ProvideService<R, E, A, S> extends Instr<Exclude<R, S>, E, A> {
+  readonly tag = 'ProvideService'
+
+  constructor(
+    readonly fx: Fx<R, E, A>,
+    readonly service: Service<S>,
+    readonly implementation: S,
+    readonly __trace?: string,
+  ) {
+    super(__trace)
+  }
+
+  static make<R, E, A, S>(
+    fx: Fx<R, E, A>,
+    service: Service<S>,
+    implementation: S,
+    __trace?: string,
+  ): Fx<Exclude<R, S>, E, A> {
+    return new ProvideService(fx, service, implementation, __trace) as any as Fx<
+      Exclude<R, S>,
+      E,
+      A
+    >
+  }
+}
+
+export class ProvideLayer<R, E, A, R2, E2, S> extends Instr<Exclude<R | R2, S>, E | E2, A> {
+  readonly tag = 'ProvideLayer'
+
+  constructor(
+    readonly fx: Fx<R, E, A>,
+    readonly layer: Layer<R2, E2, S>,
+    readonly __trace?: string,
+  ) {
+    super(__trace)
+  }
+
+  static make<R, E, A, R2, E2, S>(
+    fx: Fx<R, E, A>,
+    layer: Layer<R2, E2, S>,
+    __trace?: string,
+  ): Fx<Exclude<R, S>, E, A> {
+    return new ProvideLayer(fx, layer, __trace) as any
+  }
+}
+
+export class LazyFx<R, E, A> extends Instr<R, E, A> {
+  readonly tag = 'Lazy'
+
+  constructor(readonly f: () => Fx<R, E, A>, readonly __trace?: string) {
+    super(__trace)
+  }
+
+  static make<R, E, A>(f: () => Fx<R, E, A>, __trace?: string): Fx<R, E, A> {
+    return new LazyFx(f, __trace)
+  }
+}
+
+export class Wait<R, E, A> extends Instr<R, E, A> {
+  readonly tag = 'Wait'
+
+  constructor(readonly future: Future<R, E, A>, readonly __trace?: string) {
+    super(__trace)
+  }
+
+  static make<R, E, A>(future: Future<R, E, A>, __trace?: string): Fx<R, E, A> {
+    return new Wait(future, __trace)
+  }
+}
+
+export class AddTrace<R, E, A> extends Instr<R, E, A> {
+  readonly tag = 'AddTrace'
+
+  constructor(readonly fx: Fx<R, E, A>, readonly trace: Trace) {
+    super()
+  }
+
+  static make<R, E, A>(fx: Fx<R, E, A>, trace: Trace): Fx<R, E, A> {
+    return new AddTrace(fx, trace)
+  }
+}
+
+export class GetTrace extends Instr<never, never, Trace> {
+  readonly tag = 'GetTrace'
+
+  static make = (__trace?: string): Fx<never, never, Trace> => new GetTrace(__trace)
+}
+
+export class SetInterruptStatus<R, E, A> extends Instr<R, E, A> {
+  readonly tag = 'SetInterruptStatus'
+
+  constructor(readonly fx: Fx<R, E, A>, readonly interruptStatus: boolean, __trace?: string) {
+    super(__trace)
+  }
+
+  static make<R, E, A>(fx: Fx<R, E, A>, interruptStatus: boolean, __trace?: string): Fx<R, E, A> {
+    return new SetInterruptStatus(fx, interruptStatus, __trace)
+  }
+}
+
+export class GetFiberContext extends Instr<never, never, FiberContext> {
+  readonly tag = 'GetFiberContext'
+
+  static make = (__trace?: string): Fx<never, never, FiberContext> => new GetFiberContext(__trace)
+}
+
+export class GetInterruptStatus extends Instr<never, never, boolean> {
+  readonly tag = 'GetInterruptStatus'
+
+  static make = (__trace?: string): Fx<never, never, boolean> => new GetInterruptStatus(__trace)
+}
+
+export class SetConcurrencyLevel<R, E, A> extends Instr<R, E, A> {
+  readonly tag = 'SetConcurrencyLevel'
+
+  constructor(
+    readonly fx: Fx<R, E, A>,
+    readonly concurrencyLevel: NonNegativeInteger,
+    __trace?: string,
+  ) {
+    super(__trace)
+  }
+
+  static make<R, E, A>(
+    fx: Fx<R, E, A>,
+    concurrencyLevel: NonNegativeInteger,
+    __trace?: string,
+  ): Fx<R, E, A> {
+    return new SetConcurrencyLevel(fx, concurrencyLevel, __trace)
+  }
+}
+
+export class GetFiberRef<R, E, A> extends Instr<R, E, A> {
+  readonly tag = 'GetFiberRef'
+
+  constructor(readonly fiberRef: FiberRef<R, E, A>, __trace?: string) {
+    super(__trace)
+  }
+
+  static make<R, E, A>(fiberRef: FiberRef<R, E, A>, __trace?: string): Fx<R, E, A> {
+    return new GetFiberRef(fiberRef, __trace)
+  }
+}
+
+export class ModifyFiberRef<R, E, A, B> extends Instr<R, E, B> {
+  readonly tag = 'ModifyFiberRef'
+
+  constructor(
+    readonly fiberRef: FiberRef<R, E, A>,
+    readonly modify: (a: A) => readonly [B, A],
+    __trace?: string,
+  ) {
+    super(__trace)
+  }
+
+  static make<R, E, A, B>(
+    fiberRef: FiberRef<R, E, A>,
+    modify: (a: A) => readonly [B, A],
+    __trace?: string,
+  ): Fx<R, E, B> {
+    return new ModifyFiberRef(fiberRef, modify, __trace)
+  }
+}
+
+export class DeleteFiberRef<R, E, A, B> extends Instr<R, E, B> {
+  readonly tag = 'DeleteFiberRef'
+
+  constructor(readonly fiberRef: FiberRef<R, E, A>, __trace?: string) {
+    super(__trace)
+  }
+
+  static make<R, E, A>(fiberRef: FiberRef<R, E, A>, __trace?: string): Fx<R, E, Maybe<A>> {
+    return new DeleteFiberRef(fiberRef, __trace)
+  }
+}
+
+export class FiberRefLocally<R, E, A, R2, E2, B> extends Instr<R2, E2, B> {
+  readonly tag = 'FiberRefLocally'
+
+  constructor(
+    readonly fiberRef: FiberRef<R, E, A>,
+    readonly value: A,
+    readonly fx: Fx<R2, E2, B>,
+    __trace?: string,
+  ) {
+    super(__trace)
+  }
+
+  static make<R, E, A, R2, E2, B>(
+    fiberRef: FiberRef<R, E, A>,
+    value: A,
+    fx: Fx<R2, E2, B>,
+    __trace?: string,
+  ): Fx<R2, E2, B> {
+    return new FiberRefLocally(fiberRef, value, fx, __trace)
+  }
+}
+
+export class Fork<R, E, A> extends Instr<R, never, Live<E, A>> {
+  readonly tag = 'Fork'
+
+  constructor(readonly fx: Fx<R, E, A>, readonly context: FiberContext, readonly __trace?: string) {
+    super(__trace)
+  }
+
+  static make<R, E, A>(
+    fx: Fx<R, E, A>,
+    context: FiberContext,
+    __trace?: string,
+  ): Fx<R, never, Live<E, A>> {
+    return new Fork(fx, context, __trace) as any
+  }
+}
+
+export class BothFx<R, E, A, R2, E2, B> extends Instr<R | R2, E | E2, readonly [A, B]> {
+  readonly tag = 'Both'
+
+  constructor(
+    readonly first: Fx<R, E, A>,
+    readonly second: Fx<R2, E2, B>,
+    readonly __trace?: string,
+  ) {
+    super(__trace)
+  }
+
+  static make<R, E, A, R2, E2, B>(
+    first: Fx<R, E, A>,
+    second: Fx<R2, E2, B>,
+    __trace?: string,
+  ): Fx<R | R2, E | E2, readonly [A, B]> {
+    return new BothFx(first, second, __trace) as Fx<R | R2, E | E2, readonly [A, B]>
+  }
+}
+
+export class EitherFx<R, E, A, R2, E2, B> extends Instr<R | R2, E | E2, Either<A, B>> {
+  readonly tag = 'Either'
+
+  constructor(
+    readonly first: Fx<R, E, A>,
+    readonly second: Fx<R2, E2, B>,
+    readonly __trace?: string,
+  ) {
+    super(__trace)
+  }
+
+  static make<R, E, A, R2, E2, B>(
+    first: Fx<R, E, A>,
+    second: Fx<R2, E2, B>,
+    __trace?: string,
+  ): Fx<R | R2, E | E2, Either<A, B>> {
+    return new EitherFx(first, second, __trace) as any
+  }
+}

package/src/Fx/index.ts

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

package/src/Fx/join.ts

@@ -0,0 +1,17 @@
+import { Either } from 'hkt-ts'
+
+import { Fx, fromExit } from './Fx.js'
+
+// eslint-disable-next-line import/no-cycle
+import * as Fiber from '@/Fiber/Fiber.js'
+
+export const join = <E, A>(fiber: Fiber.Fiber<E, A>) =>
+  Fx(function* () {
+    const exit = yield* fiber.exit
+
+    if (Either.isRight(exit)) {
+      yield* Fiber.inheritFiberRefs(fiber)
+    }
+
+    return yield* fromExit(exit)
+  })

package/src/Fx/logging.ts

@@ -0,0 +1,69 @@
+import { pipe } from 'hkt-ts'
+
+import * as Fx from './Fx.js'
+
+import { CurrentLogAnnotations, CurrentLogSpans } from '@/FiberRef/FiberRef.js'
+import { LogAnnotation } from '@/Logger/LogAnnotation.js'
+import { LogLevel } from '@/Logger/LogLevel.js'
+import { LogSpan } from '@/Logger/LogSpan.js'
+
+const makeLogWithLevel = (level: LogLevel) => (msg: string, __trace?: string) =>
+  pipe(
+    Fx.Do,
+    Fx.bind('context', () => Fx.getFiberContext),
+    Fx.bind('spans', () => Fx.getFiberRef(CurrentLogSpans)),
+    Fx.bind('annotations', () => Fx.getFiberRef(CurrentLogAnnotations)),
+    Fx.flatMap(
+      ({ context, spans, annotations }) =>
+        context.logger.log(
+          msg,
+          level,
+          context.id,
+          Array.from(spans.values()),
+          Array.from(annotations.values()),
+        ),
+      __trace,
+    ),
+  )
+
+export const logDebug = makeLogWithLevel(LogLevel.Debug)
+export const logTrace = makeLogWithLevel(LogLevel.Trace)
+export const logInfo = makeLogWithLevel(LogLevel.Info)
+export const log = makeLogWithLevel(LogLevel.Log)
+export const logWarn = makeLogWithLevel(LogLevel.Warn)
+export const logError = makeLogWithLevel(LogLevel.Error)
+export const logFatal = makeLogWithLevel(LogLevel.Fatal)
+
+export const span =
+  (label: string) =>
+  <R, E, A>(fx: Fx.Fx<R, E, A>) =>
+    pipe(
+      Fx.Do,
+      Fx.bind('spans', () => Fx.getFiberRef(CurrentLogSpans)),
+      Fx.bind('context', () => Fx.getFiberContext),
+      Fx.flatMap(({ spans, context }) =>
+        pipe(
+          fx,
+          Fx.fiberRefLocally(
+            CurrentLogSpans,
+            spans.set(label, LogSpan(label, context.platform.timer.getCurrentTime())),
+          ),
+        ),
+      ),
+    )
+
+export const annotate =
+  (label: string, value: string) =>
+  <R, E, A>(fx: Fx.Fx<R, E, A>) =>
+    pipe(
+      Fx.getFiberRef(CurrentLogAnnotations),
+      Fx.flatMap((annotations) =>
+        pipe(
+          fx,
+          Fx.fiberRefLocally(
+            CurrentLogAnnotations,
+            annotations.set(label, LogAnnotation(label, value)),
+          ),
+        ),
+      ),
+    )

package/src/Fx/scoped.ts

@@ -0,0 +1,77 @@
+import { pipe } from 'hkt-ts/function'
+
+import {
+  Fx,
+  ask,
+  ensuring,
+  getEnv,
+  getFiberContext,
+  provide,
+  provideService,
+  uninterruptable,
+} from './Fx.js'
+
+import { ConcurrentStrategy, FinalizationStrategy } from '@/Finalizer/Finalizer.js'
+import { Scope } from '@/Scope/Scope.js'
+
+/**
+ * Run a Scoped Fx within an isolated Scope, cleaning up those resources as soon as complete.
+ */
+export function scoped<R, E, A>(
+  scoped: Fx<R | Scope, E, A>,
+  strategy: FinalizationStrategy = ConcurrentStrategy,
+): Fx<Exclude<R, Scope>, E, A> {
+  return Fx(function* () {
+    const { scope: fiberScope } = yield* getFiberContext
+    const scope = fiberScope.fork(strategy)
+
+    return yield* pipe(scoped, provideService(Scope, scope), ensuring(scope.close))
+  })
+}
+
+/**
+ * Track a Resource within a given Scoped environment
+ */
+export function managed<R, E, A, R2>(
+  acquire: Fx<R, E, A>,
+  release: (value: A) => Fx<R2, never, any>,
+): Fx<R | R2 | Scope, E, A> {
+  return uninterruptable(
+    Fx(function* () {
+      const scope = yield* ask(Scope)
+      const env = yield* getEnv<R | R2>()
+
+      const a = yield* acquire
+
+      scope.ensuring(() => pipe(a, release, provide(env)))
+
+      return a
+    }),
+  )
+}
+
+/**
+ * Perform an effect with an aquired resource with the release of that resource.
+ */
+export function bracket<R, E, A, R2, E2, B, R3>(
+  acquire: Fx<R, E, A>,
+  withResource: (a: A) => Fx<R2, E2, B>,
+  release: (a: A) => Fx<R3, never, unknown>,
+): Fx<Scope | R | R2 | R3, E | E2, B> {
+  return Fx(function* () {
+    const a: A = yield* managed(acquire, release)
+
+    return yield* withResource(a)
+  })
+}
+
+/**
+ * Run a Scoped Fx within an isolated Scope, cleaning up those resources as soon as complete.
+ */
+export function fiberScoped<R, E, A>(scoped: Fx<R | Scope, E, A>): Fx<Exclude<R, Scope>, E, A> {
+  return Fx(function* () {
+    const { scope } = yield* getFiberContext
+
+    return yield* pipe(scoped, provideService(Scope, scope))
+  })
+}

package/src/ImmutableMap/ImmutableMap.ts

@@ -0,0 +1,55 @@
+import { Just, Maybe, Nothing } from 'hkt-ts/Maybe'
+
+/**
+ * ImmutableMap is a small wrapper around ReadonlyMap that makes it a little
+ * easier to deal wih immutable data.
+ */
+export interface ImmutableMap<K, V> extends Iterable<readonly [K, V]> {
+  readonly has: (key: K) => boolean
+  readonly get: (key: K) => Maybe<V>
+  readonly set: (key: K, value: V) => ImmutableMap<K, V>
+  readonly remove: (key: K) => ImmutableMap<K, V>
+  readonly keys: () => Iterable<K>
+  readonly values: () => Iterable<V>
+}
+
+export function ImmutableMap<K, V>(cache: ReadonlyMap<K, V> = new Map()): ImmutableMap<K, V> {
+  return new ImmutableMapImpl<K, V>(cache)
+}
+
+class ImmutableMapImpl<K, V> implements ImmutableMap<K, V> {
+  constructor(readonly cache: ReadonlyMap<K, V> = new Map()) {}
+
+  readonly has = (key: K) => this.cache.has(key)
+
+  /**
+   * Retrieves the current value of the key, if it exists.
+   */
+  readonly get = (key: K): Maybe<V> => {
+    // Attempt to get the value from the cache
+    if (this.cache.has(key)) {
+      return Just(this.cache.get(key) as V)
+    }
+
+    return Nothing
+  }
+
+  /**
+   * Sets the value of the key, returning a new ImmutableMap with the new value.
+   */
+  readonly set = (key: K, value: V): ImmutableMap<K, V> =>
+    ImmutableMap(new Map([...this.cache, [key, value]]))
+
+  /**
+   * Removes the key from the map, returning a new ImmutableMap with the key removed.
+   */
+  readonly remove = (key: K): ImmutableMap<K, V> =>
+    ImmutableMap(new Map([...this.cache].filter(([k]) => k !== key)));
+
+  *[Symbol.iterator]() {
+    return yield* this.cache
+  }
+
+  readonly keys = () => this.cache.keys()
+  readonly values = () => this.cache.values()
+}

package/src/ImmutableMap/index.ts

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