@grain/stdlib 0.4.4 → 0.5.0

package/runtime/string.md

@@ -0,0 +1,24 @@
+### String.**StringList**
+
+```grain
+type StringList
+```
+
+### String.**concat**
+
+```grain
+concat : (String, String) -> String
+```
+
+### String.**toString**
+
+```grain
+toString : a -> String
+```
+
+### String.**print**
+
+```grain
+print : a -> Void
+```
+

package/runtime/stringUtils.gr

@@ -14,9 +14,10 @@ import 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"
 
-@disableGC
+@unsafe
 export let rec parseInt = (string: String, radix: Number) => {
   let _CHAR_0 = 0x30n
   let _CHAR_B = 0x42n
@@ -45,11 +46,13 @@ export let rec parseInt = (string: String, radix: Number) => {
   let strEnd = offset + strLen
 
   let radix = WasmI32.fromGrain(radix)
-  let result = if (WasmI32.eqz(radix & Tags._GRAIN_NUMBER_TAG_MASK) || radix < WasmI32.fromGrain(2) || radix > WasmI32.fromGrain(36)) {
-    Memory.incRef(WasmI32.fromGrain(Err))
+  if (
+    WasmI32.eqz(radix & Tags._GRAIN_NUMBER_TAG_MASK) ||
+    radix < WasmI32.fromGrain(2) ||
+    radix > WasmI32.fromGrain(36)
+  ) {
     Err("Radix must be an integer between 2 and 36")
   } else if (WasmI32.eqz(strLen)) {
-    Memory.incRef(WasmI32.fromGrain(Err))
     Err("Invalid input")
   } else {
     let mut char = WasmI32.load8U(offset, 0n)
@@ -86,10 +89,13 @@ export let rec parseInt = (string: String, radix: Number) => {
       }
     }
 
+    // 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
 
-    // we use 0 to represent no error, 1 to represent an invalid
-    // input, and 2 to represent an overflow
+    // we use 0 to represent no error and 1 to represent an invalid input
     let mut error = 1n
 
     for (let mut i = offset; i < strEnd; i += 1n) {
@@ -126,47 +132,65 @@ export let rec parseInt = (string: String, radix: Number) => {
 
       let digit = WasmI64.extendI32U(digit)
 
-      value = WasmI64.mul(value, radix)
-
-      // Check for overflow
-      // 64-bit int min + 1
-      if (WasmI64.ltS(value, WasmI64.add(limit, digit))) {
-        error = 2n
-        // overflow
-        break
+      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 newvalue = BI.mul(valueBigInt, radixBigInt)
+        Memory.decRef(valueBigInt)
+        valueBigInt = newvalue
+        let newvalue = BI.addInt(valueBigInt, digit)
+        Memory.decRef(valueBigInt)
+        valueBigInt = newvalue
       }
-
-      // 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)
     }
 
     match (error) {
       1n => {
-        Memory.incRef(WasmI32.fromGrain(Err))
         Err("Invalid digit in input")
       },
-      2n => {
-        Memory.incRef(WasmI32.fromGrain(Err))
-        Err("Input out of range of representable integers")
-      },
       _ => {
-        let value = if (negative) value else WasmI64.mul(value, -1N)
-        let number = WasmI32.toGrain(reducedInteger(value)): (Number)
-        Memory.incRef(WasmI32.fromGrain(Ok))
-        Ok(number)
+        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))
+          }
+        }
       },
     }
   }
-
-  Memory.decRef(WasmI32.fromGrain(parseInt))
-  Memory.decRef(radix)
-
-  result
 }

package/runtime/stringUtils.md

@@ -0,0 +1,6 @@
+### StringUtils.**parseInt**
+
+```grain
+parseInt : (String, Number) -> Result<Number, String>
+```
+

package/runtime/unsafe/constants.gr

@@ -0,0 +1,17 @@
+/* grainc-flags --compilation-mode=runtime */
+
+// Signed/Unsigned Min/Max Constants
+export let _SMIN_I32 = 0xFFFFFFFFn
+export let _SMAX_I32 = 0x7FFFFFFFn
+export let _UMIN_I32 = 0x0n
+export let _UMAX_I32 = 0xFFFFFFFFn
+
+export let _SMIN_I64 = 0xFFFFFFFFFFFFFFFFN
+export let _SMAX_I64 = 0x7FFFFFFFFFFFFFFFN
+export let _UMIN_I64 = 0x0N
+export let _UMAX_I64 = 0xFFFFFFFFFFFFFFFFN
+
+export let _SMIN32_I64 = -0x7FFFFFFFN
+export let _SMAX32_I64 = 0x7FFFFFFFN
+export let _UMIN32_I64 = 0x0N
+export let _UMAX32_I64 = 0xFFFFFFFFN

