effect 2.0.0-next.37 → 2.0.0-next.39

package/dist/List-d9775087.cjs.prod.js

@@ -0,0 +1,912 @@
+'use strict';
+
+var Chunk_dist_effectChunk = require('./Chunk-6cf5a8e6.cjs.prod.js');
+var Either_dist_effectEither = require('./Either-3fab3796.cjs.prod.js');
+var Equal_dist_effectEqual = require('./Equal-ce9977a8.cjs.prod.js');
+var Equivalence_dist_effectEquivalence = require('./Equivalence-0bc84518.cjs.prod.js');
+var Function_dist_effectFunction = require('./Function-2e6b0cda.cjs.prod.js');
+var Hash_dist_effectHash = require('./Hash-1bd73210.cjs.prod.js');
+var Inspectable_dist_effectInspectable = require('./Inspectable-3c4a0f5d.cjs.prod.js');
+var Option_dist_effectOption = require('./Option-02025c86.cjs.prod.js');
+var Pipeable_dist_effectPipeable = require('./Pipeable-d3ec6711.cjs.prod.js');
+var Predicate_dist_effectPredicate = require('./Predicate-daa86e61.cjs.prod.js');
+var ReadonlyArray_dist_effectReadonlyArray = require('./ReadonlyArray-8157f697.cjs.prod.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 => Equivalence_dist_effectEquivalence.mapInput(ReadonlyArray_dist_effectReadonlyArray.getEquivalence(isEquivalent), toReadonlyArray);
+const _equivalence = /*#__PURE__*/getEquivalence(Equal_dist_effectEqual.equals);
+const ConsProto = {
+  [TypeId]: TypeId,
+  _tag: "Cons",
+  toString() {
+    return Inspectable_dist_effectInspectable.toString(this.toJSON());
+  },
+  toJSON() {
+    return {
+      _id: "List",
+      _tag: "Cons",
+      values: toReadonlyArray(this).map(Inspectable_dist_effectInspectable.toJSON)
+    };
+  },
+  [Inspectable_dist_effectInspectable.NodeInspectSymbol]() {
+    return this.toJSON();
+  },
+  [Equal_dist_effectEqual.symbol](that) {
+    return isList(that) && this._tag === that._tag && _equivalence(this, that);
+  },
+  [Hash_dist_effectHash.symbol]() {
+    return Hash_dist_effectHash.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 Pipeable_dist_effectPipeable.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 Inspectable_dist_effectInspectable.toString(this.toJSON());
+  },
+  toJSON() {
+    return {
+      _id: "List",
+      _tag: "Nil"
+    };
+  },
+  [Inspectable_dist_effectInspectable.NodeInspectSymbol]() {
+    return this.toJSON();
+  },
+  [Hash_dist_effectHash.symbol]() {
+    return Hash_dist_effectHash.array(toReadonlyArray(this));
+  },
+  [Equal_dist_effectEqual.symbol](that) {
+    return isList(that) && this._tag === that._tag;
+  },
+  [Symbol.iterator]() {
+    return {
+      next() {
+        return {
+          done: true,
+          value: undefined
+        };
+      }
+    };
+  },
+  pipe() {
+    return Pipeable_dist_effectPipeable.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 => Predicate_dist_effectPredicate.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__*/Function_dist_effectFunction.dual(2, (self, element) => appendAllNonEmpty(self, of(element)));
+
+/**
+ * Concatentates the specified lists together.
+ *
+ * @category concatenating
+ * @since 2.0.0
+ */
+const appendAll = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => prependAll(that, self));
+
+/**
+ * @category concatenating
+ * @since 2.0.0
+ */
+const appendAllNonEmpty = /*#__PURE__*/Function_dist_effectFunction.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__*/Function_dist_effectFunction.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__*/Function_dist_effectFunction.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__*/Function_dist_effectFunction.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__*/Function_dist_effectFunction.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__*/Function_dist_effectFunction.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__*/Function_dist_effectFunction.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__*/Function_dist_effectFunction.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__*/Function_dist_effectFunction.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 = Function_dist_effectFunction.unsafeCoerce(newElem);
+    toProcess = Function_dist_effectFunction.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 = Function_dist_effectFunction.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 = Function_dist_effectFunction.unsafeCoerce(nextToCopy.tail);
+      }
+      nextToCopy = Function_dist_effectFunction.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__*/Function_dist_effectFunction.dual(2, (self, f) => {
+  const bs = [];
+  for (const a of self) {
+    const oa = f(a);
+    if (Option_dist_effectOption.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, Function_dist_effectFunction.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__*/Function_dist_effectFunction.dual(2, (self, predicate) => {
+  let these = self;
+  while (!isNil(these)) {
+    if (predicate(these.head)) {
+      return Option_dist_effectOption.some(these.head);
+    }
+    these = these.tail;
+  }
+  return Option_dist_effectOption.none();
+});
+
+/**
+ * Flat maps a list using the specified function.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const flatMap = /*#__PURE__*/Function_dist_effectFunction.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__*/Function_dist_effectFunction.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) ? Option_dist_effectOption.none() : Option_dist_effectOption.some(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) ? Option_dist_effectOption.none() : Option_dist_effectOption.some(unsafeLast(self));
+
+/**
+ * Applies the specified mapping function to each element of the list.
+ *
+ * @since 2.0.0
+ * @category combinators
+ */
+const map = /*#__PURE__*/Function_dist_effectFunction.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__*/Function_dist_effectFunction.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__*/Function_dist_effectFunction.dual(2, (self, f) => {
+  const left = [];
+  const right = [];
+  for (const a of self) {
+    const e = f(a);
+    if (Either_dist_effectEither.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__*/Function_dist_effectFunction.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__*/Function_dist_effectFunction.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__*/Function_dist_effectFunction.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) ? Option_dist_effectOption.none() : Option_dist_effectOption.some(self.tail);
+
+/**
+ * Takes the specified number of elements from the beginning of the specified
+ * list.
+ *
+ * @since 2.0.0
+ * @category combinators
+ */
+const take = /*#__PURE__*/Function_dist_effectFunction.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 => Chunk_dist_effectChunk.fromIterable(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
+});
+
+exports.List = List;
+exports.TypeId = TypeId;
+exports.append = append;
+exports.appendAll = appendAll;
+exports.appendAllNonEmpty = appendAllNonEmpty;
+exports.compact = compact;
+exports.cons = cons;
+exports.drop = drop;
+exports.empty = empty;
+exports.every = every;
+exports.filter = filter;
+exports.filterMap = filterMap;
+exports.findFirst = findFirst;
+exports.flatMap = flatMap;
+exports.flatMapNonEmpty = flatMapNonEmpty;
+exports.forEach = forEach;
+exports.fromIterable = fromIterable;
+exports.getEquivalence = getEquivalence;
+exports.head = head;
+exports.isCons = isCons;
+exports.isList = isList;
+exports.isNil = isNil;
+exports.last = last;
+exports.make = make;
+exports.map = map;
+exports.nil = nil;
+exports.of = of;
+exports.partition = partition;
+exports.partitionMap = partitionMap;
+exports.prepend = prepend;
+exports.prependAll = prependAll;
+exports.prependAllNonEmpty = prependAllNonEmpty;
+exports.prependAllReversed = prependAllReversed;
+exports.reduce = reduce;
+exports.reduceRight = reduceRight;
+exports.reverse = reverse;
+exports.size = size;
+exports.some = some;
+exports.splitAt = splitAt;
+exports.tail = tail;
+exports.take = take;
+exports.toChunk = toChunk;
+exports.toReadonlyArray = toReadonlyArray;
+exports.unsafeHead = unsafeHead;
+exports.unsafeLast = unsafeLast;
+exports.unsafeTail = unsafeTail;