@typed/fx 0.0.6 → 0.0.9

package/src/Exit/Exit.ts

@@ -1,50 +0,0 @@
-import { pipe } from 'hkt-ts'
-import * as Either from 'hkt-ts/Either'
-import { Associative } from 'hkt-ts/Typeclass'
-import { Eq } from 'hkt-ts/Typeclass/Eq'
-import { Identity } from 'hkt-ts/Typeclass/Identity'
-
-import * as Cause from '@/Cause/Cause.js'
-import type * as FiberId from '@/FiberId/FiberId.js'
-
-export type Exit<E, A> = Either.Either<Cause.Cause<E>, A>
-
-export type AnyExit = Exit<any, any>
-
-export const success = <A>(value: A): Exit<never, A> => Either.Right(value)
-
-export const interrupt = (fiberId: FiberId.FiberId): Exit<never, never> =>
-  Either.Left(Cause.interrupted(fiberId))
-
-export const unexpected = (error: unknown): Exit<never, never> =>
-  Either.Left(Cause.unexpected(error))
-
-export const expected = <E>(error: E): Exit<E, never> => Either.Left(Cause.expected(error))
-
-export const fromEither = <E, A>(either: Either.Either<E, A>): Exit<E, A> =>
-  pipe(
-    either,
-    Either.mapLeft((e) => Cause.expected(e)),
-  )
-
-export const makeParallelAssociative = <A, E = never>(
-  A: Associative.Associative<A>,
-): Associative.Associative<Exit<E, A>> =>
-  Either.makeAssociative(Cause.makeParallelAssociative<E>(), A)
-
-export const makeSequentialAssociative = <A, E = never>(
-  A: Associative.Associative<A>,
-): Associative.Associative<Exit<E, A>> =>
-  Either.makeAssociative(Cause.makeSequentialAssociative<E>(), A)
-
-export const makeParallelIdentity = <A, E = never>(A: Identity<A>): Identity<Exit<E, A>> =>
-  Either.makeIdentity(Cause.makeParallelAssociative<E>(), A)
-
-export const makeSequentialIdentity = <A, E = never>(A: Identity<A>): Identity<Exit<E, A>> =>
-  Either.makeIdentity(Cause.makeSequentialAssociative<E>(), A)
-
-export const makeParallelBottom = <E>() => Either.makeBottom(Cause.makeParallelIdentity<E>())
-export const makeSequentialBottom = <E>() => Either.makeBottom(Cause.makeSequentialIdentity<E>())
-
-export const makeEq = <E, A>(E: Eq<E>, A: Eq<A>): Eq<Exit<E, A>> =>
-  Either.makeEq(Cause.makeEq(E), A)

package/src/Exit/hkt.ts

@@ -1,44 +0,0 @@
-import { HKT2, Params, Variance, flow, pipe } from 'hkt-ts'
-import * as Either from 'hkt-ts/Either'
-import * as B from 'hkt-ts/Typeclass/Bicovariant'
-import { Bottom2 } from 'hkt-ts/Typeclass/Bottom'
-import * as C from 'hkt-ts/Typeclass/Covariant'
-import { Top2 } from 'hkt-ts/Typeclass/Top'
-
-import { Exit } from './Exit.js'
-
-import * as Cause from '@/Cause/index.js'
-
-export interface ExitHKT extends HKT2 {
-  readonly type: Exit<this[Params.E], this[Params.A]>
-  readonly defaults: {
-    readonly [Params.E]: Variance.Covariant<unknown>
-    readonly [Params.A]: Variance.Covariant<unknown>
-  }
-}
-
-export const Bicovariant: B.Bicovariant2<ExitHKT> = {
-  bimap: (f, g) => (exit) =>
-    pipe(exit, Either.match(flow(Cause.map(f), Either.Left), flow(g, Either.Right))),
-}
-
-export const bimap = Bicovariant.bimap
-export const mapLeft = B.mapLeft(Bicovariant)
-export const map = B.map(Bicovariant)
-
-export const Covariant: C.Covariant2<ExitHKT> = {
-  map,
-}
-
-export const bindTo = C.bindTo(Covariant)
-export const flap = C.flap(Covariant)
-export const mapTo = C.mapTo(Covariant)
-export const tupled = C.tupled(Covariant)
-
-export const Top = Either.Top as Top2<ExitHKT>
-export const top = Top.top
-
-export const Bottom: Bottom2<ExitHKT> = {
-  bottom: Either.Left(Cause.Empty),
-}
-export const bottom = Bottom.bottom

