bfc8f08 | plum | pyrossh

git clone https://git.pyrossh.dev/plum

A statically typed, imperative programming language inspired by rust, python

bfc8f08 — Peter John 2026-11-01T21:42:35+05:30

perf: Str methods linear loops; plain-string replace/replaceAll/search/deburr; drop regex stubs

Files changed (1) hide show

plum-std/Str.plum +335 -135

plum-std/Str.plum CHANGED Viewed

@@ -4,6 +4,8 @@ import std/List
 import std/Buffer
 import std/Int
 import std/Float
+import std/Byte
+import std/ByteSlice
 # A Str is an immutable byte sequence, backed by a real `Buffer` in its
 # `data` field, not a compiler special case: `Str` is an ordinary
@@ -103,13 +105,24 @@ record Str(data: Buffer) =
   # Number of Unicode CHARACTERS (codepoints) — as opposed to `length`,
   # which counts bytes and only agrees with this for pure-ASCII text.
   fun runeLength(self) -> Int =
+    n := self.length()
+    i := 0
+    count := 0
+    while i < n
-    runeLengthFrom(self, 0, self.length(), 0)
+      i = i + self.codePointByteLength(i)
+      count = count + 1
+    return count
   # The `charIndex`-th Unicode character, re-encoded as its own (1-4 byte)
   # `Str`. Unlike `get` (which indexes by BYTE and can split a character in
   # half), this always returns a complete character.
   fun runeAt(self, charIndex: Int) -> Str =
+    i := 0
-    runeAtFrom(self, 0, charIndex)
+    k := charIndex
+    while k > 0
+      i = i + self.codePointByteLength(i)
+      k = k - 1
+    return self.sub(i, i + self.codePointByteLength(i))
   fun contains(self, search: Str) -> Bool =
     self.indexOf(search) >= 0
@@ -126,9 +139,6 @@ record Str(data: Buffer) =
       i = i + 1
     return -1
-  fun test(self, pattern: Regex) -> Bool =
-    todo
   fun startsWith(self, search: Str) -> Bool =
     matchesAt(self, search, 0, search.length())
@@ -150,38 +160,76 @@ record Str(data: Buffer) =
     else
       return error.BadBoolStr
-  fun matchPattern(self, pattern: Regex) -> List[Str] =
-    todo
-  fun matchAll(self, pattern: Regex) -> List[Str] =
-    todo
   # Pads the start of `self` with repeated copies of `sub` until its length is
   # at least `count`. If `sub` doesn't evenly divide the needed amount, the
   # final length may overshoot `count` by up to `sub.length() - 1`.
   fun padStart(self, sub: Str, count: Int) -> Str =
     if self.length() >= count || sub.length() == 0
       return self
+    buf := Buffer()
-    return {sub + self}.padStart(sub, count)
+    need := count - self.length()
+    written := 0
+    while written < need
+      buf.write(sub)
+      written = written + sub.length()
+    buf.write(self)
+    return buf.toStr()
   fun padEnd(self, sub: Str, count: Int) -> Str =
     if self.length() >= count || sub.length() == 0
       return self
+    buf := Buffer()
+    buf.write(self)
+    need := count - self.length()
+    written := 0
+    while written < need
+      buf.write(sub)
-    return {self + sub}.padEnd(sub, count)
+      written = written + sub.length()
+    return buf.toStr()
   fun repeat(self, count: Int) -> Str =
     if count <= 0
       return ""
