@grain/stdlib 0.4.4 → 0.4.5

package/runtime/equal.gr

@@ -10,15 +10,15 @@ 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"
 
@@ -45,7 +45,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 +77,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 +98,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 +107,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 +121,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 +135,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
             }
@@ -153,8 +169,8 @@ let rec heapEqualHelp = (heapTag, xptr, yptr) => {
         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)
+      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 => {
@@ -170,7 +186,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 +203,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)) {

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/gc.gr

@@ -25,18 +25,23 @@ import WasmI32, {
   sub as (-),
   mul as (*),
   and as (&),
-  eq as (==)
+  eq as (==),
 } from "runtime/unsafe/wasmi32"
 
 // Using foreigns directly here to avoid cyclic dependency
-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"
 
-primitive (&&) : (Bool, Bool) -> Bool = "@and"
-primitive (||) : (Bool, Bool) -> Bool = "@or"
-primitive throw : Exception -> a = "@throw"
-primitive ignore : a -> Void = "@ignore"
-primitive box : a -> Box<a> = "@box"
-primitive unbox : Box<a> -> a = "@unbox"
+primitive (&&): (Bool, Bool) -> Bool = "@and"
+primitive (||): (Bool, Bool) -> Bool = "@or"
+primitive throw: Exception -> a = "@throw"
+primitive ignore: a -> Void = "@ignore"
+primitive box: a -> Box<a> = "@box"
+primitive unbox: Box<a> -> a = "@unbox"
 
 exception DecRefError
 
@@ -154,7 +159,10 @@ export let free = (userPtr: WasmI32) => {
 }
 
 export let incRef = (userPtr: WasmI32) => {
-  if (WasmI32.eqz(userPtr & Tags._GRAIN_GENERIC_TAG_MASK) && WasmI32.ne(userPtr, 0n)) {
+  if (
+    WasmI32.eqz(userPtr & Tags._GRAIN_GENERIC_TAG_MASK) &&
+    WasmI32.ne(userPtr, 0n)
+  ) {
     // if (_DEBUG) {
     //   logIncRef(userPtr, getRefCount(userPtr))
     //   void;
@@ -165,7 +173,10 @@ export let incRef = (userPtr: WasmI32) => {
 }
 
 let rec decRef = (userPtr: WasmI32, ignoreZeros: Bool) => {
-  if (WasmI32.eqz(userPtr & Tags._GRAIN_GENERIC_TAG_MASK) && WasmI32.ne(userPtr, 0n)) {
+  if (
+    WasmI32.eqz(userPtr & Tags._GRAIN_GENERIC_TAG_MASK) &&
+    WasmI32.ne(userPtr, 0n)
+  ) {
     let refCount = getRefCount(userPtr)
     // if (_DEBUG) {
     //   logDecRef(userPtr, refCount, ignoreZeros)
@@ -197,40 +208,42 @@ let rec decRef = (userPtr: WasmI32, ignoreZeros: Bool) => {
     t when t == Tags._GRAIN_ADT_HEAP_TAG => {
       let arity = WasmI32.load(userPtr, 16n)
       let maxOffset = arity * 4n
-      for (let mut i = 0n; WasmI32.ltU(i, maxOffset); i = i + 4n) {
+      for (let mut i = 0n; WasmI32.ltU(i, maxOffset); i += 4n) {
         ignore(decRef(WasmI32.load(userPtr + i, 20n), false))
       }
     },
     t when t == Tags._GRAIN_RECORD_HEAP_TAG => {
       let arity = WasmI32.load(userPtr, 12n)
       let maxOffset = arity * 4n
-      for (let mut i = 0n; WasmI32.ltU(i, maxOffset); i = i + 4n) {
+      for (let mut i = 0n; WasmI32.ltU(i, maxOffset); i += 4n) {
         ignore(decRef(WasmI32.load(userPtr + i, 16n), false))
       }
     },
-    t when t == Tags._GRAIN_ARRAY_HEAP_TAG || t == Tags._GRAIN_TUPLE_HEAP_TAG => {
+    t when (
+      t == Tags._GRAIN_ARRAY_HEAP_TAG || t == Tags._GRAIN_TUPLE_HEAP_TAG
+    ) => {
       let arity = WasmI32.load(userPtr, 4n)
       let maxOffset = arity * 4n
-      for (let mut i = 0n; WasmI32.ltU(i, maxOffset); i = i + 4n) {
+      for (let mut i = 0n; WasmI32.ltU(i, maxOffset); i += 4n) {
         ignore(decRef(WasmI32.load(userPtr + i, 8n), false))
       }
     },
     t when t == Tags._GRAIN_LAMBDA_HEAP_TAG => {
       let arity = WasmI32.load(userPtr, 12n)
       let maxOffset = arity * 4n
-      for (let mut i = 0n; WasmI32.ltU(i, maxOffset); i = i + 4n) {
+      for (let mut i = 0n; WasmI32.ltU(i, maxOffset); i += 4n) {
         ignore(decRef(WasmI32.load(userPtr + i, 16n), false))
       }
     },
     _ => {
       // No travelsal necessary for other tags
       void
-    }
+    },
   }
 }
 
-export let decRefIgnoreZeros = (userPtr) => decRef(userPtr, true)
-export let decRef = (userPtr) => decRef(userPtr, false)
+export let decRefIgnoreZeros = userPtr => decRef(userPtr, true)
+export let decRef = userPtr => decRef(userPtr, false)
 
 // For debugging:
 

package/runtime/malloc.gr

@@ -17,18 +17,18 @@ import WasmI32, {
   shl as (<<),
   shrU as (>>),
   eq as (==),
-  ne as (!=)
+  ne as (!=),
 } from "runtime/unsafe/wasmi32"
 import Exception from "runtime/exception"
 
 primitive memorySize: () -> WasmI32 = "@wasm.memory_size"
-primitive memoryGrow: (WasmI32) -> WasmI32 = "@wasm.memory_grow"
+primitive memoryGrow: WasmI32 -> WasmI32 = "@wasm.memory_grow"
 
-primitive (!) : Bool -> Bool = "@not"
-primitive (&&) : (Bool, Bool) -> Bool = "@and"
-primitive (||) : (Bool, Bool) -> Bool = "@or"
+primitive (!): Bool -> Bool = "@not"
+primitive (&&): (Bool, Bool) -> Bool = "@and"
+primitive (||): (Bool, Bool) -> Bool = "@or"
 
-primitive throw : Exception -> a = "@throw"
+primitive throw: Exception -> a = "@throw"
 
 /* UNDERSTANDING THE STRUCTURE OF THE FREE LIST
  * The original K&R definition for the free list entry type was the following:
@@ -130,7 +130,7 @@ let growHeap = (nbytes: WasmI32) => {
       // so we need to request more anyway.
       reqSize = nbytes - heapSize
       reqSize = reqSize >> 16n
-      reqSize = reqSize + 1n
+      reqSize += 1n
       reqResult = memoryGrow(reqSize)
       if (reqResult == -1n) {
         -1n
@@ -147,7 +147,7 @@ let growHeap = (nbytes: WasmI32) => {
 
     reqSize = nbytes
     reqSize = reqSize >> 16n
-    reqSize = reqSize + 1n
+    reqSize += 1n
 
     reqResult = memoryGrow(reqSize)
     if (reqResult == -1n) {
@@ -174,7 +174,10 @@ export let free = (ap: WasmI32) => {
     // Find the location to insert this block into the free list
     while (true) {
       let nextp = getNext(p)
-      if ( ((blockPtr > p) && (blockPtr < nextp)) || ((p >= nextp) && ((blockPtr > p) || (blockPtr < nextp))) ) {
+      if (
+        blockPtr > p && blockPtr < nextp ||
+        p >= nextp && (blockPtr > p || blockPtr < nextp)
+      ) {
         break
       }
       p = nextp
@@ -255,7 +258,12 @@ export let malloc = (nb: WasmI32) => {
   let mut ret = -1n
 
   // Search the freelist for any blocks large enough.
-  for (let mut p = getNext(prevp); ; {prevp = p; p = getNext(p)}) {
+  for (
+    let mut p = getNext(prevp); ; {
+      prevp = p
+      p = getNext(p)
+    }
+  ) {
     let size = getSize(p)
     if (size >= nbytes) {
       // If this block is big enough, allocate from it.
@@ -266,7 +274,7 @@ export let malloc = (nb: WasmI32) => {
         // Shrink it as needed
         let newSize = size - nbytes
         setSize(p, newSize)
-        p = p + newSize
+        p += newSize
         setSize(p, nbytes)
       }
       // Update the pointer to the free list.