@grain/stdlib 0.4.4 → 0.4.5

package/runtime/string.gr

@@ -14,7 +14,7 @@ import WasmI32, {
   geS as (>=),
   gtS as (>),
   leS as (<=),
-  ltS as (<)
+  ltS as (<),
 } from "runtime/unsafe/wasmi32"
 import WasmI64 from "runtime/unsafe/wasmi64"
 import WasmF32 from "runtime/unsafe/wasmf32"
@@ -25,13 +25,21 @@ import NumberUtils from "runtime/numberUtils"
 
 import { allocateString, allocateArray } from "runtime/dataStructures"
 
-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 = "@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"
 
-enum StringList { SLEmpty, SLCons(String, StringList) }
+enum StringList {
+  SLEmpty,
+  SLCons(String, StringList),
+}
 
 @disableGC
 let slConsDisableGc = (a, b) => {
@@ -42,14 +50,14 @@ let slConsDisableGc = (a, b) => {
 }
 
 @disableGC
-let mut _RUNTIME_TYPE_METADATA_PTR = 0x01n;
+let mut _RUNTIME_TYPE_METADATA_PTR = 0x01n
 
 @disableGC
 let initPtr = () => {
   // hack to avoid incRef on this pointer
   _RUNTIME_TYPE_METADATA_PTR = 0x408n
 }
-initPtr();
+initPtr()
 
 @disableGC
 let findTypeMetadata = (moduleId, typeId) => {
@@ -82,7 +90,7 @@ let findTypeMetadata = (moduleId, typeId) => {
 }
 
 @disableGC
-let getVariantName = (variant) => {
+let getVariantName = variant => {
   let moduleId = WasmI32.load(variant, 4n) >> 1n
   let typeId = WasmI32.load(variant, 8n) >> 1n
   let variantId = WasmI32.load(variant, 12n) >> 1n
@@ -113,7 +121,7 @@ let getVariantName = (variant) => {
 }
 
 @disableGC
-let getRecordFieldNames = (record_) => {
+let getRecordFieldNames = record_ => {
   let moduleId = WasmI32.load(record_, 4n) >> 1n
   let typeId = WasmI32.load(record_, 8n) >> 1n
   let arity = WasmI32.load(record_, 12n)
@@ -132,7 +140,7 @@ let getRecordFieldNames = (record_) => {
       let fieldLength = WasmI32.load(fields + fieldOffset, 4n)
       let fieldName = allocateString(fieldLength)
       Memory.copy(fieldName + 8n, fields + fieldOffset + 8n, fieldLength)
-      WasmI32.store(fieldArray + (i * 4n), fieldName, 8n)
+      WasmI32.store(fieldArray + i * 4n, fieldName, 8n)
 
       fieldOffset += WasmI32.load(fields + fieldOffset, 0n)
     }
@@ -144,8 +152,9 @@ let getRecordFieldNames = (record_) => {
 @disableGC
 let rec totalBytes = (acc, list) => {
   match (list) {
-    SLCons(hd, tl) => totalBytes(acc + WasmI32.load(WasmI32.fromGrain(hd), 4n), tl),
-    SLEmpty => acc
+    SLCons(hd, tl) =>
+      totalBytes(acc + WasmI32.load(WasmI32.fromGrain(hd), 4n), tl),
+    SLEmpty => acc,
   }
 }
 
@@ -158,12 +167,12 @@ let rec writeStrings = (buf, list) => {
       Memory.copy(buf, hd + 8n, hdSize)
       writeStrings(buf + hdSize, tl)
     },
-    SLEmpty => void
+    SLEmpty => void,
   }
 }
 
 @disableGC
-let join = (list) => {
+let join = list => {
   let len = totalBytes(0n, list)
   let str = allocateString(len)
   writeStrings(str + 8n, list)
@@ -171,12 +180,12 @@ let join = (list) => {
 }
 
 @disableGC
-let reverse = (list) => {
+let reverse = list => {
   @disableGC
   let rec iter = (list, acc) => {
     match (list) {
       SLEmpty => acc,
-      SLCons(first, rest) => iter(rest, slConsDisableGc(first, acc))
+      SLCons(first, rest) => iter(rest, slConsDisableGc(first, acc)),
     }
   }
   Memory.incRef(WasmI32.fromGrain(SLEmpty))
@@ -240,7 +249,12 @@ let escape = (ptr, isString) => {
   let mut newSize = 2n // extra space for quote characters
   for (let mut i = 0n; i < size; i += 1n) {
     let byte = WasmI32.load8U(ptr + i, startOffset)
-    if (byte >= _SEQ_B && byte <= _SEQ_R /* b, f, n, r, t, v */ || byte == _SEQ_V || byte == _SEQ_SLASH || byte == _SEQ_QUOTE) {
+    if (
+      byte >= _SEQ_B && byte <= _SEQ_R || /* b, f, n, r, t, v */
+      byte == _SEQ_V ||
+      byte == _SEQ_SLASH ||
+      byte == _SEQ_QUOTE
+    ) {
       newSize += 2n
     } else {
       newSize += 1n
@@ -254,7 +268,12 @@ let escape = (ptr, isString) => {
 
   for (let mut i = 0n; i < size; i += 1n) {
     let byte = WasmI32.load8U(ptr + i, startOffset)
-    if (byte >= _SEQ_B && byte <= _SEQ_R /* b, f, n, r, t, v */ || byte == _SEQ_V || byte == _SEQ_SLASH || byte == _SEQ_QUOTE) {
+    if (
+      byte >= _SEQ_B && byte <= _SEQ_R || /* b, f, n, r, t, v */
+      byte == _SEQ_V ||
+      byte == _SEQ_SLASH ||
+      byte == _SEQ_QUOTE
+    ) {
       WasmI32.store8(escapedString + j, _SEQ_SLASH, stringOffset)
       j += 1n
       let seq = match (byte) {
@@ -264,7 +283,7 @@ let escape = (ptr, isString) => {
         r when r == _SEQ_R => 0x72n,
         t when t == _SEQ_T => 0x74n,
         v when v == _SEQ_V => 0x76n,
-        _ => byte
+        _ => byte,
       }
       WasmI32.store8(escapedString + j, seq, stringOffset)
       j += 1n
@@ -390,7 +409,11 @@ let rec heapValueToString = (ptr, extraIndents, toplevel) => {
             Memory.incRef(WasmI32.fromGrain(SLEmpty))
             let mut strings = slConsDisableGc(rparen, SLEmpty)
             for (let mut i = variantArity * 4n - 4n; i >= 0n; i -= 4n) {
-              let tmp = toStringHelp(WasmI32.load(ptr + i, 20n), extraIndents, false)
+              let tmp = toStringHelp(
+                WasmI32.load(ptr + i, 20n),
+                extraIndents,
+                false
+              )
               strings = slConsDisableGc(tmp, strings)
               Memory.decRef(WasmI32.fromGrain(tmp))
               if (i > 0n) {
@@ -399,7 +422,10 @@ let rec heapValueToString = (ptr, extraIndents, toplevel) => {
             }
             Memory.incRef(WasmI32.fromGrain(variantName))
             let lparen = "("
-            strings = slConsDisableGc(variantName, slConsDisableGc(lparen, strings))
+            strings = slConsDisableGc(
+              variantName,
+              slConsDisableGc(lparen, strings)
+            )
             let string = join(strings)
             Memory.decRef(WasmI32.fromGrain(variantName))
             Memory.decRef(WasmI32.fromGrain(lparen))
@@ -418,10 +444,16 @@ let rec heapValueToString = (ptr, extraIndents, toplevel) => {
         "<record value>"
       } else {
         let prevPadAmount = extraIndents * 2n
-        let prevSpacePadding = if (prevPadAmount == 0n) "" else {
+        let prevSpacePadding = if (prevPadAmount == 0n) {
+          ""
+        } else {
           let v = allocateString(prevPadAmount)
-          Memory.fill(v + 8n, 0x20n, prevPadAmount) // create indentation for closing brace
-          WasmI32.toGrain(v) : String
+          Memory.fill(
+            v + 8n,
+            0x20n,
+            prevPadAmount
+          ) // create indentation for closing brace
+          WasmI32.toGrain(v): String
         }
         let padAmount = (extraIndents + 1n) * 2n
         let spacePadding = allocateString(padAmount)
@@ -430,13 +462,26 @@ let rec heapValueToString = (ptr, extraIndents, toplevel) => {
         Memory.incRef(WasmI32.fromGrain(SLEmpty))
         let newline = "\n"
         let rbrace = "}"
-        let mut strings = slConsDisableGc(newline, slConsDisableGc(prevSpacePadding, slConsDisableGc(rbrace, SLEmpty)))
+        let mut strings = slConsDisableGc(
+          newline,
+          slConsDisableGc(prevSpacePadding, slConsDisableGc(rbrace, SLEmpty))
+        )
         let colspace = ": "
         let comlf = ",\n"
-        for (let mut i = recordArity * 4n - 4n; i >= 0n;  i -= 4n) {
+        for (let mut i = recordArity * 4n - 4n; i >= 0n; i -= 4n) {
           let fieldName = WasmI32.toGrain(WasmI32.load(fields + i, 8n)): String
-          let fieldValue = toStringHelp(WasmI32.load(ptr + i, 16n), extraIndents + 1n, false)
-          strings = slConsDisableGc(spacePadding, slConsDisableGc(fieldName, slConsDisableGc(colspace, slConsDisableGc(fieldValue, strings))))
+          let fieldValue = toStringHelp(
+            WasmI32.load(ptr + i, 16n),
+            extraIndents + 1n,
+            false
+          )
+          strings = slConsDisableGc(
+            spacePadding,
+            slConsDisableGc(
+              fieldName,
+              slConsDisableGc(colspace, slConsDisableGc(fieldValue, strings))
+            )
+          )
           Memory.decRef(WasmI32.fromGrain(fieldValue))
           if (i > 0n) {
             strings = slConsDisableGc(comlf, strings)
@@ -497,7 +542,10 @@ let rec heapValueToString = (ptr, extraIndents, toplevel) => {
           let denominator = NumberUtils.itoa32(WasmI32.load(ptr, 12n), 10n)
           Memory.incRef(WasmI32.fromGrain(SLEmpty))
           let slash = "/"
-          let strings = slConsDisableGc(numerator, slConsDisableGc(slash, slConsDisableGc(denominator, SLEmpty)))
+          let strings = slConsDisableGc(
+            numerator,
+            slConsDisableGc(slash, slConsDisableGc(denominator, SLEmpty))
+          )
           let string = join(strings)
           Memory.decRef(WasmI32.fromGrain(strings))
           Memory.decRef(WasmI32.fromGrain(numerator))
@@ -513,7 +561,7 @@ let rec heapValueToString = (ptr, extraIndents, toplevel) => {
         },
         _ => {
           "<unknown boxed number>"
-        }
+        },
       }
     },
     t when t == Tags._GRAIN_TUPLE_HEAP_TAG => {
@@ -534,7 +582,11 @@ let rec heapValueToString = (ptr, extraIndents, toplevel) => {
           void
         }
         for (let mut i = tupleLength * 4n - 4n; i >= 0n; i -= 4n) {
-          let item = toStringHelp(WasmI32.load(ptr + i, 8n), extraIndents, false)
+          let item = toStringHelp(
+            WasmI32.load(ptr + i, 8n),
+            extraIndents,
+            false
+          )
           strings = slConsDisableGc(item, strings)
           Memory.decRef(WasmI32.fromGrain(item))
           if (i > 0n) {
@@ -563,14 +615,21 @@ let rec heapValueToString = (ptr, extraIndents, toplevel) => {
       Memory.incRef(WasmI32.fromGrain(SLEmpty))
       let strings = slConsDisableGc(
         "<unknown heap tag type: 0x",
-        slConsDisableGc(NumberUtils.itoa32(tag, 16n),
-        slConsDisableGc(" | value: 0x",
-        slConsDisableGc(NumberUtils.itoa32(ptr, 16n),
-        slConsDisableGc(">", SLEmpty)))))
+        slConsDisableGc(
+          NumberUtils.itoa32(tag, 16n),
+          slConsDisableGc(
+            " | value: 0x",
+            slConsDisableGc(
+              NumberUtils.itoa32(ptr, 16n),
+              slConsDisableGc(">", SLEmpty)
+            )
+          )
+        )
+      )
       let string = join(strings)
       Memory.decRef(WasmI32.fromGrain(strings))
       string
-    }
+    },
   }
 }, toStringHelp = (grainValue, extraIndents, toplevel) => {
   if ((grainValue & 1n) != 0n) {
@@ -624,7 +683,7 @@ let rec heapValueToString = (ptr, extraIndents, toplevel) => {
 }
 
 @disableGC
-export let rec toString = (value) => {
+export let rec toString = value => {
   let value = WasmI32.fromGrain(value)
   let ret = toStringHelp(value, 0n, true)
   Memory.decRef(value)
@@ -633,7 +692,7 @@ export let rec toString = (value) => {
 }
 
 @disableGC
-export let rec print = (value) => {
+export let rec print = value => {
   // First convert the value to string, if it isn't one already. Calling
   // toString will either return value instance itself if it's already a
   // string, or a new string with the content of value object, which will need

package/runtime/stringUtils.gr

@@ -45,7 +45,11 @@ 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)) {
+  let result = if (
+    WasmI32.eqz(radix & Tags._GRAIN_NUMBER_TAG_MASK) ||
+    radix < WasmI32.fromGrain(2) ||
+    radix > WasmI32.fromGrain(36)
+  ) {
     Memory.incRef(WasmI32.fromGrain(Err))
     Err("Radix must be an integer between 2 and 36")
   } else if (WasmI32.eqz(strLen)) {
@@ -158,7 +162,7 @@ export let rec parseInt = (string: String, radix: Number) => {
       },
       _ => {
         let value = if (negative) value else WasmI64.mul(value, -1N)
-        let number = WasmI32.toGrain(reducedInteger(value)): (Number)
+        let number = WasmI32.toGrain(reducedInteger(value)): Number
         Memory.incRef(WasmI32.fromGrain(Ok))
         Ok(number)
       },

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

@@ -5,7 +5,7 @@ import Memory from "runtime/unsafe/memory"
 // [FIXME] These all leak ATM (grain-lang/grain#791)
 
 @disableGC
-export let printI32 = (val) => {
+export let printI32 = val => {
   Memory.incRef(WasmI32.fromGrain(print))
   Memory.incRef(WasmI32.fromGrain(toString))
   let conv = Conv.toInt32(val)
@@ -23,7 +23,7 @@ export let printI32 = (val) => {
 }
 
 @disableGC
-export let printI64 = (val) => {
+export let printI64 = val => {
   Memory.incRef(WasmI32.fromGrain(print))
   Memory.incRef(WasmI32.fromGrain(toString))
   let conv = Conv.toInt64(val)
@@ -41,7 +41,7 @@ export let printI64 = (val) => {
 }
 
 @disableGC
-export let printF32 = (val) => {
+export let printF32 = val => {
   Memory.incRef(WasmI32.fromGrain(print))
   Memory.incRef(WasmI32.fromGrain(toString))
   let conv = Conv.toFloat32(val)
@@ -59,7 +59,7 @@ export let printF32 = (val) => {
 }
 
 @disableGC
-export let printF64 = (val) => {
+export let printF64 = val => {
   Memory.incRef(WasmI32.fromGrain(print))
   Memory.incRef(WasmI32.fromGrain(toString))
   let conv = Conv.toFloat64(val)

package/runtime/unsafe/tags.gr

@@ -1,7 +1,7 @@
 /* grainc-flags --compilation-mode=runtime */
 
-export let _GRAIN_NUMBER_TAG_TYPE       = 0b0001n
-export let _GRAIN_CONST_TAG_TYPE        = 0b0110n
+export let _GRAIN_NUMBER_TAG_TYPE = 0b0001n
+export let _GRAIN_CONST_TAG_TYPE = 0b0110n
 export let _GRAIN_GENERIC_HEAP_TAG_TYPE = 0b0000n
 
 export let _GRAIN_NUMBER_TAG_MASK = 0b0001n

package/runtime/unsafe/wasmf32.gr

@@ -2,7 +2,11 @@
 
 // WebAssembly Memory Instructions
 export primitive load: (WasmI32, WasmI32) -> WasmF32 = "@wasm.load_float32"
-export primitive store: (WasmI32, WasmF32, WasmI32) -> Void = "@wasm.store_float32"
+export primitive store: (
+  WasmI32,
+  WasmF32,
+  WasmI32,
+) -> Void = "@wasm.store_float32"
 
 // WebAssembly Unary Instructions
 export primitive neg: WasmF32 -> WasmF32 = "@wasm.neg_float32"
@@ -18,7 +22,10 @@ export primitive add: (WasmF32, WasmF32) -> WasmF32 = "@wasm.add_float32"
 export primitive sub: (WasmF32, WasmF32) -> WasmF32 = "@wasm.sub_float32"
 export primitive mul: (WasmF32, WasmF32) -> WasmF32 = "@wasm.mul_float32"
 export primitive div: (WasmF32, WasmF32) -> WasmF32 = "@wasm.div_float32"
-export primitive copySign: (WasmF32, WasmF32) -> WasmF32 = "@wasm.copy_sign_float32"
+export primitive copySign: (
+  WasmF32,
+  WasmF32,
+) -> WasmF32 = "@wasm.copy_sign_float32"
 export primitive min: (WasmF32, WasmF32) -> WasmF32 = "@wasm.min_float32"
 export primitive max: (WasmF32, WasmF32) -> WasmF32 = "@wasm.max_float32"
 export primitive eq: (WasmF32, WasmF32) -> Bool = "@wasm.eq_float32"

package/runtime/unsafe/wasmf64.gr

@@ -2,7 +2,11 @@
 
 // WebAssembly Memory Instructions
 export primitive load: (WasmI32, WasmI32) -> WasmF64 = "@wasm.load_float64"
-export primitive store: (WasmI32, WasmF64, WasmI32) -> Void = "@wasm.store_float64"
+export primitive store: (
+  WasmI32,
+  WasmF64,
+  WasmI32,
+) -> Void = "@wasm.store_float64"
 
 // WebAssembly Unary Instructions
 export primitive neg: WasmF64 -> WasmF64 = "@wasm.neg_float64"
@@ -18,7 +22,10 @@ export primitive add: (WasmF64, WasmF64) -> WasmF64 = "@wasm.add_float64"
 export primitive sub: (WasmF64, WasmF64) -> WasmF64 = "@wasm.sub_float64"
 export primitive mul: (WasmF64, WasmF64) -> WasmF64 = "@wasm.mul_float64"
 export primitive div: (WasmF64, WasmF64) -> WasmF64 = "@wasm.div_float64"
-export primitive copySign: (WasmF64, WasmF64) -> WasmF64 = "@wasm.copy_sign_float64"
+export primitive copySign: (
+  WasmF64,
+  WasmF64,
+) -> WasmF64 = "@wasm.copy_sign_float64"
 export primitive min: (WasmF64, WasmF64) -> WasmF64 = "@wasm.min_float64"
 export primitive max: (WasmF64, WasmF64) -> WasmF64 = "@wasm.max_float64"
 export primitive eq: (WasmF64, WasmF64) -> Bool = "@wasm.eq_float64"

package/runtime/unsafe/wasmi32.gr

@@ -1,58 +1,76 @@
 /* grainc-flags --compilation-mode=runtime */
 
 // WebAssembly Memory Instructions
-export primitive load : (WasmI32, WasmI32) -> WasmI32 = "@wasm.load_int32"
-export primitive load8S : (WasmI32, WasmI32) -> WasmI32 = "@wasm.load_8_s_int32"
-export primitive load8U : (WasmI32, WasmI32) -> WasmI32 = "@wasm.load_8_u_int32"
-export primitive load16S : (WasmI32, WasmI32) -> WasmI32 = "@wasm.load_16_s_int32"
-export primitive load16U : (WasmI32, WasmI32) -> WasmI32 = "@wasm.load_16_u_int32"
-export primitive store : (WasmI32, WasmI32, WasmI32) -> Void = "@wasm.store_int32"
-export primitive store8 : (WasmI32, WasmI32, WasmI32) -> Void = "@wasm.store_8_int32"
-export primitive store16 : (WasmI32, WasmI32, WasmI32) -> Void = "@wasm.store_16_int32"
+export primitive load: (WasmI32, WasmI32) -> WasmI32 = "@wasm.load_int32"
+export primitive load8S: (WasmI32, WasmI32) -> WasmI32 = "@wasm.load_8_s_int32"
+export primitive load8U: (WasmI32, WasmI32) -> WasmI32 = "@wasm.load_8_u_int32"
+export primitive load16S: (
+  WasmI32,
+  WasmI32,
+) -> WasmI32 = "@wasm.load_16_s_int32"
+export primitive load16U: (
+  WasmI32,
+  WasmI32,
+) -> WasmI32 = "@wasm.load_16_u_int32"
+export primitive store: (
+  WasmI32,
+  WasmI32,
+  WasmI32,
+) -> Void = "@wasm.store_int32"
+export primitive store8: (
+  WasmI32,
+  WasmI32,
+  WasmI32,
+) -> Void = "@wasm.store_8_int32"
+export primitive store16: (
+  WasmI32,
+  WasmI32,
+  WasmI32,
+) -> Void = "@wasm.store_16_int32"
 
 // WebAssembly Unary Instructions
-export primitive clz : WasmI32 -> WasmI32 = "@wasm.clz_int32"
-export primitive ctz : WasmI32 -> WasmI32 = "@wasm.ctz_int32"
-export primitive popcnt : WasmI32 -> WasmI32 = "@wasm.popcnt_int32"
-export primitive eqz : WasmI32 -> Bool = "@wasm.eq_z_int32"
+export primitive clz: WasmI32 -> WasmI32 = "@wasm.clz_int32"
+export primitive ctz: WasmI32 -> WasmI32 = "@wasm.ctz_int32"
+export primitive popcnt: WasmI32 -> WasmI32 = "@wasm.popcnt_int32"
+export primitive eqz: WasmI32 -> Bool = "@wasm.eq_z_int32"
 
 // WebAssembly Binary Instructions
-export primitive add : (WasmI32, WasmI32) -> WasmI32 = "@wasm.add_int32"
-export primitive sub : (WasmI32, WasmI32) -> WasmI32 = "@wasm.sub_int32"
-export primitive mul : (WasmI32, WasmI32) -> WasmI32 = "@wasm.mul_int32"
-export primitive divS : (WasmI32, WasmI32) -> WasmI32 = "@wasm.div_s_int32"
-export primitive divU : (WasmI32, WasmI32) -> WasmI32 = "@wasm.div_u_int32"
-export primitive remS : (WasmI32, WasmI32) -> WasmI32 = "@wasm.rem_s_int32"
-export primitive remU : (WasmI32, WasmI32) -> WasmI32 = "@wasm.rem_u_int32"
-export primitive and : (WasmI32, WasmI32) -> WasmI32 = "@wasm.and_int32"
-export primitive or : (WasmI32, WasmI32) -> WasmI32 = "@wasm.or_int32"
-export primitive xor : (WasmI32, WasmI32) -> WasmI32 = "@wasm.xor_int32"
-export primitive shl : (WasmI32, WasmI32) -> WasmI32 = "@wasm.shl_int32"
-export primitive shrS : (WasmI32, WasmI32) -> WasmI32 = "@wasm.shr_s_int32"
-export primitive shrU : (WasmI32, WasmI32) -> WasmI32 = "@wasm.shr_u_int32"
-export primitive rotl : (WasmI32, WasmI32) -> WasmI32 = "@wasm.rot_l_int32"
-export primitive rotr : (WasmI32, WasmI32) -> WasmI32 = "@wasm.rot_r_int32"
-export primitive eq : (WasmI32, WasmI32) -> Bool = "@wasm.eq_int32"
-export primitive ne : (WasmI32, WasmI32) -> Bool = "@wasm.ne_int32"
-export primitive ltS : (WasmI32, WasmI32) -> Bool = "@wasm.lt_s_int32"
-export primitive ltU : (WasmI32, WasmI32) -> Bool = "@wasm.lt_u_int32"
-export primitive leS : (WasmI32, WasmI32) -> Bool = "@wasm.le_s_int32"
-export primitive leU : (WasmI32, WasmI32) -> Bool = "@wasm.le_u_int32"
-export primitive gtS : (WasmI32, WasmI32) -> Bool = "@wasm.gt_s_int32"
-export primitive gtU : (WasmI32, WasmI32) -> Bool = "@wasm.gt_u_int32"
-export primitive geS : (WasmI32, WasmI32) -> Bool = "@wasm.ge_s_int32"
-export primitive geU : (WasmI32, WasmI32) -> Bool = "@wasm.ge_u_int32"
+export primitive add: (WasmI32, WasmI32) -> WasmI32 = "@wasm.add_int32"
+export primitive sub: (WasmI32, WasmI32) -> WasmI32 = "@wasm.sub_int32"
+export primitive mul: (WasmI32, WasmI32) -> WasmI32 = "@wasm.mul_int32"
+export primitive divS: (WasmI32, WasmI32) -> WasmI32 = "@wasm.div_s_int32"
+export primitive divU: (WasmI32, WasmI32) -> WasmI32 = "@wasm.div_u_int32"
+export primitive remS: (WasmI32, WasmI32) -> WasmI32 = "@wasm.rem_s_int32"
+export primitive remU: (WasmI32, WasmI32) -> WasmI32 = "@wasm.rem_u_int32"
+export primitive and: (WasmI32, WasmI32) -> WasmI32 = "@wasm.and_int32"
+export primitive or: (WasmI32, WasmI32) -> WasmI32 = "@wasm.or_int32"
+export primitive xor: (WasmI32, WasmI32) -> WasmI32 = "@wasm.xor_int32"
+export primitive shl: (WasmI32, WasmI32) -> WasmI32 = "@wasm.shl_int32"
+export primitive shrS: (WasmI32, WasmI32) -> WasmI32 = "@wasm.shr_s_int32"
+export primitive shrU: (WasmI32, WasmI32) -> WasmI32 = "@wasm.shr_u_int32"
+export primitive rotl: (WasmI32, WasmI32) -> WasmI32 = "@wasm.rot_l_int32"
+export primitive rotr: (WasmI32, WasmI32) -> WasmI32 = "@wasm.rot_r_int32"
+export primitive eq: (WasmI32, WasmI32) -> Bool = "@wasm.eq_int32"
+export primitive ne: (WasmI32, WasmI32) -> Bool = "@wasm.ne_int32"
+export primitive ltS: (WasmI32, WasmI32) -> Bool = "@wasm.lt_s_int32"
+export primitive ltU: (WasmI32, WasmI32) -> Bool = "@wasm.lt_u_int32"
+export primitive leS: (WasmI32, WasmI32) -> Bool = "@wasm.le_s_int32"
+export primitive leU: (WasmI32, WasmI32) -> Bool = "@wasm.le_u_int32"
+export primitive gtS: (WasmI32, WasmI32) -> Bool = "@wasm.gt_s_int32"
+export primitive gtU: (WasmI32, WasmI32) -> Bool = "@wasm.gt_u_int32"
+export primitive geS: (WasmI32, WasmI32) -> Bool = "@wasm.ge_s_int32"
+export primitive geU: (WasmI32, WasmI32) -> Bool = "@wasm.ge_u_int32"
 
 // WebAssembly Conversion Instructions
-export primitive wrapI64 : WasmI64 -> WasmI32 = "@wasm.wrap_int64"
-export primitive truncF32S : WasmF32 -> WasmI32 = "@wasm.trunc_s_float32_to_int32"
-export primitive truncF32U : WasmF32 -> WasmI32 = "@wasm.trunc_u_float32_to_int32"
-export primitive truncF64S : WasmF64 -> WasmI32 = "@wasm.trunc_s_float64_to_int32"
-export primitive truncF64U : WasmF64 -> WasmI32 = "@wasm.trunc_u_float64_to_int32"
-export primitive reinterpretF32 : WasmF32 -> WasmI32 = "@wasm.reinterpret_float32"
-export primitive extendS8 : WasmI32 -> WasmI32 = "@wasm.extend_s8_int32"
-export primitive extendS16 : WasmI32 -> WasmI32 = "@wasm.extend_s16_int32"
+export primitive wrapI64: WasmI64 -> WasmI32 = "@wasm.wrap_int64"
+export primitive truncF32S: WasmF32 -> WasmI32 = "@wasm.trunc_s_float32_to_int32"
+export primitive truncF32U: WasmF32 -> WasmI32 = "@wasm.trunc_u_float32_to_int32"
+export primitive truncF64S: WasmF64 -> WasmI32 = "@wasm.trunc_s_float64_to_int32"
+export primitive truncF64U: WasmF64 -> WasmI32 = "@wasm.trunc_u_float64_to_int32"
+export primitive reinterpretF32: WasmF32 -> WasmI32 = "@wasm.reinterpret_float32"
+export primitive extendS8: WasmI32 -> WasmI32 = "@wasm.extend_s8_int32"
+export primitive extendS16: WasmI32 -> WasmI32 = "@wasm.extend_s16_int32"
 
 // Grain Conversions
-export primitive fromGrain : a -> WasmI32 = "@wasm.fromGrain"
-export primitive toGrain : WasmI32 -> a = "@wasm.toGrain"
+export primitive fromGrain: a -> WasmI32 = "@wasm.fromGrain"
+export primitive toGrain: WasmI32 -> a = "@wasm.toGrain"