@grain/stdlib 0.5.12 → 0.6.0

package/runtime/atof/slow.gr

@@ -11,11 +11,11 @@
  * the Software, and to permit persons to whom the Software
  * is furnished to do so, subject to the following
  * conditions:
- * 
+ *
  * The above copyright notice and this permission notice
  * shall be included in all copies or substantial portions
  * of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
  * ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
  * TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
@@ -26,16 +26,19 @@
  * IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  * DEALINGS IN THE SOFTWARE.
 */
+module Slow
 
 //! Slow, fallback algorithm for cases the Eisel-Lemire algorithm cannot round.
 
-import WasmI32 from "runtime/unsafe/wasmi32"
-import WasmI64 from "runtime/unsafe/wasmi64"
-import Memory from "runtime/unsafe/memory"
-import { newInt32, newInt64 } from "runtime/dataStructures"
+from "runtime/unsafe/wasmi32" include WasmI32
+from "runtime/unsafe/wasmi64" include WasmI64
+from "runtime/unsafe/memory" include Memory
+from "runtime/dataStructures" include DataStructures
+use DataStructures.{ newInt32, newInt64 }
 
-import {
-  BiasedFp,
+from "runtime/atof/common" include Common
+use Common.{
+  type BiasedFp,
   fpZero,
   fpInf,
   fpErr,
@@ -43,8 +46,9 @@ import {
   _INFINITE_POWER,
   _MANTISSA_EXPLICIT_BITS_32,
   _MANTISSA_EXPLICIT_BITS_64,
-} from "./common"
-import Decimal, { parseDecimal, _DECIMAL_POINT_RANGE } from "./decimal"
+}
+from "runtime/atof/decimal" include Decimal
+use Decimal.{ parseDecimal, _DECIMAL_POINT_RANGE }
 
 @unsafe
 let _MAX_SHIFT = 60n
@@ -55,7 +59,7 @@ let mut _POWERS = -1n
 
 @unsafe
 let get_POWERS = () => {
-  let (==) = WasmI32.eq
+  use WasmI32.{ (==) }
   if (_POWERS == -1n) {
     _POWERS = Memory.malloc(130n)
     WasmI32.store8(_POWERS, 0n, 0n)
@@ -83,7 +87,8 @@ let get_POWERS = () => {
 
 @unsafe
 let getShift = n => {
-  if (WasmI32.ltS(n, _NUM_POWERS)) {
+  use WasmI32.{ (<) }
+  if (n < _NUM_POWERS) {
     WasmI32.load8U(get_POWERS(), n)
   } else {
     _MAX_SHIFT
@@ -112,22 +117,14 @@ let getShift = n => {
  * available here: <https://arxiv.org/pdf/2101.11408.pdf#section.11>.
 */
 @unsafe
-export let parseLongMantissa = (s: String) => {
-  let (+) = WasmI32.add
-  let (-) = WasmI32.sub
-  let (&) = WasmI32.and
-  let (<) = WasmI32.ltS
-  let (>) = WasmI32.gtS
-  let (>=) = WasmI32.geS
-  let (<=) = WasmI32.leS
-  let (>>) = WasmI32.shrU
-  let (<<) = WasmI32.shl
-  let (==) = WasmI32.eq
+provide let parseLongMantissa = (s: String) => {
+  use WasmI32.{ (+), (-), (&), (<), (>), (>=), (<=), (==) }
+  use WasmI64.{ (+) as addWasmI64, (<<) }
 
   let mut d = parseDecimal(s)
   let digits = WasmI32.fromGrain(d.digits)
-  let mut numDigits = WasmI32.load(WasmI32.fromGrain(d.numDigits), 8n)
-  let mut decimalPoint = WasmI32.load(WasmI32.fromGrain(d.decimalPoint), 8n)
+  let mut numDigits = WasmI32.load(WasmI32.fromGrain(d.numDigits), 4n)
+  let mut decimalPoint = WasmI32.load(WasmI32.fromGrain(d.decimalPoint), 4n)
 
   // Short-circuit if the value can only be a literal 0 or infinity.
   if (numDigits == 0n || decimalPoint < -324n) {
@@ -142,7 +139,7 @@ export let parseLongMantissa = (s: String) => {
       let n = decimalPoint
       let shift = getShift(n)
       Decimal.rightShift(d, shift)
-      decimalPoint = WasmI32.load(WasmI32.fromGrain(d.decimalPoint), 8n)
+      decimalPoint = WasmI32.load(WasmI32.fromGrain(d.decimalPoint), 4n)
       if (decimalPoint < 0n - _DECIMAL_POINT_RANGE) {
         done = true
         break
@@ -169,7 +166,7 @@ export let parseLongMantissa = (s: String) => {
           getShift(0n - decimalPoint)
         }
         Decimal.leftShift(d, shift)
-        decimalPoint = WasmI32.load(WasmI32.fromGrain(d.decimalPoint), 8n)
+        decimalPoint = WasmI32.load(WasmI32.fromGrain(d.decimalPoint), 4n)
         if (decimalPoint > _DECIMAL_POINT_RANGE) {
           done = true
           break
@@ -200,7 +197,7 @@ export let parseLongMantissa = (s: String) => {
           if (
             WasmI64.geU(
               mantissa,
-              WasmI64.shl(1N, WasmI64.add(_MANTISSA_EXPLICIT_BITS_64, 1N))
+              1N << addWasmI64(_MANTISSA_EXPLICIT_BITS_64, 1N)
             )
           ) {
             // Rounding up overflowed to the carry bit, need to
@@ -216,16 +213,12 @@ export let parseLongMantissa = (s: String) => {
             fpInf()
           } else {
             let mut power2 = exp2 - _MINIMUM_EXPONENT
-            if (
-              WasmI64.ltU(mantissa, WasmI64.shl(1N, _MANTISSA_EXPLICIT_BITS_64))
-            ) {
+            if (WasmI64.ltU(mantissa, 1N << _MANTISSA_EXPLICIT_BITS_64)) {
               power2 -= 1n
             }
+            use WasmI64.{ (-), (&) }
             // Zero out all the bits above the explicit mantissa bits.
-            mantissa = WasmI64.and(
-              mantissa,
-              WasmI64.sub(WasmI64.shl(1N, _MANTISSA_EXPLICIT_BITS_64), 1N)
-            )
+            mantissa = mantissa & (1N << _MANTISSA_EXPLICIT_BITS_64) - 1N
             {
               f: WasmI32.toGrain(newInt64(mantissa)): Int64,
               e: WasmI32.toGrain(newInt32(power2)): Int32,

package/runtime/atof/slow.md

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

package/runtime/atof/table.gr

@@ -1,16 +1,17 @@
-/* grainc-flags --no-pervasives */
+@noPervasives
+module Table
 
-import WasmI32 from "runtime/unsafe/wasmi32"
-import WasmI64 from "runtime/unsafe/wasmi64"
-import WasmF64 from "runtime/unsafe/wasmf64"
-import Memory from "runtime/unsafe/memory"
+from "runtime/unsafe/wasmi32" include WasmI32
+from "runtime/unsafe/wasmi64" include WasmI64
+from "runtime/unsafe/wasmf64" include WasmF64
+from "runtime/unsafe/memory" include Memory
 
 @unsafe
 let mut _F64_POWERS10_FAST_PATH = -1n
 
 @unsafe
-export let get_F64_POWERS10_FAST_PATH = () => {
-  let (==) = WasmI32.eq
+provide let get_F64_POWERS10_FAST_PATH = () => {
+  use WasmI32.{ (==) }
   if (_F64_POWERS10_FAST_PATH == -1n) {
     _F64_POWERS10_FAST_PATH = Memory.malloc(256n) // 32 x 64-bit values
 
@@ -37,15 +38,15 @@ export let get_F64_POWERS10_FAST_PATH = () => {
     WasmF64.store(_F64_POWERS10_FAST_PATH, 1e20W, 160n)
     WasmF64.store(_F64_POWERS10_FAST_PATH, 1e21W, 168n)
     WasmF64.store(_F64_POWERS10_FAST_PATH, 1e22W, 176n)
-    WasmF64.store(_F64_POWERS10_FAST_PATH, 0.W, 184n)
-    WasmF64.store(_F64_POWERS10_FAST_PATH, 0.W, 192n)
-    WasmF64.store(_F64_POWERS10_FAST_PATH, 0.W, 200n)
-    WasmF64.store(_F64_POWERS10_FAST_PATH, 0.W, 208n)
-    WasmF64.store(_F64_POWERS10_FAST_PATH, 0.W, 216n)
-    WasmF64.store(_F64_POWERS10_FAST_PATH, 0.W, 224n)
-    WasmF64.store(_F64_POWERS10_FAST_PATH, 0.W, 232n)
-    WasmF64.store(_F64_POWERS10_FAST_PATH, 0.W, 240n)
-    WasmF64.store(_F64_POWERS10_FAST_PATH, 0.W, 248n)
+    WasmF64.store(_F64_POWERS10_FAST_PATH, 0.0W, 184n)
+    WasmF64.store(_F64_POWERS10_FAST_PATH, 0.0W, 192n)
+    WasmF64.store(_F64_POWERS10_FAST_PATH, 0.0W, 200n)
+    WasmF64.store(_F64_POWERS10_FAST_PATH, 0.0W, 208n)
+    WasmF64.store(_F64_POWERS10_FAST_PATH, 0.0W, 216n)
+    WasmF64.store(_F64_POWERS10_FAST_PATH, 0.0W, 224n)
+    WasmF64.store(_F64_POWERS10_FAST_PATH, 0.0W, 232n)
+    WasmF64.store(_F64_POWERS10_FAST_PATH, 0.0W, 240n)
+    WasmF64.store(_F64_POWERS10_FAST_PATH, 0.0W, 248n)
   }
   _F64_POWERS10_FAST_PATH
 }
@@ -54,8 +55,8 @@ export let get_F64_POWERS10_FAST_PATH = () => {
 let mut _POWERS5 = -1n
 
 @unsafe
-export let get_POWERS5 = () => {
-  let (==) = WasmI32.eq
+provide let get_POWERS5 = () => {
+  use WasmI32.{ (==) }
   if (_POWERS5 == -1n) {
     _POWERS5 = Memory.malloc(10416n) // 1302 x 64-bit values
     //5^-342

package/runtime/atof/table.md

@@ -1,12 +1,20 @@
+---
+title: Table
+---
+
+## Values
+
+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

@@ -1,24 +1,51 @@
-// TODO(#1050): Remove dependency on Pervasives once Option/Result types are imbedded in the compiler
+@noPervasives
+module Parse
 
-import WasmI32, {
-  add as (+),
-  sub as (-),
+from "runtime/unsafe/wasmi32" include WasmI32
+use WasmI32.{
+  (+),
+  (-),
   gtU as (>),
   geU as (>=),
   ltU as (<),
-  shrS as (>>),
-  eq as (==),
-  ne as (!=),
-  and as (&),
-} from "runtime/unsafe/wasmi32"
-import WasmI64 from "runtime/unsafe/wasmi64"
-import Memory from "runtime/unsafe/memory"
-import Tags from "runtime/unsafe/tags"
-import BI from "runtime/bigint"
-import { reducedInteger } from "runtime/numbers"
+  (>>),
+  (==),
+  (!=),
+  (&),
+}
+from "runtime/unsafe/wasmi64" include WasmI64
+from "runtime/unsafe/memory" include Memory
+from "runtime/unsafe/tags" include Tags
+from "runtime/bigint" include Bigint as BI
+from "runtime/numbers" include Numbers
+use Numbers.{ reducedInteger }
+
+/**
+ * Represents an error that occurred trying to parse an integer.
+ *
+ * @since v0.6.0
+ */
+provide enum ParseIntError {
+  /**
+   * Represents an error caused by trying to parse an empty string.
+   */
+  ParseIntEmptyString,
+  /**
+   * Represents an error caused by trying to parse a string with an invalid character.
+   */
+  ParseIntInvalidDigit,
+  /**
+   * Represents an error caused by trying to parse with an invalid radix.
+   */
+  ParseIntInvalidRadix,
+}
+
+primitive (&&) = "@and"
+primitive (||) = "@or"
 
 @unsafe
-export let parseInt = (string: String, radix: Number) => {
+provide let parseInt = (string: String, radix: Number) => {
+  use WasmI64.{ (+) as addWasmI64 }
   let _CHAR_0 = 0x30n
   let _CHAR_B = 0x42n
   let _CHAR_b = 0x62n
@@ -51,146 +78,136 @@ export let parseInt = (string: String, radix: Number) => {
     radix < WasmI32.fromGrain(2) ||
     radix > WasmI32.fromGrain(36)
   ) {
-    Err("Radix must be an integer between 2 and 36")
-  } else if (WasmI32.eqz(strLen)) {
-    Err("Invalid input")
-  } else {
-    let mut char = WasmI32.load8U(offset, 0n)
-
-    let mut limit = WasmI64.add(_INT_MIN, 1N)
-
-    // Check for a sign
-    let mut negative = false
-    if (char == _CHAR_MINUS) {
-      negative = true
-      offset += 1n
-      limit = _INT_MIN
-      char = WasmI32.load8U(offset, 0n)
-    }
+    return Err(ParseIntInvalidRadix)
+  }
 
-    let mut radix = WasmI64.extendI32S(radix >> 1n)
-
-    // Check if we should override the supplied radix
-    if (char == _CHAR_0 && strLen > 2n) {
-      match (WasmI32.load8U(offset, 1n)) {
-        c when c == _CHAR_B || c == _CHAR_b => {
-          radix = 2N
-          offset += 2n
-        },
-        c when c == _CHAR_O || c == _CHAR_o => {
-          radix = 8N
-          offset += 2n
-        },
-        c when c == _CHAR_X || c == _CHAR_x => {
-          radix = 16N
-          offset += 2n
-        },
-        _ => void,
-      }
-    }
+  if (WasmI32.eqz(strLen)) {
+    return Err(ParseIntEmptyString)
+  }
 
-    // We try to avoid allocating a BigInt if it's not needed
-    let mut value = 0N
-    let mut radixBigInt = 0n
-    let mut valueBigInt = 0n
-    let mut isBigInt = 0n
+  let mut char = WasmI32.load8U(offset, 0n)
 
-    // we use 0 to represent no error and 1 to represent an invalid input
-    let mut error = 1n
+  let mut limit = addWasmI64(_INT_MIN, 1N)
 
-    for (let mut i = offset; i < strEnd; i += 1n) {
-      let char = WasmI32.load8U(i, 0n)
+  // Check for a sign
+  let mut negative = false
+  if (char == _CHAR_MINUS) {
+    negative = true
+    offset += 1n
+    limit = _INT_MIN
+    char = WasmI32.load8U(offset, 0n)
+  }
 
-      // Ignore underscore characters
-      if (char == _CHAR_UNDERSCORE) {
-        continue
-      }
+  let mut radix = WasmI64.extendI32S(radix >> 1n)
 
-      // We've seen at least one non-underscore character, so we'll consider
-      // the input valid until we find out otherwise
+  // Check if we should override the supplied radix
+  if (char == _CHAR_0 && strLen > 2n) {
+    match (WasmI32.load8U(offset, 1n)) {
+      c when c == _CHAR_B || c == _CHAR_b => {
+        radix = 2N
+        offset += 2n
+      },
+      c when c == _CHAR_O || c == _CHAR_o => {
+        radix = 8N
+        offset += 2n
+      },
+      c when c == _CHAR_X || c == _CHAR_x => {
+        radix = 16N
+        offset += 2n
+      },
+      _ => void,
+    }
+  }
 
-      error = 0n
+  // We try to avoid allocating a BigInt if it's not needed
+  let mut value = 0N
+  let mut radixBigInt = 0n
+  let mut valueBigInt = 0n
+  let mut isBigInt = 0n
+  let mut sawDigit = 0n
 
-      let mut digit = 0n
+  for (let mut i = offset; i < strEnd; i += 1n) {
+    let char = WasmI32.load8U(i, 0n)
 
-      match (char) {
-        c when c - _CHAR_0 < 10n => digit = char - _CHAR_0,
-        c when c - _CHAR_A < 26n => digit = char - _CHAR_A + 10n,
-        c when c - _CHAR_a < 26n => digit = char - _CHAR_a + 10n,
-        _ => {
-          error = 1n
-          // invalid digit
-          break
-        },
-      }
+    // Ignore underscore characters
+    if (char == _CHAR_UNDERSCORE) {
+      continue
+    }
 
-      if (digit >= WasmI32.wrapI64(radix)) {
-        error = 1n
-        // invalid digit
-        break
-      }
+    sawDigit = 1n
 
-      let digit = WasmI64.extendI32U(digit)
-
-      if (WasmI32.eqz(isBigInt)) {
-        let prevValue = value
-        value = WasmI64.mul(value, radix)
-        // Check for overflow
-        // 64-bit int min + 1
-        if (WasmI64.ltS(value, WasmI64.add(limit, digit))) {
-          // we overflowed. allocate BigInt and use instead
-          isBigInt = 1n
-          valueBigInt = BI.makeWrappedUint64(WasmI64.mul(prevValue, -1N))
-          radixBigInt = BI.makeWrappedUint64(radix)
-          let newvalue = BI.mul(valueBigInt, radixBigInt)
-          Memory.decRef(valueBigInt)
-          valueBigInt = newvalue
-          let newvalue = BI.addInt(valueBigInt, digit)
-          Memory.decRef(valueBigInt)
-          valueBigInt = newvalue
-        } else {
-          // To quote the OpenJDK,
-          // "Accumulating negatively avoids surprises near MAX_VALUE"
-          // The minimum value of a 64-bit integer (-9223372036854775808) can't be
-          // represented as a positive number because it would be larger than the
-          // maximum 64-bit integer (9223372036854775807), so we'd be unable to
-          // parse negatives as positives and multiply by the sign at the end.
-          // Instead, we represent all positive numbers as negative numbers since
-          // we have one unit more headroom.
-          value = WasmI64.sub(value, digit)
-        }
-      } else {
+    let mut digit = 0n
+
+    match (char) {
+      c when c - _CHAR_0 < 10n => digit = char - _CHAR_0,
+      c when c - _CHAR_A < 26n => digit = char - _CHAR_A + 10n,
+      c when c - _CHAR_a < 26n => digit = char - _CHAR_a + 10n,
+      _ => {
+        return Err(ParseIntInvalidDigit)
+      },
+    }
+
+    if (digit >= WasmI32.wrapI64(radix)) {
+      return Err(ParseIntInvalidDigit)
+    }
+
+    let digit = WasmI64.extendI32U(digit)
+
+    if (WasmI32.eqz(isBigInt)) {
+      use WasmI64.{ (+) }
+      use WasmI64.{ (*), (<) }
+      let prevValue = value
+      value *= radix
+      // Check for overflow
+      // 64-bit int min + 1
+      if (value < limit + digit) {
+        // we overflowed. allocate BigInt and use instead
+        isBigInt = 1n
+        valueBigInt = BI.makeWrappedUint64(prevValue * -1N)
+        radixBigInt = BI.makeWrappedUint64(radix)
         let newvalue = BI.mul(valueBigInt, radixBigInt)
         Memory.decRef(valueBigInt)
         valueBigInt = newvalue
         let newvalue = BI.addInt(valueBigInt, digit)
         Memory.decRef(valueBigInt)
         valueBigInt = newvalue
+      } else {
+        use WasmI64.{ (-) }
+        // To quote the OpenJDK,
+        // "Accumulating negatively avoids surprises near MAX_VALUE"
+        // The minimum value of a 64-bit integer (-9223372036854775808) can't be
+        // represented as a positive number because it would be larger than the
+        // maximum 64-bit integer (9223372036854775807), so we'd be unable to
+        // parse negatives as positives and multiply by the sign at the end.
+        // Instead, we represent all positive numbers as negative numbers since
+        // we have one unit more headroom.
+        value -= digit
       }
+    } else {
+      let newvalue = BI.mul(valueBigInt, radixBigInt)
+      Memory.decRef(valueBigInt)
+      valueBigInt = newvalue
+      let newvalue = BI.addInt(valueBigInt, digit)
+      Memory.decRef(valueBigInt)
+      valueBigInt = newvalue
     }
+  }
+  use WasmI64.{ (*) }
+  // TODO: Verify this is suitable for handling "_"
+  if (WasmI32.eqz(sawDigit)) return Err(ParseIntInvalidDigit)
+
+  if (WasmI32.eqz(isBigInt)) {
+    let value = if (negative) value else value * -1N
+    let number = WasmI32.toGrain(Memory.incRef(reducedInteger(value))): Number
+    return Ok(number)
+  }
 
-    match (error) {
-      1n => {
-        Err("Invalid digit in input")
-      },
-      _ => {
-        if (WasmI32.eqz(isBigInt)) {
-          let value = if (negative) value else WasmI64.mul(value, -1N)
-          let number = WasmI32.toGrain(
-            Memory.incRef(reducedInteger(value))
-          ): Number
-          Ok(number)
-        } else {
-          // BigInt number is accumulated in positive form
-          if (negative) {
-            let newvalue = BI.negate(valueBigInt)
-            Memory.decRef(valueBigInt)
-            Ok(WasmI32.toGrain(newvalue))
-          } else {
-            Ok(WasmI32.toGrain(valueBigInt))
-          }
-        }
-      },
-    }
+  // BigInt number is accumulated in positive form
+  if (negative) {
+    let newvalue = BI.negate(valueBigInt)
+    Memory.decRef(valueBigInt)
+    return Ok(WasmI32.toGrain(newvalue))
   }
+
+  return Ok(WasmI32.toGrain(valueBigInt))
 }

package/runtime/atoi/parse.md

@@ -1,6 +1,55 @@
+---
+title: Parse
+---
+
+## Types
+
+Type declarations included in the Parse module.
+
+### Parse.**ParseIntError**
+
+<details disabled>
+<summary tabindex="-1">Added in <code>0.6.0</code></summary>
+No other changes yet.
+</details>
+
+```grain
+enum ParseIntError {
+  ParseIntEmptyString,
+  ParseIntInvalidDigit,
+  ParseIntInvalidRadix,
+}
+```
+
+Represents an error that occurred trying to parse an integer.
+
+Variants:
+
+```grain
+ParseIntEmptyString
+```
+
+Represents an error caused by trying to parse an empty string.
+
+```grain
+ParseIntInvalidDigit
+```
+
+Represents an error caused by trying to parse a string with an invalid character.
+
+```grain
+ParseIntInvalidRadix
+```
+
+Represents an error caused by trying to parse with an invalid radix.
+
+## Values
+
+Functions and constants included in the Parse module.
+
 ### Parse.**parseInt**
 
 ```grain
-parseInt : (String, Number) -> Result<Number, String>
+parseInt : (string: String, radix: Number) => Result<Number, ParseIntError>
 ```