+    buf := Buffer()
+    i := 0
+    while i < count
+      buf.write(self)
+      i = i + 1
-    return self + self.repeat(count - 1)
+    return buf.toStr()
-  fun replace(self, pattern: Regex, sub: Str) -> Str =
-    todo
+  # Replaces the FIRST occurrence of `old` with `new` (byte-exact). Returns
+  # `self` if `old` doesn't occur.
+  fun replace(self, old: Str, new: Str) -> Str =
+    idx := self.indexOf(old)
+    if idx < 0
+      return self
+    buf := Buffer()
+    buf.write(self.sub(0, idx))
+    buf.write(new)
+    buf.write(self.sub(idx + old.length(), self.length()))
+    return buf.toStr()
+  # Replaces every non-overlapping occurrence of `old`, scanning left to
+  # right. An empty `old` returns `self` unchanged.
-  fun replaceAll(self, pattern: Regex, sub: Str) -> Str =
+  fun replaceAll(self, old: Str, new: Str) -> Str =
+    m := old.length()
+    if m == 0
+      return self
+    n := self.length()
+    buf := Buffer()
+    i := 0
+    while i < n
+      if matchesAt(self, old, i, m)
+        buf.write(new)
+        i = i + m
-    todo
+      else
+        buf.writeByte(Byte(self.byteAt(i)))
+        i = i + 1
+    return buf.toStr()
+  # Byte index of the first occurrence of `sub`, or -1 (same as `indexOf`).
-  fun search(self, pattern: Regex) -> Str =
+  fun search(self, sub: Str) -> Int =
-    todo
+    self.indexOf(sub)
   # JS-`String.prototype.slice`-style: a negative `start`/`e` counts from the
   # end. Clamped to a valid range; `e` is exclusive.
@@ -231,22 +279,31 @@ record Str(data: Buffer) =
     en := if e > len then len else e
     if s >= en
       return ""
-    return self.get(s) + self.sub(s + 1, en)
+    return bytesToStr(self.data.data, s, en - s)
   fun toLower(self) -> Str =
-    mapCaseFrom(self, 0, self.length(), false)
+    mapCase(self, false)
   # Reverses a Str BY CHARACTER (codepoint), not by byte — reversing raw
   # UTF-8 bytes would scramble every multi-byte character's own byte order
   # along with the string's, corrupting any non-ASCII text.
   fun reverse(self) -> Str =
+    n := self.length()
+    out := makeBytes(n)
+    i := 0
+    while i < n
+      cl := self.codePointByteLength(i)
+      if i + cl > n
+        cl = n - i
+      copyBytes(out, n - i - cl, self.data.data, i, cl)
+      i = i + cl
-    reverseFrom(self, 0)
+    return bytesToStr(out, 0, n)
   fun camelCase(self) -> Str =
-    caseConvertFrom(self, 0, self.length(), "", 2, 0, 0)
+    caseConvert(self, "", 2)
   fun snakeCase(self) -> Str =
-    caseConvertFrom(self, 0, self.length(), "_", 1, 0, 0)
+    caseConvert(self, "_", 1)
   fun capitalize(self) -> Str =
     if self.length() == 0
@@ -254,7 +311,7 @@ record Str(data: Buffer) =
     return self.get(0).upperCase() + self.sub(1, self.length()).toLower()
   fun kebabCase(self) -> Str =
-    caseConvertFrom(self, 0, self.length(), "-", 1, 0, 0)
+    caseConvert(self, "-", 1)
   fun lowerCase(self) -> Str =
     self.toLower()
@@ -265,7 +322,7 @@ record Str(data: Buffer) =
     return self.get(0).toLower() + self.sub(1, self.length())
   fun upperCase(self) -> Str =
-    mapCaseFrom(self, 0, self.length(), true)
+    mapCase(self, true)
   fun upperFirst(self) -> Str =
     if self.length() == 0
@@ -273,19 +330,45 @@ record Str(data: Buffer) =
     return self.get(0).upperCase() + self.sub(1, self.length())
   fun startCase(self) -> Str =
