@grain/stdlib 0.4.4 → 0.4.5

package/set.gr

@@ -10,12 +10,12 @@ import { hash } from "hash"
 
 record Bucket<t> {
   mut key: t,
-  mut next: Option<Bucket<t>>
+  mut next: Option<Bucket<t>>,
 }
 
 record Set<k> {
   mut size: Number,
-  mut buckets: Array<Option<Bucket<k>>>
+  mut buckets: Array<Option<Bucket<k>>>,
 }
 
 // TODO: This could take an `eq` function to custom comparisons
@@ -27,12 +27,9 @@ record Set<k> {
  * 
  * @since 0.3.0
  */
-export let makeSized = (storageLength) => {
-  let buckets = Array.make(storageLength, None);
-  {
-    size: 0,
-    buckets
-  }
+export let makeSized = storageLength => {
+  let buckets = Array.make(storageLength, None)
+  { size: 0, buckets }
 }
 /**
  * Creates a new, empty set.
@@ -46,8 +43,8 @@ export let make = () => {
 }
 
 let getBucketIndex = (key, buckets) => {
-  let bucketsLength = Array.length(buckets);
-  let hashedKey = hash(key);
+  let bucketsLength = Array.length(buckets)
+  let hashedKey = hash(key)
   hashedKey % bucketsLength
 }
 
@@ -55,45 +52,45 @@ let rec copyNodeWithNewHash = (oldNode, next, tail) => {
   match (oldNode) {
     None => void,
     Some(node) => {
-      let idx = getBucketIndex(node.key, next);
-      let newNode = Some(node);
+      let idx = getBucketIndex(node.key, next)
+      let newNode = Some(node)
       match (tail[idx]) {
         None => {
-          next[idx] = newNode;
+          next[idx] = newNode
         },
         Some(tailNode) => {
           // If there's already a tail node, we add this to the end
-          tailNode.next = newNode;
-        }
+          tailNode.next = newNode
+        },
       }
       // Always place this node as the new tail
-      tail[idx] = newNode;
+      tail[idx] = newNode
       // Recurse with the next node
-      copyNodeWithNewHash(node.next, next, tail);
-    }
+      copyNodeWithNewHash(node.next, next, tail)
+    },
   }
 }
 
-let resize = (set) => {
-  let currentBuckets = set.buckets;
-  let currentSize = Array.length(currentBuckets);
-  let nextSize = currentSize * 2;
+let resize = set => {
+  let currentBuckets = set.buckets
+  let currentSize = Array.length(currentBuckets)
+  let nextSize = currentSize * 2
   if (nextSize >= currentSize) {
-    let nextBuckets = Array.make(nextSize, None);
+    let nextBuckets = Array.make(nextSize, None)
     // This tracks the tail nodes so we can set their `next` to None
-    let tailNodes = Array.make(nextSize, None);
-    set.buckets = nextBuckets;
-    Array.forEach((old) => {
-      copyNodeWithNewHash(old, nextBuckets, tailNodes);
-    }, currentBuckets);
-    Array.forEach((tail) => {
+    let tailNodes = Array.make(nextSize, None)
+    set.buckets = nextBuckets
+    Array.forEach(old => {
+      copyNodeWithNewHash(old, nextBuckets, tailNodes)
+    }, currentBuckets)
+    Array.forEach(tail => {
       match (tail) {
         None => void,
         Some(node) => {
-          node.next = None;
-        }
+          node.next = None
+        },
       }
-    }, tailNodes);
+    }, tailNodes)
   } else {
     void
   }
@@ -105,7 +102,7 @@ let rec nodeInBucket = (key, node) => {
   } else {
     match (node.next) {
       None => false,
-      Some(next) => nodeInBucket(key, next)
+      Some(next) => nodeInBucket(key, next),
     }
   }
 }
@@ -119,24 +116,24 @@ let rec nodeInBucket = (key, node) => {
  * @since 0.3.0
  */
 export let add = (key, set) => {
-  let buckets = set.buckets;
+  let buckets = set.buckets
   let idx = getBucketIndex(key, buckets)
-  let bucket = buckets[idx];
+  let bucket = buckets[idx]
   match (bucket) {
     None => {
-      buckets[idx] = Some({ key, next: None });
-      set.size = incr(set.size);
+      buckets[idx] = Some({ key, next: None })
+      set.size = incr(set.size)
     },
     Some(node) => {
       if (!nodeInBucket(key, node)) {
-        buckets[idx] = Some({ key, next: bucket });
-        set.size = incr(set.size);
-      };
-    }
+        buckets[idx] = Some({ key, next: bucket })
+        set.size = incr(set.size)
+      }
+    },
   }
   // Resize if there are more than 2x the amount of nodes as buckets
-  if (set.size > (Array.length(buckets) * 2)) {
-    resize(set);
+  if (set.size > Array.length(buckets) * 2) {
+    resize(set)
   } else {
     void
   }
@@ -152,12 +149,12 @@ export let add = (key, set) => {
  * @since 0.3.0
  */
 export let contains = (key, set) => {
-  let buckets = set.buckets;
-  let idx = getBucketIndex(key, buckets);
-  let bucket = buckets[idx];
+  let buckets = set.buckets
+  let idx = getBucketIndex(key, buckets)
+  let bucket = buckets[idx]
   match (bucket) {
     None => false,
-    Some(node) => nodeInBucket(key, node)
+    Some(node) => nodeInBucket(key, node),
   }
 }
 
@@ -166,12 +163,12 @@ let rec removeInBucket = (key, node) => {
     None => false,
     Some(next) => {
       if (key == next.key) {
-        node.next = next.next;
+        node.next = next.next
         true
       } else {
         removeInBucket(key, next)
       }
-    }
+    },
   }
 }
 
@@ -184,22 +181,22 @@ let rec removeInBucket = (key, node) => {
  * @since 0.3.0
  */
 export let remove = (key, set) => {
-  let buckets = set.buckets;
-  let idx = getBucketIndex(key, buckets);
-  let bucket = buckets[idx];
+  let buckets = set.buckets
+  let idx = getBucketIndex(key, buckets)
+  let bucket = buckets[idx]
   match (bucket) {
     None => void,
     Some(node) => {
       // If it is a top-level node, just replace with next node
       if (key == node.key) {
-        set.size = decr(set.size);
-        buckets[idx] = node.next;
+        set.size = decr(set.size)
+        buckets[idx] = node.next
       } else {
         if (removeInBucket(key, node)) {
-          set.size = decr(set.size);
+          set.size = decr(set.size)
         }
       }
-    }
+    },
   }
 }
 
@@ -211,7 +208,7 @@ export let remove = (key, set) => {
  * 
  * @since 0.3.0
  */
-export let size = (set) => {
+export let size = set => {
   set.size
 }
 
@@ -223,7 +220,7 @@ export let size = (set) => {
  * 
  * @since 0.3.0
  */
-export let isEmpty = (set) => {
+export let isEmpty = set => {
   size(set) == 0
 }
 
@@ -234,21 +231,21 @@ export let isEmpty = (set) => {
  * 
  * @since 0.3.0
  */
-export let clear = (set) => {
-  set.size = 0;
-  let buckets = set.buckets;
+export let clear = set => {
+  set.size = 0
+  let buckets = set.buckets
   Array.forEachi((bucket, idx) => {
-    buckets[idx] = None;
-  }, buckets);
+    buckets[idx] = None
+  }, buckets)
 }
 
 let rec forEachBucket = (fn, node) => {
   match (node) {
     None => void,
     Some({ key, next }) => {
-      fn(key);
-      forEachBucket(fn, next);
-    }
+      fn(key)
+      forEachBucket(fn, next)
+    },
   }
 }
 
@@ -261,17 +258,16 @@ let rec forEachBucket = (fn, node) => {
  * @since 0.3.0
  */
 export let forEach = (fn, set) => {
-  let buckets = set.buckets;
-  Array.forEach((bucket) => {
+  let buckets = set.buckets
+  Array.forEach(bucket => {
     forEachBucket(fn, bucket)
-  }, buckets);
+  }, buckets)
 }
 
 let rec reduceEachBucket = (fn, node, acc) => {
   match (node) {
     None => acc,
-    Some({ key, next }) =>
-      reduceEachBucket(fn, next, fn(acc, key))
+    Some({ key, next }) => reduceEachBucket(fn, next, fn(acc, key)),
   }
 }
 
@@ -286,11 +282,11 @@ let rec reduceEachBucket = (fn, node, acc) => {
  * @since 0.3.0
  */
 export let reduce = (fn, init, set) => {
-  let buckets = set.buckets;
-  let mut acc = init;
-  Array.forEach((bucket) => {
+  let buckets = set.buckets
+  let mut acc = init
+  Array.forEach(bucket => {
     acc = reduceEachBucket(fn, bucket, acc)
-  }, buckets);
+  }, buckets)
   acc
 }
 
@@ -303,15 +299,14 @@ export let reduce = (fn, init, set) => {
  * @since 0.3.0
  */
 export let filter = (predicate, set) => {
-  let keysToRemove = reduce((list, key) =>
-    if (!predicate(key)) {
-      [key, ...list]
-    } else {
-      list
-    }, [], set);
-  List.forEach((key) => {
-    remove(key, set);
-  }, keysToRemove);
+  let keysToRemove = reduce((list, key) => if (!predicate(key)) {
+    [key, ...list]
+  } else {
+    list
+  }, [], set)
+  List.forEach(key => {
+    remove(key, set)
+  }, keysToRemove)
 }
 
 /**
@@ -323,7 +318,7 @@ export let filter = (predicate, set) => {
  * @since 0.3.0
  */
 export let reject = (predicate, set) => {
-  filter((key) => !predicate(key), set)
+  filter(key => !predicate(key), set)
 }
 
 /**
@@ -334,7 +329,7 @@ export let reject = (predicate, set) => {
  * 
  * @since 0.3.0
  */
-export let toList = (set) => {
+export let toList = set => {
   reduce((list, key) => [key, ...list], [], set)
 }
 
@@ -346,11 +341,11 @@ export let toList = (set) => {
  * 
  * @since 0.3.0
  */
-export let fromList = (list) => {
-  let set = make();
-  List.forEach((key) => {
-    add(key, set);
-  }, list);
+export let fromList = list => {
+  let set = make()
+  List.forEach(key => {
+    add(key, set)
+  }, list)
   set
 }
 
@@ -362,7 +357,7 @@ export let fromList = (list) => {
  * 
  * @since 0.3.0
  */
-export let toArray = (set) => {
+export let toArray = set => {
   Array.fromList(toList(set))
 }
 
@@ -374,11 +369,11 @@ export let toArray = (set) => {
  * 
  * @since 0.3.0
  */
-export let fromArray = (array) => {
-  let set = make();
-  Array.forEach((key) => {
-    add(key, set);
-  }, array);
+export let fromArray = array => {
+  let set = make()
+  Array.forEach(key => {
+    add(key, set)
+  }, array)
   set
 }
 
@@ -392,13 +387,13 @@ export let fromArray = (array) => {
  * @since 0.3.0
  */
 export let union = (set1, set2) => {
-  let set = make();
-  forEach((key) => {
-    add(key, set);
+  let set = make()
+  forEach(key => {
+    add(key, set)
   }, set1)
-  forEach((key) => {
-    add(key, set);
-  }, set2);
+  forEach(key => {
+    add(key, set)
+  }, set2)
   set
 }
 
@@ -412,17 +407,17 @@ export let union = (set1, set2) => {
  * @since 0.3.0
  */
 export let diff = (set1, set2) => {
-  let set = make();
-  forEach((key) => {
+  let set = make()
+  forEach(key => {
     if (!contains(key, set2)) {
-      add(key, set);
+      add(key, set)
     }
   }, set1)
-  forEach((key) => {
+  forEach(key => {
     if (!contains(key, set1)) {
-      add(key, set);
+      add(key, set)
     }
-  }, set2);
+  }, set2)
   set
 }
 
@@ -436,17 +431,17 @@ export let diff = (set1, set2) => {
  * @since 0.3.0
  */
 export let intersect = (set1, set2) => {
-  let set = make();
-  forEach((key) => {
+  let set = make()
+  forEach(key => {
     if (contains(key, set2)) {
-      add(key, set);
+      add(key, set)
     }
   }, set1)
-  forEach((key) => {
+  forEach(key => {
     if (contains(key, set1)) {
-      add(key, set);
+      add(key, set)
     }
-  }, set2);
+  }, set2)
   set
 }
 
@@ -460,6 +455,6 @@ export let intersect = (set1, set2) => {
  * 
  * @since 0.3.0
  */
-export let getInternalStats = (set) => {
+export let getInternalStats = set => {
   (set.size, Array.length(set.buckets))
 }

package/stack.gr

@@ -13,7 +13,7 @@ import List from "list"
  * Stacks are immutable data structures that store their data in a List.
  */
 record Stack<a> {
-    data: List<a>
+  data: List<a>,
 }
 
 /**
@@ -26,7 +26,7 @@ record Stack<a> {
  * @returns An empty stack
  */
 export let make = () => {
-    { data: [] }
+  { data: [], }
 }
 
 /**
@@ -35,11 +35,11 @@ export let make = () => {
  * @param stack: The stack to check
  * @returns `true` if the stack has no items, and `false` otherwise
  */
-export let isEmpty = (stack) => {
-    match (stack) {
-        { data: [] } => true,
-        _ => false
-    }
+export let isEmpty = stack => {
+  match (stack) {
+    { data: [] } => true,
+    _ => false,
+  }
 }
 
 /**
@@ -48,11 +48,11 @@ export let isEmpty = (stack) => {
  * @param stack: The stack to inspect
  * @returns The value at the top of the stack, if it exists
  */
-export let peek = (stack) => {
-    match (stack) {
-        { data: [] } => None,
-        { data } => List.head(data)
-    }
+export let peek = stack => {
+  match (stack) {
+    { data: [] } => None,
+    { data } => List.head(data),
+  }
 }
 
 /**
@@ -63,10 +63,10 @@ export let peek = (stack) => {
  * @returns A new stack with the item added to the end
  */
 export let push = (value, stack) => {
-    match (stack) {
-        { data: [] } => { data: [value] },
-        { data } => { data: [value, ...data] }
-    }
+  match (stack) {
+    { data: [] } => { data: [value], },
+    { data } => { data: [value, ...data], },
+  }
 }
 
 /**
@@ -75,11 +75,11 @@ export let push = (value, stack) => {
  * @param stack: The stack being updated
  * @returns A new stack with the last item removed
  */
-export let pop = (stack) => {
-    match (stack) {
-        { data: [] } => stack,
-        { data: [head, ...tail] } => { data: tail, }
-    }
+export let pop = stack => {
+  match (stack) {
+    { data: [] } => stack,
+    { data: [head, ...tail] } => { data: tail, },
+  }
 }
 
 /**
@@ -88,9 +88,9 @@ export let pop = (stack) => {
  * @param stack: The stack to inspect
  * @returns The count of the items in the stack
  */
-export let size = (stack) => {
-    match (stack) {
-        { data: [] } => 0,
-        { data } => List.length(data)
-    }
+export let size = stack => {
+  match (stack) {
+    { data: [] } => 0,
+    { data } => List.length(data),
+  }
 }