@clayroach/effect 3.19.14-source-capture.6 → 3.19.14-source-capture.8

package/src/internal/fiberMessage.ts

@@ -1,82 +0,0 @@
-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

@@ -1,144 +0,0 @@
-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

@@ -1,297 +0,0 @@
-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)
-})