@grain/stdlib 0.5.3 → 0.5.4

package/string.gr

@@ -872,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
@@ -1349,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
     },
   }
 }
@@ -1612,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
@@ -1635,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
@@ -1867,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.

package/string.md

@@ -514,6 +514,105 @@ Examples:
 String.endsWith("world", "Hello world") == true
 ```
 
+### String.**replaceFirst**
+
+<details disabled>
+<summary tabindex="-1">Added in <code>0.5.4</code></summary>
+No other changes yet.
+</details>
+
+```grain
+replaceFirst : (String, String, String) -> String
+```
+
+Replaces the first appearance of the search pattern in the string with the replacement value.
+
+Parameters:
+
+|param|type|description|
+|-----|----|-----------|
+|`searchPattern`|`String`|The string to replace|
+|`replacement`|`String`|The replacement|
+|`string`|`String`|The string to change|
+
+Returns:
+
+|type|description|
+|----|-----------|
+|`String`|A new string with the first occurrence of the search pattern replaced|
+
+Examples:
+
+```grain
+String.replaceFirst("🌾", "🌎", "Hello 🌾🌾") == "Hello 🌎🌾"
+```
+
+### String.**replaceLast**
+
+<details disabled>
+<summary tabindex="-1">Added in <code>0.5.4</code></summary>
+No other changes yet.
+</details>
+
+```grain
+replaceLast : (String, String, String) -> String
+```
+
+Replaces the last appearance of the search pattern in the string with the replacement value.
+
+Parameters:
+
+|param|type|description|
+|-----|----|-----------|
+|`searchPattern`|`String`|The string to replace|
+|`replacement`|`String`|The replacement|
+|`string`|`String`|The string to change|
+
+Returns:
+
+|type|description|
+|----|-----------|
+|`String`|A new string with the last occurrence of the search pattern replaced|
+
+Examples:
+
+```grain
+String.replaceLast("🌾", "🌎", "Hello 🌾🌾") == "Hello 🌾🌎"
+```
+
+### String.**replaceAll**
+
+<details disabled>
+<summary tabindex="-1">Added in <code>0.5.4</code></summary>
+No other changes yet.
+</details>
+
+```grain
+replaceAll : (String, String, String) -> String
+```
+
+Replaces every appearance of the search pattern in the string with the replacement value.
+
+Parameters:
+
+|param|type|description|
+|-----|----|-----------|
+|`searchPattern`|`String`|The string to replace|
+|`replacement`|`String`|The replacement|
+|`string`|`String`|The string to change|
+
+Returns:
+
+|type|description|
+|----|-----------|
+|`String`|A new string with each occurrence of the search pattern replaced|
+
+Examples:
+
+```grain
+String.replaceAll("🌾", "🌎", "Hello 🌾🌾") == "Hello 🌎🌎"
+```
+
 ### String.**encodeAt**
 
 <details disabled>

package/sys/file.gr

@@ -816,7 +816,7 @@ export let fdStats = (fd: FileDescriptor) => {
       let rightsInheriting = WasmI64.load(structPtr, 16n)
       (rightsInheriting &
         1N << WasmI64.extendI32U(WasmI32.fromGrain(i) >> 1n)) >
-      0N
+        0N
     }
     let rightsInheritingList = List.filteri(flagsToWasmVal, orderedRights)