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

package/dist/TSet-91c5d646.esm.js

@@ -0,0 +1,412 @@
+import { d as dual, p as pipe } from './Function-12511160.esm.js';
+import { h as has$2, e as empty$2, a as add$2 } from './HashSet-ae2856c1.esm.js';
+import { n as flatMap, r as map } from './core-f6cae6d7.esm.js';
+import { y as set, g as fromIterable$2, j as has$3, k as isEmpty$2, p as reduceWithIndex, q as reduceWithIndexSTM, s as remove$2, t as removeAll$2, u as removeIf$2, v as removeIfDiscard$2, w as retainIf$2, x as retainIfDiscard$2, B as takeFirst$2, C as takeFirstSTM$2, D as takeSome$2, E as takeSomeSTM$2, l as keys, J as transform$2, K as transformSTM$2 } from './tMap-907e37f4.esm.js';
+import { m as map$1 } from './ReadonlyArray-0a71b226.esm.js';
+
+/** @internal */
+const TSetSymbolKey = "effect/TSet";
+
+/** @internal */
+const TSetTypeId$1 = /*#__PURE__*/Symbol.for(TSetSymbolKey);
+
+/** @internal */
+const tSetVariance = {
+  _A: _ => _
+};
+
+/** @internal */
+class TSetImpl {
+  [TSetTypeId$1] = tSetVariance;
+  constructor(tMap) {
+    this.tMap = tMap;
+  }
+}
+
+/** @internal */
+const add$1 = /*#__PURE__*/dual(2, (self, value) => set(self.tMap, value, void 0));
+
+/** @internal */
+const difference$1 = /*#__PURE__*/dual(2, (self, other) => flatMap(toHashSet$1(other), values => removeIfDiscard$1(self, value => has$2(values, value))));
+
+/** @internal */
+const empty$1 = () => fromIterable$1([]);
+
+/** @internal */
+const forEach$1 = /*#__PURE__*/dual(2, (self, f) => reduceSTM$1(self, void 0, (_, value) => f(value)));
+
+/** @internal */
+const fromIterable$1 = iterable => map(fromIterable$2(Array.from(iterable).map(a => [a, void 0])), tMap => new TSetImpl(tMap));
+
+/** @internal */
+const has$1 = /*#__PURE__*/dual(2, (self, value) => has$3(self.tMap, value));
+
+/** @internal */
+const intersection$1 = /*#__PURE__*/dual(2, (self, other) => flatMap(toHashSet$1(other), values => pipe(self, retainIfDiscard$1(value => pipe(values, has$2(value))))));
+
+/** @internal */
+const isEmpty$1 = self => isEmpty$2(self.tMap);
+
+/** @internal */
+const make$1 = (...elements) => fromIterable$1(elements);
+
+/** @internal */
+const reduce$1 = /*#__PURE__*/dual(3, (self, zero, f) => reduceWithIndex(self.tMap, zero, (acc, _, key) => f(acc, key)));
+
+/** @internal */
+const reduceSTM$1 = /*#__PURE__*/dual(3, (self, zero, f) => reduceWithIndexSTM(self.tMap, zero, (acc, _, key) => f(acc, key)));
+
+/** @internal */
+const remove$1 = /*#__PURE__*/dual(2, (self, value) => remove$2(self.tMap, value));
+
+/** @internal */
+const removeAll$1 = /*#__PURE__*/dual(2, (self, iterable) => removeAll$2(self.tMap, iterable));
+
+/** @internal */
+const removeIf$1 = /*#__PURE__*/dual(2, (self, predicate) => pipe(removeIf$2(self.tMap, key => predicate(key)), map(map$1(entry => entry[0]))));
+
+/** @internal */
+const removeIfDiscard$1 = /*#__PURE__*/dual(2, (self, predicate) => removeIfDiscard$2(self.tMap, key => predicate(key)));
+
+/** @internal */
+const retainIf$1 = /*#__PURE__*/dual(2, (self, predicate) => pipe(retainIf$2(self.tMap, key => predicate(key)), map(map$1(entry => entry[0]))));
+
+/** @internal */
+const retainIfDiscard$1 = /*#__PURE__*/dual(2, (self, predicate) => retainIfDiscard$2(self.tMap, key => predicate(key)));
+
+/** @internal */
+const size$1 = self => map(toChunk$1(self), chunk => chunk.length);
+
+/** @internal */
+const takeFirst$1 = /*#__PURE__*/dual(2, (self, pf) => takeFirst$2(self.tMap, key => pf(key)));
+
+/** @internal */
+const takeFirstSTM$1 = /*#__PURE__*/dual(2, (self, pf) => takeFirstSTM$2(self.tMap, key => pf(key)));
+
+/** @internal */
+const takeSome$1 = /*#__PURE__*/dual(2, (self, pf) => takeSome$2(self.tMap, key => pf(key)));
+
+/** @internal */
+const takeSomeSTM$1 = /*#__PURE__*/dual(2, (self, pf) => takeSomeSTM$2(self.tMap, key => pf(key)));
+
+/** @internal */
+const toChunk$1 = self => keys(self.tMap);
+
+/** @internal */
+const toHashSet$1 = self => reduce$1(self, empty$2(), (acc, value) => pipe(acc, add$2(value)));
+
+/** @internal */
+const toReadonlyArray$1 = self => reduce$1(self, [], (acc, value) => [...acc, value]);
+
+/** @internal */
+const toReadonlySet$1 = self => map(toReadonlyArray$1(self), values => new Set(values));
+
+/** @internal */
+const transform$1 = /*#__PURE__*/dual(2, (self, f) => transform$2(self.tMap, (key, value) => [f(key), value]));
+
+/** @internal */
+const transformSTM$1 = /*#__PURE__*/dual(2, (self, f) => transformSTM$2(self.tMap, (key, value) => map(f(key), a => [a, value])));
+
+/** @internal */
+const union$1 = /*#__PURE__*/dual(2, (self, other) => forEach$1(other, value => add$1(self, value)));
+
+/**
+ * @since 2.0.0
+ */
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+const TSetTypeId = TSetTypeId$1;
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+
+/**
+ * Transactional set implemented on top of `TMap`.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+
+/**
+ * @internal
+ * @since 2.0.0
+ */
+
+/**
+ * @since 2.0.0
+ */
+
+/**
+ * Stores new element in the set.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const add = add$1;
+
+/**
+ * Atomically transforms the set into the difference of itself and the
+ * provided set.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const difference = difference$1;
+
+/**
+ * Makes an empty `TSet`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const empty = empty$1;
+
+/**
+ * Atomically performs transactional-effect for each element in set.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+const forEach = forEach$1;
+
+/**
+ * Makes a new `TSet` initialized with provided iterable.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromIterable = fromIterable$1;
+
+/**
+ * Tests whether or not set contains an element.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+const has = has$1;
+
+/**
+ * Atomically transforms the set into the intersection of itself and the
+ * provided set.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const intersection = intersection$1;
+
+/**
+ * Tests if the set is empty or not
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const isEmpty = isEmpty$1;
+
+/**
+ * Makes a new `TSet` that is initialized with specified values.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const make = make$1;
+
+/**
+ * Atomically folds using a pure function.
+ *
+ * @since 2.0.0
+ * @category folding
+ */
+const reduce = reduce$1;
+
+/**
+ * Atomically folds using a transactional function.
+ *
+ * @since 2.0.0
+ * @category folding
+ */
+const reduceSTM = reduceSTM$1;
+
+/**
+ * Removes a single element from the set.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const remove = remove$1;
+
+/**
+ * Removes elements from the set.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const removeAll = removeAll$1;
+
+/**
+ * Removes bindings matching predicate and returns the removed entries.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const removeIf = removeIf$1;
+
+/**
+ * Removes elements matching predicate.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const removeIfDiscard = removeIfDiscard$1;
+
+/**
+ * Retains bindings matching predicate and returns removed bindings.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const retainIf = retainIf$1;
+
+/**
+ * Retains elements matching predicate.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const retainIfDiscard = retainIfDiscard$1;
+
+/**
+ * Returns the set's cardinality.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const size = size$1;
+
+/**
+ * Takes the first matching value, or retries until there is one.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const takeFirst = takeFirst$1;
+
+/**
+ * Takes the first matching value, or retries until there is one.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const takeFirstSTM = takeFirstSTM$1;
+
+/**
+ * Takes all matching values, or retries until there is at least one.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const takeSome = takeSome$1;
+
+/**
+ * Takes all matching values, or retries until there is at least one.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const takeSomeSTM = takeSomeSTM$1;
+
+/**
+ * Collects all elements into a `Chunk`.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const toChunk = toChunk$1;
+
+/**
+ * Collects all elements into a `HashSet`.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const toHashSet = toHashSet$1;
+
+/**
+ * Collects all elements into a `ReadonlyArray`.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const toReadonlyArray = toReadonlyArray$1;
+
+/**
+ * Collects all elements into a `ReadonlySet`.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const toReadonlySet = toReadonlySet$1;
+
+/**
+ * Atomically updates all elements using a pure function.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const transform = transform$1;
+
+/**
+ * Atomically updates all elements using a transactional function.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const transformSTM = transformSTM$1;
+
+/**
+ * Atomically transforms the set into the union of itself and the provided
+ * set.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const union = union$1;
+
+var TSet = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  TSetTypeId: TSetTypeId,
+  add: add,
+  difference: difference,
+  empty: empty,
+  forEach: forEach,
+  fromIterable: fromIterable,
+  has: has,
+  intersection: intersection,
+  isEmpty: isEmpty,
+  make: make,
+  reduce: reduce,
+  reduceSTM: reduceSTM,
+  remove: remove,
+  removeAll: removeAll,
+  removeIf: removeIf,
+  removeIfDiscard: removeIfDiscard,
+  retainIf: retainIf,
+  retainIfDiscard: retainIfDiscard,
+  size: size,
+  takeFirst: takeFirst,
+  takeFirstSTM: takeFirstSTM,
+  takeSome: takeSome,
+  takeSomeSTM: takeSomeSTM,
+  toChunk: toChunk,
+  toHashSet: toHashSet,
+  toReadonlyArray: toReadonlyArray,
+  toReadonlySet: toReadonlySet,
+  transform: transform,
+  transformSTM: transformSTM,
+  union: union
+});
+
+export { toReadonlySet as A, transform as B, transformSTM as C, union as D, TSet as T, TSetTypeId as a, add as b, fromIterable as c, difference as d, empty as e, forEach as f, isEmpty as g, has as h, intersection as i, reduceSTM as j, remove as k, removeAll as l, make as m, removeIf as n, removeIfDiscard as o, retainIf as p, retainIfDiscard as q, reduce as r, size as s, takeFirst as t, takeFirstSTM as u, takeSome as v, takeSomeSTM as w, toChunk as x, toHashSet as y, toReadonlyArray as z };

package/dist/Take-880079f7.esm.js

@@ -0,0 +1,214 @@
+import { b as TakeTypeId$1, c as chunk$1, g as die$1, h as dieMessage$1, d as done$1, e as end$1, i as fail$1, f as failCause$1, j as fromEffect$1, k as fromExit$1, a as fromPull$1, l as isDone$1, n as isFailure$1, p as isSuccess$1, q as make$1, r as map$1, m as match$1, s as matchEffect$1, o as of$1, t as tap$1 } from './take-0d5e0eab.esm.js';
+
+/**
+ * @since 2.0.0
+ */
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+const TakeTypeId = TakeTypeId$1;
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+
+/**
+ * A `Take<E, A>` represents a single `take` from a queue modeling a stream of
+ * values. A `Take` may be a failure cause `Cause<E>`, a chunk value `Chunk<A>`,
+ * or an end-of-stream marker.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+
+/**
+ * @since 2.0.0
+ */
+
+/**
+ * Creates a `Take` with the specified chunk.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const chunk = chunk$1;
+
+/**
+ * Creates a failing `Take` with the specified defect.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const die = die$1;
+
+/**
+ * Creates a failing `Take` with the specified error message.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const dieMessage = dieMessage$1;
+
+/**
+ * Transforms a `Take<E, A>` to an `Effect<never, E, A>`.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const done = done$1;
+
+/**
+ * Represents the end-of-stream marker.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const end = end$1;
+
+/**
+ * Creates a failing `Take` with the specified error.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fail = fail$1;
+
+/**
+ * Creates a failing `Take` with the specified cause.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const failCause = failCause$1;
+
+/**
+ * Creates an effect from `Effect<R, E, A>` that does not fail, but succeeds with
+ * the `Take<E, A>`. Error from stream when pulling is converted to
+ * `Take.failCause`. Creates a single value chunk.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromEffect = fromEffect$1;
+
+/**
+ * Creates a `Take` from an `Exit`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromExit = fromExit$1;
+
+/**
+ * Creates effect from `Effect<R, Option<E>, Chunk<A>>` that does not fail, but
+ * succeeds with the `Take<E, A>`. Errors from stream when pulling are converted
+ * to `Take.failCause`, and the end-of-stream is converted to `Take.end`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromPull = fromPull$1;
+
+/**
+ * Checks if this `take` is done (`Take.end`).
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const isDone = isDone$1;
+
+/**
+ * Checks if this `take` is a failure.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const isFailure = isFailure$1;
+
+/**
+ * Checks if this `take` is a success.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const isSuccess = isSuccess$1;
+
+/**
+ * Constructs a `Take`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const make = make$1;
+
+/**
+ * Transforms `Take<E, A>` to `Take<E, B>` by applying function `f`.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const map = map$1;
+
+/**
+ * Folds over the failure cause, success value and end-of-stream marker to
+ * yield a value.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const match = match$1;
+
+/**
+ * Effectful version of `Take.fold`.
+ *
+ * Folds over the failure cause, success value and end-of-stream marker to
+ * yield an effect.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const matchEffect = matchEffect$1;
+
+/**
+ * Creates a `Take` with a single value chunk.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const of = of$1;
+
+/**
+ * Returns an effect that effectfully "peeks" at the success of this take.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const tap = tap$1;
+
+var Take = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  TakeTypeId: TakeTypeId,
+  chunk: chunk,
+  die: die,
+  dieMessage: dieMessage,
+  done: done,
+  end: end,
+  fail: fail,
+  failCause: failCause,
+  fromEffect: fromEffect,
+  fromExit: fromExit,
+  fromPull: fromPull,
+  isDone: isDone,
+  isFailure: isFailure,
+  isSuccess: isSuccess,
+  make: make,
+  map: map,
+  match: match,
+  matchEffect: matchEffect,
+  of: of,
+  tap: tap
+});
+
+export { Take as T, TakeTypeId as a, dieMessage as b, chunk as c, die as d, done as e, end as f, fail as g, failCause as h, fromEffect as i, fromExit as j, fromPull as k, isDone as l, isFailure as m, isSuccess as n, make as o, map as p, match as q, matchEffect as r, of as s, tap as t };