Drop arrays and unzip tuples for quantified captures.

Sources/VariadicsGenerator/VariadicsGenerator.swift

@@ -294,8 +294,8 @@ struct VariadicsGenerator: ParsableCommand {
     var operatorName: String {
       switch self {
       case .zeroOrOne: return ".?"
-      case .zeroOrMore: return ".+"
-      case .oneOrMore: return ".*"
+      case .zeroOrMore: return ".*"
+      case .oneOrMore: return ".+"
       }
     }
 
@@ -320,16 +320,16 @@ struct VariadicsGenerator: ParsableCommand {
       result += "Component: \(regexProtocolName)"
       return result
     }()
-    let captures = (0..<arity).map { "C\($0)" }.joined(separator: ", ")
-    let capturesTupled = arity == 1 ? captures : "(\(captures))"
+    let captures = (0..<arity).map { "C\($0)" }
+    let capturesJoined = captures.joined(separator: ", ")
     let whereClause: String = arity == 0 ? "" :
-      "where Component.Match == (W, \(captures))"
+      "where Component.Match == (W, \(capturesJoined))"
     let quantifiedCaptures: String = {
       switch kind {
-      case .zeroOrOne:
-        return "\(capturesTupled)?"
-      case .zeroOrMore, .oneOrMore:
-        return "[\(capturesTupled)]"
+      case .zeroOrOne, .zeroOrMore:
+        return captures.map { "\($0)?" }.joined(separator: ", ")
+      case .oneOrMore:
+        return capturesJoined
       }
     }()
     let matchType = arity == 0 ? baseMatchTypeName : "(\(baseMatchTypeName), \(quantifiedCaptures))"

Sources/_MatchingEngine/Regex/Parse/CaptureStructure.swift

@@ -46,7 +46,6 @@ extension CaptureStructure.Constructor {
   public mutating func alternating<C: Collection>(
     _ children: C
   ) -> CaptureStructure where C.Element: _TreeNode {
-//    assert(children.count > 1)
     return children.map {
       $0._captureStructure(&self)
     }.reduce(.empty, +)
@@ -113,17 +112,15 @@ extension CaptureStructure.Constructor {
     }
     let branchCaptures = trueBranch._captureStructure(&self) +
                          falseBranch._captureStructure(&self)
-    return captures + branchCaptures.map(
-      CaptureStructure.optional)
+    return captures + branchCaptures.map(CaptureStructure.optional)
   }
 
   public mutating func quantifying<T: _TreeNode>(
     _ child: T, amount: AST.Quantification.Amount
   ) -> CaptureStructure {
-    return child._captureStructure(&self).map(
-      amount == .zeroOrOne
-        ? CaptureStructure.optional
-        : CaptureStructure.array)
+    let result = child._captureStructure(&self)
+    return amount.bounds.atLeast == 0
+      ? result.map(CaptureStructure.optional) : result
   }
 
   // TODO: Will need to adjust for DSLTree support, and