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

package/src/MutableList.ts

@@ -1,297 +0,0 @@
-/**
- * @since 2.0.0
- */
-import * as Dual from "./Function.js"
-import { format, NodeInspectSymbol, toJSON } from "./Inspectable.js"
-import type { Inspectable } from "./Inspectable.js"
-import type { Pipeable } from "./Pipeable.js"
-import { pipeArguments } from "./Pipeable.js"
-
-const TypeId: unique symbol = Symbol.for("effect/MutableList") as TypeId
-
-/**
- * @since 2.0.0
- * @category symbol
- */
-export type TypeId = typeof TypeId
-
-/**
- * @since 2.0.0
- * @category model
- */
-export interface MutableList<out A> extends Iterable<A>, Pipeable, Inspectable {
-  readonly [TypeId]: TypeId
-
-  /** @internal */
-  head: LinkedListNode<A> | undefined
-  /** @internal */
-  tail: LinkedListNode<A> | undefined
-}
-
-const MutableListProto: Omit<MutableList<unknown>, "head" | "tail"> = {
-  [TypeId]: TypeId,
-  [Symbol.iterator](this: MutableList<unknown>): Iterator<unknown> {
-    let done = false
-    let head: LinkedListNode<unknown> | undefined = this.head
-    return {
-      next() {
-        if (done) {
-          return this.return!()
-        }
-        if (head == null) {
-          done = true
-          return this.return!()
-        }
-        const value = head.value
-        head = head.next
-        return { done, value }
-      },
-      return(value?: unknown) {
-        if (!done) {
-          done = true
-        }
-        return { done: true, value }
-      }
-    }
-  },
-  toString() {
-    return format(this.toJSON())
-  },
-  toJSON() {
-    return {
-      _id: "MutableList",
-      values: Array.from(this).map(toJSON)
-    }
-  },
-  [NodeInspectSymbol]() {
-    return this.toJSON()
-  },
-  pipe() {
-    return pipeArguments(this, arguments)
-  }
-}
-
-interface MutableListImpl<A> extends MutableList<A> {
-  _length: number
-}
-
-/** @internal */
-interface LinkedListNode<T> {
-  removed: boolean
-  value: T
-  prev: LinkedListNode<T> | undefined
-  next: LinkedListNode<T> | undefined
-}
-
-/** @internal */
-const makeNode = <T>(value: T): LinkedListNode<T> => ({
-  value,
-  removed: false,
-  prev: undefined,
-  next: undefined
-})
-
-/**
- * Creates an empty `MutableList`.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const empty = <A = never>(): MutableList<A> => {
-  const list = Object.create(MutableListProto)
-  list.head = undefined
-  list.tail = undefined
-  list._length = 0
-  return list
-}
-
-/**
- * Creates a new `MutableList` from an iterable collection of values.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const fromIterable = <A>(iterable: Iterable<A>): MutableList<A> => {
-  const list = empty<A>()
-  for (const element of iterable) {
-    append(list, element)
-  }
-  return list
-}
-
-/**
- * Creates a new `MutableList` from the specified elements.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const make = <A>(...elements: ReadonlyArray<A>): MutableList<A> => fromIterable(elements)
-
-/**
- * Returns `true` if the list contains zero elements, `false`, otherwise.
- *
- * @since 2.0.0
- * @category getters
- */
-export const isEmpty = <A>(self: MutableList<A>): boolean => length(self) === 0
-
-/**
- * Returns the length of the list.
- *
- * @since 2.0.0
- * @category getters
- */
-export const length = <A>(self: MutableList<A>): number => (self as MutableListImpl<A>)._length
-
-/**
- * Returns the last element of the list, if it exists.
- *
- * @since 2.0.0
- * @category getters
- */
-export const tail = <A>(self: MutableList<A>): A | undefined => self.tail === undefined ? undefined : self.tail.value
-
-/**
- * Returns the first element of the list, if it exists.
- *
- * @since 2.0.0
- * @category getters
- */
-export const head = <A>(self: MutableList<A>): A | undefined => self.head === undefined ? undefined : self.head.value
-
-/**
- * Executes the specified function `f` for each element in the list.
- *
- * @since 2.0.0
- * @category traversing
- */
-export const forEach: {
-  <A>(f: (element: A) => void): (self: MutableList<A>) => void
-  <A>(self: MutableList<A>, f: (element: A) => void): void
-} = Dual.dual<
-  <A>(f: (element: A) => void) => (self: MutableList<A>) => void,
-  <A>(self: MutableList<A>, f: (element: A) => void) => void
->(2, (self, f) => {
-  let current = self.head
-  while (current !== undefined) {
-    f(current.value)
-    current = current.next
-  }
-})
-
-/**
- * Removes all elements from the doubly-linked list.
- *
- * @since 2.0.0
- */
-export const reset = <A>(self: MutableList<A>): MutableList<A> => {
-  ;(self as MutableListImpl<A>)._length = 0
-  self.head = undefined
-  self.tail = undefined
-  return self
-}
-
-/**
- * Appends the specified element to the end of the `MutableList`.
- *
- * @category concatenating
- * @since 2.0.0
- */
-export const append: {
-  <A>(value: A): (self: MutableList<A>) => MutableList<A>
-  <A>(self: MutableList<A>, value: A): MutableList<A>
-} = Dual.dual<
-  <A>(value: A) => (self: MutableList<A>) => MutableList<A>,
-  <A>(self: MutableList<A>, value: A) => MutableList<A>
->(2, <A>(self: MutableList<A>, value: A) => {
-  const node = makeNode(value)
-  if (self.head === undefined) {
-    self.head = node
-  }
-  if (self.tail === undefined) {
-    self.tail = node
-  } else {
-    self.tail.next = node
-    node.prev = self.tail
-    self.tail = node
-  }
-  ;(self as MutableListImpl<A>)._length += 1
-  return self
-})
-
-/**
- * Removes the first value from the list and returns it, if it exists.
- *
- * @since 0.0.1
- */
-export const shift = <A>(self: MutableList<A>): A | undefined => {
-  const head = self.head
-  if (head !== undefined) {
-    remove(self, head)
-    return head.value
-  }
-  return undefined
-}
-
-/**
- * Removes the last value from the list and returns it, if it exists.
- *
- * @since 0.0.1
- */
-export const pop = <A>(self: MutableList<A>): A | undefined => {
-  const tail = self.tail
-  if (tail !== undefined) {
-    remove(self, tail)
-    return tail.value
-  }
-  return undefined
-}
-
-/**
- * Prepends the specified value to the beginning of the list.
- *
- * @category concatenating
- * @since 2.0.0
- */
-export const prepend: {
-  <A>(value: A): (self: MutableList<A>) => MutableList<A>
-  <A>(self: MutableList<A>, value: A): MutableList<A>
-} = Dual.dual<
-  <A>(value: A) => (self: MutableList<A>) => MutableList<A>,
-  <A>(self: MutableList<A>, value: A) => MutableList<A>
->(2, <A>(self: MutableList<A>, value: A) => {
-  const node = makeNode(value)
-  node.next = self.head
-  if (self.head !== undefined) {
-    self.head.prev = node
-  }
-  self.head = node
-  if (self.tail === undefined) {
-    self.tail = node
-  }
-  ;(self as MutableListImpl<A>)._length += 1
-  return self
-})
-
-const remove = <A>(self: MutableList<A>, node: LinkedListNode<A>): void => {
-  if (node.removed) {
-    return
-  }
-  node.removed = true
-  if (node.prev !== undefined && node.next !== undefined) {
-    node.prev.next = node.next
-    node.next.prev = node.prev
-  } else if (node.prev !== undefined) {
-    self.tail = node.prev
-    node.prev.next = undefined
-  } else if (node.next !== undefined) {
-    self.head = node.next
-    node.next.prev = undefined
-  } else {
-    self.tail = undefined
-    self.head = undefined
-  }
-  if ((self as MutableListImpl<A>)._length > 0) {
-    ;(self as MutableListImpl<A>)._length -= 1
-  }
-}

