@grain/stdlib 0.6.6 → 0.7.1

package/runtime/atof/common.md

@@ -22,234 +22,234 @@ Functions and constants included in the Common module.
 ### Common.**_MINIMUM_EXPONENT**
 
 ```grain
-_MINIMUM_EXPONENT : WasmI32
+_MINIMUM_EXPONENT: WasmI32
 ```
 
 ### Common.**_MIN_EXPONENT_ROUND_TO_EVEN**
 
 ```grain
-_MIN_EXPONENT_ROUND_TO_EVEN : WasmI64
+_MIN_EXPONENT_ROUND_TO_EVEN: WasmI64
 ```
 
 ### Common.**_MAX_EXPONENT_ROUND_TO_EVEN**
 
 ```grain
-_MAX_EXPONENT_ROUND_TO_EVEN : WasmI64
+_MAX_EXPONENT_ROUND_TO_EVEN: WasmI64
 ```
 
 ### Common.**_MIN_EXPONENT_FAST_PATH**
 
 ```grain
-_MIN_EXPONENT_FAST_PATH : WasmI32
+_MIN_EXPONENT_FAST_PATH: WasmI32
 ```
 
 ### Common.**_MAX_EXPONENT_FAST_PATH**
 
 ```grain
-_MAX_EXPONENT_FAST_PATH : WasmI32
+_MAX_EXPONENT_FAST_PATH: WasmI32
 ```
 
 ### Common.**_MAX_EXPONENT_DISGUISED_FAST_PATH**
 
 ```grain
-_MAX_EXPONENT_DISGUISED_FAST_PATH : WasmI32
+_MAX_EXPONENT_DISGUISED_FAST_PATH: WasmI32
 ```
 
 ### Common.**_MAX_MANTISSA_FAST_PATH**
 
 ```grain
-_MAX_MANTISSA_FAST_PATH : WasmI64
+_MAX_MANTISSA_FAST_PATH: WasmI64
 ```
 
 ### Common.**_MANTISSA_EXPLICIT_BITS_64**
 
 ```grain
-_MANTISSA_EXPLICIT_BITS_64 : WasmI64
+_MANTISSA_EXPLICIT_BITS_64: WasmI64
 ```
 
 ### Common.**_MANTISSA_EXPLICIT_BITS_32**
 
 ```grain
-_MANTISSA_EXPLICIT_BITS_32 : WasmI32
+_MANTISSA_EXPLICIT_BITS_32: WasmI32
 ```
 
 ### Common.**_INFINITE_POWER**
 
 ```grain
-_INFINITE_POWER : WasmI32
+_INFINITE_POWER: WasmI32
 ```
 
 ### Common.**_SMALLEST_POWER_OF_TEN**
 
 ```grain
-_SMALLEST_POWER_OF_TEN : WasmI64
+_SMALLEST_POWER_OF_TEN: WasmI64
 ```
 
 ### Common.**_LARGEST_POWER_OF_TEN**
 
 ```grain
-_LARGEST_POWER_OF_TEN : WasmI64
+_LARGEST_POWER_OF_TEN: WasmI64
 ```
 
 ### Common.**_SMALLEST_POWER_OF_FIVE**
 
 ```grain
-_SMALLEST_POWER_OF_FIVE : WasmI64
+_SMALLEST_POWER_OF_FIVE: WasmI64
 ```
 
 ### Common.**_LARGEST_POWER_OF_FIVE**
 
 ```grain
-_LARGEST_POWER_OF_FIVE : WasmI64
+_LARGEST_POWER_OF_FIVE: WasmI64
 ```
 
 ### Common.**_CHAR_CODE_UNDERSCORE**
 
 ```grain
-_CHAR_CODE_UNDERSCORE : WasmI32
+_CHAR_CODE_UNDERSCORE: WasmI32
 ```
 
 ### Common.**_CHAR_CODE_PLUS**
 
 ```grain
-_CHAR_CODE_PLUS : WasmI32
+_CHAR_CODE_PLUS: WasmI32
 ```
 
 ### Common.**_CHAR_CODE_MINUS**
 
 ```grain
-_CHAR_CODE_MINUS : WasmI32
+_CHAR_CODE_MINUS: WasmI32
 ```
 
 ### Common.**_CHAR_CODE_0**
 
 ```grain
-_CHAR_CODE_0 : WasmI32
+_CHAR_CODE_0: WasmI32
 ```
 
 ### Common.**_CHAR_CODE_e**
 
 ```grain
-_CHAR_CODE_e : WasmI32
+_CHAR_CODE_e: WasmI32
 ```
 
 ### Common.**_CHAR_CODE_E**
 
 ```grain
-_CHAR_CODE_E : WasmI32
+_CHAR_CODE_E: WasmI32
 ```
 
 ### Common.**_CHAR_CODE_DOT**
 
 ```grain
-_CHAR_CODE_DOT : WasmI32
+_CHAR_CODE_DOT: WasmI32
 ```
 
 ### Common.**_CHAR_CODE_A**
 
 ```grain
-_CHAR_CODE_A : WasmI32
+_CHAR_CODE_A: WasmI32
 ```
 
 ### Common.**_CHAR_CODE_Z**
 
 ```grain
-_CHAR_CODE_Z : WasmI32
+_CHAR_CODE_Z: WasmI32
 ```
 
 ### Common.**_CHAR_CODE_a**
 
 ```grain
-_CHAR_CODE_a : WasmI32
+_CHAR_CODE_a: WasmI32
 ```
 
 ### Common.**_CHAR_CODE_f**
 
 ```grain
-_CHAR_CODE_f : WasmI32
+_CHAR_CODE_f: WasmI32
 ```
 
 ### Common.**_CHAR_CODE_i**
 
 ```grain
-_CHAR_CODE_i : WasmI32
+_CHAR_CODE_i: WasmI32
 ```
 
 ### Common.**_CHAR_CODE_n**
 
 ```grain
-_CHAR_CODE_n : WasmI32
+_CHAR_CODE_n: WasmI32
 ```
 
 ### Common.**_CHAR_CODE_t**
 
 ```grain
-_CHAR_CODE_t : WasmI32
+_CHAR_CODE_t: WasmI32
 ```
 
 ### Common.**_CHAR_CODE_y**
 
 ```grain
-_CHAR_CODE_y : WasmI32
+_CHAR_CODE_y: WasmI32
 ```
 
 ### Common.**fpZero**
 
 ```grain
-fpZero : () => BiasedFp
+fpZero: () => BiasedFp
 ```
 
 ### Common.**fpInf**
 
 ```grain
-fpInf : () => BiasedFp
+fpInf: () => BiasedFp
 ```
 
 ### Common.**fpErr**
 
 ```grain
-fpErr : () => BiasedFp
+fpErr: () => BiasedFp
 ```
 
 ### Common.**fpNan**
 
 ```grain
-fpNan : () => BiasedFp
+fpNan: () => BiasedFp
 ```
 
 ### Common.**getPowers10**
 
 ```grain
-getPowers10 : (i: WasmI32) => WasmI32
+getPowers10: (i: WasmI32) => WasmI32
 ```
 
 ### Common.**getPowers10FastPath**
 
 ```grain
-getPowers10FastPath : (i: WasmI32) => WasmF64
+getPowers10FastPath: (i: WasmI32) => WasmF64
 ```
 
 ### Common.**is8Digits**
 
 ```grain
-is8Digits : (value: WasmI64) => Bool
+is8Digits: (value: WasmI64) => Bool
 ```
 
 ### Common.**power**
 
 ```grain
-power : (q: WasmI32) => WasmI32
+power: (q: WasmI32) => WasmI32
 ```
 
 ### Common.**fullMultiplication**
 
 ```grain
-fullMultiplication : (a: WasmI64, b: WasmI64) => (Int64, Int64)
+fullMultiplication: (a: WasmI64, b: WasmI64) => (Int64, Int64)
 ```
 
 ### Common.**biasedFpToNumber**
 
 ```grain
-biasedFpToNumber : (fp: BiasedFp, negative: Bool) => Number
+biasedFpToNumber: (fp: BiasedFp, negative: Bool) => Number
 ```
 

