@typed/fx 0.0.8 → 0.0.9

package/src/Fx/Instruction.ts

@@ -1,511 +0,0 @@
-import { Either, Left, Right } 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 { FiberId } from '@/FiberId/FiberId.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> =
-  | AddTrace<R, E, A>
-  | BothFx<R, E, A>
-  | DeleteFiberRef<R, E, any, A>
-  | EitherFx<R, E, A>
-  | FiberRefLocally<any, any, any, R, E, A>
-  | FlatMap<R, E, any, R, E, A>
-  | Fork<R, E, A>
-  | FromCause<E>
-  | FromLazy<A>
-  | GetEnv<R, E, A>
-  | GetFiberContext
-  | GetFiberRef<R, E, A>
-  | GetInterruptStatus
-  | GetTrace
-  | LazyFx<R, E, A>
-  | MapFx<R, E, any, A>
-  | Match<R, any, any, R, E, A, R, E, A>
-  | ModifyFiberRef<R, E, any, A>
-  | Now<A>
-  | Provide<any, E, A>
-  | Provide<never, E, A>
-  | ProvideLayer<R, E, A, R, E, any>
-  | ProvideService<R, E, A, 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<out R, out E, out 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, any> {
-    return yield this
-  }
-}
-
-export class Now<out 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<out 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<out 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<out R, out E, in out A, out 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
-
-    // Eagerly evaluate the function to runtime cost. Stack unsafe.
-    if (prev.tag === 'Now') {
-      return Now.make(f(prev.value), __trace)
-    }
-
-    // Map cannot process failures
-    if (prev.tag === 'FromCause') {
-      return prev
-    }
-
-    // Fuse together multiple maps.
-    if (prev.tag === 'Map') {
-      return MapFx.make(prev.fx, flow(prev.f, f), __trace)
-    }
-
-    return new MapFx(fx, f, __trace)
-  }
-}
-
-export class FlatMap<out R, out E, in out A, out R2, out E2, out 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
-
-    // Flatmap cannot process failures
-    if (prev.tag === 'FromCause') {
-      return prev
-    }
-
-    // Fuse together Map + FlatMap into a single FlatMap.
-    if (prev.tag === 'Map') {
-      return FlatMap.make(prev.fx, flow(prev.f, f), __trace)
-    }
-
-    return new FlatMap(fx, f, __trace)
-  }
-}
-
-export class Match<
-  out R,
-  in out E,
-  in out A,
-  out R2,
-  out E2,
-  out B,
-  out R3,
-  out E3,
-  out 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
-
-    // Fuse together Map + Match
-    if (prev.tag === 'Map') {
-      return Match.make(prev.fx, onLeft, flow(prev.f, onRight), __trace)
-    }
-
-    return new Match(fx, onLeft, onRight, __trace)
-  }
-}
-
-export class GetEnv<out R, out E, out A> extends Instr<R, E, A> {
-  readonly tag = 'GetEnv'
-
-  static make<R>(__trace?: string): Fx<R, never, Env<R>> {
-    return new GetEnv<R, never, Env<R>>(__trace)
-  }
-}
-
-export class Provide<out R, out E, out 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<any, any, any>, 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<FiberId.Live>> {
-  readonly tag = 'GetFiberContext'
-
-  static make = (__trace?: string): Fx<never, never, FiberContext<FiberId.Live>> =>
-    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<any, any, any>, __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, E, A> {
-  readonly tag = 'Fork'
-
-  constructor(
-    readonly fx: Fx<any, any, any>,
-    readonly context: FiberContext<FiberId.Live>,
-    readonly __trace?: string,
-  ) {
-    super(__trace)
-  }
-
-  static make<R, E, A>(
-    fx: Fx<R, E, A>,
-    context: FiberContext<FiberId.Live>,
-    __trace?: string,
-  ): Fx<R, never, Live<E, A>> {
-    return new Fork(fx, context, __trace)
-  }
-}
-
-export class BothFx<R, E, A> extends Instr<R, E, A> {
-  readonly tag = 'Both'
-
-  constructor(
-    readonly first: Fx<any, any, any>,
-    readonly second: Fx<any, any, any>,
-    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]> {
-    // Any Failures cannot be combined into a tuple of success values
-    if (first.instr.tag === 'FromCause') {
-      return first.instr
-    }
-    if (second.instr.tag === 'FromCause') {
-      return second.instr
-    }
-
-    return new BothFx(first, second, __trace)
-  }
-}
-
-export class EitherFx<R, E, A> extends Instr<R, E, A> {
-  readonly tag = 'Either'
-
-  constructor(
-    readonly first: Fx<any, any, any>,
-    readonly second: Fx<any, any, any>,
-    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>> {
-    const fi = first.instr
-
-    if (fi.tag === 'Now') {
-      return Now.make(Left(fi.value), __trace)
-    }
-
-    const si = second.instr
-
-    if (si.tag === 'Now') {
-      return Now.make(Right(si.value), __trace)
-    }
-
-    if (fi.tag === 'FromCause') {
-      return fi
-    }
-
-    if (si.tag === 'FromCause') {
-      return si
-    }
-
-    return new EitherFx(first, second, __trace)
-  }
-}

package/src/Fx/fromLayer.ts

@@ -1,8 +0,0 @@
-import * as Fx from './Fx.js'
-
-import { Layer } from '@/Layer/Layer.js'
-import { Scope } from '@/Scope/Scope.js'
-
-export function fromLayer<R, E, A>(layer: Layer<R, E, A>): Fx.Fx<R | Scope, E, A> {
-  return Fx.flatMap(layer.build)(Fx.ask(Scope))
-}

package/src/Fx/index.ts

@@ -1,7 +0,0 @@
-export * from './fromLayer.js'
-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/join.ts

@@ -1,30 +0,0 @@
-import { pipe } from 'hkt-ts'
-
-import * as Fx from './Fx.js'
-
-import * as Fiber from '@/Fiber/Fiber.js'
-import { FiberContext } from '@/FiberContext/FiberContext.js'
-import { FiberId } from '@/FiberId/FiberId.js'
-import { Scope } from '@/Scope/Scope.js'
-
-export const join = <E, A>(fiber: Fiber.Fiber<E, A>) =>
-  pipe(
-    fiber.exit,
-    Fx.flatMap((exit) =>
-      pipe(
-        Fiber.inheritFiberRefs(fiber),
-        Fx.flatMap(() => Fx.fromExit(exit)),
-      ),
-    ),
-  )
-
-export const forkJoinInContext =
-  (context: FiberContext<FiberId.Live>) =>
-  <R, E, A>(fx: Fx.Fx<R, E, A>): Fx.Fx<R, E, A> =>
-    pipe(fx, Fx.forkInContext(context), Fx.flatMap(join))
-
-export const forkJoinIn = <R, E, A>(fx: Fx.Fx<R, E, A>, scope: Scope): Fx.Fx<R, E, A> =>
-  pipe(fx, Fx.forkIn(scope), Fx.flatMap(join))
-
-export const forkJoin = <R, E, A>(fx: Fx.Fx<R, E, A>): Fx.Fx<R, E, A> =>
-  pipe(fx, Fx.fork, Fx.flatMap(join))

package/src/Fx/logging.ts

@@ -1,72 +0,0 @@
-import { pipe } from 'hkt-ts'
-
-import * as Fx from './Fx.js'
-
-import { CurrentLogAnnotations, CurrentLogSpans } from '@/FiberRef/builtins.js'
-import { LogAnnotation } from '@/Logger/LogAnnotation.js'
-import { LogLevel } from '@/Logger/LogLevel.js'
-import { LogSpan } from '@/Logger/LogSpan.js'
-import { EmptyTrace, Trace } from '@/Trace/Trace.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.bind('trace', () => (level >= LogLevel.Trace ? Fx.getTrace : Fx.now<Trace>(EmptyTrace))),
-    Fx.flatMap(
-      ({ context, spans, annotations, trace }) =>
-        context.logger.log(
-          msg,
-          level,
-          context.id,
-          Array.from(spans.values()),
-          Array.from(annotations.values()),
-          trace,
-        ),
-      __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/run.ts

@@ -1,33 +0,0 @@
-import { pipe } from 'hkt-ts'
-
-import { Of, getFiberContext, map } from './Fx.js'
-
-import { Atomic } from '@/Atomic/index.js'
-import { AnyLiveFiber } from '@/Fiber/Fiber.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'
-import { trackIn } from '@/Supervisor/trackIn.js'
-
-export const RootFibers = Atomic<ReadonlyMap<FiberId.Live, AnyLiveFiber>>(new Map())
-export const MainSupervisor = trackIn(RootFibers)
-export const MainPlatform = Platform()
-export const MainRuntime = Runtime(
-  FiberContext({
-    platform: MainPlatform,
-    id: FiberId.None,
-    scope: GlobalScope,
-    supervisor: MainSupervisor,
-  }),
-)
-
-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 })),
-  )
-}