package/src/MutableQueue.ts

@@ -1,227 +0,0 @@
-/**
- * @since 2.0.0
- */
-import * as Chunk from "./Chunk.js"
-import * as Dual from "./Function.js"
-import { format, type Inspectable, NodeInspectSymbol, toJSON } from "./Inspectable.js"
-import * as MutableList from "./MutableList.js"
-import type { Pipeable } from "./Pipeable.js"
-import { pipeArguments } from "./Pipeable.js"
-
-const TypeId: unique symbol = Symbol.for("effect/MutableQueue") as TypeId
-
-/**
- * @since 2.0.0
- * @category symbol
- */
-export type TypeId = typeof TypeId
-
-/**
- * @since 2.0.0
- * @category symbol
- */
-export const EmptyMutableQueue = Symbol.for("effect/mutable/MutableQueue/Empty")
-
-/**
- * @since 2.0.0
- * @category model
- */
-export interface MutableQueue<out A> extends Iterable<A>, Pipeable, Inspectable {
-  readonly [TypeId]: TypeId
-
-  /** @internal */
-  queue: MutableList.MutableList<A>
-  /** @internal */
-  capacity: number | undefined
-}
-
-/**
- * @since 2.0.0
- */
-export declare namespace MutableQueue {
-  /**
-   * @since 2.0.0
-   */
-  export type Empty = typeof EmptyMutableQueue
-}
-
-const MutableQueueProto: Omit<MutableQueue<unknown>, "queue" | "capacity"> = {
-  [TypeId]: TypeId,
-  [Symbol.iterator]<A>(this: MutableQueue<A>): Iterator<A> {
-    return Array.from(this.queue)[Symbol.iterator]()
-  },
-  toString() {
-    return format(this.toJSON())
-  },
-  toJSON() {
-    return {
-      _id: "MutableQueue",
-      values: Array.from(this).map(toJSON)
-    }
-  },
-  [NodeInspectSymbol]() {
-    return this.toJSON()
-  },
-  pipe() {
-    return pipeArguments(this, arguments)
-  }
-}
-
-const make = <A>(capacity: number | undefined): MutableQueue<A> => {
-  const queue = Object.create(MutableQueueProto)
-  queue.queue = MutableList.empty()
-  queue.capacity = capacity
-  return queue
-}
-
-/**
- * Creates a new bounded `MutableQueue`.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const bounded = <A>(capacity: number): MutableQueue<A> => make(capacity)
-
-/**
- * Creates a new unbounded `MutableQueue`.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const unbounded = <A>(): MutableQueue<A> => make(undefined)
-
-/**
- * Returns the current number of elements in the queue.
- *
- * @since 2.0.0
- * @category getters
- */
-export const length = <A>(self: MutableQueue<A>): number => MutableList.length(self.queue)
-
-/**
- * Returns `true` if the queue is empty, `false` otherwise.
- *
- * @since 2.0.0
- * @category getters
- */
-export const isEmpty = <A>(self: MutableQueue<A>): boolean => MutableList.isEmpty(self.queue)
-
-/**
- * Returns `true` if the queue is full, `false` otherwise.
- *
- * @since 2.0.0
- * @category getters
- */
-export const isFull = <A>(self: MutableQueue<A>): boolean =>
-  self.capacity === undefined ? false : MutableList.length(self.queue) === self.capacity
-
-/**
- * The **maximum** number of elements that a queue can hold.
- *
- * **Note**: unbounded queues can still implement this interface with
- * `capacity = Infinity`.
- *
- * @since 2.0.0
- * @category getters
- */
-export const capacity = <A>(self: MutableQueue<A>): number => self.capacity === undefined ? Infinity : self.capacity
-
-/**
- * Offers an element to the queue.
- *
- * Returns whether the enqueue was successful or not.
- *
- * @since 2.0.0
- */
-export const offer: {
-  <A>(self: MutableQueue<A>, value: A): boolean
-  <A>(value: A): (self: MutableQueue<A>) => boolean
-} = Dual.dual<
-  <A>(value: A) => (self: MutableQueue<A>) => boolean,
-  <A>(self: MutableQueue<A>, value: A) => boolean
->(2, <A>(self: MutableQueue<A>, value: A) => {
-  const queueLength = MutableList.length(self.queue)
-  if (self.capacity !== undefined && queueLength === self.capacity) {
-    return false
-  }
-  MutableList.append(value)(self.queue)
-  return true
-})
-
-/**
- * Enqueues a collection of values into the queue.
- *
- * Returns a `Chunk` of the values that were **not** able to be enqueued.
- *
- * @since 2.0.0
- */
-export const offerAll: {
-  <A>(values: Iterable<A>): (self: MutableQueue<A>) => Chunk.Chunk<A>
-  <A>(self: MutableQueue<A>, values: Iterable<A>): Chunk.Chunk<A>
-} = Dual.dual<
-  <A>(values: Iterable<A>) => (self: MutableQueue<A>) => Chunk.Chunk<A>,
-  <A>(self: MutableQueue<A>, values: Iterable<A>) => Chunk.Chunk<A>
->(2, <A>(self: MutableQueue<A>, values: Iterable<A>) => {
-  const iterator = values[Symbol.iterator]()
-  let next: IteratorResult<A> | undefined
-  let remainder = Chunk.empty<A>()
-  let offering = true
-  while (offering && (next = iterator.next()) && !next.done) {
-    offering = offer(next.value)(self)
-  }
-  while (next != null && !next.done) {
-    remainder = Chunk.prepend<A>(next.value)(remainder)
-    next = iterator.next()
-  }
-  return Chunk.reverse(remainder)
-})
-
-/**
- * Dequeues an element from the queue.
- *
- * Returns either an element from the queue, or the `def` param.
- *
- * **Note**: if there is no meaningful default for your type, you can always
- * use `poll(MutableQueue.EmptyMutableQueue)`.
- *
- * @since 2.0.0
- */
-export const poll: {
-  <D>(def: D): <A>(self: MutableQueue<A>) => D | A
-  <A, D>(self: MutableQueue<A>, def: D): A | D
-} = Dual.dual<
-  <D>(def: D) => <A>(self: MutableQueue<A>) => A | D,
-  <A, D>(self: MutableQueue<A>, def: D) => A | D
->(2, (self, def) => {
-  if (MutableList.isEmpty(self.queue)) {
-    return def
-  }
-  return MutableList.shift(self.queue)!
-})
-
-/**
- * Dequeues up to `n` elements from the queue.
- *
- * Returns a `List` of up to `n` elements.
- *
- * @since 2.0.0
- */
-export const pollUpTo: {
-  (n: number): <A>(self: MutableQueue<A>) => Chunk.Chunk<A>
-  <A>(self: MutableQueue<A>, n: number): Chunk.Chunk<A>
-} = Dual.dual<
-  (n: number) => <A>(self: MutableQueue<A>) => Chunk.Chunk<A>,
-  <A>(self: MutableQueue<A>, n: number) => Chunk.Chunk<A>
->(2, <A>(self: MutableQueue<A>, n: number) => {
-  let result = Chunk.empty<A>()
-  let count = 0
-  while (count < n) {
-    const element = poll(EmptyMutableQueue)(self)
-    if (element === EmptyMutableQueue) {
-      break
-    }
-    result = Chunk.prepend(element)(result)
-    count += 1
-  }
-  return Chunk.reverse(result)
-})