package/runtime/atof/decimal.gr

@@ -140,8 +140,8 @@ let trim = d => {
   let digits = WasmI32.fromGrain(d.digits)
   let mut numDigits = WasmI32.load(WasmI32.fromGrain(d.numDigits), 4n)
   while (
-    numDigits != 0n &&
-    WasmI32.eqz(WasmI32.load8U(digits + (numDigits - 1n), 8n))
+    numDigits != 0n
+    && WasmI32.eqz(WasmI32.load8U(digits + (numDigits - 1n), 8n))
   ) {
     numDigits -= 1n
   }
@@ -173,8 +173,8 @@ provide let round = d => {
       let dpDigit = WasmI32.load8U(digits + dp, 8n)
       roundUp = dpDigit >= 5n
       if (dpDigit == 5n && dp + 1n == numDigits) {
-        roundUp = d.truncated ||
-          dp != 0n && (1n & WasmI32.load8U(digits + dp - 1n, 8n)) != 0n
+        roundUp = d.truncated
+          || dp != 0n && (1n & WasmI32.load8U(digits + dp - 1n, 8n)) != 0n
       }
     }
     if (roundUp) {
@@ -381,8 +381,8 @@ provide let leftShift = (d, shift) => {
       writeIndex -= 1n
       n = addWasmI64(
         n,
-        WasmI64.extendI32U(WasmI32.load8U(digits + readIndex, 8n)) <<
-          WasmI64.extendI32U(shift)
+        WasmI64.extendI32U(WasmI32.load8U(digits + readIndex, 8n))
+          << WasmI64.extendI32U(shift)
       )
       let quotient = n / 10N
       let remainder = subWasmI64(n, 10N * quotient)

package/runtime/atof/decimal.md

@@ -19,12 +19,12 @@ record Decimal {
 
 Fields:
 
-|name|type|description|
-|----|----|-----------|
-|`numDigits`|`Int32`|The number of significant digits in the decimal.|
-|`decimalPoint`|`Int32`|The offset of the decimal point in the significant digits.|
-|`truncated`|`Bool`|If the number of significant digits stored in the decimal is truncated.|
-|`digits`|`Bytes`|Buffer of the raw digits, in the range [0, 9].|
+| name           | type    | description                                                             |
+| -------------- | ------- | ----------------------------------------------------------------------- |
+| `numDigits`    | `Int32` | The number of significant digits in the decimal.                        |
+| `decimalPoint` | `Int32` | The offset of the decimal point in the significant digits.              |
+| `truncated`    | `Bool`  | If the number of significant digits stored in the decimal is truncated. |
+| `digits`       | `Bytes` | Buffer of the raw digits, in the range [0, 9].                          |
 
 ## Values
 
@@ -33,48 +33,48 @@ Functions and constants included in the Decimal module.
 ### Decimal.**_DECIMAL_POINT_RANGE**
 
 ```grain
-_DECIMAL_POINT_RANGE : WasmI32
+_DECIMAL_POINT_RANGE: WasmI32
 ```
 
 ### Decimal.**tryAddDigit**
 
 ```grain
-tryAddDigit : (d: Decimal, digit: WasmI32) => Void
+tryAddDigit: (d: Decimal, digit: WasmI32) => Void
 ```
 
 ### Decimal.**round**
 
 ```grain
-round : (d: Decimal) => WasmI64
+round: (d: Decimal) => WasmI64
 ```
 
 ### Decimal.**get_TABLE**
 
 ```grain
-get_TABLE : () => WasmI32
+get_TABLE: () => WasmI32
 ```
 
 ### Decimal.**get_TABLE_POW5**
 
 ```grain
-get_TABLE_POW5 : () => WasmI32
+get_TABLE_POW5: () => WasmI32
 ```
 
 ### Decimal.**leftShift**
 
 ```grain
-leftShift : (d: Decimal, shift: WasmI32) => Void
+leftShift: (d: Decimal, shift: WasmI32) => Void
 ```
 
 ### Decimal.**rightShift**
 
 ```grain
-rightShift : (d: Decimal, shift: WasmI32) => Void
+rightShift: (d: Decimal, shift: WasmI32) => Void
 ```
 
 ### Decimal.**parseDecimal**
 
 ```grain
-parseDecimal : (s: String) => Decimal
+parseDecimal: (s: String) => Decimal
 ```
 

package/runtime/atof/lemire.gr

@@ -203,11 +203,11 @@ provide let computeFloat = (exponent: WasmI64, mantissa: WasmI64) => {
           //
           // Or, we may fall between two floats: we are exactly halfway.
           if (
-            WasmI64.leU(lo, 1N) &&
-            q >= _MIN_EXPONENT_ROUND_TO_EVEN &&
-            q <= _MAX_EXPONENT_ROUND_TO_EVEN &&
-            (mantissa & 3N) == 1N &&
-            mantissa << WasmI64.extendI32S({
+            WasmI64.leU(lo, 1N)
+            && q >= _MIN_EXPONENT_ROUND_TO_EVEN
+            && q <= _MAX_EXPONENT_ROUND_TO_EVEN
+            && (mantissa & 3N) == 1N
+            && mantissa << WasmI64.extendI32S({
               use WasmI32.{ (+), (-) }
               upperbit + 64n - _MANTISSA_EXPLICIT_BITS_32 - 3n
             }) == hi

package/runtime/atof/lemire.md

@@ -9,6 +9,6 @@ Functions and constants included in the Lemire module.
 ### Lemire.**computeFloat**
 
 ```grain
-computeFloat : (exponent: WasmI64, mantissa: WasmI64) => Common.BiasedFp
+computeFloat: (exponent: WasmI64, mantissa: WasmI64) => Common.BiasedFp
 ```
 

package/runtime/atof/parse.gr

@@ -419,16 +419,16 @@ let parseInfNan = s => {
         }
 
         if (
-          len - i == 3n &&
-          c1 == _CHAR_CODE_n &&
-          c2 == _CHAR_CODE_a &&
-          c3 == _CHAR_CODE_n
+          len - i == 3n
+          && c1 == _CHAR_CODE_n
+          && c2 == _CHAR_CODE_a
+          && c3 == _CHAR_CODE_n
         ) {
           Ok((fpNan(), negative))
         } else if (
-          c1 == _CHAR_CODE_i &&
-          c2 == _CHAR_CODE_n &&
-          c3 == _CHAR_CODE_f
+          c1 == _CHAR_CODE_i
+          && c2 == _CHAR_CODE_n
+          && c3 == _CHAR_CODE_f
         ) {
           if (len - i == 3n) {
             Ok((fpInf(), negative))
@@ -455,11 +455,11 @@ let parseInfNan = s => {
             }
 
             if (
-              c4 == _CHAR_CODE_i &&
-              c5 == _CHAR_CODE_n &&
-              c6 == _CHAR_CODE_i &&
-              c7 == _CHAR_CODE_t &&
-              c8 == _CHAR_CODE_y
+              c4 == _CHAR_CODE_i
+              && c5 == _CHAR_CODE_n
+              && c6 == _CHAR_CODE_i
+              && c7 == _CHAR_CODE_t
+              && c8 == _CHAR_CODE_y
             ) {
               Ok((fpInf(), negative))
             } else {
@@ -486,10 +486,10 @@ provide let isFastPath = (
   use WasmI32.{ (<=) }
   use WasmI64.{ (<<) }
 
-  _MIN_EXPONENT_FAST_PATH <= exponent &&
-    exponent <= _MAX_EXPONENT_DISGUISED_FAST_PATH &&
-    WasmI64.leU(mantissa, _MAX_MANTISSA_FAST_PATH) &&
-    !manyDigits
+  _MIN_EXPONENT_FAST_PATH <= exponent
+    && exponent <= _MAX_EXPONENT_DISGUISED_FAST_PATH
+    && WasmI64.leU(mantissa, _MAX_MANTISSA_FAST_PATH)
+    && !manyDigits
 }
 
 @unsafe

package/runtime/atof/parse.md

@@ -9,7 +9,7 @@ Functions and constants included in the Parse module.
 ### Parse.**isFastPath**
 
 ```grain
-isFastPath :
+isFastPath:
   (exponent: WasmI32, mantissa: WasmI64, negative: Bool, manyDigits: Bool) =>
    Bool
 ```
@@ -17,6 +17,6 @@ isFastPath :
 ### Parse.**parseFloat**
 
 ```grain
-parseFloat : (string: String) => Result<Number, String>
+parseFloat: (string: String) => Result<Number, String>
 ```
 

package/runtime/atof/slow.md

@@ -9,6 +9,6 @@ Functions and constants included in the Slow module.
 ### Slow.**parseLongMantissa**
 
 ```grain
-parseLongMantissa : (s: String) => Common.BiasedFp
+parseLongMantissa: (s: String) => Common.BiasedFp
 ```
 

package/runtime/atof/table.md

@@ -9,12 +9,12 @@ Functions and constants included in the Table module.
 ### Table.**get_F64_POWERS10_FAST_PATH**
 
 ```grain
-get_F64_POWERS10_FAST_PATH : () => WasmI32
+get_F64_POWERS10_FAST_PATH: () => WasmI32
 ```
 
 ### Table.**get_POWERS5**
 
 ```grain
-get_POWERS5 : () => WasmI32
+get_POWERS5: () => WasmI32
 ```
 

package/runtime/atoi/parse.gr

@@ -74,9 +74,9 @@ provide let parseInt = (string: String, radix: Number) => {
 
   let radix = WasmI32.fromGrain(radix)
   if (
-    WasmI32.eqz(radix & Tags._GRAIN_NUMBER_TAG_MASK) ||
-    radix < WasmI32.fromGrain(2) ||
-    radix > WasmI32.fromGrain(36)
+    WasmI32.eqz(radix & Tags._GRAIN_NUMBER_TAG_MASK)
+    || radix < WasmI32.fromGrain(2)
+    || radix > WasmI32.fromGrain(36)
   ) {
     return Err(ParseIntInvalidRadix)
   }

package/runtime/atoi/parse.md

@@ -50,6 +50,6 @@ Functions and constants included in the Parse module.
 ### Parse.**parseInt**
 
 ```grain
-parseInt : (string: String, radix: Number) => Result<Number, ParseIntError>
+parseInt: (string: String, radix: Number) => Result<Number, ParseIntError>
 ```
 

package/runtime/bigint.gr

@@ -25,7 +25,6 @@ from "runtime/unsafe/wasmf32" include WasmF32
 from "runtime/unsafe/wasmf64" include WasmF64
 from "runtime/exception" include Exception
 from "runtime/dataStructures" include DataStructures as DS
-from "runtime/utils/printing" include Printing as RPrint
 
 // things we need which are missing due to --no-pervasives:
 primitive (!) = "@not"
@@ -131,34 +130,6 @@ let init = (limbs: WasmI32) => {
   ptr
 }
 
-// For debugging
-@unsafe
-provide let debugDumpNumber = (num: WasmI32) => {
-  use WasmI32.{ (*), (+), (-), (&), (>>>), (<) }
-  //let num = WasmI32.fromGrain(num)
-  RPrint.printString("-=-=-=-== debug dump ==-=-=-=-")
-  RPrint.printString("Ref Count:")
-  RPrint.printNumber(WasmI64.extendI32U(WasmI32.load(num - 8n, 0n)))
-  RPrint.printString("Heap Tag:")
-  RPrint.printNumber(WasmI64.extendI32U(WasmI32.load(num, 0n)))
-  RPrint.printString("Boxed Num Tag:")
-  RPrint.printNumber(WasmI64.extendI32U(WasmI32.load(num, 4n)))
-  RPrint.printString("Num Limbs:")
-  let limbs = WasmI32.load(num, 8n)
-  RPrint.printNumber(WasmI64.extendI32U(limbs))
-  RPrint.printString("Flags:")
-  RPrint.printNumber(WasmI64.extendI32U(0xffffn & WasmI32.load(num, 12n)))
-  RPrint.printString("<reserved>:")
-  RPrint.printNumber(
-    WasmI64.extendI32U((0xffff0000n & WasmI32.load(num, 12n)) >>> 16n)
-  )
-  RPrint.printString("Limbs:")
-  for (let mut i = 0n; i < limbs; i += 1n) {
-    // if a nonzero limb is found, then we're at the min
-    RPrint.printNumber(WasmI64.load(num, (i + 2n) * 8n))
-  }
-}
-
 @unsafe
 provide let getSize = ptr => {
   WasmI32.load(ptr, 8n)
@@ -222,8 +193,8 @@ let getHalfSize = ptr => {
   use WasmI32.{ (-), (<<), gtU as (>) }
   use WasmI64.{ (>>>) }
   if (
-    size > 0n &&
-    WasmI32.eqz(WasmI32.wrapI64(getLimb(ptr, size - 1n) >>> 32N))
+    size > 0n
+    && WasmI32.eqz(WasmI32.wrapI64(getLimb(ptr, size - 1n) >>> 32N))
   ) {
     // last half-limb is trailing zeros
     (size << 1n) - 1n
@@ -521,11 +492,8 @@ provide let toFloat64 = (num: WasmI32) => {
     let mut result = 0.0W
     use WasmI32.{ (+) }
     for (let mut i = 0n; WasmI32.ltU(i, numLimbs); i += 1n) {
-      if (!WasmI32.eqz(i)) {
-        result *= factor
-      }
       use WasmF64.{ (+) }
-      result += WasmF64.convertI64U(getLimb(num, i))
+      result += WasmF64.convertI64U(getLimb(num, i)) * factor
     }
     result
   }
@@ -798,8 +766,8 @@ provide let bigIntToString = (num: WasmI32, base: WasmI32) => {
       let bits = WasmI64.extendI32U(WasmI32.ctz(base))
       let mask = (1N << bits) - 1N
       let numLimbs = getSize(num)
-      let totalBits = 64N * WasmI64.extendI32U(numLimbs) -
-        WasmI64.clz(getLimb(num, subWasmI32(numLimbs, 1n)))
+      let totalBits = 64N * WasmI64.extendI32U(numLimbs)
+        - WasmI64.clz(getLimb(num, subWasmI32(numLimbs, 1n)))
       let mut acc = 0N
       let mut accBits = 0N
       for (let mut i = 0n; i < numLimbs; i += 1n) {
@@ -1230,8 +1198,8 @@ let unsignedMul = (num1: WasmI32, num2: WasmI32) => {
       let curHalfLimb = getHalfLimb(dest, j + i)
       let halfLimb1 = getHalfLimb(num1, i)
       use WasmI64.{ (+) }
-      tmp += WasmI64.extendI32U(curHalfLimb) +
-        WasmI64.extendI32U(halfLimb1) * WasmI64.extendI32U(halfLimb2)
+      tmp += WasmI64.extendI32U(curHalfLimb)
+        + WasmI64.extendI32U(halfLimb1) * WasmI64.extendI32U(halfLimb2)
       use WasmI32.{ (+) }
       setHalfLimb(dest, j + i, WasmI32.wrapI64(tmp))
       tmp = tmp >>> 32N
@@ -1285,8 +1253,8 @@ provide let shl = (num: WasmI32, places: WasmI32) => {
   let mut carry = 0N
   let a = places / 32n
   let b = places % 32n
-  let mask = ((1N << WasmI64.extendI32U(b)) - 1N) <<
-    (64N - WasmI64.extendI32U(b))
+  let mask = ((1N << WasmI64.extendI32U(b)) - 1N)
+    << (64N - WasmI64.extendI32U(b))
   let result = init(numLimbs + a)
   setFlag(result, _IS_NEGATIVE, getFlag(num, _IS_NEGATIVE))
   use WasmI32.{ (<<) }
@@ -1855,8 +1823,8 @@ let division = (
     r = WasmI32.load(result, 4n)
     Memory.free(result)
     if (
-      flagIsSet(num1, _IS_NEGATIVE) && !flagIsSet(num2, _IS_NEGATIVE) ||
-      !flagIsSet(num1, _IS_NEGATIVE) && flagIsSet(num2, _IS_NEGATIVE)
+      flagIsSet(num1, _IS_NEGATIVE) && !flagIsSet(num2, _IS_NEGATIVE)
+      || !flagIsSet(num1, _IS_NEGATIVE) && flagIsSet(num2, _IS_NEGATIVE)
     ) {
       // fix sign for negative div by positive & vice versa
       q = negateInPlace(q)
@@ -1873,10 +1841,10 @@ let division = (
   // convert truncated division to floor division
   // https://en.wikipedia.org/wiki/Modulo_operation
   if (
-    divMod &&
-    (
-      flagIsSet(r, _IS_NEGATIVE) && !flagIsSet(num2, _IS_NEGATIVE) ||
-      !flagIsSet(r, _IS_NEGATIVE) && flagIsSet(num2, _IS_NEGATIVE)
+    divMod
+    && (
+      flagIsSet(r, _IS_NEGATIVE) && !flagIsSet(num2, _IS_NEGATIVE)
+      || !flagIsSet(r, _IS_NEGATIVE) && flagIsSet(num2, _IS_NEGATIVE)
     )
   ) {
     let newr = add(r, num2)