package/src/Exit/index.ts

@@ -1,2 +0,0 @@
-export * from './Exit.js'
-export * from './hkt.js'

package/src/Fiber/Fiber.ts

@@ -1,86 +0,0 @@
-import { flow, pipe } from 'hkt-ts/function'
-
-import type { Exit } from '@/Exit/Exit.js'
-import type { FiberContext } from '@/FiberContext/FiberContext.js'
-import type { FiberId } from '@/FiberId/FiberId.js'
-import { join } from '@/FiberRefs/FiberRefs.js'
-import type { FiberStatus } from '@/FiberStatus/index.js'
-import { Of, flatMap, fork, fromExit, getFiberContext, map } from '@/Fx/Fx.js'
-import type { Trace } from '@/Trace/Trace.js'
-
-export type Fiber<E, A> = Live<E, A> | Synthetic<E, A>
-
-export type AnyFiber = Fiber<any, any> | Fiber<never, never> | Fiber<any, never> | Fiber<never, any>
-
-/* eslint-disable @typescript-eslint/no-unused-vars */
-export type ErrorsOf<T> = [T] extends [Fiber<infer E, infer _A>] ? E : never
-
-export type OutputOf<T> = [T] extends [Fiber<infer _E, infer A>] ? A : never
-/* eslint-enable @typescript-eslint/no-unused-vars */
-
-export interface Live<E, A> {
-  readonly tag: 'Live'
-  readonly id: FiberId.Live
-  readonly context: FiberContext
-  readonly status: Of<FiberStatus>
-  readonly exit: Of<Exit<E, A>>
-  readonly trace: Of<Trace>
-  readonly interruptAs: (id: FiberId) => Of<Exit<E, A>>
-}
-
-export type AnyLiveFiber = Live<any, any> | Live<never, never> | Live<any, never> | Live<never, any>
-
-export const Live = <E, A>(params: Omit<Live<E, A>, 'tag'>): Fiber<E, A> => ({
-  tag: 'Live',
-  ...params,
-})
-
-export interface Synthetic<E, A> {
-  readonly tag: 'Synthetic'
-  readonly id: FiberId
-  readonly exit: Of<Exit<E, A>>
-  readonly inheritFiberRefs: Of<void>
-  readonly interruptAs: (id: FiberId) => Of<Exit<E, A>>
-}
-
-export const Synthetic = <E, A>(params: Omit<Synthetic<E, A>, 'tag'>): Fiber<E, A> => ({
-  tag: 'Synthetic',
-  ...params,
-})
-
-export const match =
-  <E, A, B, C>(onLive: (live: Live<E, A>) => B, onSynthetic: (synthetic: Synthetic<E, A>) => C) =>
-  (fiber: Fiber<E, A>) =>
-    fiber.tag === 'Live' ? onLive(fiber) : onSynthetic(fiber)
-
-export const inheritFiberRefs = <E, A>(fiber: Fiber<E, A>): Of<void> =>
-  pipe(
-    fiber,
-    match(
-      (l) =>
-        pipe(
-          getFiberContext,
-          map((c) => join(c.fiberRefs, l.context.fiberRefs)),
-        ),
-      (s) => s.inheritFiberRefs,
-    ),
-  )
-
-export const interruptAs =
-  (id: FiberId) =>
-  <E, A>(fiber: Fiber<E, A>) =>
-    fiber.interruptAs(id)
-
-export const interruptAsFork = (id: FiberId) => flow(interruptAs(id), flatMap(fromExit), fork)
-
-export const interrupt = <E, A>(fiber: Fiber<E, A>) =>
-  pipe(
-    getFiberContext,
-    flatMap(({ id }) => interruptAs(id)(fiber)),
-  )
-
-export const interruptFork = <E, A>(fiber: Fiber<E, A>) =>
-  pipe(
-    getFiberContext,
-    flatMap(({ id }) => interruptAsFork(id)(fiber)),
-  )

package/src/Fiber/fromExit.ts