package/runtime/unsafe/constants.md

@@ -0,0 +1,72 @@
+### Constants.**_SMIN_I32**
+
+```grain
+_SMIN_I32 : WasmI32
+```
+
+### Constants.**_SMAX_I32**
+
+```grain
+_SMAX_I32 : WasmI32
+```
+
+### Constants.**_UMIN_I32**
+
+```grain
+_UMIN_I32 : WasmI32
+```
+
+### Constants.**_UMAX_I32**
+
+```grain
+_UMAX_I32 : WasmI32
+```
+
+### Constants.**_SMIN_I64**
+
+```grain
+_SMIN_I64 : WasmI64
+```
+
+### Constants.**_SMAX_I64**
+
+```grain
+_SMAX_I64 : WasmI64
+```
+
+### Constants.**_UMIN_I64**
+
+```grain
+_UMIN_I64 : WasmI64
+```
+
+### Constants.**_UMAX_I64**
+
+```grain
+_UMAX_I64 : WasmI64
+```
+
+### Constants.**_SMIN32_I64**
+
+```grain
+_SMIN32_I64 : WasmI64
+```
+
+### Constants.**_SMAX32_I64**
+
+```grain
+_SMAX32_I64 : WasmI64
+```
+
+### Constants.**_UMIN32_I64**
+
+```grain
+_UMIN32_I64 : WasmI64
+```
+
+### Constants.**_UMAX32_I64**
+
+```grain
+_UMAX32_I64 : WasmI64
+```
+

package/runtime/unsafe/conv.gr

@@ -6,13 +6,13 @@ import WasmF64 from "runtime/unsafe/wasmf64"
 import Tags from "runtime/unsafe/tags"
 
 @disableGC
