diff --git a/Sources/Exercises/Participants/RegexParticipant.swift b/Sources/Exercises/Participants/RegexParticipant.swift
index a73f9ecd0..d62ddc422 100644
--- a/Sources/Exercises/Participants/RegexParticipant.swift
+++ b/Sources/Exercises/Participants/RegexParticipant.swift
@@ -46,7 +46,7 @@ struct RegexLiteralParticipant: Participant {
 // MARK: - Regex literal
 
 private func extractFromCaptures(
-  _ match: Tuple4<Substring, Substring, Substring?, Substring>
+  _ match: (Substring, Substring, Substring?, Substring)
 ) -> GraphemeBreakEntry? {
   guard let lowerScalar = Unicode.Scalar(hex: match.1),
         let upperScalar = match.2.map(Unicode.Scalar.init(hex:)) ?? lowerScalar,
@@ -61,7 +61,7 @@ private func extractFromCaptures(
 private func graphemeBreakPropertyData<RP: RegexProtocol>(
   forLine line: String,
   using regex: RP
-) -> GraphemeBreakEntry? where RP.Match == Tuple4<Substring, Substring, Substring?, Substring> {
+) -> GraphemeBreakEntry? where RP.Match == (Substring, Substring, Substring?, Substring) {
   line.match(regex).map(\.match).flatMap(extractFromCaptures)
 }
 
@@ -71,7 +71,7 @@ private func graphemeBreakPropertyDataLiteral(
   return graphemeBreakPropertyData(
     forLine: line,
     using: r(#"([0-9A-F]+)(?:\.\.([0-9A-F]+))?\s+;\s+(\w+).*"#,
-             matching: Tuple4<Substring, Substring, Substring?, Substring>.self))
+             matching: (Substring, Substring, Substring?, Substring).self))
 }
 
 // MARK: - Builder DSL
@@ -80,18 +80,18 @@ private func graphemeBreakPropertyData(
   forLine line: String
 ) -> GraphemeBreakEntry? {
   line.match {
-    OneOrMore(.hexDigit).tryCapture(Unicode.Scalar.init(hex:))
-    Optionally {
+    oneOrMore(.hexDigit).tryCapture(Unicode.Scalar.init(hex:))
+    optionally {
       ".."
-      OneOrMore(.hexDigit).tryCapture(Unicode.Scalar.init(hex:))
+      oneOrMore(.hexDigit).tryCapture(Unicode.Scalar.init(hex:))
     }
-    OneOrMore(.whitespace)
+    oneOrMore(.whitespace)
     ";"
-    OneOrMore(.whitespace)
-    OneOrMore(.word).tryCapture(Unicode.GraphemeBreakProperty.init)
-    Repeat(.any)
+    oneOrMore(.whitespace)
+    oneOrMore(.word).tryCapture(Unicode.GraphemeBreakProperty.init)
+    many(.any)
   }.map {
-    let (_, lower, upper, property) = $0.match.tuple
+    let (_, lower, upper, property) = $0.match
     return GraphemeBreakEntry(lower...(upper ?? lower), property)
   }
 }
diff --git a/Sources/VariadicsGenerator/VariadicsGenerator.swift b/Sources/VariadicsGenerator/VariadicsGenerator.swift
index 130e51c27..c82f4b1ff 100644
--- a/Sources/VariadicsGenerator/VariadicsGenerator.swift
+++ b/Sources/VariadicsGenerator/VariadicsGenerator.swift
@@ -89,7 +89,7 @@ struct StandardErrorStream: TextOutputStream {
 var standardError = StandardErrorStream()
 
 typealias Counter = Int64
-let patternProtocolName = "RegexProtocol"
+let regexProtocolName = "RegexProtocol"
 let concatenationStructTypeBaseName = "Concatenate"
 let capturingGroupTypeBaseName = "CapturingGroup"
 let matchAssociatedTypeName = "Match"
@@ -97,7 +97,6 @@ let captureAssociatedTypeName = "Capture"
 let patternBuilderTypeName = "RegexBuilder"
 let patternProtocolRequirementName = "regex"
 let PatternTypeBaseName = "Regex"
-let emptyProtocolName = "EmptyCaptureProtocol"
 let baseMatchTypeName = "Substring"
 
 @main
@@ -128,13 +127,19 @@ struct VariadicsGenerator: ParsableCommand {
 
       """)
 
-    for arity in 2...maxArity+1 {
-      emitTupleStruct(arity: arity)
+    print("Generating 'buildBlock(_:)' overloads...", to: &standardError)
+    for arity in 1..<maxArity {
+      print("  Capture arity: \(arity)", to: &standardError)
+      emitUnaryBuildBlock(arity: arity)
     }
 
+    print("Generating concatenation overloads...", to: &standardError)
     for (leftArity, rightArity) in Permutations(totalArity: maxArity) {
+      guard rightArity != 0 else {
+        continue
+      }
       print(
-        "Left arity: \(leftArity)  Right arity: \(rightArity)",
+        "  Left arity: \(leftArity)  Right arity: \(rightArity)",
         to: &standardError)
       emitConcatenation(leftArity: leftArity, rightArity: rightArity)
     }
@@ -144,7 +149,20 @@ struct VariadicsGenerator: ParsableCommand {
     }
 
     output("\n\n")
-    output("// END AUTO-GENERATED CONTENT")
+
+    print("Generating quantifiers...", to: &standardError)
+    for arity in 0..<maxArity {
+      print("  Arity \(arity): ", terminator: "", to: &standardError)
+      for kind in QuantifierKind.allCases {
+        print("\(kind.rawValue) ", terminator: "", to: &standardError)
+        emitQuantifier(kind: kind, arity: arity)
+      }
+      print(to: &standardError)
+    }
+
+    output("\n\n")
+
+    output("// END AUTO-GENERATED CONTENT\n")
 
     print("Done!", to: &standardError)
   }
@@ -154,73 +172,22 @@ struct VariadicsGenerator: ParsableCommand {
     if arity == 0 {
       return genericParameters()
     }
-    return "Tuple\(arity)<\(genericParameters())>"
+    return "(\(genericParameters()))"
   }
 
-  func emitTupleStruct(arity: Int) {
-    output("""
-      @frozen @dynamicMemberLookup
-      public struct Tuple\(arity)<
-      """)
-    outputForEach(0..<arity, separator: ", ") {
-      "_\($0)"
-    }
-    output("> {")
-    // `public typealias Tuple = (_0, ...)`
-    output("\n  public typealias Tuple = (")
-    outputForEach(0..<arity, separator: ", ") { "_\($0)" }
-    output(")")
-    // `public var tuple: Tuple`
-    output("\n  public var tuple: Tuple\n")
-    // `subscript(dynamicMember:)`
+  func emitUnaryBuildBlock(arity: Int) {
+    assert(arity > 0)
+    let captureTypes = (0..<arity).map { "C\($0)" }.joined(separator: ", ")
     output("""
-        public subscript<T>(dynamicMember keyPath: WritableKeyPath<Tuple, T>) -> T {
-          get { tuple[keyPath: keyPath] }
-          _modify { yield &tuple[keyPath: keyPath] }
+      extension RegexBuilder {
+        public static func buildBlock<R: RegexProtocol, W, \(captureTypes)>(_ regex: R) -> R
+        where R.Match == (W, \(captureTypes))
+        {
+          regex
         }
-      """)
-    output("\n}\n")
-    output("extension Tuple\(arity): \(emptyProtocolName) where ")
-    outputForEach(1..<arity, separator: ", ") {
-      "_\($0): \(emptyProtocolName)"
-    }
-    output(" {}\n")
-    output("extension Tuple\(arity): MatchProtocol {\n")
-    output("  public typealias Capture = ")
-    if arity == 2 {
-      output("_1")
-    } else {
-      output("Tuple\(arity-1)<")
-      outputForEach(1..<arity, separator: ", ") {
-        "_\($0)"
       }
-      output(">")
-    }
-    output("\n  public init(_ tuple: Tuple) { self.tuple = tuple }")
-    // `public init(_0: _0, ...) { ... }`
-    output("\n  public init(")
-    outputForEach(0..<arity, separator: ", ") {
-      "_ _\($0): _\($0)"
-    }
-    output(") {\n")
-    output("    self.init((")
-    outputForEach(0..<arity, separator: ", ") { "_\($0)" }
-    output("))\n")
-    output("  }")
-    output("\n}\n")
-    // Equatable
-    output("extension Tuple\(arity): Equatable where ")
-    outputForEach(0..<arity, separator: ", ") {
-      "_\($0): Equatable"
-    }
-    output(" {\n")
-    output("  public static func == (lhs: Self, rhs: Self) -> Bool {\n")
-    output("    ")
-    outputForEach(0..<arity, separator: " && ") {
-      "lhs.tuple.\($0) == rhs.tuple.\($0)"
-    }
-    output("\n  }\n")
-    output("}\n")
+
+      """)
   }
 
   func emitConcatenation(leftArity: Int, rightArity: Int) {
@@ -231,7 +198,7 @@ struct VariadicsGenerator: ParsableCommand {
       }
       output(", ")
       if withConstraints {
-        output("R0: \(patternProtocolName), R1: \(patternProtocolName)")
+        output("R0: \(regexProtocolName), R1: \(regexProtocolName)")
       } else {
         output("R0, R1")
       }
@@ -240,11 +207,11 @@ struct VariadicsGenerator: ParsableCommand {
     // Emit concatenation type declaration.
 
     // public struct Concatenation2<W0, W1, C0, C1, R0: RegexProtocol, R1: RegexProtocol>: RegexProtocol
-    // where R0.Match == Tuple2<W0, C0>, R1.Match == Tuple2<W1, C1>
+    // where R0.Match == (W0, C0), R1.Match == (W1, C1)
     // {
-    //   public typealias Match = Tuple3<Substring, C0, C1>
+    //   public typealias Match = (Substring, C0, C1)
     //
-    //   public let regex: Regex<Tuple3<Substring, C0, C1>>
+    //   public let regex: Regex<(Substring, C0, C1)>
     //
     //   public init(_ r0: R0, _ r1: R1) {
     //     self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
@@ -268,38 +235,38 @@ struct VariadicsGenerator: ParsableCommand {
     let typeName = "\(concatenationStructTypeBaseName)_\(leftArity)_\(rightArity)"
     output("public struct \(typeName)<\n  ")
     emitGenericParameters(withConstraints: true)
-    output("\n>: \(patternProtocolName)")
+    output("\n>: \(regexProtocolName)")
     output(" where ")
     output("R0.Match == ")
     if leftArity == 0 {
       output("W0")
     } else {
-      output("Tuple\(leftArity+1)<W0")
+      output("(W0")
       outputForEach(0..<leftArity) {
         ", C\($0)"
       }
-      output(">")
+      output(")")
     }
     output(", R1.Match == ")
     if rightArity == 0 {
       output("W1")
     } else {
-      output("Tuple\(rightArity+1)<W1")
+      output("(W1")
       outputForEach(leftArity..<leftArity+rightArity) {
         ", C\($0)"
       }
-      output(">")
+      output(")")
     }
     output(" {\n")
     output("  public typealias \(matchAssociatedTypeName) = ")
     if leftArity+rightArity == 0 {
       output(baseMatchTypeName)
     } else {
-      output("Tuple\(leftArity+rightArity+1)<\(baseMatchTypeName), ")
+      output("(\(baseMatchTypeName), ")
       outputForEach(0..<leftArity+rightArity, separator: ", ") {
         "C\($0)"
       }
-      output(">")
+      output(")")
     }
     output("\n")
     output("  public let \(patternProtocolRequirementName): \(PatternTypeBaseName)<\(matchAssociatedTypeName)>\n")
@@ -337,41 +304,144 @@ struct VariadicsGenerator: ParsableCommand {
     // T + () = T
     output("""
        extension RegexBuilder {
+         @_disfavoredOverload
          public static func buildBlock<W0
        """)
     outputForEach(0..<leftArity) {
       ", C\($0)"
     }
     output("""
-      , R0: \(patternProtocolName), R1: \(patternProtocolName)>(
+      , R0: \(regexProtocolName), R1: \(regexProtocolName)>(
           combining next: R1, into combined: R0
         ) -> Regex<
       """)
     if leftArity == 0 {
       output(baseMatchTypeName)
     } else {
-      output("Tuple\(leftArity+1)<\(baseMatchTypeName)")
+      output("(\(baseMatchTypeName)")
       outputForEach(0..<leftArity) {
         ", C\($0)"
       }
-      output(">")
+      output(")")
     }
     output("> where R0.\(matchAssociatedTypeName) == ")
     if leftArity == 0 {
       output("W0")
     } else {
-      output("Tuple\(leftArity+1)<W0")
+      output("(W0")
       outputForEach(0..<leftArity) {
         ", C\($0)"
       }
-      output(">")
+      output(")")
     }
     output("""
-      , R1.\(matchAssociatedTypeName): \(emptyProtocolName) {
+        {
           .init(node: combined.regex.root.appending(next.regex.root))
         }
       }
 
       """)
   }
+
+  enum QuantifierKind: String, CaseIterable {
+    case zeroOrOne = "optionally"
+    case zeroOrMore = "many"
+    case oneOrMore = "oneOrMore"
+
+    var typeName: String {
+      switch self {
+      case .zeroOrOne: return "_ZeroOrOne"
+      case .zeroOrMore: return "_ZeroOrMore"
+      case .oneOrMore: return "_OneOrMore"
+      }
+    }
+
+    var operatorName: String {
+      switch self {
+      case .zeroOrOne: return ".?"
+      case .zeroOrMore: return ".+"
+      case .oneOrMore: return ".*"
+      }
+    }
+
+    var astQuantifierAmount: String {
+      switch self {
+      case .zeroOrOne: return "zeroOrOne"
+      case .zeroOrMore: return "zeroOrMore"
+      case .oneOrMore: return "oneOrMore"
+      }
+    }
+  }
+
+  func emitQuantifier(kind: QuantifierKind, arity: Int) {
+    assert(arity >= 0)
+    func genericParameters(withConstraints: Bool) -> String {
+      var result = ""
+      if arity > 0 {
+        result += "W"
+        result += (0..<arity).map { ", C\($0)" }.joined()
+        result += ", "
+      }
+      result += "Component"
+      if withConstraints {
+        result += ": \(regexProtocolName)"
+      }
+      return result
+    }
+    let captures = (0..<arity).map { "C\($0)" }.joined(separator: ", ")
+    let capturesTupled = arity == 1 ? captures : "(\(captures))"
+    let componentConstraint: String = arity == 0 ? "" :
+      "where Component.Match == (W, \(captures))"
+    let quantifiedCaptures: String = {
+      switch kind {
+      case .zeroOrOne:
+        return "\(capturesTupled)?"
+      case .zeroOrMore, .oneOrMore:
+        return "[\(capturesTupled)]"
+      }
+    }()
+    let matchType = arity == 0 ? baseMatchTypeName : "(\(baseMatchTypeName), \(quantifiedCaptures))"
+    output("""
+      public struct \(kind.typeName)_\(arity)<\(genericParameters(withConstraints: true))>: \(regexProtocolName) \(componentConstraint) {
+        public typealias \(matchAssociatedTypeName) = \(matchType)
+        public let regex: Regex<\(matchAssociatedTypeName)>
+        public init(component: Component) {
+          self.regex = .init(node: .quantification(.\(kind.astQuantifierAmount), .eager, component.regex.root))
+        }
+      }
+
+      \(arity == 0 ? "@_disfavoredOverload" : "")
+      public func \(kind.rawValue)<\(genericParameters(withConstraints: true))>(
+        _ component: Component
+      ) -> \(kind.typeName)_\(arity)<\(genericParameters(withConstraints: false))> {
+        .init(component: component)
+      }
+
+      \(arity == 0 ? "@_disfavoredOverload" : "")
+      public func \(kind.rawValue)<\(genericParameters(withConstraints: true))>(
+        @RegexBuilder _ component: () -> Component
+      ) -> \(kind.typeName)_\(arity)<\(genericParameters(withConstraints: false))> {
+        \(kind.rawValue)(component())
+      }
+
+      \(arity == 0 ? "@_disfavoredOverload" : "")
+      public postfix func \(kind.operatorName)<\(genericParameters(withConstraints: true))>(
+        _ component: Component
+      ) -> \(kind.typeName)_\(arity)<\(genericParameters(withConstraints: false))> {
+        \(kind.rawValue)(component)
+      }
+
+      \(kind == .zeroOrOne ?
+        """
+        extension RegexBuilder {
+          public static func buildLimitedAvailability<\(genericParameters(withConstraints: true))>(
+            _ component: Component
+          ) -> \(kind.typeName)_\(arity)<\(genericParameters(withConstraints: false))> {
+            \(kind.rawValue)(component)
+          }
+        }
+        """ : "")
+
+      """)
+  }
 }
diff --git a/Sources/_StringProcessing/RegexDSL/Builder.swift b/Sources/_StringProcessing/RegexDSL/Builder.swift
index 754dff219..f4b3516c3 100644
--- a/Sources/_StringProcessing/RegexDSL/Builder.swift
+++ b/Sources/_StringProcessing/RegexDSL/Builder.swift
@@ -16,12 +16,6 @@ public enum RegexBuilder {
     r0
   }
 
-  public static func buildBlock<R0: RegexProtocol>(
-    _ r0: R0
-  ) -> Regex<Substring> where R0.Match: EmptyCaptureProtocol {
-    .init(node: r0.regex.root)
-  }
-
   public static func buildExpression<R: RegexProtocol>(_ regex: R) -> R {
     regex
   }
@@ -33,10 +27,4 @@ public enum RegexBuilder {
   public static func buildEither<R: RegexProtocol>(second component: R) -> R {
     component
   }
-
-  public static func buildLimitedAvailability<R: RegexProtocol>(
-    _ component: R
-  ) -> Optionally<R> {
-    .init(component)
-  }
 }
diff --git a/Sources/_StringProcessing/RegexDSL/Concatenation.swift b/Sources/_StringProcessing/RegexDSL/Concatenation.swift
index 575384d33..c243b68c6 100644
--- a/Sources/_StringProcessing/RegexDSL/Concatenation.swift
+++ b/Sources/_StringProcessing/RegexDSL/Concatenation.swift
@@ -13,247 +13,73 @@
 
 import _MatchingEngine
 
-@frozen @dynamicMemberLookup
-public struct Tuple2<_0, _1> {
-  public typealias Tuple = (_0, _1)
-  public var tuple: Tuple
-  public subscript<T>(dynamicMember keyPath: WritableKeyPath<Tuple, T>) -> T {
-    get { tuple[keyPath: keyPath] }
-    _modify { yield &tuple[keyPath: keyPath] }
-  }
-}
-extension Tuple2: EmptyCaptureProtocol where _1: EmptyCaptureProtocol {}
-extension Tuple2: MatchProtocol {
-  public typealias Capture = _1
-  public init(_ tuple: Tuple) { self.tuple = tuple }
-  public init(_ _0: _0, _ _1: _1) {
-    self.init((_0, _1))
-  }
-}
-extension Tuple2: Equatable where _0: Equatable, _1: Equatable {
-  public static func == (lhs: Self, rhs: Self) -> Bool {
-    lhs.tuple.0 == rhs.tuple.0 && lhs.tuple.1 == rhs.tuple.1
-  }
-}
-@frozen @dynamicMemberLookup
-public struct Tuple3<_0, _1, _2> {
-  public typealias Tuple = (_0, _1, _2)
-  public var tuple: Tuple
-  public subscript<T>(dynamicMember keyPath: WritableKeyPath<Tuple, T>) -> T {
-    get { tuple[keyPath: keyPath] }
-    _modify { yield &tuple[keyPath: keyPath] }
-  }
-}
-extension Tuple3: EmptyCaptureProtocol where _1: EmptyCaptureProtocol, _2: EmptyCaptureProtocol {}
-extension Tuple3: MatchProtocol {
-  public typealias Capture = Tuple2<_1, _2>
-  public init(_ tuple: Tuple) { self.tuple = tuple }
-  public init(_ _0: _0, _ _1: _1, _ _2: _2) {
-    self.init((_0, _1, _2))
-  }
-}
-extension Tuple3: Equatable where _0: Equatable, _1: Equatable, _2: Equatable {
-  public static func == (lhs: Self, rhs: Self) -> Bool {
-    lhs.tuple.0 == rhs.tuple.0 && lhs.tuple.1 == rhs.tuple.1 && lhs.tuple.2 == rhs.tuple.2
-  }
-}
-@frozen @dynamicMemberLookup
-public struct Tuple4<_0, _1, _2, _3> {
-  public typealias Tuple = (_0, _1, _2, _3)
-  public var tuple: Tuple
-  public subscript<T>(dynamicMember keyPath: WritableKeyPath<Tuple, T>) -> T {
-    get { tuple[keyPath: keyPath] }
-    _modify { yield &tuple[keyPath: keyPath] }
-  }
-}
-extension Tuple4: EmptyCaptureProtocol where _1: EmptyCaptureProtocol, _2: EmptyCaptureProtocol, _3: EmptyCaptureProtocol {}
-extension Tuple4: MatchProtocol {
-  public typealias Capture = Tuple3<_1, _2, _3>
-  public init(_ tuple: Tuple) { self.tuple = tuple }
-  public init(_ _0: _0, _ _1: _1, _ _2: _2, _ _3: _3) {
-    self.init((_0, _1, _2, _3))
-  }
-}
-extension Tuple4: Equatable where _0: Equatable, _1: Equatable, _2: Equatable, _3: Equatable {
-  public static func == (lhs: Self, rhs: Self) -> Bool {
-    lhs.tuple.0 == rhs.tuple.0 && lhs.tuple.1 == rhs.tuple.1 && lhs.tuple.2 == rhs.tuple.2 && lhs.tuple.3 == rhs.tuple.3
-  }
-}
-@frozen @dynamicMemberLookup
-public struct Tuple5<_0, _1, _2, _3, _4> {
-  public typealias Tuple = (_0, _1, _2, _3, _4)
-  public var tuple: Tuple
-  public subscript<T>(dynamicMember keyPath: WritableKeyPath<Tuple, T>) -> T {
-    get { tuple[keyPath: keyPath] }
-    _modify { yield &tuple[keyPath: keyPath] }
-  }
-}
-extension Tuple5: EmptyCaptureProtocol where _1: EmptyCaptureProtocol, _2: EmptyCaptureProtocol, _3: EmptyCaptureProtocol, _4: EmptyCaptureProtocol {}
-extension Tuple5: MatchProtocol {
-  public typealias Capture = Tuple4<_1, _2, _3, _4>
-  public init(_ tuple: Tuple) { self.tuple = tuple }
-  public init(_ _0: _0, _ _1: _1, _ _2: _2, _ _3: _3, _ _4: _4) {
-    self.init((_0, _1, _2, _3, _4))
-  }
-}
-extension Tuple5: Equatable where _0: Equatable, _1: Equatable, _2: Equatable, _3: Equatable, _4: Equatable {
-  public static func == (lhs: Self, rhs: Self) -> Bool {
-    lhs.tuple.0 == rhs.tuple.0 && lhs.tuple.1 == rhs.tuple.1 && lhs.tuple.2 == rhs.tuple.2 && lhs.tuple.3 == rhs.tuple.3 && lhs.tuple.4 == rhs.tuple.4
-  }
-}
-@frozen @dynamicMemberLookup
-public struct Tuple6<_0, _1, _2, _3, _4, _5> {
-  public typealias Tuple = (_0, _1, _2, _3, _4, _5)
-  public var tuple: Tuple
-  public subscript<T>(dynamicMember keyPath: WritableKeyPath<Tuple, T>) -> T {
-    get { tuple[keyPath: keyPath] }
-    _modify { yield &tuple[keyPath: keyPath] }
-  }
-}
-extension Tuple6: EmptyCaptureProtocol where _1: EmptyCaptureProtocol, _2: EmptyCaptureProtocol, _3: EmptyCaptureProtocol, _4: EmptyCaptureProtocol, _5: EmptyCaptureProtocol {}
-extension Tuple6: MatchProtocol {
-  public typealias Capture = Tuple5<_1, _2, _3, _4, _5>
-  public init(_ tuple: Tuple) { self.tuple = tuple }
-  public init(_ _0: _0, _ _1: _1, _ _2: _2, _ _3: _3, _ _4: _4, _ _5: _5) {
-    self.init((_0, _1, _2, _3, _4, _5))
-  }
-}
-extension Tuple6: Equatable where _0: Equatable, _1: Equatable, _2: Equatable, _3: Equatable, _4: Equatable, _5: Equatable {
-  public static func == (lhs: Self, rhs: Self) -> Bool {
-    lhs.tuple.0 == rhs.tuple.0 && lhs.tuple.1 == rhs.tuple.1 && lhs.tuple.2 == rhs.tuple.2 && lhs.tuple.3 == rhs.tuple.3 && lhs.tuple.4 == rhs.tuple.4 && lhs.tuple.5 == rhs.tuple.5
-  }
-}
-@frozen @dynamicMemberLookup
-public struct Tuple7<_0, _1, _2, _3, _4, _5, _6> {
-  public typealias Tuple = (_0, _1, _2, _3, _4, _5, _6)
-  public var tuple: Tuple
-  public subscript<T>(dynamicMember keyPath: WritableKeyPath<Tuple, T>) -> T {
-    get { tuple[keyPath: keyPath] }
-    _modify { yield &tuple[keyPath: keyPath] }
-  }
-}
-extension Tuple7: EmptyCaptureProtocol where _1: EmptyCaptureProtocol, _2: EmptyCaptureProtocol, _3: EmptyCaptureProtocol, _4: EmptyCaptureProtocol, _5: EmptyCaptureProtocol, _6: EmptyCaptureProtocol {}
-extension Tuple7: MatchProtocol {
-  public typealias Capture = Tuple6<_1, _2, _3, _4, _5, _6>
-  public init(_ tuple: Tuple) { self.tuple = tuple }
-  public init(_ _0: _0, _ _1: _1, _ _2: _2, _ _3: _3, _ _4: _4, _ _5: _5, _ _6: _6) {
-    self.init((_0, _1, _2, _3, _4, _5, _6))
-  }
-}
-extension Tuple7: Equatable where _0: Equatable, _1: Equatable, _2: Equatable, _3: Equatable, _4: Equatable, _5: Equatable, _6: Equatable {
-  public static func == (lhs: Self, rhs: Self) -> Bool {
-    lhs.tuple.0 == rhs.tuple.0 && lhs.tuple.1 == rhs.tuple.1 && lhs.tuple.2 == rhs.tuple.2 && lhs.tuple.3 == rhs.tuple.3 && lhs.tuple.4 == rhs.tuple.4 && lhs.tuple.5 == rhs.tuple.5 && lhs.tuple.6 == rhs.tuple.6
-  }
-}
-@frozen @dynamicMemberLookup
-public struct Tuple8<_0, _1, _2, _3, _4, _5, _6, _7> {
-  public typealias Tuple = (_0, _1, _2, _3, _4, _5, _6, _7)
-  public var tuple: Tuple
-  public subscript<T>(dynamicMember keyPath: WritableKeyPath<Tuple, T>) -> T {
-    get { tuple[keyPath: keyPath] }
-    _modify { yield &tuple[keyPath: keyPath] }
-  }
-}
-extension Tuple8: EmptyCaptureProtocol where _1: EmptyCaptureProtocol, _2: EmptyCaptureProtocol, _3: EmptyCaptureProtocol, _4: EmptyCaptureProtocol, _5: EmptyCaptureProtocol, _6: EmptyCaptureProtocol, _7: EmptyCaptureProtocol {}
-extension Tuple8: MatchProtocol {
-  public typealias Capture = Tuple7<_1, _2, _3, _4, _5, _6, _7>
-  public init(_ tuple: Tuple) { self.tuple = tuple }
-  public init(_ _0: _0, _ _1: _1, _ _2: _2, _ _3: _3, _ _4: _4, _ _5: _5, _ _6: _6, _ _7: _7) {
-    self.init((_0, _1, _2, _3, _4, _5, _6, _7))
-  }
-}
-extension Tuple8: Equatable where _0: Equatable, _1: Equatable, _2: Equatable, _3: Equatable, _4: Equatable, _5: Equatable, _6: Equatable, _7: Equatable {
-  public static func == (lhs: Self, rhs: Self) -> Bool {
-    lhs.tuple.0 == rhs.tuple.0 && lhs.tuple.1 == rhs.tuple.1 && lhs.tuple.2 == rhs.tuple.2 && lhs.tuple.3 == rhs.tuple.3 && lhs.tuple.4 == rhs.tuple.4 && lhs.tuple.5 == rhs.tuple.5 && lhs.tuple.6 == rhs.tuple.6 && lhs.tuple.7 == rhs.tuple.7
-  }
-}
-@frozen @dynamicMemberLookup
-public struct Tuple9<_0, _1, _2, _3, _4, _5, _6, _7, _8> {
-  public typealias Tuple = (_0, _1, _2, _3, _4, _5, _6, _7, _8)
-  public var tuple: Tuple
-  public subscript<T>(dynamicMember keyPath: WritableKeyPath<Tuple, T>) -> T {
-    get { tuple[keyPath: keyPath] }
-    _modify { yield &tuple[keyPath: keyPath] }
-  }
-}
-extension Tuple9: EmptyCaptureProtocol where _1: EmptyCaptureProtocol, _2: EmptyCaptureProtocol, _3: EmptyCaptureProtocol, _4: EmptyCaptureProtocol, _5: EmptyCaptureProtocol, _6: EmptyCaptureProtocol, _7: EmptyCaptureProtocol, _8: EmptyCaptureProtocol {}
-extension Tuple9: MatchProtocol {
-  public typealias Capture = Tuple8<_1, _2, _3, _4, _5, _6, _7, _8>
-  public init(_ tuple: Tuple) { self.tuple = tuple }
-  public init(_ _0: _0, _ _1: _1, _ _2: _2, _ _3: _3, _ _4: _4, _ _5: _5, _ _6: _6, _ _7: _7, _ _8: _8) {
-    self.init((_0, _1, _2, _3, _4, _5, _6, _7, _8))
-  }
-}
-extension Tuple9: Equatable where _0: Equatable, _1: Equatable, _2: Equatable, _3: Equatable, _4: Equatable, _5: Equatable, _6: Equatable, _7: Equatable, _8: Equatable {
-  public static func == (lhs: Self, rhs: Self) -> Bool {
-    lhs.tuple.0 == rhs.tuple.0 && lhs.tuple.1 == rhs.tuple.1 && lhs.tuple.2 == rhs.tuple.2 && lhs.tuple.3 == rhs.tuple.3 && lhs.tuple.4 == rhs.tuple.4 && lhs.tuple.5 == rhs.tuple.5 && lhs.tuple.6 == rhs.tuple.6 && lhs.tuple.7 == rhs.tuple.7 && lhs.tuple.8 == rhs.tuple.8
+extension RegexBuilder {
+  public static func buildBlock<R: RegexProtocol, W, C0>(_ regex: R) -> R
+  where R.Match == (W, C0)
+  {
+    regex
   }
 }
-@frozen @dynamicMemberLookup
-public struct Tuple10<_0, _1, _2, _3, _4, _5, _6, _7, _8, _9> {
-  public typealias Tuple = (_0, _1, _2, _3, _4, _5, _6, _7, _8, _9)
-  public var tuple: Tuple
-  public subscript<T>(dynamicMember keyPath: WritableKeyPath<Tuple, T>) -> T {
-    get { tuple[keyPath: keyPath] }
-    _modify { yield &tuple[keyPath: keyPath] }
+extension RegexBuilder {
+  public static func buildBlock<R: RegexProtocol, W, C0, C1>(_ regex: R) -> R
+  where R.Match == (W, C0, C1)
+  {
+    regex
   }
 }
-extension Tuple10: EmptyCaptureProtocol where _1: EmptyCaptureProtocol, _2: EmptyCaptureProtocol, _3: EmptyCaptureProtocol, _4: EmptyCaptureProtocol, _5: EmptyCaptureProtocol, _6: EmptyCaptureProtocol, _7: EmptyCaptureProtocol, _8: EmptyCaptureProtocol, _9: EmptyCaptureProtocol {}
-extension Tuple10: MatchProtocol {
-  public typealias Capture = Tuple9<_1, _2, _3, _4, _5, _6, _7, _8, _9>
-  public init(_ tuple: Tuple) { self.tuple = tuple }
-  public init(_ _0: _0, _ _1: _1, _ _2: _2, _ _3: _3, _ _4: _4, _ _5: _5, _ _6: _6, _ _7: _7, _ _8: _8, _ _9: _9) {
-    self.init((_0, _1, _2, _3, _4, _5, _6, _7, _8, _9))
+extension RegexBuilder {
+  public static func buildBlock<R: RegexProtocol, W, C0, C1, C2>(_ regex: R) -> R
+  where R.Match == (W, C0, C1, C2)
+  {
+    regex
   }
 }
-extension Tuple10: Equatable where _0: Equatable, _1: Equatable, _2: Equatable, _3: Equatable, _4: Equatable, _5: Equatable, _6: Equatable, _7: Equatable, _8: Equatable, _9: Equatable {
-  public static func == (lhs: Self, rhs: Self) -> Bool {
-    lhs.tuple.0 == rhs.tuple.0 && lhs.tuple.1 == rhs.tuple.1 && lhs.tuple.2 == rhs.tuple.2 && lhs.tuple.3 == rhs.tuple.3 && lhs.tuple.4 == rhs.tuple.4 && lhs.tuple.5 == rhs.tuple.5 && lhs.tuple.6 == rhs.tuple.6 && lhs.tuple.7 == rhs.tuple.7 && lhs.tuple.8 == rhs.tuple.8 && lhs.tuple.9 == rhs.tuple.9
+extension RegexBuilder {
+  public static func buildBlock<R: RegexProtocol, W, C0, C1, C2, C3>(_ regex: R) -> R
+  where R.Match == (W, C0, C1, C2, C3)
+  {
+    regex
   }
 }
-@frozen @dynamicMemberLookup
-public struct Tuple11<_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10> {
-  public typealias Tuple = (_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10)
-  public var tuple: Tuple
-  public subscript<T>(dynamicMember keyPath: WritableKeyPath<Tuple, T>) -> T {
-    get { tuple[keyPath: keyPath] }
-    _modify { yield &tuple[keyPath: keyPath] }
+extension RegexBuilder {
+  public static func buildBlock<R: RegexProtocol, W, C0, C1, C2, C3, C4>(_ regex: R) -> R
+  where R.Match == (W, C0, C1, C2, C3, C4)
+  {
+    regex
   }
 }
-extension Tuple11: EmptyCaptureProtocol where _1: EmptyCaptureProtocol, _2: EmptyCaptureProtocol, _3: EmptyCaptureProtocol, _4: EmptyCaptureProtocol, _5: EmptyCaptureProtocol, _6: EmptyCaptureProtocol, _7: EmptyCaptureProtocol, _8: EmptyCaptureProtocol, _9: EmptyCaptureProtocol, _10: EmptyCaptureProtocol {}
-extension Tuple11: MatchProtocol {
-  public typealias Capture = Tuple10<_1, _2, _3, _4, _5, _6, _7, _8, _9, _10>
-  public init(_ tuple: Tuple) { self.tuple = tuple }
-  public init(_ _0: _0, _ _1: _1, _ _2: _2, _ _3: _3, _ _4: _4, _ _5: _5, _ _6: _6, _ _7: _7, _ _8: _8, _ _9: _9, _ _10: _10) {
-    self.init((_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10))
+extension RegexBuilder {
+  public static func buildBlock<R: RegexProtocol, W, C0, C1, C2, C3, C4, C5>(_ regex: R) -> R
+  where R.Match == (W, C0, C1, C2, C3, C4, C5)
+  {
+    regex
   }
 }
-extension Tuple11: Equatable where _0: Equatable, _1: Equatable, _2: Equatable, _3: Equatable, _4: Equatable, _5: Equatable, _6: Equatable, _7: Equatable, _8: Equatable, _9: Equatable, _10: Equatable {
-  public static func == (lhs: Self, rhs: Self) -> Bool {
-    lhs.tuple.0 == rhs.tuple.0 && lhs.tuple.1 == rhs.tuple.1 && lhs.tuple.2 == rhs.tuple.2 && lhs.tuple.3 == rhs.tuple.3 && lhs.tuple.4 == rhs.tuple.4 && lhs.tuple.5 == rhs.tuple.5 && lhs.tuple.6 == rhs.tuple.6 && lhs.tuple.7 == rhs.tuple.7 && lhs.tuple.8 == rhs.tuple.8 && lhs.tuple.9 == rhs.tuple.9 && lhs.tuple.10 == rhs.tuple.10
+extension RegexBuilder {
+  public static func buildBlock<R: RegexProtocol, W, C0, C1, C2, C3, C4, C5, C6>(_ regex: R) -> R
+  where R.Match == (W, C0, C1, C2, C3, C4, C5, C6)
+  {
+    regex
   }
 }
-public struct Concatenate_0_0<
-  W0, W1, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == W0, R1.Match == W1 {
-  public typealias Match = Substring
-  public let regex: Regex<Match>
-  init(_ r0: R0, _ r1: R1) {
-    self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
+extension RegexBuilder {
+  public static func buildBlock<R: RegexProtocol, W, C0, C1, C2, C3, C4, C5, C6, C7>(_ regex: R) -> R
+  where R.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7)
+  {
+    regex
   }
 }
 extension RegexBuilder {
-  @_disfavoredOverload
-  public static func buildBlock<W0, W1, R0: RegexProtocol, R1: RegexProtocol>(
-    combining next: R1, into combined: R0
-  ) -> Concatenate_0_0<W0, W1, R0, R1> {
-    .init(combined, next)
+  public static func buildBlock<R: RegexProtocol, W, C0, C1, C2, C3, C4, C5, C6, C7, C8>(_ regex: R) -> R
+  where R.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8)
+  {
+    regex
   }
 }
 public struct Concatenate_0_1<
   W0, W1, C0, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == W0, R1.Match == Tuple2<W1, C0> {
-  public typealias Match = Tuple2<Substring, C0>
+>: RegexProtocol where R0.Match == W0, R1.Match == (W1, C0) {
+  public typealias Match = (Substring, C0)
   public let regex: Regex<Match>
   init(_ r0: R0, _ r1: R1) {
     self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
@@ -269,8 +95,8 @@ extension RegexBuilder {
 }
 public struct Concatenate_0_2<
   W0, W1, C0, C1, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == W0, R1.Match == Tuple3<W1, C0, C1> {
-  public typealias Match = Tuple3<Substring, C0, C1>
+>: RegexProtocol where R0.Match == W0, R1.Match == (W1, C0, C1) {
+  public typealias Match = (Substring, C0, C1)
   public let regex: Regex<Match>
   init(_ r0: R0, _ r1: R1) {
     self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
@@ -286,8 +112,8 @@ extension RegexBuilder {
 }
 public struct Concatenate_0_3<
   W0, W1, C0, C1, C2, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == W0, R1.Match == Tuple4<W1, C0, C1, C2> {
-  public typealias Match = Tuple4<Substring, C0, C1, C2>
+>: RegexProtocol where R0.Match == W0, R1.Match == (W1, C0, C1, C2) {
+  public typealias Match = (Substring, C0, C1, C2)
   public let regex: Regex<Match>
   init(_ r0: R0, _ r1: R1) {
     self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
@@ -303,8 +129,8 @@ extension RegexBuilder {
 }
 public struct Concatenate_0_4<
   W0, W1, C0, C1, C2, C3, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == W0, R1.Match == Tuple5<W1, C0, C1, C2, C3> {
-  public typealias Match = Tuple5<Substring, C0, C1, C2, C3>
+>: RegexProtocol where R0.Match == W0, R1.Match == (W1, C0, C1, C2, C3) {
+  public typealias Match = (Substring, C0, C1, C2, C3)
   public let regex: Regex<Match>
   init(_ r0: R0, _ r1: R1) {
     self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
@@ -320,8 +146,8 @@ extension RegexBuilder {
 }
 public struct Concatenate_0_5<
   W0, W1, C0, C1, C2, C3, C4, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == W0, R1.Match == Tuple6<W1, C0, C1, C2, C3, C4> {
-  public typealias Match = Tuple6<Substring, C0, C1, C2, C3, C4>
+>: RegexProtocol where R0.Match == W0, R1.Match == (W1, C0, C1, C2, C3, C4) {
+  public typealias Match = (Substring, C0, C1, C2, C3, C4)
   public let regex: Regex<Match>
   init(_ r0: R0, _ r1: R1) {
     self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
@@ -337,8 +163,8 @@ extension RegexBuilder {
 }
 public struct Concatenate_0_6<
   W0, W1, C0, C1, C2, C3, C4, C5, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == W0, R1.Match == Tuple7<W1, C0, C1, C2, C3, C4, C5> {
-  public typealias Match = Tuple7<Substring, C0, C1, C2, C3, C4, C5>
+>: RegexProtocol where R0.Match == W0, R1.Match == (W1, C0, C1, C2, C3, C4, C5) {
+  public typealias Match = (Substring, C0, C1, C2, C3, C4, C5)
   public let regex: Regex<Match>
   init(_ r0: R0, _ r1: R1) {
     self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
@@ -354,8 +180,8 @@ extension RegexBuilder {
 }
 public struct Concatenate_0_7<
   W0, W1, C0, C1, C2, C3, C4, C5, C6, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == W0, R1.Match == Tuple8<W1, C0, C1, C2, C3, C4, C5, C6> {
-  public typealias Match = Tuple8<Substring, C0, C1, C2, C3, C4, C5, C6>
+>: RegexProtocol where R0.Match == W0, R1.Match == (W1, C0, C1, C2, C3, C4, C5, C6) {
+  public typealias Match = (Substring, C0, C1, C2, C3, C4, C5, C6)
   public let regex: Regex<Match>
   init(_ r0: R0, _ r1: R1) {
     self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
@@ -371,8 +197,8 @@ extension RegexBuilder {
 }
 public struct Concatenate_0_8<
   W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == W0, R1.Match == Tuple9<W1, C0, C1, C2, C3, C4, C5, C6, C7> {
-  public typealias Match = Tuple9<Substring, C0, C1, C2, C3, C4, C5, C6, C7>
+>: RegexProtocol where R0.Match == W0, R1.Match == (W1, C0, C1, C2, C3, C4, C5, C6, C7) {
+  public typealias Match = (Substring, C0, C1, C2, C3, C4, C5, C6, C7)
   public let regex: Regex<Match>
   init(_ r0: R0, _ r1: R1) {
     self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
@@ -388,8 +214,8 @@ extension RegexBuilder {
 }
 public struct Concatenate_0_9<
   W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, C8, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == W0, R1.Match == Tuple10<W1, C0, C1, C2, C3, C4, C5, C6, C7, C8> {
-  public typealias Match = Tuple10<Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8>
+>: RegexProtocol where R0.Match == W0, R1.Match == (W1, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
+  public typealias Match = (Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8)
   public let regex: Regex<Match>
   init(_ r0: R0, _ r1: R1) {
     self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
@@ -405,8 +231,8 @@ extension RegexBuilder {
 }
 public struct Concatenate_0_10<
   W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == W0, R1.Match == Tuple11<W1, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9> {
-  public typealias Match = Tuple11<Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9>
+>: RegexProtocol where R0.Match == W0, R1.Match == (W1, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
+  public typealias Match = (Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9)
   public let regex: Regex<Match>
   init(_ r0: R0, _ r1: R1) {
     self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
@@ -420,27 +246,10 @@ extension RegexBuilder {
     .init(combined, next)
   }
 }
-public struct Concatenate_1_0<
-  W0, W1, C0, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == Tuple2<W0, C0>, R1.Match == W1 {
-  public typealias Match = Tuple2<Substring, C0>
-  public let regex: Regex<Match>
-  init(_ r0: R0, _ r1: R1) {
-    self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
-  }
-}
-extension RegexBuilder {
-  @_disfavoredOverload
-  public static func buildBlock<W0, W1, C0, R0: RegexProtocol, R1: RegexProtocol>(
-    combining next: R1, into combined: R0
-  ) -> Concatenate_1_0<W0, W1, C0, R0, R1> {
-    .init(combined, next)
-  }
-}
 public struct Concatenate_1_1<
   W0, W1, C0, C1, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == Tuple2<W0, C0>, R1.Match == Tuple2<W1, C1> {
-  public typealias Match = Tuple3<Substring, C0, C1>
+>: RegexProtocol where R0.Match == (W0, C0), R1.Match == (W1, C1) {
+  public typealias Match = (Substring, C0, C1)
   public let regex: Regex<Match>
   init(_ r0: R0, _ r1: R1) {
     self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
@@ -456,8 +265,8 @@ extension RegexBuilder {
 }
 public struct Concatenate_1_2<
   W0, W1, C0, C1, C2, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == Tuple2<W0, C0>, R1.Match == Tuple3<W1, C1, C2> {
-  public typealias Match = Tuple4<Substring, C0, C1, C2>
+>: RegexProtocol where R0.Match == (W0, C0), R1.Match == (W1, C1, C2) {
+  public typealias Match = (Substring, C0, C1, C2)
   public let regex: Regex<Match>
   init(_ r0: R0, _ r1: R1) {
     self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
@@ -473,8 +282,8 @@ extension RegexBuilder {
 }
 public struct Concatenate_1_3<
   W0, W1, C0, C1, C2, C3, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == Tuple2<W0, C0>, R1.Match == Tuple4<W1, C1, C2, C3> {
-  public typealias Match = Tuple5<Substring, C0, C1, C2, C3>
+>: RegexProtocol where R0.Match == (W0, C0), R1.Match == (W1, C1, C2, C3) {
+  public typealias Match = (Substring, C0, C1, C2, C3)
   public let regex: Regex<Match>
   init(_ r0: R0, _ r1: R1) {
     self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
@@ -490,8 +299,8 @@ extension RegexBuilder {
 }
 public struct Concatenate_1_4<
   W0, W1, C0, C1, C2, C3, C4, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == Tuple2<W0, C0>, R1.Match == Tuple5<W1, C1, C2, C3, C4> {
-  public typealias Match = Tuple6<Substring, C0, C1, C2, C3, C4>
+>: RegexProtocol where R0.Match == (W0, C0), R1.Match == (W1, C1, C2, C3, C4) {
+  public typealias Match = (Substring, C0, C1, C2, C3, C4)
   public let regex: Regex<Match>
   init(_ r0: R0, _ r1: R1) {
     self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
@@ -507,8 +316,8 @@ extension RegexBuilder {
 }
 public struct Concatenate_1_5<
   W0, W1, C0, C1, C2, C3, C4, C5, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == Tuple2<W0, C0>, R1.Match == Tuple6<W1, C1, C2, C3, C4, C5> {
-  public typealias Match = Tuple7<Substring, C0, C1, C2, C3, C4, C5>
+>: RegexProtocol where R0.Match == (W0, C0), R1.Match == (W1, C1, C2, C3, C4, C5) {
+  public typealias Match = (Substring, C0, C1, C2, C3, C4, C5)
   public let regex: Regex<Match>
   init(_ r0: R0, _ r1: R1) {
     self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
@@ -524,8 +333,8 @@ extension RegexBuilder {
 }
 public struct Concatenate_1_6<
   W0, W1, C0, C1, C2, C3, C4, C5, C6, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == Tuple2<W0, C0>, R1.Match == Tuple7<W1, C1, C2, C3, C4, C5, C6> {
-  public typealias Match = Tuple8<Substring, C0, C1, C2, C3, C4, C5, C6>
+>: RegexProtocol where R0.Match == (W0, C0), R1.Match == (W1, C1, C2, C3, C4, C5, C6) {
+  public typealias Match = (Substring, C0, C1, C2, C3, C4, C5, C6)
   public let regex: Regex<Match>
   init(_ r0: R0, _ r1: R1) {
     self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
@@ -541,8 +350,8 @@ extension RegexBuilder {
 }
 public struct Concatenate_1_7<
   W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == Tuple2<W0, C0>, R1.Match == Tuple8<W1, C1, C2, C3, C4, C5, C6, C7> {
-  public typealias Match = Tuple9<Substring, C0, C1, C2, C3, C4, C5, C6, C7>
+>: RegexProtocol where R0.Match == (W0, C0), R1.Match == (W1, C1, C2, C3, C4, C5, C6, C7) {
+  public typealias Match = (Substring, C0, C1, C2, C3, C4, C5, C6, C7)
   public let regex: Regex<Match>
   init(_ r0: R0, _ r1: R1) {
     self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
@@ -558,8 +367,8 @@ extension RegexBuilder {
 }
 public struct Concatenate_1_8<
   W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, C8, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == Tuple2<W0, C0>, R1.Match == Tuple9<W1, C1, C2, C3, C4, C5, C6, C7, C8> {
-  public typealias Match = Tuple10<Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8>
+>: RegexProtocol where R0.Match == (W0, C0), R1.Match == (W1, C1, C2, C3, C4, C5, C6, C7, C8) {
+  public typealias Match = (Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8)
   public let regex: Regex<Match>
   init(_ r0: R0, _ r1: R1) {
     self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
@@ -575,8 +384,8 @@ extension RegexBuilder {
 }
 public struct Concatenate_1_9<
   W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == Tuple2<W0, C0>, R1.Match == Tuple10<W1, C1, C2, C3, C4, C5, C6, C7, C8, C9> {
-  public typealias Match = Tuple11<Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9>
+>: RegexProtocol where R0.Match == (W0, C0), R1.Match == (W1, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
+  public typealias Match = (Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9)
   public let regex: Regex<Match>
   init(_ r0: R0, _ r1: R1) {
     self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
@@ -590,27 +399,10 @@ extension RegexBuilder {
     .init(combined, next)
   }
 }
-public struct Concatenate_2_0<
-  W0, W1, C0, C1, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == Tuple3<W0, C0, C1>, R1.Match == W1 {
-  public typealias Match = Tuple3<Substring, C0, C1>
-  public let regex: Regex<Match>
-  init(_ r0: R0, _ r1: R1) {
-    self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
-  }
-}
-extension RegexBuilder {
-  @_disfavoredOverload
-  public static func buildBlock<W0, W1, C0, C1, R0: RegexProtocol, R1: RegexProtocol>(
-    combining next: R1, into combined: R0
-  ) -> Concatenate_2_0<W0, W1, C0, C1, R0, R1> {
-    .init(combined, next)
-  }
-}
 public struct Concatenate_2_1<
   W0, W1, C0, C1, C2, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == Tuple3<W0, C0, C1>, R1.Match == Tuple2<W1, C2> {
-  public typealias Match = Tuple4<Substring, C0, C1, C2>
+>: RegexProtocol where R0.Match == (W0, C0, C1), R1.Match == (W1, C2) {
+  public typealias Match = (Substring, C0, C1, C2)
   public let regex: Regex<Match>
   init(_ r0: R0, _ r1: R1) {
     self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
@@ -626,8 +418,8 @@ extension RegexBuilder {
 }
 public struct Concatenate_2_2<
   W0, W1, C0, C1, C2, C3, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == Tuple3<W0, C0, C1>, R1.Match == Tuple3<W1, C2, C3> {
-  public typealias Match = Tuple5<Substring, C0, C1, C2, C3>
+>: RegexProtocol where R0.Match == (W0, C0, C1), R1.Match == (W1, C2, C3) {
+  public typealias Match = (Substring, C0, C1, C2, C3)
   public let regex: Regex<Match>
   init(_ r0: R0, _ r1: R1) {
     self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
@@ -643,8 +435,8 @@ extension RegexBuilder {
 }
 public struct Concatenate_2_3<
   W0, W1, C0, C1, C2, C3, C4, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == Tuple3<W0, C0, C1>, R1.Match == Tuple4<W1, C2, C3, C4> {
-  public typealias Match = Tuple6<Substring, C0, C1, C2, C3, C4>
+>: RegexProtocol where R0.Match == (W0, C0, C1), R1.Match == (W1, C2, C3, C4) {
+  public typealias Match = (Substring, C0, C1, C2, C3, C4)
   public let regex: Regex<Match>
   init(_ r0: R0, _ r1: R1) {
     self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
@@ -660,8 +452,8 @@ extension RegexBuilder {
 }
 public struct Concatenate_2_4<
   W0, W1, C0, C1, C2, C3, C4, C5, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == Tuple3<W0, C0, C1>, R1.Match == Tuple5<W1, C2, C3, C4, C5> {
-  public typealias Match = Tuple7<Substring, C0, C1, C2, C3, C4, C5>
+>: RegexProtocol where R0.Match == (W0, C0, C1), R1.Match == (W1, C2, C3, C4, C5) {
+  public typealias Match = (Substring, C0, C1, C2, C3, C4, C5)
   public let regex: Regex<Match>
   init(_ r0: R0, _ r1: R1) {
     self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
@@ -677,8 +469,8 @@ extension RegexBuilder {
 }
 public struct Concatenate_2_5<
   W0, W1, C0, C1, C2, C3, C4, C5, C6, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == Tuple3<W0, C0, C1>, R1.Match == Tuple6<W1, C2, C3, C4, C5, C6> {
-  public typealias Match = Tuple8<Substring, C0, C1, C2, C3, C4, C5, C6>
+>: RegexProtocol where R0.Match == (W0, C0, C1), R1.Match == (W1, C2, C3, C4, C5, C6) {
+  public typealias Match = (Substring, C0, C1, C2, C3, C4, C5, C6)
   public let regex: Regex<Match>
   init(_ r0: R0, _ r1: R1) {
     self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
@@ -694,8 +486,8 @@ extension RegexBuilder {
 }
 public struct Concatenate_2_6<
   W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == Tuple3<W0, C0, C1>, R1.Match == Tuple7<W1, C2, C3, C4, C5, C6, C7> {
-  public typealias Match = Tuple9<Substring, C0, C1, C2, C3, C4, C5, C6, C7>
+>: RegexProtocol where R0.Match == (W0, C0, C1), R1.Match == (W1, C2, C3, C4, C5, C6, C7) {
+  public typealias Match = (Substring, C0, C1, C2, C3, C4, C5, C6, C7)
   public let regex: Regex<Match>
   init(_ r0: R0, _ r1: R1) {
     self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
@@ -711,8 +503,8 @@ extension RegexBuilder {
 }
 public struct Concatenate_2_7<
   W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, C8, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == Tuple3<W0, C0, C1>, R1.Match == Tuple8<W1, C2, C3, C4, C5, C6, C7, C8> {
-  public typealias Match = Tuple10<Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8>
+>: RegexProtocol where R0.Match == (W0, C0, C1), R1.Match == (W1, C2, C3, C4, C5, C6, C7, C8) {
+  public typealias Match = (Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8)
   public let regex: Regex<Match>
   init(_ r0: R0, _ r1: R1) {
     self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
@@ -728,8 +520,8 @@ extension RegexBuilder {
 }
 public struct Concatenate_2_8<
   W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == Tuple3<W0, C0, C1>, R1.Match == Tuple9<W1, C2, C3, C4, C5, C6, C7, C8, C9> {
-  public typealias Match = Tuple11<Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9>
+>: RegexProtocol where R0.Match == (W0, C0, C1), R1.Match == (W1, C2, C3, C4, C5, C6, C7, C8, C9) {
+  public typealias Match = (Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9)
   public let regex: Regex<Match>
   init(_ r0: R0, _ r1: R1) {
     self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
@@ -743,27 +535,10 @@ extension RegexBuilder {
     .init(combined, next)
   }
 }
-public struct Concatenate_3_0<
-  W0, W1, C0, C1, C2, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == Tuple4<W0, C0, C1, C2>, R1.Match == W1 {
-  public typealias Match = Tuple4<Substring, C0, C1, C2>
-  public let regex: Regex<Match>
-  init(_ r0: R0, _ r1: R1) {
-    self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
-  }
-}
-extension RegexBuilder {
-  @_disfavoredOverload
-  public static func buildBlock<W0, W1, C0, C1, C2, R0: RegexProtocol, R1: RegexProtocol>(
-    combining next: R1, into combined: R0
-  ) -> Concatenate_3_0<W0, W1, C0, C1, C2, R0, R1> {
-    .init(combined, next)
-  }
-}
 public struct Concatenate_3_1<
   W0, W1, C0, C1, C2, C3, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == Tuple4<W0, C0, C1, C2>, R1.Match == Tuple2<W1, C3> {
-  public typealias Match = Tuple5<Substring, C0, C1, C2, C3>
+>: RegexProtocol where R0.Match == (W0, C0, C1, C2), R1.Match == (W1, C3) {
+  public typealias Match = (Substring, C0, C1, C2, C3)
   public let regex: Regex<Match>
   init(_ r0: R0, _ r1: R1) {
     self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
@@ -779,8 +554,8 @@ extension RegexBuilder {
 }
 public struct Concatenate_3_2<
   W0, W1, C0, C1, C2, C3, C4, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == Tuple4<W0, C0, C1, C2>, R1.Match == Tuple3<W1, C3, C4> {
-  public typealias Match = Tuple6<Substring, C0, C1, C2, C3, C4>
+>: RegexProtocol where R0.Match == (W0, C0, C1, C2), R1.Match == (W1, C3, C4) {
+  public typealias Match = (Substring, C0, C1, C2, C3, C4)
   public let regex: Regex<Match>
   init(_ r0: R0, _ r1: R1) {
     self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
@@ -796,8 +571,8 @@ extension RegexBuilder {
 }
 public struct Concatenate_3_3<
   W0, W1, C0, C1, C2, C3, C4, C5, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == Tuple4<W0, C0, C1, C2>, R1.Match == Tuple4<W1, C3, C4, C5> {
-  public typealias Match = Tuple7<Substring, C0, C1, C2, C3, C4, C5>
+>: RegexProtocol where R0.Match == (W0, C0, C1, C2), R1.Match == (W1, C3, C4, C5) {
+  public typealias Match = (Substring, C0, C1, C2, C3, C4, C5)
   public let regex: Regex<Match>
   init(_ r0: R0, _ r1: R1) {
     self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
@@ -813,8 +588,8 @@ extension RegexBuilder {
 }
 public struct Concatenate_3_4<
   W0, W1, C0, C1, C2, C3, C4, C5, C6, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == Tuple4<W0, C0, C1, C2>, R1.Match == Tuple5<W1, C3, C4, C5, C6> {
-  public typealias Match = Tuple8<Substring, C0, C1, C2, C3, C4, C5, C6>
+>: RegexProtocol where R0.Match == (W0, C0, C1, C2), R1.Match == (W1, C3, C4, C5, C6) {
+  public typealias Match = (Substring, C0, C1, C2, C3, C4, C5, C6)
   public let regex: Regex<Match>
   init(_ r0: R0, _ r1: R1) {
     self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
@@ -830,8 +605,8 @@ extension RegexBuilder {
 }
 public struct Concatenate_3_5<
   W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == Tuple4<W0, C0, C1, C2>, R1.Match == Tuple6<W1, C3, C4, C5, C6, C7> {
-  public typealias Match = Tuple9<Substring, C0, C1, C2, C3, C4, C5, C6, C7>
+>: RegexProtocol where R0.Match == (W0, C0, C1, C2), R1.Match == (W1, C3, C4, C5, C6, C7) {
+  public typealias Match = (Substring, C0, C1, C2, C3, C4, C5, C6, C7)
   public let regex: Regex<Match>
   init(_ r0: R0, _ r1: R1) {
     self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
@@ -847,8 +622,8 @@ extension RegexBuilder {
 }
 public struct Concatenate_3_6<
   W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, C8, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == Tuple4<W0, C0, C1, C2>, R1.Match == Tuple7<W1, C3, C4, C5, C6, C7, C8> {
-  public typealias Match = Tuple10<Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8>
+>: RegexProtocol where R0.Match == (W0, C0, C1, C2), R1.Match == (W1, C3, C4, C5, C6, C7, C8) {
+  public typealias Match = (Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8)
   public let regex: Regex<Match>
   init(_ r0: R0, _ r1: R1) {
     self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
@@ -864,8 +639,8 @@ extension RegexBuilder {
 }
 public struct Concatenate_3_7<
   W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == Tuple4<W0, C0, C1, C2>, R1.Match == Tuple8<W1, C3, C4, C5, C6, C7, C8, C9> {
-  public typealias Match = Tuple11<Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9>
+>: RegexProtocol where R0.Match == (W0, C0, C1, C2), R1.Match == (W1, C3, C4, C5, C6, C7, C8, C9) {
+  public typealias Match = (Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9)
   public let regex: Regex<Match>
   init(_ r0: R0, _ r1: R1) {
     self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
@@ -879,27 +654,10 @@ extension RegexBuilder {
     .init(combined, next)
   }
 }
-public struct Concatenate_4_0<
-  W0, W1, C0, C1, C2, C3, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == Tuple5<W0, C0, C1, C2, C3>, R1.Match == W1 {
-  public typealias Match = Tuple5<Substring, C0, C1, C2, C3>
-  public let regex: Regex<Match>
-  init(_ r0: R0, _ r1: R1) {
-    self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
-  }
-}
-extension RegexBuilder {
-  @_disfavoredOverload
-  public static func buildBlock<W0, W1, C0, C1, C2, C3, R0: RegexProtocol, R1: RegexProtocol>(
-    combining next: R1, into combined: R0
-  ) -> Concatenate_4_0<W0, W1, C0, C1, C2, C3, R0, R1> {
-    .init(combined, next)
-  }
-}
 public struct Concatenate_4_1<
   W0, W1, C0, C1, C2, C3, C4, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == Tuple5<W0, C0, C1, C2, C3>, R1.Match == Tuple2<W1, C4> {
-  public typealias Match = Tuple6<Substring, C0, C1, C2, C3, C4>
+>: RegexProtocol where R0.Match == (W0, C0, C1, C2, C3), R1.Match == (W1, C4) {
+  public typealias Match = (Substring, C0, C1, C2, C3, C4)
   public let regex: Regex<Match>
   init(_ r0: R0, _ r1: R1) {
     self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
@@ -915,8 +673,8 @@ extension RegexBuilder {
 }
 public struct Concatenate_4_2<
   W0, W1, C0, C1, C2, C3, C4, C5, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == Tuple5<W0, C0, C1, C2, C3>, R1.Match == Tuple3<W1, C4, C5> {
-  public typealias Match = Tuple7<Substring, C0, C1, C2, C3, C4, C5>
+>: RegexProtocol where R0.Match == (W0, C0, C1, C2, C3), R1.Match == (W1, C4, C5) {
+  public typealias Match = (Substring, C0, C1, C2, C3, C4, C5)
   public let regex: Regex<Match>
   init(_ r0: R0, _ r1: R1) {
     self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
@@ -932,8 +690,8 @@ extension RegexBuilder {
 }
 public struct Concatenate_4_3<
   W0, W1, C0, C1, C2, C3, C4, C5, C6, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == Tuple5<W0, C0, C1, C2, C3>, R1.Match == Tuple4<W1, C4, C5, C6> {
-  public typealias Match = Tuple8<Substring, C0, C1, C2, C3, C4, C5, C6>
+>: RegexProtocol where R0.Match == (W0, C0, C1, C2, C3), R1.Match == (W1, C4, C5, C6) {
+  public typealias Match = (Substring, C0, C1, C2, C3, C4, C5, C6)
   public let regex: Regex<Match>
   init(_ r0: R0, _ r1: R1) {
     self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
@@ -949,8 +707,8 @@ extension RegexBuilder {
 }
 public struct Concatenate_4_4<
   W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == Tuple5<W0, C0, C1, C2, C3>, R1.Match == Tuple5<W1, C4, C5, C6, C7> {
-  public typealias Match = Tuple9<Substring, C0, C1, C2, C3, C4, C5, C6, C7>
+>: RegexProtocol where R0.Match == (W0, C0, C1, C2, C3), R1.Match == (W1, C4, C5, C6, C7) {
+  public typealias Match = (Substring, C0, C1, C2, C3, C4, C5, C6, C7)
   public let regex: Regex<Match>
   init(_ r0: R0, _ r1: R1) {
     self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
@@ -966,8 +724,8 @@ extension RegexBuilder {
 }
 public struct Concatenate_4_5<
   W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, C8, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == Tuple5<W0, C0, C1, C2, C3>, R1.Match == Tuple6<W1, C4, C5, C6, C7, C8> {
-  public typealias Match = Tuple10<Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8>
+>: RegexProtocol where R0.Match == (W0, C0, C1, C2, C3), R1.Match == (W1, C4, C5, C6, C7, C8) {
+  public typealias Match = (Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8)
   public let regex: Regex<Match>
   init(_ r0: R0, _ r1: R1) {
     self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
@@ -983,8 +741,8 @@ extension RegexBuilder {
 }
 public struct Concatenate_4_6<
   W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == Tuple5<W0, C0, C1, C2, C3>, R1.Match == Tuple7<W1, C4, C5, C6, C7, C8, C9> {
-  public typealias Match = Tuple11<Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9>
+>: RegexProtocol where R0.Match == (W0, C0, C1, C2, C3), R1.Match == (W1, C4, C5, C6, C7, C8, C9) {
+  public typealias Match = (Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9)
   public let regex: Regex<Match>
   init(_ r0: R0, _ r1: R1) {
     self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
@@ -998,27 +756,10 @@ extension RegexBuilder {
     .init(combined, next)
   }
 }
-public struct Concatenate_5_0<
-  W0, W1, C0, C1, C2, C3, C4, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == Tuple6<W0, C0, C1, C2, C3, C4>, R1.Match == W1 {
-  public typealias Match = Tuple6<Substring, C0, C1, C2, C3, C4>
-  public let regex: Regex<Match>
-  init(_ r0: R0, _ r1: R1) {
-    self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
-  }
-}
-extension RegexBuilder {
-  @_disfavoredOverload
-  public static func buildBlock<W0, W1, C0, C1, C2, C3, C4, R0: RegexProtocol, R1: RegexProtocol>(
-    combining next: R1, into combined: R0
-  ) -> Concatenate_5_0<W0, W1, C0, C1, C2, C3, C4, R0, R1> {
-    .init(combined, next)
-  }
-}
 public struct Concatenate_5_1<
   W0, W1, C0, C1, C2, C3, C4, C5, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == Tuple6<W0, C0, C1, C2, C3, C4>, R1.Match == Tuple2<W1, C5> {
-  public typealias Match = Tuple7<Substring, C0, C1, C2, C3, C4, C5>
+>: RegexProtocol where R0.Match == (W0, C0, C1, C2, C3, C4), R1.Match == (W1, C5) {
+  public typealias Match = (Substring, C0, C1, C2, C3, C4, C5)
   public let regex: Regex<Match>
   init(_ r0: R0, _ r1: R1) {
     self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
@@ -1034,8 +775,8 @@ extension RegexBuilder {
 }
 public struct Concatenate_5_2<
   W0, W1, C0, C1, C2, C3, C4, C5, C6, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == Tuple6<W0, C0, C1, C2, C3, C4>, R1.Match == Tuple3<W1, C5, C6> {
-  public typealias Match = Tuple8<Substring, C0, C1, C2, C3, C4, C5, C6>
+>: RegexProtocol where R0.Match == (W0, C0, C1, C2, C3, C4), R1.Match == (W1, C5, C6) {
+  public typealias Match = (Substring, C0, C1, C2, C3, C4, C5, C6)
   public let regex: Regex<Match>
   init(_ r0: R0, _ r1: R1) {
     self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
@@ -1051,8 +792,8 @@ extension RegexBuilder {
 }
 public struct Concatenate_5_3<
   W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == Tuple6<W0, C0, C1, C2, C3, C4>, R1.Match == Tuple4<W1, C5, C6, C7> {
-  public typealias Match = Tuple9<Substring, C0, C1, C2, C3, C4, C5, C6, C7>
+>: RegexProtocol where R0.Match == (W0, C0, C1, C2, C3, C4), R1.Match == (W1, C5, C6, C7) {
+  public typealias Match = (Substring, C0, C1, C2, C3, C4, C5, C6, C7)
   public let regex: Regex<Match>
   init(_ r0: R0, _ r1: R1) {
     self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
@@ -1068,8 +809,8 @@ extension RegexBuilder {
 }
 public struct Concatenate_5_4<
   W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, C8, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == Tuple6<W0, C0, C1, C2, C3, C4>, R1.Match == Tuple5<W1, C5, C6, C7, C8> {
-  public typealias Match = Tuple10<Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8>
+>: RegexProtocol where R0.Match == (W0, C0, C1, C2, C3, C4), R1.Match == (W1, C5, C6, C7, C8) {
+  public typealias Match = (Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8)
   public let regex: Regex<Match>
   init(_ r0: R0, _ r1: R1) {
     self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
@@ -1085,8 +826,8 @@ extension RegexBuilder {
 }
 public struct Concatenate_5_5<
   W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == Tuple6<W0, C0, C1, C2, C3, C4>, R1.Match == Tuple6<W1, C5, C6, C7, C8, C9> {
-  public typealias Match = Tuple11<Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9>
+>: RegexProtocol where R0.Match == (W0, C0, C1, C2, C3, C4), R1.Match == (W1, C5, C6, C7, C8, C9) {
+  public typealias Match = (Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9)
   public let regex: Regex<Match>
   init(_ r0: R0, _ r1: R1) {
     self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
@@ -1100,27 +841,10 @@ extension RegexBuilder {
     .init(combined, next)
   }
 }
-public struct Concatenate_6_0<
-  W0, W1, C0, C1, C2, C3, C4, C5, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == Tuple7<W0, C0, C1, C2, C3, C4, C5>, R1.Match == W1 {
-  public typealias Match = Tuple7<Substring, C0, C1, C2, C3, C4, C5>
-  public let regex: Regex<Match>
-  init(_ r0: R0, _ r1: R1) {
-    self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
-  }
-}
-extension RegexBuilder {
-  @_disfavoredOverload
-  public static func buildBlock<W0, W1, C0, C1, C2, C3, C4, C5, R0: RegexProtocol, R1: RegexProtocol>(
-    combining next: R1, into combined: R0
-  ) -> Concatenate_6_0<W0, W1, C0, C1, C2, C3, C4, C5, R0, R1> {
-    .init(combined, next)
-  }
-}
 public struct Concatenate_6_1<
   W0, W1, C0, C1, C2, C3, C4, C5, C6, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == Tuple7<W0, C0, C1, C2, C3, C4, C5>, R1.Match == Tuple2<W1, C6> {
-  public typealias Match = Tuple8<Substring, C0, C1, C2, C3, C4, C5, C6>
+>: RegexProtocol where R0.Match == (W0, C0, C1, C2, C3, C4, C5), R1.Match == (W1, C6) {
+  public typealias Match = (Substring, C0, C1, C2, C3, C4, C5, C6)
   public let regex: Regex<Match>
   init(_ r0: R0, _ r1: R1) {
     self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
@@ -1136,8 +860,8 @@ extension RegexBuilder {
 }
 public struct Concatenate_6_2<
   W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == Tuple7<W0, C0, C1, C2, C3, C4, C5>, R1.Match == Tuple3<W1, C6, C7> {
-  public typealias Match = Tuple9<Substring, C0, C1, C2, C3, C4, C5, C6, C7>
+>: RegexProtocol where R0.Match == (W0, C0, C1, C2, C3, C4, C5), R1.Match == (W1, C6, C7) {
+  public typealias Match = (Substring, C0, C1, C2, C3, C4, C5, C6, C7)
   public let regex: Regex<Match>
   init(_ r0: R0, _ r1: R1) {
     self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
@@ -1153,8 +877,8 @@ extension RegexBuilder {
 }
 public struct Concatenate_6_3<
   W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, C8, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == Tuple7<W0, C0, C1, C2, C3, C4, C5>, R1.Match == Tuple4<W1, C6, C7, C8> {
-  public typealias Match = Tuple10<Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8>
+>: RegexProtocol where R0.Match == (W0, C0, C1, C2, C3, C4, C5), R1.Match == (W1, C6, C7, C8) {
+  public typealias Match = (Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8)
   public let regex: Regex<Match>
   init(_ r0: R0, _ r1: R1) {
     self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
@@ -1170,8 +894,8 @@ extension RegexBuilder {
 }
 public struct Concatenate_6_4<
   W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == Tuple7<W0, C0, C1, C2, C3, C4, C5>, R1.Match == Tuple5<W1, C6, C7, C8, C9> {
-  public typealias Match = Tuple11<Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9>
+>: RegexProtocol where R0.Match == (W0, C0, C1, C2, C3, C4, C5), R1.Match == (W1, C6, C7, C8, C9) {
+  public typealias Match = (Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9)
   public let regex: Regex<Match>
   init(_ r0: R0, _ r1: R1) {
     self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
@@ -1185,27 +909,10 @@ extension RegexBuilder {
     .init(combined, next)
   }
 }
-public struct Concatenate_7_0<
-  W0, W1, C0, C1, C2, C3, C4, C5, C6, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == Tuple8<W0, C0, C1, C2, C3, C4, C5, C6>, R1.Match == W1 {
-  public typealias Match = Tuple8<Substring, C0, C1, C2, C3, C4, C5, C6>
-  public let regex: Regex<Match>
-  init(_ r0: R0, _ r1: R1) {
-    self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
-  }
-}
-extension RegexBuilder {
-  @_disfavoredOverload
-  public static func buildBlock<W0, W1, C0, C1, C2, C3, C4, C5, C6, R0: RegexProtocol, R1: RegexProtocol>(
-    combining next: R1, into combined: R0
-  ) -> Concatenate_7_0<W0, W1, C0, C1, C2, C3, C4, C5, C6, R0, R1> {
-    .init(combined, next)
-  }
-}
 public struct Concatenate_7_1<
   W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == Tuple8<W0, C0, C1, C2, C3, C4, C5, C6>, R1.Match == Tuple2<W1, C7> {
-  public typealias Match = Tuple9<Substring, C0, C1, C2, C3, C4, C5, C6, C7>
+>: RegexProtocol where R0.Match == (W0, C0, C1, C2, C3, C4, C5, C6), R1.Match == (W1, C7) {
+  public typealias Match = (Substring, C0, C1, C2, C3, C4, C5, C6, C7)
   public let regex: Regex<Match>
   init(_ r0: R0, _ r1: R1) {
     self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
@@ -1221,8 +928,8 @@ extension RegexBuilder {
 }
 public struct Concatenate_7_2<
   W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, C8, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == Tuple8<W0, C0, C1, C2, C3, C4, C5, C6>, R1.Match == Tuple3<W1, C7, C8> {
-  public typealias Match = Tuple10<Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8>
+>: RegexProtocol where R0.Match == (W0, C0, C1, C2, C3, C4, C5, C6), R1.Match == (W1, C7, C8) {
+  public typealias Match = (Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8)
   public let regex: Regex<Match>
   init(_ r0: R0, _ r1: R1) {
     self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
@@ -1238,8 +945,8 @@ extension RegexBuilder {
 }
 public struct Concatenate_7_3<
   W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == Tuple8<W0, C0, C1, C2, C3, C4, C5, C6>, R1.Match == Tuple4<W1, C7, C8, C9> {
-  public typealias Match = Tuple11<Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9>
+>: RegexProtocol where R0.Match == (W0, C0, C1, C2, C3, C4, C5, C6), R1.Match == (W1, C7, C8, C9) {
+  public typealias Match = (Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9)
   public let regex: Regex<Match>
   init(_ r0: R0, _ r1: R1) {
     self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
@@ -1253,27 +960,10 @@ extension RegexBuilder {
     .init(combined, next)
   }
 }
-public struct Concatenate_8_0<
-  W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == Tuple9<W0, C0, C1, C2, C3, C4, C5, C6, C7>, R1.Match == W1 {
-  public typealias Match = Tuple9<Substring, C0, C1, C2, C3, C4, C5, C6, C7>
-  public let regex: Regex<Match>
-  init(_ r0: R0, _ r1: R1) {
-    self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
-  }
-}
-extension RegexBuilder {
-  @_disfavoredOverload
-  public static func buildBlock<W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, R0: RegexProtocol, R1: RegexProtocol>(
-    combining next: R1, into combined: R0
-  ) -> Concatenate_8_0<W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, R0, R1> {
-    .init(combined, next)
-  }
-}
 public struct Concatenate_8_1<
   W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, C8, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == Tuple9<W0, C0, C1, C2, C3, C4, C5, C6, C7>, R1.Match == Tuple2<W1, C8> {
-  public typealias Match = Tuple10<Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8>
+>: RegexProtocol where R0.Match == (W0, C0, C1, C2, C3, C4, C5, C6, C7), R1.Match == (W1, C8) {
+  public typealias Match = (Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8)
   public let regex: Regex<Match>
   init(_ r0: R0, _ r1: R1) {
     self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
@@ -1289,8 +979,8 @@ extension RegexBuilder {
 }
 public struct Concatenate_8_2<
   W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == Tuple9<W0, C0, C1, C2, C3, C4, C5, C6, C7>, R1.Match == Tuple3<W1, C8, C9> {
-  public typealias Match = Tuple11<Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9>
+>: RegexProtocol where R0.Match == (W0, C0, C1, C2, C3, C4, C5, C6, C7), R1.Match == (W1, C8, C9) {
+  public typealias Match = (Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9)
   public let regex: Regex<Match>
   init(_ r0: R0, _ r1: R1) {
     self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
@@ -1304,27 +994,10 @@ extension RegexBuilder {
     .init(combined, next)
   }
 }
-public struct Concatenate_9_0<
-  W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, C8, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == Tuple10<W0, C0, C1, C2, C3, C4, C5, C6, C7, C8>, R1.Match == W1 {
-  public typealias Match = Tuple10<Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8>
-  public let regex: Regex<Match>
-  init(_ r0: R0, _ r1: R1) {
-    self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
-  }
-}
-extension RegexBuilder {
-  @_disfavoredOverload
-  public static func buildBlock<W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, C8, R0: RegexProtocol, R1: RegexProtocol>(
-    combining next: R1, into combined: R0
-  ) -> Concatenate_9_0<W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, C8, R0, R1> {
-    .init(combined, next)
-  }
-}
 public struct Concatenate_9_1<
   W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, R0: RegexProtocol, R1: RegexProtocol
->: RegexProtocol where R0.Match == Tuple10<W0, C0, C1, C2, C3, C4, C5, C6, C7, C8>, R1.Match == Tuple2<W1, C9> {
-  public typealias Match = Tuple11<Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9>
+>: RegexProtocol where R0.Match == (W0, C0, C1, C2, C3, C4, C5, C6, C7, C8), R1.Match == (W1, C9) {
+  public typealias Match = (Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9)
   public let regex: Regex<Match>
   init(_ r0: R0, _ r1: R1) {
     self.regex = .init(node: r0.regex.root.appending(r1.regex.root))
@@ -1339,75 +1012,1047 @@ extension RegexBuilder {
   }
 }
 extension RegexBuilder {
+  @_disfavoredOverload
   public static func buildBlock<W0, R0: RegexProtocol, R1: RegexProtocol>(
     combining next: R1, into combined: R0
-  ) -> Regex<Substring> where R0.Match == W0, R1.Match: EmptyCaptureProtocol {
+  ) -> Regex<Substring> where R0.Match == W0  {
     .init(node: combined.regex.root.appending(next.regex.root))
   }
 }
 extension RegexBuilder {
+  @_disfavoredOverload
   public static func buildBlock<W0, C0, R0: RegexProtocol, R1: RegexProtocol>(
     combining next: R1, into combined: R0
-  ) -> Regex<Tuple2<Substring, C0>> where R0.Match == Tuple2<W0, C0>, R1.Match: EmptyCaptureProtocol {
+  ) -> Regex<(Substring, C0)> where R0.Match == (W0, C0)  {
     .init(node: combined.regex.root.appending(next.regex.root))
   }
 }
 extension RegexBuilder {
+  @_disfavoredOverload
   public static func buildBlock<W0, C0, C1, R0: RegexProtocol, R1: RegexProtocol>(
     combining next: R1, into combined: R0
-  ) -> Regex<Tuple3<Substring, C0, C1>> where R0.Match == Tuple3<W0, C0, C1>, R1.Match: EmptyCaptureProtocol {
+  ) -> Regex<(Substring, C0, C1)> where R0.Match == (W0, C0, C1)  {
     .init(node: combined.regex.root.appending(next.regex.root))
   }
 }
 extension RegexBuilder {
+  @_disfavoredOverload
   public static func buildBlock<W0, C0, C1, C2, R0: RegexProtocol, R1: RegexProtocol>(
     combining next: R1, into combined: R0
-  ) -> Regex<Tuple4<Substring, C0, C1, C2>> where R0.Match == Tuple4<W0, C0, C1, C2>, R1.Match: EmptyCaptureProtocol {
+  ) -> Regex<(Substring, C0, C1, C2)> where R0.Match == (W0, C0, C1, C2)  {
     .init(node: combined.regex.root.appending(next.regex.root))
   }
 }
 extension RegexBuilder {
+  @_disfavoredOverload
   public static func buildBlock<W0, C0, C1, C2, C3, R0: RegexProtocol, R1: RegexProtocol>(
     combining next: R1, into combined: R0
-  ) -> Regex<Tuple5<Substring, C0, C1, C2, C3>> where R0.Match == Tuple5<W0, C0, C1, C2, C3>, R1.Match: EmptyCaptureProtocol {
+  ) -> Regex<(Substring, C0, C1, C2, C3)> where R0.Match == (W0, C0, C1, C2, C3)  {
     .init(node: combined.regex.root.appending(next.regex.root))
   }
 }
 extension RegexBuilder {
+  @_disfavoredOverload
   public static func buildBlock<W0, C0, C1, C2, C3, C4, R0: RegexProtocol, R1: RegexProtocol>(
     combining next: R1, into combined: R0
-  ) -> Regex<Tuple6<Substring, C0, C1, C2, C3, C4>> where R0.Match == Tuple6<W0, C0, C1, C2, C3, C4>, R1.Match: EmptyCaptureProtocol {
+  ) -> Regex<(Substring, C0, C1, C2, C3, C4)> where R0.Match == (W0, C0, C1, C2, C3, C4)  {
     .init(node: combined.regex.root.appending(next.regex.root))
   }
 }
 extension RegexBuilder {
+  @_disfavoredOverload
   public static func buildBlock<W0, C0, C1, C2, C3, C4, C5, R0: RegexProtocol, R1: RegexProtocol>(
     combining next: R1, into combined: R0
-  ) -> Regex<Tuple7<Substring, C0, C1, C2, C3, C4, C5>> where R0.Match == Tuple7<W0, C0, C1, C2, C3, C4, C5>, R1.Match: EmptyCaptureProtocol {
+  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5)> where R0.Match == (W0, C0, C1, C2, C3, C4, C5)  {
     .init(node: combined.regex.root.appending(next.regex.root))
   }
 }
 extension RegexBuilder {
+  @_disfavoredOverload
   public static func buildBlock<W0, C0, C1, C2, C3, C4, C5, C6, R0: RegexProtocol, R1: RegexProtocol>(
     combining next: R1, into combined: R0
-  ) -> Regex<Tuple8<Substring, C0, C1, C2, C3, C4, C5, C6>> where R0.Match == Tuple8<W0, C0, C1, C2, C3, C4, C5, C6>, R1.Match: EmptyCaptureProtocol {
+  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6)> where R0.Match == (W0, C0, C1, C2, C3, C4, C5, C6)  {
     .init(node: combined.regex.root.appending(next.regex.root))
   }
 }
 extension RegexBuilder {
+  @_disfavoredOverload
   public static func buildBlock<W0, C0, C1, C2, C3, C4, C5, C6, C7, R0: RegexProtocol, R1: RegexProtocol>(
     combining next: R1, into combined: R0
-  ) -> Regex<Tuple9<Substring, C0, C1, C2, C3, C4, C5, C6, C7>> where R0.Match == Tuple9<W0, C0, C1, C2, C3, C4, C5, C6, C7>, R1.Match: EmptyCaptureProtocol {
+  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7)> where R0.Match == (W0, C0, C1, C2, C3, C4, C5, C6, C7)  {
     .init(node: combined.regex.root.appending(next.regex.root))
   }
 }
 extension RegexBuilder {
+  @_disfavoredOverload
   public static func buildBlock<W0, C0, C1, C2, C3, C4, C5, C6, C7, C8, R0: RegexProtocol, R1: RegexProtocol>(
     combining next: R1, into combined: R0
-  ) -> Regex<Tuple10<Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8>> where R0.Match == Tuple10<W0, C0, C1, C2, C3, C4, C5, C6, C7, C8>, R1.Match: EmptyCaptureProtocol {
+  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8)> where R0.Match == (W0, C0, C1, C2, C3, C4, C5, C6, C7, C8)  {
     .init(node: combined.regex.root.appending(next.regex.root))
   }
 }
 
 
-// END AUTO-GENERATED CONTENT
\ No newline at end of file
+public struct _ZeroOrOne_0<Component: RegexProtocol>: RegexProtocol  {
+  public typealias Match = Substring
+  public let regex: Regex<Match>
+  public init(component: Component) {
+    self.regex = .init(node: .quantification(.zeroOrOne, .eager, component.regex.root))
+  }
+}
+
+@_disfavoredOverload
+public func optionally<Component: RegexProtocol>(
+  _ component: Component
+) -> _ZeroOrOne_0<Component> {
+  .init(component: component)
+}
+
+@_disfavoredOverload
+public func optionally<Component: RegexProtocol>(
+  @RegexBuilder _ component: () -> Component
+) -> _ZeroOrOne_0<Component> {
+  optionally(component())
+}
+
+@_disfavoredOverload
+public postfix func .?<Component: RegexProtocol>(
+  _ component: Component
+) -> _ZeroOrOne_0<Component> {
+  optionally(component)
+}
+
+extension RegexBuilder {
+  public static func buildLimitedAvailability<Component: RegexProtocol>(
+    _ component: Component
+  ) -> _ZeroOrOne_0<Component> {
+    optionally(component)
+  }
+}
+public struct _ZeroOrMore_0<Component: RegexProtocol>: RegexProtocol  {
+  public typealias Match = Substring
+  public let regex: Regex<Match>
+  public init(component: Component) {
+    self.regex = .init(node: .quantification(.zeroOrMore, .eager, component.regex.root))
+  }
+}
+
+@_disfavoredOverload
+public func many<Component: RegexProtocol>(
+  _ component: Component
+) -> _ZeroOrMore_0<Component> {
+  .init(component: component)
+}
+
+@_disfavoredOverload
+public func many<Component: RegexProtocol>(
+  @RegexBuilder _ component: () -> Component
+) -> _ZeroOrMore_0<Component> {
+  many(component())
+}
+
+@_disfavoredOverload
+public postfix func .+<Component: RegexProtocol>(
+  _ component: Component
+) -> _ZeroOrMore_0<Component> {
+  many(component)
+}
+
+
+public struct _OneOrMore_0<Component: RegexProtocol>: RegexProtocol  {
+  public typealias Match = Substring
+  public let regex: Regex<Match>
+  public init(component: Component) {
+    self.regex = .init(node: .quantification(.oneOrMore, .eager, component.regex.root))
+  }
+}
+
+@_disfavoredOverload
+public func oneOrMore<Component: RegexProtocol>(
+  _ component: Component
+) -> _OneOrMore_0<Component> {
+  .init(component: component)
+}
+
+@_disfavoredOverload
+public func oneOrMore<Component: RegexProtocol>(
+  @RegexBuilder _ component: () -> Component
+) -> _OneOrMore_0<Component> {
+  oneOrMore(component())
+}
+
+@_disfavoredOverload
+public postfix func .*<Component: RegexProtocol>(
+  _ component: Component
+) -> _OneOrMore_0<Component> {
+  oneOrMore(component)
+}
+
+
+public struct _ZeroOrOne_1<W, C0, Component: RegexProtocol>: RegexProtocol where Component.Match == (W, C0) {
+  public typealias Match = (Substring, C0?)
+  public let regex: Regex<Match>
+  public init(component: Component) {
+    self.regex = .init(node: .quantification(.zeroOrOne, .eager, component.regex.root))
+  }
+}
+
+
+public func optionally<W, C0, Component: RegexProtocol>(
+  _ component: Component
+) -> _ZeroOrOne_1<W, C0, Component> {
+  .init(component: component)
+}
+
+
+public func optionally<W, C0, Component: RegexProtocol>(
+  @RegexBuilder _ component: () -> Component
+) -> _ZeroOrOne_1<W, C0, Component> {
+  optionally(component())
+}
+
+
+public postfix func .?<W, C0, Component: RegexProtocol>(
+  _ component: Component
+) -> _ZeroOrOne_1<W, C0, Component> {
+  optionally(component)
+}
+
+extension RegexBuilder {
+  public static func buildLimitedAvailability<W, C0, Component: RegexProtocol>(
+    _ component: Component
+  ) -> _ZeroOrOne_1<W, C0, Component> {
+    optionally(component)
+  }
+}
+public struct _ZeroOrMore_1<W, C0, Component: RegexProtocol>: RegexProtocol where Component.Match == (W, C0) {
+  public typealias Match = (Substring, [C0])
+  public let regex: Regex<Match>
+  public init(component: Component) {
+    self.regex = .init(node: .quantification(.zeroOrMore, .eager, component.regex.root))
+  }
+}
+
+
+public func many<W, C0, Component: RegexProtocol>(
+  _ component: Component
+) -> _ZeroOrMore_1<W, C0, Component> {
+  .init(component: component)
+}
+
+
+public func many<W, C0, Component: RegexProtocol>(
+  @RegexBuilder _ component: () -> Component
+) -> _ZeroOrMore_1<W, C0, Component> {
+  many(component())
+}
+
+
+public postfix func .+<W, C0, Component: RegexProtocol>(
+  _ component: Component
+) -> _ZeroOrMore_1<W, C0, Component> {
+  many(component)
+}
+
+
+public struct _OneOrMore_1<W, C0, Component: RegexProtocol>: RegexProtocol where Component.Match == (W, C0) {
+  public typealias Match = (Substring, [C0])
+  public let regex: Regex<Match>
+  public init(component: Component) {
+    self.regex = .init(node: .quantification(.oneOrMore, .eager, component.regex.root))
+  }
+}
+
+
+public func oneOrMore<W, C0, Component: RegexProtocol>(
+  _ component: Component
+) -> _OneOrMore_1<W, C0, Component> {
+  .init(component: component)
+}
+
+
+public func oneOrMore<W, C0, Component: RegexProtocol>(
+  @RegexBuilder _ component: () -> Component
+) -> _OneOrMore_1<W, C0, Component> {
+  oneOrMore(component())
+}
+
+
+public postfix func .*<W, C0, Component: RegexProtocol>(
+  _ component: Component
+) -> _OneOrMore_1<W, C0, Component> {
+  oneOrMore(component)
+}
+
+
+public struct _ZeroOrOne_2<W, C0, C1, Component: RegexProtocol>: RegexProtocol where Component.Match == (W, C0, C1) {
+  public typealias Match = (Substring, (C0, C1)?)
+  public let regex: Regex<Match>
+  public init(component: Component) {
+    self.regex = .init(node: .quantification(.zeroOrOne, .eager, component.regex.root))
+  }
+}
+
+
+public func optionally<W, C0, C1, Component: RegexProtocol>(
+  _ component: Component
+) -> _ZeroOrOne_2<W, C0, C1, Component> {
+  .init(component: component)
+}
+
+
+public func optionally<W, C0, C1, Component: RegexProtocol>(
+  @RegexBuilder _ component: () -> Component
+) -> _ZeroOrOne_2<W, C0, C1, Component> {
+  optionally(component())
+}
+
+
+public postfix func .?<W, C0, C1, Component: RegexProtocol>(
+  _ component: Component
+) -> _ZeroOrOne_2<W, C0, C1, Component> {
+  optionally(component)
+}
+
+extension RegexBuilder {
+  public static func buildLimitedAvailability<W, C0, C1, Component: RegexProtocol>(
+    _ component: Component
+  ) -> _ZeroOrOne_2<W, C0, C1, Component> {
+    optionally(component)
+  }
+}
+public struct _ZeroOrMore_2<W, C0, C1, Component: RegexProtocol>: RegexProtocol where Component.Match == (W, C0, C1) {
+  public typealias Match = (Substring, [(C0, C1)])
+  public let regex: Regex<Match>
+  public init(component: Component) {
+    self.regex = .init(node: .quantification(.zeroOrMore, .eager, component.regex.root))
+  }
+}
+
+
+public func many<W, C0, C1, Component: RegexProtocol>(
+  _ component: Component
+) -> _ZeroOrMore_2<W, C0, C1, Component> {
+  .init(component: component)
+}
+
+
+public func many<W, C0, C1, Component: RegexProtocol>(
+  @RegexBuilder _ component: () -> Component
+) -> _ZeroOrMore_2<W, C0, C1, Component> {
+  many(component())
+}
+
+
+public postfix func .+<W, C0, C1, Component: RegexProtocol>(
+  _ component: Component
+) -> _ZeroOrMore_2<W, C0, C1, Component> {
+  many(component)
+}
+
+
+public struct _OneOrMore_2<W, C0, C1, Component: RegexProtocol>: RegexProtocol where Component.Match == (W, C0, C1) {
+  public typealias Match = (Substring, [(C0, C1)])
+  public let regex: Regex<Match>
+  public init(component: Component) {
+    self.regex = .init(node: .quantification(.oneOrMore, .eager, component.regex.root))
+  }
+}
+
+
+public func oneOrMore<W, C0, C1, Component: RegexProtocol>(
+  _ component: Component
+) -> _OneOrMore_2<W, C0, C1, Component> {
+  .init(component: component)
+}
+
+
+public func oneOrMore<W, C0, C1, Component: RegexProtocol>(
+  @RegexBuilder _ component: () -> Component
+) -> _OneOrMore_2<W, C0, C1, Component> {
+  oneOrMore(component())
+}
+
+
+public postfix func .*<W, C0, C1, Component: RegexProtocol>(
+  _ component: Component
+) -> _OneOrMore_2<W, C0, C1, Component> {
+  oneOrMore(component)
+}
+
+
+public struct _ZeroOrOne_3<W, C0, C1, C2, Component: RegexProtocol>: RegexProtocol where Component.Match == (W, C0, C1, C2) {
+  public typealias Match = (Substring, (C0, C1, C2)?)
+  public let regex: Regex<Match>
+  public init(component: Component) {
+    self.regex = .init(node: .quantification(.zeroOrOne, .eager, component.regex.root))
+  }
+}
+
+
+public func optionally<W, C0, C1, C2, Component: RegexProtocol>(
+  _ component: Component
+) -> _ZeroOrOne_3<W, C0, C1, C2, Component> {
+  .init(component: component)
+}
+
+
+public func optionally<W, C0, C1, C2, Component: RegexProtocol>(
+  @RegexBuilder _ component: () -> Component
+) -> _ZeroOrOne_3<W, C0, C1, C2, Component> {
+  optionally(component())
+}
+
+
+public postfix func .?<W, C0, C1, C2, Component: RegexProtocol>(
+  _ component: Component
+) -> _ZeroOrOne_3<W, C0, C1, C2, Component> {
+  optionally(component)
+}
+
+extension RegexBuilder {
+  public static func buildLimitedAvailability<W, C0, C1, C2, Component: RegexProtocol>(
+    _ component: Component
+  ) -> _ZeroOrOne_3<W, C0, C1, C2, Component> {
+    optionally(component)
+  }
+}
+public struct _ZeroOrMore_3<W, C0, C1, C2, Component: RegexProtocol>: RegexProtocol where Component.Match == (W, C0, C1, C2) {
+  public typealias Match = (Substring, [(C0, C1, C2)])
+  public let regex: Regex<Match>
+  public init(component: Component) {
+    self.regex = .init(node: .quantification(.zeroOrMore, .eager, component.regex.root))
+  }
+}
+
+
+public func many<W, C0, C1, C2, Component: RegexProtocol>(
+  _ component: Component
+) -> _ZeroOrMore_3<W, C0, C1, C2, Component> {
+  .init(component: component)
+}
+
+
+public func many<W, C0, C1, C2, Component: RegexProtocol>(
+  @RegexBuilder _ component: () -> Component
+) -> _ZeroOrMore_3<W, C0, C1, C2, Component> {
+  many(component())
+}
+
+
+public postfix func .+<W, C0, C1, C2, Component: RegexProtocol>(
+  _ component: Component
+) -> _ZeroOrMore_3<W, C0, C1, C2, Component> {
+  many(component)
+}
+
+
+public struct _OneOrMore_3<W, C0, C1, C2, Component: RegexProtocol>: RegexProtocol where Component.Match == (W, C0, C1, C2) {
+  public typealias Match = (Substring, [(C0, C1, C2)])
+  public let regex: Regex<Match>
+  public init(component: Component) {
+    self.regex = .init(node: .quantification(.oneOrMore, .eager, component.regex.root))
+  }
+}
+
+
+public func oneOrMore<W, C0, C1, C2, Component: RegexProtocol>(
+  _ component: Component
+) -> _OneOrMore_3<W, C0, C1, C2, Component> {
+  .init(component: component)
+}
+
+
+public func oneOrMore<W, C0, C1, C2, Component: RegexProtocol>(
+  @RegexBuilder _ component: () -> Component
+) -> _OneOrMore_3<W, C0, C1, C2, Component> {
+  oneOrMore(component())
+}
+
+
+public postfix func .*<W, C0, C1, C2, Component: RegexProtocol>(
+  _ component: Component
+) -> _OneOrMore_3<W, C0, C1, C2, Component> {
+  oneOrMore(component)
+}
+
+
+public struct _ZeroOrOne_4<W, C0, C1, C2, C3, Component: RegexProtocol>: RegexProtocol where Component.Match == (W, C0, C1, C2, C3) {
+  public typealias Match = (Substring, (C0, C1, C2, C3)?)
+  public let regex: Regex<Match>
+  public init(component: Component) {
+    self.regex = .init(node: .quantification(.zeroOrOne, .eager, component.regex.root))
+  }
+}
+
+
+public func optionally<W, C0, C1, C2, C3, Component: RegexProtocol>(
+  _ component: Component
+) -> _ZeroOrOne_4<W, C0, C1, C2, C3, Component> {
+  .init(component: component)
+}
+
+
+public func optionally<W, C0, C1, C2, C3, Component: RegexProtocol>(
+  @RegexBuilder _ component: () -> Component
+) -> _ZeroOrOne_4<W, C0, C1, C2, C3, Component> {
+  optionally(component())
+}
+
+
+public postfix func .?<W, C0, C1, C2, C3, Component: RegexProtocol>(
+  _ component: Component
+) -> _ZeroOrOne_4<W, C0, C1, C2, C3, Component> {
+  optionally(component)
+}
+
+extension RegexBuilder {
+  public static func buildLimitedAvailability<W, C0, C1, C2, C3, Component: RegexProtocol>(
+    _ component: Component
+  ) -> _ZeroOrOne_4<W, C0, C1, C2, C3, Component> {
+    optionally(component)
+  }
+}
+public struct _ZeroOrMore_4<W, C0, C1, C2, C3, Component: RegexProtocol>: RegexProtocol where Component.Match == (W, C0, C1, C2, C3) {
+  public typealias Match = (Substring, [(C0, C1, C2, C3)])
+  public let regex: Regex<Match>
+  public init(component: Component) {
+    self.regex = .init(node: .quantification(.zeroOrMore, .eager, component.regex.root))
+  }
+}
+
+
+public func many<W, C0, C1, C2, C3, Component: RegexProtocol>(
+  _ component: Component
+) -> _ZeroOrMore_4<W, C0, C1, C2, C3, Component> {
+  .init(component: component)
+}
+
+
+public func many<W, C0, C1, C2, C3, Component: RegexProtocol>(
+  @RegexBuilder _ component: () -> Component
+) -> _ZeroOrMore_4<W, C0, C1, C2, C3, Component> {
+  many(component())
+}
+
+
+public postfix func .+<W, C0, C1, C2, C3, Component: RegexProtocol>(
+  _ component: Component
+) -> _ZeroOrMore_4<W, C0, C1, C2, C3, Component> {
+  many(component)
+}
+
+
+public struct _OneOrMore_4<W, C0, C1, C2, C3, Component: RegexProtocol>: RegexProtocol where Component.Match == (W, C0, C1, C2, C3) {
+  public typealias Match = (Substring, [(C0, C1, C2, C3)])
+  public let regex: Regex<Match>
+  public init(component: Component) {
+    self.regex = .init(node: .quantification(.oneOrMore, .eager, component.regex.root))
+  }
+}
+
+
+public func oneOrMore<W, C0, C1, C2, C3, Component: RegexProtocol>(
+  _ component: Component
+) -> _OneOrMore_4<W, C0, C1, C2, C3, Component> {
+  .init(component: component)
+}
+
+
+public func oneOrMore<W, C0, C1, C2, C3, Component: RegexProtocol>(
+  @RegexBuilder _ component: () -> Component
+) -> _OneOrMore_4<W, C0, C1, C2, C3, Component> {
+  oneOrMore(component())
+}
+
+
+public postfix func .*<W, C0, C1, C2, C3, Component: RegexProtocol>(
+  _ component: Component
+) -> _OneOrMore_4<W, C0, C1, C2, C3, Component> {
+  oneOrMore(component)
+}
+
+
+public struct _ZeroOrOne_5<W, C0, C1, C2, C3, C4, Component: RegexProtocol>: RegexProtocol where Component.Match == (W, C0, C1, C2, C3, C4) {
+  public typealias Match = (Substring, (C0, C1, C2, C3, C4)?)
+  public let regex: Regex<Match>
+  public init(component: Component) {
+    self.regex = .init(node: .quantification(.zeroOrOne, .eager, component.regex.root))
+  }
+}
+
+
+public func optionally<W, C0, C1, C2, C3, C4, Component: RegexProtocol>(
+  _ component: Component
+) -> _ZeroOrOne_5<W, C0, C1, C2, C3, C4, Component> {
+  .init(component: component)
+}
+
+
+public func optionally<W, C0, C1, C2, C3, C4, Component: RegexProtocol>(
+  @RegexBuilder _ component: () -> Component
+) -> _ZeroOrOne_5<W, C0, C1, C2, C3, C4, Component> {
+  optionally(component())
+}
+
+
+public postfix func .?<W, C0, C1, C2, C3, C4, Component: RegexProtocol>(
+  _ component: Component
+) -> _ZeroOrOne_5<W, C0, C1, C2, C3, C4, Component> {
+  optionally(component)
+}
+
+extension RegexBuilder {
+  public static func buildLimitedAvailability<W, C0, C1, C2, C3, C4, Component: RegexProtocol>(
+    _ component: Component
+  ) -> _ZeroOrOne_5<W, C0, C1, C2, C3, C4, Component> {
+    optionally(component)
+  }
+}
+public struct _ZeroOrMore_5<W, C0, C1, C2, C3, C4, Component: RegexProtocol>: RegexProtocol where Component.Match == (W, C0, C1, C2, C3, C4) {
+  public typealias Match = (Substring, [(C0, C1, C2, C3, C4)])
+  public let regex: Regex<Match>
+  public init(component: Component) {
+    self.regex = .init(node: .quantification(.zeroOrMore, .eager, component.regex.root))
+  }
+}
+
+
+public func many<W, C0, C1, C2, C3, C4, Component: RegexProtocol>(
+  _ component: Component
+) -> _ZeroOrMore_5<W, C0, C1, C2, C3, C4, Component> {
+  .init(component: component)
+}
+
+
+public func many<W, C0, C1, C2, C3, C4, Component: RegexProtocol>(
+  @RegexBuilder _ component: () -> Component
+) -> _ZeroOrMore_5<W, C0, C1, C2, C3, C4, Component> {
+  many(component())
+}
+
+
+public postfix func .+<W, C0, C1, C2, C3, C4, Component: RegexProtocol>(
+  _ component: Component
+) -> _ZeroOrMore_5<W, C0, C1, C2, C3, C4, Component> {
+  many(component)
+}
+
+
+public struct _OneOrMore_5<W, C0, C1, C2, C3, C4, Component: RegexProtocol>: RegexProtocol where Component.Match == (W, C0, C1, C2, C3, C4) {
+  public typealias Match = (Substring, [(C0, C1, C2, C3, C4)])
+  public let regex: Regex<Match>
+  public init(component: Component) {
+    self.regex = .init(node: .quantification(.oneOrMore, .eager, component.regex.root))
+  }
+}
+
+
+public func oneOrMore<W, C0, C1, C2, C3, C4, Component: RegexProtocol>(
+  _ component: Component
+) -> _OneOrMore_5<W, C0, C1, C2, C3, C4, Component> {
+  .init(component: component)
+}
+
+
+public func oneOrMore<W, C0, C1, C2, C3, C4, Component: RegexProtocol>(
+  @RegexBuilder _ component: () -> Component
+) -> _OneOrMore_5<W, C0, C1, C2, C3, C4, Component> {
+  oneOrMore(component())
+}
+
+
+public postfix func .*<W, C0, C1, C2, C3, C4, Component: RegexProtocol>(
+  _ component: Component
+) -> _OneOrMore_5<W, C0, C1, C2, C3, C4, Component> {
+  oneOrMore(component)
+}
+
+
+public struct _ZeroOrOne_6<W, C0, C1, C2, C3, C4, C5, Component: RegexProtocol>: RegexProtocol where Component.Match == (W, C0, C1, C2, C3, C4, C5) {
+  public typealias Match = (Substring, (C0, C1, C2, C3, C4, C5)?)
+  public let regex: Regex<Match>
+  public init(component: Component) {
+    self.regex = .init(node: .quantification(.zeroOrOne, .eager, component.regex.root))
+  }
+}
+
+
+public func optionally<W, C0, C1, C2, C3, C4, C5, Component: RegexProtocol>(
+  _ component: Component
+) -> _ZeroOrOne_6<W, C0, C1, C2, C3, C4, C5, Component> {
+  .init(component: component)
+}
+
+
+public func optionally<W, C0, C1, C2, C3, C4, C5, Component: RegexProtocol>(
+  @RegexBuilder _ component: () -> Component
+) -> _ZeroOrOne_6<W, C0, C1, C2, C3, C4, C5, Component> {
+  optionally(component())
+}
+
+
+public postfix func .?<W, C0, C1, C2, C3, C4, C5, Component: RegexProtocol>(
+  _ component: Component
+) -> _ZeroOrOne_6<W, C0, C1, C2, C3, C4, C5, Component> {
+  optionally(component)
+}
+
+extension RegexBuilder {
+  public static func buildLimitedAvailability<W, C0, C1, C2, C3, C4, C5, Component: RegexProtocol>(
+    _ component: Component
+  ) -> _ZeroOrOne_6<W, C0, C1, C2, C3, C4, C5, Component> {
+    optionally(component)
+  }
+}
+public struct _ZeroOrMore_6<W, C0, C1, C2, C3, C4, C5, Component: RegexProtocol>: RegexProtocol where Component.Match == (W, C0, C1, C2, C3, C4, C5) {
+  public typealias Match = (Substring, [(C0, C1, C2, C3, C4, C5)])
+  public let regex: Regex<Match>
+  public init(component: Component) {
+    self.regex = .init(node: .quantification(.zeroOrMore, .eager, component.regex.root))
+  }
+}
+
+
+public func many<W, C0, C1, C2, C3, C4, C5, Component: RegexProtocol>(
+  _ component: Component
+) -> _ZeroOrMore_6<W, C0, C1, C2, C3, C4, C5, Component> {
+  .init(component: component)
+}
+
+
+public func many<W, C0, C1, C2, C3, C4, C5, Component: RegexProtocol>(
+  @RegexBuilder _ component: () -> Component
+) -> _ZeroOrMore_6<W, C0, C1, C2, C3, C4, C5, Component> {
+  many(component())
+}
+
+
+public postfix func .+<W, C0, C1, C2, C3, C4, C5, Component: RegexProtocol>(
+  _ component: Component
+) -> _ZeroOrMore_6<W, C0, C1, C2, C3, C4, C5, Component> {
+  many(component)
+}
+
+
+public struct _OneOrMore_6<W, C0, C1, C2, C3, C4, C5, Component: RegexProtocol>: RegexProtocol where Component.Match == (W, C0, C1, C2, C3, C4, C5) {
+  public typealias Match = (Substring, [(C0, C1, C2, C3, C4, C5)])
+  public let regex: Regex<Match>
+  public init(component: Component) {
+    self.regex = .init(node: .quantification(.oneOrMore, .eager, component.regex.root))
+  }
+}
+
+
+public func oneOrMore<W, C0, C1, C2, C3, C4, C5, Component: RegexProtocol>(
+  _ component: Component
+) -> _OneOrMore_6<W, C0, C1, C2, C3, C4, C5, Component> {
+  .init(component: component)
+}
+
+
+public func oneOrMore<W, C0, C1, C2, C3, C4, C5, Component: RegexProtocol>(
+  @RegexBuilder _ component: () -> Component
+) -> _OneOrMore_6<W, C0, C1, C2, C3, C4, C5, Component> {
+  oneOrMore(component())
+}
+
+
+public postfix func .*<W, C0, C1, C2, C3, C4, C5, Component: RegexProtocol>(
+  _ component: Component
+) -> _OneOrMore_6<W, C0, C1, C2, C3, C4, C5, Component> {
+  oneOrMore(component)
+}
+
+
+public struct _ZeroOrOne_7<W, C0, C1, C2, C3, C4, C5, C6, Component: RegexProtocol>: RegexProtocol where Component.Match == (W, C0, C1, C2, C3, C4, C5, C6) {
+  public typealias Match = (Substring, (C0, C1, C2, C3, C4, C5, C6)?)
+  public let regex: Regex<Match>
+  public init(component: Component) {
+    self.regex = .init(node: .quantification(.zeroOrOne, .eager, component.regex.root))
+  }
+}
+
+
+public func optionally<W, C0, C1, C2, C3, C4, C5, C6, Component: RegexProtocol>(
+  _ component: Component
+) -> _ZeroOrOne_7<W, C0, C1, C2, C3, C4, C5, C6, Component> {
+  .init(component: component)
+}
+
+
+public func optionally<W, C0, C1, C2, C3, C4, C5, C6, Component: RegexProtocol>(
+  @RegexBuilder _ component: () -> Component
+) -> _ZeroOrOne_7<W, C0, C1, C2, C3, C4, C5, C6, Component> {
+  optionally(component())
+}
+
+
+public postfix func .?<W, C0, C1, C2, C3, C4, C5, C6, Component: RegexProtocol>(
+  _ component: Component
+) -> _ZeroOrOne_7<W, C0, C1, C2, C3, C4, C5, C6, Component> {
+  optionally(component)
+}
+
+extension RegexBuilder {
+  public static func buildLimitedAvailability<W, C0, C1, C2, C3, C4, C5, C6, Component: RegexProtocol>(
+    _ component: Component
+  ) -> _ZeroOrOne_7<W, C0, C1, C2, C3, C4, C5, C6, Component> {
+    optionally(component)
+  }
+}
+public struct _ZeroOrMore_7<W, C0, C1, C2, C3, C4, C5, C6, Component: RegexProtocol>: RegexProtocol where Component.Match == (W, C0, C1, C2, C3, C4, C5, C6) {
+  public typealias Match = (Substring, [(C0, C1, C2, C3, C4, C5, C6)])
+  public let regex: Regex<Match>
+  public init(component: Component) {
+    self.regex = .init(node: .quantification(.zeroOrMore, .eager, component.regex.root))
+  }
+}
+
+
+public func many<W, C0, C1, C2, C3, C4, C5, C6, Component: RegexProtocol>(
+  _ component: Component
+) -> _ZeroOrMore_7<W, C0, C1, C2, C3, C4, C5, C6, Component> {
+  .init(component: component)
+}
+
+
+public func many<W, C0, C1, C2, C3, C4, C5, C6, Component: RegexProtocol>(
+  @RegexBuilder _ component: () -> Component
+) -> _ZeroOrMore_7<W, C0, C1, C2, C3, C4, C5, C6, Component> {
+  many(component())
+}
+
+
+public postfix func .+<W, C0, C1, C2, C3, C4, C5, C6, Component: RegexProtocol>(
+  _ component: Component
+) -> _ZeroOrMore_7<W, C0, C1, C2, C3, C4, C5, C6, Component> {
+  many(component)
+}
+
+
+public struct _OneOrMore_7<W, C0, C1, C2, C3, C4, C5, C6, Component: RegexProtocol>: RegexProtocol where Component.Match == (W, C0, C1, C2, C3, C4, C5, C6) {
+  public typealias Match = (Substring, [(C0, C1, C2, C3, C4, C5, C6)])
+  public let regex: Regex<Match>
+  public init(component: Component) {
+    self.regex = .init(node: .quantification(.oneOrMore, .eager, component.regex.root))
+  }
+}
+
+
+public func oneOrMore<W, C0, C1, C2, C3, C4, C5, C6, Component: RegexProtocol>(
+  _ component: Component
+) -> _OneOrMore_7<W, C0, C1, C2, C3, C4, C5, C6, Component> {
+  .init(component: component)
+}
+
+
+public func oneOrMore<W, C0, C1, C2, C3, C4, C5, C6, Component: RegexProtocol>(
+  @RegexBuilder _ component: () -> Component
+) -> _OneOrMore_7<W, C0, C1, C2, C3, C4, C5, C6, Component> {
+  oneOrMore(component())
+}
+
+
+public postfix func .*<W, C0, C1, C2, C3, C4, C5, C6, Component: RegexProtocol>(
+  _ component: Component
+) -> _OneOrMore_7<W, C0, C1, C2, C3, C4, C5, C6, Component> {
+  oneOrMore(component)
+}
+
+
+public struct _ZeroOrOne_8<W, C0, C1, C2, C3, C4, C5, C6, C7, Component: RegexProtocol>: RegexProtocol where Component.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
+  public typealias Match = (Substring, (C0, C1, C2, C3, C4, C5, C6, C7)?)
+  public let regex: Regex<Match>
+  public init(component: Component) {
+    self.regex = .init(node: .quantification(.zeroOrOne, .eager, component.regex.root))
+  }
+}
+
+
+public func optionally<W, C0, C1, C2, C3, C4, C5, C6, C7, Component: RegexProtocol>(
+  _ component: Component
+) -> _ZeroOrOne_8<W, C0, C1, C2, C3, C4, C5, C6, C7, Component> {
+  .init(component: component)
+}
+
+
+public func optionally<W, C0, C1, C2, C3, C4, C5, C6, C7, Component: RegexProtocol>(
+  @RegexBuilder _ component: () -> Component
+) -> _ZeroOrOne_8<W, C0, C1, C2, C3, C4, C5, C6, C7, Component> {
+  optionally(component())
+}
+
+
+public postfix func .?<W, C0, C1, C2, C3, C4, C5, C6, C7, Component: RegexProtocol>(
+  _ component: Component
+) -> _ZeroOrOne_8<W, C0, C1, C2, C3, C4, C5, C6, C7, Component> {
+  optionally(component)
+}
+
+extension RegexBuilder {
+  public static func buildLimitedAvailability<W, C0, C1, C2, C3, C4, C5, C6, C7, Component: RegexProtocol>(
+    _ component: Component
+  ) -> _ZeroOrOne_8<W, C0, C1, C2, C3, C4, C5, C6, C7, Component> {
+    optionally(component)
+  }
+}
+public struct _ZeroOrMore_8<W, C0, C1, C2, C3, C4, C5, C6, C7, Component: RegexProtocol>: RegexProtocol where Component.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
+  public typealias Match = (Substring, [(C0, C1, C2, C3, C4, C5, C6, C7)])
+  public let regex: Regex<Match>
+  public init(component: Component) {
+    self.regex = .init(node: .quantification(.zeroOrMore, .eager, component.regex.root))
+  }
+}
+
+
+public func many<W, C0, C1, C2, C3, C4, C5, C6, C7, Component: RegexProtocol>(
+  _ component: Component
+) -> _ZeroOrMore_8<W, C0, C1, C2, C3, C4, C5, C6, C7, Component> {
+  .init(component: component)
+}
+
+
+public func many<W, C0, C1, C2, C3, C4, C5, C6, C7, Component: RegexProtocol>(
+  @RegexBuilder _ component: () -> Component
+) -> _ZeroOrMore_8<W, C0, C1, C2, C3, C4, C5, C6, C7, Component> {
+  many(component())
+}
+
+
+public postfix func .+<W, C0, C1, C2, C3, C4, C5, C6, C7, Component: RegexProtocol>(
+  _ component: Component
+) -> _ZeroOrMore_8<W, C0, C1, C2, C3, C4, C5, C6, C7, Component> {
+  many(component)
+}
+
+
+public struct _OneOrMore_8<W, C0, C1, C2, C3, C4, C5, C6, C7, Component: RegexProtocol>: RegexProtocol where Component.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
+  public typealias Match = (Substring, [(C0, C1, C2, C3, C4, C5, C6, C7)])
+  public let regex: Regex<Match>
+  public init(component: Component) {
+    self.regex = .init(node: .quantification(.oneOrMore, .eager, component.regex.root))
+  }
+}
+
+
+public func oneOrMore<W, C0, C1, C2, C3, C4, C5, C6, C7, Component: RegexProtocol>(
+  _ component: Component
+) -> _OneOrMore_8<W, C0, C1, C2, C3, C4, C5, C6, C7, Component> {
+  .init(component: component)
+}
+
+
+public func oneOrMore<W, C0, C1, C2, C3, C4, C5, C6, C7, Component: RegexProtocol>(
+  @RegexBuilder _ component: () -> Component
+) -> _OneOrMore_8<W, C0, C1, C2, C3, C4, C5, C6, C7, Component> {
+  oneOrMore(component())
+}
+
+
+public postfix func .*<W, C0, C1, C2, C3, C4, C5, C6, C7, Component: RegexProtocol>(
+  _ component: Component
+) -> _OneOrMore_8<W, C0, C1, C2, C3, C4, C5, C6, C7, Component> {
+  oneOrMore(component)
+}
+
+
+public struct _ZeroOrOne_9<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, Component: RegexProtocol>: RegexProtocol where Component.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
+  public typealias Match = (Substring, (C0, C1, C2, C3, C4, C5, C6, C7, C8)?)
+  public let regex: Regex<Match>
+  public init(component: Component) {
+    self.regex = .init(node: .quantification(.zeroOrOne, .eager, component.regex.root))
+  }
+}
+
+
+public func optionally<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, Component: RegexProtocol>(
+  _ component: Component
+) -> _ZeroOrOne_9<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, Component> {
+  .init(component: component)
+}
+
+
+public func optionally<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, Component: RegexProtocol>(
+  @RegexBuilder _ component: () -> Component
+) -> _ZeroOrOne_9<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, Component> {
+  optionally(component())
+}
+
+
+public postfix func .?<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, Component: RegexProtocol>(
+  _ component: Component
+) -> _ZeroOrOne_9<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, Component> {
+  optionally(component)
+}
+
+extension RegexBuilder {
+  public static func buildLimitedAvailability<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, Component: RegexProtocol>(
+    _ component: Component
+  ) -> _ZeroOrOne_9<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, Component> {
+    optionally(component)
+  }
+}
+public struct _ZeroOrMore_9<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, Component: RegexProtocol>: RegexProtocol where Component.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
+  public typealias Match = (Substring, [(C0, C1, C2, C3, C4, C5, C6, C7, C8)])
+  public let regex: Regex<Match>
+  public init(component: Component) {
+    self.regex = .init(node: .quantification(.zeroOrMore, .eager, component.regex.root))
+  }
+}
+
+
+public func many<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, Component: RegexProtocol>(
+  _ component: Component
+) -> _ZeroOrMore_9<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, Component> {
+  .init(component: component)
+}
+
+
+public func many<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, Component: RegexProtocol>(
+  @RegexBuilder _ component: () -> Component
+) -> _ZeroOrMore_9<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, Component> {
+  many(component())
+}
+
+
+public postfix func .+<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, Component: RegexProtocol>(
+  _ component: Component
+) -> _ZeroOrMore_9<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, Component> {
+  many(component)
+}
+
+
+public struct _OneOrMore_9<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, Component: RegexProtocol>: RegexProtocol where Component.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
+  public typealias Match = (Substring, [(C0, C1, C2, C3, C4, C5, C6, C7, C8)])
+  public let regex: Regex<Match>
+  public init(component: Component) {
+    self.regex = .init(node: .quantification(.oneOrMore, .eager, component.regex.root))
+  }
+}
+
+
+public func oneOrMore<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, Component: RegexProtocol>(
+  _ component: Component
+) -> _OneOrMore_9<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, Component> {
+  .init(component: component)
+}
+
+
+public func oneOrMore<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, Component: RegexProtocol>(
+  @RegexBuilder _ component: () -> Component
+) -> _OneOrMore_9<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, Component> {
+  oneOrMore(component())
+}
+
+
+public postfix func .*<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, Component: RegexProtocol>(
+  _ component: Component
+) -> _OneOrMore_9<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, Component> {
+  oneOrMore(component)
+}
+
+
+
+
+// END AUTO-GENERATED CONTENT
diff --git a/Sources/_StringProcessing/RegexDSL/Core.swift b/Sources/_StringProcessing/RegexDSL/Core.swift
index bcdf96c5d..f161ee227 100644
--- a/Sources/_StringProcessing/RegexDSL/Core.swift
+++ b/Sources/_StringProcessing/RegexDSL/Core.swift
@@ -23,34 +23,12 @@ public struct RegexMatch<Match> {
 
 /// A type that represents a regular expression.
 public protocol RegexProtocol {
-  associatedtype Match: MatchProtocol
+  associatedtype Match
   var regex: Regex<Match> { get }
 }
 
-/// A `RegexProtocol` that has a single component child.
-///
-/// This protocol adds an init supporting static lookup for character classes
-public protocol RegexProtocolWithComponent: RegexProtocol {
-  associatedtype Component: RegexProtocol
-
-  // Label needed for disambiguation
-  init(component: Component)
-}
-extension RegexProtocolWithComponent
-where Component == CharacterClass {
-  // This gives us static member lookup
-  public init(_ component: Component) {
-    self.init(component: component)
-  }
-}
-extension RegexProtocolWithComponent {
-  public init(_ component: Component) {
-    self.init(component: component)
-  }
-}
-
 /// A regular expression.
-public struct Regex<Match: MatchProtocol>: RegexProtocol {
+public struct Regex<Match>: RegexProtocol {
   /// A program representation that caches any lowered representation for
   /// execution.
   internal class Program {
@@ -167,10 +145,8 @@ extension RegexProtocol {
         return nil
       }
       let convertedMatch: Match
-      if Match.self == Tuple2<Substring, DynamicCaptures>.self {
-        convertedMatch = Tuple2(
-          input[range], DynamicCaptures(captures)
-        ) as! Match
+      if Match.self == (Substring, DynamicCaptures).self {
+        convertedMatch = (input[range], DynamicCaptures(captures)) as! Match
       } else {
         let typeErasedMatch = captures.matchValue(
           withWholeMatch: input[range]
@@ -187,10 +163,8 @@ extension RegexProtocol {
       return nil
     }
     let convertedMatch: Match
-    if Match.self == Tuple2<Substring, DynamicCaptures>.self {
-      convertedMatch = Tuple2(
-        input[result.range], DynamicCaptures.empty
-      ) as! Match
+    if Match.self == (Substring, DynamicCaptures).self {
+      convertedMatch = (input[result.range], DynamicCaptures.empty) as! Match
     } else {
       assert(Match.self == Substring.self)
       convertedMatch = input[result.range] as! Match
@@ -221,7 +195,7 @@ extension Substring {
     match(content())
   }
 }
-public struct MockRegexLiteral<Match: MatchProtocol>: RegexProtocol {
+public struct MockRegexLiteral<Match>: RegexProtocol {
   public typealias MatchValue = Substring
   public let regex: Regex<Match>
 
@@ -241,16 +215,3 @@ public func r<Match>(
 }
 
 fileprivate typealias DefaultEngine = TortoiseVM
-
-public protocol EmptyCaptureProtocol {}
-public struct EmptyCapture: EmptyCaptureProtocol {}
-extension Array: EmptyCaptureProtocol where Element: EmptyCaptureProtocol {}
-extension Optional: EmptyCaptureProtocol where Wrapped: EmptyCaptureProtocol {}
-
-public protocol MatchProtocol {
-  associatedtype Capture
-}
-extension Substring: MatchProtocol {
-  public typealias Capture = EmptyCapture
-}
-
diff --git a/Sources/_StringProcessing/RegexDSL/DSL.swift b/Sources/_StringProcessing/RegexDSL/DSL.swift
index d90af6db8..a2daf579e 100644
--- a/Sources/_StringProcessing/RegexDSL/DSL.swift
+++ b/Sources/_StringProcessing/RegexDSL/DSL.swift
@@ -14,7 +14,6 @@ import _MatchingEngine
 // MARK: - Primitives
 
 extension String: RegexProtocol {
-  public typealias Capture = EmptyCapture
   public typealias Match = Substring
 
   public var regex: Regex<Match> {
@@ -24,7 +23,6 @@ extension String: RegexProtocol {
 }
 
 extension Character: RegexProtocol {
-  public typealias Capture = EmptyCapture
   public typealias Match = Substring
 
   public var regex: Regex<Match> {
@@ -33,7 +31,6 @@ extension Character: RegexProtocol {
 }
 
 extension CharacterClass: RegexProtocol {
-  public typealias Capture = EmptyCapture
   public typealias Match = Substring
 
   public var regex: Regex<Match> {
@@ -46,97 +43,81 @@ extension CharacterClass: RegexProtocol {
 
 // MARK: - Combinators
 
-// TODO: We want variadic generics!
-// Overloads are auto-generated in Concatenation.swift.
-//
-// public struct Concatenate<R...: RegexContent>: RegexContent {
-//   public let regex: Regex<(R...).filter { $0 != Void.self }>
-//
-//   public init(_ components: R...) {
-//     regex = .init(ast: .concatenation([#splat(components...)]))
-//   }
-// }
+// MARK: Concatenation
 
-// MARK: Repetition
+// Note: Concatenation overloads are currently gyb'd.
 
-/// A regular expression.
-public struct OneOrMore<Component: RegexProtocol>: RegexProtocolWithComponent {
-  public typealias Match = Tuple2<Substring, [Component.Match.Capture]>
+// TODO: Variadic generics
+// struct Concatenation<W0, C0..., R0: RegexProtocol, W1, C1..., R1: RegexProtocol>
+// where R0.Match == (W0, C0...), R1.Match == (W1, C1...)
+// {
+//   typealias Match = (Substring, C0..., C1...)
+//   let regex: Regex<Match>
+//   init(_ first: R0, _ second: R1) {
+//     regex = .init(concat(r0, r1))
+//   }
+// }
 
-  public let regex: Regex<Match>
+// MARK: Quantification
 
-  public init(component: Component) {
-    self.regex = .init(node: .quantification(
-      .oneOrMore, .eager, component.regex.root)
-    )
-  }
+// Note: Quantifiers are currently gyb'd.
 
-  public init(@RegexBuilder _ content: () -> Component) {
-    self.init(content())
-  }
-}
+// TODO: Variadic generics
+// struct _OneOrMore<W, C..., Component: RegexProtocol>
+// where R.Match == (W, C...)
+// {
+//   typealias Match = (Substring, [(C...)])
+//   let regex: Regex<Match>
+//   init(_ component: Component) {
+//     regex = .init(oneOrMore(r0))
+//   }
+// }
+//
+// struct _OneOrMoreNonCapturing<Component: RegexProtocol> {
+//   typealias Match = Substring
+//   let regex: Regex<Match>
+//   init(_ component: Component) {
+//     regex = .init(oneOrMore(r0))
+//   }
+// }
+//
+// func oneOrMore<W, C..., Component: RegexProtocol>(
+//   _ component: Component
+// ) -> <R: RegexProtocol where R.Match == (Substring, [(C...)])> R {
+//   _OneOrMore(component)
+// }
+//
+// @_disfavoredOverload
+// func oneOrMore<Component: RegexProtocol>(
+//   _ component: Component
+// ) -> <R: RegexProtocol where R.Match == Substring> R {
+//   _OneOrMoreNonCapturing(component)
+// }
 
+postfix operator .?
+postfix operator .*
 postfix operator .+
 
-public postfix func .+ <R: RegexProtocol>(
-  lhs: R
-) -> OneOrMore<R> {
-  .init(lhs)
-}
-
-public struct Repeat<
-  Component: RegexProtocol
->: RegexProtocolWithComponent {
-  public typealias Match = Tuple2<Substring, [Component.Match.Capture]>
-
-  public let regex: Regex<Match>
-
-  public init(component: Component) {
-    self.regex = .init(node: .quantification(
-      .zeroOrMore, .eager, component.regex.root))
-  }
-
-  public init(@RegexBuilder _ content: () -> Component) {
-    self.init(content())
-  }
+// Overloads for quantifying over a character class.
+public func zeroOrOne(_ cc: CharacterClass) -> _ZeroOrOne_0<CharacterClass> {
+  .init(component: cc)
 }
 
-postfix operator .*
-
-public postfix func .* <R: RegexProtocol>(
-  lhs: R
-) -> Repeat<R> {
-  .init(lhs)
+public func many(_ cc: CharacterClass) -> _ZeroOrMore_0<CharacterClass> {
+  .init(component: cc)
 }
 
-public struct Optionally<Component: RegexProtocol>: RegexProtocolWithComponent {
-  public typealias Match = Tuple2<Substring, Component.Match.Capture?>
-
-  public let regex: Regex<Match>
-
-  public init(component: Component) {
-    self.regex = .init(node: .quantification(
-      .zeroOrOne, .eager, component.regex.root))
-  }
-
-  public init(@RegexBuilder _ content: () -> Component) {
-    self.init(content())
-  }
+public func oneOrMore(_ cc: CharacterClass) -> _OneOrMore_0<CharacterClass> {
+  .init(component: cc)
 }
 
-postfix operator .?
-
-public postfix func .? <R: RegexProtocol>(
-  lhs: R
-) -> Optionally<R> {
-  .init(lhs)
-}
+// MARK: Alternation
 
 // TODO: Support heterogeneous capture alternation.
 public struct Alternation<
   Component1: RegexProtocol, Component2: RegexProtocol
->: RegexProtocol where Component1.Match.Capture == Component2.Match.Capture {
-  public typealias Match = Tuple2<Substring, Component1.Match.Capture>
+>: RegexProtocol {
+  public typealias Match = Component1.Match
 
   public let regex: Regex<Match>
 
@@ -161,7 +142,7 @@ public func | <Component1, Component2>(
 
 // MARK: - Capture
 
-public struct CapturingGroup<Match: MatchProtocol>: RegexProtocol {
+public struct CapturingGroup<Match>: RegexProtocol {
   public let regex: Regex<Match>
 
   init<Component: RegexProtocol>(
diff --git a/Sources/_StringProcessing/RegexDSL/DSLCapture.swift b/Sources/_StringProcessing/RegexDSL/DSLCapture.swift
index 4d2dba9a3..05d974239 100644
--- a/Sources/_StringProcessing/RegexDSL/DSLCapture.swift
+++ b/Sources/_StringProcessing/RegexDSL/DSLCapture.swift
@@ -10,93 +10,97 @@
 //===----------------------------------------------------------------------===//
 
 extension RegexProtocol {
-  public func capture() -> CapturingGroup<Tuple2<Substring, Substring>> where Match.Capture: EmptyCaptureProtocol {
+  @_disfavoredOverload
+  public func capture() -> CapturingGroup<(Substring, Substring)> {
     .init(self)
   }
 
+  @_disfavoredOverload
   public func capture<NewCapture>(
     _ transform: @escaping (Substring) -> NewCapture
-  ) -> CapturingGroup<Tuple2<Substring, NewCapture>> where Match.Capture: EmptyCaptureProtocol {
+  ) -> CapturingGroup<(Substring, NewCapture)> {
     .init(self, transform: transform)
   }
 
+  @_disfavoredOverload
   public func tryCapture<NewCapture>(
     _ transform: @escaping (Substring) throws -> NewCapture
-  ) -> CapturingGroup<Tuple2<Substring, NewCapture>> where Match.Capture: EmptyCaptureProtocol {
+  ) -> CapturingGroup<(Substring, NewCapture)> {
     .init(self, transform: transform)
   }
 
+  @_disfavoredOverload
   public func tryCapture<NewCapture>(
     _ transform: @escaping (Substring) -> NewCapture?
-  ) -> CapturingGroup<Tuple2<Substring, NewCapture>> where Match.Capture: EmptyCaptureProtocol {
+  ) -> CapturingGroup<(Substring, NewCapture)> {
     .init(self, transform: transform)
   }
 
-  public func capture<C0>() -> CapturingGroup<Tuple3<Substring, Substring, C0>>
-  where Match.Capture == C0 {
+  public func capture<W, C0>() -> CapturingGroup<(Substring, Substring, C0)>
+  where Match == (W, C0) {
     .init(self)
   }
 
-  public func capture<NewCapture, C0>(
+  public func capture<NewCapture, W, C0>(
     _ transform: @escaping (Substring) -> NewCapture
-  ) -> CapturingGroup<Tuple3<Substring, NewCapture, C0>> where Match.Capture == C0 {
+  ) -> CapturingGroup<(Substring, NewCapture, C0)> where Match == (W, C0) {
     .init(self, transform: transform)
   }
 
-  public func tryCapture<NewCapture, C0>(
+  public func tryCapture<NewCapture, W, C0>(
     _ transform: @escaping (Substring) throws -> NewCapture
-  ) -> CapturingGroup<Tuple3<Substring, NewCapture, C0>> where Match.Capture == C0 {
+  ) -> CapturingGroup<(Substring, NewCapture, C0)> where Match == (W, C0) {
     .init(self, transform: transform)
   }
 
-  public func tryCapture<NewCapture, C0>(
+  public func tryCapture<NewCapture, W, C0>(
     _ transform: @escaping (Substring) -> NewCapture?
-  ) -> CapturingGroup<Tuple3<Substring, NewCapture, C0>> where Match.Capture == C0 {
+  ) -> CapturingGroup<(Substring, NewCapture, C0)> where Match == (W, C0) {
     .init(self, transform: transform)
   }
 
-  public func capture<C0, C1>() -> CapturingGroup<Tuple4<Substring, Substring, C0, C1>> where Match.Capture == Tuple2<C0, C1> {
+  public func capture<W, C0, C1>() -> CapturingGroup<(Substring, Substring, C0, C1)> where Match == (W, C0, C1) {
     .init(self)
   }
 
-  public func capture<NewCapture, C0, C1>(
+  public func capture<NewCapture, W, C0, C1>(
     _ transform: @escaping (Substring) -> NewCapture
-  ) -> CapturingGroup<Tuple4<Substring, NewCapture, C0, C1>> where Match.Capture == Tuple2<C0, C1> {
+  ) -> CapturingGroup<(Substring, NewCapture, C0, C1)> where Match == (W, C0, C1) {
     .init(self, transform: transform)
   }
 
-  public func tryCapture<NewCapture, C0, C1>(
+  public func tryCapture<NewCapture, W, C0, C1>(
     _ transform: @escaping (Substring) throws -> NewCapture
-  ) -> CapturingGroup<Tuple4<Substring, NewCapture, C0, C1>> where Match.Capture == Tuple2<C0, C1> {
+  ) -> CapturingGroup<(Substring, NewCapture, C0, C1)> where Match == (W, C0, C1) {
     .init(self, transform: transform)
   }
 
-  public func tryCapture<NewCapture, C0, C1>(
+  public func tryCapture<NewCapture, W, C0, C1>(
     _ transform: @escaping (Substring) -> NewCapture?
-  ) -> CapturingGroup<Tuple4<Substring, NewCapture, C0, C1>> where Match.Capture == Tuple2<C0, C1> {
+  ) -> CapturingGroup<(Substring, NewCapture, C0, C1)> where Match == (W, C0, C1) {
     .init(self, transform: transform)
   }
 
-  public func capture<C0, C1, C2>() -> CapturingGroup<Tuple5<Substring, Substring, C0, C1, C2>>
-  where Match.Capture == Tuple3<C0, C1, C2> {
+  public func capture<W, C0, C1, C2>() -> CapturingGroup<(Substring, Substring, C0, C1, C2)>
+  where Match == (W, C0, C1, C2) {
     .init(self)
   }
 
-  public func capture<NewCapture, C0, C1, C2>(
+  public func capture<NewCapture, W, C0, C1, C2>(
     _ transform: @escaping (Substring) -> NewCapture
-  ) -> CapturingGroup<Tuple5<Substring, NewCapture, C0, C1, C2>> where Match.Capture == Tuple3<C0, C1, C2> {
+  ) -> CapturingGroup<(Substring, NewCapture, C0, C1, C2)> where Match == (W, C0, C1, C2) {
     .init(self, transform: transform)
   }
 
-  public func tryCapture<NewCapture, C0, C1, C2>(
+  public func tryCapture<NewCapture, W, C0, C1, C2>(
     _ transform: @escaping (Substring) throws -> NewCapture
-  ) -> CapturingGroup<Tuple5<Substring, NewCapture, C0, C1, C2>> where Match.Capture == Tuple3<C0, C1, C2> {
+  ) -> CapturingGroup<(Substring, NewCapture, C0, C1, C2)> where Match == (W, C0, C1, C2) {
     .init(self, transform: transform)
   }
 
-  public func tryCapture<NewCapture, C0, C1, C2>(
+  public func tryCapture<NewCapture, W, C0, C1, C2>(
     _ transform: @escaping (Substring) -> NewCapture?
-  ) -> CapturingGroup<Tuple5<Substring, NewCapture, C0, C1, C2>> where Match.Capture == Tuple3<C0, C1, C2> {
+  ) -> CapturingGroup<(Substring, NewCapture, C0, C1, C2)> where Match == (W, C0, C1, C2) {
     .init(self, transform: transform)
   }
 }
diff --git a/Sources/_StringProcessing/RegexDSL/DynamicCaptures.swift b/Sources/_StringProcessing/RegexDSL/DynamicCaptures.swift
index 18f0b31a1..dadd6339f 100644
--- a/Sources/_StringProcessing/RegexDSL/DynamicCaptures.swift
+++ b/Sources/_StringProcessing/RegexDSL/DynamicCaptures.swift
@@ -11,7 +11,7 @@
 
 import _MatchingEngine
 
-extension Regex where Match == Tuple2<Substring, DynamicCaptures> {
+extension Regex where Match == (Substring, DynamicCaptures) {
   public init(_ pattern: String) throws {
     self.init(ast: try parse(pattern, .traditional))
   }
diff --git a/Tests/RegexTests/AlgorithmsTests.swift b/Tests/RegexTests/AlgorithmsTests.swift
index 5a848a6e4..8041214b0 100644
--- a/Tests/RegexTests/AlgorithmsTests.swift
+++ b/Tests/RegexTests/AlgorithmsTests.swift
@@ -116,7 +116,7 @@ class RegexConsumerTests: XCTestCase {
   }
   
   func testMatches() {
-    let regex = Regex(OneOrMore(.digit).capture { 2 * Int($0)! })
+    let regex = Regex(oneOrMore(.digit).capture { 2 * Int($0)! })
     let str = "foo 160 bar 99 baz"
     XCTAssertEqual(str.matches(of: regex).map(\.result.1), [320, 198])
   }
@@ -133,7 +133,7 @@ class RegexConsumerTests: XCTestCase {
       XCTAssertEqual(input.replacing(regex, with: replace), result)
     }
     
-    let int = OneOrMore(.digit).capture { Int($0)! }
+    let int = oneOrMore(.digit).capture { Int($0)! }
     
     replaceTest(
       int,
@@ -148,13 +148,13 @@ class RegexConsumerTests: XCTestCase {
       { match in "\(match.result.1 + match.result.2)" })
     
     replaceTest(
-      OneOrMore { int; "," },
+      oneOrMore { int; "," },
       input: "3,5,8,0, 1,0,2,-5,x8,8,",
       result: "16 3-5x16",
       { match in "\(match.result.1.reduce(0, +))" })
     
     replaceTest(
-      Regex { int; "x"; int; Optionally { "x"; int } },
+      Regex { int; "x"; int; optionally { "x"; int } },
       input: "2x3 5x4x3 6x0 1x2x3x4",
       result: "6 60 0 6x4",
       { match in "\(match.result.1 * match.result.2 * (match.result.3 ?? 1))" })
diff --git a/Tests/RegexTests/RegexDSLTests.swift b/Tests/RegexTests/RegexDSLTests.swift
index 629e91240..1e803396d 100644
--- a/Tests/RegexTests/RegexDSLTests.swift
+++ b/Tests/RegexTests/RegexDSLTests.swift
@@ -20,15 +20,14 @@ class RegexDSLTests: XCTestCase {
       "1".tryCapture { Int($0) } // Int
     }
     // Assert the inferred capture type.
-    let _: Tuple3<Substring, Substring, Int>.Type = type(of: regex).Match.self
+    let _: (Substring, Substring, Int).Type = type(of: regex).Match.self
     let maybeMatch = "ab1".match(regex)
     let match = try XCTUnwrap(maybeMatch)
-    XCTAssertEqual(match.match, Tuple3("ab1", "b", 1))
+    XCTAssertTrue(match.match == ("ab1", "b", 1))
 
     let substring = "ab1"[...]
-    let substringMatch = try XCTUnwrap(
-      substring.match(regex))
-    XCTAssertEqual(match.match, substringMatch.match)
+    let substringMatch = try XCTUnwrap(substring.match(regex))
+    XCTAssertTrue(match.match == substringMatch.match)
   }
 
   func testCharacterClasses() throws {
@@ -38,43 +37,43 @@ class RegexDSLTests: XCTestCase {
       "c".capture() // Substring
     }
     // Assert the inferred capture type.
-    let _: Tuple3<Substring, Substring, Substring>.Type = type(of: regex).Match.self
+    let _: (Substring, Substring, Substring).Type = type(of: regex).Match.self
     let maybeMatch = "a c".match(regex)
     let match = try XCTUnwrap(maybeMatch)
-    XCTAssertTrue(match.match == Tuple3("a c", " ", "c"))
+    XCTAssertTrue(match.match == ("a c", " ", "c"))
   }
 
   func testCombinators() throws {
     let regex = Regex {
       "a".+
-      OneOrMore(Character("b")).capture() // Substring
-      Repeat("c").capture() // Substring
+      oneOrMore(Character("b")).capture() // Substring
+      many("c").capture() // Substring
       CharacterClass.hexDigit.capture().* // [Substring]
       "e".?
       ("t" | "k").capture() // Substring
     }
     // Assert the inferred capture type.
-    let _: Tuple5<Substring, Substring, Substring, [Substring], Substring>.Type
+    let _: (Substring, Substring, Substring, [Substring], Substring).Type
       = type(of: regex).Match.self
     let maybeMatch = "aaaabccccdddk".match(regex)
     let match = try XCTUnwrap(maybeMatch)
     XCTAssertTrue(
       match.match
-        == Tuple5("aaaabccccdddk", "b", "cccc", ["d", "d", "d"], "k"))
+        == ("aaaabccccdddk", "b", "cccc", ["d", "d", "d"], "k"))
   }
 
   func testNestedGroups() throws {
     let regex = Regex {
       "a".+
-      OneOrMore {
-        OneOrMore("b").capture()
-        Repeat("c").capture()
+      oneOrMore {
+        oneOrMore("b").capture()
+        many("c").capture()
         "d".capture().*
         "e".?
       }
     }
     // Assert the inferred capture type.
-    let _: Tuple2<Substring, [Tuple3<Substring, Substring, [Substring]>]>.Type
+    let _: (Substring, [(Substring, Substring, [Substring])]).Type
       = type(of: regex).Match.self
     let maybeMatch = "aaaabccccddd".match(regex)
     let match = try XCTUnwrap(maybeMatch)
@@ -82,7 +81,20 @@ class RegexDSLTests: XCTestCase {
     XCTAssertEqual(match.match.0, "aaaabccccddd")
     XCTAssertTrue(
       match.match.1[0]
-        == Tuple3("b", "cccc", ["d", "d", "d"]))
+        == ("b", "cccc", ["d", "d", "d"]))
+  }
+
+  func testCapturelessQuantification() throws {
+    // This test is to make sure that a captureless quantification, when used
+    // straight out of the quantifier (without being wrapped in a builder), is
+    // able to produce a regex whose `Match` type does not contain any sort of
+    // void.
+    let regex = many(.digit)
+    // Assert the inferred capture type.
+    let _: Substring.Type = type(of: regex).Match.self
+    let input = "123123"
+    let match = try XCTUnwrap(input.match(regex)?.match)
+    XCTAssertTrue(match == input)
   }
 
   func testQuantificationWithTransformedCapture() throws {
@@ -104,21 +116,20 @@ class RegexDSLTests: XCTestCase {
     }
     let regex = Regex {
       "a".+
-      OneOrMore(.whitespace)
-      Optionally {
-        OneOrMore(.digit).capture { Int($0)! }
+      oneOrMore(.whitespace)
+      optionally {
+        oneOrMore(.digit).capture { Int($0)! }
       }
-      Repeat {
-        OneOrMore(.whitespace)
-        OneOrMore(.word).capture { Word($0)! }
+      many {
+        oneOrMore(.whitespace)
+        oneOrMore(.word).capture { Word($0)! }
       }
     }
     // Assert the inferred capture type.
-    let _: Tuple3<Substring, Int?, [Word]>.Type
-      = type(of: regex).Match.self
+    let _: (Substring, Int?, [Word]).Type = type(of: regex).Match.self
     do {
       let input = "aaa 123 apple orange apple"
-      let match = input.match(regex)?.match.tuple
+      let match = input.match(regex)?.match
       let (whole, number, words) = try XCTUnwrap(match)
       XCTAssertTrue(whole == input)
       XCTAssertEqual(number, 123)
@@ -126,7 +137,7 @@ class RegexDSLTests: XCTestCase {
     }
     do {
       let input = "aaa   "
-      let match = input.match(regex)?.match.tuple
+      let match = input.match(regex)?.match
       let (whole, number, words) = try XCTUnwrap(match)
       XCTAssertTrue(whole == input)
       XCTAssertEqual(number, nil)
@@ -138,11 +149,11 @@ class RegexDSLTests: XCTestCase {
     let regex1 = Regex {
       "a".+
       Regex {
-        OneOrMore("b").capture()
+        oneOrMore("b").capture()
         "e".?
       }.capture()
     }
-    let _: Tuple3<Substring, Substring, Substring>.Type
+    let _: (Substring, Substring, Substring).Type
       = type(of: regex1).Match.self
     let regex2 = Regex {
       "a".+
@@ -151,7 +162,7 @@ class RegexDSLTests: XCTestCase {
         "e".?
       }.capture()
     }
-    let _: Tuple3<Substring, Substring, [Int]>.Type
+    let _: (Substring, Substring, [Int]).Type
       = type(of: regex2).Match.self
     let regex3 = Regex {
       "a".+
@@ -161,31 +172,31 @@ class RegexDSLTests: XCTestCase {
         "e".?
       }.capture()
     }
-    let _: Tuple4<Substring, Substring, Int, [Double]>.Type
+    let _: (Substring, Substring, Int, [Double]).Type
       = type(of: regex3).Match.self
     let regex4 = Regex {
       "a".+
-      OneOrMore {
-        OneOrMore("b").capture()
-        Repeat("c").capture()
+      oneOrMore {
+        oneOrMore("b").capture()
+        many("c").capture()
         "d".capture().*
         "e".?
       }.capture()
     }
-    let _: Tuple3<
-      Substring, Substring, [Tuple3<Substring, Substring, [Substring]>]>.Type
+    let _: (
+      Substring, Substring, [(Substring, Substring, [Substring])]).Type
       = type(of: regex4).Match.self
   }
 
   func testUnicodeScalarPostProcessing() throws {
     let spaces = Regex {
-      Repeat {
+      many {
         CharacterClass.whitespace
       }
     }
 
     let unicodeScalar = Regex {
-      OneOrMore {
+      oneOrMore {
         CharacterClass.hexDigit
       }
       spaces
@@ -193,7 +204,7 @@ class RegexDSLTests: XCTestCase {
 
     let unicodeData = Regex {
       unicodeScalar
-      Optionally {
+      optionally {
         ".."
         unicodeScalar
       }
@@ -201,17 +212,17 @@ class RegexDSLTests: XCTestCase {
       ";"
       spaces
 
-      OneOrMore {
+      oneOrMore {
         CharacterClass.word
       }.capture()
 
-      Repeat {
+      many {
         CharacterClass.any
       }
     }
 
     // Assert the inferred capture type.
-    let _: Tuple2<Substring, Substring>.Type = type(of: unicodeData).Match.self
+    let _: (Substring, Substring).Type = type(of: unicodeData).Match.self
 
     let unicodeLine =
       "1BCA0..1BCA3  ; Control # Cf   [4] SHORTHAND FORMAT LETTER OVERLAP..SHORTHAND FORMAT UP STEP"
@@ -226,26 +237,26 @@ class RegexDSLTests: XCTestCase {
       """
     
     let regexWithCapture = Regex {
-      OneOrMore(CharacterClass.hexDigit).capture(Unicode.Scalar.init(hex:))
-      Optionally {
+      oneOrMore(CharacterClass.hexDigit).capture(Unicode.Scalar.init(hex:))
+      optionally {
         ".."
-        OneOrMore(CharacterClass.hexDigit).capture(Unicode.Scalar.init(hex:))
+        oneOrMore(CharacterClass.hexDigit).capture(Unicode.Scalar.init(hex:))
       }
-      OneOrMore(CharacterClass.whitespace)
+      oneOrMore(CharacterClass.whitespace)
       ";"
-      OneOrMore(CharacterClass.whitespace)
-      OneOrMore(CharacterClass.word).capture()
-      Repeat(CharacterClass.any)
+      oneOrMore(CharacterClass.whitespace)
+      oneOrMore(CharacterClass.word).capture()
+      many(CharacterClass.any)
     } // Regex<(Substring, Unicode.Scalar?, Unicode.Scalar??, Substring)>
     do {
       // Assert the inferred capture type.
-      typealias ExpectedMatch = Tuple4<
+      typealias ExpectedMatch = (
         Substring, Unicode.Scalar?, Unicode.Scalar??, Substring
-      >
+      )
       let _: ExpectedMatch.Type = type(of: regexWithCapture).Match.self
       let maybeMatchResult = line.match(regexWithCapture)
       let matchResult = try XCTUnwrap(maybeMatchResult)
-      let (wholeMatch, lower, upper, propertyString) = matchResult.match.tuple
+      let (wholeMatch, lower, upper, propertyString) = matchResult.match
       XCTAssertEqual(wholeMatch, Substring(line))
       XCTAssertEqual(lower, Unicode.Scalar(0xA6F0))
       XCTAssertEqual(upper, Unicode.Scalar(0xA6F1))
@@ -253,26 +264,26 @@ class RegexDSLTests: XCTestCase {
     }
 
     let regexWithTryCapture = Regex {
-      OneOrMore(CharacterClass.hexDigit).tryCapture(Unicode.Scalar.init(hex:))
-      Optionally {
+      oneOrMore(CharacterClass.hexDigit).tryCapture(Unicode.Scalar.init(hex:))
+      optionally {
         ".."
-        OneOrMore(CharacterClass.hexDigit).tryCapture(Unicode.Scalar.init(hex:))
+        oneOrMore(CharacterClass.hexDigit).tryCapture(Unicode.Scalar.init(hex:))
       }
-      OneOrMore(CharacterClass.whitespace)
+      oneOrMore(CharacterClass.whitespace)
       ";"
-      OneOrMore(CharacterClass.whitespace)
-      OneOrMore(CharacterClass.word).capture()
-      Repeat(CharacterClass.any)
+      oneOrMore(CharacterClass.whitespace)
+      oneOrMore(CharacterClass.word).capture()
+      many(CharacterClass.any)
     } // Regex<(Substring, Unicode.Scalar, Unicode.Scalar?, Substring)>
     do {
       // Assert the inferred capture type.
-      typealias ExpectedMatch = Tuple4<
+      typealias ExpectedMatch = (
         Substring, Unicode.Scalar, Unicode.Scalar?, Substring
-      >
+      )
       let _: ExpectedMatch.Type = type(of: regexWithTryCapture).Match.self
       let maybeMatchResult = line.match(regexWithTryCapture)
       let matchResult = try XCTUnwrap(maybeMatchResult)
-      let (wholeMatch, lower, upper, propertyString) = matchResult.match.tuple
+      let (wholeMatch, lower, upper, propertyString) = matchResult.match
       XCTAssertEqual(wholeMatch, Substring(line))
       XCTAssertEqual(lower, Unicode.Scalar(0xA6F0))
       XCTAssertEqual(upper, Unicode.Scalar(0xA6F1))
@@ -282,10 +293,10 @@ class RegexDSLTests: XCTestCase {
     do {
       let regexLiteral = try MockRegexLiteral(
         #"([0-9A-F]+)(?:\.\.([0-9A-F]+))?\s+;\s+(\w+).*"#,
-        matching: Tuple4<Substring, Substring, Substring?, Substring>.self)
+        matching: (Substring, Substring, Substring?, Substring).self)
       let maybeMatchResult = line.match(regexLiteral)
       let matchResult = try XCTUnwrap(maybeMatchResult)
-      let (wholeMatch, lower, upper, propertyString) = matchResult.match.tuple
+      let (wholeMatch, lower, upper, propertyString) = matchResult.match
       XCTAssertEqual(wholeMatch, Substring(line))
       XCTAssertEqual(lower, "A6F0")
       XCTAssertEqual(upper, "A6F1")