@@ -1,14 +0,0 @@
-import { Fiber, Synthetic } from './Fiber.js'
-
-import { Exit } from '@/Exit/Exit.js'
-import { FiberId } from '@/FiberId/FiberId.js'
-import { now, unit } from '@/Fx/index.js'
-
-export function fromExit<E, A>(exit: Exit<E, A>): Fiber<E, A> {
-  return Synthetic({
-    id: new FiberId.Synthetic([]),
-    exit: now(exit),
-    inheritFiberRefs: unit,
-    interruptAs: () => now(exit),
-  })
-}

package/src/Fiber/fromScope.ts

@@ -1,19 +0,0 @@
-import { pipe } from 'hkt-ts'
-
-import { Synthetic } from './Fiber.js'
-
-import { FiberId } from '@/FiberId/FiberId.js'
-import { Closeable, closeOrWait, wait } from '@/Scope/Closeable.js'
-import { Exit, FiberRefs, Fx } from '@/index.js'
-
-export function fromScope(id: FiberId, fiberRefs: FiberRefs.FiberRefs, scope: Closeable) {
-  return Synthetic({
-    id,
-    exit: wait(scope),
-    inheritFiberRefs: pipe(
-      Fx.getFiberRefs,
-      Fx.flatMap((refs) => Fx.fromLazy(() => FiberRefs.join(refs, fiberRefs))),
-    ),
-    interruptAs: (id) => closeOrWait(scope)(Exit.interrupt(id)),
-  })
-}

package/src/Fiber/hkt.ts

