@grain/stdlib 0.4.4 → 0.5.0

package/runtime/dataStructures.md

@@ -0,0 +1,391 @@
+### DataStructures.**allocateArray**
+
+```grain
+allocateArray : WasmI32 -> WasmI32
+```
+
+Allocates a new Grain array.
+
+Parameters:
+
+|param|type|description|
+|-----|----|-----------|
+|`numElts`|`WasmI32`|The number of elements to be contained in this array|
+
+Returns:
+
+|type|description|
+|----|-----------|
+|`WasmI32`|The pointer to the array|
+
+### DataStructures.**allocateTuple**
+
+```grain
+allocateTuple : WasmI32 -> WasmI32
+```
+
+Allocates a new Grain tuple.
+
+Parameters:
+
+|param|type|description|
+|-----|----|-----------|
+|`numElts`|`WasmI32`|The number of elements to be contained in this tuple|
+
+Returns:
+
+|type|description|
+|----|-----------|
+|`WasmI32`|The pointer to the tuple|
+
+### DataStructures.**allocateBytes**
+
+```grain
+allocateBytes : WasmI32 -> WasmI32
+```
+
+Allocates a new Grain bytes.
+
+Parameters:
+
+|param|type|description|
+|-----|----|-----------|
+|`size`|`WasmI32`|The number of bytes to be contained in this buffer|
+
+Returns:
+
+|type|description|
+|----|-----------|
+|`WasmI32`|The pointer to the bytes|
+
+### DataStructures.**allocateString**
+
+```grain
+allocateString : WasmI32 -> WasmI32
+```
+
+Allocates a new Grain string.
+
+Parameters:
+
+|param|type|description|
+|-----|----|-----------|
+|`size`|`WasmI32`|The size (in bytes) of the string to allocate|
+
+Returns:
+
+|type|description|
+|----|-----------|
+|`WasmI32`|The pointer to the string|
+
+### DataStructures.**allocateInt32**
+
+```grain
+allocateInt32 : () -> WasmI32
+```
+
+Allocates a new Int32.
+
+Returns:
+
+|type|description|
+|----|-----------|
+|`WasmI32`|The pointer to the empty Int32|
+
+### DataStructures.**newInt32**
+
+```grain
+newInt32 : WasmI32 -> WasmI32
+```
+
+Allocates a new Int32 with a prepopulated value
+
+Parameters:
+
+|param|type|description|
+|-----|----|-----------|
+|`value`|`WasmI32`|The value to store|
+
+Returns:
+
+|type|description|
+|----|-----------|
+|`WasmI32`|The pointer to the Int32|
+
+### DataStructures.**allocateInt64**
+
+```grain
+allocateInt64 : () -> WasmI32
+```
+
+Allocates a new Int64.
+
+Returns:
+
+|type|description|
+|----|-----------|
+|`WasmI32`|The pointer to the empty Int64|
+
+### DataStructures.**newInt64**
+
+```grain
+newInt64 : WasmI64 -> WasmI32
+```
+
+Allocates a new Int64 with a prepopulated value
+
+Parameters:
+
+|param|type|description|
+|-----|----|-----------|
+|`value`|`WasmI64`|The value to store|
+
+Returns:
+
+|type|description|
+|----|-----------|
+|`WasmI32`|The pointer to the Int64|
+
+### DataStructures.**allocateFloat32**
+
+```grain
+allocateFloat32 : () -> WasmI32
+```
+
+Allocates a new Float32.
+
+Returns:
+
+|type|description|
+|----|-----------|
+|`WasmI32`|The pointer to the empty Float32|
+
+### DataStructures.**newFloat32**
+
+```grain
+newFloat32 : WasmF32 -> WasmI32
+```
+
+Allocates a new Float32 with a prepopulated value
+
+Parameters:
+
+|param|type|description|
+|-----|----|-----------|
+|`value`|`WasmF32`|The value to store|
+
+Returns:
+
+|type|description|
+|----|-----------|
+|`WasmI32`|the pointer to the Float32|
+
+### DataStructures.**allocateFloat64**
+
+```grain
+allocateFloat64 : () -> WasmI32
+```
+
+Allocates a new Float64.
+
+Returns:
+
+|type|description|
+|----|-----------|
+|`WasmI32`|The pointer to the empty Float64|
+
+### DataStructures.**newFloat64**
+
+```grain
+newFloat64 : WasmF64 -> WasmI32
+```
+
+Allocates a new Float64 with a prepopulated value
+
+Parameters:
+
+|param|type|description|
+|-----|----|-----------|
+|`value`|`WasmF64`|The value to store|
+
+Returns:
+
+|type|description|
+|----|-----------|
+|`WasmI32`|The pointer to the Float64|
+
+### DataStructures.**allocateRational**
+
+```grain
+allocateRational : () -> WasmI32
+```
+
+Allocates a new Rational.
+
+Returns:
+
+|type|description|
+|----|-----------|
+|`WasmI32`|The pointer to the empty Rational|
+
+### DataStructures.**newRational**
+
+```grain
+newRational : (WasmI32, WasmI32) -> WasmI32
+```
+
+Allocates a new Rational with a prepopulated value
+
+Parameters:
+
+|param|type|description|
+|-----|----|-----------|
+|`value`|`WasmI32`|The numerator value to store|
+|`value`|`WasmI32`|The denominator value to store|
+
+Returns:
+
+|type|description|
+|----|-----------|
+|`WasmI32`|The pointer to the Rational|
+
+### DataStructures.**loadAdtVariant**
+
+```grain
+loadAdtVariant : WasmI32 -> WasmI32
+```
+
+Load the (tagged) variant of an ADT.
+
+Parameters:
+
+|param|type|description|
+|-----|----|-----------|
+|`ptr`|`WasmI32`|Untagged pointer to the ADT|
+
+Returns:
+
+|type|description|
+|----|-----------|
+|`WasmI32`|The (tagged) ADT variant id|
+
+### DataStructures.**stringSize**
+
+```grain
+stringSize : WasmI32 -> WasmI32
+```
+
+Load an untagged string's size.
+
+Parameters:
+
+|param|type|description|
+|-----|----|-----------|
+|`ptr`|`WasmI32`|Untagged pointer to the string|
+
+Returns:
+
+|type|description|
+|----|-----------|
+|`WasmI32`|The string size (in bytes)|
+
+### DataStructures.**bytesSize**
+
+```grain
+bytesSize : WasmI32 -> WasmI32
+```
+
+Load an untagged Bytes' size.
+
+Parameters:
+
+|param|type|description|
+|-----|----|-----------|
+|`ptr`|`WasmI32`|Untagged pointer to the Bytes|
+
+Returns:
+
+|type|description|
+|----|-----------|
+|`WasmI32`|The Bytes size (in bytes)|
+
+### DataStructures.**tagSimpleNumber**
+
+```grain
+tagSimpleNumber : WasmI32 -> Number
+```
+
+Tag a simple number.
+
+Parameters:
+
+|param|type|description|
+|-----|----|-----------|
+|`num`|`WasmI32`|The number to tag|
+
+Returns:
+
+|type|description|
+|----|-----------|
+|`Number`|The tagged number|
+
+### DataStructures.**untagSimpleNumber**
+
+```grain
+untagSimpleNumber : Number -> WasmI32
+```
+
+Untag a simple number.
+
+Parameters:
+
+|param|type|description|
+|-----|----|-----------|
+|`num`|`Number`|The number to untag|
+
+Returns:
+
+|type|description|
+|----|-----------|
+|`WasmI32`|The untagged number|
+
+### DataStructures.**tagChar**
+
+```grain
+tagChar : WasmI32 -> Char
+```
+
+Tag a char.
+
+Parameters:
+
+|param|type|description|
+|-----|----|-----------|
+|`num`|`WasmI32`|The usv to tag|
+
+Returns:
+
+|type|description|
+|----|-----------|
+|`Char`|The tagged char|
+
+### DataStructures.**untagChar**
+
+```grain
+untagChar : Char -> WasmI32
+```
+
+Untag a char.
+
+Parameters:
+
+|param|type|description|
+|-----|----|-----------|
+|`num`|`Char`|The char to untag|
+
+Returns:
+
+|type|description|
+|----|-----------|
+|`WasmI32`|The untagged usv|
+

