@typed/fx 0.0.8 → 0.0.9

package/src/FiberRef/builtins.ts

@@ -1,166 +0,0 @@
-import { Maybe, constant, identity, pipe } from 'hkt-ts'
-import { Nothing } from 'hkt-ts/Maybe'
-import { NonNegativeInteger } from 'hkt-ts/number'
-
-import { FiberRef, make } from './FiberRef.js'
-
-import type { Env } from '@/Env/Env.js'
-import { Live } from '@/Fiber/Fiber.js'
-import * as FiberRefs from '@/FiberRefs/FiberRefs.js'
-import * as Fx from '@/Fx/Fx.js'
-import { join } from '@/Fx/join.js'
-import { ImmutableMap } from '@/ImmutableMap/ImmutableMap.js'
-import { LogAnnotation } from '@/Logger/LogAnnotation.js'
-import { LogSpan } from '@/Logger/LogSpan.js'
-import { Semaphore } from '@/Semaphore/Semaphore.js'
-import { Service } from '@/Service/Service.js'
-import { Trace } from '@/Trace/Trace.js'
-
-export const CurrentEnv = make(
-  pipe(
-    Fx.getFiberContext,
-    Fx.map((c) => makeEnvFromFiberRefs(c.fiberRefs)),
-  ),
-  {
-    fork: constant(Nothing), // Always create a new Env for each Fiber.
-    join: identity, // Always keep the parent Fiber's Env
-  },
-)
-
-export function makeEnvFromFiberRefs<R>(fiberRefs: FiberRefs.FiberRefs): Env<R> {
-  // Always use a snapshot of the FiberRefs to avoid mutability problems.
-  const forked = FiberRefs.fork(fiberRefs)
-
-  return {
-    fiberRefs: forked,
-    get: getServiceFromFiberRefs(forked),
-    addService: addServiceFromFiberRefs(forked),
-    join: joinEnvFromFiberRefs(forked),
-  }
-}
-
-export const CurrentConcurrencyLevel = make(
-  Fx.fromLazy(() => new Semaphore(NonNegativeInteger(Infinity))),
-  {
-    join: identity, // Always keep the parent Fiber's concurrency level
-  },
-)
-
-export const CurrentInterruptStatus = make(Fx.now(true), {
-  join: identity, // Always keep the parent Fiber's interrupt status
-})
-
-export const CurrentTrace = make(
-  Fx.fromLazy<Trace>(() => Trace.runtime(new Error())),
-  {
-    join: identity, // Always keep the parent Fiber's trace
-  },
-)
-
-export const Layers = FiberRef.make(
-  Fx.fromLazy(() =>
-    ImmutableMap<Service<any>, readonly [() => Live<never, any>, Maybe.Maybe<Live<never, any>>]>(),
-  ),
-  {
-    join: identity, // Always keep the parent Fiber's layers
-  },
-)
-
-export const Services = FiberRef.make(
-  Fx.fromLazy(() => ImmutableMap<Service<any>, any>()),
-  {
-    join: identity, // Always keep the parent Fiber's services
-  },
-)
-
-export const CurrentLogSpans = FiberRef.make(
-  Fx.fromLazy(() => ImmutableMap<string, LogSpan>()),
-  {
-    join: identity,
-  },
-)
-
-export const CurrentLogAnnotations = FiberRef.make(
-  Fx.fromLazy(() => ImmutableMap<string, LogAnnotation>()),
-  {
-    join: identity,
-  },
-)
-
-export function getServiceFromFiberRefs(fiberRefs: FiberRefs.FiberRefs) {
-  return <S>(id: Service<S>): Fx.Of<S> => {
-    return Fx.lazy(() => {
-      const service = pipe(
-        fiberRefs,
-        FiberRefs.maybeGetFiberRefValue(Services),
-        Maybe.flatMap((s) => s.get(id)),
-      )
-
-      if (Maybe.isJust(service)) {
-        return Fx.success(service.value as S)
-      }
-
-      return getLayerFromFiberRefs(id, fiberRefs)
-    })
-  }
-}
-
-const getLayerFromFiberRefs = <S>(id: Service<S>, fiberRefs: FiberRefs.FiberRefs) =>
-  Fx.lazy(() => {
-    const layers = FiberRefs.maybeGetFiberRefValue(Layers)(fiberRefs)
-
-    // Add Layers if it is missing
-    if (Maybe.isNothing(layers)) {
-      throw new Error(`Unable to find Layer or Service for ${id.description}`)
-    }
-
-    const layer = layers.value.get(id)
-
-    if (Maybe.isNothing(layer)) {
-      throw new Error(`Unable to find Layer or Service for ${id.description}`)
-    }
-
-    const [makeFiber, currentFiber] = layer.value
-
-    if (Maybe.isJust(currentFiber)) {
-      return pipe(currentFiber.value.exit, Fx.flatMap(Fx.fromExit))
-    }
-
-    const fiber = makeFiber()
-
-    FiberRefs.setFiberRef(Layers, layers.value.set(id, [makeFiber, Maybe.Just(fiber)]))(fiberRefs)
-
-    return join(fiber)
-  })
-
-export function addServiceFromFiberRefs<R>(fiberRefs: FiberRefs.FiberRefs): Env<R>['addService'] {
-  return (id, impl) => {
-    const forked = fiberRefs.fork()
-
-    // AddService
-    FiberRefs.setFiberRef(
-      Services,
-      pipe(
-        forked,
-        FiberRefs.maybeGetFiberRefValue(Services),
-        Maybe.match(
-          () => ImmutableMap<Service<any>, any>().set(id, impl),
-          (s) => s.set(id, impl),
-        ),
-      ),
-    )(forked)
-
-    return makeEnvFromFiberRefs(forked)
-  }
-}
-
-export function joinEnvFromFiberRefs<R>(fiberRefs: FiberRefs.FiberRefs): Env<R>['join'] {
-  return (other) => {
-    const forked = other.fiberRefs.fork()
-
-    // Reverse the order to ensure incoming values take precedence for Services + Layers
-    FiberRefs.join(forked, fiberRefs)
-
-    return makeEnvFromFiberRefs(forked)
-  }
-}