-    caseConvertFrom(self, 0, self.length(), " ", 4, 0, 0)
+    caseConvert(self, " ", 4)
+  # Strips Latin-1 Supplement and Latin Extended-A diacritics to their ASCII
-  # Diacritic stripping needs a Unicode decomposition table (`é` -> `e`, ...) —
+  # base letters (`é` -> `e`, `ß` -> `ss`, `æ` -> `ae`, `Ł` -> `L`). Other
-  # far more than the ASCII byte-array `Str` primitives here support. Left as a
+  # characters (including `×`/`÷` and everything outside U+00C0..U+017F)
-  # known gap rather than a wrong "ASCII-only" approximation.
+  # pass through unchanged. Compact table, not exhaustive Unicode.
   fun deburr(self) -> Str =
+    n := self.length()
+    t1 := deburrLatin1()
+    t2 := deburrLatinExtA()
+    buf := Buffer()
+    i := 0
+    while i < n
+      cl := self.codePointByteLength(i)
+      if cl == 1
+        buf.writeByte(Byte(self.byteAt(i)))
-    todo
+      else
+        cp := self.codePointAt(i)
+        idx := -1
+        tbl := t1
+        if cp >= 0xC0 && cp < 0x100
+          idx = {cp - 0xC0} * 2
+        else if cp >= 0x100 && cp < 0x180
+          idx = {cp - 0x100} * 2
+          tbl = t2
+        if idx < 0 || tbl.byteAt(idx) == 35
+          buf.write(self.sub(i, i + cl))
+        else
+          buf.writeByte(Byte(tbl.byteAt(idx)))
+          if tbl.byteAt(idx + 1) != 32
+            buf.writeByte(Byte(tbl.byteAt(idx + 1)))
+      i = i + cl
+    return buf.toStr()
   fun escape(self) -> Str =
-    escapeFrom(self, 0, self.length())
+    escapeHtml(self)
   fun escapeRegExp(self) -> Str =
-    escapeRegExpFrom(self, 0, self.length())
+    escapeRegExpStr(self)
   # Pads BOTH sides of `self` with repeated copies of `sub` until its length
   # is at least `count`, split as evenly as possible between the two sides
@@ -301,25 +384,14 @@ record Str(data: Buffer) =
     right := total - left
     return self.padStart(sub, len + left).padEnd(sub, len + left + right)
-  # `template` (lodash's `_.template`) compiles a string containing
-  # `<%= expr %>`-style placeholders into a REUSABLE function that renders it
-  # against different data each call — that needs the ability to compile and
-  # run Plum source AT RUNTIME (from a `Str` value, not a `.plum` file), which
-  # the language has no way to do (no `eval`, no dynamic codegen from within
-  # a running program). Left as a known gap rather than a fundamentally
-  # different, simpler feature (e.g. a one-shot find/replace) under the same
-  # name.
-  fun template(self) -> Str =
-    todo
   fun trim(self) -> Str =
     self.trimStart().trimEnd()
   fun trimEnd(self) -> Str =
-    trimEndFrom(self, self.length())
+    self.sub(0, trimEndIndex(self))
   fun trimStart(self) -> Str =
-    trimStartFrom(self, 0, self.length())
+    self.sub(trimStartIndex(self), self.length())
   # Truncates `self` to at most `length` bytes (INCLUDING the "..." suffix,
   # lodash's default `omission` string) if it's longer than `length`; returns
@@ -334,12 +406,12 @@ record Str(data: Buffer) =
     return self.sub(0, length - omission.length()) + omission
   fun unescape(self) -> Str =
-    unescapeFrom(self, 0, self.length())
+    unescapeHtml(self)
   # Space-joined, un-cased word boundaries (splits on whitespace/punctuation
   # AND on a lower->upper "camel" transition, e.g. "fooBar baz" -> "foo Bar baz").
   fun words(self) -> Str =
-    caseConvertFrom(self, 0, self.length(), " ", 0, 0, 0)
+    caseConvert(self, " ", 0)
 # A new 1-byte Str holding `b`'s low 8 bits — a compiler intrinsic (there's no
 # way to build a new array from Plum source), the counterpart to `byteAt`.
