@grain/stdlib 0.5.3 → 0.5.4

package/runtime/numbers.gr

@@ -79,7 +79,7 @@ export let isFloat = x => {
   if (isBoxedNumber(x)) {
     let tag = WasmI32.load(x, 4n)
     WasmI32.eq(tag, Tags._GRAIN_FLOAT32_BOXED_NUM_TAG) ||
-    WasmI32.eq(tag, Tags._GRAIN_FLOAT64_BOXED_NUM_TAG)
+      WasmI32.eq(tag, Tags._GRAIN_FLOAT64_BOXED_NUM_TAG)
   } else {
     false
   }
@@ -90,8 +90,8 @@ export let isInteger = x => {
   if (isBoxedNumber(x)) {
     let tag = WasmI32.load(x, 4n)
     WasmI32.eq(tag, Tags._GRAIN_INT32_BOXED_NUM_TAG) ||
-    WasmI32.eq(tag, Tags._GRAIN_INT64_BOXED_NUM_TAG) ||
-    WasmI32.eq(tag, Tags._GRAIN_BIGINT_BOXED_NUM_TAG)
+      WasmI32.eq(tag, Tags._GRAIN_INT64_BOXED_NUM_TAG) ||
+      WasmI32.eq(tag, Tags._GRAIN_BIGINT_BOXED_NUM_TAG)
   } else {
     true
   }
@@ -518,13 +518,13 @@ let isIntegerF64 = value => {
 @unsafe
 let isSafeIntegerF32 = value => {
   WasmF32.le(WasmF32.abs(value), _F32_MAX_SAFE_INTEGER) &&
-  WasmF32.eq(WasmF32.trunc(value), value)
+    WasmF32.eq(WasmF32.trunc(value), value)
 }
 
 @unsafe
 let isSafeIntegerF64 = value => {
   WasmF64.le(WasmF64.abs(value), _F64_MAX_SAFE_INTEGER) &&
-  WasmF64.eq(WasmF64.trunc(value), value)
+    WasmF64.eq(WasmF64.trunc(value), value)
 }
 
 /** Number-aware equality checking
@@ -564,12 +564,12 @@ let numberEqualSimpleHelp = (x, y) => {
       t when WasmI32.eq(t, Tags._GRAIN_FLOAT32_BOXED_NUM_TAG) => {
         let yBoxedVal = boxedFloat32Number(y)
         isSafeIntegerF32(yBoxedVal) &&
-        WasmF32.eq(WasmF32.convertI32S(xval), yBoxedVal)
+          WasmF32.eq(WasmF32.convertI32S(xval), yBoxedVal)
       },
       t when WasmI32.eq(t, Tags._GRAIN_FLOAT64_BOXED_NUM_TAG) => {
         let yBoxedVal = boxedFloat64Number(y)
         isSafeIntegerF64(yBoxedVal) &&
-        WasmF64.eq(WasmF64.convertI32S(xval), yBoxedVal)
+          WasmF64.eq(WasmF64.convertI32S(xval), yBoxedVal)
       },
       _ => {
         throw UnknownNumberTag
@@ -606,12 +606,12 @@ let numberEqualInt64Help = (xBoxedVal, y) => {
       t when WasmI32.eq(t, Tags._GRAIN_FLOAT32_BOXED_NUM_TAG) => {
         let yBoxedVal = boxedFloat32Number(y)
         isSafeIntegerF32(yBoxedVal) &&
-        WasmI64.eq(xBoxedVal, WasmI64.truncF32S(yBoxedVal))
+          WasmI64.eq(xBoxedVal, WasmI64.truncF32S(yBoxedVal))
       },
       t when WasmI32.eq(t, Tags._GRAIN_FLOAT64_BOXED_NUM_TAG) => {
         let yBoxedVal = boxedFloat64Number(y)
         isSafeIntegerF64(yBoxedVal) &&
-        WasmI64.eq(xBoxedVal, WasmI64.truncF64S(yBoxedVal))
+          WasmI64.eq(xBoxedVal, WasmI64.truncF64S(yBoxedVal))
       },
       _ => {
         throw UnknownNumberTag
@@ -843,14 +843,16 @@ let numberAddSubSimpleHelp = (x, y, isSub) => {
       t when WasmI32.eq(t, Tags._GRAIN_INT32_BOXED_NUM_TAG) => {
         let xval = WasmI64.extendI32S(xval)
         let yBoxedVal = WasmI64.extendI32S(boxedInt32Number(y))
-        let result = if (isSub) WasmI64.sub(xval, yBoxedVal)
+        let result =
+          if (isSub) WasmI64.sub(xval, yBoxedVal)
           else WasmI64.add(xval, yBoxedVal)
         reducedInteger(result)
       },
       t when WasmI32.eq(t, Tags._GRAIN_INT64_BOXED_NUM_TAG) => {
         let yBoxedVal = boxedInt64Number(y)
         let xval64 = WasmI64.extendI32S(xval)
-        let result = if (isSub) WasmI64.sub(xval64, yBoxedVal)
+        let result =
+          if (isSub) WasmI64.sub(xval64, yBoxedVal)
           else WasmI64.add(xval64, yBoxedVal)
         if (
           WasmI64.geS(yBoxedVal, 0N) && WasmI64.ltS(result, xval64) ||
@@ -884,7 +886,8 @@ let numberAddSubSimpleHelp = (x, y, isSub) => {
         let yDenominator = boxedRationalDenominator(y)
         let expandedXNumerator = BI.mul(xBig, yDenominator)
         Memory.decRef(xBig)
-        let result = if (isSub) BI.sub(expandedXNumerator, yNumerator)
+        let result =
+          if (isSub) BI.sub(expandedXNumerator, yNumerator)
           else BI.add(expandedXNumerator, yNumerator)
         let ret = reducedFractionBigInt(result, yDenominator)
         Memory.decRef(expandedXNumerator)
@@ -894,14 +897,16 @@ let numberAddSubSimpleHelp = (x, y, isSub) => {
       t when WasmI32.eq(t, Tags._GRAIN_FLOAT32_BOXED_NUM_TAG) => {
         let yBoxedVal = boxedFloat32Number(y)
         let xval = WasmF32.convertI32S(xval)
-        let result = if (isSub) WasmF32.sub(xval, yBoxedVal)
+        let result =
+          if (isSub) WasmF32.sub(xval, yBoxedVal)
           else WasmF32.add(xval, yBoxedVal)
         newFloat32(result)
       },
       t when WasmI32.eq(t, Tags._GRAIN_FLOAT64_BOXED_NUM_TAG) => {
         let yBoxedVal = boxedFloat64Number(y)
         let xval = WasmF64.convertI32S(xval)
-        let result = if (isSub) WasmF64.sub(xval, yBoxedVal)
+        let result =
+          if (isSub) WasmF64.sub(xval, yBoxedVal)
           else WasmF64.add(xval, yBoxedVal)
         newFloat64(result)
       },
@@ -940,14 +945,16 @@ let numberAddSubInt64Help = (xval, y, isSub) => {
     match (yBoxedNumberTag) {
       t when WasmI32.eq(t, Tags._GRAIN_INT32_BOXED_NUM_TAG) => {
         let yBoxedVal = WasmI64.extendI32S(boxedInt32Number(y))
-        let result = if (isSub) WasmI64.sub(xval, yBoxedVal)
+        let result =
+          if (isSub) WasmI64.sub(xval, yBoxedVal)
           else WasmI64.add(xval, yBoxedVal)
         reducedInteger(result)
       },
       t when WasmI32.eq(t, Tags._GRAIN_INT64_BOXED_NUM_TAG) => {
         let yBoxedVal = boxedInt64Number(y)
         let xval64 = xval
-        let result = if (isSub) WasmI64.sub(xval64, yBoxedVal)
+        let result =
+          if (isSub) WasmI64.sub(xval64, yBoxedVal)
           else WasmI64.add(xval64, yBoxedVal)
         if (
           WasmI64.geS(yBoxedVal, 0N) && WasmI64.ltS(result, xval64) ||
@@ -981,7 +988,8 @@ let numberAddSubInt64Help = (xval, y, isSub) => {
         let yDenominator = boxedRationalDenominator(y)
         let expandedXNumerator = BI.mul(xBig, yDenominator)
         Memory.decRef(xBig)
-        let result = if (isSub) BI.sub(expandedXNumerator, yNumerator)
+        let result =
+          if (isSub) BI.sub(expandedXNumerator, yNumerator)
           else BI.add(expandedXNumerator, yNumerator)
         let ret = reducedFractionBigInt(result, yDenominator)
         Memory.decRef(expandedXNumerator)
@@ -991,14 +999,16 @@ let numberAddSubInt64Help = (xval, y, isSub) => {
       t when WasmI32.eq(t, Tags._GRAIN_FLOAT32_BOXED_NUM_TAG) => {
         let xval = WasmF32.convertI64S(xval)
         let yBoxedVal = boxedFloat32Number(y)
-        let result = if (isSub) WasmF32.sub(xval, yBoxedVal)
+        let result =
+          if (isSub) WasmF32.sub(xval, yBoxedVal)
           else WasmF32.add(xval, yBoxedVal)
         newFloat32(result)
       },
       t when WasmI32.eq(t, Tags._GRAIN_FLOAT64_BOXED_NUM_TAG) => {
         let xval = WasmF64.convertI64S(xval)
         let yBoxedVal = boxedFloat64Number(y)
-        let result = if (isSub) WasmF64.sub(xval, yBoxedVal)
+        let result =
+          if (isSub) WasmF64.sub(xval, yBoxedVal)
           else WasmF64.add(xval, yBoxedVal)
         newFloat64(result)
       },
@@ -1092,7 +1102,8 @@ let numberAddSubBigIntHelp = (x, y, isSub) => {
         let yNumerator = boxedRationalNumerator(y)
         let yDenominator = boxedRationalDenominator(y)
         let expandedXNumerator = BI.mul(x, yDenominator)
-        let result = if (isSub) BI.sub(expandedXNumerator, yNumerator)
+        let result =
+          if (isSub) BI.sub(expandedXNumerator, yNumerator)
           else BI.add(expandedXNumerator, yNumerator)
         Memory.decRef(expandedXNumerator)
         let ret = reducedFractionBigInt(result, yDenominator)
@@ -1102,14 +1113,16 @@ let numberAddSubBigIntHelp = (x, y, isSub) => {
       t when WasmI32.eq(t, Tags._GRAIN_FLOAT32_BOXED_NUM_TAG) => {
         let xval = BI.toFloat32(x)
         let yBoxedVal = boxedFloat32Number(y)
-        let result = if (isSub) WasmF32.sub(xval, yBoxedVal)
+        let result =
+          if (isSub) WasmF32.sub(xval, yBoxedVal)
           else WasmF32.add(xval, yBoxedVal)
         newFloat32(result)
       },
       t when WasmI32.eq(t, Tags._GRAIN_FLOAT64_BOXED_NUM_TAG) => {
         let xval = BI.toFloat64(x)
         let yBoxedVal = boxedFloat64Number(y)
-        let result = if (isSub) WasmF64.sub(xval, yBoxedVal)
+        let result =
+          if (isSub) WasmF64.sub(xval, yBoxedVal)
           else WasmF64.add(xval, yBoxedVal)
         newFloat64(result)
       },
@@ -1128,7 +1141,8 @@ let numberAddSubRationalHelp = (x, y, isSub) => {
     let yval = untagSimple(y)
     let yBig = BI.makeWrappedInt32(yval)
     let expandedYNumerator = BI.mul(xDenominator, yBig)
-    let result = if (isSub) BI.sub(xNumerator, expandedYNumerator)
+    let result =
+      if (isSub) BI.sub(xNumerator, expandedYNumerator)
       else BI.add(xNumerator, expandedYNumerator)
     Memory.decRef(expandedYNumerator)
     Memory.decRef(yBig)
@@ -1145,7 +1159,8 @@ let numberAddSubRationalHelp = (x, y, isSub) => {
         let yNumerator = boxedRationalNumerator(y)
         let yDenominator = boxedRationalDenominator(y)
         if (BI.eq(xDenominator, yDenominator)) {
-          let newNumerator = if (isSub) BI.sub(xNumerator, yNumerator)
+          let newNumerator =
+            if (isSub) BI.sub(xNumerator, yNumerator)
             else BI.add(xNumerator, yNumerator)
           let ret = reducedFractionBigInt(newNumerator, xDenominator)
           Memory.decRef(newNumerator)
@@ -1153,7 +1168,8 @@ let numberAddSubRationalHelp = (x, y, isSub) => {
         } else {
           let numerator1 = BI.mul(xNumerator, yDenominator)
           let numerator2 = BI.mul(yNumerator, xDenominator)
-          let numerator = if (isSub) BI.sub(numerator1, numerator2)
+          let numerator =
+            if (isSub) BI.sub(numerator1, numerator2)
             else BI.add(numerator1, numerator2)
           let denominator = BI.mul(xDenominator, yDenominator)
           let ret = reducedFractionBigInt(numerator, denominator)
@@ -1167,7 +1183,8 @@ let numberAddSubRationalHelp = (x, y, isSub) => {
         let yBig = BI.makeWrappedInt32(boxedInt32Number(y))
         let expandedYNumerator = BI.mul(yBig, xDenominator)
         Memory.decRef(yBig)
-        let result = if (isSub) BI.sub(xNumerator, expandedYNumerator)
+        let result =
+          if (isSub) BI.sub(xNumerator, expandedYNumerator)
           else BI.add(xNumerator, expandedYNumerator)
         let ret = reducedFractionBigInt(result, xDenominator)
         Memory.decRef(expandedYNumerator)
@@ -1178,7 +1195,8 @@ let numberAddSubRationalHelp = (x, y, isSub) => {
         let yBig = BI.makeWrappedInt64(boxedInt64Number(y))
         let expandedYNumerator = BI.mul(yBig, xDenominator)
         Memory.decRef(yBig)
-        let result = if (isSub) BI.sub(xNumerator, expandedYNumerator)
+        let result =
+          if (isSub) BI.sub(xNumerator, expandedYNumerator)
           else BI.add(xNumerator, expandedYNumerator)
         let ret = reducedFractionBigInt(result, xDenominator)
         Memory.decRef(expandedYNumerator)
@@ -1187,7 +1205,8 @@ let numberAddSubRationalHelp = (x, y, isSub) => {
       },
       t when WasmI32.eq(t, Tags._GRAIN_BIGINT_BOXED_NUM_TAG) => {
         let expandedYNumerator = BI.mul(xDenominator, y)
-        let result = if (isSub) BI.sub(xNumerator, expandedYNumerator)
+        let result =
+          if (isSub) BI.sub(xNumerator, expandedYNumerator)
           else BI.add(xNumerator, expandedYNumerator)
         Memory.decRef(expandedYNumerator)
         let ret = reducedFractionBigInt(result, xDenominator)
@@ -1199,7 +1218,8 @@ let numberAddSubRationalHelp = (x, y, isSub) => {
           BI.toFloat32(xNumerator),
           BI.toFloat32(xDenominator)
         )
-        let result = if (isSub) WasmF32.sub(xval, boxedFloat32Number(y))
+        let result =
+          if (isSub) WasmF32.sub(xval, boxedFloat32Number(y))
           else WasmF32.add(xval, boxedFloat32Number(y))
         newFloat32(result)
       },
@@ -1208,8 +1228,8 @@ let numberAddSubRationalHelp = (x, y, isSub) => {
         let xdenfloat = BI.toFloat64(xDenominator)
         let xval = WasmF64.div(xnumfloat, xdenfloat)
         let yval = boxedFloat64Number(y)
-        let result = if (isSub) WasmF64.sub(xval, yval)
-          else WasmF64.add(xval, yval)
+        let result =
+          if (isSub) WasmF64.sub(xval, yval) else WasmF64.add(xval, yval)
         let ret = newFloat64(result)
         ret
       },
@@ -1404,6 +1424,13 @@ let numberTimesDivideBigIntHelp = (x, y, isDivide) => {
         Memory.decRef(yBig)
         ret
       },
+      t when WasmI32.eq(t, Tags._GRAIN_BIGINT_BOXED_NUM_TAG) => {
+        if (isDivide) {
+          reducedBigInteger(BI.div(x, y))
+        } else {
+          reducedBigInteger(BI.mul(x, y))
+        }
+      },
       t when WasmI32.eq(t, Tags._GRAIN_RATIONAL_BOXED_NUM_TAG) => {
         let yNumerator = boxedRationalNumerator(y)
         let yDenominator = boxedRationalDenominator(y)
@@ -1548,9 +1575,11 @@ let numberTimesDivideRationalHelp = (x, y, isDivide) => {
         let yDenominator = boxedRationalDenominator(y)
         // (a / b) * (c / d) == (a * c) / (b * d)
         // (a / b) / (c / d) == (a * d) / (b * c)
-        let numerator = if (isDivide) BI.mul(xNumerator, yDenominator)
+        let numerator =
+          if (isDivide) BI.mul(xNumerator, yDenominator)
           else BI.mul(xNumerator, yNumerator)
-        let denominator = if (isDivide) BI.mul(xDenominator, yNumerator)
+        let denominator =
+          if (isDivide) BI.mul(xDenominator, yNumerator)
           else BI.mul(xDenominator, yDenominator)
         reducedFractionBigInt(numerator, denominator)
       },
@@ -1686,7 +1715,8 @@ let numberMod = (x, y) => {
     WasmI64.gtS(xval, 0N) && WasmI64.ltS(yval, 0N)
   ) {
     let modval = WasmI64.remS(i64abs(xval), i64abs(yval))
-    let result = if (WasmI64.ne(modval, 0N))
+    let result =
+      if (WasmI64.ne(modval, 0N))
         WasmI64.mul(
           WasmI64.sub(i64abs(yval), modval),
           if (WasmI64.ltS(yval, 0N)) -1N else 1N
@@ -1702,9 +1732,9 @@ let numberMod = (x, y) => {
  * Int/int and float/float comparisons are always accurate.
  * Rational/rational comparisons are approximations with the exception of
  * equality, which is always accurate.
- * 
+ *
  * Values compared to floats or rationals are first converted to floats.
- * 
+ *
  * All comparison operators consider NaN not equal to, less than, or greater
  * than NaN, with the exception of `compare`, which considers NaN equal to
  * itself and otherwise smaller than any other float value. This provides a
@@ -2459,3 +2489,57 @@ export let isBigInt = x => {
   let x = WasmI32.fromGrain(x)
   isBigInt(x)
 }
+
+// Scalbn is based on https://git.musl-libc.org/cgit/musl/tree/src/math/scalbn.c
+/*
+ * ====================================================
+ * Copyright (C) 2004 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+/**
+ * Multiplies a floating-point number by an integral power of 2.
+ *
+ * @param x: The floating-point value
+ * @param n: The Integer exponent
+ * @returns The result of x * 2^n
+ *
+ * @since v0.5.4
+ */
+@unsafe
+export let scalbn = (x, n) => {
+  let (>) = WasmI32.gtS
+  let (<) = WasmI32.ltS
+  let (*) = WasmF64.mul
+  let (-) = WasmI32.sub
+  let (+) = WasmI32.add
+  let (<<) = WasmI64.shl
+  // Constants
+  let const_0x1p1023 = 8.98847e+307W
+  let const_0x1p_1022 = 2.22507e-308W
+  let const_0x1p53 = 9.0072e+15W
+  let mut n = n
+  let mut y = x
+  if (n > 1023n) {
+    y *= const_0x1p1023
+    n -= 1023n
+    if (n > 1023n) {
+      y *= const_0x1p1023
+      n -= 1023n
+      if (n > 1023n) n = 1023n
+    } else if (n < -1023n) {
+      /* make sure final n < -53 to avoid double rounding in the subnormal range */
+      y *= const_0x1p_1022 * const_0x1p53
+      n += 1022n - 53n
+      if (n < -1022n) {
+        y *= const_0x1p_1022 * const_0x1p53
+        n += 1022n - 53n
+        if (n < -1022n) n = -1022n
+      }
+    }
+  }
+  y * WasmF64.reinterpretI64(WasmI64.extendI32S(0x3FFn + n) << 52N)
+}

package/runtime/numbers.md

@@ -322,3 +322,29 @@ decr : Number -> Number
 isBigInt : a -> Bool
 ```
 
+### Numbers.**scalbn**
+
+<details disabled>
+<summary tabindex="-1">Added in <code>0.5.4</code></summary>
+No other changes yet.
+</details>
+
+```grain
+scalbn : (WasmF64, WasmI32) -> WasmF64
+```
+
+Multiplies a floating-point number by an integral power of 2.
+
+Parameters:
+
+|param|type|description|
+|-----|----|-----------|
+|`x`|`WasmF64`|The floating-point value|
+|`n`|`WasmI32`|The Integer exponent|
+
+Returns:
+
+|type|description|
+|----|-----------|
+|`WasmF64`|The result of x * 2^n|
+

package/runtime/string.gr

@@ -547,7 +547,8 @@ let rec heapValueToString = (ptr, extraIndents, toplevel) => {
       join(strings)
     },
   }
-}, toStringHelp = (grainValue, extraIndents, toplevel) => {
+},
+toStringHelp = (grainValue, extraIndents, toplevel) => {
   if ((grainValue & 1n) != 0n) {
     // Simple (unboxed) numbers
     NumberUtils.itoa32(grainValue >> 1n, 10n)
@@ -572,7 +573,8 @@ let rec heapValueToString = (ptr, extraIndents, toplevel) => {
       "<unknown value>"
     }
   }
-}, listToString = (ptr, extraIndents) => {
+},
+listToString = (ptr, extraIndents) => {
   let mut cur = ptr
   let mut isFirst = true
 

package/set.gr

@@ -2,7 +2,7 @@
  * @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"
  * 
- * @since 0.3.0
+ * @since v0.3.0
  */
 import List from "list"
 import Array from "array"
@@ -33,7 +33,7 @@ record Set<k> {
  * @param size: The initial storage size of the set
  * @returns An empty set with the given initial storage size
  * 
- * @since 0.3.0
+ * @since v0.3.0
  */
 export let makeSized = size => {
   let buckets = Array.make(size, None)
@@ -44,7 +44,7 @@ export let makeSized = size => {
  *
  * @returns An empty set
  * 
- * @since 0.3.0
+ * @since v0.3.0
  */
 export let make = () => {
   makeSized(16)
@@ -121,7 +121,7 @@ let rec nodeInBucket = (key, node) => {
  * @param key: The value to add
  * @param set: The set to update
  * 
- * @since 0.3.0
+ * @since v0.3.0
  */
 export let add = (key, set) => {
   let buckets = set.buckets
@@ -154,7 +154,7 @@ export let add = (key, set) => {
  * @param set: The set to search
  * @returns `true` if the set contains the given value or `false` otherwise
  * 
- * @since 0.3.0
+ * @since v0.3.0
  */
 export let contains = (key, set) => {
   let buckets = set.buckets
@@ -186,7 +186,7 @@ let rec removeInBucket = (key, node) => {
  * @param key: The value to remove
  * @param set: The set to update
  * 
- * @since 0.3.0
+ * @since v0.3.0
  */
 export let remove = (key, set) => {
   let buckets = set.buckets
@@ -214,7 +214,7 @@ export let remove = (key, set) => {
  * @param set: The set to inspect
  * @returns The count of elements in the set
  * 
- * @since 0.3.0
+ * @since v0.3.0
  */
 export let size = set => {
   set.size
@@ -226,7 +226,7 @@ export let size = set => {
  * @param set: The set to inspect
  * @returns `true` if the given set is empty or `false` otherwise
  * 
- * @since 0.3.0
+ * @since v0.3.0
  */
 export let isEmpty = set => {
   size(set) == 0
@@ -237,7 +237,7 @@ export let isEmpty = set => {
  *
  * @param set: The set to reset
  * 
- * @since 0.3.0
+ * @since v0.3.0
  */
 export let clear = set => {
   set.size = 0
@@ -263,7 +263,7 @@ let rec forEachBucket = (fn, node) => {
  * @param fn: The iterator function to call with each element
  * @param set: The set to iterate
  * 
- * @since 0.3.0
+ * @since v0.3.0
  * @history v0.5.0: Ensured the iterator function return type is always `Void`
  */
 export let forEach = (fn, set) => {
@@ -288,7 +288,7 @@ let rec reduceEachBucket = (fn, node, acc) => {
  * @param set: The set to iterate
  * @returns The final accumulator returned from `fn`
  * 
- * @since 0.3.0
+ * @since v0.3.0
  */
 export let reduce = (fn, init, set) => {
   let buckets = set.buckets
@@ -305,10 +305,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 0.3.0
+ * @since v0.3.0
  */
-export let filter = (predicate, set) => {
-  let keysToRemove = reduce((list, key) => if (!predicate(key)) {
+export let filter = (fn, set) => {
+  let keysToRemove = reduce((list, key) => if (!fn(key)) {
     [key, ...list]
   } else {
     list
@@ -324,10 +324,10 @@ export let filter = (predicate, 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 0.3.0
+ * @since v0.3.0
  */
-export let reject = (predicate, set) => {
-  filter(key => !predicate(key), set)
+export let reject = (fn, set) => {
+  filter(key => !fn(key), set)
 }
 
 /**
@@ -336,7 +336,7 @@ export let reject = (predicate, set) => {
  * @param set: The set to convert
  * @returns A list containing all set values
  * 
- * @since 0.3.0
+ * @since v0.3.0
  */
 export let toList = set => {
   reduce((list, key) => [key, ...list], [], set)
@@ -348,7 +348,7 @@ export let toList = set => {
  * @param list: The list to convert
  * @returns A set containing all list values
  * 
- * @since 0.3.0
+ * @since v0.3.0
  */
 export let fromList = list => {
   let set = make()
@@ -364,7 +364,7 @@ export let fromList = list => {
  * @param set: The set to convert
  * @returns An array containing all set values
  * 
- * @since 0.3.0
+ * @since v0.3.0
  */
 export let toArray = set => {
   Array.fromList(toList(set))
@@ -376,7 +376,7 @@ export let toArray = set => {
  * @param array: The array to convert
  * @returns A set containing all array values
  * 
- * @since 0.3.0
+ * @since v0.3.0
  */
 export let fromArray = array => {
   let set = make()
@@ -393,7 +393,7 @@ export let fromArray = array => {
  * @param set2: The second set to combine
  * @returns A set containing all elements of both sets
  * 
- * @since 0.3.0
+ * @since v0.3.0
  */
 export let union = (set1, set2) => {
   let set = make()
@@ -413,7 +413,7 @@ export let union = (set1, set2) => {
  * @param set2: The second set to combine
  * @returns A set containing only unshared elements from both sets
  * 
- * @since 0.3.0
+ * @since v0.3.0
  */
 export let diff = (set1, set2) => {
   let set = make()
@@ -437,7 +437,7 @@ export let diff = (set1, set2) => {
  * @param set2: The second set to combine
  * @returns A set containing only shared elements from both sets
  * 
- * @since 0.3.0
+ * @since v0.3.0
  */
 export let intersect = (set1, set2) => {
   let set = make()
@@ -461,7 +461,7 @@ export let intersect = (set1, set2) => {
  * @param set: The set to inspect
  * @returns The internal state of the set
  * 
- * @since 0.3.0
+ * @since v0.3.0
  */
 export let getInternalStats = set => {
   (set.size, Array.length(set.buckets))

package/stack.gr

@@ -20,10 +20,22 @@ record Stack<a> {
  * @section Values: Functions and constants included in the Stack module.
  */
 
+/**
+ * An empty stack.
+ * 
+ * @since v0.5.4
+ */
+export let empty = {
+  let empty = { data: [], }
+  empty
+}
+
 /**
  * Creates a new stack.
  *
  * @returns An empty stack
+ * 
+ * @deprecated This will be removed in the v0.6.0 release of Grain.
  */
 export let make = () => {
   { data: [], }

package/stack.md

@@ -24,8 +24,23 @@ Stacks are immutable data structures that store their data in a List.
 
 Functions and constants included in the Stack module.
 
+### Stack.**empty**
+
+<details disabled>
+<summary tabindex="-1">Added in <code>0.5.4</code></summary>
+No other changes yet.
+</details>
+
+```grain
+empty : Stack<a>
+```
+
+An empty stack.
+
 ### Stack.**make**
 
+> **Deprecated:** This will be removed in the v0.6.0 release of Grain.
+
 ```grain
 make : () -> Stack<a>
 ```