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

package/src/internal/rcRef.ts

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

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

@@ -1,68 +0,0 @@
-/** @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)
-}