From d225803774ee0488ddd5c87dd79cb4fc6d78d80c Mon Sep 17 00:00:00 2001
From: Michael Ilseman <michael.ilseman@gmail.com>
Date: Wed, 9 Oct 2024 14:00:36 -0600
Subject: [PATCH 1/7] Cleanup algorithms code

Delete lots of dead code, get off of collections and onto iterators, simplify implementations.
---
 .../Algorithms/Algorithms/Ranges.swift        | 134 ++------
 .../Algorithms/Algorithms/Replace.swift       |   2 +-
 .../Algorithms/Algorithms/Split.swift         |  62 ++--
 .../Algorithms/Algorithms/Trim.swift          |   8 +-
 .../Consumers/CollectionConsumer.swift        |  25 --
 .../Consumers/FixedPatternConsumer.swift      |  28 --
 .../Algorithms/Consumers/ManyConsumer.swift   |  47 ---
 .../Consumers/PredicateConsumer.swift         |  74 -----
 .../Algorithms/Matching/FirstMatch.swift      |  24 --
 .../Algorithms/Matching/MatchReplace.swift    |  63 ----
 .../Algorithms/Matching/MatchResult.swift     |   9 -
 .../Algorithms/Matching/Matches.swift         | 288 ++----------------
 .../Matching/MatchingCollectionConsumer.swift |  48 ---
 .../Matching/MatchingCollectionSearcher.swift | 104 -------
 .../Searchers/CollectionSearcher.swift        |  54 ----
 .../Searchers/ConsumerSearcher.swift          | 109 -------
 .../Searchers/NaivePatternSearcher.swift      |  93 ------
 .../Algorithms/Searchers/PatternOrEmpty.swift |  65 ----
 .../Searchers/PredicateSearcher.swift         |  44 ---
 Sources/_StringProcessing/CMakeLists.txt      |   7 -
 .../RegexTests/AlgorithmsInternalsTests.swift |  15 +-
 21 files changed, 80 insertions(+), 1223 deletions(-)
 delete mode 100644 Sources/_StringProcessing/Algorithms/Consumers/ManyConsumer.swift
 delete mode 100644 Sources/_StringProcessing/Algorithms/Consumers/PredicateConsumer.swift
 delete mode 100644 Sources/_StringProcessing/Algorithms/Matching/MatchingCollectionConsumer.swift
 delete mode 100644 Sources/_StringProcessing/Algorithms/Searchers/ConsumerSearcher.swift
 delete mode 100644 Sources/_StringProcessing/Algorithms/Searchers/NaivePatternSearcher.swift
 delete mode 100644 Sources/_StringProcessing/Algorithms/Searchers/PatternOrEmpty.swift
 delete mode 100644 Sources/_StringProcessing/Algorithms/Searchers/PredicateSearcher.swift

diff --git a/Sources/_StringProcessing/Algorithms/Algorithms/Ranges.swift b/Sources/_StringProcessing/Algorithms/Algorithms/Ranges.swift
index 3f9b8d49a..57834a324 100644
--- a/Sources/_StringProcessing/Algorithms/Algorithms/Ranges.swift
+++ b/Sources/_StringProcessing/Algorithms/Algorithms/Ranges.swift
@@ -11,107 +11,33 @@
 
 // MARK: `RangesCollection`
 