@@ -357,7 +429,7 @@ fun isAsciiDigit(b: Int) -> Bool =
 # Byte 0x80+ is either a UTF-8 continuation byte or the lead byte of a
 # multi-byte character — never an ASCII separator — so it's treated as
-# "part of a word" here. Without this, `caseConvertFrom` (backing `words`/
+# "part of a word" here. Without this, `caseConvert` (backing `words`/
 # `camelCase`/`snakeCase`/`kebabCase`/`startCase`) would treat every
 # non-ASCII character as a word BOUNDARY, shredding any text that isn't
 # pure ASCII into a separate "word" per byte.
@@ -386,24 +458,6 @@ fun matchesAt(s: Str, sub: Str, offset: Int, sub_len: Int) -> Bool =
     j = j + 1
   return true
-fun reverseFrom(s: Str, i: Int) -> Str =
-  if i >= s.length()
-    return ""
-  n := s.codePointByteLength(i)
-  return reverseFrom(s, i + n) + s.sub(i, i + n)
-fun runeLengthFrom(s: Str, i: Int, len: Int, count: Int) -> Int =
-  if i >= len
-    return count
-  n := s.codePointByteLength(i)
-  return runeLengthFrom(s, i + n, len, count + 1)
-fun runeAtFrom(s: Str, byte_index: Int, chars_remaining: Int) -> Str =
-  n := s.codePointByteLength(byte_index)
-  if chars_remaining == 0
-    return s.sub(byte_index, byte_index + n)
-  return runeAtFrom(s, byte_index + n, chars_remaining - 1)
 # Encodes a single Unicode codepoint (its raw integer value) as its own
 # UTF-8 `Str` (1-4 bytes) — the reverse of `Str.codePointAt`. `b0`/`b1`/`b2`
 # are declared ONCE up front and reassigned per branch (rather than
@@ -428,80 +482,123 @@ fun codePointToStr(cp: Int) -> Str =
   b3 := 0x80 | {cp & 0x3F}
   return byteToStr(b0) + byteToStr(b1) + byteToStr(b2) + byteToStr(b3)
+fun isTrimByte(b: Int) -> Bool =
+  b == 32 || b == 9 || b == 10 || b == 13
-fun trimStartFrom(s: Str, i: Int, len: Int) -> Str =
+fun trimStartIndex(s: Str) -> Int =
-  if i >= len
-    return ""
-  b := s.byteAt(i)
+  n := s.length()
+  i := 0
-  if b != 32 && b != 9 && b != 10 && b != 13
+  while i < n && isTrimByte(s.byteAt(i))
+    i = i + 1
-    return s.sub(i, len)
+  return i
-  return trimStartFrom(s, i + 1, len)
+# Exclusive end index of `s` with trailing whitespace dropped.
-fun trimEndFrom(s: Str, len: Int) -> Str =
+fun trimEndIndex(s: Str) -> Int =
-  if len <= 0
-    return ""
-  b := s.byteAt(len - 1)
+  n := s.length()
-  if b != 32 && b != 9 && b != 10 && b != 13
+  while n > 0 && isTrimByte(s.byteAt(n - 1))
+    n = n - 1
-    return s.sub(0, len)
+  return n
-  return trimEndFrom(s, len - 1)
-fun escapeFrom(s: Str, i: Int, len: Int) -> Str =
-  if i >= len
-    return ""
-  return escapeChar(s, i) + escapeFrom(s, i + 1, len)
-fun escapeChar(s: Str, i: Int) -> Str =
+fun htmlEntity(b: Int) -> Str =
-  match s.byteAt(i)
+  match b
     38 => "&amp;"
     60 => "&lt;"
     62 => "&gt;"
     34 => "&quot;"
     39 => "&#39;"
