Revised algorithm 5 7

Package.swift

@@ -29,7 +29,6 @@ let package = Package(
     ],
     dependencies: [
         .package(url: "https://github.com/apple/swift-argument-parser", from: "1.0.0"),
-        .package(url: "https://github.com/apple/swift-docc-plugin", from: "1.0.0"),
     ],
     targets: [
         // Targets are the basic building blocks of a package. A target can define a module or a test suite.

Sources/_StringProcessing/Regex/CustomComponents.swift

@@ -0,0 +1,39 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+@available(SwiftStdlib 5.7, *)
+/// A protocol allowing custom types to function as regex components by
+/// providing the raw functionality backing `prefixMatch`.
+public protocol CustomConsumingRegexComponent: RegexComponent {
+  /// Process the input string within the specified bounds, beginning at the given index, and return
+  /// the end position (upper bound) of the match and the produced output.
+  /// - Parameters:
+  ///   - input: The string in which the match is performed.
+  ///   - index: An index of `input` at which to begin matching.
+  ///   - bounds: The bounds in `input` in which the match is performed.
+  /// - Returns: The upper bound where the match terminates and a matched instance, or `nil` if
+  ///   there isn't a match.
+  func consuming(
+    _ input: String,
+    startingAt index: String.Index,
+    in bounds: Range<String.Index>
+  ) throws -> (upperBound: String.Index, output: RegexOutput)?
+}
+
+@available(SwiftStdlib 5.7, *)
+extension CustomConsumingRegexComponent {
+  public var regex: Regex<RegexOutput> {
+    let node: DSLTree.Node = .matcher(.init(RegexOutput.self), { input, index, bounds in
+      try consuming(input, startingAt: index, in: bounds)
+    })
+    return Regex(node: node)
+  }
+}

Tests/RegexBuilderTests/CustomTests.swift

@@ -14,13 +14,13 @@ import _StringProcessing
 @testable import RegexBuilder
 
 // A nibbler processes a single character from a string
-private protocol Nibbler: CustomMatchingRegexComponent {
+private protocol Nibbler: CustomConsumingRegexComponent {
   func nibble(_: Character) -> RegexOutput?
 }
 
 extension Nibbler {
   // Default implementation, just feed the character in
-  func match(
+  func consuming(
     _ input: String,
     startingAt index: String.Index,
     in bounds: Range<String.Index>
@@ -49,10 +49,10 @@ private struct Asciibbler: Nibbler {
   }
 }
 
-private struct IntParser: CustomMatchingRegexComponent {
+private struct IntParser: CustomConsumingRegexComponent {
   struct ParseError: Error, Hashable {}
   typealias RegexOutput = Int
-  func match(_ input: String,
+  func consuming(_ input: String,
     startingAt index: String.Index,
     in bounds: Range<String.Index>
   ) throws -> (upperBound: String.Index, output: Int)? {
@@ -71,7 +71,7 @@ private struct IntParser: CustomMatchingRegexComponent {
   }
 }
 
-private struct CurrencyParser: CustomMatchingRegexComponent {
+private struct CurrencyParser: CustomConsumingRegexComponent {
   enum Currency: String, Hashable {
     case usd = "USD"
     case ntd = "NTD"
@@ -84,7 +84,7 @@ private struct CurrencyParser: CustomMatchingRegexComponent {
   }
 
   typealias RegexOutput = Currency
-  func match(_ input: String,
+  func consuming(_ input: String,
              startingAt index: String.Index,
              in bounds: Range<String.Index>
   ) throws -> (upperBound: String.Index, output: Currency)? {

Tests/RegexBuilderTests/RegexDSLTests.swift

@@ -850,9 +850,9 @@ class RegexDSLTests: XCTestCase {
       var patch: Int
       var dev: String?
     }
-    struct SemanticVersionParser: CustomMatchingRegexComponent {
+    struct SemanticVersionParser: CustomConsumingRegexComponent {
       typealias RegexOutput = SemanticVersion
-      func match(
+      func consuming(
         _ input: String,
         startingAt index: String.Index,
         in bounds: Range<String.Index>