@clayroach/effect 3.19.14-source-capture.8 → 3.19.14-source-trace.2

package/src/internal/fiberMessage.ts

@@ -0,0 +1,82 @@
+import type * as Cause from "../Cause.js"
+import type * as Effect from "../Effect.js"
+import type * as FiberStatus from "../FiberStatus.js"
+import type * as FiberRuntime from "./fiberRuntime.js"
+
+/** @internal */
+export type FiberMessage = InterruptSignal | Stateful | Resume | YieldNow
+
+/** @internal */
+export const OP_INTERRUPT_SIGNAL = "InterruptSignal" as const
+
+/** @internal */
+export type OP_INTERRUPT_SIGNAL = typeof OP_INTERRUPT_SIGNAL
+
+/** @internal */
+export const OP_STATEFUL = "Stateful" as const
+
+/** @internal */
+export type OP_STATEFUL = typeof OP_STATEFUL
+
+/** @internal */
+export const OP_RESUME = "Resume" as const
+
+/** @internal */
+export type OP_RESUME = typeof OP_RESUME
+
+/** @internal */
+export const OP_YIELD_NOW = "YieldNow" as const
+
+/** @internal */
+export type OP_YIELD_NOW = typeof OP_YIELD_NOW
+
+/** @internal */
+export interface InterruptSignal {
+  readonly _tag: OP_INTERRUPT_SIGNAL
+  readonly cause: Cause.Cause<never>
+}
+
+/** @internal */
+export interface Stateful {
+  readonly _tag: OP_STATEFUL
+  onFiber(fiber: FiberRuntime.FiberRuntime<any, any>, status: FiberStatus.FiberStatus): void
+}
+
+/** @internal */
+export interface Resume {
+  readonly _tag: OP_RESUME
+  readonly effect: Effect.Effect<any, any, any>
+}
+
+/** @internal */
+export interface YieldNow {
+  readonly _tag: OP_YIELD_NOW
+}
+
+/** @internal */
+export const interruptSignal = (cause: Cause.Cause<never>): FiberMessage => ({
+  _tag: OP_INTERRUPT_SIGNAL,
+  cause
+})
+
+/** @internal */
+export const stateful = (
+  onFiber: (
+    fiber: FiberRuntime.FiberRuntime<any, any>,
+    status: FiberStatus.FiberStatus
+  ) => void
+): FiberMessage => ({
+  _tag: OP_STATEFUL,
+  onFiber
+})
+
+/** @internal */
+export const resume = (effect: Effect.Effect<any, any, any>): FiberMessage => ({
+  _tag: OP_RESUME,
+  effect
+})
+
+/** @internal */
+export const yieldNow = (): FiberMessage => ({
+  _tag: OP_YIELD_NOW
+})

package/src/internal/fiberRefs/patch.ts

