@grain/stdlib 0.5.12 → 0.6.0

package/string.gr

@@ -1,16 +1,21 @@
 /**
- * @module String: Utilities for working with strings.
- * @example import String from "string"
+ * Utilities for working with strings.
+ *
+ * @example from "string" include String
  *
  * @since v0.2.0
  * @history v0.1.0: Originally named `strings`
  * @history v0.2.0: Renamed to `string`
  */
-import WasmI32 from "runtime/unsafe/wasmi32"
-import Memory from "runtime/unsafe/memory"
-import Exception from "runtime/exception"
-import Conv from "runtime/unsafe/conv"
-import {
+module String
+
+from "char" include Char
+from "runtime/unsafe/wasmi32" include WasmI32
+from "runtime/unsafe/memory" include Memory
+from "runtime/exception" include Exception
+from "runtime/unsafe/conv" include Conv
+from "runtime/dataStructures" include DataStructures
+use DataStructures.{
   untagSimpleNumber,
   tagSimpleNumber,
   tagChar,
@@ -18,16 +23,12 @@ import {
   allocateArray,
   allocateString,
   allocateBytes,
-} from "runtime/dataStructures"
-
-/**
- * @section Types: Type declarations included in the String module.
- */
+}
 
 /**
  * Byte encodings
  */
-export enum Encoding {
+provide enum Encoding {
   UTF8,
   UTF16_BE,
   UTF16_LE,
@@ -37,10 +38,6 @@ export enum Encoding {
 
 exception MalformedUnicode
 
-/**
- * @section Values: Functions for working with the String data type.
- */
-
 /**
  * Concatenate two strings.
  *
@@ -52,7 +49,7 @@ exception MalformedUnicode
  *
  * @since v0.2.0
  */
-export let concat = (++)
+provide let concat = (++)
 
 /**
  * Returns the character length of the input string.
@@ -65,20 +62,21 @@ export let concat = (++)
  * @since v0.1.0
  */
 @unsafe
-export let length = (string: String) => {
+provide let length = (string: String) => {
+  use WasmI32.{ (+), (&), (!=) }
   let string = WasmI32.fromGrain(string)
   let size = WasmI32.load(string, 4n)
 
   let mut len = 0n
-  let mut ptr = WasmI32.add(string, 8n)
-  let end = WasmI32.add(ptr, size)
+  let mut ptr = string + 8n
+  let end = ptr + size
 
   while (WasmI32.ltU(ptr, end)) {
     let byte = WasmI32.load8U(ptr, 0n)
-    if (WasmI32.ne(WasmI32.and(byte, 0xC0n), 0x80n)) {
-      len = WasmI32.add(len, 1n)
+    if ((byte & 0xC0n) != 0x80n) {
+      len += 1n
     }
-    ptr = WasmI32.add(ptr, 1n)
+    ptr += 1n
   }
 
   Conv.wasmI32ToNumber(len)
@@ -95,11 +93,26 @@ export let length = (string: String) => {
  * @since v0.1.0
  */
 @unsafe
-export let byteLength = (string: String) => {
+provide let byteLength = (string: String) => {
   let string = WasmI32.fromGrain(string)
   Conv.wasmI32ToNumber(WasmI32.load(string, 4n))
 }
 
+/**
+ * Determines if the string contains no characters.
+ *
+ * @param string: The string to inspect
+ * @returns `true` if the string is empty and `false` otherwise
+ *
+ * @since v0.6.0
+ */
+@unsafe
+provide let isEmpty = (string: String) => {
+  use WasmI32.{ (==) }
+  let strPtr = WasmI32.fromGrain(string)
+  WasmI32.load(strPtr, 4n) == 0n
+}
+
 /**
  * Finds the first position of a substring in the input string.
  *
@@ -112,54 +125,40 @@ export let byteLength = (string: String) => {
  * @since v0.3.0
  */
 @unsafe
-export let indexOf = (search: String, string: String) => {
+provide let indexOf = (search: String, string: String) => {
   let search = WasmI32.fromGrain(search)
   let string = WasmI32.fromGrain(string)
 
   let size = WasmI32.load(string, 4n)
   let psize = WasmI32.load(search, 4n)
-
-  let (>) = WasmI32.gtU
-  let (<) = WasmI32.ltU
-  let (==) = WasmI32.eq
-  let (+) = WasmI32.add
-  let (-) = WasmI32.sub
-  let (&) = WasmI32.and
+  use WasmI32.{ (+), (-), (&), ltU as (<), gtU as (>), (==) }
 
   if (psize > size) {
-    None
-  } else {
-    let mut idx = 0n
-    let mut ptr = string + 8n
-    let mut pptr = search + 8n
-    let end = ptr + size - psize + 1n
-
-    let mut result = -1n
+    return None
+  }
+  let mut idx = 0n
+  let mut ptr = string + 8n
+  let pptr = search + 8n
+  let end = ptr + size - psize + 1n
 
-    while (ptr < end) {
-      if (Memory.compare(ptr, pptr, psize) == 0n) {
-        result = idx
-        break
-      }
-      idx += 1n
-      let byte = WasmI32.load8U(ptr, 0n)
-      if ((byte & 0x80n) == 0x00n) {
-        ptr += 1n
-      } else if ((byte & 0xF0n) == 0xF0n) {
-        ptr += 4n
-      } else if ((byte & 0xE0n) == 0xE0n) {
-        ptr += 3n
-      } else {
-        ptr += 2n
-      }
+  while (ptr < end) {
+    if (Memory.compare(ptr, pptr, psize) == 0n) {
+      return Some(tagSimpleNumber(idx))
     }
-
-    if (result == -1n) {
-      None
+    idx += 1n
+    let byte = WasmI32.load8U(ptr, 0n)
+    if ((byte & 0x80n) == 0x00n) {
+      ptr += 1n
+    } else if ((byte & 0xF0n) == 0xF0n) {
+      ptr += 4n
+    } else if ((byte & 0xE0n) == 0xE0n) {
+      ptr += 3n
     } else {
-      Some(tagSimpleNumber(result))
+      ptr += 2n
     }
   }
+
+  return None
 }
 
 /**
@@ -174,63 +173,45 @@ export let indexOf = (search: String, string: String) => {
  * @since v0.5.3
  */
 @unsafe
-export let lastIndexOf = (search: String, string: String) => {
+provide let lastIndexOf = (search: String, string: String) => {
   // The last possible index in the string given the length of the search
   let lastIndex = length(string) - length(search)
 
-  let (>) = WasmI32.gtU
-  let (>=) = WasmI32.geU
-  let (==) = WasmI32.eq
-  let (!=) = WasmI32.ne
-  let (+) = WasmI32.add
-  let (-) = WasmI32.sub
-  let (&) = WasmI32.and
+  use WasmI32.{ (+), (-), (&), gtU as (>), geU as (>=), (==), (!=) }
 
   let search = WasmI32.fromGrain(search)
   let string = WasmI32.fromGrain(string)
   let searchSize = WasmI32.load(search, 4n)
   let stringSize = WasmI32.load(string, 4n)
   if (searchSize > stringSize) {
-    None
-  } else {
-    let mut matchIndex = -1n
-    let mut stringIndex = untagSimpleNumber(lastIndex)
-    let searchPtr = search + 8n
-    let stringStartPtr = string + 8n
-    for (
-      let mut stringPtr = stringStartPtr + stringSize - searchSize;
-      stringPtr >= stringStartPtr;
-      stringPtr -= 1n
-    ) {
-      let byte = WasmI32.load8U(stringPtr, 0n)
-      if ((byte & 0xC0n) == 0x80n) {
-        // We're not at the start of a codepoint, so move on
-        continue
-      }
-      if (Memory.compare(stringPtr, searchPtr, searchSize) == 0n) {
-        matchIndex = stringIndex
-        break
-      }
-      stringIndex -= 1n
+    return None
+  }
+  let mut stringIndex = untagSimpleNumber(lastIndex)
+  let searchPtr = search + 8n
+  let stringStartPtr = string + 8n
+  for (
+    let mut stringPtr = stringStartPtr + stringSize - searchSize;
+    stringPtr >= stringStartPtr;
+    stringPtr -= 1n
+  ) {
+    let byte = WasmI32.load8U(stringPtr, 0n)
+    if ((byte & 0xC0n) == 0x80n) {
+      // We're not at the start of a codepoint, so move on
+      continue
     }
-    if (matchIndex == -1n) {
-      None
-    } else {
-      Some(tagSimpleNumber(matchIndex))
+    if (Memory.compare(stringPtr, searchPtr, searchSize) == 0n) {
+      return Some(tagSimpleNumber(stringIndex))
     }
+    stringIndex -= 1n
   }
+
+  return None
 }
 
 @unsafe
 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
+  use WasmI32.{ (+), (&), (|), (<<), leU as (<=), geU as (>=), (==) }
 
   let mut codePoint = 0n
   let mut bytesSeen = 0n
@@ -240,15 +221,12 @@ let getCodePoint = (ptr: WasmI32) => {
 
   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
+        return byte
       } else if (byte >= 0xC2n && byte <= 0xDFn) {
         bytesNeeded = 1n
         codePoint = byte & 0x1Fn
@@ -275,11 +253,10 @@ let getCodePoint = (ptr: WasmI32) => {
     codePoint = codePoint << 6n | byte & 0x3Fn
     bytesSeen += 1n
     if (bytesSeen == bytesNeeded) {
-      result = codePoint
-      break
+      return codePoint
     }
   }
-  result
+  return 0n
 }
 
 @unsafe
@@ -288,22 +265,16 @@ let charAtHelp = (position, string: String) => {
     fail "Invalid offset: " ++ toString(position)
   }
   // Implementation is similar to explodeHelp, but doesn't perform unneeded memory allocations
-  let (>>>) = WasmI32.shrU
-  let (+) = WasmI32.add
-  let (&) = WasmI32.and
-  let (<) = WasmI32.ltU
-  let (==) = WasmI32.eq
+  use WasmI32.{ (+), (&), (>>>), ltU as (<), (==) }
   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
   while (ptr < end) {
     if (counter == position) {
-      result = getCodePoint(ptr)
-      break
+      return getCodePoint(ptr)
     }
     let byte = WasmI32.load8U(ptr, 0n)
     let n = if ((byte & 0x80n) == 0x00n) {
@@ -318,10 +289,8 @@ let charAtHelp = (position, string: String) => {
     counter += 1n
     ptr += n
   }
-  if (WasmI32.eqz(WasmI32.fromGrain(result))) {
-    fail "charAt: should be impossible (please report)"
-  }
-  result
+
+  fail "charAt: should be impossible (please report)"
 }
 
 /**
@@ -331,12 +300,15 @@ let charAtHelp = (position, string: String) => {
  * @param string: The string to search
  * @returns The character code at the provided position
  *
+ * @throws MalformedUnicode: When the `string` is malformed
+ * @throws Failure(String): When the `position` is out of bounds
+ *
  * @example String.charCodeAt(5, "Hello world") == 32
  *
  * @since v0.5.3
  */
 @unsafe
-export let charCodeAt = (position, string: String) => {
+provide let charCodeAt = (position, string: String) => {
   tagSimpleNumber(charAtHelp(position, string))
 }
 
@@ -347,22 +319,21 @@ export let charCodeAt = (position, string: String) => {
  * @param string: The string to search
  * @returns The character at the provided position
  *
+ * @throws MalformedUnicode: When the `string` is malformed
+ * @throws Failure(String): When the `position` is out of bounds
+ *
  * @example String.charAt(5, "Hello world") == ' '
  *
  * @since v0.4.0
  */
 @unsafe
-export let charAt = (position, string: String) => {
+provide let charAt = (position, string: String) => {
   tagChar(charAtHelp(position, string))
 }
 
 @unsafe
 let explodeHelp = (s: String, chars) => {
-  let (>>>) = WasmI32.shrU
-  let (+) = WasmI32.add
-  let (&) = WasmI32.and
-  let (<) = WasmI32.ltU
-  let (==) = WasmI32.eq
+  use WasmI32.{ (+), (&), (>>>), ltU as (<), (==) }
 
   let size = WasmI32.fromGrain(byteLength(s)) >>> 1n
   let len = WasmI32.fromGrain(length(s)) >>> 1n
@@ -409,12 +380,14 @@ let explodeHelp = (s: String, chars) => {
  * @param string: The string to split
  * @returns An array containing all characters in the string
  *
+ * @throws MalformedUnicode: When the `string` is malformed
+ *
  * @example String.explode("Hello") == [> 'H', 'e', 'l', 'l', 'o']
  *
  * @since v0.3.0
  */
 @unsafe
-export let explode = string => {
+provide let explode = string => {
   WasmI32.toGrain(explodeHelp(string, true)): Array<Char>
 }
 
@@ -429,17 +402,19 @@ export let explode = string => {
  * @since v0.3.0
  */
 @unsafe
-export let implode = (arr: Array<Char>) => {
-  let (+) = WasmI32.add
-  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
+provide let implode = (arr: Array<Char>) => {
+  use WasmI32.{
+    (+),
+    (-),
+    (*),
+    (&),
+    (|),
+    (<<),
+    (>>>),
+    ltU as (<),
+    gtU as (>),
+    leU as (<=),
+  }
 
   let arrLength = WasmI32.load(WasmI32.fromGrain(arr), 4n)
 
@@ -483,11 +458,11 @@ export let implode = (arr: Array<Char>) => {
         count = 3n
         marker = 0xF0n
       }
-      WasmI32.store8(str + offset, (usv >>> 6n * count) + marker, 0n)
+      WasmI32.store8(str + offset, (usv >>> (6n * count)) + marker, 0n)
       offset += 1n
 
       while (count > 0n) {
-        let temp = usv >>> 6n * (count - 1n)
+        let temp = usv >>> (6n * (count - 1n))
         WasmI32.store8(str + offset, 0x80n | temp & 0x3Fn, 0n)
         count -= 1n
         offset += 1n
@@ -499,7 +474,7 @@ export let implode = (arr: Array<Char>) => {
 }
 
 // Helper to get the length in constant time without depending on Array
-primitive arrayLength: Array<a> -> Number = "@array.length"
+primitive arrayLength = "@array.length"
 
 /**
  * Create a string that is the given string reversed.
@@ -511,7 +486,7 @@ primitive arrayLength: Array<a> -> Number = "@array.length"
  *
  * @since v0.4.5
  */
-export let reverse = string => {
+provide let reverse = string => {
   let mut arr = explode(string)
   let len = arrayLength(arr)
   let halfLen = len / 2
@@ -532,18 +507,13 @@ export let reverse = string => {
  * @param string: The string to split
  * @returns An array of substrings from the initial string
  *
+ * @throws MalformedUnicode: When the `string` is malformed
+ *
  * @example String.split(" ", "Hello world") == [> "Hello", "world"]
  */
 @unsafe
-export let split = (separator: String, string: String) => {
-  let (+) = WasmI32.add
-  let (-) = WasmI32.sub
-  let (==) = WasmI32.eq
-  let (<) = WasmI32.ltU
-  let (>) = WasmI32.gtU
-  let (<<) = WasmI32.shl
-  let (>>) = WasmI32.shrS
-  let (&) = WasmI32.and
+provide let split = (separator: String, string: String) => {
+  use WasmI32.{ (+), (-), (&), (<<), (>>), ltU as (<), gtU as (>), (==) }
 
   let size = WasmI32.fromGrain(byteLength(string)) >> 1n
   let psize = WasmI32.fromGrain(byteLength(separator)) >> 1n
@@ -620,27 +590,25 @@ export let split = (separator: String, string: String) => {
  * Get a portion of a string.
  *
  * @param start: The start position of the substring
- * @param to: The end position of the substring, exclusive
+ * @param end: The end position of the substring, exclusive
  * @param string: The input string
  * @returns The substring from the initial string
  *
- * @example String.slice(0, 5, "Hello world") == "Hello"
+ * @throws InvalidArgument(String): When the `start` index is not an integer
+ * @throws InvalidArgument(String): When the `to` index is not an integer
+ * @throws IndexOutOfBounds: When `start` is out of bounds
+ * @throws IndexOutOfBounds: When `end` is out of bounds
+ * @throws InvalidArgument(String): When `start` is greater than `end`
+ *
+ * @example String.slice(0, end=5, "Hello world") == "Hello"
+ * @example String.slice(0, "Hello world") == "Hello world"
  *
  * @since v0.1.0
+ * @history v0.6.0: Default `end` to the String length
  */
 @unsafe
-export let slice = (start: Number, to: Number, string: String) => {
-  let (+) = WasmI32.add
-  let (-) = WasmI32.sub
-  let (==) = WasmI32.eq
-  let (!=) = WasmI32.ne
-  let (<) = WasmI32.ltS
-  let (>) = WasmI32.gtS
-  let (<<) = WasmI32.shl
-  let (>>) = WasmI32.shrS
-  let (&) = WasmI32.and
-  let startOrig = start
-  let toOrig = to
+provide let slice = (start: Number, end=length(string), string: String) => {
+  use WasmI32.{ (+), (-), (&), (<<), (>>), (<), (>), (==), (!=) }
 
   let len = WasmI32.fromGrain(length(string)) >> 1n
   let size = WasmI32.fromGrain(byteLength(string)) >> 1n
@@ -653,7 +621,7 @@ export let slice = (start: Number, to: Number, string: String) => {
   }
   start = start >> 1n
 
-  let mut to = WasmI32.fromGrain(to)
+  let mut to = WasmI32.fromGrain(end)
   if ((to & 1n) != 1n) {
     throw InvalidArgument("Invalid end index")
   }
@@ -667,7 +635,7 @@ export let slice = (start: Number, to: Number, string: String) => {
   }
 
   if (start > len || to > len) {
-    throw Exception.IndexOutOfBounds
+    throw IndexOutOfBounds
   }
 
   if (to < start) {
@@ -721,20 +689,21 @@ export let slice = (start: Number, to: Number, string: String) => {
  * @since v0.1.0
  */
 @unsafe
-export let contains = (search: String, string: String) => {
+provide 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
   // http://igm.univ-mlv.fr/~lecroq/string/node13.html#SECTION00130
-
-  let (+) = WasmI32.add
-  let (-) = WasmI32.sub
-  let (==) = WasmI32.eq
-  let (!=) = WasmI32.ne
-  let (<) = WasmI32.ltU
-  let (<=) = WasmI32.leU
-  let (>) = WasmI32.gtU
-  let (>>) = WasmI32.shrS
+  use WasmI32.{
+    (+),
+    (-),
+    (>>),
+    ltU as (<),
+    gtU as (>),
+    leU as (<=),
+    (==),
+    (!=),
+  }
   let pOrig = search
   let sOrig = string
 
@@ -747,56 +716,58 @@ export let contains = (search: String, string: String) => {
   string += 8n
   search += 8n
 
-  let mut j = 0n, k = 0n, ell = 0n
+  let mut j = 0n
+  and k = 0n
+  and ell = 0n
 
   if (m > n) {
     // Bail if pattern length is longer than input length
-    false
-  } else if (m < 2n) {
+    return false
+  }
+
+  if (m < 2n) {
     // Handle very small patterns
     if (m == 0n) {
-      true
-    } else {
-      let pat = WasmI32.load8U(search, 0n)
-      let mut result = false
-      while (j < n) {
-        if (pat == WasmI32.load8U(string + j, 0n)) {
-          result = true
-          break
-        } else {
-          j += 1n
-        }
+      return true
+    }
+
+    let pat = WasmI32.load8U(search, 0n)
+    while (j < n) {
+      if (pat == WasmI32.load8U(string + j, 0n)) {
+        return true
+      } else {
+        j += 1n
       }
-      result
     }
+
+    return false
+  }
+
+  // NSM preprocessing
+  if (WasmI32.load8U(search, 0n) == WasmI32.load8U(search, 1n)) {
+    k = 2n
+    ell = 1n
   } else {
-    // NSM preprocessing
-    if (WasmI32.load8U(search, 0n) == WasmI32.load8U(search, 1n)) {
-      k = 2n
-      ell = 1n
-    } else {
-      k = 1n
-      ell = 2n
-    }
+    k = 1n
+    ell = 2n
+  }
 
-    let mut result = false
-    // NSM searching
-    while (j <= n - m) {
-      if (WasmI32.load8U(search, 1n) != WasmI32.load8U(string + j, 1n)) {
-        j += k
-      } else {
-        if (
-          Memory.compare(search + 2n, string + j + 2n, m - 2n) == 0n &&
-          WasmI32.load8U(search, 0n) == WasmI32.load8U(string + j, 0n)
-        ) {
-          result = true
-          break
-        }
-        j += ell
+  // NSM searching
+  while (j <= n - m) {
+    if (WasmI32.load8U(search, 1n) != WasmI32.load8U(string + j, 1n)) {
+      j += k
+    } else {
+      if (
+        Memory.compare(search + 2n, string + j + 2n, m - 2n) == 0n &&
+        WasmI32.load8U(search, 0n) == WasmI32.load8U(string + j, 0n)
+      ) {
+        return true
       }
+      j += ell
     }
-    result
   }
+
+  return false
 }
 
 /**
@@ -811,10 +782,8 @@ export let contains = (search: String, string: String) => {
  * @since v0.1.0
  */
 @unsafe
-export let startsWith = (search: String, string: String) => {
-  let (+) = WasmI32.add
-  let (>) = WasmI32.gtU
-  let (==) = WasmI32.eq
+provide let startsWith = (search: String, string: String) => {
+  use WasmI32.{ (+), gtU as (>), (==) }
   let pOrig = search
   let sOrig = string
 
@@ -847,11 +816,8 @@ export let startsWith = (search: String, string: String) => {
  * @since v0.1.0
  */
 @unsafe
-export let endsWith = (search: String, string: String) => {
-  let (+) = WasmI32.add
-  let (-) = WasmI32.sub
-  let (>) = WasmI32.gtU
-  let (==) = WasmI32.eq
+provide let endsWith = (search: String, string: String) => {
+  use WasmI32.{ (+), (-), gtU as (>), (==) }
   let pOrig = search
   let sOrig = string
 
@@ -885,17 +851,12 @@ export let endsWith = (search: String, string: String) => {
  * @since v0.5.4
  */
 @unsafe
-export let replaceFirst =
-  (
-    searchPattern: String,
-    replacement: String,
-    string: String,
-  ) => {
-  let (+) = WasmI32.add
-  let (-) = WasmI32.sub
-  let (>) = WasmI32.gtU
-  let (<) = WasmI32.ltU
-  let (==) = WasmI32.eq
+provide let replaceFirst = (
+  searchPattern: String,
+  replacement: String,
+  string: String,
+) => {
+  use WasmI32.{ (+), (-), gtU as (>), ltU as (<), (==) }
 
   let mut patternPtr = WasmI32.fromGrain(searchPattern)
   let mut stringPtr = WasmI32.fromGrain(string)
@@ -906,25 +867,19 @@ export let replaceFirst =
   let replacementLen = WasmI32.load(replacementPtr, 4n)
   // Bail if search str is longer than the string
   if (stringLen < patternLen) {
-    string
-  } else {
-    patternPtr += 8n
-    stringPtr += 8n
-    replacementPtr += 8n
-
-    let mut found = false
-    // Search for an instance of the string
-    let mut foundIndex = -1n
-    let stringEndPtr = stringPtr + stringLen - patternLen + 1n
-    for (let mut i = stringPtr; i < stringEndPtr; i += 1n) {
-      // check for match
-      foundIndex += 1n
-      if (Memory.compare(i, patternPtr, patternLen) == 0n) {
-        found = true
-        break
-      }
-    }
-    if (found) {
+    return string
+  }
+  patternPtr += 8n
+  stringPtr += 8n
+  replacementPtr += 8n
+
+  // Search for an instance of the string
+  let mut foundIndex = -1n
+  let stringEndPtr = stringPtr + stringLen - patternLen + 1n
+  for (let mut i = stringPtr; i < stringEndPtr; i += 1n) {
+    // check for match
+    foundIndex += 1n
+    if (Memory.compare(i, patternPtr, patternLen) == 0n) {
       // Create the new string
       let str = allocateString(stringLen - patternLen + replacementLen)
       let strPtr = str + 8n
@@ -936,11 +891,11 @@ export let replaceFirst =
         stringLen - foundIndex
       )
       // Copy over the str
-      WasmI32.toGrain(str): String
-    } else {
-      string
+      return WasmI32.toGrain(str): String
     }
   }
+
+  return string
 }
 
 /**
@@ -956,17 +911,12 @@ export let replaceFirst =
  * @since v0.5.4
  */
 @unsafe
-export let replaceLast =
-  (
-    searchPattern: String,
-    replacement: String,
-    string: String,
-  ) => {
-  let (+) = WasmI32.add
-  let (-) = WasmI32.sub
-  let (>) = WasmI32.gtU
-  let (<) = WasmI32.ltU
-  let (==) = WasmI32.eq
+provide let replaceLast = (
+  searchPattern: String,
+  replacement: String,
+  string: String,
+) => {
+  use WasmI32.{ (+), (-), gtU as (>), ltU as (<), (==) }
 
   let mut patternPtr = WasmI32.fromGrain(searchPattern)
   let mut stringPtr = WasmI32.fromGrain(string)
@@ -978,25 +928,20 @@ export let replaceLast =
 
   // Bail if search str is longer than the string
   if (stringLen < patternLen) {
-    string
-  } else {
-    patternPtr += 8n
-    stringPtr += 8n
-    replacementPtr += 8n
-
-    let mut found = false
-    // Search for an instance of the string
-    let stringEndPtr = stringPtr + stringLen - patternLen
-    let mut foundIndex = stringLen - patternLen + 1n
-    for (let mut i = stringEndPtr; i > stringPtr - 1n; i -= 1n) {
-      // check for match
-      foundIndex -= 1n
-      if (Memory.compare(i, patternPtr, patternLen) == 0n) {
-        found = true
-        break
-      }
-    }
-    if (found) {
+    return string
+  }
+  patternPtr += 8n
+  stringPtr += 8n
+  replacementPtr += 8n
+
+  let mut found = false
+  // Search for an instance of the string
+  let stringEndPtr = stringPtr + stringLen - patternLen
+  let mut foundIndex = stringLen - patternLen + 1n
+  for (let mut i = stringEndPtr; i > stringPtr - 1n; i -= 1n) {
+    // check for match
+    foundIndex -= 1n
+    if (Memory.compare(i, patternPtr, patternLen) == 0n) {
       // Create the new string
       let str = allocateString(stringLen - patternLen + replacementLen)
       let strPtr = str + 8n
@@ -1008,11 +953,11 @@ export let replaceLast =
         stringLen - foundIndex
       )
       // Copy over the str
-      WasmI32.toGrain(str): String
-    } else {
-      string
+      return WasmI32.toGrain(str): String
     }
   }
+
+  return string
 }
 
 /**
@@ -1028,19 +973,12 @@ export let replaceLast =
  * @since v0.5.4
  */
 @unsafe
-export let replaceAll =
-  (
-    searchPattern: String,
-    replacement: String,
-    string: String,
-  ) => {
-  let (*) = WasmI32.mul
-  let (+) = WasmI32.add
-  let (-) = WasmI32.sub
-  let (>) = WasmI32.gtU
-  let (<) = WasmI32.ltU
-  let (==) = WasmI32.eq
-  let (>>) = WasmI32.shrS
+provide let replaceAll = (
+  searchPattern: String,
+  replacement: String,
+  string: String,
+) => {
+  use WasmI32.{ (+), (-), (*), (>>), gtU as (>), ltU as (<), (==) }
 
   let mut patternPtr = WasmI32.fromGrain(searchPattern)
   let mut stringPtr = WasmI32.fromGrain(string)
@@ -1071,6 +1009,8 @@ export let replaceAll =
         found = true
         foundCount += 1n
         foundIndexes = [tagSimpleNumber(foundIndex), ...foundIndexes]
+        foundIndex -= patternLen - 1n
+        i -= patternLen - 1n
       }
     }
     if (found) {
@@ -1114,13 +1054,14 @@ let _OFFSET_NAME = "offset"
 
 @unsafe
 let grainToWasmNumber = (num, name) => {
+  use WasmI32.{ (&), (>>), (<) }
   let num = WasmI32.fromGrain(num)
-  if (WasmI32.eqz(WasmI32.and(num, 1n))) {
+  if (WasmI32.eqz(num & 1n)) {
     let str = " argument must be an integer"
     throw Exception.InvalidArgument(name ++ str)
   }
-  let num = WasmI32.shrS(num, 1n)
-  if (WasmI32.ltS(num, 0n)) {
+  let num = num >> 1n
+  if (num < 0n) {
     let str = " argument must be non-negative"
     throw Exception.InvalidArgument(name ++ str)
   }
@@ -1129,12 +1070,7 @@ let grainToWasmNumber = (num, name) => {
 
 @unsafe
 let utf16Length = (s: String) => {
-  let (>>>) = WasmI32.shrU
-  let (<<) = WasmI32.shl
-  let (+) = WasmI32.add
-  let (&) = WasmI32.and
-  let (<) = WasmI32.ltU
-  let (==) = WasmI32.eq
+  use WasmI32.{ (+), (&), (>>>), (<<), ltU as (<), (==) }
 
   let size = WasmI32.fromGrain(byteLength(s)) >>> 1n
   let len = WasmI32.fromGrain(length(s)) >>> 1n
@@ -1184,22 +1120,14 @@ let mut _BYTES_SIZE_OFFSET = 4n
 let mut _BYTES_OFFSET = 8n
 
 @unsafe
-let encodeAtHelp =
-  (
-    string: String,
-    encoding: Encoding,
-    includeBom: Bool,
-    dest: Bytes,
-    destPos: Number,
-  ) => {
-  let (>>>) = WasmI32.shrU
-  let (-) = WasmI32.sub
-  let (&) = WasmI32.and
-  let (<) = WasmI32.ltU
-  let (>) = WasmI32.gtS
-  let (<=) = WasmI32.leU
-  let (==) = WasmI32.eq
-  let (+) = WasmI32.add
+let encodeAtHelp = (
+  string: String,
+  encoding: Encoding,
+  includeBom: Bool,
+  dest: Bytes,
+  destPos: Number,
+) => {
+  use WasmI32.{ (+), (-), (&), (>>>), ltU as (<), (>), leU as (<=), (==) }
   let byteSize = WasmI32.fromGrain(byteLength(string)) >>> 1n
   let len = WasmI32.fromGrain(length(string)) >>> 1n
 
@@ -1217,7 +1145,7 @@ let encodeAtHelp =
     match (encoding) {
       UTF8 => {
         if (bytesIdx + 3n > destSize) {
-          throw Exception.IndexOutOfBounds
+          throw IndexOutOfBounds
         }
         WasmI32.store8(bytes + bytesIdx, 0xEFn, _BYTES_OFFSET)
         WasmI32.store8(bytes + bytesIdx + 1n, 0xBBn, _BYTES_OFFSET)
@@ -1226,7 +1154,7 @@ let encodeAtHelp =
       },
       UTF16_BE => {
         if (bytesIdx + 2n > destSize) {
-          throw Exception.IndexOutOfBounds
+          throw IndexOutOfBounds
         }
         WasmI32.store8(bytes + bytesIdx, 0xFEn, _BYTES_OFFSET)
         WasmI32.store8(bytes + bytesIdx + 1n, 0xFFn, _BYTES_OFFSET)
@@ -1234,7 +1162,7 @@ let encodeAtHelp =
       },
       UTF16_LE => {
         if (bytesIdx + 2n > destSize) {
-          throw Exception.IndexOutOfBounds
+          throw IndexOutOfBounds
         }
         WasmI32.store8(bytes + bytesIdx, 0xFFn, _BYTES_OFFSET)
         WasmI32.store8(bytes + bytesIdx + 1n, 0xFEn, _BYTES_OFFSET)
@@ -1242,7 +1170,7 @@ let encodeAtHelp =
       },
       UTF32_BE => {
         if (bytesIdx + 4n > destSize) {
-          throw Exception.IndexOutOfBounds
+          throw IndexOutOfBounds
         }
         WasmI32.store8(bytes + bytesIdx, 0n, _BYTES_OFFSET)
         WasmI32.store8(bytes + bytesIdx + 1n, 0n, _BYTES_OFFSET)
@@ -1252,7 +1180,7 @@ let encodeAtHelp =
       },
       UTF32_LE => {
         if (bytesIdx + 4n > destSize) {
-          throw Exception.IndexOutOfBounds
+          throw IndexOutOfBounds
         }
         WasmI32.store8(bytes + bytesIdx, 0xFFn, _BYTES_OFFSET)
         WasmI32.store8(bytes + bytesIdx + 1n, 0xFEn, _BYTES_OFFSET)
@@ -1269,7 +1197,7 @@ let encodeAtHelp =
       // the target encoding is UTF8 as well, then copy the entire memory range
       // in bulk. No need to iterate individual characters.
       if (bytesIdx + byteSize > destSize) {
-        throw Exception.IndexOutOfBounds
+        throw IndexOutOfBounds
       }
       Memory.copy(bytes + bytesIdx + _BYTES_OFFSET, ptr, byteSize)
     },
@@ -1291,7 +1219,7 @@ let encodeAtHelp =
             // With the optimization above for bulk memory copy, this match
             // should never occur for the UTF8 case.
             if (bytesIdx + n > destSize) {
-              throw Exception.IndexOutOfBounds
+              throw IndexOutOfBounds
             }
             Memory.copy(bytes + bytesIdx + _BYTES_OFFSET, ptr, n)
             bytesIdx += n
@@ -1301,7 +1229,7 @@ let encodeAtHelp =
             if (codePoint <= 0xFFFFn) {
               // <hi><lo>
               if (bytesIdx + 2n > destSize) {
-                throw Exception.IndexOutOfBounds
+                throw IndexOutOfBounds
               }
               WasmI32.store8(
                 bytes + bytesIdx,
@@ -1317,13 +1245,11 @@ let encodeAtHelp =
             } else {
               // https://en.wikipedia.org/wiki/UTF-16#Code_points_from_U+010000_to_U+10FFFF
               if (bytesIdx + 4n > destSize) {
-                throw Exception.IndexOutOfBounds
+                throw IndexOutOfBounds
               }
               let uPrime = codePoint - 0x10000n
-              let w1 = ((uPrime & 0b11111111110000000000n) >>> 10n) +
-                0xD800n // High surrogate
-              let w2 = (uPrime & 0b00000000001111111111n) +
-                0xDC00n // Low surrogate
+              let w1 = ((uPrime & 0b11111111110000000000n) >>> 10n) + 0xD800n // High surrogate
+              let w2 = (uPrime & 0b00000000001111111111n) + 0xDC00n // Low surrogate
               WasmI32.store8(
                 bytes + bytesIdx,
                 (w1 & 0xff00n) >>> 8n,
@@ -1343,7 +1269,7 @@ let encodeAtHelp =
             let codePoint = getCodePoint(ptr)
             if (codePoint <= 0xFFFFn) {
               if (bytesIdx + 2n > destSize) {
-                throw Exception.IndexOutOfBounds
+                throw IndexOutOfBounds
               }
               // <lo><hi>
               WasmI32.store8(bytes + bytesIdx, codePoint & 0xffn, _BYTES_OFFSET)
@@ -1356,13 +1282,11 @@ let encodeAtHelp =
             } else {
               // https://en.wikipedia.org/wiki/UTF-16#Code_points_from_U+010000_to_U+10FFFF
               if (bytesIdx + 4n > destSize) {
-                throw Exception.IndexOutOfBounds
+                throw IndexOutOfBounds
               }
               let uPrime = codePoint - 0x10000n
-              let w1 = ((uPrime & 0b11111111110000000000n) >>> 10n) +
-                0xD800n // High surrogate
-              let w2 = (uPrime & 0b00000000001111111111n) +
-                0xDC00n // Low surrogate
+              let w1 = ((uPrime & 0b11111111110000000000n) >>> 10n) + 0xD800n // High surrogate
+              let w2 = (uPrime & 0b00000000001111111111n) + 0xDC00n // Low surrogate
               WasmI32.store8(bytes + bytesIdx, w1 & 0xffn, _BYTES_OFFSET)
               WasmI32.store8(
                 bytes + bytesIdx + 1n,
@@ -1380,7 +1304,7 @@ let encodeAtHelp =
           },
           UTF32_BE => {
             if (bytesIdx + 4n > destSize) {
-              throw Exception.IndexOutOfBounds
+              throw IndexOutOfBounds
             }
             let codePoint = getCodePoint(ptr)
             WasmI32.store8(
@@ -1407,7 +1331,7 @@ let encodeAtHelp =
           },
           UTF32_LE => {
             if (bytesIdx + 4n > destSize) {
-              throw Exception.IndexOutOfBounds
+              throw IndexOutOfBounds
             }
             let codePoint = getCodePoint(ptr)
             WasmI32.store8(bytes + bytesIdx, codePoint & 0xffn, _BYTES_OFFSET)
@@ -1438,92 +1362,63 @@ let encodeAtHelp =
 }
 
 /**
- * Encodes the given string into a byte sequence at the supplied position, excluding any byte-order marker, using the encoding scheme provided.
+ * Encodes the given string into a byte sequence at the supplied position using the encoding scheme provided.
  *
  * @param string: The input string
  * @param encoding: The encoding to use
  * @param dest: The byte sequence that will be copied
  * @param destPos: The location in the byte sequence to write the output
+ * @param includeBom: Whether or not to include a byte order marker (false by default)
  * @returns A copy of the input bytes with the encoded string replaced at the given position
  *
- * @since v0.4.0
- */
-export let encodeAt = (string, encoding, dest, destPos) => {
-  encodeAtHelp(string, encoding, false, dest, destPos)
-}
-
-/**
- * Encodes the given string into a byte sequence at the supplied position, including any byte-order marker, using the encoding scheme provided.
- *
- * @param string: The input string
- * @param encoding: The encoding to use
- * @param dest: The byte sequence that will be copied
- * @param destPos: The location in the byte sequence to write the output
- * @returns A copy of the input bytes with the encoded string replaced at the given position
+ * @throws InvalidArgument(String): When `destPos` is not an integer
+ * @throws InvalidArgument(String): When `destPos` is negative
  *
  * @since v0.4.0
+ * @history v0.6.0: Added `includeBom` default argument
  */
-export let encodeAtWithBom = (string, encoding, dest, destPos) => {
-  encodeAtHelp(string, encoding, true, dest, destPos)
+provide let encodeAt = (string, encoding, dest, destPos, includeBom=false) => {
+  encodeAtHelp(string, encoding, includeBom, dest, destPos)
 }
 
 @unsafe
 let encodeHelp = (string: String, encoding: Encoding, includeBom: Bool) => {
-  let size = encodedLength(string, encoding) +
-    (if (includeBom) {
-      match (encoding) {
-        UTF8 => 3,
-        UTF16_LE => 2,
-        UTF16_BE => 2,
-        UTF32_LE => 4,
-        UTF32_BE => 4,
-      }
-    } else {
-      0
-    })
-  let (>>>) = WasmI32.shrU
+  let size = encodedLength(string, encoding) + (if (includeBom) {
+    match (encoding) {
+      UTF8 => 3,
+      UTF16_LE => 2,
+      UTF16_BE => 2,
+      UTF32_LE => 4,
+      UTF32_BE => 4,
+    }
+  } else {
+    0
+  })
+  use WasmI32.{ (>>>) }
   let bytes = WasmI32.toGrain(allocateBytes(WasmI32.fromGrain(size) >>> 1n))
   encodeAtHelp(string, encoding, includeBom, bytes, 0)
 }
 
 /**
- * Encodes the given string using the given encoding scheme, excluding any byte-order marker.
+ * Encodes the given string using the given encoding scheme.
  *
  * @param string: The input string
  * @param encoding: The encoding to use
+ * @param includeBom: Whether or not to include a byte order marker (false by default)
  * @returns The byte representation of the string in the given encoding
  *
  * @since v0.4.0
+ * @history v0.6.0: Added `includeBom` default argument
  */
-export let encode = (string: String, encoding: Encoding) => {
-  encodeHelp(string, encoding, false)
-}
-
-/**
- * Encodes the given string using the given encoding scheme, including any byte-order marker.
- *
- * @param string: The input string
- * @param encoding: The encoding to use
- * @returns The byte representation of the string in the given encoding
- *
- * @since v0.4.0
- */
-export let encodeWithBom = (string: String, encoding: Encoding) => {
-  encodeHelp(string, encoding, true)
+provide let encode = (string: String, encoding: Encoding, includeBom=false) => {
+  encodeHelp(string, encoding, includeBom)
 }
 
 // Byte->String decoding and helper functions:
 
 @unsafe
 let writeUtf8CodePoint = (ptr, codePoint) => {
-  let (>>>) = WasmI32.shrU
-  let (-) = WasmI32.sub
-  let (&) = WasmI32.and
-  let (|) = WasmI32.or
-  let (+) = WasmI32.add
-  let (<) = WasmI32.ltU
-  let (<=) = WasmI32.leU
-  let (==) = WasmI32.eq
+  use WasmI32.{ (+), (-), (&), (|), (>>>), ltU as (<), leU as (<=), (==) }
   if (codePoint <= 0x007Fn) {
     // Code points in the ASCII range are written as just one byte with the
     // leading bit equal to zero (0xxxxxxx). Just store the value as one byte
@@ -1573,9 +1468,7 @@ let writeUtf8CodePoint = (ptr, codePoint) => {
 
 @unsafe
 let bytesHaveBom = (bytes: Bytes, encoding: Encoding, start: WasmI32) => {
-  let (+) = WasmI32.add
-  let (==) = WasmI32.eq
-  let (>=) = WasmI32.geU
+  use WasmI32.{ (+), geU as (>=), (==) }
   let ptr = WasmI32.fromGrain(bytes)
   let bytesSize = WasmI32.load(ptr, 4n)
   let ptr = ptr + start
@@ -1614,25 +1507,26 @@ let bytesHaveBom = (bytes: Bytes, encoding: Encoding, start: WasmI32) => {
 }
 
 @unsafe
-let decodedLength =
-  (
-    bytes: Bytes,
-    encoding: Encoding,
-    start: WasmI32,
-    size: WasmI32,
-  ) => {
-  let (+) = WasmI32.add
-  let (-) = WasmI32.sub
-  let (==) = WasmI32.eq
-  let (!=) = WasmI32.ne
-  let (<) = WasmI32.ltU
-  let (>) = WasmI32.gtU
-  let (|) = WasmI32.or
-  let (&) = WasmI32.and
-  let (>>>) = WasmI32.shrU
-  let (<<) = WasmI32.shl
-  let (>=) = WasmI32.geU
-  let (<=) = WasmI32.leU
+let decodedLength = (
+  bytes: Bytes,
+  encoding: Encoding,
+  start: WasmI32,
+  size: WasmI32,
+) => {
+  use WasmI32.{
+    (+),
+    (-),
+    (&),
+    (|),
+    (>>>),
+    (<<),
+    ltU as (<),
+    gtU as (>),
+    geU as (>=),
+    leU as (<=),
+    (==),
+    (!=),
+  }
   let ptr = WasmI32.fromGrain(bytes)
   let bytesSize = {
     let tmp = WasmI32.load(ptr, 4n) - start
@@ -1783,24 +1677,25 @@ let decodedLength =
 }
 
 @unsafe
-let decodeRangeHelp =
-  (
-    bytes: Bytes,
-    encoding: Encoding,
-    skipBom: Bool,
-    start: Number,
-    size: Number,
-  ) => {
-  let (+) = WasmI32.add
-  let (-) = WasmI32.sub
-  let (<) = WasmI32.ltU
-  let (|) = WasmI32.or
-  let (&) = WasmI32.and
-  let (>>>) = WasmI32.shrU
-  let (<<) = WasmI32.shl
-  let (>=) = WasmI32.geU
-  let (<=) = WasmI32.leU
-  let (==) = WasmI32.eq
+let decodeRangeHelp = (
+  bytes: Bytes,
+  encoding: Encoding,
+  skipBom: Bool,
+  start: Number,
+  size: Number,
+) => {
+  use WasmI32.{
+    (+),
+    (-),
+    (&),
+    (|),
+    (>>>),
+    (<<),
+    ltU as (<),
+    geU as (>=),
+    leU as (<=),
+    (==),
+  }
   let start = grainToWasmNumber(start, _START_NAME)
   let size = grainToWasmNumber(size, _SIZE_NAME)
   let hasBom = bytesHaveBom(bytes, encoding, start)
@@ -1844,8 +1739,10 @@ let decodeRangeHelp =
           let codeWord = if (w1 >= 0xD800n && w1 <= 0xDBFFn) {
             // high surrogate. next character is low srurrogate
             let w1 = (w1 & 0x03FFn) << 10n
-            let w2 = (WasmI32.load8U(bytesPtr, 2n) << 8n |
-              WasmI32.load8U(bytesPtr, 3n)) &
+            let w2 = (
+              WasmI32.load8U(bytesPtr, 2n) << 8n |
+              WasmI32.load8U(bytesPtr, 3n)
+            ) &
               0x03FFn
             let codeWord = w1 + w2 + 0x10000n
             // no problems, so go past both code words
@@ -1867,8 +1764,10 @@ let decodeRangeHelp =
           let codeWord = if (w1 >= 0xD800n && w1 <= 0xDBFFn) {
             // high surrogate. next character is low srurrogate
             let w1 = (w1 & 0x03FFn) << 10n
-            let w2 = (WasmI32.load8U(bytesPtr, 3n) << 8n |
-              WasmI32.load8U(bytesPtr, 2n)) &
+            let w2 = (
+              WasmI32.load8U(bytesPtr, 3n) << 8n |
+              WasmI32.load8U(bytesPtr, 2n)
+            ) &
               0x03FFn
             //let uPrime = codePoint - 0x10000n
             //let w1 = ((uPrime & 0b11111111110000000000n) >>> 10n) + 0xD800n // High surrogate
@@ -1912,45 +1811,31 @@ let decodeRangeHelp =
 }
 
 /**
- * Decodes the given byte sequence of the specified range into a string, excluding any byte-order marker, using encoding scheme provided.
+ * Decodes the given byte sequence of the specified range into a string using the encoding scheme provided.
  *
  * @param bytes: The input bytes
  * @param encoding: The encoding to use
  * @param start: The byte offset to begin decoding from
  * @param size: The maximum number of bytes to decode
+ * @param keepBom: Whether or not to include a byte order marker (false by default)
  * @returns The decoded string
  *
- * @since v0.4.0
- */
-export let decodeRange =
-  (
-    bytes: Bytes,
-    encoding: Encoding,
-    start: Number,
-    size: Number,
-  ) => {
-  decodeRangeHelp(bytes, encoding, true, start, size)
-}
-
-/**
- * Decodes the given byte sequence of the specified range into a string, including any byte-order marker, using encoding scheme provided.
- *
- * @param bytes: The input bytes
- * @param encoding: The encoding to use
- * @param start: The byte offset to begin decoding from
- * @param size: The maximum number of bytes to decode
- * @returns The decoded string
+ * @throws InvalidArgument(String): When `start` is not an integer
+ * @throws InvalidArgument(String): When `start` is negative
+ * @throws InvalidArgument(String): When `size` is not an integer
+ * @throws InvalidArgument(String): When `size` is negative
  *
  * @since v0.4.0
+ * @history v0.6.0: Added `keepBom` default argument
  */
-export let decodeRangeKeepBom =
-  (
-    bytes: Bytes,
-    encoding: Encoding,
-    start: Number,
-    size: Number,
-  ) => {
-  decodeRangeHelp(bytes, encoding, false, start, size)
+provide let decodeRange = (
+  bytes: Bytes,
+  encoding: Encoding,
+  start: Number,
+  size: Number,
+  keepBom=false,
+) => {
+  decodeRangeHelp(bytes, encoding, !keepBom, start, size)
 }
 
 @unsafe
@@ -1961,29 +1846,18 @@ let decodeHelp = (bytes: Bytes, encoding: Encoding, skipBom: Bool) => {
 }
 
 /**
- * Decodes the given byte sequence into a string using the given encoding scheme, excluding any byte-order marker.
+ * Decodes the given byte sequence into a string using the given encoding scheme.
  *
  * @param bytes: The input bytes
  * @param encoding: The encoding to use
+ * @param keepBom: Whether or not to include a byte order marker (false by default)
  * @returns The decoded string
  *
  * @since v0.4.0
+ * @history v0.6.0: Added `keepBom` default argument
  */
-export let decode = (bytes: Bytes, encoding: Encoding) => {
-  decodeHelp(bytes, encoding, true)
-}
-
-/**
- * Decodes the given byte sequence into a string using the given encoding scheme, including any byte-order marker.
- *
- * @param bytes: The input bytes
- * @param encoding: The encoding to use
- * @returns The decoded string
- *
- * @since v0.4.0
- */
-export let decodeKeepBom = (bytes: Bytes, encoding: Encoding) => {
-  decodeHelp(bytes, encoding, false)
+provide let decode = (bytes: Bytes, encoding: Encoding, keepBom=false) => {
+  decodeHelp(bytes, encoding, !keepBom)
 }
 
 /**
@@ -1997,14 +1871,8 @@ export let decodeKeepBom = (bytes: Bytes, encoding: Encoding) => {
  * @since v0.4.0
  */
 @unsafe
-export let forEachCodePoint = (fn: Number -> Void, str: String) => {
-  let (>>>) = WasmI32.shrU
-  let (-) = WasmI32.sub
-  let (&) = WasmI32.and
-  let (<) = WasmI32.ltU
-  let (<=) = WasmI32.leU
-  let (==) = WasmI32.eq
-  let (+) = WasmI32.add
+provide let forEachCodePoint = (fn: Number => Void, str: String) => {
+  use WasmI32.{ (+), (-), (&), (>>>), ltU as (<), leU as (<=), (==) }
 
   let strPtr = WasmI32.fromGrain(str)
 
@@ -2055,14 +1923,8 @@ export let forEachCodePoint = (fn: Number -> Void, str: String) => {
  * @since v0.4.0
  */
 @unsafe
-export let forEachCodePointi = (fn: (Number, Number) -> Void, str: String) => {
-  let (>>>) = WasmI32.shrU
-  let (-) = WasmI32.sub
-  let (&) = WasmI32.and
-  let (<) = WasmI32.ltU
-  let (<=) = WasmI32.leU
-  let (==) = WasmI32.eq
-  let (+) = WasmI32.add
+provide let forEachCodePointi = (fn: (Number, Number) => Void, str: String) => {
+  use WasmI32.{ (+), (-), (&), (>>>), ltU as (<), leU as (<=), (==) }
 
   let strPtr = WasmI32.fromGrain(str)
 
@@ -2101,19 +1963,10 @@ export let forEachCodePointi = (fn: (Number, Number) -> Void, str: String) => {
 }
 
 @unsafe
-let trimString = (str: String, fromEnd: Bool) => {
-  let (>>>) = WasmI32.shrU
-  let (+) = WasmI32.add
-  let (*) = WasmI32.mul
-  let (-) = WasmI32.sub
-  let (<) = WasmI32.ltU
-  let (==) = WasmI32.eq
-  let (!=) = WasmI32.ne
-
-  let mut stringPtr = WasmI32.fromGrain(str)
-  let byteLength = WasmI32.load(stringPtr, 4n)
-  stringPtr += 8n
-  let mut i = 0n, offset = 1n
+let trimString = (stringPtr: WasmI32, byteLength: WasmI32, fromEnd: Bool) => {
+  use WasmI32.{ (+), (-), (*), (>>>), ltU as (<), (==), (!=) }
+  let mut i = 0n
+  and offset = 1n
   if (fromEnd) {
     i = byteLength - 1n
     offset = -1n
@@ -2157,14 +2010,7 @@ let trimString = (str: String, fromEnd: Bool) => {
     }
     count += 1n
   }
-  let str = allocateString(byteLength - count)
-  // Copy the string
-  if (fromEnd) {
-    Memory.copy(str + 8n, stringPtr, byteLength - count)
-  } else {
-    Memory.copy(str + 8n, stringPtr + count, byteLength - count)
-  }
-  WasmI32.toGrain(str): String
+  count
 }
 /**
  * Trims the beginning of a string—removing any leading whitespace characters.
@@ -2176,7 +2022,17 @@ let trimString = (str: String, fromEnd: Bool) => {
  *
  * @since v0.4.2
  */
-export let trimStart = (string: String) => trimString(string, false)
+@unsafe
+provide let trimStart = (string: String) => {
+  use WasmI32.{ (-), (+) }
+  let mut stringPtr = WasmI32.fromGrain(string)
+  let byteLength = WasmI32.load(stringPtr, 4n)
+  stringPtr += 8n
+  let count = trimString(stringPtr, byteLength, false)
+  let str = allocateString(byteLength - count)
+  Memory.copy(str + 8n, stringPtr + count, byteLength - count)
+  WasmI32.toGrain(str): String
+}
 /**
  * Trims the end of a string—removing any trailing whitespace characters.
  *
@@ -2187,7 +2043,17 @@ export let trimStart = (string: String) => trimString(string, false)
  *
  * @since v0.4.2
  */
-export let trimEnd = (string: String) => trimString(string, true)
+@unsafe
+provide let trimEnd = (string: String) => {
+  use WasmI32.{ (-), (+) }
+  let mut stringPtr = WasmI32.fromGrain(string)
+  let byteLength = WasmI32.load(stringPtr, 4n)
+  stringPtr += 8n
+  let count = trimString(stringPtr, byteLength, true)
+  let str = allocateString(byteLength - count)
+  Memory.copy(str + 8n, stringPtr, byteLength - count)
+  WasmI32.toGrain(str): String
+}
 /**
  * Trims a string—removing all leading and trailing whitespace characters.
  *
@@ -2198,4 +2064,58 @@ export let trimEnd = (string: String) => trimString(string, true)
  *
  * @since v0.4.2
  */
-export let trim = (string: String) => trimEnd(trimStart(string))
+@unsafe
+provide let trim = (string: String) => {
+  use WasmI32.{ (-), (+), (==) }
+  let mut stringPtr = WasmI32.fromGrain(string)
+  let byteLength = WasmI32.load(stringPtr, 4n)
+  stringPtr += 8n
+  let startCount = trimString(stringPtr, byteLength, false)
+  if (startCount == byteLength) return ""
+  let endCount = trimString(stringPtr, byteLength, true)
+  let str = allocateString(byteLength - startCount - endCount)
+  Memory.copy(
+    str + 8n,
+    stringPtr + startCount,
+    byteLength - startCount - endCount
+  )
+  return WasmI32.toGrain(str): String
+}
+
+/**
+ * Converts all ASCII uppercase characters in the string to lowercase.
+ *
+ * @param string: The string to convert
+ * @returns The lowercased string
+ *
+ * @example assert String.toAsciiLowercase("aBc123") == "abc123"
+ *
+ * @since v0.6.0
+ */
+provide let toAsciiLowercase = string => {
+  let chars = explode(string)
+  let len = arrayLength(chars)
+  for (let mut i = 0; i < len; i += 1) {
+    chars[i] = Char.toAsciiLowercase(chars[i])
+  }
+  implode(chars)
+}
+
+/**
+ * Converts all ASCII lowercase characters in the string to uppercase.
+ *
+ * @param string: The string to convert
+ * @returns The uppercased string
+ *
+ * @example assert String.toAsciiUppercase("aBc123") == "ABC123"
+ *
+ * @since v0.6.0
+ */
+provide let toAsciiUppercase = string => {
+  let chars = explode(string)
+  let len = arrayLength(chars)
+  for (let mut i = 0; i < len; i += 1) {
+    chars[i] = Char.toAsciiUppercase(chars[i])
+  }
+  implode(chars)
+}