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

package/src/internal/rcRef.ts

@@ -0,0 +1,192 @@
+import * as Context from "../Context.js"
+import * as Duration from "../Duration.js"
+import type { Effect } from "../Effect.js"
+import * as Effectable from "../Effectable.js"
+import type { RuntimeFiber } from "../Fiber.js"
+import { identity } from "../Function.js"
+import type * as RcRef from "../RcRef.js"
+import * as Readable from "../Readable.js"
+import type * as Scope from "../Scope.js"
+import * as coreEffect from "./core-effect.js"
+import * as core from "./core.js"
+import * as circular from "./effect/circular.js"
+import * as fiberRuntime from "./fiberRuntime.js"
+
+/** @internal */
+export const TypeId: RcRef.TypeId = Symbol.for("effect/RcRef") as RcRef.TypeId
+
+type State<A> = State.Empty | State.Acquired<A> | State.Closed
+
+declare namespace State {
+  interface Empty {
+    readonly _tag: "Empty"
+  }
+
+  interface Acquired<A> {
+    readonly _tag: "Acquired"
+    readonly value: A
+    readonly scope: Scope.CloseableScope
+    fiber: RuntimeFiber<void, never> | undefined
+    refCount: number
+  }
+
+  interface Closed {
+    readonly _tag: "Closed"
+  }
+}
+
+const stateEmpty: State<never> = { _tag: "Empty" }
+const stateClosed: State<never> = { _tag: "Closed" }
+
+const variance: RcRef.RcRef.Variance<any, any> = {
+  _A: identity,
+  _E: identity
+}
+
+class RcRefImpl<A, E> extends Effectable.Class<A, E, Scope.Scope> implements RcRef.RcRef<A, E> {
+  readonly [TypeId]: RcRef.RcRef.Variance<A, E> = variance
+  readonly [Readable.TypeId]: Readable.TypeId = Readable.TypeId
+
+  state: State<A> = stateEmpty
+  readonly semaphore = circular.unsafeMakeSemaphore(1)
+
+  constructor(
+    readonly acquire: Effect<A, E, Scope.Scope>,
+    readonly context: Context.Context<never>,
+    readonly scope: Scope.Scope,
+    readonly idleTimeToLive: Duration.Duration | undefined
+  ) {
+    super()
+    this.get = get(this)
+  }
+  readonly get: Effect<A, E, Scope.Scope>
+
+  commit() {
+    return this.get
+  }
+}
+
+/** @internal */
+export const make = <A, E, R>(options: {
+  readonly acquire: Effect<A, E, R>
+  readonly idleTimeToLive?: Duration.DurationInput | undefined
+}) =>
+  core.withFiberRuntime<RcRef.RcRef<A, E>, never, R | Scope.Scope>((fiber) => {
+    const context = fiber.getFiberRef(core.currentContext) as Context.Context<R | Scope.Scope>
+    const scope = Context.get(context, fiberRuntime.scopeTag)
+    const ref = new RcRefImpl<A, E>(
+      options.acquire as Effect<A, E, Scope.Scope>,
+      context,
+      scope,
+      options.idleTimeToLive ? Duration.decode(options.idleTimeToLive) : undefined
+    )
+    return core.as(
+      scope.addFinalizer(() =>
+        ref.semaphore.withPermits(1)(core.suspend(() => {
+          const close = ref.state._tag === "Acquired"
+            ? core.scopeClose(ref.state.scope, core.exitVoid)
+            : core.void
+          ref.state = stateClosed
+          return close
+        }))
+      ),
+      ref
+    )
+  })
+
+/** @internal */
+export const get = <A, E>(
+  self_: RcRef.RcRef<A, E>
+): Effect<A, E, Scope.Scope> => {
+  const self = self_ as RcRefImpl<A, E>
+  const isInfinite = self.idleTimeToLive && !Duration.isFinite(self.idleTimeToLive)
+  return core.uninterruptibleMask((restore) =>
+    core.suspend(() => {
+      switch (self.state._tag) {
+        case "Closed": {
+          return core.interrupt
+        }
+        case "Acquired": {
+          self.state.refCount++
+          return self.state.fiber
+            ? core.as(core.interruptFiber(self.state.fiber), self.state)
+            : core.succeed(self.state)
+        }
+        case "Empty": {
+          return fiberRuntime.scopeMake().pipe(
+            coreEffect.bindTo("scope"),
+            coreEffect.bind("value", ({ scope }) =>
+              restore(core.fiberRefLocally(
+                self.acquire as Effect<A, E>,
+                core.currentContext,
+                Context.add(self.context, fiberRuntime.scopeTag, scope)
+              ))),
+            core.map(({ scope, value }) => {
+              const state: State.Acquired<A> = {
+                _tag: "Acquired",
+                value,
+                scope,
+                fiber: undefined,
+                refCount: 1
+              }
+              self.state = state
+              return state
+            })
+          )
+        }
+      }
+    })
+  ).pipe(
+    self.semaphore.withPermits(1),
+    coreEffect.bindTo("state"),
+    coreEffect.bind("scope", () => fiberRuntime.scopeTag),
+    core.tap(({ scope, state }) =>
+      scope.addFinalizer(() =>
+        core.suspend(() => {
+          state.refCount--
+          if (state.refCount > 0 || isInfinite) {
+            return core.void
+          }
+          if (self.idleTimeToLive === undefined) {
+            self.state = stateEmpty
+            return core.scopeClose(state.scope, core.exitVoid)
+          }
+          return coreEffect.sleep(self.idleTimeToLive).pipe(
+            core.interruptible,
+            core.zipRight(core.suspend(() => {
+              if (self.state._tag === "Acquired" && self.state.refCount === 0) {
+                self.state = stateEmpty
+                return core.scopeClose(state.scope, core.exitVoid)
+              }
+              return core.void
+            })),
+            fiberRuntime.ensuring(core.sync(() => {
+              state.fiber = undefined
+            })),
+            circular.forkIn(self.scope),
+            core.tap((fiber) => {
+              state.fiber = fiber
+            }),
+            self.semaphore.withPermits(1)
+          )
+        })
+      )
+    ),
+    core.map(({ state }) => state.value)
+  )
+}
+
+/** @internal */
+export const invalidate = <A, E>(
+  self_: RcRef.RcRef<A, E>
+): Effect<void> => {
+  const self = self_ as RcRefImpl<A, E>
+  return core.uninterruptible(core.suspend(() => {
+    if (self.state._tag !== "Acquired") {
+      return core.void
+    }
+    const state = self.state
+    self.state = stateEmpty
+    return state.scope.close(core.exitVoid)
+  }))
+}