-export let toInt32 = (n) => {
+export let toInt32 = n => {
   let ptr = Memory.malloc(12n)
   WasmI32.store(ptr, Tags._GRAIN_BOXED_NUM_HEAP_TAG, 0n)
   WasmI32.store(ptr, Tags._GRAIN_INT32_BOXED_NUM_TAG, 4n)
   WasmI32.store(ptr, n, 8n)
 
-  WasmI32.toGrain(ptr) : Int32
+  WasmI32.toGrain(ptr): Int32
 }
 
 @disableGC
@@ -22,13 +22,13 @@ export let fromInt32 = (n: Int32) => {
 }
 
 @disableGC
-export let toInt64 = (n) => {
+export let toInt64 = n => {
   let ptr = Memory.malloc(16n)
   WasmI32.store(ptr, Tags._GRAIN_BOXED_NUM_HEAP_TAG, 0n)
   WasmI32.store(ptr, Tags._GRAIN_INT64_BOXED_NUM_TAG, 4n)
   WasmI64.store(ptr, n, 8n)
 
-  WasmI32.toGrain(ptr) : Int64
+  WasmI32.toGrain(ptr): Int64
 }
 
 @disableGC
@@ -38,13 +38,13 @@ export let fromInt64 = (n: Int64) => {
 }
 
 @disableGC
-export let toFloat32 = (n) => {
+export let toFloat32 = n => {
   let ptr = Memory.malloc(12n)
   WasmI32.store(ptr, Tags._GRAIN_BOXED_NUM_HEAP_TAG, 0n)
   WasmI32.store(ptr, Tags._GRAIN_FLOAT32_BOXED_NUM_TAG, 4n)
   WasmF32.store(ptr, n, 8n)
 
-  WasmI32.toGrain(ptr) : Float32
+  WasmI32.toGrain(ptr): Float32
 }
 
 @disableGC
@@ -54,13 +54,13 @@ export let fromFloat32 = (n: Float32) => {
 }
 
 @disableGC
-export let toFloat64 = (n) => {
+export let toFloat64 = n => {
   let ptr = Memory.malloc(16n)
   WasmI32.store(ptr, Tags._GRAIN_BOXED_NUM_HEAP_TAG, 0n)
   WasmI32.store(ptr, Tags._GRAIN_FLOAT64_BOXED_NUM_TAG, 4n)
   WasmF64.store(ptr, n, 8n)
 
-  WasmI32.toGrain(ptr) : Float64
+  WasmI32.toGrain(ptr): Float64
 }
 
 @disableGC
@@ -101,13 +101,13 @@ export let wasmI32ToNumber = (n: WasmI32) => {
     // Just test if the untagged number is the same. If it didn't overflow, then
     // we're good. We just need to cast the raw value into a Number at the type
     // system level.
-    WasmI32.toGrain(simple): (Number)
+    WasmI32.toGrain(simple): Number
   } else {
     // If it did overflow, then the value differs and we need to discard it and
     // allocate the number on the heap. A boxed 32 bit number actually is the
     // same thing as an Int32. It only needs to be cast into Number.
     let asInt32 = toInt32(n)
-    WasmI32.toGrain(WasmI32.fromGrain(asInt32)): (Number)
+    WasmI32.toGrain(WasmI32.fromGrain(asInt32)): Number
   }
   result
 }

package/runtime/unsafe/conv.md

@@ -0,0 +1,71 @@
+### Conv.**toInt32**
+
+```grain
+toInt32 : WasmI32 -> Int32
+```
+
+### Conv.**fromInt32**
+
+```grain
+fromInt32 : Int32 -> WasmI32
+```
+
+### Conv.**toInt64**
+
+```grain
+toInt64 : WasmI64 -> Int64
+```
+
+### Conv.**fromInt64**
+
+```grain
+fromInt64 : Int64 -> WasmI64
+```
+
+### Conv.**toFloat32**
+
+```grain
+toFloat32 : WasmF32 -> Float32
+```
+
+### Conv.**fromFloat32**
+
+```grain
+fromFloat32 : Float32 -> WasmF32
+```
+
+### Conv.**toFloat64**
+
+```grain
+toFloat64 : WasmF64 -> Float64
+```
+
+### Conv.**fromFloat64**
+
+```grain
+fromFloat64 : Float64 -> WasmF64
+```
+
+### Conv.**wasmI32ToNumber**
+
+```grain
+wasmI32ToNumber : WasmI32 -> Number
+```
+
+Converts a WasmI32 value to Number.
+
+This function is meant to be called from a `@disableGC` context without
+need to call incRef on the function.
+
+Parameters:
+
+|param|type|description|
+|-----|----|-----------|
+|`n`|`WasmI32`|The WasmI32 to convert|
+
+Returns:
+
+|type|description|
+|----|-----------|
+|`Number`|The value converted to either a simple or a 32 bit heap allocated number.|
+

package/runtime/unsafe/errors.md

@@ -0,0 +1,204 @@
+### Errors.**_GRAIN_ERR_NOT_NUMBER_COMP**
+
+```grain
+_GRAIN_ERR_NOT_NUMBER_COMP : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_NOT_NUMBER_ARITH**
+
+```grain
+_GRAIN_ERR_NOT_NUMBER_ARITH : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_NOT_BOOLEAN_LOGIC**
+
+```grain
+_GRAIN_ERR_NOT_BOOLEAN_LOGIC : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_NOT_BOOLEAN_IF**
+
+```grain
+_GRAIN_ERR_NOT_BOOLEAN_IF : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_OVERFLOW**
+
+```grain
+_GRAIN_ERR_OVERFLOW : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_GET_NOT_TUP**
+
+```grain
+_GRAIN_ERR_GET_NOT_TUP : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_GET_ITEM_IDX_NOT_NUMBER**
+
+```grain
+_GRAIN_ERR_GET_ITEM_IDX_NOT_NUMBER : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_GET_ITEM_IDX_TOO_SMALL**
+
+```grain
+_GRAIN_ERR_GET_ITEM_IDX_TOO_SMALL : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_GET_ITEM_IDX_TOO_LARGE**
+
+```grain
+_GRAIN_ERR_GET_ITEM_IDX_TOO_LARGE : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_CALLED_NON_FUNCTION**
+
+```grain
+_GRAIN_ERR_CALLED_NON_FUNCTION : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_ARITY_MISMATCH**
+
+```grain
+_GRAIN_ERR_ARITY_MISMATCH : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_OUT_OF_MEMORY**
+
+```grain
+_GRAIN_ERR_OUT_OF_MEMORY : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_SET_NOT_TUP**
+
+```grain
+_GRAIN_ERR_SET_NOT_TUP : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_SET_ITEM_IDX_NOT_NUMBER**
+
+```grain
+_GRAIN_ERR_SET_ITEM_IDX_NOT_NUMBER : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_SET_ITEM_IDX_TOO_SMALL**
+
+```grain
+_GRAIN_ERR_SET_ITEM_IDX_TOO_SMALL : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_SET_ITEM_IDX_TOO_LARGE**
+
+```grain
+_GRAIN_ERR_SET_ITEM_IDX_TOO_LARGE : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_DIVISION_BY_ZERO**
+
+```grain
+_GRAIN_ERR_DIVISION_BY_ZERO : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_MODULO_BY_ZERO**
+
+```grain
+_GRAIN_ERR_MODULO_BY_ZERO : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_ARRAY_INDEX_OUT_OF_BOUNDS**
+
+```grain
+_GRAIN_ERR_ARRAY_INDEX_OUT_OF_BOUNDS : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_INVALID_ARGUMENT**
+
+```grain
+_GRAIN_ERR_INVALID_ARGUMENT : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_ASSERTION_ERROR**
+
+```grain
+_GRAIN_ERR_ASSERTION_ERROR : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_FAILURE**
+
+```grain
+_GRAIN_ERR_FAILURE : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_SYSTEM**
+
+```grain
+_GRAIN_ERR_SYSTEM : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_NOT_INTLIKE**
+
+```grain
+_GRAIN_ERR_NOT_INTLIKE : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_NOT_RATIONAL**
+
+```grain
+_GRAIN_ERR_NOT_RATIONAL : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_MALFORMED_UTF8**
+
+```grain
+_GRAIN_ERR_MALFORMED_UTF8 : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_NOT_ADT_VAL_GENERIC**
+
+```grain
+_GRAIN_ERR_NOT_ADT_VAL_GENERIC : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_NOT_STRING_GENERIC**
+
+```grain
+_GRAIN_ERR_NOT_STRING_GENERIC : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_NOT_BOOLEAN_GENERIC**
+
+```grain
+_GRAIN_ERR_NOT_BOOLEAN_GENERIC : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_NOT_TUPLE_GENERIC**
+
+```grain
+_GRAIN_ERR_NOT_TUPLE_GENERIC : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_NOT_LAMBDA_GENERIC**
+
+```grain
+_GRAIN_ERR_NOT_LAMBDA_GENERIC : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_BAD_INPUT**
+
+```grain
+_GRAIN_ERR_BAD_INPUT : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_NOT_NONNEG**
+
+```grain
+_GRAIN_ERR_NOT_NONNEG : WasmI32
+```
+
+### Errors.**_GRAIN_ERR_NOT_NUMBER_GENERIC**
+
+```grain
+_GRAIN_ERR_NOT_NUMBER_GENERIC : WasmI32
+```
+

package/runtime/unsafe/memory.gr

@@ -1,13 +1,20 @@
 /* grainc-flags --compilation-mode=runtime */
 
-import { malloc, free, incRef, decRef, utoa32Buffered, decimalCount32 } from "runtime/gc"
+import {
+  malloc,
+  free,
+  incRef,
+  decRef,
+  utoa32Buffered,
+  decimalCount32,
+} from "runtime/gc"
 import WasmI32, {
   add as (+),
   sub as (-),
   shl as (<<),
   eq as (==),
   ne as (!=),
-  ltU as (<)
+  ltU as (<),
 } from "runtime/unsafe/wasmi32"
 
 export malloc
@@ -48,4 +55,8 @@ export let fill = (dest, c, n) => {
   }
 }
 
-export primitive compare: (WasmI32, WasmI32, WasmI32) -> WasmI32 = "@wasm.memory_compare"
+export primitive compare: (
+  WasmI32,
+  WasmI32,
+  WasmI32,
+) -> WasmI32 = "@wasm.memory_compare"

package/runtime/unsafe/memory.md

@@ -0,0 +1,54 @@
+### Memory.**malloc**
+
+```grain
+malloc : WasmI32 -> WasmI32
+```
+
+### Memory.**free**
+
+```grain
+free : WasmI32 -> Void
+```
+
+### Memory.**incRef**
+
+```grain
+incRef : WasmI32 -> WasmI32
+```
+
+### Memory.**decRef**
+
+```grain
+decRef : WasmI32 -> WasmI32
+```
+
+### Memory.**utoa32Buffered**
+
+```grain
+utoa32Buffered : Box<(WasmI32, WasmI32, WasmI32) -> Void>
+```
+
+### Memory.**decimalCount32**
+
+```grain
+decimalCount32 : Box<WasmI32 -> WasmI32>
+```
+
+### Memory.**copy**
+
+```grain
+copy : (WasmI32, WasmI32, WasmI32) -> Void
+```
+
+### Memory.**fill**
+
+```grain
+fill : (WasmI32, WasmI32, WasmI32) -> Void
+```
+
+### Memory.**compare**
+
+```grain
+compare : (WasmI32, WasmI32, WasmI32) -> WasmI32
+```
+