-    _ => s.get(i)
+    _ => ""
+fun escapeHtml(s: Str) -> Str =
+  n := s.length()
+  buf := Buffer()
+  i := 0
+  while i < n
+    b := s.byteAt(i)
+    ent := htmlEntity(b)
+    if ent.length() == 0
+      buf.writeByte(Byte(b))
+    else
+      buf.write(ent)
+    i = i + 1
+  return buf.toStr()
 fun isRegExpMetaByte(b: Int) -> Bool =
   b == 94 || b == 36 || b == 92 || b == 46 || b == 42 || b == 43 || b == 63
     || b == 40 || b == 41 || b == 91 || b == 93 || b == 123 || b == 125 || b == 124
-fun escapeRegExpFrom(s: Str, i: Int, len: Int) -> Str =
+fun escapeRegExpStr(s: Str) -> Str =
+  n := s.length()
+  buf := Buffer()
+  i := 0
-  if i >= len
+  while i < n
+    b := s.byteAt(i)
+    if isRegExpMetaByte(b)
+      buf.writeByte(Byte(92))
+    buf.writeByte(Byte(b))
+    i = i + 1
-    return ""
+  return buf.toStr()
-  piece := if isRegExpMetaByte(s.byteAt(i)) then "\\" + s.get(i) else s.get(i)
+# Length of the HTML entity starting at `i` (and writes its decoded byte
-  return piece + escapeRegExpFrom(s, i + 1, len)
+# into `buf`), or 0 if none starts there.
-fun unescapeFrom(s: Str, i: Int, len: Int) -> Str =
+fun unescapeEntityAt(s: Str, i: Int, buf: Buffer) -> Int =
-  if i >= len
-    return ""
   if matchesAt(s, "&amp;", i, 5)
-    return "&" + unescapeFrom(s, i + 5, len)
+    buf.writeByte(Byte(38))
+    return 5
   if matchesAt(s, "&lt;", i, 4)
-    return "<" + unescapeFrom(s, i + 4, len)
+    buf.writeByte(Byte(60))
+    return 4
   if matchesAt(s, "&gt;", i, 4)
-    return ">" + unescapeFrom(s, i + 4, len)
+    buf.writeByte(Byte(62))
+    return 4
   if matchesAt(s, "&quot;", i, 6)
-    return "\"" + unescapeFrom(s, i + 6, len)
+    buf.writeByte(Byte(34))
+    return 6
   if matchesAt(s, "&#39;", i, 5)
+    buf.writeByte(Byte(39))
+    return 5
+  return 0
-    return "'" + unescapeFrom(s, i + 5, len)
+fun unescapeHtml(s: Str) -> Str =
+  n := s.length()
+  buf := Buffer()
+  i := 0
+  while i < n
+    k := 0
+    if s.byteAt(i) == 38
-  return s.get(i) + unescapeFrom(s, i + 1, len)
+      k = unescapeEntityAt(s, i, buf)
+    if k == 0
+      buf.writeByte(Byte(s.byteAt(i)))
+      k = 1
+    i = i + k
+  return buf.toStr()
-# Shared walker behind `words`/`camelCase`/`snakeCase`/`kebabCase`/`upperCase`/
+# Shared walker behind `words`/`camelCase`/`snakeCase`/`kebabCase`/`startCase`:
-# `toLower`/`startCase`: splits on non-word bytes and on a lower->upper "camel"
+# splits on non-word bytes and on a lower->upper "camel" transition, joining
-# transition, joining the surviving words with `sep` and case-mapping each
+# the surviving words with `sep` and case-mapping each byte per `mode`:
-# byte per `mode`:
 #   0 = leave case as-is (words)                        1 = lowercase everything (snake/kebab)
 #   2 = camelCase (word 1 lowercase, rest Capitalized)  4 = Capitalize every word (startCase)
