@grain/stdlib 0.5.2 → 0.5.4

package/string.gr

@@ -11,6 +11,7 @@ import Memory from "runtime/unsafe/memory"
 import Exception from "runtime/exception"
 import Conv from "runtime/unsafe/conv"
 import {
+  untagSimpleNumber,
   tagSimpleNumber,
   tagChar,
   untagChar,
@@ -100,7 +101,7 @@ export let byteLength = (string: String) => {
 }
 
 /**
- * Finds the position of a substring in the input string.
+ * Finds the first position of a substring in the input string.
  *
  * @param search: The substring to find
  * @param string: The string to inspect
@@ -161,6 +162,65 @@ export let indexOf = (search: String, string: String) => {
   }
 }
 
+/**
+ * Finds the last position of a substring in the input string.
+ *
+ * @param search: The substring to find
+ * @param string: The string to inspect
+ * @returns `Some(position)` containing the starting position of the substring if found or `None` otherwise
+ *
+ * @example String.lastIndexOf("world", "Hello world world") == Some(12)
+ *
+ * @since v0.5.3
+ */
+@unsafe
+export 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
+
+  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
+    }
+    if (matchIndex == -1n) {
+      None
+    } else {
+      Some(tagSimpleNumber(matchIndex))
+    }
+  }
+}
+
 @disableGC
 let getCodePoint = (ptr: WasmI32) => {
   // Algorithm from https://encoding.spec.whatwg.org/#utf-8-decoder
@@ -221,19 +281,9 @@ let getCodePoint = (ptr: WasmI32) => {
   }
   result
 }
-/**
- * Get the character at the position in the input string.
- *
- * @param position: The position to check
- * @param string: The string to search
- * @returns The character at the provided position
- *
- * @example String.charAt(5, "Hello world") == ' '
- *
- * @since v0.4.0
- */
+
 @unsafe
