Erster Docker-Stand

_node_modules/effect/src/MutableQueue.ts

@@ -0,0 +1,289 @@
+/**
+ * @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: {
+  /**
+   * Offers an element to the queue.
+   *
+   * Returns whether the enqueue was successful or not.
+   *
+   * @since 2.0.0
+   */
+  <A>(self: MutableQueue<A>, value: A): boolean
+  /**
+   * Offers an element to the queue.
+   *
+   * Returns whether the enqueue was successful or not.
+   *
+   * @since 2.0.0
+   */
+  <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: {
+  /**
+   * 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
+   */
+  <A>(values: Iterable<A>): (self: MutableQueue<A>) => Chunk.Chunk<A>
+  /**
+   * 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
+   */
+  <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: {
+  /**
+   * 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
+   */
+  <D>(def: D): <A>(self: MutableQueue<A>) => D | A
+  /**
+   * 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
+   */
+  <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: {
+  /**
+   * Dequeues up to `n` elements from the queue.
+   *
+   * Returns a `List` of up to `n` elements.
+   *
+   * @since 2.0.0
+   */
+  (n: number): <A>(self: MutableQueue<A>) => Chunk.Chunk<A>
+  /**
+   * Dequeues up to `n` elements from the queue.
+   *
+   * Returns a `List` of up to `n` elements.
+   *
+   * @since 2.0.0
+   */
+  <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)
+})