@typed/fx 0.0.3 → 0.0.4

package/src/FiberRefs/FiberRefs.ts

@@ -1,41 +1,26 @@
 import { flow, pipe } from 'hkt-ts'
 import * as Maybe from 'hkt-ts/Maybe'
-import { NonNegativeInteger } from 'hkt-ts/number'
 
 import { Atomic } from '@/Atomic/Atomic.js'
-// eslint-disable-next-line import/no-cycle
+import type { AnyLiveFiber } from '@/Fiber/Fiber.js'
 import * as FiberRef from '@/FiberRef/FiberRef.js'
 import { ImmutableMap } from '@/ImmutableMap/ImmutableMap.js'
-import { Semaphore } from '@/Semaphore/index.js'
 import * as Stack from '@/Stack/index.js'
-import { EmptyTrace, Trace } from '@/Trace/Trace.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
 }
 
-const defaultFiberLocals = (
-  concurrencyLevel: NonNegativeInteger = NonNegativeInteger(Infinity),
-  interruptStatus = true,
-  trace: Trace = EmptyTrace,
-) =>
-  new Map<FiberRef.AnyFiberRef, Stack.Stack<any>>([
-    [FiberRef.CurrentConcurrencyLevel, new Stack.Stack(new Semaphore(concurrencyLevel))],
-    [FiberRef.CurrentInterruptStatus, new Stack.Stack(interruptStatus)],
-    [FiberRef.CurrentTrace, new Stack.Stack(trace)],
-    [FiberRef.Services, new Stack.Stack(ImmutableMap())],
-    [FiberRef.Layers, new Stack.Stack(ImmutableMap())],
-    [FiberRef.CurrentLogSpans, new Stack.Stack(ImmutableMap())],
-    [FiberRef.CurrentLogAnnotations, new Stack.Stack(ImmutableMap())],
-  ])
-
 export function FiberRefs(
-  locals: ImmutableMap<FiberRef.AnyFiberRef, Stack.Stack<any>> = ImmutableMap(defaultFiberLocals()),
+  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()) {
@@ -138,14 +123,11 @@ export function fork(fiberRefs: FiberRefs): FiberRefs {
     const forked = key.fork(stack.value)
 
     if (Maybe.isJust(forked)) {
-      updated.set(
-        key,
-        stack.replace(() => forked.value),
-      )
+      updated.set(key, new Stack.Stack(forked.value))
     }
   }
 
-  return FiberRefs(ImmutableMap(updated))
+  return FiberRefs(ImmutableMap(updated), fiberRefs.initializing.get())
 }
 
 export function join(first: FiberRefs, second: FiberRefs): void {
@@ -155,7 +137,10 @@ export function join(first: FiberRefs, second: FiberRefs): void {
   for (const [key, stack] of incoming) {
     const current = updated.get(key)
 
-    updated.set(key, current ? current.replace((a) => key.join(a, stack.value)) : stack)
+    updated.set(
+      key,
+      current ? current.replace((a) => key.join(a, stack.value)) : new Stack.Stack(stack.value),
+    )
   }
 
   first.locals.set(ImmutableMap(updated))