@grain/stdlib 0.5.13 → 0.6.1

package/runtime/atof/lemire.gr

@@ -1,5 +1,3 @@
-/* grainc-flags --no-pervasives */
-
 // This module was based on Rust's dec2flt
 // https://github.com/rust-lang/rust/blob/1cbc45942d5c0f6eb5d94e3b10762ba541958035/library/core/src/num/dec2flt/lemire.rs
 // Rust's MIT license is provided below:
@@ -13,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
@@ -28,14 +26,19 @@
  * IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  * DEALINGS IN THE SOFTWARE.
 */
+@noPervasives
+module Lemire
 
-import WasmI32 from "runtime/unsafe/wasmi32"
-import WasmI64 from "runtime/unsafe/wasmi64"
+from "runtime/unsafe/wasmi32" include WasmI32
+from "runtime/unsafe/wasmi64" include WasmI64
 
-import { newInt32, newInt64, newFloat64 } from "runtime/dataStructures"
-import { get_POWERS5 } from "./table"
+from "runtime/dataStructures" include DataStructures
+use DataStructures.{ newInt32, newInt64, newFloat64 }
+from "runtime/atof/table" include Table
+use Table.{ get_POWERS5 }
 
-import {
+from "runtime/atof/common" include Common
+use Common.{
   _SMALLEST_POWER_OF_FIVE,
   _LARGEST_POWER_OF_FIVE,
   _INFINITE_POWER,
@@ -48,15 +51,15 @@ import {
   _MAX_EXPONENT_ROUND_TO_EVEN,
   fullMultiplication,
   power,
-  BiasedFp,
+  type BiasedFp,
   fpZero,
   fpInf,
   fpErr,
-} from "./common"
+}
 
-primitive (&&): (Bool, Bool) -> Bool = "@and"
-primitive (||): (Bool, Bool) -> Bool = "@or"
-primitive (!): Bool -> Bool = "@not"
+primitive (&&) = "@and"
+primitive (||) = "@or"
+primitive (!) = "@not"
 
 // From Rust:
 // This will compute or rather approximate w * 5**q and return a pair of 64-bit words
@@ -64,18 +67,11 @@ primitive (!): Bool -> Bool = "@not"
 // bits and the low part corresponding to the least significant bits.
 @unsafe
 let computeProductApprox = (q: WasmI64, w: WasmI64, precision: WasmI64) => {
-  let (==) = WasmI64.eq
-  let (&) = WasmI64.and
-  let (>) = WasmI64.gtU
-  let (<) = WasmI64.ltU
-  let (>=) = WasmI64.geS
-  let (<=) = WasmI64.leS
-  let (>>) = WasmI64.shrU
-  let (-) = WasmI64.sub
-  let (+) = WasmI64.add
+  use WasmI64.{ (==), (&), gtU as (>), ltU as (<), (>=), (<=), (>>>), (-), (+) }
+  use WasmI32.{ (*) }
 
   let mask = if (precision < 64N) {
-    0xFFFF_FFFF_FFFF_FFFFN >> precision
+    0xFFFF_FFFF_FFFF_FFFFN >>> precision
   } else {
     0xFFFF_FFFF_FFFF_FFFFN
   }
@@ -85,10 +81,11 @@ let computeProductApprox = (q: WasmI64, w: WasmI64, precision: WasmI64) => {
   // That means whenever we need to round ties to even, we always have
   // an exact value.
   let index = q - _SMALLEST_POWER_OF_FIVE
-  let n = WasmI32.mul(16n, WasmI32.wrapI64(index))
-  let lo5 = WasmI64.load(get_POWERS5(), n),
-    hi5 = WasmI64.load(get_POWERS5(), WasmI32.add(n, 8n))
-
+  let n = 16n * WasmI32.wrapI64(index)
+  use WasmI32.{ (+) }
+  let lo5 = WasmI64.load(get_POWERS5(), n)
+  and hi5 = WasmI64.load(get_POWERS5(), n + 8n)
+  use WasmI64.{ (+) }
   // From Rust:
   // Only need one multiplication as long as there is 1 zero but
   // in the explicit mantissa bits, +1 for the hidden bit, +1 to
@@ -120,16 +117,8 @@ let computeProductApprox = (q: WasmI64, w: WasmI64, precision: WasmI64) => {
 // Returns the significant bits and a biased binary exponent that can be directly shifted into exponent bits:
 // (u64, i32)
 @unsafe
-export let computeFloat = (exponent: WasmI64, mantissa: WasmI64) => {
-  let (==) = WasmI64.eq
-  let (<) = WasmI64.ltS
-  let (<=) = WasmI64.leS
-  let (>) = WasmI64.gtS
-  let (>=) = WasmI64.geS
-  let (<<) = WasmI64.shl
-  let (>>) = WasmI64.shrS
-  let (&) = WasmI64.and
-  let (+) = WasmI64.add
+provide let computeFloat = (exponent: WasmI64, mantissa: WasmI64) => {
+  use WasmI64.{ (==), (<), (<=), (>), (>=), (<<), (>>), (&), (+), (>>>) }
 
   let w = mantissa
   let q = exponent
@@ -163,33 +152,30 @@ export let computeFloat = (exponent: WasmI64, mantissa: WasmI64) => {
     match (lo == 0xFFFF_FFFF_FFFF_FFFFN && !(q >= -27N && q <= 55N)) {
       true => fpErr(),
       false => {
-        let upperbit = WasmI32.wrapI64(WasmI64.shrU(hi, 63N))
-        let mut mantissa = WasmI64.shrU(
-          hi,
-          WasmI64.extendI32S(
-            {
-              let (+) = WasmI32.add
-              let (-) = WasmI32.sub
-              upperbit + 64n - _MANTISSA_EXPLICIT_BITS_32 - 3n
-            }
-          )
-        )
+        let upperbit = WasmI32.wrapI64(hi >>> 63N)
+        let mut mantissa = hi >>> WasmI64.extendI32S({
+          use WasmI32.{ (+), (-) }
+          upperbit + 64n - _MANTISSA_EXPLICIT_BITS_32 - 3n
+        })
         let mut power2 = {
-          let (+) = WasmI32.add
-          let (-) = WasmI32.sub
+          use WasmI32.{ (+), (-) }
           let q = WasmI32.wrapI64(q)
           let lz = WasmI32.wrapI64(lz)
           power(q) + upperbit - lz - _MINIMUM_EXPONENT
         }
-        if (WasmI32.leS(power2, 0n)) {
+
+        use WasmI32.{ (<=) }
+        if (power2 <= 0n) {
+          use WasmI32.{ (+), (*), (>=) }
           // -power2 + 1 >= 64
-          if (WasmI32.geS(WasmI32.add(WasmI32.mul(-1n, power2), 1n), 64n)) {
+          if (-1n * power2 + 1n >= 64n) {
             // Have more than 64 bits below the minimum exponent, must be 0.
             fpZero()
           } else {
+            use WasmI64.{ (>=) }
             // Have a subnormal value.
-            mantissa = mantissa >>
-              WasmI64.extendI32S(WasmI32.add(WasmI32.mul(-1n, power2), 1n))
+            mantissa = mantissa >> WasmI64.extendI32S(-1n * power2 + 1n)
+            use WasmI64.{ (+) }
             mantissa += mantissa & 1N
             mantissa = mantissa >> 1N
             power2 = if (mantissa >= 1N << _MANTISSA_EXPLICIT_BITS_64) {
@@ -204,6 +190,7 @@ export let computeFloat = (exponent: WasmI64, mantissa: WasmI64) => {
             }
           }
         } else {
+          use WasmI64.{ (<=) }
           // Need to handle rounding ties. Normally, we need to round up,
           // but if we fall right in between and and we have an even basis, we
           // need to round down.
@@ -220,38 +207,36 @@ export let computeFloat = (exponent: WasmI64, mantissa: WasmI64) => {
             q >= _MIN_EXPONENT_ROUND_TO_EVEN &&
             q <= _MAX_EXPONENT_ROUND_TO_EVEN &&
             (mantissa & 3N) == 1N &&
-            mantissa <<
-            WasmI64.extendI32S(
-              {
-                let (+) = WasmI32.add
-                let (-) = WasmI32.sub
-                upperbit + 64n - _MANTISSA_EXPLICIT_BITS_32 - 3n
-              }
-            ) ==
-            hi
+            mantissa << WasmI64.extendI32S({
+              use WasmI32.{ (+), (-) }
+              upperbit + 64n - _MANTISSA_EXPLICIT_BITS_32 - 3n
+            }) == hi
           ) {
+            use WasmI64.{ (^) }
             // Zero the lowest bit, so we don't round up.
             // mantissa &= !1N;
-            mantissa = mantissa & WasmI64.xor(1N, -1N)
+            mantissa = mantissa & (1N ^ -1N)
           }
           // Round-to-even, then shift the significant digits into place.
           mantissa += mantissa & 1N
-          mantissa = WasmI64.shrU(mantissa, 1N)
+          use WasmI64.{ (>>>) }
+          mantissa = mantissa >>> 1N
           if (WasmI64.geU(mantissa, 2N << _MANTISSA_EXPLICIT_BITS_64)) {
+            use WasmI32.{ (+) }
             // Rounding up overflowed, so the carry bit is set. Set the
             // mantissa to 1 (only the implicit, hidden bit is set) and
             // increase the exponent.
             mantissa = 1N << _MANTISSA_EXPLICIT_BITS_64
-            power2 = WasmI32.add(power2, 1n)
+            power2 += 1n
           }
+          use WasmI32.{ (>=) }
+          use WasmI64.{ (^) }
           // Zero out the hidden bit.
-          mantissa = mantissa &
-            WasmI64.xor(1N << _MANTISSA_EXPLICIT_BITS_64, -1N)
-          if (WasmI32.geS(power2, _INFINITE_POWER)) {
+          mantissa = mantissa & (1N << _MANTISSA_EXPLICIT_BITS_64 ^ -1N)
+          if (power2 >= _INFINITE_POWER) {
             // Exponent is above largest normal value, must be infinite.
             fpInf()
           } else {
-
             {
               f: WasmI32.toGrain(newInt64(mantissa)): Int64,
               e: WasmI32.toGrain(newInt32(power2)): Int32,

package/runtime/atof/lemire.md

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

package/runtime/atof/parse.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,13 +26,16 @@
  * IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  * DEALINGS IN THE SOFTWARE.
 */
+module Parse
 
-import WasmI32 from "runtime/unsafe/wasmi32"
-import WasmI64 from "runtime/unsafe/wasmi64"
-import WasmF64 from "runtime/unsafe/wasmf64"
-import { newInt32, newInt64, newFloat64 } from "runtime/dataStructures"
+from "runtime/unsafe/wasmi32" include WasmI32
+from "runtime/unsafe/wasmi64" include WasmI64
+from "runtime/unsafe/wasmf64" include WasmF64
+from "runtime/dataStructures" include DataStructures
+use DataStructures.{ newInt32, newInt64, newFloat64 }
 
-import {
+from "runtime/atof/common" include Common
+use Common.{
   _CHAR_CODE_UNDERSCORE,
   _CHAR_CODE_PLUS,
   _CHAR_CODE_MINUS,
@@ -58,41 +61,32 @@ import {
   biasedFpToNumber,
   fpNan,
   fpInf,
-} from "./common"
+}
 
-import { computeFloat } from "./lemire"
-import { parseLongMantissa } from "./slow"
+from "runtime/atof/lemire" include Lemire
+use Lemire.{ computeFloat }
+from "runtime/atof/slow" include Slow
+use Slow.{ parseLongMantissa }
 
 // Try to parse 8 digits at a time:
 // https://johnnylee-sde.github.io/Fast-numeric-string-to-int/
 @unsafe
 let parse8Digits = (digits: WasmI64) => {
-  let (+) = WasmI64.add
-  let (-) = WasmI64.sub
-  let (*) = WasmI64.mul
-  let (>>) = WasmI64.shrU
-  let (&) = WasmI64.and
-  let (|) = WasmI64.or
-  let (==) = WasmI64.eq
+  use WasmI64.{ (+), (-), (*), (>>>), (&), (|), (==) }
 
   let _MASK = 0x0000_00FF_0000_00FFN
 
   let a = digits - 0x3030_3030_3030_3030N
-  let b = a * 10N + (a >> 8N)
+  let b = a * 10N + (a >>> 8N)
   let c = (b & _MASK) * 0x000F_4240_0000_0064N
-  let d = (b >> 16N & _MASK) * 0x0000_2710_0000_0001N
+  let d = (b >>> 16N & _MASK) * 0x0000_2710_0000_0001N
 
-  (c + d) >> 32N
+  (c + d) >>> 32N
 }
 
 @unsafe
 let parseScientificExponent = (ptr: WasmI32, offset: WasmI32, len: WasmI32) => {
-  let (+) = WasmI32.add
-  let (-) = WasmI32.sub
-  let (>=) = WasmI32.geU
-  let (<) = WasmI32.ltU
-  let (==) = WasmI32.eq
-  let (!=) = WasmI32.ne
+  use WasmI32.{ (+), (-), (*), geU as (>=), ltU as (<), (==), (!=) }
 
   let mut offset = offset
   let mut exponent = 0n
@@ -119,8 +113,9 @@ let parseScientificExponent = (ptr: WasmI32, offset: WasmI32, len: WasmI32) => {
       let char = WasmI32.load8U(ptr, offset)
       let digit = char - 0x30n
       if (digit >= 0n && digit < 10n) {
-        if (WasmI32.ltS(exponent, 0x10000n)) {
-          exponent = WasmI32.add(digit, WasmI32.mul(10n, exponent))
+        use WasmI32.{ (<) }
+        if (exponent < 0x10000n) {
+          exponent = digit + 10n * exponent
         }
         offset += 1n
       } else if (char == _CHAR_CODE_UNDERSCORE) {
@@ -132,7 +127,7 @@ let parseScientificExponent = (ptr: WasmI32, offset: WasmI32, len: WasmI32) => {
     if (offset != len) {
       Err("Invalid exponent")
     } else if (negative) {
-      Ok(WasmI32.toGrain(newInt32(WasmI32.sub(0n, exponent))): Int32)
+      Ok(WasmI32.toGrain(newInt32(0n - exponent)): Int32)
     } else {
       Ok(WasmI32.toGrain(newInt32(exponent)): Int32)
     }
@@ -141,13 +136,8 @@ let parseScientificExponent = (ptr: WasmI32, offset: WasmI32, len: WasmI32) => {
 
 @unsafe
 let parseFloatToParts = (string: String) => {
-  let (+) = WasmI32.add
-  let (-) = WasmI32.sub
-  let (>) = WasmI32.gtU
-  let (>=) = WasmI32.geU
-  let (<) = WasmI32.ltU
-  let (==) = WasmI32.eq
-  let (!=) = WasmI32.ne
+  use WasmI32.{ (+), (-), gtU as (>), geU as (>=), ltU as (<), (==), (!=) }
+  use WasmI64.{ (+) as addWasmI64, (*) }
 
   let ptr = WasmI32.fromGrain(string)
   match (WasmI32.load(ptr, 4n)) {
@@ -183,10 +173,7 @@ let parseFloatToParts = (string: String) => {
         let char = WasmI32.load8U(ptr, i)
         let digit = char - _CHAR_CODE_0
         if (digit >= 0n && digit < 10n) {
-          mantissa = WasmI64.add(
-            WasmI64.mul(mantissa, 10N),
-            WasmI64.extendI32U(digit)
-          )
+          mantissa = addWasmI64(mantissa * 10N, WasmI64.extendI32U(digit))
           numDigits += 1n
           i += 1n
         } else if (char == _CHAR_CODE_UNDERSCORE) {
@@ -207,10 +194,7 @@ let parseFloatToParts = (string: String) => {
           while (WasmI32.leU(i + 8n, len)) {
             let digits = WasmI64.load(ptr, i)
             if (is8Digits(digits)) {
-              mantissa = WasmI64.add(
-                parse8Digits(digits),
-                WasmI64.mul(mantissa, 100000000N)
-              )
+              mantissa = addWasmI64(parse8Digits(digits), mantissa * 100000000N)
               i += 8n
               numDigitsAfterDot += 8n
             } else {
@@ -222,10 +206,7 @@ let parseFloatToParts = (string: String) => {
             let char = WasmI32.load8U(ptr, i)
             let digit = char - _CHAR_CODE_0
             if (digit >= 0n && digit < 10n) {
-              mantissa = WasmI64.add(
-                WasmI64.extendI32U(digit),
-                WasmI64.mul(mantissa, 10N)
-              )
+              mantissa = addWasmI64(WasmI64.extendI32U(digit), mantissa * 10N)
               i += 1n
               numDigitsAfterDot += 1n
             } else if (char == _CHAR_CODE_UNDERSCORE) {
@@ -242,7 +223,7 @@ let parseFloatToParts = (string: String) => {
       numDigits += numDigitsAfterDot
 
       match (numDigits) {
-        n when n == 0n => Err("Invalid float"),
+        0n => Err("Invalid float"),
         _ => {
           let _MAX_MANTISSA_DIGITS = 19n // 10^19 fits in uint64
           let _MIN_19DIGIT_INT = 100_0000_0000_0000_0000N
@@ -266,7 +247,7 @@ let parseFloatToParts = (string: String) => {
             Ok(exponentNumber) => {
               let exponentNumber = WasmI32.load(
                 WasmI32.fromGrain(exponentNumber),
-                8n
+                4n
               )
               exponent += exponentNumber
 
@@ -278,14 +259,15 @@ let parseFloatToParts = (string: String) => {
                 while (i < len) {
                   let c = WasmI32.load8U(ptr, i)
                   if (c == _CHAR_CODE_DOT || c == _CHAR_CODE_0) {
+                    use WasmI32.{ (<), (>) }
                     let n = c - (_CHAR_CODE_0 - 1n)
-                    numDigits -= if (WasmI32.ltS(n, 0n)) {
-                        0n
-                      } else if (WasmI32.gtS(n, 255n)) {
-                        255n
-                      } else {
-                        n
-                      }
+                    numDigits -= if (n < 0n) {
+                      0n
+                    } else if (n > 255n) {
+                      255n
+                    } else {
+                      n
+                    }
                     i += 1n
                   } else if (c == _CHAR_CODE_UNDERSCORE) {
                     continue
@@ -296,7 +278,8 @@ let parseFloatToParts = (string: String) => {
 
                 // Attempt to parse 19 digits, the most that can fit in an i64
                 let mut digitsParsed = 0n
-                if (WasmI32.gtS(numDigits, 0n)) {
+                use WasmI32.{ (>) }
+                if (numDigits > 0n) {
                   manyDigits = true
                   mantissa = 0N
 
@@ -306,8 +289,8 @@ let parseFloatToParts = (string: String) => {
                       let char = WasmI32.load8U(ptr, i)
                       let digit = char - _CHAR_CODE_0
                       if (digit >= 0n && digit < 10n) {
-                        mantissa = WasmI64.add(
-                          WasmI64.mul(mantissa, 10N),
+                        mantissa = addWasmI64(
+                          mantissa * 10N,
                           WasmI64.extendI32U(digit)
                         )
                         i += 1n
@@ -339,8 +322,8 @@ let parseFloatToParts = (string: String) => {
                         let char = WasmI32.load8U(ptr, i)
                         let digit = char - _CHAR_CODE_0
                         if (digit < 10n) {
-                          mantissa = WasmI64.add(
-                            WasmI64.mul(mantissa, 10N),
+                          mantissa = addWasmI64(
+                            mantissa * 10N,
                             WasmI64.extendI32U(digit)
                           )
                           i += 1n
@@ -365,7 +348,7 @@ let parseFloatToParts = (string: String) => {
                     WasmI32.toGrain(newInt64(mantissa)): Int64,
                     negative,
                     manyDigits,
-                  )
+                  ),
                 )
               } else {
                 Ok(
@@ -374,7 +357,7 @@ let parseFloatToParts = (string: String) => {
                     WasmI32.toGrain(newInt64(mantissa)): Int64,
                     negative,
                     manyDigits,
-                  )
+                  ),
                 )
               }
             },
@@ -388,12 +371,7 @@ let parseFloatToParts = (string: String) => {
 
 @unsafe
 let parseInfNan = s => {
-  let (+) = WasmI32.add
-  let (-) = WasmI32.sub
-  let (<) = WasmI32.ltS
-  let (>=) = WasmI32.geS
-  let (<=) = WasmI32.leS
-  let (==) = WasmI32.eq
+  use WasmI32.{ (+), (-), (<), (>=), (<=), (==) }
 
   let ptr = WasmI32.fromGrain(s)
   match (WasmI32.load(ptr, 4n)) {
@@ -448,7 +426,9 @@ let parseInfNan = s => {
         ) {
           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))
@@ -497,15 +477,14 @@ let parseInfNan = s => {
 }
 
 @unsafe
-export let isFastPath =
-  (
-    exponent: WasmI32,
-    mantissa: WasmI64,
-    negative: Bool,
-    manyDigits: Bool,
-  ) => {
-  let (<=) = WasmI32.leS
-  let (<<) = WasmI64.shl
+provide let isFastPath = (
+  exponent: WasmI32,
+  mantissa: WasmI64,
+  negative: Bool,
+  manyDigits: Bool,
+) => {
+  use WasmI32.{ (<=) }
+  use WasmI64.{ (<<) }
 
   _MIN_EXPONENT_FAST_PATH <= exponent &&
     exponent <= _MAX_EXPONENT_DISGUISED_FAST_PATH &&
@@ -514,53 +493,48 @@ export let isFastPath =
 }
 
 @unsafe
-export let parseFloat = (string: String) => {
-  let (!=) = WasmI32.ne
-
+provide let parseFloat = (string: String) => {
+  use WasmI32.{ (!=), (*) }
   match (parseFloatToParts(string)) {
     Ok((exponent, mantissa, negative, manyDigits)) => {
-      let exponent = WasmI32.load(WasmI32.fromGrain(exponent), 8n)
+      use WasmI64.{ (+), (>) }
+      let exponent = WasmI32.load(WasmI32.fromGrain(exponent), 4n)
       let mantissa = WasmI64.load(WasmI32.fromGrain(mantissa), 8n)
       let floatOpt = if (isFastPath(exponent, mantissa, negative, manyDigits)) {
-        let (<=) = WasmI32.leS
+        use WasmI32.{ (<=) }
         if (exponent <= _MAX_EXPONENT_FAST_PATH) {
           // normal fast path
-          let (*) = WasmF64.mul
-          let (/) = WasmF64.div
-          let (<) = WasmI32.leS
-
+          use WasmF64.{ (/), (*) }
+          use WasmI32.{ (<) }
           let mantissa = WasmF64.convertI64U(mantissa)
           let n = if (exponent < 0n) {
-            mantissa / getPowers10FastPath(WasmI32.mul(exponent, -1n))
+            use WasmI32.{ (*) }
+            mantissa / getPowers10FastPath(exponent * -1n)
           } else {
             mantissa * getPowers10FastPath(exponent)
           }
           if (negative) {
-            Some(WasmI32.toGrain(newFloat64(n * -1.W)): Number)
+            Some(WasmI32.toGrain(newFloat64(n * -1.0W)): Number)
           } else {
             Some(WasmI32.toGrain(newFloat64(n)): Number)
           }
         } else {
           // disguised fast path
-          let (-) = WasmI32.sub
-          let (*) = WasmF64.mul
-          let (>) = WasmI64.gtS
+          use WasmI32.{ (-) }
+          use WasmI64.{ (*), (<=) }
 
           let shift = exponent - _MAX_EXPONENT_FAST_PATH
 
-          let mantissa = WasmI64.mul(
-            mantissa,
-            WasmI64.extendI32U(getPowers10(shift))
-          )
+          let mantissa = mantissa * WasmI64.extendI32U(getPowers10(shift))
           if (mantissa > _MAX_MANTISSA_FAST_PATH) {
             None
           } else {
-            assert WasmI64.leS(mantissa, _MAX_MANTISSA_FAST_PATH)
+            use WasmF64.{ (*) }
 
             let mantissa = WasmF64.convertI64U(mantissa)
             let n = mantissa * getPowers10FastPath(_MAX_EXPONENT_FAST_PATH)
             if (negative) {
-              Some(WasmI32.toGrain(newFloat64(n * -1.W)): Number)
+              Some(WasmI32.toGrain(newFloat64(n * -1.0W)): Number)
             } else {
               Some(WasmI32.toGrain(newFloat64(n)): Number)
             }
@@ -573,6 +547,7 @@ export let parseFloat = (string: String) => {
       match (floatOpt) {
         Some(n) => Ok(n),
         None => {
+          use WasmI32.{ (<), (>=) }
           // From Rust:
           // If significant digits were truncated, then we can have rounding error
           // only if `mantissa + 1` produces a different result. We also avoid
@@ -581,23 +556,21 @@ export let parseFloat = (string: String) => {
 
           let mut fp = computeFloat(WasmI64.extendI32S(exponent), mantissa)
           let f = WasmI64.load(WasmI32.fromGrain(fp.f), 8n)
-          let e = WasmI32.load(WasmI32.fromGrain(fp.e), 8n)
-          if (manyDigits && WasmI32.geS(e, 0n)) {
-            let fp2 = computeFloat(
-              WasmI64.extendI32S(exponent),
-              WasmI64.add(mantissa, 1N)
-            )
+          let e = WasmI32.load(WasmI32.fromGrain(fp.e), 4n)
+          if (manyDigits && e >= 0n) {
+            use WasmI64.{ (!=) as neWasmI64 }
+            let fp2 = computeFloat(WasmI64.extendI32S(exponent), mantissa + 1N)
             let f2 = WasmI64.load(WasmI32.fromGrain(fp2.f), 8n)
-            let e2 = WasmI32.load(WasmI32.fromGrain(fp2.e), 8n)
-            if (e != e2 || WasmI64.ne(f, f2)) {
+            let e2 = WasmI32.load(WasmI32.fromGrain(fp2.e), 4n)
+            if (e != e2 || neWasmI64(f, f2)) {
               fp.e = -1l
             }
           }
 
           // Unable to correctly round the float using the Eisel-Lemire algorithm.
           // Fallback to a slower, but always correct algorithm.
-          let e = WasmI32.load(WasmI32.fromGrain(fp.e), 8n)
-          if (WasmI32.ltS(e, 0n)) {
+          let e = WasmI32.load(WasmI32.fromGrain(fp.e), 4n)
+          if (e < 0n) {
             fp = parseLongMantissa(string)
           }
 

package/runtime/atof/parse.md

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