@@ -1,125 +0,0 @@
-import { makeAssociative } from 'hkt-ts/Array'
-import { HKT2, Params } from 'hkt-ts/HKT'
-import * as AB from 'hkt-ts/Typeclass/AssociativeBoth'
-import * as B from 'hkt-ts/Typeclass/Bicovariant'
-import { Bottom2 } from 'hkt-ts/Typeclass/Bottom'
-import { CommutativeBoth2 } from 'hkt-ts/Typeclass/CommutativeBoth'
-import * as C from 'hkt-ts/Typeclass/Covariant'
-import * as IB from 'hkt-ts/Typeclass/IdentityBoth'
-import { Top2 } from 'hkt-ts/Typeclass/Top'
-import { flow, pipe } from 'hkt-ts/function'
-
-import { Fiber, Synthetic, inheritFiberRefs } from './Fiber.js'
-import { fromExit } from './fromExit.js'
-
-import * as Exit from '@/Exit/index.js'
-import * as FiberId from '@/FiberId/FiberId.js'
-import * as Fx from '@/Fx/Fx.js'
-
-export interface FiberHKT extends HKT2 {
-  readonly type: Fiber<this[Params.E], this[Params.A]>
-}
-
-export const Bicovariant: B.Bicovariant2<FiberHKT> = {
-  bimap: (f, g) => (fiber) =>
-    Synthetic({
-      id: FiberId.Synthetic([fiber.id]),
-      exit: pipe(fiber.exit, Fx.map(Exit.bimap(f, g))),
-      inheritFiberRefs: inheritFiberRefs(fiber),
-      interruptAs: flow(fiber.interruptAs, Fx.map(Exit.bimap(f, g))),
-    }),
-}
-
-export const bimap = Bicovariant.bimap
-export const mapLeft = B.mapLeft(Bicovariant)
-export const map = B.map(Bicovariant)
-
-export const Covariant: C.Covariant2<FiberHKT> = {
-  map,
-}
-
-export const bindTo = C.bindTo(Covariant)
-export const flap = C.flap(Covariant)
-export const mapTo = C.mapTo(Covariant)
-export const tupled = C.tupled(Covariant)
-
-export const Top: Top2<FiberHKT> = {
-  top: fromExit(Exit.top),
-}
-export const top = Top.top
-
-export const Bottom: Bottom2<FiberHKT> = {
-  bottom: fromExit(Exit.bottom),
-}
-export const bottom = Bottom.bottom
-
-const concatExitSeq = Exit.makeSequentialAssociative<any, any>(makeAssociative<any>()).concat
-
-export const AssociativeBoth: AB.AssociativeBoth2<FiberHKT> = {
-  both: (fb) => (fa) =>
-    Synthetic({
-      id: FiberId.Synthetic([fa.id, fb.id]),
-      exit: pipe(
-        Fx.zipAllSeq([fa.exit, fb.exit]),
-        Fx.flatMap(([ea, eb]) => Fx.now(concatExitSeq(Exit.tupled(ea), Exit.tupled(eb)))),
-      ),
-      inheritFiberRefs: pipe(
-        inheritFiberRefs(fa),
-        Fx.flatMap(() => inheritFiberRefs(fb)),
-      ),
-      interruptAs: (id) =>
-        pipe(
-          Fx.zipAllSeq([fa.interruptAs(id), fb.interruptAs(id)]),
-          Fx.map(([ea, eb]) => concatExitSeq(Exit.tupled(ea), Exit.tupled(eb))),
-        ),
-    }),
-}
-
-export const bothSeq = AssociativeBoth.both
-
-export const zipLeftSeq = AB.zipLeft<FiberHKT>({ ...AssociativeBoth, ...Covariant })
-export const zipRightSeq = AB.zipRight<FiberHKT>({ ...AssociativeBoth, ...Covariant })
-
-const concatExitPar = Exit.makeParallelAssociative<any, any>(makeAssociative<any>()).concat
-
-export const CommutativeBoth: CommutativeBoth2<FiberHKT> = {
-  both: (fb) => (fa) =>
-    Synthetic({
-      id: FiberId.Synthetic([fa.id, fb.id]),
-      exit: pipe(
-        Fx.zipAll([fa.exit, fb.exit]),
-        Fx.flatMap(([ea, eb]) => Fx.now(concatExitPar(Exit.tupled(ea), Exit.tupled(eb)))),
-      ),
-      inheritFiberRefs: pipe(
-        inheritFiberRefs(fa),
-        Fx.flatMap(() => inheritFiberRefs(fb)),
-      ),
-      interruptAs: (id) =>
-        pipe(
-          Fx.zipAll([fa.interruptAs(id), fb.interruptAs(id)]),
-          Fx.map(([ea, eb]) => concatExitPar(Exit.tupled(ea), Exit.tupled(eb))),
-        ),
-    }),
-}
-
-export const both = CommutativeBoth.both
-export const zipLeft = AB.zipLeft<FiberHKT>({ ...CommutativeBoth, ...Covariant })
-export const zipRight = AB.zipRight<FiberHKT>({ ...CommutativeBoth, ...Covariant })
-
-export const IdentityBothSeq: IB.IdentityBoth2<FiberHKT> = {
-  ...AssociativeBoth,
-  ...Top,
-}
-
-export const tupleSeq = IB.tuple<FiberHKT>({ ...IdentityBothSeq, ...Covariant })
-export const structSeq = IB.struct<FiberHKT>({ ...IdentityBothSeq, ...Covariant })
-
-export const IdentityBothPar: IB.IdentityBoth2<FiberHKT> = {
-  ...CommutativeBoth,
-  ...Top,
-}
-
-export const tuple = IB.tuple<FiberHKT>({ ...IdentityBothPar, ...Covariant })
-export const struct = IB.struct<FiberHKT>({ ...IdentityBothPar, ...Covariant })
-
-// TODO: More Typeclass instances

package/src/Fiber/index.ts

@@ -1,2 +0,0 @@
-export * from './Fiber.js'
-export * from './hkt.js'

package/src/FiberContext/FiberContext.ts

