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

package/src/MutableList.ts

@@ -0,0 +1,297 @@
+/**
+ * @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

@@ -0,0 +1,227 @@
+/**
+ * @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

@@ -0,0 +1,202 @@
+/**
+ * @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, (_) => !_)