package/src/internal/redBlackTree/iterator.ts

@@ -0,0 +1,200 @@
+import * as Arr from "../../Array.js"
+import * as Option from "../../Option.js"
+import type * as RBT from "../../RedBlackTree.js"
+import type { RedBlackTreeImpl } from "../redBlackTree.js"
+import type * as Node from "./node.js"
+
+/** @internal */
+export const Direction = {
+  Forward: 0 as RBT.RedBlackTree.Direction,
+  Backward: 1 << 0 as RBT.RedBlackTree.Direction
+} as const
+
+/** @internal */
+export class RedBlackTreeIterator<in out K, out V> implements Iterator<[K, V]> {
+  private count = 0
+
+  constructor(
+    readonly self: RBT.RedBlackTree<K, V>,
+    readonly stack: Array<Node.Node<K, V>>,
+    readonly direction: RBT.RedBlackTree.Direction
+  ) {}
+
+  /**
+   * Clones the iterator
+   */
+  clone(): RedBlackTreeIterator<K, V> {
+    return new RedBlackTreeIterator(this.self, this.stack.slice(), this.direction)
+  }
+
+  /**
+   * Reverse the traversal direction
+   */
+  reversed(): RedBlackTreeIterator<K, V> {
+    return new RedBlackTreeIterator(
+      this.self,
+      this.stack.slice(),
+      this.direction === Direction.Forward ? Direction.Backward : Direction.Forward
+    )
+  }
+
+  /**
+   * Iterator next
+   */
+  next(): IteratorResult<[K, V], number> {
+    const entry = this.entry
+    this.count++
+    if (this.direction === Direction.Forward) {
+      this.moveNext()
+    } else {
+      this.movePrev()
+    }
+    switch (entry._tag) {
+      case "None": {
+        return { done: true, value: this.count }
+      }
+      case "Some": {
+        return { done: false, value: entry.value }
+      }
+    }
+  }
+
+  /**
+   * Returns the key
+   */
+  get key(): Option.Option<K> {
+    if (this.stack.length > 0) {
+      return Option.some(this.stack[this.stack.length - 1]!.key)
+    }
+    return Option.none()
+  }
+
+  /**
+   * Returns the value
+   */
+  get value(): Option.Option<V> {
+    if (this.stack.length > 0) {
+      return Option.some(this.stack[this.stack.length - 1]!.value)
+    }
+    return Option.none()
+  }
+
+  /**
+   * Returns the key
+   */
+  get entry(): Option.Option<[K, V]> {
+    return Option.map(Arr.last(this.stack), (node) => [node.key, node.value])
+  }
+
+  /**
+   * Returns the position of this iterator in the sorted list
+   */
+  get index(): number {
+    let idx = 0
+    const stack = this.stack
+    if (stack.length === 0) {
+      const r = (this.self as RedBlackTreeImpl<K, V>)._root
+      if (r != null) {
+        return r.count
+      }
+      return 0
+    } else if (stack[stack.length - 1]!.left != null) {
+      idx = stack[stack.length - 1]!.left!.count
+    }
+    for (let s = stack.length - 2; s >= 0; --s) {
+      if (stack[s + 1] === stack[s]!.right) {
+        ++idx
+        if (stack[s]!.left != null) {
+          idx += stack[s]!.left!.count
+        }
+      }
+    }
+    return idx
+  }
+
+  /**
+   * Advances iterator to next element in list
+   */
+  moveNext() {
+    const stack = this.stack
+    if (stack.length === 0) {
+      return
+    }
+    let n: Node.Node<K, V> | undefined = stack[stack.length - 1]!
+    if (n.right != null) {
+      n = n.right
+      while (n != null) {
+        stack.push(n)
+        n = n.left
+      }
+    } else {
+      stack.pop()
+      while (stack.length > 0 && stack[stack.length - 1]!.right === n) {
+        n = stack[stack.length - 1]
+        stack.pop()
+      }
+    }
+  }
+
+  /**
+   * Checks if there is a next element
+   */
+  get hasNext() {
+    const stack = this.stack
+    if (stack.length === 0) {
+      return false
+    }
+    if (stack[stack.length - 1]!.right != null) {
+      return true
+    }
+    for (let s = stack.length - 1; s > 0; --s) {
+      if (stack[s - 1]!.left === stack[s]) {
+        return true
+      }
+    }
+    return false
+  }
+
+  /**
+   * Advances iterator to previous element in list
+   */
+  movePrev() {
+    const stack = this.stack
+    if (stack.length === 0) {
+      return
+    }
+    let n: Node.Node<K, V> | undefined = stack[stack.length - 1]
+    if (n != null && n.left != null) {
+      n = n.left
+      while (n != null) {
+        stack.push(n)
+        n = n.right
+      }
+    } else {
+      stack.pop()
+      while (stack.length > 0 && stack[stack.length - 1]!.left === n) {
+        n = stack[stack.length - 1]
+        stack.pop()
+      }
+    }
+  }
+
+  /**
+   * Checks if there is a previous element
+   */
+  get hasPrev() {
+    const stack = this.stack
+    if (stack.length === 0) {
+      return false
+    }
+    if (stack[stack.length - 1]!.left != null) {
+      return true
+    }
+    for (let s = stack.length - 1; s > 0; --s) {
+      if (stack[s - 1]!.right === stack[s]) {
+        return true
+      }
+    }
+    return false
+  }
+}