-export let charAt = (position, string: String) => {
+let charAtHelp = (position, string: String) => {
   if (length(string) <= position || position < 0) {
     fail "Invalid offset: " ++ toString(position)
   }
@@ -249,10 +299,10 @@ export let charAt = (position, string: String) => {
   let mut ptr = string + 8n
   let end = ptr + size
   let mut counter = 0n
-  let mut result = WasmI32.toGrain(0n): Char
+  let mut result = 0n
   while (ptr < end) {
     if (counter == position) {
-      result = tagChar(getCodePoint(ptr))
+      result = getCodePoint(ptr)
       break
     }
     let byte = WasmI32.load8U(ptr, 0n)
@@ -274,6 +324,38 @@ export let charAt = (position, string: String) => {
   result
 }
 
+/**
+ * Get the Unicode code point at the position in the input string.
+ *
+ * @param position: The position to check
+ * @param string: The string to search
+ * @returns The character code at the provided position
+ *
+ * @example String.charCodeAt(5, "Hello world") == 32
+ *
+ * @since v0.5.3
+ */
+@unsafe
+export let charCodeAt = (position, string: String) => {
+  tagSimpleNumber(charAtHelp(position, string))
+}
+
+/**
+ * Get the character at the position in the input string.
+ *
+ * @param position: The position to check
+ * @param string: The string to search
+ * @returns The character at the provided position
+ *
+ * @example String.charAt(5, "Hello world") == ' '
+ *
+ * @since v0.4.0
+ */
+@unsafe
+export let charAt = (position, string: String) => {
+  tagChar(charAtHelp(position, string))
+}
+
 @unsafe
 let explodeHelp = (s: String, chars) => {
   let (>>>) = WasmI32.shrU
@@ -790,6 +872,239 @@ export let endsWith = (search: String, string: String) => {
   }
 }
 
+/**
+ * Replaces the first appearance of the search pattern in the string with the replacement value.
+ *
+ * @param searchPattern: The string to replace
+ * @param replacement: The replacement
+ * @param string: The string to change
+ * @returns A new string with the first occurrence of the search pattern replaced
+ *
+ * @example String.replaceFirst("🌾", "🌎", "Hello 🌾🌾") == "Hello 🌎🌾"
+ *
+ * @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
+
+  let mut patternPtr = WasmI32.fromGrain(searchPattern)
+  let mut stringPtr = WasmI32.fromGrain(string)
+  let mut replacementPtr = WasmI32.fromGrain(replacement)
+
+  let patternLen = WasmI32.load(patternPtr, 4n)
+  let stringLen = WasmI32.load(stringPtr, 4n)
+  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) {
+      // Create the new string
+      let str = allocateString(stringLen - patternLen + replacementLen)
+      let strPtr = str + 8n
+      Memory.copy(strPtr, stringPtr, foundIndex)
+      Memory.copy(strPtr + foundIndex, replacementPtr, replacementLen)
+      Memory.copy(
+        strPtr + foundIndex + replacementLen,
+        stringPtr + foundIndex + patternLen,
+        stringLen - foundIndex
+      )
+      // Copy over the str
+      WasmI32.toGrain(str): String
+    } else {
+      string
+    }
+  }
+}
+
+/**
+ * Replaces the last appearance of the search pattern in the string with the replacement value.
+ *
+ * @param searchPattern: The string to replace
+ * @param replacement: The replacement
+ * @param string: The string to change
+ * @returns A new string with the last occurrence of the search pattern replaced
+ *
+ * @example String.replaceLast("🌾", "🌎", "Hello 🌾🌾") == "Hello 🌾🌎"
+ *
+ * @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
+
+  let mut patternPtr = WasmI32.fromGrain(searchPattern)
+  let mut stringPtr = WasmI32.fromGrain(string)
+  let mut replacementPtr = WasmI32.fromGrain(replacement)
+
+  let patternLen = WasmI32.load(patternPtr, 4n)
+  let stringLen = WasmI32.load(stringPtr, 4n)
+  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 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) {
+      // Create the new string
+      let str = allocateString(stringLen - patternLen + replacementLen)
+      let strPtr = str + 8n
+      Memory.copy(strPtr, stringPtr, foundIndex)
+      Memory.copy(strPtr + foundIndex, replacementPtr, replacementLen)
+      Memory.copy(
+        strPtr + foundIndex + replacementLen,
+        stringPtr + foundIndex + patternLen,
+        stringLen - foundIndex
+      )
+      // Copy over the str
+      WasmI32.toGrain(str): String
+    } else {
+      string
+    }
+  }
+}
+
+/**
+ * Replaces every appearance of the search pattern in the string with the replacement value.
+ *
+ * @param searchPattern: The string to replace
+ * @param replacement: The replacement
+ * @param string: The string to change
+ * @returns A new string with each occurrence of the search pattern replaced
+ *
+ * @example String.replaceAll("🌾", "🌎", "Hello 🌾🌾") == "Hello 🌎🌎"
+ *
+ * @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
+
+  let mut patternPtr = WasmI32.fromGrain(searchPattern)
+  let mut stringPtr = WasmI32.fromGrain(string)
+  let mut replacementPtr = WasmI32.fromGrain(replacement)
+
+  let patternLen = WasmI32.load(patternPtr, 4n)
+  let stringLen = WasmI32.load(stringPtr, 4n)
+  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 stringEndPtr = stringPtr + stringLen - patternLen
+    let mut foundIndex = stringLen - patternLen + 1n
+    let mut foundIndexes = []
+    let mut foundCount = 0n
+    for (let mut i = stringEndPtr; i > stringPtr - 1n; i -= 1n) {
+      // check for match
+      foundIndex -= 1n
+      if (Memory.compare(i, patternPtr, patternLen) == 0n) {
+        found = true
+        foundCount += 1n
+        foundIndexes = [tagSimpleNumber(foundIndex), ...foundIndexes]
+      }
+    }
+    if (found) {
+      // Create the new string
+      let str = allocateString(
+        stringLen - (patternLen - replacementLen) * foundCount
+      )
+      let mut strPtr = str + 8n
+      let mut lastIndex = 0n
+      while (true) {
+        match (foundIndexes) {
+          [idx, ...rest] => {
+            let index = untagSimpleNumber(idx)
+            // Copy the part before
+            Memory.copy(strPtr, stringPtr + lastIndex, index - lastIndex)
+            strPtr += index - lastIndex
+            // Copy the part after
+            Memory.copy(strPtr, replacementPtr, replacementLen)
+            strPtr += replacementLen
+            lastIndex = index + patternLen
+            foundIndexes = rest
+          },
+          [] => break,
+        }
+      }
+      // Copy remaining string
+      Memory.copy(strPtr, stringPtr + lastIndex, stringLen - lastIndex)
+      WasmI32.toGrain(str): String
+    } else {
+      string
+    }
+  }
+}
+
 // String->Byte encoding and helper functions:
 
 // these are globals to avoid memory leaks
@@ -1267,33 +1582,33 @@ let bytesHaveBom = (bytes: Bytes, encoding: Encoding, start: WasmI32) => {
   match (encoding) {
     UTF8 => {
       bytesSize >= 3n &&
-      WasmI32.load8U(ptr, _BYTES_OFFSET) == 0xEFn &&
-      WasmI32.load8U(ptr + 1n, _BYTES_OFFSET) == 0xBBn &&
-      WasmI32.load8U(ptr + 2n, _BYTES_OFFSET) == 0xBFn
+        WasmI32.load8U(ptr, _BYTES_OFFSET) == 0xEFn &&
+        WasmI32.load8U(ptr + 1n, _BYTES_OFFSET) == 0xBBn &&
+        WasmI32.load8U(ptr + 2n, _BYTES_OFFSET) == 0xBFn
     },
     UTF16_BE => {
       bytesSize >= 2n &&
-      WasmI32.load8U(ptr, _BYTES_OFFSET) == 0xFEn &&
-      WasmI32.load8U(ptr + 1n, _BYTES_OFFSET) == 0xFFn
+        WasmI32.load8U(ptr, _BYTES_OFFSET) == 0xFEn &&
+        WasmI32.load8U(ptr + 1n, _BYTES_OFFSET) == 0xFFn
     },
     UTF16_LE => {
       bytesSize >= 2n &&
-      WasmI32.load8U(ptr, _BYTES_OFFSET) == 0xFFn &&
-      WasmI32.load8U(ptr + 1n, _BYTES_OFFSET) == 0xFEn
+        WasmI32.load8U(ptr, _BYTES_OFFSET) == 0xFFn &&
+        WasmI32.load8U(ptr + 1n, _BYTES_OFFSET) == 0xFEn
     },
     UTF32_BE => {
       bytesSize >= 4n &&
-      WasmI32.load8U(ptr, _BYTES_OFFSET) == 0x00n &&
-      WasmI32.load8U(ptr + 1n, _BYTES_OFFSET) == 0x00n &&
-      WasmI32.load8U(ptr + 2n, _BYTES_OFFSET) == 0xFEn &&
-      WasmI32.load8U(ptr + 3n, _BYTES_OFFSET) == 0xFFn
+        WasmI32.load8U(ptr, _BYTES_OFFSET) == 0x00n &&
+        WasmI32.load8U(ptr + 1n, _BYTES_OFFSET) == 0x00n &&
+        WasmI32.load8U(ptr + 2n, _BYTES_OFFSET) == 0xFEn &&
+        WasmI32.load8U(ptr + 3n, _BYTES_OFFSET) == 0xFFn
     },
     UTF32_LE => {
       bytesSize >= 4n &&
-      WasmI32.load8U(ptr, _BYTES_OFFSET) == 0xFFn &&
-      WasmI32.load8U(ptr + 1n, _BYTES_OFFSET) == 0xFEn &&
-      WasmI32.load8U(ptr + 2n, _BYTES_OFFSET) == 0x00n &&
-      WasmI32.load8U(ptr + 3n, _BYTES_OFFSET) == 0x00n
+        WasmI32.load8U(ptr, _BYTES_OFFSET) == 0xFFn &&
+        WasmI32.load8U(ptr + 1n, _BYTES_OFFSET) == 0xFEn &&
+        WasmI32.load8U(ptr + 2n, _BYTES_OFFSET) == 0x00n &&
+        WasmI32.load8U(ptr + 3n, _BYTES_OFFSET) == 0x00n
     },
   }
 }
@@ -1530,7 +1845,7 @@ let 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
@@ -1553,7 +1868,7 @@ let 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
@@ -1785,30 +2100,71 @@ export let forEachCodePointi = (fn: (Number, Number) -> Void, str: String) => {
   void
 }
 
-let trimString = (str: String, end: Bool) => {
-  let chars = explode(str), charsLength = length(str)
-  let mut i = 0, offset = 1
-  if (end) {
-    i = charsLength - 1
-    offset = -1
+@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
+  if (fromEnd) {
+    i = byteLength - 1n
+    offset = -1n
   }
-  for (; i < charsLength && i > -1; i += offset) {
-    let currentChar = chars[i]
-    // TODO: Use unicode whitespace property and unicode line terminator once github issue #661 is completed
+  let mut count = 0n
+  for (; i < byteLength; i += offset) {
+    // Get the byte, not necessarily a full UTF-8 codepoint
+    let byte = WasmI32.load8U(stringPtr, i)
+    // TODO(#661): Use unicode whitespace property and unicode line terminator
+    if (!fromEnd) {
+      if (
+        byte == 0xEFn && // Check for the first BOM byte
+        // Check for the full BOM codepoint, 0xEFBBBF. Bytes are reversed because wasm is little-endian
+        WasmI32.load(stringPtr, i - 1n) >>> 8n == 0xBFBBEFn
+      ) {
+        i += 2n
+        count += 3n
+        continue
+      }
+    } else {
+      if (
+        byte == 0xBFn && // Check for the last BOM byte
+        // Check for the full BOM codepoint, 0xEFBBBF. Bytes are reversed because wasm is little-endian
+        WasmI32.load(stringPtr, i - 3n) >>> 8n == 0xBFBBEFn
+      ) {
+        i -= 2n
+        count += 3n
+        continue
+      }
+    }
     if (
-      // Spacing
-      currentChar != '\u{0009}' && // Tab
-      currentChar != '\u{000B}' && // LINE TABULATION
-      currentChar != '\u{000C}' && // FORM FEED (FF)
-      currentChar != '\u{0020}' && // Space
-      currentChar != '\u{00A0}' && // No Break Space
-      currentChar != '\u{FEFF}' && // ZERO WIDTH NO-BREAK SPACE
-      // Line Terminators
-      currentChar != '\n' && // LF
-      currentChar != '\r' // CR
-    ) break
+      byte != 0x20n && // Space
+      byte != 0x0Dn && // LF
+      byte != 0x0An && // CR
+      byte != 0x09n && // Tab
+      byte != 0x0Bn && // LINE TABULATION
+      byte != 0x0Cn && // FORM FEED (FF)
+      byte != 0xA0n // No Break Space
+    ) {
+      break
+    }
+    count += 1n
   }
-  if (end) slice(0, i + 1, str) else slice(i, charsLength, str)
+  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
 }
 /**
  * Trims the beginning of a string—removing any leading whitespace characters.