@grain/stdlib 0.4.5 → 0.5.1

package/string.gr

@@ -9,10 +9,12 @@
 import WasmI32 from "runtime/unsafe/wasmi32"
 import Memory from "runtime/unsafe/memory"
 import Exception from "runtime/exception"
+import Conv from "runtime/unsafe/conv"
 import {
   tagSimpleNumber,
+  tagChar,
+  untagChar,
   allocateArray,
-  allocateChar,
   allocateString,
   allocateBytes,
 } from "runtime/dataStructures"
@@ -32,6 +34,8 @@ export enum Encoding {
   UTF32_LE,
 }
 
+exception MalformedUnicode
+
 /**
  * @section Values: Functions for working with the String data type.
  */
@@ -43,9 +47,9 @@ export enum Encoding {
  * @param str2: The ending string
  * @returns The combined string
  *
- * @example String.concat("Foo", " Bar") == "FooBar"
+ * @example String.concat("Foo", "Bar") == "FooBar"
  *
- * @since v0.1.0
+ * @since v0.2.0
  */
 export let concat = (++)
 
@@ -59,8 +63,8 @@ export let concat = (++)
  *
  * @since v0.1.0
  */
-@disableGC
-export let rec length = (string: String) => {
+@unsafe
+export let length = (string: String) => {
   let string = WasmI32.fromGrain(string)
   let size = WasmI32.load(string, 4n)
 
@@ -76,18 +80,7 @@ export let rec length = (string: String) => {
     ptr = WasmI32.add(ptr, 1n)
   }
 
-  let ret = tagSimpleNumber(len)
-  Memory.decRef(WasmI32.fromGrain(length))
-  Memory.decRef(WasmI32.fromGrain(string))
-  ret
-}
-
-// @disableGC-safe wrapper
-@disableGC
-let wasmSafeLength = (s: String) => {
-  Memory.incRef(WasmI32.fromGrain(length))
-  Memory.incRef(WasmI32.fromGrain(s))
-  length(s)
+  Conv.wasmI32ToNumber(len)
 }
 
 /**
@@ -100,21 +93,10 @@ let wasmSafeLength = (s: String) => {
  *
  * @since v0.1.0
  */
-@disableGC
-export let rec byteLength = (string: String) => {
+@unsafe
+export let byteLength = (string: String) => {
   let string = WasmI32.fromGrain(string)
-  let ret = tagSimpleNumber(WasmI32.load(string, 4n))
-  Memory.decRef(WasmI32.fromGrain(byteLength))
-  Memory.decRef(WasmI32.fromGrain(string))
-  ret
-}
-
-// @disableGC-safe wrapper
-@disableGC
-let wasmSafeByteLength = (string: String) => {
-  Memory.incRef(WasmI32.fromGrain(byteLength))
-  Memory.incRef(WasmI32.fromGrain(string))
-  byteLength(string)
+  Conv.wasmI32ToNumber(WasmI32.load(string, 4n))
 }
 
 /**
@@ -128,8 +110,8 @@ let wasmSafeByteLength = (string: String) => {
  *
  * @since v0.3.0
  */
-@disableGC
-export let rec indexOf = (search: String, string: String) => {
+@unsafe
+export let indexOf = (search: String, string: String) => {
   let search = WasmI32.fromGrain(search)
   let string = WasmI32.fromGrain(string)
 
@@ -143,10 +125,8 @@ export let rec indexOf = (search: String, string: String) => {
   let (-) = WasmI32.sub
   let (&) = WasmI32.and
 
-  let ret = if (psize > size) {
-    let none = None
-    Memory.incRef(WasmI32.fromGrain(none))
-    none
+  if (psize > size) {
+    None
   } else {
     let mut idx = 0n
     let mut ptr = string + 8n
@@ -174,20 +154,73 @@ export let rec indexOf = (search: String, string: String) => {
     }
 
     if (result == -1n) {
-      let none = None
-      Memory.incRef(WasmI32.fromGrain(none))
-      none
+      None
     } else {
-      Memory.incRef(WasmI32.fromGrain(Some))
       Some(tagSimpleNumber(result))
     }
   }
-  Memory.decRef(WasmI32.fromGrain(search))
-  Memory.decRef(WasmI32.fromGrain(string))
-  Memory.decRef(WasmI32.fromGrain(indexOf))
-  ret
 }
 
+@disableGC
+let getCodePoint = (ptr: WasmI32) => {
+  // Algorithm from https://encoding.spec.whatwg.org/#utf-8-decoder
+  let (+) = WasmI32.add
+  let (==) = WasmI32.eq
+  let (>=) = WasmI32.geU
+  let (<=) = WasmI32.leU
+  let (<<) = WasmI32.shl
+  let (&) = WasmI32.and
+  let (|) = WasmI32.or
+
+  let mut codePoint = 0n
+  let mut bytesSeen = 0n
+  let mut bytesNeeded = 0n
+  let mut lowerBoundary = 0x80n
+  let mut upperBoundary = 0xBFn
+
+  let mut offset = 0n
+
+  let mut result = 0n
+
+  while (true) {
+    let byte = WasmI32.load8U(ptr + offset, 0n)
+    offset += 1n
+    if (bytesNeeded == 0n) {
+      if (byte >= 0x00n && byte <= 0x7Fn) {
+        result = byte
+        break
+      } else if (byte >= 0xC2n && byte <= 0xDFn) {
+        bytesNeeded = 1n
+        codePoint = byte & 0x1Fn
+      } else if (byte >= 0xE0n && byte <= 0xEFn) {
+        if (byte == 0xE0n) lowerBoundary = 0xA0n
+        if (byte == 0xEDn) upperBoundary = 0x9Fn
+        bytesNeeded = 2n
+        codePoint = byte & 0xFn
+      } else if (byte >= 0xF0n && byte <= 0xF4n) {
+        if (byte == 0xF0n) lowerBoundary = 0x90n
+        if (byte == 0xF4n) upperBoundary = 0x8Fn
+        bytesNeeded = 3n
+        codePoint = byte & 0x7n
+      } else {
+        throw MalformedUnicode
+      }
+      continue
+    }
+    if (!(lowerBoundary <= byte && byte <= upperBoundary)) {
+      throw MalformedUnicode
+    }
+    lowerBoundary = 0x80n
+    upperBoundary = 0xBFn
+    codePoint = codePoint << 6n | byte & 0x3Fn
+    bytesSeen += 1n
+    if (bytesSeen == bytesNeeded) {
+      result = codePoint
+      break
+    }
+  }
+  result
+}
 /**
  * Get the character at the position in the input string.
  *
@@ -199,18 +232,9 @@ export let rec indexOf = (search: String, string: String) => {
  *
  * @since v0.4.0
  */
-@disableGC
-export let rec charAt = (position, string: String) => {
-  Memory.incRef(WasmI32.fromGrain((<=)))
-  if (
-    wasmSafeLength(string) <= position ||
-    {
-      Memory.incRef(WasmI32.fromGrain((<)))
-      position < 0
-    }
-  ) {
-    Memory.incRef(WasmI32.fromGrain((++)))
-    Memory.incRef(WasmI32.fromGrain(toString))
+@unsafe
+export let charAt = (position, string: String) => {
+  if (length(string) <= position || position < 0) {
     fail "Invalid offset: " ++ toString(position)
   }
   // Implementation is similar to explodeHelp, but doesn't perform unneeded memory allocations
@@ -219,15 +243,18 @@ export let rec charAt = (position, string: String) => {
   let (&) = WasmI32.and
   let (<) = WasmI32.ltU
   let (==) = WasmI32.eq
-  let size = WasmI32.fromGrain(wasmSafeByteLength(string)) >>> 1n
-  let len = WasmI32.fromGrain(wasmSafeLength(string)) >>> 1n
+  let size = WasmI32.fromGrain(byteLength(string)) >>> 1n
   let position = WasmI32.fromGrain(position) >>> 1n
   let string = WasmI32.fromGrain(string)
   let mut ptr = string + 8n
   let end = ptr + size
   let mut counter = 0n
-  let mut result = 0n
+  let mut result = WasmI32.toGrain(0n): Char
   while (ptr < end) {
+    if (counter == position) {
+      result = tagChar(getCodePoint(ptr))
+      break
+    }
     let byte = WasmI32.load8U(ptr, 0n)
     let n = if ((byte & 0x80n) == 0x00n) {
       1n
@@ -238,25 +265,16 @@ export let rec charAt = (position, string: String) => {
     } else {
       2n
     }
-    if (counter == position) {
-      let c = allocateChar()
-      Memory.copy(c + 4n, ptr, n)
-      result = c
-      break
-    }
     counter += 1n
     ptr += n
   }
-  if (result == 0n) {
+  if (WasmI32.eqz(WasmI32.fromGrain(result))) {
     fail "charAt: should be impossible (please report)"
   }
-  let ret = WasmI32.toGrain(result): Char
-  Memory.decRef(WasmI32.fromGrain(string))
-  Memory.decRef(WasmI32.fromGrain(charAt))
-  ret
+  result
 }
 
-@disableGC
+@unsafe
 let explodeHelp = (s: String, chars) => {
   let (>>>) = WasmI32.shrU
   let (+) = WasmI32.add
@@ -264,8 +282,8 @@ let explodeHelp = (s: String, chars) => {
   let (<) = WasmI32.ltU
   let (==) = WasmI32.eq
 
-  let size = WasmI32.fromGrain(wasmSafeByteLength(s)) >>> 1n
-  let len = WasmI32.fromGrain(wasmSafeLength(s)) >>> 1n
+  let size = WasmI32.fromGrain(byteLength(s)) >>> 1n
+  let len = WasmI32.fromGrain(length(s)) >>> 1n
 
   let s = WasmI32.fromGrain(s)
 
@@ -288,9 +306,7 @@ let explodeHelp = (s: String, chars) => {
     }
 
     let c = if (chars) {
-      let c = allocateChar()
-      Memory.copy(c + 4n, ptr, n)
-      c
+      WasmI32.fromGrain(tagChar(getCodePoint(ptr)))
     } else {
       let s = allocateString(n)
       Memory.copy(s + 8n, ptr, n)
@@ -315,15 +331,9 @@ let explodeHelp = (s: String, chars) => {
  *
  * @since v0.3.0
  */
-@disableGC
-export let rec explode = string => {
-  // `explodeHelp` and `string` do not need to be incRef'd as they are not
-  // decRef'd in `explodeHelp`
-  let ret = WasmI32.toGrain(explodeHelp(string, true)): (Array<Char>)
-
-  Memory.decRef(WasmI32.fromGrain(string))
-  Memory.decRef(WasmI32.fromGrain(explode))
-  ret
+@unsafe
+export let explode = string => {
+  WasmI32.toGrain(explodeHelp(string, true)): Array<Char>
 }
 
 /**
@@ -336,32 +346,34 @@ export let rec explode = string => {
  *
  * @since v0.3.0
  */
-@disableGC
-export let rec implode = (arr: Array<Char>) => {
+@unsafe
+export let implode = (arr: Array<Char>) => {
   let (+) = WasmI32.add
-  let (==) = WasmI32.eq
+  let (-) = WasmI32.sub
+  let (*) = WasmI32.mul
   let (<) = WasmI32.ltU
+  let (>) = WasmI32.gtU
+  let (<=) = WasmI32.leU
   let (<<) = WasmI32.shl
+  let (>>>) = WasmI32.shrU
   let (&) = WasmI32.and
+  let (|) = WasmI32.or
 
-  let arr = WasmI32.fromGrain(arr)
-
-  let arrLength = WasmI32.load(arr, 4n)
+  let arrLength = WasmI32.load(WasmI32.fromGrain(arr), 4n)
 
   let mut stringByteLength = 0n
 
   for (let mut i = 0n; i < arrLength; i += 1n) {
-    let char = WasmI32.load(arr + (i << 2n), 8n)
-    let byte = WasmI32.load8U(char, 4n)
+    let usv = untagChar(arr[tagSimpleNumber(i)])
 
-    let n = if ((byte & 0x80n) == 0x00n) {
+    let n = if (usv <= 0x7Fn) {
       1n
-    } else if ((byte & 0xF0n) == 0xF0n) {
-      4n
-    } else if ((byte & 0xE0n) == 0xE0n) {
+    } else if (usv <= 0x07FFn) {
+      2n
+    } else if (usv <= 0xFFFFn) {
       3n
     } else {
-      2n
+      4n
     }
 
     stringByteLength += n
@@ -371,27 +383,37 @@ export let rec implode = (arr: Array<Char>) => {
   let mut offset = 8n
 
   for (let mut i = 0n; i < arrLength; i += 1n) {
-    let char = WasmI32.load(arr + (i << 2n), 8n)
-    let byte = WasmI32.load8U(char, 4n)
+    let usv = untagChar(arr[tagSimpleNumber(i)])
 
-    let n = if ((byte & 0x80n) == 0x00n) {
-      1n
-    } else if ((byte & 0xF0n) == 0xF0n) {
-      4n
-    } else if ((byte & 0xE0n) == 0xE0n) {
-      3n
+    if (usv < 0x7Fn) {
+      WasmI32.store8(str + offset, usv, 0n)
+      offset += 1n
     } else {
-      2n
+      let mut count = 0n
+      let mut marker = 0n
+      if (usv <= 0x07FFn) {
+        count = 1n
+        marker = 0xC0n
+      } else if (usv <= 0xFFFFn) {
+        count = 2n
+        marker = 0xE0n
+      } else {
+        count = 3n
+        marker = 0xF0n
+      }
+      WasmI32.store8(str + offset, (usv >>> 6n * count) + marker, 0n)
+      offset += 1n
+
+      while (count > 0n) {
+        let temp = usv >>> 6n * (count - 1n)
+        WasmI32.store8(str + offset, 0x80n | temp & 0x3Fn, 0n)
+        count -= 1n
+        offset += 1n
+      }
     }
-
-    Memory.copy(str + offset, char + 4n, n)
-    offset += n
   }
 
-  let ret = WasmI32.toGrain(str): String
-  Memory.decRef(WasmI32.fromGrain(arr))
-  Memory.decRef(WasmI32.fromGrain(implode))
-  ret
+  WasmI32.toGrain(str): String
 }
 
 // Helper to get the length in constant time without depending on Array
@@ -430,8 +452,8 @@ export let reverse = string => {
  *
  * @example String.split(" ", "Hello world") == [> "Hello", "world"]
  */
-@disableGC
-export let rec split = (separator: String, string: String) => {
+@unsafe
+export let split = (separator: String, string: String) => {
   let (+) = WasmI32.add
   let (-) = WasmI32.sub
   let (==) = WasmI32.eq
@@ -441,16 +463,13 @@ export let rec split = (separator: String, string: String) => {
   let (>>) = WasmI32.shrS
   let (&) = WasmI32.and
 
-  let size = WasmI32.fromGrain(wasmSafeByteLength(string)) >> 1n
-  let psize = WasmI32.fromGrain(wasmSafeByteLength(separator)) >> 1n
+  let size = WasmI32.fromGrain(byteLength(string)) >> 1n
+  let psize = WasmI32.fromGrain(byteLength(separator)) >> 1n
 
-  let ret = if (psize == 0n) {
-    WasmI32.toGrain(explodeHelp(string, false)): (Array<String>)
+  if (psize == 0n) {
+    WasmI32.toGrain(explodeHelp(string, false)): Array<String>
   } else if (psize > size) {
-    let string = WasmI32.fromGrain(string)
-    let ptr = allocateArray(1n)
-    WasmI32.store(ptr, Memory.incRef(string), 8n)
-    WasmI32.toGrain(ptr): (Array<String>)
+    [> string]
   } else {
     let string = WasmI32.fromGrain(string)
     let separator = WasmI32.fromGrain(separator)
@@ -511,12 +530,8 @@ export let rec split = (separator: String, string: String) => {
     Memory.copy(lastStr + 8n, last, strSize)
     WasmI32.store(arr + arrIdx, lastStr, 8n)
 
-    WasmI32.toGrain(arr): (Array<String>)
+    WasmI32.toGrain(arr): Array<String>
   }
-  Memory.decRef(WasmI32.fromGrain(separator))
-  Memory.decRef(WasmI32.fromGrain(string))
-  Memory.decRef(WasmI32.fromGrain(split))
-  ret
 }
 
 /**
@@ -531,8 +546,8 @@ export let rec split = (separator: String, string: String) => {
  *
  * @since v0.1.0
  */
-@disableGC
-export let rec slice = (start: Number, to: Number, string: String) => {
+@unsafe
+export let slice = (start: Number, to: Number, string: String) => {
   let (+) = WasmI32.add
   let (-) = WasmI32.sub
   let (==) = WasmI32.eq
@@ -545,8 +560,8 @@ export let rec slice = (start: Number, to: Number, string: String) => {
   let startOrig = start
   let toOrig = to
 
-  let len = WasmI32.fromGrain(wasmSafeLength(string)) >> 1n
-  let size = WasmI32.fromGrain(wasmSafeByteLength(string)) >> 1n
+  let len = WasmI32.fromGrain(length(string)) >> 1n
+  let size = WasmI32.fromGrain(byteLength(string)) >> 1n
 
   let string = WasmI32.fromGrain(string)
 
@@ -609,12 +624,7 @@ export let rec slice = (start: Number, to: Number, string: String) => {
 
   Memory.copy(newString + 8n, begin, newSize)
 
-  let ret = WasmI32.toGrain(newString): String
-  Memory.decRef(WasmI32.fromGrain(startOrig))
-  Memory.decRef(WasmI32.fromGrain(toOrig))
-  Memory.decRef(WasmI32.fromGrain(string))
-  Memory.decRef(WasmI32.fromGrain(slice))
-  ret
+  WasmI32.toGrain(newString): String
 }
 
 /**
@@ -628,8 +638,8 @@ export let rec slice = (start: Number, to: Number, string: String) => {
  *
  * @since v0.1.0
  */
-@disableGC
-export let rec contains = (search: String, string: String) => {
+@unsafe
+export let contains = (search: String, string: String) => {
   // "Not So Naive" string search algorithm
   // searching phase in O(nm) time complexity
   // slightly (by coefficient) sub-linear in the average case
@@ -646,8 +656,8 @@ export let rec contains = (search: String, string: String) => {
   let pOrig = search
   let sOrig = string
 
-  let n = WasmI32.fromGrain(wasmSafeByteLength(string)) >> 1n
-  let m = WasmI32.fromGrain(wasmSafeByteLength(search)) >> 1n
+  let n = WasmI32.fromGrain(byteLength(string)) >> 1n
+  let m = WasmI32.fromGrain(byteLength(search)) >> 1n
 
   let mut string = WasmI32.fromGrain(string)
   let mut search = WasmI32.fromGrain(search)
@@ -657,7 +667,7 @@ export let rec contains = (search: String, string: String) => {
 
   let mut j = 0n, k = 0n, ell = 0n
 
-  let ret = if (m > n) {
+  if (m > n) {
     // Bail if pattern length is longer than input length
     false
   } else if (m < 2n) {
@@ -705,10 +715,6 @@ export let rec contains = (search: String, string: String) => {
     }
     result
   }
-  Memory.decRef(WasmI32.fromGrain(pOrig))
-  Memory.decRef(WasmI32.fromGrain(sOrig))
-  Memory.decRef(WasmI32.fromGrain(contains))
-  ret
 }
 
 /**
@@ -722,8 +728,8 @@ export let rec contains = (search: String, string: String) => {
  *
  * @since v0.1.0
  */
-@disableGC
-export let rec startsWith = (search: String, string: String) => {
+@unsafe
+export let startsWith = (search: String, string: String) => {
   let (+) = WasmI32.add
   let (>) = WasmI32.gtU
   let (==) = WasmI32.eq
@@ -740,15 +746,11 @@ export let rec startsWith = (search: String, string: String) => {
   search += 8n
 
   // Bail if pattern length is longer than input length
-  let ret = if (m > n) {
+  if (m > n) {
     false
   } else {
     Memory.compare(search, string, m) == 0n
   }
-  Memory.decRef(WasmI32.fromGrain(pOrig))
-  Memory.decRef(WasmI32.fromGrain(sOrig))
-  Memory.decRef(WasmI32.fromGrain(startsWith))
-  ret
 }
 
 /**
@@ -762,8 +764,8 @@ export let rec startsWith = (search: String, string: String) => {
  *
  * @since v0.1.0
  */
-@disableGC
-export let rec endsWith = (search: String, string: String) => {
+@unsafe
+export let endsWith = (search: String, string: String) => {
   let (+) = WasmI32.add
   let (-) = WasmI32.sub
   let (>) = WasmI32.gtU
@@ -781,15 +783,11 @@ export let rec endsWith = (search: String, string: String) => {
   search += 8n
 
   // Bail if pattern length is longer than input length
-  let ret = if (m > n) {
+  if (m > n) {
     false
   } else {
     Memory.compare(search, string + n - m, m) == 0n
   }
-  Memory.decRef(WasmI32.fromGrain(pOrig))
-  Memory.decRef(WasmI32.fromGrain(sOrig))
-  Memory.decRef(WasmI32.fromGrain(endsWith))
-  ret
 }
 
 // String->Byte encoding and helper functions:
@@ -799,30 +797,22 @@ let _START_NAME = "start"
 let _SIZE_NAME = "size"
 let _OFFSET_NAME = "offset"
 
-@disableGC
+@unsafe
 let grainToWasmNumber = (num, name) => {
   let num = WasmI32.fromGrain(num)
   if (WasmI32.eqz(WasmI32.and(num, 1n))) {
-    Memory.incRef(WasmI32.fromGrain(name))
-    Memory.incRef(WasmI32.fromGrain((++)))
     let str = " argument must be an integer"
-    Memory.incRef(WasmI32.fromGrain(str))
-    Memory.incRef(WasmI32.fromGrain(Exception.InvalidArgument))
     throw Exception.InvalidArgument(name ++ str)
   }
   let num = WasmI32.shrS(num, 1n)
   if (WasmI32.ltS(num, 0n)) {
-    Memory.incRef(WasmI32.fromGrain(name))
-    Memory.incRef(WasmI32.fromGrain((++)))
     let str = " argument must be non-negative"
-    Memory.incRef(WasmI32.fromGrain(str))
-    Memory.incRef(WasmI32.fromGrain(Exception.InvalidArgument))
     throw Exception.InvalidArgument(name ++ str)
   }
   num
 }
 
-@disableGC
+@unsafe
 let utf16Length = (s: String) => {
   let (>>>) = WasmI32.shrU
   let (<<) = WasmI32.shl
@@ -831,8 +821,8 @@ let utf16Length = (s: String) => {
   let (<) = WasmI32.ltU
   let (==) = WasmI32.eq
 
-  let size = WasmI32.fromGrain(wasmSafeByteLength(s)) >>> 1n
-  let len = WasmI32.fromGrain(wasmSafeLength(s)) >>> 1n
+  let size = WasmI32.fromGrain(byteLength(s)) >>> 1n
+  let len = WasmI32.fromGrain(length(s)) >>> 1n
 
   let s = WasmI32.fromGrain(s)
 
@@ -862,101 +852,24 @@ let utf16Length = (s: String) => {
   tagSimpleNumber(size << 1n)
 }
 
-@disableGC
+@unsafe
 let encodedLength = (s: String, encoding) => {
   match (encoding) {
-    UTF32_BE => {
-      Memory.incRef(WasmI32.fromGrain((*)))
-      wasmSafeLength(s) * 4
-    },
-    UTF32_LE => {
-      Memory.incRef(WasmI32.fromGrain((*)))
-      wasmSafeLength(s) * 4
-    },
+    UTF32_BE => length(s) * 4,
+    UTF32_LE => length(s) * 4,
     UTF16_BE => utf16Length(s),
     UTF16_LE => utf16Length(s),
-    UTF8 => wasmSafeByteLength(s),
+    UTF8 => byteLength(s),
   }
 }
 
-exception MalformedUnicode
+@unsafe
+let mut _BYTES_SIZE_OFFSET = 4n
+@unsafe
+let mut _BYTES_OFFSET = 8n
 
-@disableGC
-let getCodePoint = (ptr: WasmI32) => {
-  // Algorithm from https://encoding.spec.whatwg.org/#utf-8-decoder
-  let (+) = WasmI32.add
-  let (==) = WasmI32.eq
-  let (>=) = WasmI32.geU
-  let (<=) = WasmI32.leU
-  let (<<) = WasmI32.shl
-  let (&) = WasmI32.and
-  let (|) = WasmI32.or
-
-  let mut codePoint = 0n
-  let mut bytesSeen = 0n
-  let mut bytesNeeded = 0n
-  let mut lowerBoundary = 0x80n
-  let mut upperBoundary = 0xBFn
-
-  let mut offset = 0n
-
-  let mut result = 0n
-
-  while (true) {
-    let byte = WasmI32.load8U(ptr + offset, 0n)
-    offset += 1n
-    if (bytesNeeded == 0n) {
-      if (byte >= 0x00n && byte <= 0x7Fn) {
-        result = byte
-        break
-      } else if (byte >= 0xC2n && byte <= 0xDFn) {
-        bytesNeeded = 1n
-        codePoint = byte & 0x1Fn
-      } else if (byte >= 0xE0n && byte <= 0xEFn) {
-        if (byte == 0xE0n) lowerBoundary = 0xA0n
-        if (byte == 0xEDn) upperBoundary = 0x9Fn
-        bytesNeeded = 2n
-        codePoint = byte & 0xFn
-      } else if (byte >= 0xF0n && byte <= 0xF4n) {
-        if (byte == 0xF0n) lowerBoundary = 0x90n
-        if (byte == 0xF4n) upperBoundary = 0x8Fn
-        bytesNeeded = 3n
-        codePoint = byte & 0x7n
-      } else {
-        throw MalformedUnicode
-      }
-      continue
-    }
-    if (!(lowerBoundary <= byte && byte <= upperBoundary)) {
-      throw MalformedUnicode
-    }
-    lowerBoundary = 0x80n
-    upperBoundary = 0xBFn
-    codePoint = codePoint << 6n | byte & 0x3Fn
-    bytesSeen += 1n
-    if (bytesSeen == bytesNeeded) {
-      result = codePoint
-      break
-    }
-  }
-  result: WasmI32
-}
-
-// hack to avoid incRef on this pointer
-@disableGC
-let mut _BYTES_SIZE_OFFSET = 1n
-@disableGC
-let mut _BYTES_OFFSET = 1n
-
-@disableGC
-let initPtr = () => {
-  _BYTES_SIZE_OFFSET = 4n
-  _BYTES_OFFSET = 8n
-}
-initPtr()
-
-@disableGC
-let rec encodeAtHelp =
+@unsafe
+let encodeAtHelp =
   (
     string: String,
     encoding: Encoding,
@@ -972,8 +885,8 @@ let rec encodeAtHelp =
   let (<=) = WasmI32.leU
   let (==) = WasmI32.eq
   let (+) = WasmI32.add
-  let byteSize = WasmI32.fromGrain(wasmSafeByteLength(string)) >>> 1n
-  let len = WasmI32.fromGrain(wasmSafeLength(string)) >>> 1n
+  let byteSize = WasmI32.fromGrain(byteLength(string)) >>> 1n
+  let len = WasmI32.fromGrain(length(string)) >>> 1n
 
   let string = WasmI32.fromGrain(string)
 
@@ -1206,13 +1119,6 @@ let rec encodeAtHelp =
     },
   }
 
-  Memory.decRef(WasmI32.fromGrain(string))
-  Memory.decRef(WasmI32.fromGrain(encoding))
-  Memory.decRef(WasmI32.fromGrain(includeBom))
-  Memory.decRef(WasmI32.fromGrain(destPos))
-  Memory.decRef(WasmI32.fromGrain(encodeAtHelp))
-
-  // We don't decRef `dest` because we're returning it
   dest
 }
 
@@ -1246,9 +1152,8 @@ export let encodeAtWithBom = (string, encoding, dest, destPos) => {
   encodeAtHelp(string, encoding, true, dest, destPos)
 }
 
-@disableGC
-let rec encodeHelp = (string: String, encoding: Encoding, includeBom: Bool) => {
-  Memory.incRef(WasmI32.fromGrain((+)))
+@unsafe
+let encodeHelp = (string: String, encoding: Encoding, includeBom: Bool) => {
   let size = encodedLength(string, encoding) +
     (if (includeBom) {
       match (encoding) {
@@ -1263,17 +1168,7 @@ let rec encodeHelp = (string: String, encoding: Encoding, includeBom: Bool) => {
     })
   let (>>>) = WasmI32.shrU
   let bytes = WasmI32.toGrain(allocateBytes(WasmI32.fromGrain(size) >>> 1n))
-  Memory.incRef(WasmI32.fromGrain(encodeAtHelp))
-  Memory.incRef(WasmI32.fromGrain(string))
-  Memory.incRef(WasmI32.fromGrain(encoding))
-  Memory.incRef(WasmI32.fromGrain(includeBom))
-  Memory.incRef(WasmI32.fromGrain(bytes))
-  let ret = encodeAtHelp(string, encoding, includeBom, bytes, 0)
-  Memory.decRef(WasmI32.fromGrain(string))
-  Memory.decRef(WasmI32.fromGrain(encoding))
-  Memory.decRef(WasmI32.fromGrain(includeBom))
-  Memory.decRef(WasmI32.fromGrain(encodeHelp))
-  ret
+  encodeAtHelp(string, encoding, includeBom, bytes, 0)
 }
 
 /**
@@ -1304,7 +1199,7 @@ export let encodeWithBom = (string: String, encoding: Encoding) => {
 
 // Byte->String decoding and helper functions:
 
-@disableGC
+@unsafe
 let writeUtf8CodePoint = (ptr, codePoint) => {
   let (>>>) = WasmI32.shrU
   let (-) = WasmI32.sub
@@ -1361,7 +1256,7 @@ let writeUtf8CodePoint = (ptr, codePoint) => {
   }
 }
 
-@disableGC
+@unsafe
 let bytesHaveBom = (bytes: Bytes, encoding: Encoding, start: WasmI32) => {
   let (+) = WasmI32.add
   let (==) = WasmI32.eq
@@ -1403,7 +1298,7 @@ let bytesHaveBom = (bytes: Bytes, encoding: Encoding, start: WasmI32) => {
   }
 }
 
-@disableGC
+@unsafe
 let decodedLength =
   (
     bytes: Bytes,
@@ -1572,8 +1467,8 @@ let decodedLength =
   }
 }
 
-@disableGC
-let rec decodeRangeHelp =
+@unsafe
+let decodeRangeHelp =
   (
     bytes: Bytes,
     encoding: Encoding,
@@ -1618,7 +1513,7 @@ let rec decodeRangeHelp =
       UTF32_BE => 4n,
     }
   }
-  let ret = if (stringSize == 0n) {
+  if (stringSize == 0n) {
     WasmI32.toGrain(str): String
   } else {
     match (encoding) {
@@ -1635,7 +1530,7 @@ let rec decodeRangeHelp =
             // high surrogate. next character is low srurrogate
             let w1 = (w1 & 0x03FFn) << 10n
             let w2 = (WasmI32.load8U(bytesPtr, 2n) << 8n |
-              WasmI32.load8U(bytesPtr, 3n)) &
+                WasmI32.load8U(bytesPtr, 3n)) &
               0x03FFn
             let codeWord = w1 + w2 + 0x10000n
             // no problems, so go past both code words
@@ -1658,7 +1553,7 @@ let rec decodeRangeHelp =
             // high surrogate. next character is low srurrogate
             let w1 = (w1 & 0x03FFn) << 10n
             let w2 = (WasmI32.load8U(bytesPtr, 3n) << 8n |
-              WasmI32.load8U(bytesPtr, 2n)) &
+                WasmI32.load8U(bytesPtr, 2n)) &
               0x03FFn
             //let uPrime = codePoint - 0x10000n
             //let w1 = ((uPrime & 0b11111111110000000000n) >>> 10n) + 0xD800n // High surrogate
@@ -1699,12 +1594,6 @@ let rec decodeRangeHelp =
     }
     WasmI32.toGrain(str): String
   }
-  // bytes: Bytes, encoding: Encoding, skipBom: Bool, start: Number, size: Number
-  Memory.decRef(WasmI32.fromGrain(bytes))
-  Memory.decRef(WasmI32.fromGrain(encoding))
-  Memory.decRef(WasmI32.fromGrain(skipBom))
-  Memory.decRef(WasmI32.fromGrain(decodeRangeHelp))
-  ret
 }
 
 /**
@@ -1749,24 +1638,11 @@ export let decodeRangeKeepBom =
   decodeRangeHelp(bytes, encoding, false, start, size)
 }
 
-@disableGC
-let rec decodeHelp = (bytes: Bytes, encoding: Encoding, skipBom: Bool) => {
+@unsafe
+let decodeHelp = (bytes: Bytes, encoding: Encoding, skipBom: Bool) => {
   let bytesPtr = WasmI32.fromGrain(bytes)
   let bytesSize = WasmI32.load(bytesPtr, 4n)
-  Memory.incRef(WasmI32.fromGrain(decodeRangeHelp))
-  Memory.incRef(WasmI32.fromGrain(bytes))
-  Memory.incRef(WasmI32.fromGrain(encoding))
-  let ret = decodeRangeHelp(
-    bytes,
-    encoding,
-    skipBom,
-    0,
-    tagSimpleNumber(bytesSize)
-  )
-  Memory.incRef(WasmI32.fromGrain(bytes))
-  Memory.incRef(WasmI32.fromGrain(encoding))
-  Memory.incRef(WasmI32.fromGrain(decodeHelp))
-  ret
+  decodeRangeHelp(bytes, encoding, skipBom, 0, tagSimpleNumber(bytesSize))
 }
 
 /**
@@ -1805,8 +1681,8 @@ export let decodeKeepBom = (bytes: Bytes, encoding: Encoding) => {
  *
  * @since v0.4.0
  */
-@disableGC
-export let rec forEachCodePoint = (fn: Number -> Void, str: String) => {
+@unsafe
+export let forEachCodePoint = (fn: Number -> Void, str: String) => {
   let (>>>) = WasmI32.shrU
   let (-) = WasmI32.sub
   let (&) = WasmI32.and
@@ -1843,15 +1719,11 @@ export let rec forEachCodePoint = (fn: Number -> Void, str: String) => {
     // avoid heap allocations. `getCodePoint` will throw
     // MalformedUnicode exception for values exceeding this limit.
     let codePoint = getCodePoint(ptr)
-    Memory.incRef(WasmI32.fromGrain(fn))
     fn(tagSimpleNumber(codePoint))
 
     ptr += codePointByteCount
     idx += 1n
   }
-  Memory.decRef(WasmI32.fromGrain(fn))
-  Memory.decRef(WasmI32.fromGrain(str))
-  Memory.decRef(WasmI32.fromGrain(forEachCodePoint))
   void
 }
 
@@ -1867,12 +1739,8 @@ export let rec forEachCodePoint = (fn: Number -> Void, str: String) => {
  *
  * @since v0.4.0
  */
-@disableGC
-export let rec forEachCodePointi =
-  (
-    fn: (Number, Number) -> Void,
-    str: String,
-  ) => {
+@unsafe
+export let forEachCodePointi = (fn: (Number, Number) -> Void, str: String) => {
   let (>>>) = WasmI32.shrU
   let (-) = WasmI32.sub
   let (&) = WasmI32.and
@@ -1909,17 +1777,14 @@ export let rec forEachCodePointi =
     // avoid heap allocations. `getCodePoint` will throw
     // MalformedUnicode exception for values exceeding this limit.
     let codePoint = getCodePoint(ptr)
-    Memory.incRef(WasmI32.fromGrain(fn))
     fn(tagSimpleNumber(codePoint), tagSimpleNumber(idx))
 
     ptr += codePointByteCount
     idx += 1n
   }
-  Memory.decRef(WasmI32.fromGrain(fn))
-  Memory.decRef(WasmI32.fromGrain(str))
-  Memory.decRef(WasmI32.fromGrain(forEachCodePointi))
   void
 }
+
 let trimString = (str: String, end: Bool) => {
   let chars = explode(str), charsLength = length(str)
   let mut i = 0, offset = 1