-# (`toLower`/`upperCase` are NOT built on this — they map every byte 1:1
+# (`toLower`/`upperCase` use `mapCase` — they map every byte 1:1 including
-# including non-word bytes like spaces/punctuation, which this function drops.)
+# non-word bytes like spaces/punctuation, which this function drops.)
-fun caseConvertFrom(s: Str, i: Int, len: Int, sep: Str, mode: Int, word_index: Int, prev_byte: Int) -> Str =
+fun caseConvert(s: Str, sep: Str, mode: Int) -> Str =
+  n := s.length()
+  buf := Buffer()
+  word_index := 0
+  prev_byte := 0
+  i := 0
-  if i >= len
+  while i < n
-    return ""
-  b := s.byteAt(i)
+    b := s.byteAt(i)
-  if !isWordByte(b)
+    if !isWordByte(b)
-    return caseConvertFrom(s, i + 1, len, sep, mode, word_index, 0)
+      prev_byte = 0
+    else
-  is_word_start := prev_byte == 0 || isCamelBoundary(prev_byte, b)
+      is_word_start := prev_byte == 0 || isCamelBoundary(prev_byte, b)
+      if is_word_start
-  word_index_next := if is_word_start then word_index + 1 else word_index
+        word_index = word_index + 1
-  prefix := if {is_word_start && word_index > 0} then sep else ""
+        if word_index > 1
+          buf.write(sep)
-  out_byte := caseConvertByte(b, mode, is_word_start, word_index_next)
+      buf.writeByte(Byte(caseConvertByte(b, mode, is_word_start, word_index)))
+      prev_byte = b
+    i = i + 1
-  return prefix + byteToStr(out_byte) + caseConvertFrom(s, i + 1, len, sep, mode, word_index_next, b)
+  return buf.toStr()
 fun caseConvertByte(b: Int, mode: Int, is_word_start: Bool, word_index: Int) -> Int =
   match mode
@@ -512,15 +609,25 @@ fun caseConvertByte(b: Int, mode: Int, is_word_start: Bool, word_index: Int) ->
     _ => b
 # Simple 1:1 byte map — every byte (including non-word bytes like spaces and
-# punctuation) is preserved; only letters are case-mapped. This is what
-# `toLower`/`upperCase` need but `caseConvertFrom` above (word-boundary
-# splitting/rejoining) doesn't provide.
-fun mapCaseFrom(s: Str, i: Int, len: Int, upper: Bool) -> Str =
-  if i >= len
-    return ""
-  b := s.byteAt(i)
-  mapped := if upper then toUpperByte(b) else toLowerByte(b)
-  return byteToStr(mapped) + mapCaseFrom(s, i + 1, len, upper)
+# punctuation) is preserved; only letters are case-mapped.
+fun mapCase(s: Str, upper: Bool) -> Str =
+  n := s.length()
+  buf := Buffer()
+  i := 0
+  while i < n
+    b := s.byteAt(i)
+    buf.writeByte(Byte(if upper then toUpperByte(b) else toLowerByte(b)))
+    i = i + 1
+  return buf.toStr()
+# 2-char cells (space padded), one per codepoint U+00C0..U+00FF. `#` = keep
+# the original character (`×`, `÷`).
+fun deburrLatin1() -> Str =
+  "A A A A A A AEC E E E E I I I I D N O O O O O # O U U U U Y Thssa a a a a a aec e e e e i i i i d n o o o o o # o u u u u y thy "
+# Same layout for U+0100..U+017F (Latin Extended-A).
+fun deburrLatinExtA() -> Str =
+  "A a A a A a C c C c C c C c D d D d E e E e E e E e E e G g G g G g G g H h H h I i I i I i I i I i IJijJ j K k k L l L l L l L l L l N n N n N n n N n O o O o O o OEoeR r R r R r S s S s S s S s T t T t T t U u U u U u U u U u U u W w Y y Y Z z Z z Z z s "
 # ---- string interpolation regression tests ----
 # `"{expr}"` interpolation is a compiler/codegen feature (not a Str method
@@ -529,6 +636,14 @@ fun mapCaseFrom(s: Str, i: Int, len: Int, upper: Bool) -> Str =
 fun greetForInterpolationTest(name: Str) -> Str =
   "Hello, {name}!"