package/runtime/debug.gr

@@ -1,3 +1,2 @@
 /* grainc-flags --compilation-mode=runtime */
 export foreign wasm debug: a -> Void from "console"
-

package/runtime/debug.md

@@ -0,0 +1,6 @@
+### Debug.**debug**
+
+```grain
+debug : a -> Void
+```
+

package/runtime/equal.gr

@@ -1,4 +1,4 @@
-/* grainc-flags --compilation-mode=runtime */
+/* grainc-flags --no-pervasives */
 
 import WasmI32, {
   eq as (==),
@@ -10,20 +10,21 @@ import WasmI32, {
   mul as (*),
   ltS as (<),
   remS as (%),
-  shl as (<<)
+  shl as (<<),
 } from "runtime/unsafe/wasmi32"
 import WasmI64 from "runtime/unsafe/wasmi64"
 import Tags from "runtime/unsafe/tags"
-import Memory from "runtime/unsafe/memory"
 
-primitive (!) : Bool -> Bool = "@not"
-primitive (||) : (Bool, Bool) -> Bool = "@or"
-primitive (&&) : (Bool, Bool) -> Bool = "@and"
+primitive (!): Bool -> Bool = "@not"
+primitive (||): (Bool, Bool) -> Bool = "@or"
+primitive (&&): (Bool, Bool) -> Bool = "@and"
 
 import { isNumber, numberEqual } from "runtime/numbers"
 
+@unsafe
 let cycleMarker = 0x80000000n
 
+@unsafe
 let rec heapEqualHelp = (heapTag, xptr, yptr) => {
   match (heapTag) {
     t when t == Tags._GRAIN_ADT_HEAP_TAG => {
@@ -45,7 +46,12 @@ let rec heapEqualHelp = (heapTag, xptr, yptr) => {
 
           let bytes = xarity * 4n
           for (let mut i = 0n; i < bytes; i += 4n) {
-            if (!equalHelp(WasmI32.load(xptr + i, 20n), WasmI32.load(yptr + i, 20n))) {
+            if (
+              !equalHelp(
+                WasmI32.load(xptr + i, 20n),
+                WasmI32.load(yptr + i, 20n)
+              )
+            ) {
               result = false
               break
             }
@@ -72,7 +78,9 @@ let rec heapEqualHelp = (heapTag, xptr, yptr) => {
 
         let bytes = xlength * 4n
         for (let mut i = 0n; i < bytes; i += 4n) {
-          if (!equalHelp(WasmI32.load(xptr + i, 16n), WasmI32.load(yptr + i, 16n))) {
+          if (
+            !equalHelp(WasmI32.load(xptr + i, 16n), WasmI32.load(yptr + i, 16n))
+          ) {
             result = false
             break
           }
@@ -91,7 +99,7 @@ let rec heapEqualHelp = (heapTag, xptr, yptr) => {
       if (xlength != ylength) {
         false
       } else if ((xlength & cycleMarker) == cycleMarker) {
-      // Cycle check
+        // Cycle check
         true
       } else {
         WasmI32.store(xptr, xlength ^ cycleMarker, 4n)
@@ -100,7 +108,9 @@ let rec heapEqualHelp = (heapTag, xptr, yptr) => {
         let mut result = true
         let bytes = xlength * 4n
         for (let mut i = 0n; i < bytes; i += 4n) {
-          if (!equalHelp(WasmI32.load(xptr + i, 8n), WasmI32.load(yptr + i, 8n))) {
+          if (
+            !equalHelp(WasmI32.load(xptr + i, 8n), WasmI32.load(yptr + i, 8n))
+          ) {
             result = false
             break
           }
@@ -112,7 +122,9 @@ let rec heapEqualHelp = (heapTag, xptr, yptr) => {
         result
       }
     },
-    t when t == Tags._GRAIN_STRING_HEAP_TAG || t == Tags._GRAIN_BYTES_HEAP_TAG => {
+    t when (
+      t == Tags._GRAIN_STRING_HEAP_TAG || t == Tags._GRAIN_BYTES_HEAP_TAG
+    ) => {
       let xlength = WasmI32.load(xptr, 4n)
       let ylength = WasmI32.load(yptr, 4n)
 
@@ -124,14 +136,19 @@ let rec heapEqualHelp = (heapTag, xptr, yptr) => {
         let first = xlength - extra
         let mut result = true
         for (let mut i = 0n; i < first; i += 8n) {
-          if (WasmI64.ne(WasmI64.load(xptr + i, 8n), WasmI64.load(yptr + i, 8n))) {
+          if (
+            WasmI64.ne(WasmI64.load(xptr + i, 8n), WasmI64.load(yptr + i, 8n))
+          ) {
             result = false
             break
           }
         }
         if (result) {
           for (let mut i = 0n; i < extra; i += 1n) {
-            if (WasmI32.load8U(xptr + first + i, 8n) != WasmI32.load8U(yptr + first + i, 8n)) {
+            if (
+              WasmI32.load8U(xptr + first + i, 8n) !=
+              WasmI32.load8U(yptr + first + i, 8n)
+            ) {
               result = false
               break
             }
@@ -141,22 +158,6 @@ let rec heapEqualHelp = (heapTag, xptr, yptr) => {
         result
       }
     },
-    t when t == Tags._GRAIN_CHAR_HEAP_TAG => {
-      let byte = WasmI32.load8U(xptr, 4n)
-      let n = if ((byte & 0x80n) == 0x00n) {
-        1n
-      } else if ((byte & 0xF0n) == 0xF0n) {
-        4n
-      } else if ((byte & 0xE0n) == 0xE0n) {
-        3n
-      } else {
-        2n
-      }
-      // WebAssembly is little-endian, so bytes are in reverse order
-      let x = WasmI32.load(xptr, 4n) << ((4n - n) * 8n)
-      let y = WasmI32.load(yptr, 4n) << ((4n - n) * 8n)
-      x == y
-    },
     t when t == Tags._GRAIN_TUPLE_HEAP_TAG => {
       let xsize = WasmI32.load(xptr, 4n)
       let ysize = WasmI32.load(yptr, 4n)
@@ -170,7 +171,9 @@ let rec heapEqualHelp = (heapTag, xptr, yptr) => {
         let mut result = true
         let bytes = xsize * 4n
         for (let mut i = 0n; i < bytes; i += 4n) {
-          if (!equalHelp(WasmI32.load(xptr + i, 8n), WasmI32.load(yptr + i, 8n))) {
+          if (
+            !equalHelp(WasmI32.load(xptr + i, 8n), WasmI32.load(yptr + i, 8n))
+          ) {
             result = false
             break
           }
@@ -185,10 +188,13 @@ let rec heapEqualHelp = (heapTag, xptr, yptr) => {
     _ => {
       // No other implementation
       xptr == yptr
-    }
+    },
   }
 }, equalHelp = (x, y) => {
-  if (((x & Tags._GRAIN_GENERIC_TAG_MASK) != 0n) && ((y & Tags._GRAIN_GENERIC_TAG_MASK) != 0n)) {
+  if (
+    (x & Tags._GRAIN_GENERIC_TAG_MASK) != 0n &&
+    (y & Tags._GRAIN_GENERIC_TAG_MASK) != 0n
+  ) {
     // Short circuit for non-pointer values
     x == y
   } else if (isNumber(x)) {
@@ -201,10 +207,7 @@ let rec heapEqualHelp = (heapTag, xptr, yptr) => {
   }
 }
 
+@unsafe
 export let rec equal = (x: a, y: a) => {
-  let ret = equalHelp(WasmI32.fromGrain(x), WasmI32.fromGrain(y))
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(y))
-  Memory.decRef(WasmI32.fromGrain(equal))
-  ret
+  equalHelp(WasmI32.fromGrain(x), WasmI32.fromGrain(y))
 }

package/runtime/equal.md

@@ -0,0 +1,6 @@
+### Equal.**equal**
+
+```grain
+equal : (a, a) -> Bool
+```
+

package/runtime/exception.gr

@@ -1,13 +1,18 @@
 /* grainc-flags --compilation-mode=runtime */
 
-import WasmI32, {
-  eq as (==),
-  add as (+)
-} from "runtime/unsafe/wasmi32"
+import WasmI32, { eq as (==), add as (+) } from "runtime/unsafe/wasmi32"
 
-import foreign wasm fd_write: (WasmI32, WasmI32, WasmI32, WasmI32) -> WasmI32 from "wasi_snapshot_preview1"
+import foreign wasm fd_write: (
+  WasmI32,
+  WasmI32,
+  WasmI32,
+  WasmI32,
+) -> WasmI32 from "wasi_snapshot_preview1"
 
-enum Option<a> { Some(a), None }
+enum Option<a> {
+  Some(a),
+  None,
+}
 
 export let mut printers = 0n
 
@@ -15,11 +20,14 @@ export let mut printers = 0n
 // no GC operations. As such, they should only be called by this module and/or
 // modules that understand these restrictions, namely Pervasives.
 
-export let dangerouslyRegisterBasePrinter = (f) => {
+export let dangerouslyRegisterBasePrinter = f => {
   let mut current = printers
   while (true) {
     // There will be at least one printer registered by the time this is called
-    let (_, next) = WasmI32.toGrain(current) : (Exception -> Option<String>, WasmI32)
+    let (_, next) = WasmI32.toGrain(current): (
+      Exception -> Option<String>,
+      WasmI32
+    )
     if (next == 0n) {
       // Using a tuple in runtime mode is typically disallowed as there is no way
       // to reclaim the memory, but this function is only called once
@@ -34,7 +42,7 @@ export let dangerouslyRegisterBasePrinter = (f) => {
   void
 }
 
-export let dangerouslyRegisterPrinter = (f) => {
+export let dangerouslyRegisterPrinter = f => {
   printers = WasmI32.fromGrain((f, printers))
   // We don't decRef the closure or arguments here to avoid a cyclic dep. on Memory.
   // This is fine, as this function is only called seldomly.
@@ -50,13 +58,16 @@ let exceptionToString = (e: Exception) => {
     if (current == 0n) {
       break
     }
-    let (printer, next) = WasmI32.toGrain(current) : (Exception -> Option<String>, WasmI32)
+    let (printer, next) = WasmI32.toGrain(current): (
+      Exception -> Option<String>,
+      WasmI32
+    )
     match (printer(e)) {
       Some(str) => {
         result = str
         break
       },
-      None => void
+      None => void,
     }
     current = next
   }
@@ -100,19 +111,21 @@ export exception AssertionError(String)
 export exception InvalidArgument(String)
 export exception OutOfMemory
 
-let runtimeErrorPrinter = (e) => {
+let runtimeErrorPrinter = e => {
   match (e) {
     IndexOutOfBounds => Some("IndexOutOfBounds: Index out of bounds"),
     DivisionByZero => Some("DivisionByZero: Division by zero"),
     ModuloByZero => Some("ModuloByZero: Modulo by zero"),
     Overflow => Some("Overflow: Number overflow"),
-    NumberNotIntlike => Some("NumberNotIntlike: Can't coerce number to integer"),
-    NumberNotRational => Some("NumberNotRational: Can't coerce number to rational"),
+    NumberNotIntlike =>
+      Some("NumberNotIntlike: Can't coerce number to integer"),
+    NumberNotRational =>
+      Some("NumberNotRational: Can't coerce number to rational"),
     MatchFailure => Some("MatchFailure: No matching pattern"),
     AssertionError(s) => Some(s),
     OutOfMemory => Some("OutOfMemory: Maximum memory size exceeded"),
     InvalidArgument(msg) => Some(msg),
-    _ => None
+    _ => None,
   }
 }
 

package/runtime/exception.md

@@ -0,0 +1,30 @@
+### Exception.**Option**
+
+```grain
+type Option<a>
+```
+
+### Exception.**printers**
+
+```grain
+printers : WasmI32
+```
+
+### Exception.**dangerouslyRegisterBasePrinter**
+
+```grain
+dangerouslyRegisterBasePrinter : a -> Void
+```
+
+### Exception.**dangerouslyRegisterPrinter**
+
+```grain
+dangerouslyRegisterPrinter : a -> Void
+```
+
+### Exception.**printException**
+
+```grain
+printException : Exception -> Void
+```
+