@@ -0,0 +1,144 @@
+import * as Arr from "../../Array.js"
+import { equals } from "../../Equal.js"
+import type * as FiberId from "../../FiberId.js"
+import type * as FiberRefs from "../../FiberRefs.js"
+import type * as FiberRefsPatch from "../../FiberRefsPatch.js"
+import { dual } from "../../Function.js"
+import * as fiberRefs_ from "../fiberRefs.js"
+
+/** @internal */
+export const OP_EMPTY = "Empty" as const
+
+/** @internal */
+export type OP_EMPTY = typeof OP_EMPTY
+
+/** @internal */
+export const OP_ADD = "Add" as const
+
+/** @internal */
+export type OP_ADD = typeof OP_ADD
+
+/** @internal */
+export const OP_REMOVE = "Remove" as const
+
+/** @internal */
+export type OP_REMOVE = typeof OP_REMOVE
+
+/** @internal */
+export const OP_UPDATE = "Update" as const
+
+/** @internal */
+export type OP_UPDATE = typeof OP_UPDATE
+
+/** @internal */
+export const OP_AND_THEN = "AndThen" as const
+
+/** @internal */
+export type OP_AND_THEN = typeof OP_AND_THEN
+
+/** @internal */
+export const empty: FiberRefsPatch.FiberRefsPatch = ({
+  _tag: OP_EMPTY
+}) as FiberRefsPatch.FiberRefsPatch
+
+/** @internal */
+export const diff = (
+  oldValue: FiberRefs.FiberRefs,
+  newValue: FiberRefs.FiberRefs
+): FiberRefsPatch.FiberRefsPatch => {
+  const missingLocals = new Map(oldValue.locals)
+  let patch = empty
+  for (const [fiberRef, pairs] of newValue.locals.entries()) {
+    const newValue = Arr.headNonEmpty(pairs)[1]
+    const old = missingLocals.get(fiberRef)
+    if (old !== undefined) {
+      const oldValue = Arr.headNonEmpty(old)[1]
+      if (!equals(oldValue, newValue)) {
+        patch = combine({
+          _tag: OP_UPDATE,
+          fiberRef,
+          patch: fiberRef.diff(oldValue, newValue)
+        })(patch)
+      }
+    } else {
+      patch = combine({
+        _tag: OP_ADD,
+        fiberRef,
+        value: newValue
+      })(patch)
+    }
+    missingLocals.delete(fiberRef)
+  }
+  for (const [fiberRef] of missingLocals.entries()) {
+    patch = combine({
+      _tag: OP_REMOVE,
+      fiberRef
+    })(patch)
+  }
+  return patch
+}
+
+/** @internal */
+export const combine = dual<
+  (that: FiberRefsPatch.FiberRefsPatch) => (self: FiberRefsPatch.FiberRefsPatch) => FiberRefsPatch.FiberRefsPatch,
+  (self: FiberRefsPatch.FiberRefsPatch, that: FiberRefsPatch.FiberRefsPatch) => FiberRefsPatch.FiberRefsPatch
+>(2, (self, that) => ({
+  _tag: OP_AND_THEN,
+  first: self,
+  second: that
+}))
+
+/** @internal */
+export const patch = dual<
+  (
+    fiberId: FiberId.Runtime,
+    oldValue: FiberRefs.FiberRefs
+  ) => (self: FiberRefsPatch.FiberRefsPatch) => FiberRefs.FiberRefs,
+  (
+    self: FiberRefsPatch.FiberRefsPatch,
+    fiberId: FiberId.Runtime,
+    oldValue: FiberRefs.FiberRefs
+  ) => FiberRefs.FiberRefs
+>(3, (self, fiberId, oldValue) => {
+  let fiberRefs: FiberRefs.FiberRefs = oldValue
+  let patches: ReadonlyArray<FiberRefsPatch.FiberRefsPatch> = Arr.of(self)
+  while (Arr.isNonEmptyReadonlyArray(patches)) {
+    const head = Arr.headNonEmpty(patches)
+    const tail = Arr.tailNonEmpty(patches)
+    switch (head._tag) {
+      case OP_EMPTY: {
+        patches = tail
+        break
+      }
+      case OP_ADD: {
+        fiberRefs = fiberRefs_.updateAs(fiberRefs, {
+          fiberId,
+          fiberRef: head.fiberRef,
+          value: head.value
+        })
+        patches = tail
+        break
+      }
+      case OP_REMOVE: {
+        fiberRefs = fiberRefs_.delete_(fiberRefs, head.fiberRef)
+        patches = tail
+        break
+      }
+      case OP_UPDATE: {
+        const value = fiberRefs_.getOrDefault(fiberRefs, head.fiberRef)
+        fiberRefs = fiberRefs_.updateAs(fiberRefs, {
+          fiberId,
+          fiberRef: head.fiberRef,
+          value: head.fiberRef.patch(head.patch)(value)
+        })
+        patches = tail
+        break
+      }
+      case OP_AND_THEN: {
+        patches = Arr.prepend(head.first)(Arr.prepend(head.second)(tail))
+        break
+      }
+    }
+  }
+  return fiberRefs
+})

package/src/internal/fiberRefs.ts