package/src/MutableRef.ts

@@ -1,202 +0,0 @@
-/**
- * @since 2.0.0
- */
-import * as Equal from "./Equal.js"
-import * as Dual from "./Function.js"
-import { format, type Inspectable, NodeInspectSymbol, toJSON } from "./Inspectable.js"
-import type { Pipeable } from "./Pipeable.js"
-import { pipeArguments } from "./Pipeable.js"
-
-const TypeId: unique symbol = Symbol.for("effect/MutableRef") as TypeId
-
-/**
- * @since 2.0.0
- * @category symbol
- */
-export type TypeId = typeof TypeId
-
-/**
- * @since 2.0.0
- * @category models
- */
-export interface MutableRef<out T> extends Pipeable, Inspectable {
-  readonly [TypeId]: TypeId
-  current: T
-}
-
-const MutableRefProto: Omit<MutableRef<unknown>, "current"> = {
-  [TypeId]: TypeId,
-  toString<A>(this: MutableRef<A>): string {
-    return format(this.toJSON())
-  },
-  toJSON<A>(this: MutableRef<A>) {
-    return {
-      _id: "MutableRef",
-      current: toJSON(this.current)
-    }
-  },
-  [NodeInspectSymbol]() {
-    return this.toJSON()
-  },
-  pipe() {
-    return pipeArguments(this, arguments)
-  }
-}
-
-/**
- * @since 2.0.0
- * @category constructors
- */
-export const make = <T>(value: T): MutableRef<T> => {
-  const ref = Object.create(MutableRefProto)
-  ref.current = value
-  return ref
-}
-
-/**
- * @since 2.0.0
- * @category general
- */
-export const compareAndSet: {
-  <T>(oldValue: T, newValue: T): (self: MutableRef<T>) => boolean
-  <T>(self: MutableRef<T>, oldValue: T, newValue: T): boolean
-} = Dual.dual<
-  <T>(oldValue: T, newValue: T) => (self: MutableRef<T>) => boolean,
-  <T>(self: MutableRef<T>, oldValue: T, newValue: T) => boolean
->(3, (self, oldValue, newValue) => {
-  if (Equal.equals(oldValue, self.current)) {
-    self.current = newValue
-    return true
-  }
-  return false
-})
-
-/**
- * @since 2.0.0
- * @category numeric
- */
-export const decrement = (self: MutableRef<number>): MutableRef<number> => update(self, (n) => n - 1)
-
-/**
- * @since 2.0.0
- * @category numeric
- */
-export const decrementAndGet = (self: MutableRef<number>): number => updateAndGet(self, (n) => n - 1)
-
-/**
- * @since 2.0.0
- * @category general
- */
-export const get = <T>(self: MutableRef<T>): T => self.current
-
-/**
- * @since 2.0.0
- * @category numeric
- */
-export const getAndDecrement = (self: MutableRef<number>): number => getAndUpdate(self, (n) => n - 1)
-
-/**
- * @since 2.0.0
- * @category numeric
- */
-export const getAndIncrement = (self: MutableRef<number>): number => getAndUpdate(self, (n) => n + 1)
-
-/**
- * @since 2.0.0
- * @category general
- */
-export const getAndSet: {
-  <T>(value: T): (self: MutableRef<T>) => T
-  <T>(self: MutableRef<T>, value: T): T
-} = Dual.dual<
-  <T>(value: T) => (self: MutableRef<T>) => T,
-  <T>(self: MutableRef<T>, value: T) => T
->(2, (self, value) => {
-  const ret = self.current
-  self.current = value
-  return ret
-})
-
-/**
- * @since 2.0.0
- * @category general
- */
-export const getAndUpdate: {
-  <T>(f: (value: T) => T): (self: MutableRef<T>) => T
-  <T>(self: MutableRef<T>, f: (value: T) => T): T
-} = Dual.dual<
-  <T>(f: (value: T) => T) => (self: MutableRef<T>) => T,
-  <T>(self: MutableRef<T>, f: (value: T) => T) => T
->(2, (self, f) => getAndSet(self, f(get(self))))
-
-/**
- * @since 2.0.0
- * @category numeric
- */
-export const increment = (self: MutableRef<number>): MutableRef<number> => update(self, (n) => n + 1)
-
-/**
- * @since 2.0.0
- * @category numeric
- */
-export const incrementAndGet = (self: MutableRef<number>): number => updateAndGet(self, (n) => n + 1)
-
-/**
- * @since 2.0.0
- * @category general
- */
-export const set: {
-  <T>(value: T): (self: MutableRef<T>) => MutableRef<T>
-  <T>(self: MutableRef<T>, value: T): MutableRef<T>
-} = Dual.dual<
-  <T>(value: T) => (self: MutableRef<T>) => MutableRef<T>,
-  <T>(self: MutableRef<T>, value: T) => MutableRef<T>
->(2, (self, value) => {
-  self.current = value
-  return self
-})
-
-/**
- * @since 2.0.0
- * @category general
- */
-export const setAndGet: {
-  <T>(value: T): (self: MutableRef<T>) => T
-  <T>(self: MutableRef<T>, value: T): T
-} = Dual.dual<
-  <T>(value: T) => (self: MutableRef<T>) => T,
-  <T>(self: MutableRef<T>, value: T) => T
->(2, (self, value) => {
-  self.current = value
-  return self.current
-})
-
-/**
- * @since 2.0.0
- * @category general
- */
-export const update: {
-  <T>(f: (value: T) => T): (self: MutableRef<T>) => MutableRef<T>
-  <T>(self: MutableRef<T>, f: (value: T) => T): MutableRef<T>
-} = Dual.dual<
-  <T>(f: (value: T) => T) => (self: MutableRef<T>) => MutableRef<T>,
-  <T>(self: MutableRef<T>, f: (value: T) => T) => MutableRef<T>
->(2, (self, f) => set(self, f(get(self))))
-
-/**
- * @since 2.0.0
- * @category general
- */
-export const updateAndGet: {
-  <T>(f: (value: T) => T): (self: MutableRef<T>) => T
-  <T>(self: MutableRef<T>, f: (value: T) => T): T
-} = Dual.dual<
-  <T>(f: (value: T) => T) => (self: MutableRef<T>) => T,
-  <T>(self: MutableRef<T>, f: (value: T) => T) => T
->(2, (self, f) => setAndGet(self, f(get(self))))
-
-/**
- * @since 2.0.0
- * @category boolean
- */
-export const toggle = (self: MutableRef<boolean>): MutableRef<boolean> => update(self, (_) => !_)