Drop arrays and unzip tuples for quantified captures.

To bridge the typing gap between regex literals and regex builder, this patch introduces the following changes:

1. Repeating quantifiers no longer produce an array capture. Instead, produce an optional capture when the lower bound is `0`, otherwise an atom capture. After matching, this capture corresponds to the last occurrence in the match. A history-saving quantifier variant will be introduced at a later time.
2. Applying a quantifier on a tuple-capturing regex will map quantification onto every tuple element, resulting in a tuple of quantified captures (unzipped).

-----

```swift
let literal = /a((b)(b)+)*(c)+(d)?/
//           0 ^~~~~~~~~~~~~~~~
//            1 ^~~~~~
//             2 ^~~
//                3 ^~~
//                   4 ^~~
//                       5 ^~~
// => Regex<(Substring, Substring?, Substring?, Substring?, Substring, Substring?)>

// Equivalent regex using regex builder:
let dsl = Regex { // 0
  "a"
  zeroOrMore {
    capture { // 1
      capture { // 2
        "b"
      }
      oneOrMore {
        capture { // 3
          "b"
        }
      }
    }
  }
  oneOrMore {
    capture { // 4
      "c"
    }
  }
  optionally {
    capture { // 5
      "d"
    }
  }
}

// => Regex<(Substring, Substring?, Substring?, Substring?, Substring, Substring?)>
```

Author: rxwei

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