@@ -0,0 +1,297 @@
+import * as Arr from "../Array.js"
+import type * as Effect from "../Effect.js"
+import * as Equal from "../Equal.js"
+import type * as FiberId from "../FiberId.js"
+import type * as FiberRef from "../FiberRef.js"
+import type * as FiberRefs from "../FiberRefs.js"
+import { dual, pipe } from "../Function.js"
+import * as HashSet from "../HashSet.js"
+import * as Option from "../Option.js"
+import { pipeArguments } from "../Pipeable.js"
+import * as core from "./core.js"
+
+/** @internal */
+export function unsafeMake(
+  fiberRefLocals: Map<FiberRef.FiberRef<any>, Arr.NonEmptyReadonlyArray<readonly [FiberId.Single, any]>>
+): FiberRefs.FiberRefs {
+  return new FiberRefsImpl(fiberRefLocals)
+}
+
+/** @internal */
+export function empty(): FiberRefs.FiberRefs {
+  return unsafeMake(new Map())
+}
+
+/** @internal */
+export const FiberRefsSym: FiberRefs.FiberRefsSym = Symbol.for("effect/FiberRefs") as FiberRefs.FiberRefsSym
+
+/** @internal */
+export class FiberRefsImpl implements FiberRefs.FiberRefs {
+  readonly [FiberRefsSym]: FiberRefs.FiberRefsSym = FiberRefsSym
+  constructor(
+    readonly locals: Map<
+      FiberRef.FiberRef<any>,
+      Arr.NonEmptyReadonlyArray<readonly [FiberId.Single, any]>
+    >
+  ) {}
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+}
+
+/** @internal */
+const findAncestor = (
+  _ref: FiberRef.FiberRef<any>,
+  _parentStack: ReadonlyArray<readonly [FiberId.Single, unknown]>,
+  _childStack: ReadonlyArray<readonly [FiberId.Single, unknown]>,
+  _childModified = false
+): readonly [unknown, boolean] => {
+  const ref = _ref
+  let parentStack = _parentStack
+  let childStack = _childStack
+  let childModified = _childModified
+  let ret: readonly [unknown, boolean] | undefined = undefined
+  while (ret === undefined) {
+    if (Arr.isNonEmptyReadonlyArray(parentStack) && Arr.isNonEmptyReadonlyArray(childStack)) {
+      const parentFiberId = Arr.headNonEmpty(parentStack)[0]
+      const parentAncestors = Arr.tailNonEmpty(parentStack)
+      const childFiberId = Arr.headNonEmpty(childStack)[0]
+      const childRefValue = Arr.headNonEmpty(childStack)[1]
+      const childAncestors = Arr.tailNonEmpty(childStack)
+      if (parentFiberId.startTimeMillis < childFiberId.startTimeMillis) {
+        childStack = childAncestors
+        childModified = true
+      } else if (parentFiberId.startTimeMillis > childFiberId.startTimeMillis) {
+        parentStack = parentAncestors
+      } else {
+        if (parentFiberId.id < childFiberId.id) {
+          childStack = childAncestors
+          childModified = true
+        } else if (parentFiberId.id > childFiberId.id) {
+          parentStack = parentAncestors
+        } else {
+          ret = [childRefValue, childModified] as const
+        }
+      }
+    } else {
+      ret = [ref.initial, true] as const
+    }
+  }
+  return ret
+}
+
+/** @internal */
+export const joinAs = dual<
+  (fiberId: FiberId.Single, that: FiberRefs.FiberRefs) => (self: FiberRefs.FiberRefs) => FiberRefs.FiberRefs,
+  (self: FiberRefs.FiberRefs, fiberId: FiberId.Single, that: FiberRefs.FiberRefs) => FiberRefs.FiberRefs
+>(3, (self, fiberId, that) => {
+  const parentFiberRefs = new Map(self.locals)
+  that.locals.forEach((childStack, fiberRef) => {
+    const childValue = childStack[0][1]
+    if (!childStack[0][0][Equal.symbol](fiberId)) {
+      if (!parentFiberRefs.has(fiberRef)) {
+        if (Equal.equals(childValue, fiberRef.initial)) {
+          return
+        }
+        parentFiberRefs.set(
+          fiberRef,
+          [[fiberId, fiberRef.join(fiberRef.initial, childValue)]]
+        )
+        return
+      }
+      const parentStack = parentFiberRefs.get(fiberRef)!
+      const [ancestor, wasModified] = findAncestor(
+        fiberRef,
+        parentStack,
+        childStack
+      )
+      if (wasModified) {
+        const patch = fiberRef.diff(ancestor, childValue)
+        const oldValue = parentStack[0][1]
+        const newValue = fiberRef.join(oldValue, fiberRef.patch(patch)(oldValue))
+        if (!Equal.equals(oldValue, newValue)) {
+          let newStack: Arr.NonEmptyReadonlyArray<readonly [FiberId.Single, unknown]>
+          const parentFiberId = parentStack[0][0]
+          if (parentFiberId[Equal.symbol](fiberId)) {
+            newStack = [[parentFiberId, newValue] as const, ...parentStack.slice(1)]
+          } else {
+            newStack = [[fiberId, newValue] as const, ...parentStack]
+          }
+          parentFiberRefs.set(fiberRef, newStack)
+        }
+      }
+    }
+  })
+  return new FiberRefsImpl(parentFiberRefs)
+})
+
+/** @internal */
+export const forkAs = dual<
+  (childId: FiberId.Single) => (self: FiberRefs.FiberRefs) => FiberRefs.FiberRefs,
+  (self: FiberRefs.FiberRefs, childId: FiberId.Single) => FiberRefs.FiberRefs
+>(2, (self, childId) => {
+  const map = new Map<FiberRef.FiberRef<any>, Arr.NonEmptyReadonlyArray<readonly [FiberId.Single, unknown]>>()
+  unsafeForkAs(self, map, childId)
+  return new FiberRefsImpl(map)
+})
+
+const unsafeForkAs = (
+  self: FiberRefs.FiberRefs,
+  map: Map<FiberRef.FiberRef<any>, Arr.NonEmptyReadonlyArray<readonly [FiberId.Single, any]>>,
+  fiberId: FiberId.Single
+) => {
+  self.locals.forEach((stack, fiberRef) => {
+    const oldValue = stack[0][1]
+    const newValue = fiberRef.patch(fiberRef.fork)(oldValue)
+    if (Equal.equals(oldValue, newValue)) {
+      map.set(fiberRef, stack)
+    } else {
+      map.set(fiberRef, [[fiberId, newValue] as const, ...stack])
+    }
+  })
+}
+
+/** @internal */
+export const fiberRefs = (self: FiberRefs.FiberRefs) => HashSet.fromIterable(self.locals.keys())
+
+/** @internal */
+export const setAll = (self: FiberRefs.FiberRefs): Effect.Effect<void> =>
+  core.forEachSequentialDiscard(
+    fiberRefs(self),
+    (fiberRef) => core.fiberRefSet(fiberRef, getOrDefault(self, fiberRef))
+  )
+
+/** @internal */
+export const delete_ = dual<
+  <A>(fiberRef: FiberRef.FiberRef<A>) => (self: FiberRefs.FiberRefs) => FiberRefs.FiberRefs,
+  <A>(self: FiberRefs.FiberRefs, fiberRef: FiberRef.FiberRef<A>) => FiberRefs.FiberRefs
+>(2, (self, fiberRef) => {
+  const locals = new Map(self.locals)
+  locals.delete(fiberRef)
+  return new FiberRefsImpl(locals)
+})
+
+/** @internal */
+export const get = dual<
+  <A>(fiberRef: FiberRef.FiberRef<A>) => (self: FiberRefs.FiberRefs) => Option.Option<A>,
+  <A>(self: FiberRefs.FiberRefs, fiberRef: FiberRef.FiberRef<A>) => Option.Option<A>
+>(2, (self, fiberRef) => {
+  if (!self.locals.has(fiberRef)) {
+    return Option.none()
+  }
+  return Option.some(Arr.headNonEmpty(self.locals.get(fiberRef)!)[1])
+})
+
+/** @internal */
+export const getOrDefault = dual<
+  <A>(fiberRef: FiberRef.FiberRef<A>) => (self: FiberRefs.FiberRefs) => A,
+  <A>(self: FiberRefs.FiberRefs, fiberRef: FiberRef.FiberRef<A>) => A
+>(2, (self, fiberRef) => pipe(get(self, fiberRef), Option.getOrElse(() => fiberRef.initial)))
+
+/** @internal */
+export const updateAs = dual<
+  <A>(
+    options: {
+      readonly fiberId: FiberId.Single
+      readonly fiberRef: FiberRef.FiberRef<A>
+      readonly value: A
+    }
+  ) => (self: FiberRefs.FiberRefs) => FiberRefs.FiberRefs,
+  <A>(
+    self: FiberRefs.FiberRefs,
+    options: {
+      readonly fiberId: FiberId.Single
+      readonly fiberRef: FiberRef.FiberRef<A>
+      readonly value: A
+    }
+  ) => FiberRefs.FiberRefs
+>(2, <A>(self: FiberRefs.FiberRefs, { fiberId, fiberRef, value }: {
+  readonly fiberId: FiberId.Single
+  readonly fiberRef: FiberRef.FiberRef<A>
+  readonly value: A
+}) => {
+  if (self.locals.size === 0) {
+    return new FiberRefsImpl(new Map([[fiberRef, [[fiberId, value] as const]]]))
+  }
+  const locals = new Map(self.locals)
+  unsafeUpdateAs(locals, fiberId, fiberRef, value)
+  return new FiberRefsImpl(locals)
+})
+
+const unsafeUpdateAs = (
+  locals: Map<FiberRef.FiberRef<any>, Arr.NonEmptyReadonlyArray<readonly [FiberId.Single, any]>>,
+  fiberId: FiberId.Single,
+  fiberRef: FiberRef.FiberRef<any>,
+  value: any
+) => {
+  const oldStack: ReadonlyArray<readonly [FiberId.Single, any]> = locals.get(fiberRef) ?? []
+  let newStack: Arr.NonEmptyReadonlyArray<readonly [FiberId.Single, any]> | undefined
+
+  if (Arr.isNonEmptyReadonlyArray(oldStack)) {
+    const [currentId, currentValue] = Arr.headNonEmpty(oldStack)
+    if (currentId[Equal.symbol](fiberId)) {
+      if (Equal.equals(currentValue, value)) {
+        return
+      } else {
+        newStack = [
+          [fiberId, value] as const,
+          ...oldStack.slice(1)
+        ]
+      }
+    } else {
+      newStack = [
+        [fiberId, value] as const,
+        ...oldStack
+      ]
+    }
+  } else {
+    newStack = [[fiberId, value] as const]
+  }
+
+  locals.set(fiberRef, newStack)
+}
+
+/** @internal */
+export const updateManyAs = dual<
+  (
+    options: {
+      readonly forkAs?: FiberId.Single | undefined
+      readonly entries: Arr.NonEmptyReadonlyArray<
+        readonly [FiberRef.FiberRef<any>, Arr.NonEmptyReadonlyArray<readonly [FiberId.Single, any]>]
+      >
+    }
+  ) => (self: FiberRefs.FiberRefs) => FiberRefs.FiberRefs,
+  (
+    self: FiberRefs.FiberRefs,
+    options: {
+      readonly forkAs?: FiberId.Single | undefined
+      readonly entries: Arr.NonEmptyReadonlyArray<
+        readonly [FiberRef.FiberRef<any>, Arr.NonEmptyReadonlyArray<readonly [FiberId.Single, any]>]
+      >
+    }
+  ) => FiberRefs.FiberRefs
+>(2, (self: FiberRefs.FiberRefs, { entries, forkAs }: {
+  readonly forkAs?: FiberId.Single | undefined
+  readonly entries: Arr.NonEmptyReadonlyArray<
+    readonly [FiberRef.FiberRef<any>, Arr.NonEmptyReadonlyArray<readonly [FiberId.Single, any]>]
+  >
+}) => {
+  if (self.locals.size === 0) {
+    return new FiberRefsImpl(new Map(entries))
+  }
+
+  const locals = new Map(self.locals)
+  if (forkAs !== undefined) {
+    unsafeForkAs(self, locals, forkAs)
+  }
+  entries.forEach(([fiberRef, values]) => {
+    if (values.length === 1) {
+      unsafeUpdateAs(locals, values[0][0], fiberRef, values[0][1])
+    } else {
+      values.forEach(([fiberId, value]) => {
+        unsafeUpdateAs(locals, fiberId, fiberRef, value)
+      })
+    }
+  })
+  return new FiberRefsImpl(locals)
+})