@grain/stdlib 0.5.13 → 0.6.0

package/set.gr

@@ -1,54 +1,53 @@
 /**
- * @module Set: A Set is an unordered collection of unique values. Operations on a Set mutate the internal state, so it never needs to be re-assigned.
- * @example import Set from "set"
- * 
+ * A Set is an unordered collection of unique values. Operations on a Set mutate the internal state, so it never needs to be re-assigned.
+ *
+ * An immutable set implementation is available in the `Immutable` submodule.
+ * @example from "set" include Set
+ *
  * @since v0.3.0
  */
-import List from "list"
-import Array from "array"
-import { hash } from "hash"
+module Set
+
+from "list" include List
+from "array" include Array
+from "hash" include Hash
+use Hash.{ hash }
 
-record Bucket<t> {
+record rec Bucket<t> {
   mut key: t,
   mut next: Option<Bucket<t>>,
 }
 
-/**
- * @section Types: Type declarations included in the Set module.
- */
-
-record Set<k> {
+abstract record Set<k> {
   mut size: Number,
   mut buckets: Array<Option<Bucket<k>>>,
 }
 
 /**
- * @section Values: Functions for working with Sets.
+ * Represents the internal state of a set.
  */
+provide record InternalSetStats {
+  currentSize: Number,
+  bucketCount: Number,
+}
 
 // TODO: This could take an `eq` function to custom comparisons
 /**
- * Creates a new empty set with an initial storage of the given size. As values are added or removed, the internal storage may grow or shrink. Generally, you won't need to care about the storage size of your set and can use `Set.make()` instead.
+ * Creates a new empty set with an initial storage of the given size. As
+ * values are added or removed, the internal storage may grow or shrink.
+ * Generally, you won't need to care about the storage size of your set and
+ * can use the default size.
  *
  * @param size: The initial storage size of the set
  * @returns An empty set with the given initial storage size
- * 
+ *
  * @since v0.3.0
+ * @history v0.6.0: Merged with `makeSized`; modified signature to accept size
  */
-export let makeSized = size => {
+provide let make = (size=16) => {
   let buckets = Array.make(size, None)
   { size: 0, buckets }
 }
-/**
- * Creates a new, empty set.
- *
- * @returns An empty set
- * 
- * @since v0.3.0
- */
-export let make = () => {
-  makeSized(16)
-}
 
 let getBucketIndex = (key, buckets) => {
   let bucketsLength = Array.length(buckets)
@@ -120,10 +119,10 @@ let rec nodeInBucket = (key, node) => {
  *
  * @param key: The value to add
  * @param set: The set to update
- * 
+ *
  * @since v0.3.0
  */
-export let add = (key, set) => {
+provide let add = (key, set) => {
   let buckets = set.buckets
   let idx = getBucketIndex(key, buckets)
   let bucket = buckets[idx]
@@ -153,10 +152,10 @@ export let add = (key, set) => {
  * @param key: The value to search for
  * @param set: The set to search
  * @returns `true` if the set contains the given value or `false` otherwise
- * 
+ *
  * @since v0.3.0
  */
-export let contains = (key, set) => {
+provide let contains = (key, set) => {
   let buckets = set.buckets
   let idx = getBucketIndex(key, buckets)
   let bucket = buckets[idx]
@@ -185,10 +184,10 @@ let rec removeInBucket = (key, node) => {
  *
  * @param key: The value to remove
  * @param set: The set to update
- * 
+ *
  * @since v0.3.0
  */
-export let remove = (key, set) => {
+provide let remove = (key, set) => {
   let buckets = set.buckets
   let idx = getBucketIndex(key, buckets)
   let bucket = buckets[idx]
@@ -213,10 +212,10 @@ export let remove = (key, set) => {
  *
  * @param set: The set to inspect
  * @returns The count of elements in the set
- * 
+ *
  * @since v0.3.0
  */
-export let size = set => {
+provide let size = set => {
   set.size
 }
 
@@ -225,10 +224,10 @@ export let size = set => {
  *
  * @param set: The set to inspect
  * @returns `true` if the given set is empty or `false` otherwise
- * 
+ *
  * @since v0.3.0
  */
-export let isEmpty = set => {
+provide let isEmpty = set => {
   size(set) == 0
 }
 
@@ -236,10 +235,10 @@ export let isEmpty = set => {
  * Resets the set by removing all values.
  *
  * @param set: The set to reset
- * 
+ *
  * @since v0.3.0
  */
-export let clear = set => {
+provide let clear = set => {
   set.size = 0
   let buckets = set.buckets
   Array.forEachi((bucket, idx) => {
@@ -262,11 +261,11 @@ let rec forEachBucket = (fn, node) => {
  *
  * @param fn: The iterator function to call with each element
  * @param set: The set to iterate
- * 
+ *
  * @since v0.3.0
  * @history v0.5.0: Ensured the iterator function return type is always `Void`
  */
-export let forEach = (fn, set) => {
+provide let forEach = (fn, set) => {
   let buckets = set.buckets
   Array.forEach(bucket => {
     forEachBucket(fn, bucket)
@@ -287,10 +286,10 @@ let rec reduceEachBucket = (fn, node, acc) => {
  * @param init: The initial value to use for the accumulator on the first iteration
  * @param set: The set to iterate
  * @returns The final accumulator returned from `fn`
- * 
+ *
  * @since v0.3.0
  */
-export let reduce = (fn, init, set) => {
+provide let reduce = (fn, init, set) => {
   let buckets = set.buckets
   let mut acc = init
   Array.forEach(bucket => {
@@ -304,10 +303,10 @@ export let reduce = (fn, init, set) => {
  *
  * @param fn: The predicate function to indicate which elements to remove from the set, where returning `false` indicates the value should be removed
  * @param set: The set to iterate
- * 
+ *
  * @since v0.3.0
  */
-export let filter = (fn, set) => {
+provide let filter = (fn, set) => {
   let keysToRemove = reduce((list, key) => if (!fn(key)) {
     [key, ...list]
   } else {
@@ -323,10 +322,10 @@ export let filter = (fn, set) => {
  *
  * @param fn: The predicate function to indicate which elements to remove from the set, where returning `true` indicates the value should be removed
  * @param set: The set to iterate
- * 
+ *
  * @since v0.3.0
  */
-export let reject = (fn, set) => {
+provide let reject = (fn, set) => {
   filter(key => !fn(key), set)
 }
 
@@ -335,10 +334,10 @@ export let reject = (fn, set) => {
  *
  * @param set: The set to convert
  * @returns A list containing all set values
- * 
+ *
  * @since v0.3.0
  */
-export let toList = set => {
+provide let toList = set => {
   reduce((list, key) => [key, ...list], [], set)
 }
 
@@ -347,10 +346,10 @@ export let toList = set => {
  *
  * @param list: The list to convert
  * @returns A set containing all list values
- * 
+ *
  * @since v0.3.0
  */
-export let fromList = list => {
+provide let fromList = list => {
   let set = make()
   List.forEach(key => {
     add(key, set)
@@ -363,10 +362,10 @@ export let fromList = list => {
  *
  * @param set: The set to convert
  * @returns An array containing all set values
- * 
+ *
  * @since v0.3.0
  */
-export let toArray = set => {
+provide let toArray = set => {
   Array.fromList(toList(set))
 }
 
@@ -375,10 +374,10 @@ export let toArray = set => {
  *
  * @param array: The array to convert
  * @returns A set containing all array values
- * 
+ *
  * @since v0.3.0
  */
-export let fromArray = array => {
+provide let fromArray = array => {
   let set = make()
   Array.forEach(key => {
     add(key, set)
@@ -392,10 +391,10 @@ export let fromArray = array => {
  * @param set1: The first set to combine
  * @param set2: The second set to combine
  * @returns A set containing all elements of both sets
- * 
+ *
  * @since v0.3.0
  */
-export let union = (set1, set2) => {
+provide let union = (set1, set2) => {
   let set = make()
   forEach(key => {
     add(key, set)
@@ -412,10 +411,10 @@ export let union = (set1, set2) => {
  * @param set1: The first set to combine
  * @param set2: The second set to combine
  * @returns A set containing only unshared elements from both sets
- * 
+ *
  * @since v0.3.0
  */
-export let diff = (set1, set2) => {
+provide let diff = (set1, set2) => {
   let set = make()
   forEach(key => {
     if (!contains(key, set2)) {
@@ -436,10 +435,10 @@ export let diff = (set1, set2) => {
  * @param set1: The first set to combine
  * @param set2: The second set to combine
  * @returns A set containing only shared elements from both sets
- * 
+ *
  * @since v0.3.0
  */
-export let intersect = (set1, set2) => {
+provide let intersect = (set1, set2) => {
   let set = make()
   forEach(key => {
     if (contains(key, set2)) {
@@ -454,15 +453,526 @@ export let intersect = (set1, set2) => {
   set
 }
 
-// TODO(#190): Should return a Record type instead of a Tuple
 /**
  * Provides data representing the internal state state of the set.
  *
  * @param set: The set to inspect
  * @returns The internal state of the set
- * 
+ *
  * @since v0.3.0
+ * @history v0.6.0: Return `InternalSetStats` record instead of a tuple
+ */
+provide let getInternalStats = set => {
+  { currentSize: set.size, bucketCount: Array.length(set.buckets) }
+}
+
+/**
+ * An immutable set implementation.
+ *
+ * @since v0.6.0
+ * @history v0.5.4: Originally in `"immutableset"` module
  */
-export let getInternalStats = set => {
-  (set.size, Array.length(set.buckets))
+provide module Immutable {
+  // implementation based on the paper "Implementing Sets Efficiently in a
+  // Functional Language" by Stephen Adams
+
+  record rec Node<a> {
+    key: a,
+    size: Number,
+    left: Set<a>,
+    right: Set<a>,
+  }
+  and abstract enum Set<a> {
+    Empty,
+    Tree(Node<a>),
+  }
+
+  // semi-arbitrary value chosen for algorithm for determining when to balance
+  // trees; no tree can have a left subtree containing this number of times
+  // more elements than its right subtree or vice versa
+  let weight = 4
+
+  /**
+   * An empty set
+   *
+   * @since v0.6.0
+   * @history v0.5.4: Originally in `"immutableset"` module
+   */
+  provide let empty = Empty
+
+  // returns the minimum value in a tree
+  let rec min = node => {
+    match (node) {
+      Tree({ key, left: Empty, _ }) => key,
+      Tree({ left, _ }) => min(left),
+      Empty => fail "Impossible: min of empty element in Set.Immutable",
+    }
+  }
+
+  /**
+   * Provides the count of values within the set.
+   *
+   * @param set: The set to inspect
+   * @returns The count of elements in the set
+   *
+   * @since v0.6.0
+   * @history v0.5.4: Originally in `"immutableset"` module
+   */
+  provide let size = set => {
+    match (set) {
+      Empty => 0,
+      Tree({ size, _ }) => size,
+    }
+  }
+
+  /**
+   * Determines if the set contains no elements.
+   *
+   * @param set: The set to inspect
+   * @returns `true` if the given set is empty or `false` otherwise
+   *
+   * @since v0.6.0
+   * @history v0.5.4: Originally in `"immutableset"` module
+   */
+  provide let isEmpty = set => {
+    match (set) {
+      Empty => true,
+      Tree(_) => false,
+    }
+  }
+
+  let unwrapTree = node => {
+    match (node) {
+      Empty =>
+        fail "Impossible: Set.Immutable unwrapTree got an empty tree node",
+      Tree(tree) => tree,
+    }
+  }
+
+  // helper function for creating a tree node with correct size from
+  // two balanced trees
+  let makeNode = (key, left, right) => {
+    Tree({ key, size: 1 + size(left) + size(right), left, right })
+  }
+
+  // note: see Figure 1 of paper referenced above for visual illustration of
+  // the rotations below
+
+  // node rotation moving the left subtree of the right node to the left side
+  let singleL = (key, left, right) => {
+    let { key: rKey, left: rl, right: rr, _ } = unwrapTree(right)
+    makeNode(rKey, makeNode(key, left, rl), rr)
+  }
+
+  // node rotation moving left child of right tree to the root
+  let doubleL = (key, left, right) => {
+    let { key: rKey, left: rl, right: rr, _ } = unwrapTree(right)
+    let { key: rlKey, left: rll, right: rlr, _ } = unwrapTree(rl)
+    makeNode(rlKey, makeNode(key, left, rll), makeNode(rKey, rlr, rr))
+  }
+
+  // node rotation moving the right subtree of the left node to the right side
+  let singleR = (key, left, right) => {
+    let { key: lKey, left: ll, right: lr, _ } = unwrapTree(left)
+    makeNode(lKey, ll, makeNode(key, lr, right))
+  }
+
+  // node rotation moving right child of left tree to the root
+  let doubleR = (key, left, right) => {
+    let { key: lKey, left: ll, right: lr, _ } = unwrapTree(left)
+    let { key: lrKey, left: lrl, right: lrr, _ } = unwrapTree(lr)
+    makeNode(lrKey, makeNode(lKey, ll, lrl), makeNode(key, lrr, right))
+  }
+
+  // creates a new node after either the left or right trees have just had an
+  // element inserted or removed from them, maintaining balance in the tree
+  let balancedNode = (key, left, right) => {
+    let makeNodeFn = if (size(left) + size(right) < 2) {
+      makeNode
+    } else if (size(right) > weight * size(left)) {
+      // if the right tree is too much larger than the left then move part of
+      // the right tree to the left side
+      let { left: rl, right: rr, _ } = unwrapTree(right)
+      if (size(rl) < size(rr)) singleL else doubleL
+    } else if (size(left) > weight * size(right)) {
+      // if the left tree is too much larger than the right then move part of
+      // the left tree to the right side
+      let { left: ll, right: lr, _ } = unwrapTree(left)
+      if (size(lr) < size(ll)) singleR else doubleR
+    } else {
+      // if neither tree is too much larger than the other then simply create
+      // a new node
+      makeNode
+    }
+
+    makeNodeFn(key, left, right)
+  }
+
+  /**
+   * Produces a new set by inserting the given value into the set. If the value
+   * already exists, the new set will have the same elements as the input set.
+   *
+   * @param key: The value to add
+   * @param set: The base set
+   * @returns A new set containing the new element
+   *
+   * @since v0.6.0
+   * @history v0.5.4: Originally in `"immutableset"` module
+   */
+  provide let rec add = (key, set) => {
+    match (set) {
+      Empty => Tree({ key, size: 1, left: Empty, right: Empty }),
+      Tree({ key: nodeKey, left, right, _ }) => {
+        match (compare(key, nodeKey)) {
+          cmp when cmp < 0 => balancedNode(nodeKey, add(key, left), right),
+          cmp when cmp > 0 => balancedNode(nodeKey, left, add(key, right)),
+          _ => makeNode(key, left, right),
+        }
+      },
+    }
+  }
+
+  /**
+   * Determines if the set contains the given value.
+   *
+   * @param key: The value to search for
+   * @param set: The set to search
+   * @returns `true` if the set contains the given value or `false` otherwise
+   *
+   * @since v0.6.0
+   * @history v0.5.4: Originally in `"immutableset"` module
+   */
+  provide let rec contains = (key, set) => {
+    match (set) {
+      Empty => false,
+      Tree({ key: nodeKey, left, right, _ }) => {
+        match (compare(key, nodeKey)) {
+          cmp when cmp < 0 => contains(key, left),
+          cmp when cmp > 0 => contains(key, right),
+          _ => true,
+        }
+      },
+    }
+  }
+
+  // removes the minimum element from a tree
+  let rec removeMin = node => {
+    match (node) {
+      Tree({ left: Empty, right, _ }) => right,
+      Tree({ key, left, right, _ }) =>
+        balancedNode(key, removeMin(left), right),
+      _ => fail "Impossible: Set.Immutable removeMin on empty node",
+    }
+  }
+
+  // helper function for removing a node by creating a new node containing the
+  // removed node's left and right subtrees
+  let removeInner = (left, right) => {
+    match ((left, right)) {
+      (Empty, node) | (node, Empty) => node,
+      (left, right) => {
+        balancedNode(min(right), left, removeMin(right))
+      },
+    }
+  }
+
+  /**
+   * Produces a new set without the given element. If the value doesn't exist in
+   * the set, the set will be returned unmodified.
+   *
+   * @param key: The value to exclude
+   * @param set: The set to exclude from
+   * @returns A new set without the excluded element
+   *
+   * @since v0.6.0
+   * @history v0.5.4: Originally in `"immutableset"` module
+   */
+  provide let rec remove = (key, set) => {
+    match (set) {
+      Empty => Empty,
+      Tree({ key: nodeKey, left, right, _ }) => {
+        match (compare(key, nodeKey)) {
+          cmp when cmp < 0 => balancedNode(nodeKey, remove(key, left), right),
+          cmp when cmp > 0 => balancedNode(nodeKey, left, remove(key, right)),
+          _ => removeInner(left, right),
+        }
+      },
+    }
+  }
+
+  /**
+   * Iterates the set, calling an iterator function on each element.
+   *
+   * @param fn: The iterator function to call with each element
+   * @param set: The set to iterate
+   *
+   * @since v0.6.0
+   * @history v0.5.4: Originally in `"immutableset"` module
+   */
+  provide let forEach = (fn, set) => {
+    let rec forEachInner = node => {
+      match (node) {
+        Empty => void,
+        Tree({ key, left, right, _ }) => {
+          forEachInner(left)
+          fn(key): Void
+          forEachInner(right)
+        },
+      }
+    }
+    forEachInner(set)
+  }
+
+  /**
+   * Combines all elements of a set using a reducer function.
+   *
+   * @param fn: The reducer function to call on each element, where the value returned will be the next accumulator value
+   * @param init: The initial value to use for the accumulator on the first iteration
+   * @param set: The set to iterate
+   * @returns The final accumulator returned from `fn`
+   *
+   * @since v0.6.0
+   * @history v0.5.4: Originally in `"immutableset"` module
+   */
+  provide let reduce = (fn, init, set) => {
+    let rec reduceInner = (acc, node) => {
+      match (node) {
+        Empty => acc,
+        Tree({ key, left, right, _ }) => {
+          let newAcc = fn(reduceInner(acc, left), key)
+          reduceInner(newAcc, right)
+        },
+      }
+    }
+    reduceInner(init, set)
+  }
+
+  // joins two trees with a value, preserving the BST property of left children
+  // being less the node and right children being greater than the node
+  let rec concat3 = (key, left, right) => {
+    match ((left, right)) {
+      (Empty, node) | (node, Empty) => add(key, node),
+      (Tree(left) as leftOpt, Tree(right) as rightOpt) => {
+        let { size: lSize, key: lKey, left: lLeft, right: lRight } = left
+        let { size: rSize, key: rKey, left: rLeft, right: rRight } = right
+        if (weight * lSize < rSize) {
+          balancedNode(rKey, concat3(key, leftOpt, rLeft), rRight)
+        } else if (weight * rSize < lSize) {
+          balancedNode(lKey, lLeft, concat3(key, lRight, rightOpt))
+        } else {
+          makeNode(key, leftOpt, rightOpt)
+        }
+      },
+    }
+  }
+
+  // returns a tree containing all of the nodes in the input tree whose values
+  // are less than the given value
+  let rec splitLt = (splitKey, node) => {
+    match (node) {
+      Empty => Empty,
+      Tree({ key, left, right, _ }) => {
+        match (compare(key, splitKey)) {
+          // we want this node, join it to the output
+          cmp when cmp < 0 => concat3(key, left, splitLt(splitKey, right)),
+          cmp when cmp > 0 => splitLt(splitKey, left),
+          _ => left,
+        }
+      },
+    }
+  }
+
+  // returns a tree containing all of the nodes in the input tree whose values
+  // are greater than the given value
+  let rec splitGt = (splitKey, node) => {
+    match (node) {
+      Empty => Empty,
+      Tree({ key, left, right, _ }) => {
+        match (compare(key, splitKey)) {
+          // we want this node, join it to the output
+          cmp when cmp > 0 => concat3(key, splitGt(splitKey, left), right),
+          cmp when cmp < 0 => splitGt(splitKey, right),
+          _ => right,
+        }
+      },
+    }
+  }
+
+  // concatenates two trees of arbitrary size
+  let concat = (node1, node2) => {
+    match (node2) {
+      Empty => node1,
+      _ => concat3(min(node2), node1, removeMin(node2)),
+    }
+  }
+
+  /**
+   * Produces a new set without the elements from the input set where a predicate function returns `false`.
+   *
+   * @param fn: The predicate function to indicate which elements to exclude from the set, where returning `false` indicates the value should be excluded
+   * @param set: The set to iterate
+   * @returns A new set excluding the elements not fulfilling the predicate
+   *
+   * @since v0.6.0
+   * @history v0.5.4: Originally in `"immutableset"` module
+   */
+  provide let filter = (fn, set) => {
+    let rec filterInner = node => {
+      match (node) {
+        Empty => Empty,
+        Tree({ key, left, right, _ }) => {
+          if (fn(key)) {
+            concat3(key, filterInner(left), filterInner(right))
+          } else {
+            concat(filterInner(left), filterInner(right))
+          }
+        },
+      }
+    }
+    filterInner(set)
+  }
+
+  /**
+   * Produces a new set without the elements from the input set where a predicate function returns `true`.
+   *
+   * @param fn: The predicate function to indicate which elements to exclude from the set, where returning `true` indicates the value should be excluded
+   * @param set: The set to iterate
+   * @returns A new set excluding the elements fulfilling the predicate
+   *
+   * @since v0.6.0
+   * @history v0.5.4: Originally in `"immutableset"` module
+   */
+  provide let reject = (fn, set) => {
+    filter(key => !fn(key), set)
+  }
+
+  /**
+   * Combines two sets into a single set containing all elements from both sets.
+   *
+   * @param set1: The first set to combine
+   * @param set2: The second set to combine
+   * @returns A set containing all elements of both sets
+   *
+   * @since v0.6.0
+   * @history v0.5.4: Originally in `"immutableset"` module
+   */
+  provide let rec union = (set1, set2) => {
+    match ((set1, set2)) {
+      (Empty, node) | (node, Empty) => node,
+      (node1, Tree({ key: key2, left: left2, right: right2, _ })) => {
+        let l = splitLt(key2, node1)
+        let r = splitGt(key2, node1)
+        concat3(key2, union(l, left2), union(r, right2))
+      },
+    }
+  }
+
+  /**
+   * Combines two sets into a single set containing only the elements not shared between both sets.
+   *
+   * @param set1: The first set to combine
+   * @param set2: The second set to combine
+   * @returns A set containing only unshared elements from both sets
+   *
+   * @since v0.6.0
+   * @history v0.5.4: Originally in `"immutableset"` module
+   */
+  provide let diff = (set1, set2) => {
+    let rec diffInner = (node1, node2) => {
+      match ((node1, node2)) {
+        (Empty, node) | (node, Empty) => node,
+        (node1, Tree({ key: key2, left: left2, right: right2, _ })) => {
+          let l = splitLt(key2, node1)
+          let r = splitGt(key2, node1)
+          concat(diffInner(l, left2), diffInner(r, right2))
+        },
+      }
+    }
+    union(diffInner(set1, set2), diffInner(set2, set1))
+  }
+
+  /**
+   * Combines two sets into a single set containing only the elements shared between both sets.
+   *
+   * @param set1: The first set to combine
+   * @param set2: The second set to combine
+   * @returns A set containing only shared elements from both sets
+   *
+   * @since v0.6.0
+   * @history v0.5.4: Originally in `"immutableset"` module
+   */
+  provide let rec intersect = (set1, set2) => {
+    match ((set1, set2)) {
+      (Empty, _) | (_, Empty) => Empty,
+      (node1, Tree({ key: key2, left: left2, right: right2, _ })) => {
+        let l = splitLt(key2, node1)
+        let r = splitGt(key2, node1)
+        if (contains(key2, node1)) {
+          concat3(key2, intersect(l, left2), intersect(r, right2))
+        } else {
+          concat(intersect(l, left2), intersect(r, right2))
+        }
+      },
+    }
+  }
+
+  /**
+   * Creates a set from a list.
+   *
+   * @param list: The list to convert
+   * @returns A set containing all list values
+   *
+   * @since v0.6.0
+   * @history v0.5.4: Originally in `"immutableset"` module
+   */
+  provide let fromList = list => {
+    List.reduce((set, key) => add(key, set), empty, list)
+  }
+
+  /**
+   * Converts a set into a list of its elements.
+   *
+   * @param set: The set to convert
+   * @returns A list containing all set values
+   *
+   * @since v0.6.0
+   * @history v0.5.4: Originally in `"immutableset"` module
+   */
+  provide let toList = set => {
+    let rec toListInner = (acc, node) => {
+      match (node) {
+        Empty => acc,
+        Tree({ key, left, right, _ }) => {
+          toListInner([key, ...toListInner(acc, right)], left)
+        },
+      }
+    }
+    toListInner([], set)
+  }
+
+  /**
+   * Creates a set from an array.
+   *
+   * @param array: The array to convert
+   * @returns A set containing all array values
+   *
+   * @since v0.6.0
+   * @history v0.5.4: Originally in `"immutableset"` module
+   */
+  provide let fromArray = array => {
+    Array.reduce((set, key) => add(key, set), empty, array)
+  }
+
+  /**
+   * Converts a set into an array of its elements.
+   *
+   * @param set: The set to convert
+   * @returns An array containing all set values
+   *
+   * @since v0.6.0
+   * @history v0.5.4: Originally in `"immutableset"` module
+   */
+  provide let toArray = set => {
+    Array.fromList(toList(set))
+  }
 }