effect 2.0.0-next.44 → 2.0.0-next.46

package/src/MutableQueue.ts

@@ -0,0 +1,227 @@
+/**
+ * @since 2.0.0
+ */
+import * as Chunk from "./Chunk"
+import * as Dual from "./Function"
+import { type Inspectable, NodeInspectSymbol, toJSON, toString } from "./Inspectable"
+import * as MutableList from "./MutableList"
+import type { Pipeable } from "./Pipeable"
+import { pipeArguments } from "./Pipeable"
+
+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<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 toString(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,204 @@
+/**
+ * @since 2.0.0
+ */
+import * as Equal from "./Equal"
+import * as Dual from "./Function"
+import { type Inspectable, NodeInspectSymbol, toJSON, toString } from "./Inspectable"
+import type { Pipeable } from "./Pipeable"
+import { pipeArguments } from "./Pipeable"
+
+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<T> extends Pipeable, Inspectable {
+  readonly [TypeId]: TypeId
+
+  /** @internal */
+  current: T
+}
+
+const MutableRefProto: Omit<MutableRef<unknown>, "current"> = {
+  [TypeId]: TypeId,
+  toString<A>(this: MutableRef<A>): string {
+    return toString(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, (_) => !_)

package/src/NonEmptyIterable.ts

@@ -0,0 +1,30 @@
+/**
+ * @since 2.0.0
+ */
+
+/**
+ * @category symbol
+ * @since 2.0.0
+ */
+export declare const nonEmpty: unique symbol
+
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface NonEmptyIterable<A> extends Iterable<A> {
+  readonly [nonEmpty]: A
+}
+
+/**
+ * @category getters
+ * @since 2.0.0
+ */
+export const unprepend = <A>(self: NonEmptyIterable<A>): readonly [A, Iterator<A>] => {
+  const iterator = self[Symbol.iterator]()
+  const next = iterator.next()
+  if (next.done) {
+    throw new Error("BUG: NonEmptyIterator should not be empty")
+  }
+  return [next.value, iterator]
+}