-struct RangesCollection<Searcher: CollectionSearcher> {
-  public typealias Base = Searcher.Searched
-  
-  let base: Base
+struct RangesSequence<Searcher: CollectionSearcher> {
+  let input: Searcher.Searched
   let searcher: Searcher
-  private(set) public var startIndex: Index
 
-  init(base: Base, searcher: Searcher) {
-    self.base = base
+  init(input: Searcher.Searched, searcher: Searcher) {
+    self.input = input
     self.searcher = searcher
-    
-    var state = searcher.state(for: base, in: base.startIndex..<base.endIndex)
-    self.startIndex = Index(range: nil, state: state)
-
-    if let range = searcher.search(base, &state) {
-      self.startIndex = Index(range: range, state: state)
-    } else {
-      self.startIndex = endIndex
-    }
   }
-}
-
-struct RangesIterator<Searcher: CollectionSearcher>: IteratorProtocol {
-  public typealias Base = Searcher.Searched
-  
-  let base: Base
-  let searcher: Searcher
-  var state: Searcher.State
-
-  init(base: Base, searcher: Searcher) {
-    self.base = base
-    self.searcher = searcher
-    self.state = searcher.state(for: base, in: base.startIndex..<base.endIndex)
-  }
-
-  public mutating func next() -> Range<Base.Index>? {
-    searcher.search(base, &state)
-  }
-}
-
-extension RangesCollection: Sequence {
-  public func makeIterator() -> RangesIterator<Searcher> {
-    Iterator(base: base, searcher: searcher)
-  }
-}
 
-extension RangesCollection: Collection {
-  // TODO: Custom `SubSequence` for the sake of more efficient slice iteration
-  
-  public struct Index {
-    var range: Range<Searcher.Searched.Index>?
+  struct Iterator: IteratorProtocol {
+    let base: RangesSequence
     var state: Searcher.State
-  }
-
-  public var endIndex: Index {
-    // TODO: Avoid calling `state(for:startingAt)` here
-    Index(
-      range: nil,
-      state: searcher.state(for: base, in: base.startIndex..<base.endIndex))
-  }
-
-  public func formIndex(after index: inout Index) {
-    guard index != endIndex else { fatalError("Cannot advance past endIndex") }
-    index.range = searcher.search(base, &index.state)
-  }
-
-  public func index(after index: Index) -> Index {
-    var index = index
-    formIndex(after: &index)
-    return index
-  }
 
-  public subscript(index: Index) -> Range<Base.Index> {
-    guard let range = index.range else {
-      fatalError("Cannot subscript using endIndex")
+    init(_ base: RangesSequence) {
+      self.base = base
+      self.state = base.searcher.state(for: base.input, in: base.input.startIndex..<base.input.endIndex)
     }
-    return range
-  }
-}
 
-extension RangesCollection.Index: Comparable {
-  static func == (lhs: Self, rhs: Self) -> Bool {
-    switch (lhs.range, rhs.range) {
-    case (nil, nil):
-      return true
-    case (nil, _?), (_?, nil):
-      return false
-    case (let lhs?, let rhs?):
-      return lhs.lowerBound == rhs.lowerBound
+    public mutating func next() -> Range<Searcher.Searched.Index>? {
+      base.searcher.search(base.input, &state)
     }
   }
+}
 
-  static func < (lhs: Self, rhs: Self) -> Bool {
-    switch (lhs.range, rhs.range) {
-    case (nil, _):
-      return false
-    case (_, nil):
-      return true
-    case (let lhs?, let rhs?):
-      return lhs.lowerBound < rhs.lowerBound
-    }
+extension RangesSequence: Sequence {
+  public func makeIterator() -> Iterator {
+    Iterator(self)
   }
 }
 
@@ -122,8 +48,8 @@ extension RangesCollection.Index: Comparable {
 extension Collection {
   func _ranges<S: CollectionSearcher>(
     of searcher: S
-  ) -> RangesCollection<S> where S.Searched == Self {
-    RangesCollection(base: self, searcher: searcher)
+  ) -> RangesSequence<S> where S.Searched == Self {
+    RangesSequence(input: self, searcher: searcher)
   }
 }
 
@@ -132,7 +58,7 @@ extension Collection {
 extension Collection where Element: Equatable {
   func _ranges<C: Collection>(
     of other: C
-  ) -> RangesCollection<ZSearcher<Self>> where C.Element == Element {
+  ) -> RangesSequence<ZSearcher<Self>> where C.Element == Element {
     _ranges(of: ZSearcher(pattern: Array(other), by: ==))
   }
   
@@ -163,8 +89,8 @@ extension Collection where Element: Equatable {
 }
 
 @available(SwiftStdlib 5.7, *)
-struct RegexRangesCollection<Output> {
-  let base: RegexMatchesCollection<Output>
+struct RegexRangesSequence<Output> {
+  let base: RegexMatchesSequence<Output>
 
   init(
     input: String,
@@ -181,9 +107,9 @@ struct RegexRangesCollection<Output> {
 }
 
 @available(SwiftStdlib 5.7, *)
-extension RegexRangesCollection: Sequence {
+extension RegexRangesSequence: Sequence {
   struct Iterator: IteratorProtocol {
-    var matchesBase: RegexMatchesCollection<Output>.Iterator
+    var matchesBase: RegexMatchesSequence<Output>.Iterator
     
     mutating func next() -> Range<String.Index>? {
       matchesBase.next().map(\.range)
@@ -195,16 +121,6 @@ extension RegexRangesCollection: Sequence {
   }
 }
 
-@available(SwiftStdlib 5.7, *)
-extension RegexRangesCollection: Collection {
-  typealias Index = RegexMatchesCollection<Output>.Index
-
-  var startIndex: Index { base.startIndex }
-  var endIndex: Index { base.endIndex }
-  func index(after i: Index) -> Index { base.index(after: i) }
-  subscript(position: Index) -> Range<String.Index> { base[position].range }
-}
-
 // MARK: Regex algorithms
 
 extension Collection where SubSequence == Substring {
@@ -214,8 +130,8 @@ extension Collection where SubSequence == Substring {
     of regex: R,
     subjectBounds: Range<String.Index>,
     searchBounds: Range<String.Index>
-  ) -> RegexRangesCollection<R.RegexOutput> {
-    RegexRangesCollection(
+  ) -> RegexRangesSequence<R.RegexOutput> {
+    RegexRangesSequence(
       input: self[...].base,
       subjectBounds: subjectBounds,
       searchBounds: searchBounds,
@@ -226,7 +142,7 @@ extension Collection where SubSequence == Substring {
   @_disfavoredOverload
   func _ranges<R: RegexComponent>(
     of regex: R
-  ) -> RegexRangesCollection<R.RegexOutput> {
+  ) -> RegexRangesSequence<R.RegexOutput> {
     _ranges(
       of: regex,
       subjectBounds: startIndex..<endIndex,
diff --git a/Sources/_StringProcessing/Algorithms/Algorithms/Replace.swift b/Sources/_StringProcessing/Algorithms/Algorithms/Replace.swift
index 54dd0f864..c67cfbfbd 100644
--- a/Sources/_StringProcessing/Algorithms/Algorithms/Replace.swift
+++ b/Sources/_StringProcessing/Algorithms/Algorithms/Replace.swift
@@ -38,7 +38,7 @@ extension Substring {
 }
 
 extension RangeReplaceableCollection {
-  func _replacing<Ranges: Collection, Replacement: Collection>(
+  func _replacing<Ranges: Sequence, Replacement: Collection>(
     _ ranges: Ranges,
     with replacement: Replacement,
     maxReplacements: Int = .max
diff --git a/Sources/_StringProcessing/Algorithms/Algorithms/Split.swift b/Sources/_StringProcessing/Algorithms/Algorithms/Split.swift
index da4eecc60..b722932b9 100644
--- a/Sources/_StringProcessing/Algorithms/Algorithms/Split.swift
+++ b/Sources/_StringProcessing/Algorithms/Algorithms/Split.swift
@@ -11,15 +11,15 @@
 
 // MARK: `SplitCollection`
 
-struct SplitCollection<Searcher: CollectionSearcher> {
-  public typealias Base = Searcher.Searched
+struct SplitSequence<Searcher: CollectionSearcher> {
+  public typealias Input = Searcher.Searched
   
-  let ranges: RangesCollection<Searcher>
+  let ranges: RangesSequence<Searcher>
   var maxSplits: Int
   var omittingEmptySubsequences: Bool
 
   init(
-    ranges: RangesCollection<Searcher>,
+    ranges: RangesSequence<Searcher>,
     maxSplits: Int,
     omittingEmptySubsequences: Bool)
   {
@@ -29,53 +29,53 @@ struct SplitCollection<Searcher: CollectionSearcher> {
   }
 
   init(
-    base: Base,
+    input: Input,
     searcher: Searcher,
     maxSplits: Int,
     omittingEmptySubsequences: Bool)
   {
-    self.ranges = base._ranges(of: searcher)
+    self.ranges = input._ranges(of: searcher)
     self.maxSplits = maxSplits
     self.omittingEmptySubsequences = omittingEmptySubsequences
   }
 }
 
-extension SplitCollection: Sequence {
+extension SplitSequence: Sequence {
   public struct Iterator: IteratorProtocol {
-    let base: Base
-    var index: Base.Index
-    var ranges: RangesCollection<Searcher>.Iterator
-    var maxSplits: Int
-    var omittingEmptySubsequences: Bool
+    var ranges: RangesSequence<Searcher>.Iterator
+    var index: Input.Index
 
+    var maxSplits: Int
     var splitCounter = 0
+    var omittingEmptySubsequences: Bool
     var isDone = false
 
+    var input: Input { ranges.base.input }
+
     init(
-      ranges: RangesCollection<Searcher>,
+      ranges: RangesSequence<Searcher>,
       maxSplits: Int,
       omittingEmptySubsequences: Bool
     ) {
-      self.base = ranges.base
-      self.index = base.startIndex
+      self.index = ranges.input.startIndex
       self.ranges = ranges.makeIterator()
       self.maxSplits = maxSplits
       self.omittingEmptySubsequences = omittingEmptySubsequences
     }
     
-    public mutating func next() -> Base.SubSequence? {
+    public mutating func next() -> Input.SubSequence? {
       guard !isDone else { return nil }
       
       /// Return the rest of base if it's non-empty or we're including
       /// empty subsequences.
-      func finish() -> Base.SubSequence? {
+      func finish() -> Input.SubSequence? {
         isDone = true
-        return index == base.endIndex && omittingEmptySubsequences
+        return index == input.endIndex && omittingEmptySubsequences
           ? nil
-          : base[index...]
+          : input[index...]
       }
       
-      if index == base.endIndex {
+      if index == input.endIndex {
         return finish()
       }
       
@@ -96,7 +96,7 @@ extension SplitCollection: Sequence {
         }
         
         splitCounter += 1
-        return base[index..<range.lowerBound]
+        return input[index..<range.lowerBound]
       }
     }
   }
@@ -109,13 +109,13 @@ extension SplitCollection: Sequence {
 // MARK: `CollectionSearcher` algorithms
 
 extension Collection {
-  func split<Searcher: CollectionSearcher>(
+  func _split<Searcher: CollectionSearcher>(
     by separator: Searcher,
     maxSplits: Int,
     omittingEmptySubsequences: Bool
-  ) -> SplitCollection<Searcher> where Searcher.Searched == Self {
-    SplitCollection(
-      base: self,
+  ) -> SplitSequence<Searcher> where Searcher.Searched == Self {
+    SplitSequence(
+      input: self,
       searcher: separator,
       maxSplits: maxSplits,
       omittingEmptySubsequences: omittingEmptySubsequences)
@@ -126,12 +126,12 @@ extension Collection {
 
 extension Collection where Element: Equatable {
   @_disfavoredOverload
-  func split<C: Collection>(
+  func _split<C: Collection>(
     by separator: C,
     maxSplits: Int,
     omittingEmptySubsequences: Bool
-  ) -> SplitCollection<ZSearcher<Self>> where C.Element == Element {
-    split(by: ZSearcher(pattern: Array(separator), by: ==), maxSplits: maxSplits, omittingEmptySubsequences: omittingEmptySubsequences)
+  ) -> SplitSequence<ZSearcher<Self>> where C.Element == Element {
+    _split(by: ZSearcher(pattern: Array(separator), by: ==), maxSplits: maxSplits, omittingEmptySubsequences: omittingEmptySubsequences)
   }
 
   // FIXME: Return `some Collection<SubSequence>` for SE-0346
@@ -159,7 +159,7 @@ extension Collection where Element: Equatable {
       return str._split(separator: sep, maxSplits: maxSplits, omittingEmptySubsequences: omittingEmptySubsequences) as! [SubSequence]
       
     default:
-      return Array(split(
+      return Array(_split(
         by: ZSearcher(pattern: Array(separator), by: ==),
         maxSplits: maxSplits,
         omittingEmptySubsequences: omittingEmptySubsequences))
@@ -186,7 +186,7 @@ extension StringProtocol where SubSequence == Substring {
     maxSplits: Int = .max,
     omittingEmptySubsequences: Bool = true
   ) -> [Substring] {
-    Array(self[...].split(
+    Array(self[...]._split(
       by: SubstringSearcher(text: "" as Substring, pattern: separator[...]),
       maxSplits: maxSplits,
       omittingEmptySubsequences: omittingEmptySubsequences))
@@ -199,7 +199,7 @@ extension StringProtocol where SubSequence == Substring {
     maxSplits: Int = .max,
     omittingEmptySubsequences: Bool = true
   ) -> [Substring] {
-    Array(self[...].split(
+    Array(self[...]._split(
       by: SubstringSearcher(text: "" as Substring, pattern: separator[...]),
       maxSplits: maxSplits,
       omittingEmptySubsequences: omittingEmptySubsequences))
diff --git a/Sources/_StringProcessing/Algorithms/Algorithms/Trim.swift b/Sources/_StringProcessing/Algorithms/Algorithms/Trim.swift
index e870e1493..ff385856c 100644
--- a/Sources/_StringProcessing/Algorithms/Algorithms/Trim.swift
+++ b/Sources/_StringProcessing/Algorithms/Algorithms/Trim.swift
@@ -44,7 +44,7 @@ extension RangeReplaceableCollection {
 // MARK: Predicate algorithms
 
 extension Collection {
-  fileprivate func endOfPrefix(while predicate: (Element) throws -> Bool) rethrows -> Index {
+  fileprivate func _endOfPrefix(while predicate: (Element) throws -> Bool) rethrows -> Index {
     try firstIndex(where: { try !predicate($0) }) ?? endIndex
   }
 
@@ -52,7 +52,7 @@ extension Collection {
   public func trimmingPrefix(
     while predicate: (Element) throws -> Bool
   ) rethrows -> SubSequence {
-    let end = try endOfPrefix(while: predicate)
+    let end = try _endOfPrefix(while: predicate)
     return self[end...]
   }
 }
@@ -62,7 +62,7 @@ extension Collection where SubSequence == Self {
   public mutating func trimPrefix(
     while predicate: (Element) throws -> Bool
   ) throws {
-    let end = try endOfPrefix(while: predicate)
+    let end = try _endOfPrefix(while: predicate)
     self = self[end...]
   }
 }
@@ -73,7 +73,7 @@ extension RangeReplaceableCollection {
   public mutating func trimPrefix(
     while predicate: (Element) throws -> Bool
   ) rethrows {
-    let end = try endOfPrefix(while: predicate)
+    let end = try _endOfPrefix(while: predicate)
     removeSubrange(startIndex..<end)
   }
 }
diff --git a/Sources/_StringProcessing/Algorithms/Consumers/CollectionConsumer.swift b/Sources/_StringProcessing/Algorithms/Consumers/CollectionConsumer.swift
index b71af470e..516641d51 100644
--- a/Sources/_StringProcessing/Algorithms/Consumers/CollectionConsumer.swift
+++ b/Sources/_StringProcessing/Algorithms/Consumers/CollectionConsumer.swift
@@ -32,28 +32,3 @@ extension CollectionConsumer {
     return true
   }
 }
-
-// MARK: Consuming from the back
-
-protocol BidirectionalCollectionConsumer: CollectionConsumer
-  where Consumed: BidirectionalCollection
-{
-  func consumingBack(
-    _ consumed: Consumed,
-    in range: Range<Consumed.Index>
-  ) -> Consumed.Index?
-}
-
-extension BidirectionalCollectionConsumer {
-  func consumingBack(_ consumed: Consumed) -> Consumed.Index? {
-    consumingBack(consumed, in: consumed.startIndex..<consumed.endIndex)
-  }
-  
-  func consumeBack(_ consumed: inout Consumed) -> Bool
-    where Consumed.SubSequence == Consumed
-  {
-    guard let index = consumingBack(consumed) else { return false }
-    consumed = consumed[..<index]
-    return true
-  }
-}
diff --git a/Sources/_StringProcessing/Algorithms/Consumers/FixedPatternConsumer.swift b/Sources/_StringProcessing/Algorithms/Consumers/FixedPatternConsumer.swift
index 8312c247a..572b96fe6 100644
--- a/Sources/_StringProcessing/Algorithms/Consumers/FixedPatternConsumer.swift
+++ b/Sources/_StringProcessing/Algorithms/Consumers/FixedPatternConsumer.swift
@@ -35,31 +35,3 @@ extension FixedPatternConsumer: CollectionConsumer {
   }
 }
 
-extension FixedPatternConsumer: BidirectionalCollectionConsumer
-  where Consumed: BidirectionalCollection, Pattern: BidirectionalCollection
-{
-  func consumingBack(
-    _ consumed: Consumed,
-    in range: Range<Consumed.Index>
-  ) -> Consumed.Index? {
-    var index = range.upperBound
-    var patternIndex = pattern.endIndex
-    
-    while true {
-      if patternIndex == pattern.startIndex {
-        return index
-      }
-      
-      if index == range.lowerBound {
-        return nil
-      }
-      
-      consumed.formIndex(before: &index)
-      pattern.formIndex(before: &patternIndex)
-      
-      if consumed[index] != pattern[patternIndex] {
-        return nil
-      }
-    }
-  }
-}
diff --git a/Sources/_StringProcessing/Algorithms/Consumers/ManyConsumer.swift b/Sources/_StringProcessing/Algorithms/Consumers/ManyConsumer.swift
deleted file mode 100644
index 10d9fd5c3..000000000
--- a/Sources/_StringProcessing/Algorithms/Consumers/ManyConsumer.swift
+++ /dev/null
@@ -1,47 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// This source file is part of the Swift.org open source project
-//
-// Copyright (c) 2021-2022 Apple Inc. and the Swift project authors
-// Licensed under Apache License v2.0 with Runtime Library Exception
-//
-// See https://swift.org/LICENSE.txt for license information
-//
-//===----------------------------------------------------------------------===//
-
-struct ManyConsumer<Base: CollectionConsumer> {
-  let base: Base
-}
-
-extension ManyConsumer: CollectionConsumer {
-  typealias Consumed = Base.Consumed
-  
-  func consuming(
-    _ consumed: Base.Consumed,
-    in range: Range<Consumed.Index>
-  ) -> Base.Consumed.Index? {
-    var result = range.lowerBound
-    while let index = base.consuming(consumed, in: result..<range.upperBound),
-            index != result {
-      result = index
-    }
-    return result
-  }
-}
-
-extension ManyConsumer: BidirectionalCollectionConsumer
-  where Base: BidirectionalCollectionConsumer
-{
-  func consumingBack(
-    _ consumed: Base.Consumed,
-    in range: Range<Consumed.Index>
-  ) -> Base.Consumed.Index? {
-    var result = range.upperBound
-    while let index = base.consumingBack(
-      consumed,
-      in: range.lowerBound..<result), index != result {
-      result = index
-    }
-    return result
-  }
-}
diff --git a/Sources/_StringProcessing/Algorithms/Consumers/PredicateConsumer.swift b/Sources/_StringProcessing/Algorithms/Consumers/PredicateConsumer.swift
deleted file mode 100644
index caf523d1c..000000000
--- a/Sources/_StringProcessing/Algorithms/Consumers/PredicateConsumer.swift
+++ /dev/null
@@ -1,74 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// This source file is part of the Swift.org open source project
-//
-// Copyright (c) 2021-2022 Apple Inc. and the Swift project authors
-// Licensed under Apache License v2.0 with Runtime Library Exception
-//
-// See https://swift.org/LICENSE.txt for license information
-//
-//===----------------------------------------------------------------------===//
-
-struct PredicateConsumer<Consumed: Collection> {
-  let predicate: (Consumed.Element) -> Bool
-}
-
-extension PredicateConsumer: CollectionConsumer {
-  public func consuming(
-    _ consumed: Consumed,
-    in range: Range<Consumed.Index>
-  ) -> Consumed.Index? {
-    let start = range.lowerBound
-    guard start != range.upperBound && predicate(consumed[start]) else {
-      return nil
-    }
-    return consumed.index(after: start)
-  }
-}
-
-extension PredicateConsumer: BidirectionalCollectionConsumer
-  where Consumed: BidirectionalCollection
-{
-  func consumingBack(
-    _ consumed: Consumed,
-    in range: Range<Consumed.Index>
-  ) -> Consumed.Index? {
-    let end = range.upperBound
-    guard end != range.lowerBound else { return nil }
-    let previous = consumed.index(before: end)
-    return predicate(consumed[previous]) ? previous : nil
-  }
-}
-
-extension PredicateConsumer: StatelessCollectionSearcher {
-  public typealias Searched = Consumed
-  
-  public func search(
-    _ searched: Searched,
-    in range: Range<Searched.Index>
-  ) -> Range<Searched.Index>? {
-    // TODO: Make this reusable
-    guard let index = searched[range].firstIndex(where: predicate) else {
-      return nil
-    }
-    return index..<searched.index(after: index)
-  }
-}
-
-extension PredicateConsumer: BackwardCollectionSearcher,
-                             BackwardStatelessCollectionSearcher
-  where Searched: BidirectionalCollection
-{
-  typealias BackwardSearched = Consumed
-  
-  func searchBack(
-    _ searched: BackwardSearched,
-    in range: Range<BackwardSearched.Index>
-  ) -> Range<BackwardSearched.Index>? {
-    // TODO: Make this reusable
-    guard let index = searched[range].lastIndex(where: predicate) else {
-      return nil
-    }
-    return index..<searched.index(after: index)
-  }
-}
diff --git a/Sources/_StringProcessing/Algorithms/Matching/FirstMatch.swift b/Sources/_StringProcessing/Algorithms/Matching/FirstMatch.swift
index 3ee74f258..de0cabb0a 100644
--- a/Sources/_StringProcessing/Algorithms/Matching/FirstMatch.swift
+++ b/Sources/_StringProcessing/Algorithms/Matching/FirstMatch.swift
@@ -11,30 +11,6 @@
 
 // MARK: `CollectionSearcher` algorithms
 
-extension Collection {
-  func _firstMatch<S: MatchingCollectionSearcher>(
-    of searcher: S
-  ) -> _MatchResult<S>? where S.Searched == Self {
-    var state = searcher.state(for: self, in: startIndex..<endIndex)
-    return searcher.matchingSearch(self, &state).map { range, result in
-      _MatchResult(match: self[range], result: result)
-    }
-  }
-}
-
-extension BidirectionalCollection {
-  func lastMatch<S: BackwardMatchingCollectionSearcher>(
-    of searcher: S
-  ) -> _BackwardMatchResult<S>?
-    where S.BackwardSearched == Self
-  {
-    var state = searcher.backwardState(for: self, in: startIndex..<endIndex)
-    return searcher.matchingSearchBack(self, &state).map { range, result in
-      _BackwardMatchResult(match: self[range], result: result)
-    }
-  }
-}
-
 // MARK: Regex algorithms
 
 extension BidirectionalCollection where SubSequence == Substring {
diff --git a/Sources/_StringProcessing/Algorithms/Matching/MatchReplace.swift b/Sources/_StringProcessing/Algorithms/Matching/MatchReplace.swift
index 0f23280ce..266fbd8a8 100644
--- a/Sources/_StringProcessing/Algorithms/Matching/MatchReplace.swift
+++ b/Sources/_StringProcessing/Algorithms/Matching/MatchReplace.swift
@@ -9,69 +9,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-// MARK: `MatchingCollectionSearcher` algorithms
-
-extension RangeReplaceableCollection {
-  func _replacing<
-    Searcher: MatchingCollectionSearcher, Replacement: Collection
-  >(
-    _ searcher: Searcher,
-    with replacement: (_MatchResult<Searcher>) throws -> Replacement,
-    subrange: Range<Index>,
-    maxReplacements: Int = .max
-  ) rethrows -> Self where Searcher.Searched == SubSequence,
-                  Replacement.Element == Element
-  {
-    precondition(maxReplacements >= 0)
-
-    var index = subrange.lowerBound
-    var result = Self()
-    result.append(contentsOf: self[..<index])
-
-    for match in self[subrange]._matches(of: searcher)
-          .prefix(maxReplacements)
-    {
-      result.append(contentsOf: self[index..<match.range.lowerBound])
-      result.append(contentsOf: try replacement(match))
-      index = match.range.upperBound
-    }
-
-    result.append(contentsOf: self[index...])
-    return result
-  }
-
-  func _replacing<
-    Searcher: MatchingCollectionSearcher, Replacement: Collection
-  >(
-    _ searcher: Searcher,
-    with replacement: (_MatchResult<Searcher>) throws -> Replacement,
-    maxReplacements: Int = .max
-  ) rethrows -> Self where Searcher.Searched == SubSequence,
-                           Replacement.Element == Element
-  {
-    try _replacing(
-      searcher,
-      with: replacement,
-      subrange: startIndex..<endIndex,
-      maxReplacements: maxReplacements)
-  }
-
-  mutating func _replace<
-    Searcher: MatchingCollectionSearcher, Replacement: Collection
-  >(
-    _ searcher: Searcher,
-    with replacement: (_MatchResult<Searcher>) throws -> Replacement,
-    maxReplacements: Int = .max
-  ) rethrows where Searcher.Searched == SubSequence,
-                   Replacement.Element == Element
-  {
-    self = try _replacing(
-      searcher,
-      with: replacement,
-      maxReplacements: maxReplacements)
-  }
-}
-
 // MARK: Regex algorithms
 
 extension RangeReplaceableCollection where SubSequence == Substring {
diff --git a/Sources/_StringProcessing/Algorithms/Matching/MatchResult.swift b/Sources/_StringProcessing/Algorithms/Matching/MatchResult.swift
index 94e6d8c3b..7d8157045 100644
--- a/Sources/_StringProcessing/Algorithms/Matching/MatchResult.swift
+++ b/Sources/_StringProcessing/Algorithms/Matching/MatchResult.swift
@@ -17,12 +17,3 @@ struct _MatchResult<S: MatchingCollectionSearcher> {
     match.startIndex..<match.endIndex
   }
 }
-
-struct _BackwardMatchResult<S: BackwardMatchingCollectionSearcher> {
-  let match: S.BackwardSearched.SubSequence
-  let result: S.Match
-  
-  var range: Range<S.BackwardSearched.Index> {
-    match.startIndex..<match.endIndex
-  }
-}
diff --git a/Sources/_StringProcessing/Algorithms/Matching/Matches.swift b/Sources/_StringProcessing/Algorithms/Matching/Matches.swift
index 12846bf0f..3c435be97 100644
--- a/Sources/_StringProcessing/Algorithms/Matching/Matches.swift
+++ b/Sources/_StringProcessing/Algorithms/Matching/Matches.swift
@@ -9,188 +9,15 @@
 //
 //===----------------------------------------------------------------------===//
 
-// MARK: `MatchesCollection`
-
-struct MatchesCollection<Searcher: MatchingCollectionSearcher> {
-  public typealias Base = Searcher.Searched
-  
-  let base: Base
-  let searcher: Searcher
-  private(set) public var startIndex: Index
-
-  init(base: Base, searcher: Searcher) {
-    self.base = base
-    self.searcher = searcher
-    
-    var state = searcher.state(for: base, in: base.startIndex..<base.endIndex)
-    self.startIndex = Index(match: nil, state: state)
-
-    if let match = searcher.matchingSearch(base, &state) {
-      self.startIndex = Index(match: match, state: state)
-    } else {
-      self.startIndex = endIndex
-    }
-  }
-}
-
-struct MatchesIterator<
-  Searcher: MatchingCollectionSearcher
->: IteratorProtocol {
-  public typealias Base = Searcher.Searched
-  
-  let base: Base
-  let searcher: Searcher
-  var state: Searcher.State
-
-  init(base: Base, searcher: Searcher) {
-    self.base = base
-    self.searcher = searcher
-    self.state = searcher.state(for: base, in: base.startIndex..<base.endIndex)
-  }
-
-  public mutating func next() -> _MatchResult<Searcher>? {
-    searcher.matchingSearch(base, &state).map { range, result in
-      _MatchResult(match: base[range], result: result)
-    }
-  }
-}
-
-extension MatchesCollection: Sequence {
-  public func makeIterator() -> MatchesIterator<Searcher> {
-    Iterator(base: base, searcher: searcher)
-  }
-}
-
-extension MatchesCollection: Collection {
-  // TODO: Custom `SubSequence` for the sake of more efficient slice iteration
-  
-  struct Index {
-    var match: (range: Range<Base.Index>, match: Searcher.Match)?
-    var state: Searcher.State
-  }
-
-  public var endIndex: Index {
-    // TODO: Avoid calling `state(for:startingAt)` here
-    Index(
-      match: nil,
-      state: searcher.state(for: base, in: base.startIndex..<base.endIndex))
-  }
-
-  public func formIndex(after index: inout Index) {
-    guard index != endIndex else { fatalError("Cannot advance past endIndex") }
-    index.match = searcher.matchingSearch(base, &index.state)
-  }
-
-  public func index(after index: Index) -> Index {
-    var index = index
-    formIndex(after: &index)
-    return index
-  }
-
-  public subscript(index: Index) -> _MatchResult<Searcher> {
-    guard let (range, result) = index.match else {
-      fatalError("Cannot subscript using endIndex")
-    }
-    return _MatchResult(match: base[range], result: result)
-  }
-}
-
-extension MatchesCollection.Index: Comparable {
-  public static func == (lhs: Self, rhs: Self) -> Bool {
-    switch (lhs.match?.range, rhs.match?.range) {
-    case (nil, nil):
-      return true
-    case (nil, _?), (_?, nil):
-      return false
-    case (let lhs?, let rhs?):
-      return lhs.lowerBound == rhs.lowerBound
-    }
-  }
-
-  public static func < (lhs: Self, rhs: Self) -> Bool {
-    switch (lhs.match?.range, rhs.match?.range) {
-    case (nil, _):
-      return false
-    case (_, nil):
-      return true
-    case (let lhs?, let rhs?):
-      return lhs.lowerBound < rhs.lowerBound
-    }
-  }
-}
-
-// MARK: `ReversedMatchesCollection`
-// TODO: reversed matches
-
-struct ReversedMatchesCollection<
-  Searcher: BackwardMatchingCollectionSearcher
-> {
-  public typealias Base = Searcher.BackwardSearched
-
-  let base: Base
-  let searcher: Searcher
-
-  init(base: Base, searcher: Searcher) {
-    self.base = base
-    self.searcher = searcher
-  }
-}
-
-extension ReversedMatchesCollection: Sequence {
-  struct Iterator: IteratorProtocol {
-    let base: Base
-    let searcher: Searcher
-    var state: Searcher.BackwardState
-
-    init(base: Base, searcher: Searcher) {
-      self.base = base
-      self.searcher = searcher
-      self.state = searcher.backwardState(
-        for: base, in: base.startIndex..<base.endIndex)
-    }
-
-    public mutating func next() -> _BackwardMatchResult<Searcher>? {
-      searcher.matchingSearchBack(base, &state).map { range, result in
-        _BackwardMatchResult(match: base[range], result: result)
-      }
-    }
-  }
-
-  public func makeIterator() -> Iterator {
-    Iterator(base: base, searcher: searcher)
-  }
-}
-
-// TODO: `Collection` conformance
-
-// MARK: `CollectionSearcher` algorithms
-
-extension Collection {
-  func _matches<S: MatchingCollectionSearcher>(
-    of searcher: S
-  ) -> MatchesCollection<S> where S.Searched == Self {
-    MatchesCollection(base: self, searcher: searcher)
-  }
-}
-
-extension BidirectionalCollection {
-  func _matchesFromBack<S: BackwardMatchingCollectionSearcher>(
-    of searcher: S
-  ) -> ReversedMatchesCollection<S> where S.BackwardSearched == Self {
-    ReversedMatchesCollection(base: self, searcher: searcher)
-  }
-}
-
 // MARK: Regex algorithms
 
 @available(SwiftStdlib 5.7, *)
-struct RegexMatchesCollection<Output> {
+struct RegexMatchesSequence<Output> {
   let input: String
   let subjectBounds: Range<String.Index>
   let searchBounds: Range<String.Index>
   let regex: Regex<Output>
-  let startIndex: Index
-  
+
   init(
     input: String,
     subjectBounds: Range<String.Index>,
@@ -201,15 +28,11 @@ struct RegexMatchesCollection<Output> {
     self.subjectBounds = subjectBounds
     self.searchBounds = searchBounds
     self.regex = regex
-    self.startIndex = (try? regex._firstMatch(
-      input,
-      subjectBounds: subjectBounds,
-      searchBounds: searchBounds)).map(Index.match) ?? .end
   }
 }
 
 @available(SwiftStdlib 5.7, *)
-extension RegexMatchesCollection: Sequence {
+extension RegexMatchesSequence: Sequence {
   /// Returns the index to start searching for the next match after `match`.
   fileprivate func searchIndex(after match: Regex<Output>.Match) -> String.Index? {
     if !match.range.isEmpty {
@@ -218,7 +41,7 @@ extension RegexMatchesCollection: Sequence {
     
     // If the last match was an empty match, advance by one position and
     // run again, unless at the end of `input`.
-    if match.range.lowerBound == input.endIndex {
+    guard match.range.lowerBound < subjectBounds.upperBound else {
       return nil
     }
     
@@ -231,29 +54,26 @@ extension RegexMatchesCollection: Sequence {
   }
 
   struct Iterator: IteratorProtocol {
-    let base: RegexMatchesCollection
+    let base: RegexMatchesSequence
     
     // Because `RegexMatchesCollection` eagerly computes the first match for
     // its `startIndex`, the iterator can use that match for its initial
     // iteration. For subsequent calls to `next()`, this value is `false`, and
     // `nextStart` is used to search for the next match.
     var initialIteration = true
-    var nextStart: String.Index?
-    
-    init(_ matches: RegexMatchesCollection) {
+
+    // Set to nil when iteration is finished (because some regex can empty-match
+    // at the end of the subject).
+    var currentPosition: String.Index?
+
+    init(_ matches: RegexMatchesSequence) {
       self.base = matches
-      self.nextStart = base.startIndex.match.flatMap(base.searchIndex(after:))
+      self.currentPosition = base.subjectBounds.lowerBound
     }
     
     mutating func next() -> Regex<Output>.Match? {
-      // Initial case with pre-computed first match
-      if initialIteration {
-        initialIteration = false
-        return base.startIndex.match
-      }
-      
-      // `nextStart` is `nil` when iteration has completed
-      guard let start = nextStart, start <= base.searchBounds.upperBound else {
+      // `currentPosition` is `nil` when iteration has completed
+      guard let position = currentPosition, position <= base.searchBounds.upperBound else {
         return nil
       }
       
@@ -261,8 +81,8 @@ extension RegexMatchesCollection: Sequence {
       let match = try? base.regex._firstMatch(
         base.input,
         subjectBounds: base.subjectBounds,
-        searchBounds: start..<base.searchBounds.upperBound)
-      nextStart = match.flatMap(base.searchIndex(after:))
+        searchBounds: position..<base.searchBounds.upperBound)
+      currentPosition = match.flatMap(base.searchIndex(after:))
       return match
     }
   }
@@ -272,85 +92,13 @@ extension RegexMatchesCollection: Sequence {
   }
 }
 
-@available(SwiftStdlib 5.7, *)
-extension RegexMatchesCollection: Collection {
-  enum Index: Comparable {
-    case match(Regex<Output>.Match)
-    case end
-    
-    var match: Regex<Output>.Match? {
-      switch self {
-      case .match(let match): return match
-      case .end: return nil
-      }
-    }
-    
-    static func == (lhs: Self, rhs: Self) -> Bool {
-      switch (lhs, rhs) {
-      case (.match(let lhs), .match(let rhs)):
-        return lhs.range == rhs.range
-      case (.end, .end):
-        return true
-      case (.end, .match), (.match, .end):
-        return false
-      }
-    }
-    
-    static func < (lhs: Self, rhs: Self) -> Bool {
-      switch (lhs, rhs) {
-      case (.match(let lhs), .match(let rhs)):
-        // This implementation uses a tuple comparison so that an empty
-        // range `i..<i` will be ordered before a non-empty range at that
-        // same starting point `i..<j`. As of 2022-05-30, `Regex` does not
-        // return matches of this kind, but that is one behavior under
-        // discussion for regexes like /a*|b/ when matched against "b".
-        return (lhs.range.lowerBound, lhs.range.upperBound)
-          < (rhs.range.lowerBound, rhs.range.upperBound)
-      case (.match, .end):
-        return true
-      case (.end, .match), (.end, .end):
-        return false
-      }
-    }
-  }
-  
-  var endIndex: Index {
-    Index.end
-  }
-  
-  func index(after i: Index) -> Index {
-    guard let currentMatch = i.match else {
-      fatalError("Can't advance past the 'endIndex' of a match collection.")
-    }
-    
-    guard
-      let start = searchIndex(after: currentMatch),
-      start <= searchBounds.upperBound,
-      let nextMatch = try? regex._firstMatch(
-        input,
-        subjectBounds: subjectBounds,
-        searchBounds: start..<searchBounds.upperBound)
-    else {
-      return .end
-    }
-    return Index.match(nextMatch)
-  }
-  
-  subscript(position: Index) -> Regex<Output>.Match {
-    guard let match = position.match else {
-      fatalError("Can't subscript the 'endIndex' of a match collection.")
-    }
-    return match
-  }
-}
-
 extension BidirectionalCollection where SubSequence == Substring {
   @available(SwiftStdlib 5.7, *)
   @_disfavoredOverload
   func _matches<R: RegexComponent>(
     of regex: R
-  ) -> RegexMatchesCollection<R.RegexOutput> {
-    RegexMatchesCollection(
+  ) -> RegexMatchesSequence<R.RegexOutput> {
+    RegexMatchesSequence(
       input: self[...].base,
       subjectBounds: startIndex..<endIndex,
       searchBounds: startIndex..<endIndex,
diff --git a/Sources/_StringProcessing/Algorithms/Matching/MatchingCollectionConsumer.swift b/Sources/_StringProcessing/Algorithms/Matching/MatchingCollectionConsumer.swift
deleted file mode 100644
index ae3a24d4e..000000000
--- a/Sources/_StringProcessing/Algorithms/Matching/MatchingCollectionConsumer.swift
+++ /dev/null
@@ -1,48 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// This source file is part of the Swift.org open source project
-//
-// Copyright (c) 2021-2022 Apple Inc. and the Swift project authors
-// Licensed under Apache License v2.0 with Runtime Library Exception
-//
-// See https://swift.org/LICENSE.txt for license information
-//
-//===----------------------------------------------------------------------===//
-
-protocol MatchingCollectionConsumer: CollectionConsumer {
-  associatedtype Match
-  func matchingConsuming(
-    _ consumed: Consumed,
-    in range: Range<Consumed.Index>
-  ) -> (upperBound: Consumed.Index, match: Match)?
-}
-
-extension MatchingCollectionConsumer {
-  func consuming(
-    _ consumed: Consumed,
-    in range: Range<Consumed.Index>
-  ) -> Consumed.Index? {
-    matchingConsuming(consumed, in: range)?.upperBound
-  }
-}
-
-// MARK: Consuming from the back
-
-protocol BidirectionalMatchingCollectionConsumer:
-  MatchingCollectionConsumer, BidirectionalCollectionConsumer
-{
-  func matchingConsumingBack(
-    _ consumed: Consumed,
-    in range: Range<Consumed.Index>
-  ) -> (lowerBound: Consumed.Index, match: Match)?
-}
-
-extension BidirectionalMatchingCollectionConsumer {
-  func consumingBack(
-    _ consumed: Consumed,
-    in range: Range<Consumed.Index>
-  ) -> Consumed.Index? {
-    matchingConsumingBack(consumed, in: range)?.lowerBound
-  }
-}
-
diff --git a/Sources/_StringProcessing/Algorithms/Matching/MatchingCollectionSearcher.swift b/Sources/_StringProcessing/Algorithms/Matching/MatchingCollectionSearcher.swift
index 902d94591..b75f30c73 100644
--- a/Sources/_StringProcessing/Algorithms/Matching/MatchingCollectionSearcher.swift
+++ b/Sources/_StringProcessing/Algorithms/Matching/MatchingCollectionSearcher.swift
@@ -25,107 +25,3 @@ extension MatchingCollectionSearcher {
     matchingSearch(searched, &state)?.range
   }
 }
-
-protocol MatchingStatelessCollectionSearcher:
-  MatchingCollectionSearcher, StatelessCollectionSearcher
-{
-  func matchingSearch(
-    _ searched: Searched,
-    in range: Range<Searched.Index>
-  ) -> (range: Range<Searched.Index>, match: Match)?
-}
-
-extension MatchingStatelessCollectionSearcher {
-  // for disambiguation between the `MatchingCollectionSearcher` and
-  // `StatelessCollectionSearcher` overloads
-  func search(
-    _ searched: Searched,
-    _ state: inout State
-  ) -> Range<Searched.Index>? {
-    matchingSearch(searched, &state)?.range
-  }
-  
-  func matchingSearch(
-    _ searched: Searched,
-    _ state: inout State
-  ) -> (range: Range<Searched.Index>, match: Match)? {
-    // TODO: deduplicate this logic with `StatelessCollectionSearcher`?
-    
-    guard
-      case .index(let index) = state.position,
-      let (range, value) = matchingSearch(searched, in: index..<state.end)
-    else { return nil }
-    
-    if range.isEmpty {
-      if range.upperBound == searched.endIndex {
-        state.position = .done
-      } else {
-        state.position = .index(searched.index(after: range.upperBound))
-      }
-    } else {
-      state.position = .index(range.upperBound)
-    }
-    
-    return (range, value)
-  }
-  
-  func search(
-    _ searched: Searched,
-    in range: Range<Searched.Index>
-  ) -> Range<Searched.Index>? {
-    matchingSearch(searched, in: range)?.range
-  }
-}
-
-// MARK: Searching from the back
-
-protocol BackwardMatchingCollectionSearcher: BackwardCollectionSearcher {
-  associatedtype Match
-  func matchingSearchBack(
-    _ searched: BackwardSearched,
-    _ state: inout BackwardState
-  ) -> (range: Range<BackwardSearched.Index>, match: Match)?
-}
-
-protocol BackwardMatchingStatelessCollectionSearcher:
-  BackwardMatchingCollectionSearcher, BackwardStatelessCollectionSearcher
-{
-  func matchingSearchBack(
-    _ searched: BackwardSearched,
-    in range: Range<BackwardSearched.Index>
-  ) -> (range: Range<BackwardSearched.Index>, match: Match)?
-}
-
-extension BackwardMatchingStatelessCollectionSearcher {
-  func searchBack(
-    _ searched: BackwardSearched,
-    in range: Range<BackwardSearched.Index>
-  ) -> Range<BackwardSearched.Index>? {
-    matchingSearchBack(searched, in: range)?.range
-  }
-  
-  func matchingSearchBack(
-    _ searched: BackwardSearched,
-    _ state: inout BackwardState) -> (range: Range<BackwardSearched.Index>, match: Match)?
-  {
-    // TODO: deduplicate this logic with `StatelessBackwardCollectionSearcher`?
-    
-    guard
-      case .index(let index) = state.position,
-      let (range, value) = matchingSearchBack(searched, in: state.end..<index)
-    else { return nil }
-    
-    
-    if range.isEmpty {
-      if range.lowerBound == searched.startIndex {
-        state.position = .done
-      } else {
-        state.position = .index(searched.index(before: range.lowerBound))
-      }
-    } else {
-      state.position = .index(range.lowerBound)
-    }
-    
-    return (range, value)
-  }
-}
diff --git a/Sources/_StringProcessing/Algorithms/Searchers/CollectionSearcher.swift b/Sources/_StringProcessing/Algorithms/Searchers/CollectionSearcher.swift
index 5eb199086..c31ab8c89 100644
--- a/Sources/_StringProcessing/Algorithms/Searchers/CollectionSearcher.swift
+++ b/Sources/_StringProcessing/Algorithms/Searchers/CollectionSearcher.swift
@@ -69,57 +69,3 @@ extension StatelessCollectionSearcher {
   }
 }
 
-// MARK: Searching from the back
-
-protocol BackwardCollectionSearcher {
-  associatedtype BackwardSearched: BidirectionalCollection
-  associatedtype BackwardState
-  
-  func backwardState(
-    for searched: BackwardSearched,
-    in range: Range<BackwardSearched.Index>) -> BackwardState
-  func searchBack(
-    _ searched: BackwardSearched,
-    _ state: inout BackwardState
-  ) -> Range<BackwardSearched.Index>?
-}
-
-protocol BackwardStatelessCollectionSearcher: BackwardCollectionSearcher
-  where BackwardState == DefaultSearcherState<BackwardSearched>
-{
-  func searchBack(
-    _ searched: BackwardSearched,
-    in range: Range<BackwardSearched.Index>
-  ) -> Range<BackwardSearched.Index>?
-}
-
-extension BackwardStatelessCollectionSearcher {
-  func backwardState(
-    for searched: BackwardSearched,
-    in range: Range<BackwardSearched.Index>
-  ) -> BackwardState {
-    BackwardState(position: .index(range.upperBound), end: range.lowerBound)
-  }
-  
-  func searchBack(
-    _ searched: BackwardSearched,
-    _ state: inout BackwardState) -> Range<BackwardSearched.Index>? {
-    guard
-      case .index(let index) = state.position,
-      let range = searchBack(searched, in: state.end..<index)
-    else { return nil }
-    
-    
-    if range.isEmpty {
-      if range.lowerBound == searched.startIndex {
-        state.position = .done
-      } else {
-        state.position = .index(searched.index(before: range.lowerBound))
-      }
-    } else {
-      state.position = .index(range.lowerBound)
-    }
-    
-    return range
-  }
-}
diff --git a/Sources/_StringProcessing/Algorithms/Searchers/ConsumerSearcher.swift b/Sources/_StringProcessing/Algorithms/Searchers/ConsumerSearcher.swift
deleted file mode 100644
index 0670daa44..000000000
--- a/Sources/_StringProcessing/Algorithms/Searchers/ConsumerSearcher.swift
+++ /dev/null
@@ -1,109 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// This source file is part of the Swift.org open source project
-//
-// Copyright (c) 2021-2022 Apple Inc. and the Swift project authors
-// Licensed under Apache License v2.0 with Runtime Library Exception
-//
-// See https://swift.org/LICENSE.txt for license information
-//
-//===----------------------------------------------------------------------===//
-
-/// A collection searcher that naively searches the input by repeatedly trying to consume it using the underlying consumer.
-struct ConsumerSearcher<Consumer: CollectionConsumer> {
-  let consumer: Consumer
-}
-
-extension ConsumerSearcher: StatelessCollectionSearcher {
-  typealias Searched = Consumer.Consumed
-  
-  func search(
-    _ searched: Searched,
-    in range: Range<Searched.Index>
-  ) -> Range<Searched.Index>? {
-    var start = range.lowerBound
-    while true {
-      if let end = consumer.consuming(searched, in: start..<range.upperBound) {
-        return start..<end
-      } else if start == range.upperBound {
-        return nil
-      } else {
-        searched.formIndex(after: &start)
-      }
-    }
-  }
-}
-
-extension ConsumerSearcher: BackwardCollectionSearcher,
-                            BackwardStatelessCollectionSearcher
-  where Consumer: BidirectionalCollectionConsumer
-{
-  typealias BackwardSearched = Consumer.Consumed
-  
-  func searchBack(
-    _ searched: BackwardSearched,
-    in range: Range<Searched.Index>
-  ) -> Range<Searched.Index>? {
-    var end = range.upperBound
-    while true {
-      if let start = consumer.consumingBack(
-        searched, in: range.lowerBound..<end) {
-        return start..<end
-      } else if end == searched.startIndex {
-        return nil
-      } else {
-        searched.formIndex(before: &end)
-      }
-    }
-  }
-}
-
-extension ConsumerSearcher: MatchingCollectionSearcher,
-                            MatchingStatelessCollectionSearcher
-  where Consumer: MatchingCollectionConsumer
-{
-  typealias Match = Consumer.Match
-  
-  func matchingSearch(
-    _ searched: Searched,
-    in range: Range<Searched.Index>
-  ) -> (range: Range<Searched.Index>, match: Consumer.Match)? {
-    var start = range.lowerBound
-    while true {
-      if let (end, value) = consumer.matchingConsuming(
-        searched,
-        in: start..<range.upperBound
-      ) {
-        return (start..<end, value)
-      } else if start == range.upperBound {
-        return nil
-      } else {
-        searched.formIndex(after: &start)
-      }
-    }
-  }
-}
-
-extension ConsumerSearcher: BackwardMatchingCollectionSearcher,
-                            BackwardMatchingStatelessCollectionSearcher
-  where Consumer: BidirectionalMatchingCollectionConsumer
-{
-  typealias Match = Consumer.Match
-  
-  func matchingSearchBack(
-    _ searched: BackwardSearched,
-    in range: Range<Searched.Index>
-  ) -> (range: Range<Searched.Index>, match: Match)? {
-    var end = range.upperBound
-    while true {
-      if let (start, value) = consumer.matchingConsumingBack(
-        searched, in: range.lowerBound..<end) {
-        return (start..<end, value)
-      } else if end == searched.startIndex {
-        return nil
-      } else {
-        searched.formIndex(before: &end)
-      }
-    }
-  }
-}
diff --git a/Sources/_StringProcessing/Algorithms/Searchers/NaivePatternSearcher.swift b/Sources/_StringProcessing/Algorithms/Searchers/NaivePatternSearcher.swift
deleted file mode 100644
index 2052d46fe..000000000
--- a/Sources/_StringProcessing/Algorithms/Searchers/NaivePatternSearcher.swift
+++ /dev/null
@@ -1,93 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// This source file is part of the Swift.org open source project
-//
-// Copyright (c) 2021-2022 Apple Inc. and the Swift project authors
-// Licensed under Apache License v2.0 with Runtime Library Exception
-//
-// See https://swift.org/LICENSE.txt for license information
-//
-//===----------------------------------------------------------------------===//
-
-struct NaivePatternSearcher<Searched: Collection, Pattern: Collection>
-  where Searched.Element: Equatable, Pattern.Element == Searched.Element
-{
-  let pattern: Pattern
-}
-
-extension NaivePatternSearcher: StatelessCollectionSearcher {
-  func search(
-    _ searched: Searched,
-    in range: Range<Searched.Index>
-  ) -> Range<Searched.Index>? {
-    var searchStart = range.lowerBound
-    
-    guard let patternFirst = pattern.first else {
-      return searchStart..<searchStart
-    }
-    
-    while let matchStart = searched[searchStart..<range.upperBound]
-            .firstIndex(of: patternFirst)
-    {
-      var index = matchStart
-      var patternIndex = pattern.startIndex
-      
-      repeat {
-        searched.formIndex(after: &index)
-        pattern.formIndex(after: &patternIndex)
-        
-        if patternIndex == pattern.endIndex {
-          return matchStart..<index
-        } else if index == range.upperBound {
-          return nil
-        }
-      } while searched[index] == pattern[patternIndex]
-      
-      searchStart = searched.index(after: matchStart)
-    }
-    
-    return nil
-  }
-}
-
-extension NaivePatternSearcher: BackwardCollectionSearcher,
-                                BackwardStatelessCollectionSearcher
-  where Searched: BidirectionalCollection, Pattern: BidirectionalCollection
-{
-  typealias BackwardSearched = Searched
-  
-  func searchBack(
-    _ searched: BackwardSearched,
-    in range: Range<Searched.Index>
-  ) -> Range<Searched.Index>? {
-    var searchEnd = range.upperBound
-
-    guard let otherLastIndex = pattern.indices.last else {
-      return searchEnd..<searchEnd
-    }
-    
-    let patternLast = pattern[otherLastIndex]
-    
-    while let matchEnd = searched[range.lowerBound..<searchEnd]
-            .lastIndex(of: patternLast)
-    {
-      var index = matchEnd
-      var otherIndex = otherLastIndex
-      
-      repeat {
-        if otherIndex == pattern.startIndex {
-          return index..<searched.index(after: matchEnd)
-        } else if index == range.lowerBound {
-          return nil
-        }
-        
-        searched.formIndex(before: &index)
-        pattern.formIndex(before: &otherIndex)
-      } while searched[index] == pattern[otherIndex]
-      
-      searchEnd = matchEnd
-    }
-    
-    return nil
-  }
-}
diff --git a/Sources/_StringProcessing/Algorithms/Searchers/PatternOrEmpty.swift b/Sources/_StringProcessing/Algorithms/Searchers/PatternOrEmpty.swift
deleted file mode 100644
index 3b3fe22f9..000000000
--- a/Sources/_StringProcessing/Algorithms/Searchers/PatternOrEmpty.swift
+++ /dev/null
@@ -1,65 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// This source file is part of the Swift.org open source project
-//
-// Copyright (c) 2021-2022 Apple Inc. and the Swift project authors
-// Licensed under Apache License v2.0 with Runtime Library Exception
-//
-// See https://swift.org/LICENSE.txt for license information
-//
-//===----------------------------------------------------------------------===//
-
-/// Wraps a searcher that searches for a given pattern. If the pattern is empty, falls back on matching every empty index range exactly once.
-struct PatternOrEmpty<Searcher: CollectionSearcher> {
-  let searcher: Searcher?
-}
-
-extension PatternOrEmpty: CollectionSearcher {
-  typealias Searched = Searcher.Searched
-  
-  struct State {
-    enum Representation {
-      case state(Searcher.State)
-      case empty(index: Searched.Index, end: Searched.Index)
-      case emptyDone
-    }
-    
-    let representation: Representation
-  }
-  
-  func state(
-    for searched: Searcher.Searched,
-    in range: Range<Searched.Index>
-  ) -> State {
-    if let searcher = searcher {
-      return State(
-        representation: .state(searcher.state(for: searched, in: range)))
-    } else {
-      return State(
-        representation: .empty(index: range.lowerBound, end: range.upperBound))
-    }
-  }
-  
-  func search(
-    _ searched: Searched,
-    _ state: inout State
-  ) -> Range<Searched.Index>? {
-    switch state.representation {
-    case .state(var s):
-      // TODO: Avoid a potential copy-on-write copy here
-      let result = searcher!.search(searched, &s)
-      state = State(representation: .state(s))
-      return result
-    case .empty(let index, let end):
-      if index == end {
-        state = State(representation: .emptyDone)
-      } else {
-        state = State(
-          representation: .empty(index: searched.index(after: index), end: end))
-      }
-      return index..<index
-    case .emptyDone:
-      return nil
-    }
-  }
-}
diff --git a/Sources/_StringProcessing/Algorithms/Searchers/PredicateSearcher.swift b/Sources/_StringProcessing/Algorithms/Searchers/PredicateSearcher.swift
deleted file mode 100644
index aac41fdff..000000000
--- a/Sources/_StringProcessing/Algorithms/Searchers/PredicateSearcher.swift
+++ /dev/null
@@ -1,44 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// This source file is part of the Swift.org open source project
-//
-// Copyright (c) 2021-2022 Apple Inc. and the Swift project authors
-// Licensed under Apache License v2.0 with Runtime Library Exception
-//
-// See https://swift.org/LICENSE.txt for license information
-//
-//===----------------------------------------------------------------------===//
-
-struct PredicateSearcher<Searched: Collection> {
-  let predicate: (Searched.Element) -> Bool
-}
-
-extension PredicateSearcher: StatelessCollectionSearcher {
-  func search(
-    _ searched: Searched,
-    in range: Range<Searched.Index>
-  ) -> Range<Searched.Index>? {
-    guard let index = searched[range].firstIndex(where: predicate) else {
-      return nil
-    }
-    return index..<searched.index(after: index)
-  }
-}
-
-extension PredicateSearcher: BackwardCollectionSearcher,
-                             BackwardStatelessCollectionSearcher
-  where Searched: BidirectionalCollection
-{
-  typealias BackwardSearched = Searched
-  
-  func searchBack(
-    _ searched: BackwardSearched,
-    in range: Range<Searched.Index>
-  ) -> Range<Searched.Index>? {
-    guard let index = searched[range].lastIndex(where: predicate) else {
-      return nil
-    }
-    return index..<searched.index(after: index)
-  }
-}
-
diff --git a/Sources/_StringProcessing/CMakeLists.txt b/Sources/_StringProcessing/CMakeLists.txt
index eccd3cee3..3b00470ff 100644
--- a/Sources/_StringProcessing/CMakeLists.txt
+++ b/Sources/_StringProcessing/CMakeLists.txt
@@ -9,20 +9,13 @@ add_library(_StringProcessing
   Algorithms/Algorithms/Trim.swift
   Algorithms/Consumers/CollectionConsumer.swift
   Algorithms/Consumers/FixedPatternConsumer.swift
-  Algorithms/Consumers/ManyConsumer.swift
-  Algorithms/Consumers/PredicateConsumer.swift
   Algorithms/Consumers/RegexConsumer.swift
   Algorithms/Matching/FirstMatch.swift
   Algorithms/Matching/Matches.swift
-  Algorithms/Matching/MatchingCollectionConsumer.swift
   Algorithms/Matching/MatchingCollectionSearcher.swift
   Algorithms/Matching/MatchReplace.swift
   Algorithms/Matching/MatchResult.swift
   Algorithms/Searchers/CollectionSearcher.swift
-  Algorithms/Searchers/ConsumerSearcher.swift
-  Algorithms/Searchers/NaivePatternSearcher.swift
-  Algorithms/Searchers/PatternOrEmpty.swift
-  Algorithms/Searchers/PredicateSearcher.swift
   Algorithms/Searchers/ZSearcher.swift
   Engine/Backtracking.swift
   Engine/Consume.swift
diff --git a/Tests/RegexTests/AlgorithmsInternalsTests.swift b/Tests/RegexTests/AlgorithmsInternalsTests.swift
index af0007bbe..6a604e26f 100644
--- a/Tests/RegexTests/AlgorithmsInternalsTests.swift
+++ b/Tests/RegexTests/AlgorithmsInternalsTests.swift
@@ -54,21 +54,8 @@ extension AlgorithmTests {
     ]
 
     // Make sure we're getting the right collection type
-    let _: RegexMatchesCollection<Substring> = matches
+    let _: RegexMatchesSequence<Substring> = matches
 
     XCTAssertEqual(matches.map(\.output), expected)
-    
-    let i = matches.index(matches.startIndex, offsetBy: 3)
-    XCTAssertEqual(matches[i].output, expected[3])
-    let j = matches.index(i, offsetBy: 5)
-    XCTAssertEqual(j, matches.endIndex)
-    
-    var index = matches.startIndex
-    while index < matches.endIndex {
-      XCTAssertEqual(
-        matches[index].output,
-        expected[matches.distance(from: matches.startIndex, to: index)])
-      matches.formIndex(after: &index)
-    }
   }
 }

From e0905ab7af5eb49ffcc4e6ce0f3f1d88b906249c Mon Sep 17 00:00:00 2001
From: Michael Ilseman <michael.ilseman@gmail.com>
Date: Wed, 9 Oct 2024 14:32:37 -0600
Subject: [PATCH 2/7] wip: dont create array

---
 .../Algorithms/Algorithms/Replace.swift                | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/Sources/_StringProcessing/Algorithms/Algorithms/Replace.swift b/Sources/_StringProcessing/Algorithms/Algorithms/Replace.swift
index c67cfbfbd..fae7b88ed 100644
--- a/Sources/_StringProcessing/Algorithms/Algorithms/Replace.swift
+++ b/Sources/_StringProcessing/Algorithms/Algorithms/Replace.swift
@@ -49,13 +49,15 @@ extension RangeReplaceableCollection {
     
     var result = Self()
     var index = startIndex
-    
-    // `maxRanges` is a workaround for https://github.com/apple/swift/issues/59522
-    let maxRanges = ranges.prefix(maxReplacements)
-    for range in maxRanges {
+    var replacements = 0
+
+    for range in ranges {
+      if replacements == maxReplacements { break }
+
       result.append(contentsOf: self[index..<range.lowerBound])
       result.append(contentsOf: replacement)
       index = range.upperBound
+      replacements += 1
     }
     
     result.append(contentsOf: self[index...])

From 840c602bf36ce428dc78708a3db18f7e70718cc8 Mon Sep 17 00:00:00 2001
From: Michael Ilseman <michael.ilseman@gmail.com>
Date: Wed, 9 Oct 2024 14:49:16 -0600
Subject: [PATCH 3/7] Update
 Sources/_StringProcessing/Algorithms/Algorithms/Ranges.swift

Co-authored-by: Nate Cook <natecook@apple.com>
---
 Sources/_StringProcessing/Algorithms/Algorithms/Ranges.swift | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Sources/_StringProcessing/Algorithms/Algorithms/Ranges.swift b/Sources/_StringProcessing/Algorithms/Algorithms/Ranges.swift
index 57834a324..5f0f0479d 100644
--- a/Sources/_StringProcessing/Algorithms/Algorithms/Ranges.swift
+++ b/Sources/_StringProcessing/Algorithms/Algorithms/Ranges.swift
@@ -29,7 +29,7 @@ struct RangesSequence<Searcher: CollectionSearcher> {
       self.state = base.searcher.state(for: base.input, in: base.input.startIndex..<base.input.endIndex)
     }
 
-    public mutating func next() -> Range<Searcher.Searched.Index>? {
+    mutating func next() -> Range<Searcher.Searched.Index>? {
       base.searcher.search(base.input, &state)
     }
   }

From bb4b619bb0b5541be7e211596a1b880b8afd1b96 Mon Sep 17 00:00:00 2001
From: Michael Ilseman <michael.ilseman@gmail.com>
Date: Wed, 9 Oct 2024 14:49:25 -0600
Subject: [PATCH 4/7] Update
 Sources/_StringProcessing/Algorithms/Algorithms/Ranges.swift

Co-authored-by: Nate Cook <natecook@apple.com>
---
 Sources/_StringProcessing/Algorithms/Algorithms/Ranges.swift | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Sources/_StringProcessing/Algorithms/Algorithms/Ranges.swift b/Sources/_StringProcessing/Algorithms/Algorithms/Ranges.swift
index 5f0f0479d..a82fb875c 100644
--- a/Sources/_StringProcessing/Algorithms/Algorithms/Ranges.swift
+++ b/Sources/_StringProcessing/Algorithms/Algorithms/Ranges.swift
@@ -36,7 +36,7 @@ struct RangesSequence<Searcher: CollectionSearcher> {
 }
 
 extension RangesSequence: Sequence {
-  public func makeIterator() -> Iterator {
+  func makeIterator() -> Iterator {
     Iterator(self)
   }
 }

From f59dc411f4efc068b0bba991840f396f12df2a15 Mon Sep 17 00:00:00 2001
From: Michael Ilseman <michael.ilseman@gmail.com>
Date: Wed, 9 Oct 2024 14:49:53 -0600
Subject: [PATCH 5/7] Update
 Sources/_StringProcessing/Algorithms/Algorithms/Split.swift

---
 Sources/_StringProcessing/Algorithms/Algorithms/Split.swift | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Sources/_StringProcessing/Algorithms/Algorithms/Split.swift b/Sources/_StringProcessing/Algorithms/Algorithms/Split.swift
index b722932b9..5b71ca433 100644
--- a/Sources/_StringProcessing/Algorithms/Algorithms/Split.swift
+++ b/Sources/_StringProcessing/Algorithms/Algorithms/Split.swift
@@ -12,7 +12,7 @@
 // MARK: `SplitCollection`
 
 struct SplitSequence<Searcher: CollectionSearcher> {
-  public typealias Input = Searcher.Searched
+  typealias Input = Searcher.Searched
   
   let ranges: RangesSequence<Searcher>
   var maxSplits: Int

From 35465900c4ff780bbe103fbbbec97ce285b4bb64 Mon Sep 17 00:00:00 2001
From: Michael Ilseman <michael.ilseman@gmail.com>
Date: Wed, 9 Oct 2024 14:50:23 -0600
Subject: [PATCH 6/7] Update
 Sources/_StringProcessing/Algorithms/Algorithms/Split.swift

---
 Sources/_StringProcessing/Algorithms/Algorithms/Split.swift | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Sources/_StringProcessing/Algorithms/Algorithms/Split.swift b/Sources/_StringProcessing/Algorithms/Algorithms/Split.swift
index 5b71ca433..7a4a3b283 100644
--- a/Sources/_StringProcessing/Algorithms/Algorithms/Split.swift
+++ b/Sources/_StringProcessing/Algorithms/Algorithms/Split.swift
@@ -41,7 +41,7 @@ struct SplitSequence<Searcher: CollectionSearcher> {
 }
 
 extension SplitSequence: Sequence {
-  public struct Iterator: IteratorProtocol {
+  struct Iterator: IteratorProtocol {
     var ranges: RangesSequence<Searcher>.Iterator
     var index: Input.Index
 

From 676c7dbd924e287fdf93176e6cd9e4229875975b Mon Sep 17 00:00:00 2001
From: Michael Ilseman <michael.ilseman@gmail.com>
Date: Wed, 9 Oct 2024 14:53:53 -0600
Subject: [PATCH 7/7] remove more superfluous publics

---
 Sources/_StringProcessing/Algorithms/Algorithms/Split.swift | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Sources/_StringProcessing/Algorithms/Algorithms/Split.swift b/Sources/_StringProcessing/Algorithms/Algorithms/Split.swift
index 7a4a3b283..de92c0d8a 100644
--- a/Sources/_StringProcessing/Algorithms/Algorithms/Split.swift
+++ b/Sources/_StringProcessing/Algorithms/Algorithms/Split.swift
@@ -63,7 +63,7 @@ extension SplitSequence: Sequence {
       self.omittingEmptySubsequences = omittingEmptySubsequences
     }
     
-    public mutating func next() -> Input.SubSequence? {
+    mutating func next() -> Input.SubSequence? {
       guard !isDone else { return nil }
       
       /// Return the rest of base if it's non-empty or we're including
@@ -101,7 +101,7 @@ extension SplitSequence: Sequence {
     }
   }
   
-  public func makeIterator() -> Iterator {
+  func makeIterator() -> Iterator {
     Iterator(ranges: ranges, maxSplits: maxSplits, omittingEmptySubsequences: omittingEmptySubsequences)
   }
 }