@@ -1,68 +0,0 @@
-import { Just, Maybe, Nothing } from 'hkt-ts/Maybe'
-
-import * as FiberId from '@/FiberId/FiberId.js'
-import { FiberRefs } from '@/FiberRefs/FiberRefs.js'
-import { SequentialStrategy } from '@/Finalizer/Finalizer.js'
-import { Console } from '@/Logger/Console.js'
-import { Logger } from '@/Logger/Logger.js'
-import { Platform } from '@/Platform/Platform.js'
-import { Closeable } from '@/Scope/Closeable.js'
-import { LocalScope } from '@/Scope/LocalScope.js'
-import { None, Supervisor } from '@/Supervisor/Supervisor.js'
-
-export interface FiberContext<Id extends FiberId.FiberId = FiberId.FiberId> {
-  readonly id: Id
-  readonly platform: Platform
-  readonly fiberRefs: FiberRefs
-  readonly scope: Closeable
-  readonly supervisor: Supervisor<any>
-  readonly logger: Logger<string, any>
-  readonly parent: Maybe<FiberContext>
-
-  readonly fork: <Id2 extends FiberId.FiberId = FiberId.Live>(
-    overrides?: Partial<FiberContext<Id2>>,
-  ) => FiberContext<Id2>
-}
-
-export function FiberContext<Id extends FiberId.FiberId = FiberId.Live>(
-  params: Partial<Omit<FiberContext<Id>, 'fork'>> = {},
-): FiberContext<Id> {
-  const {
-    platform = Platform(),
-    id = FiberId.Live(platform) as Id,
-    fiberRefs = FiberRefs(),
-    scope = new LocalScope(SequentialStrategy),
-    supervisor = None,
-    logger = Console,
-    parent = Nothing,
-  } = params
-
-  const context: FiberContext<Id> = {
-    id,
-    platform,
-    fiberRefs,
-    scope,
-    supervisor,
-    logger,
-    parent,
-    fork: ((overrides?: Partial<FiberContext>) =>
-      fork(context, overrides)) as FiberContext<Id>['fork'],
-  }
-
-  return context
-}
-
-export function fork<Id extends FiberId.FiberId = FiberId.Live, Id2 extends FiberId.FiberId = Id>(
-  context: FiberContext<Id>,
-  overrides?: Partial<Omit<FiberContext<Id2>, 'fork'>>,
-): FiberContext<Id2> {
-  return FiberContext({
-    id: (overrides?.id ?? FiberId.Live(context.platform)) as Id2,
-    platform: overrides?.platform ?? context.platform.fork(),
-    fiberRefs: overrides?.fiberRefs ?? context.fiberRefs.fork(),
-    scope: overrides?.scope ?? context.scope.fork(),
-    supervisor: overrides?.supervisor ?? context.supervisor,
-    logger: overrides?.logger ?? context.logger,
-    parent: overrides?.parent ?? Just(context),
-  })
-}

package/src/FiberContext/index.ts

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

package/src/FiberId/FiberId.ts