+fun bigAscii(n: Int, b: Int) -> Str =
+  buf := Buffer()
+  i := 0
+  while i < n
+    buf.writeByte(Byte(b))
+    i = i + 1
+  return buf.toStr()
 test "string interpolation of an int runs correctly"
   x := 42
   assert "{x}" == "42"
@@ -663,3 +778,88 @@ test "Str.parseBool accepts true/false and rejects everything else"
   assert "true".parseBool() catch false
   assert !{"false".parseBool() catch true}
   assert !{"yes".parseBool() catch false}
+# ---- large-input (linear-time, no stack growth) regression tests ----
+test "sub of a 200000-byte string is a single copy"
+  s := bigAscii(200000, 97)
+  r := s.sub(10, 199990)
+  assert r.length() == 199980
+  assert s.sub(0, 200000).length() == 200000
+  assert s.slice(-5, 200000) == "aaaaa"
+test "reverse of a 100000-char string"
+  buf := Buffer()
+  i := 0
+  while i < 100000
+    buf.writeByte(Byte(if i == 0 then 98 else 97))
+    i = i + 1
+  r := buf.toStr().reverse()
+  assert r.length() == 100000
+  assert r.byteAt(99999) == 98
+  assert r.byteAt(0) == 97
+test "escape and unescape of a 100000-char string"
+  s := bigAscii(100000, 60)
+  e := s.escape()
+  assert e.length() == 400000
+  assert e.unescape() == s
+test "camelCase of a 100000-char string"
+  buf := Buffer()
+  i := 0
+  while i < 50000
+    buf.write("ab ")
+    i = i + 1
+  r := buf.toStr().camelCase()
+  assert r.length() == 50000 * 2
+  assert r.startsWith("abAbAb")
+test "runeLength of 100000 multi-byte chars"
+  buf := Buffer()
+  i := 0
+  while i < 100000
+    buf.write("é")
+    i = i + 1
+  s := buf.toStr()
+  assert s.length() == 200000
+  assert s.runeLength() == 100000
+  assert s.runeAt(99999) == "é"
+test "split into 10000 parts"
+  buf := Buffer()
+  i := 0
+  while i < 10000
+    buf.write("x,")
+    i = i + 1
+  parts := buf.toStr().split(",", 0)
+  assert parts.length() == 10001
+test "replace swaps only the first occurrence"
+  assert "a-b-c".replace("-", "+") == "a+b-c"
+  assert "abc".replace("x", "y") == "abc"
+  assert "abc".replace("abc", "") == ""
+  assert "héllo wörld".replace("ö", "oe") == "héllo woerld"
+test "replaceAll swaps every non-overlapping occurrence"
+  assert "a-b-c".replaceAll("-", "+") == "a+b+c"
+  assert "aaa".replaceAll("aa", "b") == "ba"
+  assert "abc".replaceAll("", "x") == "abc"
+  assert "abc".replaceAll("x", "y") == "abc"
+  assert "héhé".replaceAll("é", "e") == "hehe"
+  assert "aXbXc".replaceAll("X", "--") == "a--b--c"
+test "search returns the byte index or -1, like indexOf"
+  assert "the quick fox".search("quick") == 4
+  assert "the quick fox".search("slow") == -1
+  assert "abc".search("") == 0
+test "deburr strips Latin-1 and Latin Extended-A diacritics"
+  assert "café".deburr() == "cafe"
+  assert "señor".deburr() == "senor"
+  assert "Straße".deburr() == "Strasse"
+  assert "Ærø".deburr() == "AEro"
+  assert "Łódź".deburr() == "Lodz"
+  assert "œuvre Ÿ ž".deburr() == "oeuvre Y z"
+  assert "plain ASCII 1+1".deburr() == "plain ASCII 1+1"
+  assert "3×4÷2 日本".deburr() == "3×4÷2 日本"