Change quantifiers in the DSL from structure types to top-level functions. This allows for a lot more flexibility with overloading a quantifier based on the input Match type. The immediate benefit of this is getting rid of void and nested void types (see example below), and as a result eliminate the need for void-filtering within concatenation. A more important benefit is being able to get rid of nominal tuples and switch back to Swift tuples, as Swift tuples enable strongly typed named captures and eliminates the complexity that comes with nominal tuples.

-----

Before:
```swift
let r0 = OneOrMore(.digit) // => `.Match == Tuple2<Substring, [()]>`
let r1 = Optionally(.digit) // => `.Match == Tuple2<Substring, ()?>`
let r2 = OneOrMore(Repeat(Optionally(.digit))) // => `.Match == Tuple2<Substring, [[()?]]>`
"123".match(r2) // => `RegexMatch<Tuple2<Substring, [[()?]]>>?`
```
After:
```swift
let r0 = oneOrMore(.digit) // => `.Match == Substring`
let r1 = optionally(.digit) // => `.Match == Substring`
let r2 = oneOrMore(many(optionally(.digit))) // => `.Match == Substring`
"123".match(r2) // => `RegexMatch<Substring>`
```

-----

Before:
```swift
/(?<number>\d+)/ // => `Regex<Tuple2<Substring, Substring>>`
```

After:
```swift
/(?<number>\d+)/ // => `Regex<(Substring, number: Substring)>`
```

Author: rxwei

Sources/Exercises/Participants/RegexParticipant.swift

@@ -80,16 +80,16 @@ 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
     return GraphemeBreakEntry(lower...(upper ?? lower), property)

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"
@@ -132,9 +132,10 @@ struct VariadicsGenerator: ParsableCommand {
       emitTupleStruct(arity: arity)
     }
 
+    print("Generating concatenation overloads...", to: &standardError)
     for (leftArity, rightArity) in Permutations(totalArity: maxArity) {
       print(
-        "Left arity: \(leftArity)  Right arity: \(rightArity)",
+        "  Left arity: \(leftArity)  Right arity: \(rightArity)",
         to: &standardError)
       emitConcatenation(leftArity: leftArity, rightArity: rightArity)
     }
@@ -144,7 +145,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)
   }
@@ -231,7 +245,7 @@ struct VariadicsGenerator: ParsableCommand {
       }
       output(", ")
       if withConstraints {
-        output("R0: \(patternProtocolName), R1: \(patternProtocolName)")
+        output("R0: \(regexProtocolName), R1: \(regexProtocolName)")
       } else {
         output("R0, R1")
       }
@@ -268,7 +282,7 @@ 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 {
@@ -343,7 +357,7 @@ struct VariadicsGenerator: ParsableCommand {
       ", C\($0)"
     }
     output("""
-      , R0: \(patternProtocolName), R1: \(patternProtocolName)>(
+      , R0: \(regexProtocolName), R1: \(regexProtocolName)>(
           combining next: R1, into combined: R0
         ) -> Regex<
       """)
@@ -374,4 +388,106 @@ struct VariadicsGenerator: ParsableCommand {
 
       """)
   }
+
+  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 : "Tuple\(arity)<\(captures)>"
+    let componentConstraint: String = arity == 0 ? "" :
+      "where Component.Match == Tuple\(arity+1)<W, \(captures)>"
+    let quantifiedCaptures: String = {
+      switch kind {
+      case .zeroOrOne:
+        return "\(capturesTupled)?"
+      case .zeroOrMore, .oneOrMore:
+        return "[\(capturesTupled)]"
+      }
+    }()
+    let matchType = arity == 0 ? baseMatchTypeName : "Tuple2<\(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)
+          }
+        }
+        """ : "")
+
+      """)
+  }
 }

Sources/_StringProcessing/RegexDSL/Builder.swift

@@ -33,10 +33,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)
-  }
 }