@grain/stdlib 0.5.12 → 0.6.0

package/immutablearray.gr

@@ -1,929 +0,0 @@
-/**
- * @module ImmutableArray: An immutable array implementation, providing fast arbitrary lookups and modifications.
- *
- * @example import ImmutableArray from "immutablearray"
- *
- * @since v0.6.0
- */
-
-import List from "list"
-import Array from "array"
-import Set from "set"
-import Buffer from "buffer"
-import Option from "option"
-import Number from "number"
-import Exception from "runtime/exception"
-
-// Immutable arrays implemented as relaxed radix balanced trees. This data
-// structure allows access and updating in O(log(n)) time, but since the tree
-// branching factor is chosen to be a large number (32), these operations run
-// in effectively constant time in most practical situations.
-
-// This implementation was adapted from Elm's Array module
-// https://github.com/elm/core/blob/master/src/Array.elm
-// license of software used:
-
-// Copyright 2014-present Evan Czaplicki
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are met:
-//
-// 1. Redistributions of source code must retain the above copyright notice,
-//    this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright notice,
-//    this list of conditions and the following disclaimer in the documentation
-//    and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the copyright holder nor the names of its
-//    contributors may be used to endorse or promote products derived from this
-//    software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
-// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-// POSSIBILITY OF SUCH DAMAGE.
-
-// Maximum number of children each tree node can have;
-// an arbitrary multiple of 2 that gives a good performance tradeoff
-let branchingFactor = 32
-// 32 = 2^5
-let branchingBits = 5
-// To be applied to numbers to bring them within the range [0, 32)
-let bitmask = branchingFactor - 1
-
-type Tree<a> = Array<Node<a>>,
-enum Node<a> {
-  Tree(Tree<a>),
-  Leaf(Array<a>),
-}
-
-// a helper data structure used for building an array piece by piece
-record Builder<a> {
-  btail: Array<a>,
-  nodes: List<Node<a>>,
-  numNodes: Number,
-}
-
-/**
- * @section Types: Type declarations included in the ImmutableArray module.
- */
-
-// A "tail" of < 32 values at the end of the array is kept as a performance
-// optimization
-record ImmutableArray<a> {
-  length: Number,
-  shift: Number,
-  root: Tree<a>,
-  tail: Array<a>,
-}
-
-/**
- * @section Values: Functions and constants for working with immutable arrays.
- */
-
-/**
- * An empty array.
- * 
- * @since v0.6.0
- */
-export let empty = {
-  let empty = { length: 0, shift: branchingBits, root: [>], tail: [>] }
-  empty
-}
-
-/**
- * Determines if the array contains no elements.
- * 
- * @param array: The array to check
- * @returns `true` if the array is empty and `false` otherwise
- *
- * @since v0.6.0
- */
-export let isEmpty = array => array.length == 0
-
-/**
- * Provides the length of the input array.
- *
- * @param array: The array to inspect
- * @returns The number of elements in the array
- *
- * @example length(fromList([1, 2, 3, 4, 5])) == 5
- * @since v0.6.0
- */
-export let length = array => array.length
-
-let tailIndex = length => {
-  let shiftedRight = length >> branchingBits
-  shiftedRight << branchingBits
-}
-
-let wrapNegativeIndex = (len, index) => {
-  if (index >= 0) index else len + index
-}
-
-let arraySetCopy = (index, value, array) => {
-  let copy = Array.copy(array)
-  copy[index] = value
-  copy
-}
-
-// Appends 2 arrays together, truncating to a max size of 32 for storage in
-// a tree node. Also returns number of elements truncated.
-let arrayAppendMax32 = (array1, array2) => {
-  let len1 = Array.length(array1)
-  let len2 = Array.length(array2)
-
-  let numToAppend = Number.min(len2, branchingFactor - len1)
-  let toAppend = if (numToAppend < len2) {
-    Array.slice(0, numToAppend, array2)
-  } else {
-    array2
-  }
-  let numNotAppended = len1 + len2 - branchingFactor
-
-  (Array.append(array1, toAppend), numNotAppended)
-}
-
-let log32floor = num => {
-  let mut val = -1
-  let mut num = num
-  while (num > 0) {
-    val += 1
-    num = num >> branchingBits
-  }
-  val
-}
-
-/**
- * Retrieves the element from the array at the specified index.
- * A negative index is treated as an offset from the end of the array.
- *
- * @param index: The index to access
- * @param array: The array to access
- * @returns The element from the array
- * @throws IndexOutOfBounds: When the index being accessed is outside the array's bounds
- * 
- * @example get(1, fromList([1, 2, 3, 4])) == 2
- * @example get(-1, fromList([1, 2, 3, 4])) == 4
- *
- * @since v0.6.0
- */
-export let get = (index, array) => {
-  let index = wrapNegativeIndex(array.length, index)
-
-  let rec getInner = (shift, node) => {
-    let pos = index >> shift & bitmask
-    match (node[pos]) {
-      Tree(subTree) => getInner(shift - branchingBits, subTree),
-      Leaf(vals) => vals[index & bitmask],
-    }
-  }
-
-  let { length, shift, root, tail } = array
-  if (index < 0 || index >= length) {
-    throw Exception.IndexOutOfBounds
-  } else if (index >= tailIndex(length)) {
-    tail[index & bitmask]
-  } else {
-    getInner(shift, root)
-  }
-}
-
-/**
- * Creates a new array in which the element at the specified index is set to a
- * new value. A negative index is treated as an offset from the end of the array.
- *
- * @param index: The index to update
- * @param value: The value to store
- * @param array: The array to update
- * @returns A new array containing the new element at the given index
- * @throws IndexOutOfBounds: When the index being updated is outside the array's bounds
- * 
- * @example set(1, 9, fromList([1, 2, 3, 4, 5])) == fromList([1, 9, 3, 4, 5])
- *
- * @since v0.6.0
- */
-export let set = (index, value, array) => {
-  let index = wrapNegativeIndex(array.length, index)
-
-  let rec setInner = (shift, node) => {
-    let pos = index >> shift & bitmask
-    let newVal = match (node[pos]) {
-      Tree(subTree) => {
-        Tree(setInner(shift - branchingBits, subTree))
-      },
-      Leaf(vals) => {
-        Leaf(arraySetCopy(index & bitmask, value, vals))
-      },
-    }
-    arraySetCopy(pos, newVal, node)
-  }
-
-  let { length, shift, root, tail } = array
-  if (index < 0 || index >= length) {
-    throw Exception.IndexOutOfBounds
-  } else if (index >= tailIndex(length)) {
-    { length, shift, root, tail: arraySetCopy(index & bitmask, value, tail) }
-  } else {
-    { length, shift, root: setInner(shift, root), tail }
-  }
-}
-
-// Inserts a new tail into the array. If the length of the tail equals the
-// branching factor, it is instead inserted into the main tree rather than
-// the tail
-let replaceTail = (newTail, array) => {
-  let rec insertTailInTree = (shift, node) => {
-    let pos = array.length >> shift & bitmask
-    if (pos >= Array.length(node)) {
-      let newElem = if (shift == branchingBits) {
-        Leaf(newTail)
-      } else {
-        Tree(insertTailInTree(shift - branchingBits, [>]))
-      }
-      Array.append(node, [> newElem])
-    } else {
-      let newSubTree = match (node[pos]) {
-        Tree(subTree) => subTree,
-        Leaf(_) => [> node[pos]],
-      }
-      let newNode = Tree(insertTailInTree(shift - branchingBits, newSubTree))
-      arraySetCopy(pos, newNode, node)
-    }
-  }
-
-  let { length, shift, root, tail } = array
-  let newArrayLen = length + (Array.length(newTail) - Array.length(tail))
-  if (Array.length(newTail) == branchingFactor) {
-    let overflow = newArrayLen >> branchingBits > 1 << shift
-    if (overflow) {
-      let newShift = shift + branchingBits
-      let newRoot = insertTailInTree(newShift, [> Tree(root)])
-      { length: newArrayLen, shift: newShift, root: newRoot, tail: [>] }
-    } else {
-      let newRoot = insertTailInTree(shift, root)
-      { length: newArrayLen, shift, root: newRoot, tail: [>] }
-    }
-  } else {
-    { length: newArrayLen, shift, root, tail: newTail }
-  }
-}
-
-let appendTree = (toAppend, array) => {
-  let (appended, numNotAppended) = arrayAppendMax32(array.tail, toAppend)
-  let newArray = replaceTail(appended, array)
-  if (numNotAppended > 0) {
-    let appendLen = Array.length(toAppend)
-    let newTail = Array.slice(appendLen - numNotAppended, appendLen, toAppend)
-    replaceTail(newTail, newArray)
-  } else {
-    newArray
-  }
-}
-
-// Flatten an array into a builder
-let arrayToBuilder = array => {
-  let rec reduceFn = (acc, node) => {
-    match (node) {
-      Tree(subTree) => Array.reduce(reduceFn, acc, subTree),
-      Leaf(_) => [node, ...acc],
-    }
-  }
-  let { tail, root, length, _ } = array
-  {
-    btail: tail,
-    nodes: Array.reduce(reduceFn, [], root),
-    numNodes: length >> branchingBits,
-  }
-}
-
-// For use to compress a large (> 32) list of nodes into subtrees
-let rec compressNodes = (nodes, acc) => {
-  let node = Array.fromList(List.take(branchingFactor, nodes))
-  let remaining = List.drop(branchingFactor, nodes)
-  let newAcc = [Tree(node), ...acc]
-  match (remaining) {
-    [] => List.reverse(newAcc),
-    _ => compressNodes(remaining, newAcc),
-  }
-}
-
-let builderToArray = builder => {
-  // Builds the non-tail portion of an array
-  let rec buildTree = (nodes, numNodes) => {
-    let newNodeSize = Number.ceil(numNodes / branchingFactor)
-    match (newNodeSize) {
-      1 => Array.fromList(nodes),
-      _ => buildTree(compressNodes(nodes, []), newNodeSize),
-    }
-  }
-
-  let { btail, nodes, numNodes } = builder
-  match (numNodes) {
-    0 =>
-      {
-        length: Array.length(btail),
-        shift: branchingBits,
-        root: [>],
-        tail: btail,
-      },
-    _ => {
-      let treeSize = numNodes * branchingFactor
-      let depth = log32floor(treeSize - 1)
-      {
-        length: treeSize + Array.length(btail),
-        shift: Number.max(1, depth) * branchingBits,
-        root: buildTree(nodes, numNodes),
-        tail: btail,
-      }
-    },
-  }
-}
-
-// Append a chunk of <= 32 values to a builder
-let appendBuilder = (toAppend, builder) => {
-  let { btail, nodes, numNodes } = builder
-  let (appended, numNotAppended) = arrayAppendMax32(btail, toAppend)
-
-  if (numNotAppended >= 0) {
-    let appendLen = Array.length(toAppend)
-    {
-      btail: Array.slice(appendLen - numNotAppended, appendLen, toAppend),
-      nodes: [Leaf(appended), ...nodes],
-      numNodes: numNodes + 1,
-    }
-  } else {
-    { btail: appended, nodes, numNodes }
-  }
-}
-
-/**
- * Creates a new array with the elements of the first array followed by
- * the elements of the second array.
- *
- * @param array1: The array containing elements to appear first
- * @param array2: The array containing elements to appear second
- * @returns The new array containing elements from `array1` followed by elements from `array2`
- *
- * @example append(fromList([1, 2]), fromList([3, 4, 5])) == fromList([1, 2, 3, 4, 5])
- *
- * @since v0.6.0
- */
-export let append = (array1, array2) => {
-  // Magic number of 4 determined best from benchmarks according to Elm's
-  // Array implementation
-  if (array2.length <= branchingFactor * 4) {
-    let rec reduceFn = (array, node) => {
-      match (node) {
-        Tree(subTree) => Array.reduce(reduceFn, array, subTree),
-        Leaf(vals) => appendTree(vals, array),
-      }
-    }
-    let withoutTail = Array.reduce(reduceFn, array1, array2.root)
-    appendTree(array2.tail, withoutTail)
-  } else {
-    let rec reduceFn = (builder, node) => {
-      match (node) {
-        Tree(subTree) => Array.reduce(reduceFn, builder, subTree),
-        Leaf(vals) => appendBuilder(vals, builder),
-      }
-    }
-    let withoutTail = Array.reduce(
-      reduceFn,
-      arrayToBuilder(array1),
-      array2.root
-    )
-    let { btail, nodes, numNodes } = appendBuilder(array2.tail, withoutTail)
-    builderToArray({ btail, nodes: List.reverse(nodes), numNodes })
-  }
-}
-
-/**
- * Creates a single array containing the elements of all arrays in the
- * provided list.
- *
- * @param arrays: A list containing all arrays to combine
- * @returns The new array
- * 
- * @example concat([fromList([1, 2]), fromList([3, 4]), fromList([5, 6])]) == fromList([1, 2, 3, 4, 5, 6])
- *
- * @since v0.6.0
- */
-export let concat = arrays => {
-  List.reduce(append, empty, arrays)
-}
-
-/**
- * Creates a new array of the specified length where each element is
- * initialized with the result of an initializer function. The initializer
- * is called with the index of each array element.
- *
- * @param length: The length of the new array
- * @param fn: The initializer function to call with each index, where the value returned will be used to initialize the element
- * @returns The new array
- *
- * @example init(5, i => i + 3) == fromList([3, 4, 5, 6, 7])
- *
- * @since v0.6.0
- */
-export let init = (length, fn) => {
-  let tailLen = length % branchingFactor
-  let btail = Array.init(tailLen, i => fn(length - tailLen + i))
-
-  let rec initInner = (beginI, nodes) => {
-    if (beginI < 0) {
-      builderToArray({ btail, nodes, numNodes: length >> branchingBits })
-    } else {
-      let leaf = Leaf(Array.init(branchingFactor, i => fn(beginI + i)))
-      initInner(beginI - branchingFactor, [leaf, ...nodes])
-    }
-  }
-  initInner(length - tailLen - branchingFactor, [])
-}
-
-/**
- * Creates a new array of the specified length with each element being
- * initialized with the given value.
- *
- * @param length: The length of the new array
- * @param value: The value to store at each index
- * @returns The new array
- *
- * @example make(5, "foo") == fromList(["foo", "foo", "foo", "foo", "foo"])
- *
- * @since v0.6.0
- */
-export let make = (length, value) => {
-  init(length, (_) => value)
-}
-
-/**
- * Iterates an array, calling an iterator function on each element.
- *
- * @param fn: The iterator function to call with each element
- * @param array: The array to iterate
- *
- * @since v0.6.0
- */
-export let forEach = (fn, array) => {
-  let rec forEachFn = node => {
-    match (node) {
-      Tree(subTree) => Array.forEach(forEachFn, subTree),
-      Leaf(vals) => Array.forEach(fn, vals),
-    }
-  }
-  let { tail, root, _ } = array
-  Array.forEach(forEachFn, root)
-  Array.forEach(fn, tail)
-}
-
-/**
- * Iterates an array a given number of times, calling an iterator function on each element.
- *
- * @param fn: The iterator function to call with each element
- * @param n: The number of times to iterate the given array
- * @param array: The array to iterate
- *
- * @since v0.6.0
- */
-export let cycle = (fn, n, array) => {
-  for (let mut i = 0; i < n; i += 1) {
-    forEach(fn, array)
-  }
-}
-
-/**
- * Produces a new array initialized with the results of a mapper function
- * called on each element of the input array.
- *
- * @param fn: The mapper function to call on each element, where the value returned will be used to initialize the element in the new array
- * @param array: The array to iterate
- * @returns The new array with mapped values
- *
- * @since v0.6.0
- */
-export let map = (fn, array) => {
-  let rec mapFn = node => {
-    match (node) {
-      Tree(subTree) => Tree(Array.map(mapFn, subTree)),
-      Leaf(vals) => Leaf(Array.map(fn, vals)),
-    }
-  }
-  let { length, shift, root, tail } = array
-  let newRoot = Array.map(mapFn, root)
-  let newTail = Array.map(fn, tail)
-  { length, shift, root: newRoot, tail: newTail }
-}
-
-/**
- * Combines all elements of an array using a reducer function,
- * starting from the "head", or left side, of the array.
- *
- * In `ImmutableArray.reduce(fn, initial, array)`, `fn` is called with
- * an accumulator and each element of the array, and returns
- * a new accumulator. The final value is the last accumulator
- * returned. The accumulator starts with value `initial`.
- *
- * @param fn: The reducer function to call on each element, where the value returned will be the next accumulator value
- * @param initial: The initial value to use for the accumulator on the first iteration
- * @param array: The array to iterate
- * @returns The final accumulator returned from `fn`
- *
- * @example reduce((acc, x) => acc + x, 0, fromList([1, 2, 3])) == 6
- *
- * @since v0.6.0
- */
-export let reduce = (fn, initial, array) => {
-  let rec reduceFn = (acc, node) => {
-    match (node) {
-      Tree(subTree) => Array.reduce(reduceFn, acc, subTree),
-      Leaf(vals) => Array.reduce(fn, acc, vals),
-    }
-  }
-  let { tail, root, _ } = array
-  let withoutTail = Array.reduce(reduceFn, initial, root)
-  Array.reduce(fn, withoutTail, tail)
-}
-
-/**
- * Combines all elements of an array using a reducer function,
- * starting from the "end", or right side, of the array.
- *
- * In `ImmutableArray.reduceRight(fn, initial, array)`, `fn` is called with
- * each element of the array and an accumulator, and returns
- * a new accumulator. The final value is the last accumulator
- * returned. The accumulator starts with value `initial`.
- *
- * @param fn: The reducer function to call on each element, where the value returned will be the next accumulator value
- * @param initial: The initial value to use for the accumulator on the first iteration
- * @param array: The array to iterate
- * @returns The final accumulator returned from `fn`
- *
- * @example reduceRight((x, acc) => acc ++ x, "", fromList(["baz", "bar", "foo"])) == "foobarbaz"
- *
- * @since v0.6.0
- */
-export let reduceRight = (fn, initial, array) => {
-  let rec reduceFn = (node, acc) => {
-    match (node) {
-      Tree(subTree) => Array.reduceRight(reduceFn, acc, subTree),
-      Leaf(vals) => Array.reduceRight(fn, acc, vals),
-    }
-  }
-  let { tail, root, _ } = array
-  let tailVal = Array.reduceRight(fn, initial, tail)
-  Array.reduceRight(reduceFn, tailVal, root)
-}
-
-/**
- * Produces a new array by calling a function on each element
- * of the input array. Each iteration produces an intermediate
- * array, which are all appended to produce a "flattened" array
- * of all results.
- *
- * @param fn: The function to be called on each element, where the value returned will be an array that gets appended to the new array
- * @param array: The array to iterate
- * @returns The new array
- * 
- * @example flatMap(n => fromList([n, n + 1]), fromList([1, 3, 5])) == fromList([1, 2, 3, 4, 5, 6])
- *
- * @since v0.6.0
- */
-export let flatMap = (fn, array) => {
-  reduce((acc, x) => append(acc, fn(x)), empty, array)
-}
-
-/**
- * Converts the input list to an array.
- *
- * @param list: The list to convert
- * @returns The array containing all elements from the list
- *
- * @since v0.6.0
- */
-export let fromList = list => {
-  let rec fromListInner = (list, nodes, numNodes) => {
-    let node = Array.fromList(List.take(branchingFactor, list))
-    let remaining = List.drop(branchingFactor, list)
-    if (Array.length(node) < branchingFactor) {
-      builderToArray({ btail: node, nodes: List.reverse(nodes), numNodes })
-    } else {
-      fromListInner(remaining, [Leaf(node), ...nodes], numNodes + 1)
-    }
-  }
-
-  fromListInner(list, [], 0)
-}
-
-/**
- * Converts the input array to a list.
- *
- * @param array: The array to convert
- * @returns The list containing all elements from the array
- *
- * @since v0.6.0
- */
-export let toList = array => {
-  reduceRight((val, list) => [val, ...list], [], array)
-}
-
-/**
- * Produces a new array by calling a function on each element of
- * the input array and only including it in the result array if the element satisfies
- * the condition.
- *
- * @param fn: The function to call on each element, where the returned value indicates if the element satisfies the condition
- * @param array: The array to iterate
- * @returns The new array containing elements where `fn` returned `true`
- *
- * @since v0.6.0
- */
-export let filter = (fn, array) => {
-  fromList(reduceRight((x, arr) => if (fn(x)) [x, ...arr] else arr, [], array))
-}
-
-/**
- * Checks that the given condition is satisfied for all
- * elements in the input array.
- *
- * @param fn: The function to call on each element, where the returned value indicates if the element satisfies the condition
- * @param array: The array to check
- * @returns `true` if all elements satify the condition or `false` otherwise
- *
- * @since v0.6.0
- */
-export let every = (fn, array) => {
-  reduce((acc, x) => acc && fn(x), true, array)
-}
-
-/**
- * Checks that the given condition is satisfied **at least
- * once** by an element in the input array.
- *
- * @param fn: The function to call on each element, where the returned value indicates if the element satisfies the condition
- * @param array: The array to iterate
- * @returns `true` if one or more elements satify the condition or `false` otherwise
- *
- * @since v0.6.0
- */
-export let some = (fn, array) => {
-  reduce((acc, x) => acc || fn(x), false, array)
-}
-
-/**
- * Creates a new array with all elements in reverse order.
- *
- * @param array: The array to reverse
- * @returns The new array
- *
- * @since v0.6.0
- */
-export let reverse = array => {
-  fromList(reduce((acc, x) => [x, ...acc], [], array))
-}
-
-/**
- * Checks if the value is an element of the input array.
- * Uses the generic `==` structural equality operator.
- *
- * @param search: The value to compare
- * @param array: The array to inspect
- * @returns `true` if the value exists in the array or `false` otherwise
- *
- * @since v0.6.0
- */
-export let contains = (value, array) => {
-  reduce((acc, x) => acc || x == value, false, array)
-}
-
-/**
- * Finds the first element in an array that satifies the given condition.
- *
- * @param fn: The function to call on each element, where the returned value indicates if the element satisfies the condition
- * @param array: The array to search
- * @returns `Some(element)` containing the first value found or `None` otherwise
- *
- * @since v0.6.0
- */
-export let find = (fn, array) => {
-  reduce((acc, x) => if (acc == None && fn(x)) Some(x) else acc, None, array)
-}
-
-/**
- * Finds the first index in an array where the element satifies the given condition.
- *
- * @param fn: The function to call on each element, where the returned value indicates if the element satisfies the condition
- * @param array: The array to search
- * @returns `Some(index)` containing the index of the first element found or `None` otherwise
- *
- * @since v0.6.0
- */
-export let findIndex = (fn, array) => {
-  let mut i = -1
-  reduce((acc, x) => {
-    i += 1
-    if (acc == None && fn(x)) Some(i) else acc
-  }, None, array)
-}
-
-/**
- * Combines two arrays into a Cartesian product of tuples containing
- * all ordered pairs `(a, b)`.
- *
- * @param array1: The array to provide values for the first tuple element
- * @param array2: The array to provide values for the second tuple element
- * @returns The new array containing all pairs of `(a, b)`
- *
- * @since v0.6.0
- */
-export let product = (array1, array2) => {
-  fromList(
-    reduceRight((x1, list) => {
-      reduceRight((x2, list) => [(x1, x2), ...list], list, array2)
-    }, [], array1)
-  )
-}
-
-/**
- * Counts the number of elements in an array that satisfy the given condition.
- *
- * @param fn: The function to call on each element, where the returned value indicates if the element satisfies the condition
- * @param array: The array to iterate
- * @returns The total number of elements that satisfy the condition
- *
- * @since v0.6.0
- */
-export let count = (fn, array) => {
-  reduce((acc, x) => if (fn(x)) acc + 1 else acc, 0, array)
-}
-
-/**
- * Produces a new array with any duplicates removed.
- * Uses the generic `==` structural equality operator.
- *
- * @param array: The array to filter
- * @returns The new array with only unique values
- *
- * @since v0.6.0
- */
-export let unique = array => {
-  let set = Set.fromList(toList(array))
-  filter(x => {
-    let good = Set.contains(x, set)
-    if (good) {
-      Set.remove(x, set)
-    }
-    good
-  }, array)
-}
-
-/**
- * Produces a new array filled with tuples of elements from both given arrays.
- * The first tuple will contain the first item of each array, the second tuple
- * will contain the second item of each array, and so on.
- *
- * Calling this function with arrays of different sizes will cause the returned
- * array to have the length of the smaller array.
- * 
- * @param array1: The array to provide values for the first tuple element
- * @param array2: The array to provide values for the second tuple element
- * @returns The new array containing indexed pairs of `(a, b)`
- *
- * @since v0.6.0
- */
-export let zip = (array1, array2) => {
-  fromList(List.zip(toList(array1), toList(array2)))
-}
-
-/**
- * Produces a new array filled with elements defined by applying a function on
- * pairs from both given arrays. The first element will contain the result of
- * applying the function to the first elements of each array, the second element
- * will contain the result of applying the function to the second elements of
- * each array, and so on.
- * 
- * Calling this function with arrays of different sizes will cause the returned
- * array to have the length of the smaller array.
- *
- * @param fn: The function to apply to pairs of elements
- * @param array1: The array whose elements will each be passed to the function as the first argument
- * @param array2: The array whose elements will each be passed to the function as the second argument
- * @returns The new array containing elements derived from applying the function to pairs of input array elements
- *
- * @example zipWith((a, b) => a + b, fromList([1, 2, 3]), fromList([4, 5, 6])) == fromList([5, 7, 9])
- * @example zipWith((a, b) => a * b, fromList([1, 2, 3]), fromList([4, 5])) == fromList([4, 10])
- * 
- * @since v0.6.0
- */
-export let zipWith = (fn, array1, array2) => {
-  fromList(List.zipWith(fn, toList(array1), toList(array2)))
-}
-
-/**
- * Produces two arrays by splitting apart an array of tuples.
- *
- * @param array: The array of tuples to split
- * @returns An array containing all elements from the first tuple element and an array containing all elements from the second tuple element
- *
- * @since v0.6.0
- */
-export let unzip = array => {
-  let (list1, list2) = List.unzip(toList(array))
-  (fromList(list1), fromList(list2))
-}
-
-/**
- * Concatenates an array of strings into a single string, separated by a separator string.
- *
- * @param separator: The separator to insert between items in the string
- * @param array: The input strings
- * @returns The concatenated string
- *
- * @since v0.6.0
- */
-export let join = (separator, array) => {
-  let buf = Buffer.make(16)
-  let mut i = 0
-  forEach(x => {
-    let toAdd = if (i != array.length - 1) x ++ separator else x
-    i += 1
-    Buffer.addString(toAdd, buf)
-  }, array)
-  Buffer.toString(buf)
-}
-
-let clampIndex = (len, index) => {
-  Number.min(len, Number.max(0, wrapNegativeIndex(len, index)))
-}
-
-/**
- * Slices an array given zero-based start and end indexes. The value
- * at the end index will not be included in the result.
- *
- * If either index is a negative number, it will be treated as a reverse index from
- * the end of the array.
- *
- * @param start: The index of the array where the slice will begin (inclusive)
- * @param end: The index of the array where the slice will end (exclusive)
- * @param array: The array to be sliced
- * @returns The subset of the array that was sliced
- * 
- * @example slice(0, 2, fromList(['a', 'b', 'c'])) == fromList(['a', 'b'])
- * @example slice(1, -1, fromList(['a', 'b', 'c'])) == fromList(['b'])
- *
- * @since v0.6.0
- */
-export let slice = (start, end, array) => {
-  let begin = clampIndex(array.length, start)
-  let end = clampIndex(array.length, end)
-  let mut i = array.length
-  fromList(
-    reduceRight((x, acc) => {
-      i -= 1
-      if (i >= begin && i < end) [x, ...acc] else acc
-    }, [], array)
-  )
-}
-
-/**
- * Sorts the given array based on a given comparator function.
- *
- * Ordering is calculated using a comparator function which takes two array elements and must return 0 if both are equal, a positive number if the first is greater, and a negative number if the first is smaller.
- * @param comp: The comparator function used to indicate sort order
- * @param array: The array to be sorted
- * @returns The sorted array
- *
- * @since v0.6.0
- */
-export let sort = (comp, array) => {
-  fromList(List.sort(comp, toList(array)))
-}
-
-/**
- * Rotates array elements by the specified amount to the left.
- *
- * If value is negative, array elements will be rotated by the
- * specified amount to the right. See examples.
- *
- * @param n: The number of elements to rotate by
- * @param array: The array to be rotated
- *
- * @example rotate(2, fromList([1, 2, 3, 4, 5])) == fromList([3, 4, 5, 1, 2])
- * @example rotate(-1, fromList([1, 2, 3, 4, 5])) == fromList([5, 1, 2, 3, 4])
- *
- * @since v0.6.0
- */
-export let rotate = (n, array) => {
-  let sliceI = if (array.length == 0) 0 else n % array.length
-  let before = slice(0, sliceI, array)
-  let after = slice(sliceI, array.length, array)
-  append(after, before)
-}