package/src/internal/redBlackTree/node.ts

@@ -0,0 +1,68 @@
+/** @internal */
+export const Color = {
+  Red: 0 as Node.Color,
+  Black: 1 << 0 as Node.Color
+} as const
+
+export declare namespace Node {
+  export type Color = number & {
+    readonly Color: unique symbol
+  }
+}
+
+export interface Node<out K, out V> {
+  color: Node.Color
+  key: K
+  value: V
+  left: Node<K, V> | undefined
+  right: Node<K, V> | undefined
+  count: number
+}
+
+/** @internal */
+export const clone = <K, V>({
+  color,
+  count,
+  key,
+  left,
+  right,
+  value
+}: Node<K, V>) => ({
+  color,
+  key,
+  value,
+  left,
+  right,
+  count
+})
+
+/** @internal */
+export function swap<K, V>(n: Node<K, V>, v: Node<K, V>) {
+  n.key = v.key
+  n.value = v.value
+  n.left = v.left
+  n.right = v.right
+  n.color = v.color
+  n.count = v.count
+}
+
+/** @internal */
+export const repaint = <K, V>({
+  count,
+  key,
+  left,
+  right,
+  value
+}: Node<K, V>, color: Node.Color) => ({
+  color,
+  key,
+  value,
+  left,
+  right,
+  count
+})
+
+/** @internal */
+export const recount = <K, V>(node: Node<K, V>) => {
+  node.count = 1 + (node.left?.count ?? 0) + (node.right?.count ?? 0)
+}