effect 2.0.0-next.37 → 2.0.0-next.38

package/dist/TPriorityQueue-a5eb73d4.esm.js

@@ -0,0 +1,360 @@
+import { p as pipe, d as dual } from './Function-12511160.esm.js';
+import { r as map, H as withSTMRuntime, t as retry, u as succeed, C as effect } from './core-f6cae6d7.esm.js';
+import { m as make$2, g as get$1, b as update, u as unsafeGet, h as modify, a as unsafeSet } from './tRef-fc8ff438.esm.js';
+import { b as match, m as map$1, n as none, s as some } from './Option-df40d2b9.esm.js';
+import { K as of, S as prepend, _ as filter, G as splitAt } from './ReadonlyArray-0a71b226.esm.js';
+import { e as empty$2, s as set, g as get, i as isEmpty$2, a as isNonEmpty$2, h as headOption, r as reduce, b as getOrder, c as remove } from './SortedMap-e429b26f.esm.js';
+
+/** @internal */
+const TPriorityQueueSymbolKey = "effect/TPriorityQueue";
+
+/** @internal */
+const TPriorityQueueTypeId$1 = /*#__PURE__*/Symbol.for(TPriorityQueueSymbolKey);
+
+/** @internal */
+const tPriorityQueueVariance = {
+  _A: _ => _
+};
+
+/** @internal */
+class TPriorityQueueImpl {
+  [TPriorityQueueTypeId$1] = tPriorityQueueVariance;
+  constructor(ref) {
+    this.ref = ref;
+  }
+}
+
+/** @internal */
+const empty$1 = order => pipe(make$2(empty$2(order)), map(ref => new TPriorityQueueImpl(ref)));
+
+/** @internal */
+const fromIterable$1 = order => iterable => pipe(make$2(Array.from(iterable).reduce((map, value) => pipe(map, set(value, pipe(map, get(value), match({
+  onNone: () => of(value),
+  onSome: prepend(value)
+})))), empty$2(order))), map(ref => new TPriorityQueueImpl(ref)));
+
+/** @internal */
+const isEmpty$1 = self => map(get$1(self.ref), isEmpty$2);
+
+/** @internal */
+const isNonEmpty$1 = self => map(get$1(self.ref), isNonEmpty$2);
+
+/** @internal */
+const make$1 = order => (...elements) => fromIterable$1(order)(elements);
+
+/** @internal */
+const offer$1 = /*#__PURE__*/dual(2, (self, value) => update(self.ref, map => set(map, value, match(get(map, value), {
+  onNone: () => of(value),
+  onSome: prepend(value)
+}))));
+
+/** @internal */
+const offerAll$1 = /*#__PURE__*/dual(2, (self, values) => update(self.ref, map => Array.from(values).reduce((map, value) => set(map, value, match(get(map, value), {
+  onNone: () => of(value),
+  onSome: prepend(value)
+})), map)));
+
+/** @internal */
+const peek$1 = self => withSTMRuntime(runtime => {
+  const map = unsafeGet(self.ref, runtime.journal);
+  return match(headOption(map), {
+    onNone: () => retry,
+    onSome: elements => succeed(elements[0])
+  });
+});
+
+/** @internal */
+const peekOption$1 = self => modify(self.ref, map => [map$1(headOption(map), elements => elements[0]), map]);
+
+/** @internal */
+const removeIf$1 = /*#__PURE__*/dual(2, (self, predicate) => retainIf$1(self, a => !predicate(a)));
+
+/** @internal */
+const retainIf$1 = /*#__PURE__*/dual(2, (self, predicate) => update(self.ref, map => reduce(map, empty$2(getOrder(map)), (map, value, key) => {
+  const filtered = filter(value, predicate);
+  return filtered.length > 0 ? set(map, key, filtered) : remove(map, key);
+})));
+
+/** @internal */
+const size$1 = self => modify(self.ref, map => [reduce(map, 0, (n, as) => n + as.length), map]);
+
+/** @internal */
+const take$1 = self => withSTMRuntime(runtime => {
+  const map = unsafeGet(self.ref, runtime.journal);
+  return match(headOption(map), {
+    onNone: () => retry,
+    onSome: values => {
+      const head = values[1][0];
+      const tail = values[1].slice(1);
+      unsafeSet(self.ref, tail.length > 0 ? set(map, head, tail) : remove(map, head), runtime.journal);
+      return succeed(head);
+    }
+  });
+});
+
+/** @internal */
+const takeAll$1 = self => modify(self.ref, map => {
+  const builder = [];
+  for (const entry of map) {
+    builder.push(...entry[1]);
+  }
+  return [builder, empty$2(getOrder(map))];
+});
+
+/** @internal */
+const takeOption$1 = self => effect(journal => {
+  const map = pipe(self.ref, unsafeGet(journal));
+  return match(headOption(map), {
+    onNone: () => none(),
+    onSome: ([key, value]) => {
+      const tail = value.slice(1);
+      unsafeSet(self.ref, tail.length > 0 ? set(map, key, tail) : remove(map, key), journal);
+      return some(value[0]);
+    }
+  });
+});
+
+/** @internal */
+const takeUpTo$1 = /*#__PURE__*/dual(2, (self, n) => modify(self.ref, map => {
+  const builder = [];
+  const iterator = map[Symbol.iterator]();
+  let updated = map;
+  let index = 0;
+  let next;
+  while ((next = iterator.next()) && !next.done && index < n) {
+    const [key, value] = next.value;
+    const [left, right] = pipe(value, splitAt(n - index));
+    builder.push(...left);
+    if (right.length > 0) {
+      updated = set(updated, key, right);
+    } else {
+      updated = remove(updated, key);
+    }
+    index = index + left.length;
+  }
+  return [builder, updated];
+}));
+
+/** @internal */
+const toChunk = self => modify(self.ref, map => {
+  const builder = [];
+  for (const entry of map) {
+    builder.push(...entry[1]);
+  }
+  return [builder, map];
+});
+
+/** @internal */
+const toReadonlyArray$1 = self => modify(self.ref, map => {
+  const builder = [];
+  for (const entry of map) {
+    builder.push(...entry[1]);
+  }
+  return [builder, map];
+});
+
+/**
+ * @since 2.0.0
+ */
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+const TPriorityQueueTypeId = TPriorityQueueTypeId$1;
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+
+/**
+ * A `TPriorityQueue` contains values of type `A` that an `Order` is defined
+ * on. Unlike a `TQueue`, `take` returns the highest priority value (the value
+ * that is first in the specified ordering) as opposed to the first value
+ * offered to the queue. The ordering that elements with the same priority will
+ * be taken from the queue is not guaranteed.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+
+/**
+ * @internal
+ * @since 2.0.0
+ */
+
+/**
+ * @since 2.0.0
+ */
+
+/**
+ * Constructs a new empty `TPriorityQueue` with the specified `Order`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const empty = empty$1;
+
+/**
+ * Makes a new `TPriorityQueue` initialized with provided iterable.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromIterable = fromIterable$1;
+
+/**
+ * Checks whether the queue is empty.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const isEmpty = isEmpty$1;
+
+/**
+ * Checks whether the queue is not empty.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const isNonEmpty = isNonEmpty$1;
+
+/**
+ * Makes a new `TPriorityQueue` that is initialized with specified values.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const make = make$1;
+
+/**
+ * Offers the specified value to the queue.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const offer = offer$1;
+
+/**
+ * Offers all of the elements in the specified collection to the queue.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const offerAll = offerAll$1;
+
+/**
+ * Peeks at the first value in the queue without removing it, retrying until a
+ * value is in the queue.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const peek = peek$1;
+
+/**
+ * Peeks at the first value in the queue without removing it, returning `None`
+ * if there is not a value in the queue.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const peekOption = peekOption$1;
+
+/**
+ * Removes all elements from the queue matching the specified predicate.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const removeIf = removeIf$1;
+
+/**
+ * Retains only elements from the queue matching the specified predicate.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const retainIf = retainIf$1;
+
+/**
+ * Returns the size of the queue.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const size = size$1;
+
+/**
+ * Takes a value from the queue, retrying until a value is in the queue.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const take = take$1;
+
+/**
+ * Takes all values from the queue.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const takeAll = takeAll$1;
+
+/**
+ * Takes a value from the queue, returning `None` if there is not a value in
+ * the queue.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const takeOption = takeOption$1;
+
+/**
+ * Takes up to the specified maximum number of elements from the queue.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const takeUpTo = takeUpTo$1;
+
+/**
+ * Collects all values into a chunk.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const toArray = toChunk;
+
+/**
+ * Collects all values into an array.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const toReadonlyArray = toReadonlyArray$1;
+
+var TPriorityQueue = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  TPriorityQueueTypeId: TPriorityQueueTypeId,
+  empty: empty,
+  fromIterable: fromIterable,
+  isEmpty: isEmpty,
+  isNonEmpty: isNonEmpty,
+  make: make,
+  offer: offer,
+  offerAll: offerAll,
+  peek: peek,
+  peekOption: peekOption,
+  removeIf: removeIf,
+  retainIf: retainIf,
+  size: size,
+  take: take,
+  takeAll: takeAll,
+  takeOption: takeOption,
+  takeUpTo: takeUpTo,
+  toArray: toArray,
+  toReadonlyArray: toReadonlyArray
+});
+
+export { TPriorityQueue as T, TPriorityQueueTypeId as a, isNonEmpty as b, offerAll as c, peekOption as d, empty as e, fromIterable as f, retainIf as g, takeAll as h, isEmpty as i, takeOption as j, takeUpTo as k, toArray as l, make as m, toReadonlyArray as n, offer as o, peek as p, removeIf as r, size as s, take as t };

package/dist/TQueue-2c224826.esm.js

@@ -0,0 +1,324 @@
+import { c as TDequeueTypeId$1, T as TEnqueueTypeId$1, i as isTQueue$1, e as isTDequeue$1, f as isTEnqueue$1, g as awaitShutdown$1, h as bounded$1, j as capacity$1, k as dropping$1, l as isEmpty$1, m as isFull$1, n as isShutdown$1, o as offer$1, p as offerAll$1, q as peek$1, r as peekOption$1, u as poll$1, v as seek$1, s as shutdown$1, w as size$1, x as sliding$1, y as take$1, z as takeAll$1, A as takeBetween$1, C as takeN$1, E as takeUpTo$1, F as unbounded$1 } from './tQueue-74395d76.esm.js';
+
+/**
+ * @since 2.0.0
+ */
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+const TDequeueTypeId = TDequeueTypeId$1;
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+const TEnqueueTypeId = TEnqueueTypeId$1;
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+
+/**
+ * The base interface that all `TQueue`s must implement.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+
+/**
+ * @since 2.0.0
+ */
+
+/**
+ * Returns `true` if the specified value is a `TQueue`, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+const isTQueue = isTQueue$1;
+
+/**
+ * Returns `true` if the specified value is a `TDequeue`, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+const isTDequeue = isTDequeue$1;
+
+/**
+ * Returns `true` if the specified value is a `TEnqueue`, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+const isTEnqueue = isTEnqueue$1;
+
+/**
+ * Waits until the queue is shutdown. The `STM` returned by this method will
+ * not resume until the queue has been shutdown. If the queue is already
+ * shutdown, the `STM` will resume right away.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const awaitShutdown = awaitShutdown$1;
+
+/**
+ * Creates a bounded queue with the back pressure strategy. The queue will
+ * retain values until they have been taken, applying back pressure to
+ * offerors if the queue is at capacity.
+ *
+ * For best performance use capacities that are powers of two.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const bounded = bounded$1;
+
+/**
+ * Returns the number of elements the queue can hold.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const capacity = capacity$1;
+
+/**
+ * Creates a bounded queue with the dropping strategy. The queue will drop new
+ * values if the queue is at capacity.
+ *
+ * For best performance use capacities that are powers of two.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const dropping = dropping$1;
+
+/**
+ * Returns `true` if the `TQueue` contains zero elements, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const isEmpty = isEmpty$1;
+
+/**
+ * Returns `true` if the `TQueue` contains at least one element, `false`
+ * otherwise.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const isFull = isFull$1;
+
+/**
+ * Returns `true` if `shutdown` has been called, otherwise returns `false`.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const isShutdown = isShutdown$1;
+
+/**
+ * Places one value in the queue.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const offer = offer$1;
+
+/**
+ * For Bounded TQueue: uses the `BackPressure` Strategy, places the values in
+ * the queue and always returns true. If the queue has reached capacity, then
+ * the fiber performing the `offerAll` will be suspended until there is room
+ * in the queue.
+ *
+ * For Unbounded TQueue: Places all values in the queue and returns true.
+ *
+ * For Sliding TQueue: uses `Sliding` Strategy If there is room in the queue,
+ * it places the values otherwise it removes the old elements and enqueues the
+ * new ones. Always returns true.
+ *
+ * For Dropping TQueue: uses `Dropping` Strategy, It places the values in the
+ * queue but if there is no room it will not enqueue them and return false.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const offerAll = offerAll$1;
+
+/**
+ * Views the next element in the queue without removing it, retrying if the
+ * queue is empty.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const peek = peek$1;
+
+/**
+ * Views the next element in the queue without removing it, returning `None`
+ * if the queue is empty.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const peekOption = peekOption$1;
+
+/**
+ * Takes a single element from the queue, returning `None` if the queue is
+ * empty.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const poll = poll$1;
+
+/**
+ * Drops elements from the queue while they do not satisfy the predicate,
+ * taking and returning the first element that does satisfy the predicate.
+ * Retries if no elements satisfy the predicate.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const seek = seek$1;
+
+/**
+ * Interrupts any fibers that are suspended on `offer` or `take`. Future calls
+ * to `offer*` and `take*` will be interrupted immediately.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const shutdown = shutdown$1;
+
+/**
+ * Retrieves the size of the queue, which is equal to the number of elements
+ * in the queue. This may be negative if fibers are suspended waiting for
+ * elements to be added to the queue.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const size = size$1;
+
+/**
+ * Creates a bounded queue with the sliding strategy. The queue will add new
+ * values and drop old values if the queue is at capacity.
+ *
+ * For best performance use capacities that are powers of two.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const sliding = sliding$1;
+
+/**
+ * Takes the oldest value in the queue. If the queue is empty, this will return
+ * a computation that resumes when an item has been added to the queue.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const take = take$1;
+
+/**
+ * Takes all the values in the queue and returns the values. If the queue is
+ * empty returns an empty collection.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const takeAll = takeAll$1;
+
+/**
+ * Takes a number of elements from the queue between the specified minimum and
+ * maximum. If there are fewer than the minimum number of elements available,
+ * retries until at least the minimum number of elements have been collected.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const takeBetween = takeBetween$1;
+
+/**
+ * Takes the specified number of elements from the queue. If there are fewer
+ * than the specified number of elements available, it retries until they
+ * become available.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const takeN = takeN$1;
+
+/**
+ * Takes up to max number of values from the queue.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const takeUpTo = takeUpTo$1;
+
+/**
+ * Creates an unbounded queue.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const unbounded = unbounded$1;
+
+var TQueue = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  TDequeueTypeId: TDequeueTypeId,
+  TEnqueueTypeId: TEnqueueTypeId,
+  isTQueue: isTQueue,
+  isTDequeue: isTDequeue,
+  isTEnqueue: isTEnqueue,
+  awaitShutdown: awaitShutdown,
+  bounded: bounded,
+  capacity: capacity,
+  dropping: dropping,
+  isEmpty: isEmpty,
+  isFull: isFull,
+  isShutdown: isShutdown,
+  offer: offer,
+  offerAll: offerAll,
+  peek: peek,
+  peekOption: peekOption,
+  poll: poll,
+  seek: seek,
+  shutdown: shutdown,
+  size: size,
+  sliding: sliding,
+  take: take,
+  takeAll: takeAll,
+  takeBetween: takeBetween,
+  takeN: takeN,
+  takeUpTo: takeUpTo,
+  unbounded: unbounded
+});
+
+export { unbounded as A, TQueue as T, TDequeueTypeId as a, TEnqueueTypeId as b, isTDequeue as c, isTEnqueue as d, awaitShutdown as e, bounded as f, capacity as g, dropping as h, isTQueue as i, isEmpty as j, isFull as k, isShutdown as l, offerAll as m, peekOption as n, offer as o, peek as p, poll as q, shutdown as r, seek as s, size as t, sliding as u, take as v, takeAll as w, takeBetween as x, takeN as y, takeUpTo as z };