@@ -1,122 +0,0 @@
-import { pipe } from 'hkt-ts'
-import * as A from 'hkt-ts/Array'
-import * as ASC from 'hkt-ts/Typeclass/Associative'
-import * as D from 'hkt-ts/Typeclass/Debug'
-import * as E from 'hkt-ts/Typeclass/Eq'
-import * as I from 'hkt-ts/Typeclass/Identity'
-import * as O from 'hkt-ts/Typeclass/Ord'
-import * as N from 'hkt-ts/number'
-import * as S from 'hkt-ts/string'
-
-import { increment } from '@/Atomic/AtomicCounter.js'
-import { Clock, timeToDate } from '@/Clock/Clock.js'
-import type { Platform } from '@/Platform/Platform.js'
-import { Time } from '@/Time/index.js'
-
-export type FiberId = FiberId.None | FiberId.Live | FiberId.Synthetic
-
-export namespace FiberId {
-  export interface None {
-    readonly tag: 'None'
-  }
-
-  export const None: None = { tag: 'None' }
-
-  export class Live {
-    static readonly tag = 'Live'
-    readonly tag = Live.tag
-    constructor(
-      readonly sequenceNumber: N.NonNegativeInteger, // Incrementing SequenceNumber guaranteeing uniqueness
-      readonly clock: Clock, // The Clock used to create FiberId
-      readonly startTime: Time, // The monotonic Time at which this Fiber started, relative to its Clock.
-    ) {}
-  }
-
-  export class Synthetic {
-    static readonly tag = 'Synthetic'
-    readonly tag = Synthetic.tag
-
-    constructor(readonly fiberIds: ReadonlyArray<FiberId>) {}
-  }
-}
-
-export const None = FiberId.None
-export type None = FiberId.None
-
-export type Live = FiberId.Live
-export const Live = ({ sequenceNumber, timer }: Platform): FiberId.Live =>
-  new FiberId.Live(increment(sequenceNumber), timer, timer.getCurrentTime())
-
-export type Synthetic = FiberId.Synthetic
-export const Synthetic = (fiberIds: ReadonlyArray<FiberId>): FiberId.Synthetic =>
-  new FiberId.Synthetic(fiberIds)
-
-export const match =
-  <A, B, C>(
-    onNone: () => A,
-    onLive: (id: FiberId.Live) => B,
-    onSynthetic: (id: FiberId.Synthetic) => C,
-  ) =>
-  (id: FiberId): A | B | C => {
-    switch (id.tag) {
-      case 'None':
-        return onNone()
-      case 'Live':
-        return onLive(id)
-      case 'Synthetic':
-        return onSynthetic(id)
-    }
-  }
-
-export const Eq: E.Eq<FiberId> = E.sum<FiberId>()('tag')({
-  None: E.struct({ tag: E.string }),
-  Live: E.struct({
-    tag: E.string,
-    sequenceNumber: N.NonNegativeIntegerEq,
-    startTime: Time.makeEq(N.Eq),
-  }),
-  Synthetic: E.struct({ tag: E.string, fiberIds: A.makeEq(E.lazy(() => Eq)) }),
-})
-
-export const Ord: O.Ord<FiberId> = O.sum<FiberId>()('tag')(
-  pipe(
-    N.Ord,
-    O.contramap((a) => (a === 'None' ? 0 : a === 'Live' ? 1 : 2)),
-  ),
-)({
-  None: O.struct<FiberId.None>({ tag: O.Static })(S.Ord),
-  Live: O.struct({
-    sequenceNumber: N.NonNegativeIntegerOrd,
-    startTime: Time.makeOrd(N.Ord),
-    tag: O.Static,
-  })(S.Ord),
-  Synthetic: O.struct<FiberId.Synthetic>({
-    fiberIds: A.makeOrd(O.lazy(() => Ord)),
-    tag: O.Static,
-  })(S.Ord),
-})
-
-export const Associative: ASC.Associative<FiberId> = {
-  concat: (f, s) => (f.tag === None.tag ? s : s.tag === None.tag ? f : Synthetic([f, s])),
-}
-
-export const Identity: I.Identity<FiberId> = {
-  ...Associative,
-  id: None,
-}
-
-export const Debug: D.Debug<FiberId> = D.sum<FiberId>()('tag')({
-  None: {
-    debug: () => 'FiberId.None',
-  },
-  Live: {
-    debug: (id) => `Fiber #${id.sequenceNumber} (started at ${idToIsoString(id)})`,
-  },
-  Synthetic: {
-    debug: (id) => `Synthetic Fiber\n  -${id.fiberIds.map(debug).join('\n  -')}`,
-  },
-})
-
-export const debug = Debug.debug
-
-const idToIsoString = (id: FiberId.Live) => timeToDate(id.startTime)(id.clock).toISOString()

package/src/FiberId/index.ts

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

package/src/FiberRef/FiberRef.ts

@@ -1,34 +0,0 @@
-import { Just, Maybe } from 'hkt-ts/Maybe'
-import { Second } from 'hkt-ts/Typeclass/Concat'
-import { DeepEquals, Eq } from 'hkt-ts/Typeclass/Eq'
-
-import { type Fx } from '@/Fx/Fx.js'
-
-export class FiberRef<R, E, A> {
-  constructor(
-    readonly initial: Fx<R, E, A>,
-    readonly fork: (a: A) => Maybe<A> = Just,
-    readonly join: (current: A, incoming: A) => A = Second.concat,
-    readonly Eq: Eq<A> = DeepEquals,
-  ) {}
-
-  static make = make
-}
-
-/* eslint-disable @typescript-eslint/no-unused-vars */
-export type ResourcesOf<T> = T extends FiberRef<infer _R, infer _E, infer _A> ? _R : never
-export type ErrorsOf<T> = T extends FiberRef<infer _R, infer _E, infer _A> ? _E : never
-export type OutputOf<T> = T extends FiberRef<infer _R, infer _E, infer _A> ? _A : never
-/* eslint-enable @typescript-eslint/no-unused-vars */
-
-export type AnyFiberRef = FiberRef<any, any, any>
-
-export function make<R, E, A>(initial: Fx<R, E, A>, params: Params<A> = {}): FiberRef<R, E, A> {
-  return new FiberRef(initial, params.fork, params.join, params.Eq)
-}
-
-export type Params<A> = {
-  readonly fork?: (a: A) => Maybe<A>
-  readonly join?: (current: A, incoming: A) => A
-  readonly Eq?: Eq<A>
-}