package/src/FiberRef/index.ts

@@ -1,2 +0,0 @@
-export * from './FiberRef.js'
-export * from './operations.js'

package/src/FiberRef/operations.ts

@@ -1,19 +0,0 @@
-import { deleteFiberRef, getFiberRef, modifyFiberRef } from '@/Fx/Fx.js'
-
-export const get = getFiberRef
-export const modify = modifyFiberRef
-export const remove = deleteFiberRef
-
-export { remove as delete }
-
-export const set = <A>(value: A) => modify(() => [value, value])
-export const getAndSet = <A>(value: A) => modify((a) => [a, value])
-
-export const update = <A>(f: (a: A) => A) =>
-  modify((a: A) => {
-    const a2 = f(a)
-
-    return [a2, a2]
-  })
-
-export const getAndUpdate = <A>(f: (a: A) => A) => modify((a: A) => [a, f(a)])

package/src/FiberRefs/FiberRefs.ts

@@ -1,147 +0,0 @@
-import { flow, pipe } from 'hkt-ts'
-import * as Maybe from 'hkt-ts/Maybe'
-
-import { Atomic } from '@/Atomic/Atomic.js'
-import type { AnyLiveFiber } from '@/Fiber/Fiber.js'
-import * as FiberRef from '@/FiberRef/FiberRef.js'
-import { ImmutableMap } from '@/ImmutableMap/ImmutableMap.js'
-import * as Stack from '@/Stack/index.js'
-
-export interface FiberRefs extends Iterable<readonly [FiberRef.AnyFiberRef, any]> {
-  readonly locals: Atomic<ImmutableMap<FiberRef.AnyFiberRef, Stack.Stack<any>>>
-  readonly initializing: Atomic<ImmutableMap<FiberRef.AnyFiberRef, AnyLiveFiber>>
-  readonly fork: () => FiberRefs
-}
-
-export function FiberRefs(
-  locals: ImmutableMap<FiberRef.AnyFiberRef, Stack.Stack<any>> = ImmutableMap(),
-  initializing: ImmutableMap<FiberRef.AnyFiberRef, AnyLiveFiber> = ImmutableMap(),
-): FiberRefs {
-  const atomic = Atomic(locals)
-  const fiberRefs: FiberRefs = {
-    locals: atomic,
-    initializing: Atomic(initializing),
-    fork: () => fork(fiberRefs),
-    *[Symbol.iterator]() {
-      for (const [key, stack] of atomic.get()) {
-        yield [key, stack.value] as const
-      }
-    },
-  }
-
-  return fiberRefs
-}
-
-export function maybeGetFiberRefStack<R, E, A>(fiberRef: FiberRef.FiberRef<R, E, A>) {
-  return (fiberRefs: FiberRefs) =>
-    fiberRefs.locals.get().get(fiberRef) as Maybe.Maybe<Stack.Stack<A>>
-}
-
-export function maybeGetFiberRefValue<R, E, A>(fiberRef: FiberRef.FiberRef<R, E, A>) {
-  return flow(
-    maybeGetFiberRefStack(fiberRef),
-    Maybe.map((s) => s.value),
-  )
-}
-
-export function setFiberRef<R, E, A>(fiberRef: FiberRef.FiberRef<R, E, A>, value: A) {
-  return (fiberRefs: FiberRefs): A =>
-    fiberRefs.locals.modify((locals) => {
-      const curr = maybeGetFiberRefStack(fiberRef)(fiberRefs)
-
-      return [
-        value,
-        locals.set(
-          fiberRef,
-          pipe(
-            curr,
-            Maybe.match(
-              () => new Stack.Stack(value),
-              (c) => c.replace(() => value),
-            ),
-          ),
-        ),
-      ]
-    })
-}
-
-export function setFiberRefLocally<R, E, A>(fiberRef: FiberRef.FiberRef<R, E, A>, value: A) {
-  return (fiberRefs: FiberRefs): A =>
-    fiberRefs.locals.modify((locals) => {
-      const curr = maybeGetFiberRefStack(fiberRef)(fiberRefs)
-
-      return [
-        value,
-        locals.set(
-          fiberRef,
-          pipe(
-            curr,
-            Maybe.match(
-              () => new Stack.Stack(value),
-              (c) => c.push(value),
-            ),
-          ),
-        ),
-      ]
-    })
-}
-
-export function popLocalFiberRef<R, E, A>(fiberRef: FiberRef.FiberRef<R, E, A>) {
-  return (fiberRefs: FiberRefs): Maybe.Maybe<A> =>
-    fiberRefs.locals.modify((locals) => {
-      const curr = maybeGetFiberRefStack(fiberRef)(fiberRefs)
-
-      if (Maybe.isNothing(curr)) {
-        return [Maybe.Nothing, locals.remove(fiberRef)]
-      }
-
-      const prev = curr.value.pop()
-
-      return [
-        pipe(
-          curr,
-          Maybe.map((c) => c.value),
-        ),
-        prev ? locals.set(fiberRef, prev) : locals.remove(fiberRef),
-      ]
-    })
-}
-
-export function deleteFiberRef<R, E, A>(fiberRef: FiberRef.FiberRef<R, E, A>) {
-  return (fiberRefs: FiberRefs): Maybe.Maybe<Stack.Stack<A>> =>
-    fiberRefs.locals.modify((locals) => {
-      const curr = maybeGetFiberRefStack(fiberRef)(fiberRefs)
-
-      return [curr, locals.remove(fiberRef)]
-    })
-}
-
-export function fork(fiberRefs: FiberRefs): FiberRefs {
-  const updated = new Map<FiberRef.AnyFiberRef, Stack.Stack<any>>()
-
-  for (const [key, stack] of fiberRefs.locals.get()) {
-    const forked = key.fork(stack.value)
-
-    if (Maybe.isJust(forked)) {
-      updated.set(key, new Stack.Stack(forked.value))
-    }
-  }
-
-  return FiberRefs(ImmutableMap(updated), fiberRefs.initializing.get())
-}
-
-export function join(first: FiberRefs, second: FiberRefs): void {
-  const updated = new Map<FiberRef.AnyFiberRef, Stack.Stack<any>>(first.locals.get())
-  const incoming = second.locals.get()
-
-  for (const [key, stack] of incoming) {
-    const current = updated.get(key)
-
-    updated.set(
-      key,
-      current ? current.replace((a) => key.join(a, stack.value)) : new Stack.Stack(stack.value),
-    )
-  }
-
-  first.locals.set(ImmutableMap(updated))
-}

package/src/FiberRefs/index.ts

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