effect 2.0.0-next.38 → 2.0.0-next.39

package/dist/List-6e58a1e9.esm.js

@@ -1,865 +0,0 @@
-import { f as fromIterable$1 } from './Chunk-4c1f4599.esm.js';
-import { a as isLeft } from './Either-aa46c018.esm.js';
-import { s as symbol$1, e as equals } from './Equal-2a99fde3.esm.js';
-import { b as mapInput } from './Equivalence-cf2752b1.esm.js';
-import { d as dual, u as unsafeCoerce, i as identity } from './Function-12511160.esm.js';
-import { s as symbol, a as array } from './Hash-7910f34f.esm.js';
-import { t as toString, N as NodeInspectSymbol, a as toJSON } from './Inspectable-b0c51e90.esm.js';
-import { i as isSome, s as some$1, n as none } from './Option-df40d2b9.esm.js';
-import { p as pipeArguments } from './Pipeable-10760a1d.esm.js';
-import { i as isObject } from './Predicate-6b61b95b.esm.js';
-import { H as getEquivalence$1 } from './ReadonlyArray-0a71b226.esm.js';
-
-/**
- * A data type for immutable linked lists representing ordered collections of elements of type `A`.
- *
- * This data type is optimal for last-in-first-out (LIFO), stack-like access patterns. If you need another access pattern, for example, random access or FIFO, consider using a collection more suited to this than `List`.
- *
- * **Performance**
- *
- * - Time: `List` has `O(1)` prepend and head/tail access. Most other operations are `O(n)` on the number of elements in the list. This includes the index-based lookup of elements, `length`, `append` and `reverse`.
- * - Space: `List` implements structural sharing of the tail list. This means that many operations are either zero- or constant-memory cost.
- *
- * @since 2.0.0
- */
-
-/**
- * Represents an immutable linked list of elements of type `A`.
- *
- * A `List` is optimal for last-in-first-out (LIFO), stack-like access patterns.
- * If you need another access pattern, for example, random access or FIFO,
- * consider using a collection more suited for that other than `List`.
- *
- * @since 2.0.0
- * @category models
- */
-
-/**
- * @since 2.0.0
- * @category symbol
- */
-const TypeId = /*#__PURE__*/Symbol.for("effect/List");
-
-/**
- * @since 2.0.0
- * @category symbol
- */
-
-/**
- * @since 2.0.0
- * @category models
- */
-
-/**
- * @since 2.0.0
- * @category models
- */
-
-/**
- * Converts the specified `List` to a `ReadonlyArray`.
- *
- * @category conversions
- * @since 2.0.0
- */
-const toReadonlyArray = self => Array.from(self);
-
-/**
- * @category equivalence
- * @since 2.0.0
- */
-const getEquivalence = isEquivalent => mapInput(getEquivalence$1(isEquivalent), toReadonlyArray);
-const _equivalence = /*#__PURE__*/getEquivalence(equals);
-const ConsProto = {
-  [TypeId]: TypeId,
-  _tag: "Cons",
-  toString() {
-    return toString(this.toJSON());
-  },
-  toJSON() {
-    return {
-      _id: "List",
-      _tag: "Cons",
-      values: toReadonlyArray(this).map(toJSON)
-    };
-  },
-  [NodeInspectSymbol]() {
-    return this.toJSON();
-  },
-  [symbol$1](that) {
-    return isList(that) && this._tag === that._tag && _equivalence(this, that);
-  },
-  [symbol]() {
-    return array(toReadonlyArray(this));
-  },
-  [Symbol.iterator]() {
-    let done = false;
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
-    let self = this;
-    return {
-      next() {
-        if (done) {
-          return this.return();
-        }
-        if (self._tag === "Nil") {
-          done = true;
-          return this.return();
-        }
-        const value = self.head;
-        self = self.tail;
-        return {
-          done,
-          value
-        };
-      },
-      return(value) {
-        if (!done) {
-          done = true;
-        }
-        return {
-          done: true,
-          value
-        };
-      }
-    };
-  },
-  pipe() {
-    return pipeArguments(this, arguments);
-  }
-};
-const makeCons = (head, tail) => {
-  const cons = Object.create(ConsProto);
-  cons.head = head;
-  cons.tail = tail;
-  return cons;
-};
-const NilProto = {
-  [TypeId]: TypeId,
-  _tag: "Nil",
-  toString() {
-    return toString(this.toJSON());
-  },
-  toJSON() {
-    return {
-      _id: "List",
-      _tag: "Nil"
-    };
-  },
-  [NodeInspectSymbol]() {
-    return this.toJSON();
-  },
-  [symbol]() {
-    return array(toReadonlyArray(this));
-  },
-  [symbol$1](that) {
-    return isList(that) && this._tag === that._tag;
-  },
-  [Symbol.iterator]() {
-    return {
-      next() {
-        return {
-          done: true,
-          value: undefined
-        };
-      }
-    };
-  },
-  pipe() {
-    return pipeArguments(this, arguments);
-  }
-};
-const _Nil = /*#__PURE__*/Object.create(NilProto);
-
-/**
- * Returns `true` if the specified value is a `List`, `false` otherwise.
- *
- * @since 2.0.0
- * @category refinements
- */
-const isList = u => isObject(u) && TypeId in u;
-
-/**
- * Returns `true` if the specified value is a `List.Nil<A>`, `false` otherwise.
- *
- * @since 2.0.0
- * @category refinements
- */
-const isNil = self => self._tag === "Nil";
-
-/**
- * Returns `true` if the specified value is a `List.Cons<A>`, `false` otherwise.
- *
- * @since 2.0.0
- * @category refinements
- */
-const isCons = self => self._tag === "Cons";
-
-/**
- * Returns the number of elements contained in the specified `List`
- *
- * @since 2.0.0
- * @category getters
- */
-const size = self => {
-  let these = self;
-  let len = 0;
-  while (!isNil(these)) {
-    len += 1;
-    these = these.tail;
-  }
-  return len;
-};
-
-/**
- * Constructs a new empty `List<A>`.
- *
- * @since 2.0.0
- * @category constructors
- */
-const nil = () => _Nil;
-
-/**
- * Constructs a new `List.Cons<A>` from the specified `head` and `tail` values.
- *
- * @since 2.0.0
- * @category constructors
- */
-const cons = (head, tail) => makeCons(head, tail);
-
-/**
- * Constructs a new empty `List<A>`.
- *
- * Alias of {@link nil}.
- *
- * @since 2.0.0
- * @category constructors
- */
-const empty = nil;
-
-/**
- * Constructs a new `List<A>` from the specified value.
- *
- * @since 2.0.0
- * @category constructors
- */
-const of = value => makeCons(value, _Nil);
-
-/**
- * Constructs a new `List<A>` from the specified `Iterable<A>`.
- *
- * @since 2.0.0
- * @category constructors
- */
-const fromIterable = prefix => {
-  const iterator = prefix[Symbol.iterator]();
-  let next;
-  if ((next = iterator.next()) && !next.done) {
-    const result = makeCons(next.value, _Nil);
-    let curr = result;
-    while ((next = iterator.next()) && !next.done) {
-      const temp = makeCons(next.value, _Nil);
-      curr.tail = temp;
-      curr = temp;
-    }
-    return result;
-  } else {
-    return _Nil;
-  }
-};
-
-/**
- * Constructs a new `List<A>` from the specified values.
- *
- * @since 2.0.0
- * @category constructors
- */
-const make = (...elements) => fromIterable(elements);
-
-/**
- * Appends the specified element to the end of the `List`, creating a new `Cons`.
- *
- * @category concatenating
- * @since 2.0.0
- */
-const append = /*#__PURE__*/dual(2, (self, element) => appendAllNonEmpty(self, of(element)));
-
-/**
- * Concatentates the specified lists together.
- *
- * @category concatenating
- * @since 2.0.0
- */
-const appendAll = /*#__PURE__*/dual(2, (self, that) => prependAll(that, self));
-
-/**
- * @category concatenating
- * @since 2.0.0
- */
-const appendAllNonEmpty = /*#__PURE__*/dual(2, (self, that) => appendAll(self, that));
-
-/**
- * Prepends the specified element to the beginning of the list.
- *
- * @category concatenating
- * @since 2.0.0
- */
-const prepend = /*#__PURE__*/dual(2, (self, element) => cons(element, self));
-
-/**
- * Prepends the specified prefix list to the beginning of the specified list.
- *
- * @category concatenating
- * @since 2.0.0
- */
-const prependAll = /*#__PURE__*/dual(2, (self, prefix) => {
-  if (isNil(self)) {
-    return prefix;
-  } else if (isNil(prefix)) {
-    return self;
-  } else {
-    const result = makeCons(prefix.head, self);
-    let curr = result;
-    let that = prefix.tail;
-    while (!isNil(that)) {
-      const temp = makeCons(that.head, self);
-      curr.tail = temp;
-      curr = temp;
-      that = that.tail;
-    }
-    return result;
-  }
-});
-
-/**
- * @category concatenating
- * @since 2.0.0
- */
-const prependAllNonEmpty = /*#__PURE__*/dual(2, (self, that) => prependAll(self, that));
-
-/**
- * Prepends the specified prefix list (in reverse order) to the beginning of the
- * specified list.
- *
- * @category concatenating
- * @since 2.0.0
- */
-const prependAllReversed = /*#__PURE__*/dual(2, (self, prefix) => {
-  let out = self;
-  let pres = prefix;
-  while (isCons(pres)) {
-    out = makeCons(pres.head, out);
-    pres = pres.tail;
-  }
-  return out;
-});
-
-/**
- * Drops the first `n` elements from the specified list.
- *
- * @since 2.0.0
- * @category combinators
- */
-const drop = /*#__PURE__*/dual(2, (self, n) => {
-  if (n <= 0) {
-    return self;
-  }
-  if (n >= size(self)) {
-    return _Nil;
-  }
-  let these = self;
-  let i = 0;
-  while (!isNil(these) && i < n) {
-    these = these.tail;
-    i += 1;
-  }
-  return these;
-});
-
-/**
- * Check if a predicate holds true for every `List` element.
- *
- * @since 2.0.0
- * @category elements
- */
-const every = /*#__PURE__*/dual(2, (self, refinement) => {
-  for (const a of self) {
-    if (!refinement(a)) {
-      return false;
-    }
-  }
-  return true;
-});
-
-/**
- * Check if a predicate holds true for some `List` element.
- *
- * @since 2.0.0
- * @category elements
- */
-const some = /*#__PURE__*/dual(2, (self, predicate) => {
-  let these = self;
-  while (!isNil(these)) {
-    if (predicate(these.head)) {
-      return true;
-    }
-    these = these.tail;
-  }
-  return false;
-});
-
-/**
- * Filters a list using the specified predicate.
- *
- * @since 2.0.0
- * @category combinators
- */
-const filter = /*#__PURE__*/dual(2, (self, predicate) => noneIn(self, predicate, false));
-
-// everything seen so far is not included
-const noneIn = (self, predicate, isFlipped) => {
-  /* eslint-disable no-constant-condition */
-  while (true) {
-    if (isNil(self)) {
-      return _Nil;
-    } else {
-      if (predicate(self.head) !== isFlipped) {
-        return allIn(self, self.tail, predicate, isFlipped);
-      } else {
-        self = self.tail;
-      }
-    }
-  }
-};
-
-// everything from 'start' is included, if everything from this point is in we can return the origin
-// start otherwise if we discover an element that is out we must create a new partial list.
-const allIn = (start, remaining, predicate, isFlipped) => {
-  /* eslint-disable no-constant-condition */
-  while (true) {
-    if (isNil(remaining)) {
-      return start;
-    } else {
-      if (predicate(remaining.head) !== isFlipped) {
-        remaining = remaining.tail;
-      } else {
-        return partialFill(start, remaining, predicate, isFlipped);
-      }
-    }
-  }
-};
-
-// we have seen elements that should be included then one that should be excluded, start building
-const partialFill = (origStart, firstMiss, predicate, isFlipped) => {
-  const newHead = makeCons(unsafeHead(origStart), _Nil);
-  let toProcess = unsafeTail(origStart);
-  let currentLast = newHead;
-
-  // we know that all elements are :: until at least firstMiss.tail
-  while (!(toProcess === firstMiss)) {
-    const newElem = makeCons(unsafeHead(toProcess), _Nil);
-    currentLast.tail = newElem;
-    currentLast = unsafeCoerce(newElem);
-    toProcess = unsafeCoerce(toProcess.tail);
-  }
-
-  // at this point newHead points to a list which is a duplicate of all the 'in' elements up to the first miss.
-  // currentLast is the last element in that list.
-
-  // now we are going to try and share as much of the tail as we can, only moving elements across when we have to.
-  let next = firstMiss.tail;
-  let nextToCopy = unsafeCoerce(next); // the next element we would need to copy to our list if we cant share.
-  while (!isNil(next)) {
-    // generally recommended is next.isNonEmpty but this incurs an extra method call.
-    const head = unsafeHead(next);
-    if (predicate(head) !== isFlipped) {
-      next = next.tail;
-    } else {
-      // its not a match - do we have outstanding elements?
-      while (!(nextToCopy === next)) {
-        const newElem = makeCons(unsafeHead(nextToCopy), _Nil);
-        currentLast.tail = newElem;
-        currentLast = newElem;
-        nextToCopy = unsafeCoerce(nextToCopy.tail);
-      }
-      nextToCopy = unsafeCoerce(next.tail);
-      next = next.tail;
-    }
-  }
-
-  // we have remaining elements - they are unchanged attach them to the end
-  if (!isNil(nextToCopy)) {
-    currentLast.tail = nextToCopy;
-  }
-  return newHead;
-};
-
-/**
- * Filters and maps a list using the specified partial function. The resulting
- * list may be smaller than the input list due to the possibility of the partial
- * function not being defined for some elements.
- *
- * @since 2.0.0
- * @category combinators
- */
-const filterMap = /*#__PURE__*/dual(2, (self, f) => {
-  const bs = [];
-  for (const a of self) {
-    const oa = f(a);
-    if (isSome(oa)) {
-      bs.push(oa.value);
-    }
-  }
-  return fromIterable(bs);
-});
-
-/**
- * Removes all `None` values from the specified list.
- *
- * @since 2.0.0
- * @category combinators
- */
-const compact = self => filterMap(self, identity);
-
-/**
- * Returns the first element that satisfies the specified
- * predicate, or `None` if no such element exists.
- *
- * @category elements
- * @since 2.0.0
- */
-const findFirst = /*#__PURE__*/dual(2, (self, predicate) => {
-  let these = self;
-  while (!isNil(these)) {
-    if (predicate(these.head)) {
-      return some$1(these.head);
-    }
-    these = these.tail;
-  }
-  return none();
-});
-
-/**
- * Flat maps a list using the specified function.
- *
- * @since 2.0.0
- * @category sequencing
- */
-const flatMap = /*#__PURE__*/dual(2, (self, f) => {
-  let rest = self;
-  let head = undefined;
-  let tail = undefined;
-  while (!isNil(rest)) {
-    let bs = f(rest.head);
-    while (!isNil(bs)) {
-      const next = makeCons(bs.head, _Nil);
-      if (tail === undefined) {
-        head = next;
-      } else {
-        tail.tail = next;
-      }
-      tail = next;
-      bs = bs.tail;
-    }
-    rest = rest.tail;
-  }
-  if (head === undefined) {
-    return _Nil;
-  }
-  return head;
-});
-
-/**
- * @category sequencing
- * @since 2.0.0
- */
-const flatMapNonEmpty = flatMap;
-
-/**
- * Applies the specified function to each element of the `List`.
- *
- * @since 2.0.0
- * @category combinators
- */
-const forEach = /*#__PURE__*/dual(2, (self, f) => {
-  let these = self;
-  while (!isNil(these)) {
-    f(these.head);
-    these = these.tail;
-  }
-});
-
-/**
- * Returns the first element of the specified list, or `None` if the list is
- * empty.
- *
- * @since 2.0.0
- * @category getters
- */
-const head = self => isNil(self) ? none() : some$1(self.head);
-
-/**
- * Returns the last element of the specified list, or `None` if the list is
- * empty.
- *
- * @since 2.0.0
- * @category getters
- */
-const last = self => isNil(self) ? none() : some$1(unsafeLast(self));
-
-/**
- * Applies the specified mapping function to each element of the list.
- *
- * @since 2.0.0
- * @category combinators
- */
-const map = /*#__PURE__*/dual(2, (self, f) => {
-  if (isNil(self)) {
-    return self;
-  } else {
-    const head = makeCons(f(self.head), _Nil);
-    let nextHead = head;
-    let rest = self.tail;
-    while (!isNil(rest)) {
-      const next = makeCons(f(rest.head), _Nil);
-      nextHead.tail = next;
-      nextHead = next;
-      rest = rest.tail;
-    }
-    return head;
-  }
-});
-
-/**
- * Partition a list into two lists, where the first list contains all elements
- * that did not satisfy the specified predicate, and the second list contains
- * all elements that did satisfy the specified predicate.
- *
- * @since 2.0.0
- * @category combinators
- */
-const partition = /*#__PURE__*/dual(2, (self, predicate) => {
-  const left = [];
-  const right = [];
-  for (const a of self) {
-    if (predicate(a)) {
-      right.push(a);
-    } else {
-      left.push(a);
-    }
-  }
-  return [fromIterable(left), fromIterable(right)];
-});
-
-/**
- * Partition a list into two lists, where the first list contains all elements
- * for which the specified function returned a `Left`, and the second list
- * contains all elements for which the specified function returned a `Right`.
- *
- * @since 2.0.0
- * @category combinators
- */
-const partitionMap = /*#__PURE__*/dual(2, (self, f) => {
-  const left = [];
-  const right = [];
-  for (const a of self) {
-    const e = f(a);
-    if (isLeft(e)) {
-      left.push(e.left);
-    } else {
-      right.push(e.right);
-    }
-  }
-  return [fromIterable(left), fromIterable(right)];
-});
-
-/**
- * Folds over the elements of the list using the specified function, using the
- * specified initial value.
- *
- * @since 2.0.0
- * @category folding
- */
-const reduce = /*#__PURE__*/dual(3, (self, zero, f) => {
-  let acc = zero;
-  let these = self;
-  while (!isNil(these)) {
-    acc = f(acc, these.head);
-    these = these.tail;
-  }
-  return acc;
-});
-
-/**
- * Folds over the elements of the list using the specified function, beginning
- * with the last element of the list, using the specified initial value.
- *
- * @since 2.0.0
- * @category folding
- */
-const reduceRight = /*#__PURE__*/dual(3, (self, zero, f) => {
-  let acc = zero;
-  let these = reverse(self);
-  while (!isNil(these)) {
-    acc = f(acc, these.head);
-    these = these.tail;
-  }
-  return acc;
-});
-
-/**
- * Returns a new list with the elements of the specified list in reverse order.
- *
- * @since 2.0.0
- * @category elements
- */
-const reverse = self => {
-  let result = empty();
-  let these = self;
-  while (!isNil(these)) {
-    result = prepend(result, these.head);
-    these = these.tail;
-  }
-  return result;
-};
-
-/**
- * Splits the specified list into two lists at the specified index.
- *
- * @since 2.0.0
- * @category combinators
- */
-const splitAt = /*#__PURE__*/dual(2, (self, n) => [take(self, n), drop(self, n)]);
-
-/**
- * Returns the tail of the specified list, or `None` if the list is empty.
- *
- * @since 2.0.0
- * @category getters
- */
-const tail = self => isNil(self) ? none() : some$1(self.tail);
-
-/**
- * Takes the specified number of elements from the beginning of the specified
- * list.
- *
- * @since 2.0.0
- * @category combinators
- */
-const take = /*#__PURE__*/dual(2, (self, n) => {
-  if (n <= 0) {
-    return _Nil;
-  }
-  if (n >= size(self)) {
-    return self;
-  }
-  let these = make(unsafeHead(self));
-  let current = unsafeTail(self);
-  for (let i = 1; i < n; i++) {
-    these = makeCons(unsafeHead(current), these);
-    current = unsafeTail(current);
-  }
-  return reverse(these);
-});
-
-/**
- * Converts the specified `List` to a `Chunk`.
- *
- * @since 2.0.0
- * @category conversions
- */
-const toChunk = self => fromIterable$1(self);
-
-/**
- * Unsafely returns the first element of the specified `List`.
- *
- * @since 2.0.0
- * @category unsafe
- */
-const unsafeHead = self => {
-  if (isNil(self)) {
-    throw new Error("Expected List to be non-empty");
-  }
-  return self.head;
-};
-
-/**
- * Unsafely returns the last element of the specified `List`.
- *
- * @since 2.0.0
- * @category unsafe
- */
-const unsafeLast = self => {
-  if (isNil(self)) {
-    throw new Error("Expected List to be non-empty");
-  }
-  let these = self;
-  let scout = self.tail;
-  while (!isNil(scout)) {
-    these = scout;
-    scout = scout.tail;
-  }
-  return these.head;
-};
-
-/**
- * Unsafely returns the tail of the specified `List`.
- *
- * @since 2.0.0
- * @category unsafe
- */
-const unsafeTail = self => {
-  if (isNil(self)) {
-    throw new Error("Expected List to be non-empty");
-  }
-  return self.tail;
-};
-
-var List = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  TypeId: TypeId,
-  toReadonlyArray: toReadonlyArray,
-  getEquivalence: getEquivalence,
-  isList: isList,
-  isNil: isNil,
-  isCons: isCons,
-  size: size,
-  nil: nil,
-  cons: cons,
-  empty: empty,
-  of: of,
-  fromIterable: fromIterable,
-  make: make,
-  append: append,
-  appendAll: appendAll,
-  appendAllNonEmpty: appendAllNonEmpty,
-  prepend: prepend,
-  prependAll: prependAll,
-  prependAllNonEmpty: prependAllNonEmpty,
-  prependAllReversed: prependAllReversed,
-  drop: drop,
-  every: every,
-  some: some,
-  filter: filter,
-  filterMap: filterMap,
-  compact: compact,
-  findFirst: findFirst,
-  flatMap: flatMap,
-  flatMapNonEmpty: flatMapNonEmpty,
-  forEach: forEach,
-  head: head,
-  last: last,
-  map: map,
-  partition: partition,
-  partitionMap: partitionMap,
-  reduce: reduce,
-  reduceRight: reduceRight,
-  reverse: reverse,
-  splitAt: splitAt,
-  tail: tail,
-  take: take,
-  toChunk: toChunk,
-  unsafeHead: unsafeHead,
-  unsafeLast: unsafeLast,
-  unsafeTail: unsafeTail
-});
-
-export { every as A, some as B, filter as C, filterMap as D, compact as E, flatMap as F, flatMapNonEmpty as G, forEach as H, last as I, map as J, partition as K, List as L, partitionMap as M, reduceRight as N, splitAt as O, tail as P, take as Q, toChunk as R, unsafeLast as S, TypeId as T, unsafeTail as a, isNil as b, cons as c, appendAll as d, empty as e, reverse as f, findFirst as g, head as h, isCons as i, getEquivalence as j, isList as k, fromIterable as l, make as m, nil as n, of as o, prepend as p, append as q, reduce as r, size as s, toReadonlyArray as t, unsafeHead as u, appendAllNonEmpty as v, prependAll as w, prependAllNonEmpty as x, prependAllReversed as y, drop as z };