@grain/stdlib 0.4.4 → 0.5.0

package/runtime/string.gr

@@ -7,6 +7,7 @@ import WasmI32, {
   divS as (/),
   shl as (<<),
   shrS as (>>),
+  shrU as (>>>),
   and as (&),
   or as (|),
   eq as (==),
@@ -14,44 +15,37 @@ 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"
 import WasmF64 from "runtime/unsafe/wasmf64"
+import BI from "runtime/bigint"
 import Memory from "runtime/unsafe/memory"
 import Tags from "runtime/unsafe/tags"
 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) }
-
-@disableGC
-let slConsDisableGc = (a, b) => {
-  Memory.incRef(WasmI32.fromGrain(SLCons))
-  Memory.incRef(WasmI32.fromGrain(a))
-  // for easier chaining, we don't incRef `b`
-  SLCons(a, b)
+enum StringList {
+  [],
+  [...](String, StringList),
 }
 
-@disableGC
-let mut _RUNTIME_TYPE_METADATA_PTR = 0x01n;
-
-@disableGC
-let initPtr = () => {
-  // hack to avoid incRef on this pointer
-  _RUNTIME_TYPE_METADATA_PTR = 0x408n
-}
-initPtr();
+primitive _RUNTIME_TYPE_METADATA_PTR: WasmI32 = "@heap.type_metadata"
 
-@disableGC
+@unsafe
 let findTypeMetadata = (moduleId, typeId) => {
   let mut metadataPtr = WasmI32.load(_RUNTIME_TYPE_METADATA_PTR, 0n)
   let mut modData = -1n
@@ -81,8 +75,8 @@ let findTypeMetadata = (moduleId, typeId) => {
   }
 }
 
-@disableGC
-let getVariantName = (variant) => {
+@unsafe
+let getVariantName = variant => {
   let moduleId = WasmI32.load(variant, 4n) >> 1n
   let typeId = WasmI32.load(variant, 8n) >> 1n
   let variantId = WasmI32.load(variant, 12n) >> 1n
@@ -112,8 +106,8 @@ let getVariantName = (variant) => {
   }
 }
 
-@disableGC
-let getRecordFieldNames = (record_) => {
+@unsafe
+let getRecordFieldNames = record_ => {
   let moduleId = WasmI32.load(record_, 4n) >> 1n
   let typeId = WasmI32.load(record_, 8n) >> 1n
   let arity = WasmI32.load(record_, 12n)
@@ -131,8 +125,9 @@ let getRecordFieldNames = (record_) => {
     for (let mut i = 0n; i < arity; i += 1n) {
       let fieldLength = WasmI32.load(fields + fieldOffset, 4n)
       let fieldName = allocateString(fieldLength)
+      Memory.incRef(fieldName)
       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)
     }
@@ -141,50 +136,50 @@ let getRecordFieldNames = (record_) => {
   }
 }
 
-@disableGC
+@unsafe
 let rec totalBytes = (acc, list) => {
   match (list) {
-    SLCons(hd, tl) => totalBytes(acc + WasmI32.load(WasmI32.fromGrain(hd), 4n), tl),
-    SLEmpty => acc
+    [hd, ...tl] =>
+      totalBytes(acc + WasmI32.load(WasmI32.fromGrain(hd), 4n), tl),
+    [] => acc,
   }
 }
 
-@disableGC
+@unsafe
 let rec writeStrings = (buf, list) => {
   match (list) {
-    SLCons(hd, tl) => {
+    [hd, ...tl] => {
       let hd = WasmI32.fromGrain(hd)
       let hdSize = WasmI32.load(hd, 4n)
       Memory.copy(buf, hd + 8n, hdSize)
       writeStrings(buf + hdSize, tl)
     },
-    SLEmpty => void
+    [] => void,
   }
 }
 
-@disableGC
-let join = (list) => {
+@unsafe
+let join = list => {
   let len = totalBytes(0n, list)
   let str = allocateString(len)
   writeStrings(str + 8n, list)
   WasmI32.toGrain(str): String
 }
 
-@disableGC
-let reverse = (list) => {
-  @disableGC
+@unsafe
+let reverse = list => {
+  @unsafe
   let rec iter = (list, acc) => {
     match (list) {
-      SLEmpty => acc,
-      SLCons(first, rest) => iter(rest, slConsDisableGc(first, acc))
+      [] => acc,
+      [first, ...rest] => iter(rest, [first, ...acc]),
     }
   }
-  Memory.incRef(WasmI32.fromGrain(SLEmpty))
-  iter(list, SLEmpty)
+  iter(list, [])
 }
 
-@disableGC
-export let rec concat = (s1: String, s2: String) => {
+@unsafe
+export let concat = (s1: String, s2: String) => {
   let ptr1 = WasmI32.fromGrain(s1)
   let ptr2 = WasmI32.fromGrain(s2)
 
@@ -196,14 +191,10 @@ export let rec concat = (s1: String, s2: String) => {
   Memory.copy(newString + 8n, ptr1 + 8n, size1)
   Memory.copy(newString + 8n + size1, ptr2 + 8n, size2)
 
-  let ret = WasmI32.toGrain(newString): String
-  Memory.decRef(ptr1)
-  Memory.decRef(ptr2)
-  Memory.decRef(WasmI32.fromGrain(concat))
-  ret
+  WasmI32.toGrain(newString): String
 }
 
-@disableGC
+@unsafe
 let escape = (ptr, isString) => {
   let _SEQ_B = 0x08n
   let _SEQ_F = 0x0Cn
@@ -217,30 +208,20 @@ let escape = (ptr, isString) => {
 
   let _SEQ_QUOTE = if (isString) _SEQ_DQUOTE else _SEQ_SQUOTE
 
-  let size = if (isString) {
-    WasmI32.load(ptr, 4n)
-  } else {
-    let byte = WasmI32.load8U(ptr, 4n)
-
-    // Calculate number of bytes via utf-8 encoding
-    if ((byte & 0x80n) == 0x00n) {
-      1n
-    } else if ((byte & 0xF0n) == 0xF0n) {
-      4n
-    } else if ((byte & 0xE0n) == 0xE0n) {
-      3n
-    } else {
-      2n
-    }
-  }
+  let size = WasmI32.load(ptr, 4n)
 
-  let startOffset = if (isString) 8n else 4n
+  let startOffset = 8n
   let stringOffset = 8n
 
   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 +235,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 +250,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
@@ -280,33 +266,65 @@ let escape = (ptr, isString) => {
   WasmI32.toGrain(escapedString): String
 }
 
-@disableGC
+@unsafe
 let escapeString = (s: String) => {
   escape(WasmI32.fromGrain(s), true)
 }
 
-@disableGC
-let escapeChar = (c: Char) => {
-  escape(WasmI32.fromGrain(c), false)
+@unsafe
+let escapeChar = (s: String) => {
+  escape(WasmI32.fromGrain(s), false)
+}
+
+@unsafe
+let usvToString = usv => {
+  if (usv < 0x80n) {
+    let string = allocateString(1n)
+    WasmI32.store8(string, usv, 8n)
+    WasmI32.toGrain(string): String
+  } else {
+    let mut count = 0n
+    let mut offset = 0n
+    if (usv <= 0x07FFn) {
+      count = 1n
+      offset = 0xC0n
+    } else if (usv <= 0xFFFFn) {
+      count = 2n
+      offset = 0xE0n
+    } else {
+      count = 3n
+      offset = 0xF0n
+    }
+    let string = allocateString(count + 1n)
+    WasmI32.store8(string, (usv >>> 6n * count) + offset, 8n)
+
+    let mut n = 0n
+    while (count > 0n) {
+      n += 1n
+      let temp = usv >>> 6n * (count - 1n)
+      WasmI32.store8(string + n, 0x80n | temp & 0x3Fn, 8n)
+      count -= 1n
+    }
+
+    WasmI32.toGrain(string): String
+  }
 }
 
-@disableGC
+@unsafe
 let isListVariant = (variant: String) => {
   // Only lists can start with `[`, so only need to check for that
   // Sort of a hack until we have a better solution
   WasmI32.load8U(WasmI32.fromGrain(variant), 8n) == 0x5Bn
 }
 
-@disableGC
+@unsafe
 let rec heapValueToString = (ptr, extraIndents, toplevel) => {
   let tag = WasmI32.load(ptr, 0n)
   match (tag) {
     t when t == Tags._GRAIN_STRING_HEAP_TAG => {
+      // In both cases, we incRef ptr so we can use it again via WasmI32.toGrain
+      Memory.incRef(ptr)
       if (toplevel) {
-        // We can just return the pointer since its already a string and
-        // doesn't need escaping in this case, but by convention its reference
-        // count needs to be incremented.
-        Memory.incRef(ptr)
         WasmI32.toGrain(ptr): String
       } else {
         escapeString(WasmI32.toGrain(ptr))
@@ -350,25 +368,6 @@ let rec heapValueToString = (ptr, extraIndents, toplevel) => {
 
       WasmI32.toGrain(str): String
     },
-    t when t == Tags._GRAIN_CHAR_HEAP_TAG => {
-      if (toplevel) {
-        let byte = WasmI32.load8U(ptr, 4n)
-        let numBytes = if ((byte & 0x80n) == 0x00n) {
-          1n
-        } else if ((byte & 0xF0n) == 0xF0n) {
-          4n
-        } else if ((byte & 0xE0n) == 0xE0n) {
-          3n
-        } else {
-          2n
-        }
-        let str = allocateString(numBytes)
-        Memory.copy(str + 8n, ptr + 4n, numBytes)
-        WasmI32.toGrain(str): String
-      } else {
-        escapeChar(WasmI32.toGrain(ptr))
-      }
-    },
     t when t == Tags._GRAIN_ADT_HEAP_TAG => {
       // [ <value type tag>, <module_tag>, <type_tag>, <variant_tag>, <arity>, elts ... ]
       let variantName = getVariantName(ptr)
@@ -387,26 +386,22 @@ let rec heapValueToString = (ptr, extraIndents, toplevel) => {
           } else {
             let comspace = ", "
             let rparen = ")"
-            Memory.incRef(WasmI32.fromGrain(SLEmpty))
-            let mut strings = slConsDisableGc(rparen, SLEmpty)
+            let mut strings = [rparen]
             for (let mut i = variantArity * 4n - 4n; i >= 0n; i -= 4n) {
-              let tmp = toStringHelp(WasmI32.load(ptr + i, 20n), extraIndents, false)
-              strings = slConsDisableGc(tmp, strings)
-              Memory.decRef(WasmI32.fromGrain(tmp))
+              let tmp = toStringHelp(
+                WasmI32.load(ptr + i, 20n),
+                extraIndents,
+                false
+              )
+              strings = [tmp, ...strings]
               if (i > 0n) {
-                strings = slConsDisableGc(comspace, strings)
+                strings = [comspace, ...strings]
               }
             }
-            Memory.incRef(WasmI32.fromGrain(variantName))
             let lparen = "("
-            strings = slConsDisableGc(variantName, slConsDisableGc(lparen, strings))
-            let string = join(strings)
-            Memory.decRef(WasmI32.fromGrain(variantName))
-            Memory.decRef(WasmI32.fromGrain(lparen))
-            Memory.decRef(WasmI32.fromGrain(rparen))
-            Memory.decRef(WasmI32.fromGrain(strings))
-            Memory.decRef(WasmI32.fromGrain(comspace))
-            string
+            strings = [variantName, lparen, ...strings]
+
+            join(strings)
           }
         }
       }
@@ -418,70 +413,60 @@ 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)
         Memory.fill(spacePadding + 8n, 0x20n, padAmount) // create indentation
         let spacePadding = WasmI32.toGrain(spacePadding): String
-        Memory.incRef(WasmI32.fromGrain(SLEmpty))
         let newline = "\n"
         let rbrace = "}"
-        let mut strings = slConsDisableGc(newline, slConsDisableGc(prevSpacePadding, slConsDisableGc(rbrace, SLEmpty)))
+        let mut strings = [newline, prevSpacePadding, rbrace]
         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))))
-          Memory.decRef(WasmI32.fromGrain(fieldValue))
+          let fieldValue = toStringHelp(
+            WasmI32.load(ptr + i, 16n),
+            extraIndents + 1n,
+            false
+          )
+          strings = [spacePadding, fieldName, colspace, fieldValue, ...strings]
           if (i > 0n) {
-            strings = slConsDisableGc(comlf, strings)
+            strings = [comlf, ...strings]
           }
         }
         let lbrace = "{\n"
-        strings = slConsDisableGc(lbrace, strings)
-        let string = join(strings)
-
-        Memory.decRef(WasmI32.fromGrain(strings))
-        Memory.decRef(WasmI32.fromGrain(spacePadding))
-        Memory.decRef(WasmI32.fromGrain(colspace))
-        Memory.decRef(WasmI32.fromGrain(comlf))
-        Memory.decRef(WasmI32.fromGrain(lbrace))
-        Memory.decRef(WasmI32.fromGrain(rbrace))
-        Memory.decRef(WasmI32.fromGrain(newline))
-
-        Memory.free(fields) // Avoid double-free of record field names
+        strings = [lbrace, ...strings]
 
-        string
+        join(strings)
       }
     },
     t when t == Tags._GRAIN_ARRAY_HEAP_TAG => {
       let arity = WasmI32.load(ptr, 4n)
-      Memory.incRef(WasmI32.fromGrain(SLEmpty))
       let rbrack = "]"
-      let mut strings = slConsDisableGc(rbrack, SLEmpty)
+      let mut strings = [rbrack]
       let comspace = ", "
       for (let mut i = arity * 4n - 4n; i >= 0n; i -= 4n) {
         let item = toStringHelp(WasmI32.load(ptr + i, 8n), extraIndents, false)
-        strings = slConsDisableGc(item, strings)
-        Memory.decRef(WasmI32.fromGrain(item))
+        strings = [item, ...strings]
         if (i > 0n) {
-          strings = slConsDisableGc(comspace, strings)
+          strings = [comspace, ...strings]
         }
       }
       let lbrack = "[> "
-      strings = slConsDisableGc(lbrack, strings)
-      let string = join(strings)
-      Memory.decRef(WasmI32.fromGrain(strings))
-      Memory.decRef(WasmI32.fromGrain(comspace))
-      Memory.decRef(WasmI32.fromGrain(lbrack))
-      Memory.decRef(WasmI32.fromGrain(rbrack))
-
-      string
+      strings = [lbrack, ...strings]
+
+      join(strings)
     },
     t when t == Tags._GRAIN_BOXED_NUM_HEAP_TAG => {
       let numberTag = WasmI32.load(ptr, 4n)
@@ -492,18 +477,15 @@ let rec heapValueToString = (ptr, extraIndents, toplevel) => {
         t when t == Tags._GRAIN_INT64_BOXED_NUM_TAG => {
           NumberUtils.itoa64(WasmI64.load(ptr, 8n), 10n)
         },
+        t when t == Tags._GRAIN_BIGINT_BOXED_NUM_TAG => {
+          BI.bigIntToString10(ptr)
+        },
         t when t == Tags._GRAIN_RATIONAL_BOXED_NUM_TAG => {
-          let numerator = NumberUtils.itoa32(WasmI32.load(ptr, 8n), 10n)
-          let denominator = NumberUtils.itoa32(WasmI32.load(ptr, 12n), 10n)
-          Memory.incRef(WasmI32.fromGrain(SLEmpty))
+          let numerator = BI.bigIntToString10(WasmI32.load(ptr, 8n))
+          let denominator = BI.bigIntToString10(WasmI32.load(ptr, 12n))
           let slash = "/"
-          let strings = slConsDisableGc(numerator, slConsDisableGc(slash, slConsDisableGc(denominator, SLEmpty)))
-          let string = join(strings)
-          Memory.decRef(WasmI32.fromGrain(strings))
-          Memory.decRef(WasmI32.fromGrain(numerator))
-          Memory.decRef(WasmI32.fromGrain(denominator))
-          Memory.decRef(WasmI32.fromGrain(slash))
-          string
+          let strings = [numerator, slash, denominator]
+          join(strings)
         },
         t when t == Tags._GRAIN_FLOAT32_BOXED_NUM_TAG => {
           NumberUtils.dtoa(WasmF64.promoteF32(WasmF32.load(ptr, 8n)))
@@ -513,7 +495,7 @@ let rec heapValueToString = (ptr, extraIndents, toplevel) => {
         },
         _ => {
           "<unknown boxed number>"
-        }
+        },
       }
     },
     t when t == Tags._GRAIN_TUPLE_HEAP_TAG => {
@@ -523,78 +505,80 @@ let rec heapValueToString = (ptr, extraIndents, toplevel) => {
       } else {
         WasmI32.store(ptr, 0x80000000n | tupleLength, 4n)
         let comspace = ", "
-        Memory.incRef(WasmI32.fromGrain(SLEmpty))
         let rparen = ")"
-        let mut strings = slConsDisableGc(rparen, SLEmpty)
+        let mut strings = [rparen]
         if (tupleLength <= 1n) {
           // Special case: unary tuple
           let comma = ","
-          strings = slConsDisableGc(comma, strings)
-          Memory.decRef(WasmI32.fromGrain(comma))
+          strings = [comma, ...strings]
           void
         }
         for (let mut i = tupleLength * 4n - 4n; i >= 0n; i -= 4n) {
-          let item = toStringHelp(WasmI32.load(ptr + i, 8n), extraIndents, false)
-          strings = slConsDisableGc(item, strings)
-          Memory.decRef(WasmI32.fromGrain(item))
+          let item = toStringHelp(
+            WasmI32.load(ptr + i, 8n),
+            extraIndents,
+            false
+          )
+          strings = [item, ...strings]
           if (i > 0n) {
-            strings = slConsDisableGc(comspace, strings)
+            strings = [comspace, ...strings]
           }
         }
         WasmI32.store(ptr, tupleLength, 4n)
 
         Memory.incRef(WasmI32.fromGrain(strings))
         let lparen = "("
-        strings = slConsDisableGc(lparen, strings)
+        strings = [lparen, ...strings]
 
-        let string = join(strings)
-        Memory.decRef(WasmI32.fromGrain(strings))
-        Memory.decRef(WasmI32.fromGrain(comspace))
-        Memory.decRef(WasmI32.fromGrain(rparen))
-        Memory.decRef(WasmI32.fromGrain(lparen))
-
-        string
+        join(strings)
       }
     },
     t when t == Tags._GRAIN_LAMBDA_HEAP_TAG => {
       "<lambda>"
     },
     _ => {
-      Memory.incRef(WasmI32.fromGrain(SLEmpty))
-      let strings = slConsDisableGc(
+      let strings = [
         "<unknown heap tag type: 0x",
-        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
-    }
+        NumberUtils.itoa32(tag, 16n),
+        " | value: 0x",
+        NumberUtils.itoa32(ptr, 16n),
+        ">",
+      ]
+      join(strings)
+    },
   }
 }, toStringHelp = (grainValue, extraIndents, toplevel) => {
   if ((grainValue & 1n) != 0n) {
     // Simple (unboxed) numbers
     NumberUtils.itoa32(grainValue >> 1n, 10n)
-  } else if ((grainValue & 7n) == Tags._GRAIN_GENERIC_HEAP_TAG_TYPE) {
-    heapValueToString(grainValue, extraIndents, toplevel)
-  } else if (grainValue == WasmI32.fromGrain(true)) {
-    "true"
-  } else if (grainValue == WasmI32.fromGrain(false)) {
-    "false"
-  } else if (grainValue == WasmI32.fromGrain(void)) {
-    "void"
   } else {
-    "<unknown value>"
+    let tag = grainValue & 7n
+    if (tag == Tags._GRAIN_GENERIC_HEAP_TAG_TYPE) {
+      heapValueToString(grainValue, extraIndents, toplevel)
+    } else if (tag == Tags._GRAIN_CHAR_TAG_TYPE) {
+      let string = usvToString(grainValue >> 3n)
+      if (toplevel) {
+        string
+      } else {
+        escapeChar(string)
+      }
+    } else if (grainValue == WasmI32.fromGrain(true)) {
+      "true"
+    } else if (grainValue == WasmI32.fromGrain(false)) {
+      "false"
+    } else if (grainValue == WasmI32.fromGrain(void)) {
+      "void"
+    } else {
+      "<unknown value>"
+    }
   }
 }, listToString = (ptr, extraIndents) => {
   let mut cur = ptr
   let mut isFirst = true
 
-  Memory.incRef(WasmI32.fromGrain(SLEmpty))
   let lbrack = "["
   let commaspace = ", "
-  let mut strings = slConsDisableGc(lbrack, SLEmpty)
+  let mut strings = [lbrack]
 
   while (true) {
     let variantId = WasmI32.load(cur, 12n) >> 1n // tagged number
@@ -602,46 +586,30 @@ let rec heapValueToString = (ptr, extraIndents, toplevel) => {
       break
     } else {
       if (!isFirst) {
-        strings = slConsDisableGc(commaspace, strings)
+        strings = [commaspace, ...strings]
       }
       isFirst = false
       let item = toStringHelp(WasmI32.load(cur, 20n), extraIndents, false)
-      strings = slConsDisableGc(item, strings)
-      Memory.decRef(WasmI32.fromGrain(item))
+      strings = [item, ...strings]
       cur = WasmI32.load(cur, 24n)
     }
   }
   let rbrack = "]"
-  strings = slConsDisableGc(rbrack, strings)
+  strings = [rbrack, ...strings]
   let reversed = reverse(strings)
-  let string = join(reversed)
-  Memory.decRef(WasmI32.fromGrain(strings))
-  Memory.decRef(WasmI32.fromGrain(reversed))
-  Memory.decRef(WasmI32.fromGrain(lbrack))
-  Memory.decRef(WasmI32.fromGrain(rbrack))
-  Memory.decRef(WasmI32.fromGrain(commaspace))
-  string
+  join(reversed)
 }
 
-@disableGC
-export let rec toString = (value) => {
+@unsafe
+export let toString = value => {
   let value = WasmI32.fromGrain(value)
-  let ret = toStringHelp(value, 0n, true)
-  Memory.decRef(value)
-  Memory.decRef(WasmI32.fromGrain(toString))
-  ret
+  toStringHelp(value, 0n, true)
 }
 
-@disableGC
-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
-  // to be deallocated. In either case it's sufficient to force decrement its
-  // reference count.
+@unsafe
+export let print = value => {
+  // First convert the value to string, if it isn't one already.
   let valuePtr = WasmI32.fromGrain(value)
-  Memory.incRef(WasmI32.fromGrain(toString))
-  Memory.incRef(valuePtr) // for function call
   let s = toString(value)
   let ptr = WasmI32.fromGrain(s)
   // iov: [<ptr to string> <nbytes of string> <ptr to newline> <nbytes of newline>] (32 bytes)
@@ -658,8 +626,5 @@ export let rec print = (value) => {
   WasmI32.store(iov, 1n, 12n)
   fd_write(1n, iov, 2n, written)
   Memory.free(buf)
-  Memory.decRef(ptr)
-  Memory.decRef(WasmI32.fromGrain(print))
-  Memory.decRef(WasmI32.fromGrain(value))
   void
 }