@grain/stdlib 0.5.3 → 0.5.5

package/set.gr

@@ -2,7 +2,7 @@
  * @module Set: A Set is an unordered collection of unique values. Operations on a Set mutate the internal state, so it never needs to be re-assigned.
  * @example import Set from "set"
  * 
- * @since 0.3.0
+ * @since v0.3.0
  */
 import List from "list"
 import Array from "array"
@@ -33,7 +33,7 @@ record Set<k> {
  * @param size: The initial storage size of the set
  * @returns An empty set with the given initial storage size
  * 
- * @since 0.3.0
+ * @since v0.3.0
  */
 export let makeSized = size => {
   let buckets = Array.make(size, None)
@@ -44,7 +44,7 @@ export let makeSized = size => {
  *
  * @returns An empty set
  * 
- * @since 0.3.0
+ * @since v0.3.0
  */
 export let make = () => {
   makeSized(16)
@@ -121,7 +121,7 @@ let rec nodeInBucket = (key, node) => {
  * @param key: The value to add
  * @param set: The set to update
  * 
- * @since 0.3.0
+ * @since v0.3.0
  */
 export let add = (key, set) => {
   let buckets = set.buckets
@@ -154,7 +154,7 @@ export let add = (key, set) => {
  * @param set: The set to search
  * @returns `true` if the set contains the given value or `false` otherwise
  * 
- * @since 0.3.0
+ * @since v0.3.0
  */
 export let contains = (key, set) => {
   let buckets = set.buckets
@@ -186,7 +186,7 @@ let rec removeInBucket = (key, node) => {
  * @param key: The value to remove
  * @param set: The set to update
  * 
- * @since 0.3.0
+ * @since v0.3.0
  */
 export let remove = (key, set) => {
   let buckets = set.buckets
@@ -214,7 +214,7 @@ export let remove = (key, set) => {
  * @param set: The set to inspect
  * @returns The count of elements in the set
  * 
- * @since 0.3.0
+ * @since v0.3.0
  */
 export let size = set => {
   set.size
@@ -226,7 +226,7 @@ export let size = set => {
  * @param set: The set to inspect
  * @returns `true` if the given set is empty or `false` otherwise
  * 
- * @since 0.3.0
+ * @since v0.3.0
  */
 export let isEmpty = set => {
   size(set) == 0
@@ -237,7 +237,7 @@ export let isEmpty = set => {
  *
  * @param set: The set to reset
  * 
- * @since 0.3.0
+ * @since v0.3.0
  */
 export let clear = set => {
   set.size = 0
@@ -263,7 +263,7 @@ let rec forEachBucket = (fn, node) => {
  * @param fn: The iterator function to call with each element
  * @param set: The set to iterate
  * 
- * @since 0.3.0
+ * @since v0.3.0
  * @history v0.5.0: Ensured the iterator function return type is always `Void`
  */
 export let forEach = (fn, set) => {
@@ -288,7 +288,7 @@ let rec reduceEachBucket = (fn, node, acc) => {
  * @param set: The set to iterate
  * @returns The final accumulator returned from `fn`
  * 
- * @since 0.3.0
+ * @since v0.3.0
  */
 export let reduce = (fn, init, set) => {
   let buckets = set.buckets
@@ -305,10 +305,10 @@ export let reduce = (fn, init, set) => {
  * @param fn: The predicate function to indicate which elements to remove from the set, where returning `false` indicates the value should be removed
  * @param set: The set to iterate
  * 
- * @since 0.3.0
+ * @since v0.3.0
  */
-export let filter = (predicate, set) => {
-  let keysToRemove = reduce((list, key) => if (!predicate(key)) {
+export let filter = (fn, set) => {
+  let keysToRemove = reduce((list, key) => if (!fn(key)) {
     [key, ...list]
   } else {
     list
@@ -324,10 +324,10 @@ export let filter = (predicate, set) => {
  * @param fn: The predicate function to indicate which elements to remove from the set, where returning `true` indicates the value should be removed
  * @param set: The set to iterate
  * 
- * @since 0.3.0
+ * @since v0.3.0
  */
-export let reject = (predicate, set) => {
-  filter(key => !predicate(key), set)
+export let reject = (fn, set) => {
+  filter(key => !fn(key), set)
 }
 
 /**
@@ -336,7 +336,7 @@ export let reject = (predicate, set) => {
  * @param set: The set to convert
  * @returns A list containing all set values
  * 
- * @since 0.3.0
+ * @since v0.3.0
  */
 export let toList = set => {
   reduce((list, key) => [key, ...list], [], set)
@@ -348,7 +348,7 @@ export let toList = set => {
  * @param list: The list to convert
  * @returns A set containing all list values
  * 
- * @since 0.3.0
+ * @since v0.3.0
  */
 export let fromList = list => {
   let set = make()
@@ -364,7 +364,7 @@ export let fromList = list => {
  * @param set: The set to convert
  * @returns An array containing all set values
  * 
- * @since 0.3.0
+ * @since v0.3.0
  */
 export let toArray = set => {
   Array.fromList(toList(set))
@@ -376,7 +376,7 @@ export let toArray = set => {
  * @param array: The array to convert
  * @returns A set containing all array values
  * 
- * @since 0.3.0
+ * @since v0.3.0
  */
 export let fromArray = array => {
   let set = make()
@@ -393,7 +393,7 @@ export let fromArray = array => {
  * @param set2: The second set to combine
  * @returns A set containing all elements of both sets
  * 
- * @since 0.3.0
+ * @since v0.3.0
  */
 export let union = (set1, set2) => {
   let set = make()
@@ -413,7 +413,7 @@ export let union = (set1, set2) => {
  * @param set2: The second set to combine
  * @returns A set containing only unshared elements from both sets
  * 
- * @since 0.3.0
+ * @since v0.3.0
  */
 export let diff = (set1, set2) => {
   let set = make()
@@ -437,7 +437,7 @@ export let diff = (set1, set2) => {
  * @param set2: The second set to combine
  * @returns A set containing only shared elements from both sets
  * 
- * @since 0.3.0
+ * @since v0.3.0
  */
 export let intersect = (set1, set2) => {
   let set = make()
@@ -461,7 +461,7 @@ export let intersect = (set1, set2) => {
  * @param set: The set to inspect
  * @returns The internal state of the set
  * 
- * @since 0.3.0
+ * @since v0.3.0
  */
 export let getInternalStats = set => {
   (set.size, Array.length(set.buckets))

package/stack.gr

@@ -1,6 +1,8 @@
 /**
  * @module Stack: An immutable stack implementation. A stack is a LIFO (last-in-first-out) data structure where new values are added, retrieved, and removed from the end.
  * @example import Stack from "stack"
+ *
+ * @deprecated This module will be renamed to ImmutableStack in the v0.6.0 release of Grain.
  */
 
 import List from "list"
@@ -20,10 +22,22 @@ record Stack<a> {
  * @section Values: Functions and constants included in the Stack module.
  */
 
+/**
+ * An empty stack.
+ *
+ * @since v0.5.4
+ */
+export let empty = {
+  let empty = { data: [], }
+  empty
+}
+
 /**
  * Creates a new stack.
  *
  * @returns An empty stack
+ *
+ * @deprecated This will be removed in the v0.6.0 release of Grain.
  */
 export let make = () => {
   { data: [], }

package/stack.md

@@ -2,6 +2,8 @@
 title: Stack
 ---
 
+> **Deprecated:** This module will be renamed to ImmutableStack in the v0.6.0 release of Grain.
+
 An immutable stack implementation. A stack is a LIFO (last-in-first-out) data structure where new values are added, retrieved, and removed from the end.
 
 ```grain
@@ -24,8 +26,23 @@ Stacks are immutable data structures that store their data in a List.
 
 Functions and constants included in the Stack module.
 
+### Stack.**empty**
+
+<details disabled>
+<summary tabindex="-1">Added in <code>0.5.4</code></summary>
+No other changes yet.
+</details>
+
+```grain
+empty : Stack<a>
+```
+
+An empty stack.
+
 ### Stack.**make**
 
+> **Deprecated:** This will be removed in the v0.6.0 release of Grain.
+
 ```grain
 make : () -> Stack<a>
 ```

package/string.gr

@@ -221,7 +221,7 @@ export let lastIndexOf = (search: String, string: String) => {
   }
 }
 
-@disableGC
+@unsafe
 let getCodePoint = (ptr: WasmI32) => {
   // Algorithm from https://encoding.spec.whatwg.org/#utf-8-decoder
   let (+) = WasmI32.add
@@ -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.