Unify Match and AnyRegexOutput

Author: Azoy

Sources/_StringProcessing/Capture.swift

@@ -61,26 +61,30 @@ func constructExistentialOutputComponent(
   return underlying
 }
 
-extension StructuredCapture {
+@available(SwiftStdlib 5.7, *)
+extension AnyRegexOutput.Element {
   func existentialOutputComponent(
     from input: Substring
   ) -> Any {
     constructExistentialOutputComponent(
       from: input,
-      in: storedCapture?.range,
-      value: storedCapture?.value,
-      optionalCount: optionalCount)
+      in: range,
+      value: value,
+      optionalCount: optionalDepth
+    )
   }
 
   func slice(from input: String) -> Substring? {
-    guard let r = storedCapture?.range else { return nil }
+    guard let r = range else { return nil }
     return input[r]
   }
 }
 
-extension Sequence where Element == StructuredCapture {
+@available(SwiftStdlib 5.7, *)
+extension Sequence where Element == AnyRegexOutput.Element {
   // FIXME: This is a stop gap where we still slice the input
   // and traffic through existentials
+  @available(SwiftStdlib 5.7, *)
   func existentialOutput(
     from input: Substring
   ) -> Any {

Sources/_StringProcessing/Executor.swift

@@ -55,14 +55,19 @@ struct Executor {
     } else {
       value = nil
     }
-
-    return .init(
+    
+    let anyRegexOutput = AnyRegexOutput(
       input: input,
+      namedCaptureOffsets: capList.namedCaptureOffsets,
+      elements: caps
+    )
+    
+    return .init(
+      anyRegexOutput: anyRegexOutput,
       range: range,
-      rawCaptures: caps,
       referencedCaptureOffsets: capList.referencedCaptureOffsets,
-      namedCaptureOffsets: capList.namedCaptureOffsets,
-      value: value)
+      value: value
+    )
   }
 
   @available(SwiftStdlib 5.7, *)

Sources/_StringProcessing/Regex/AnyRegexOutput.swift

@@ -41,11 +41,11 @@ extension Regex.Match where Output == AnyRegexOutput {
   public subscript(
     dynamicMember keyPath: KeyPath<(Substring, _doNotUse: ()), Substring>
   ) -> Substring {
-    input[range]
+    anyRegexOutput.input[range]
   }
 
   public subscript(name: String) -> AnyRegexOutput.Element? {
-    namedCaptureOffsets[name].map { self[$0 + 1] }
+    anyRegexOutput.namedCaptureOffsets[name].map { self[$0 + 1] }
   }
 }
 
@@ -54,17 +54,19 @@ extension Regex.Match where Output == AnyRegexOutput {
 public struct AnyRegexOutput {
   let input: String
   let namedCaptureOffsets: [String: Int]
-  fileprivate let _elements: [ElementRepresentation]
+  let _elements: [ElementRepresentation]
 
   /// The underlying representation of the element of a type-erased regex
   /// output.
-  fileprivate struct ElementRepresentation {
+  internal struct ElementRepresentation {
     /// The depth of `Optioals`s wrapping the underlying value. For example,
     /// `Substring` has optional depth `0`, and `Int??` has optional depth `2`.
     let optionalDepth: Int
 
     /// The bounds of the output element.
     let bounds: Range<String.Index>?
+    /// If the output vaule is strongly typed, then this will be set.
+    var value: Any? = nil
   }
 }
 
@@ -75,14 +77,7 @@ extension AnyRegexOutput {
   /// Use this initializer to fit a regex with strongly typed captures into the
   /// use site of a dynamic regex, like one that was created from a string.
   public init<Output>(_ match: Regex<Output>.Match) {
-    // Note: We use type equality instead of `match.output as? ...` to prevent
-    // unexpected optional flattening.
-    if Output.self == AnyRegexOutput.self {
-      self = match.output as! AnyRegexOutput
-      return
-    }
-    fatalError("FIXME: Not implemented")
-    // self.init(input: match.input, _elements: <elements of output tuple>)
+    self = match.anyRegexOutput
   }
 
   /// Returns a typed output by converting the underlying value to the specified
@@ -92,11 +87,8 @@ extension AnyRegexOutput {
   /// - Returns: The output, if the underlying value can be converted to the
   ///   output type; otherwise `nil`.
   public func `as`<Output>(_ type: Output.Type = Output.self) -> Output? {
-    let elements = _elements.map {
-      StructuredCapture(
-        optionalCount: $0.optionalDepth,
-        storedCapture: .init(range: $0.bounds)
-      ).existentialOutputComponent(from: input[...])
+    let elements = map {
+      $0.existentialOutputComponent(from: input[...])
     }
     return TypeConstruction.tuple(of: elements) as? Output
   }
@@ -110,7 +102,8 @@ extension AnyRegexOutput {
     self.init(
       input: input,
       namedCaptureOffsets: namedCaptureOffsets,
-      _elements: elements.map(ElementRepresentation.init))
+      _elements: elements.map(ElementRepresentation.init)
+    )
   }
 }
 
@@ -119,7 +112,9 @@ extension AnyRegexOutput.ElementRepresentation {
   init(_ element: StructuredCapture) {
     self.init(
       optionalDepth: element.optionalCount,
-      bounds: element.storedCapture.flatMap(\.range))
+      bounds: element.storedCapture.flatMap(\.range),
+      value: element.storedCapture.flatMap(\.value)
+    )
   }
 
   func value(forInput input: String) -> Any {
@@ -142,6 +137,10 @@ extension AnyRegexOutput: RandomAccessCollection {
   public struct Element {
     fileprivate let representation: ElementRepresentation
     let input: String
+    
+    var optionalDepth: Int {
+      representation.optionalDepth
+    }
 
     /// The range over which a value was captured. `nil` for no-capture.
     public var range: Range<String.Index>? {
@@ -155,7 +154,7 @@ extension AnyRegexOutput: RandomAccessCollection {
 
     /// The captured value, `nil` for no-capture
     public var value: Any? {
-      fatalError()
+      representation.value
     }
   }
 
@@ -198,19 +197,12 @@ extension Regex.Match where Output == AnyRegexOutput {
   /// Use this initializer to fit a regex match with strongly typed captures into the
   /// use site of a dynamic regex match, like one that was created from a string.
   public init<Output>(_ match: Regex<Output>.Match) {
-    fatalError("FIXME: Not implemented")
-  }
-
-  /// Returns a typed match by converting the underlying values to the specified
-  /// types.
-  ///
-  /// - Parameter type: The expected output type.
-  /// - Returns: A match generic over the output type, if the underlying values
-  ///   can be converted to the output type; otherwise, `nil`.
-  public func `as`<Output>(
-    _ type: Output.Type = Output.self
-  ) -> Regex<Output>.Match? {
-    fatalError("FIXME: Not implemented")
+    self.init(
+      anyRegexOutput: match.anyRegexOutput,
+      range: match.range,
+      referencedCaptureOffsets: match.referencedCaptureOffsets,
+      value: match.value
+    )
   }
 }
 

Sources/_StringProcessing/Regex/Match.swift

@@ -17,17 +17,13 @@ extension Regex {
   /// providing direct access to captures.
   @dynamicMemberLookup
   public struct Match {
-    let input: String
+    let anyRegexOutput: AnyRegexOutput
 
     /// The range of the overall match.
     public let range: Range<String.Index>
 
-    let rawCaptures: [StructuredCapture]
-
     let referencedCaptureOffsets: [ReferenceID: Int]
 
-    let namedCaptureOffsets: [String: Int]
-
     let value: Any?
   }
 }
@@ -37,18 +33,23 @@ extension Regex.Match {
   /// The output produced from the match operation.
   public var output: Output {
     if Output.self == AnyRegexOutput.self {
-      let wholeMatchAsCapture = StructuredCapture(
-        optionalCount: 0,
-        storedCapture: StoredCapture(range: range, value: nil))
+      let wholeMatchCapture = AnyRegexOutput.ElementRepresentation(
+        optionalDepth: 0,
+        bounds: range,
+        value: nil
+      )
+      
       let output = AnyRegexOutput(
-        input: input,
-        namedCaptureOffsets: namedCaptureOffsets,
-        elements: [wholeMatchAsCapture] + rawCaptures)
+        input: anyRegexOutput.input,
+        namedCaptureOffsets: anyRegexOutput.namedCaptureOffsets,
+        _elements: [wholeMatchCapture] + anyRegexOutput._elements
+      )
+      
       return output as! Output
     } else if Output.self == Substring.self {
       // FIXME: Plumb whole match (`.0`) through the matching engine.
-      return input[range] as! Output
-    } else if rawCaptures.isEmpty, value != nil {
+      return anyRegexOutput.input[range] as! Output
+    } else if anyRegexOutput.isEmpty, value != nil {
       // FIXME: This is a workaround for whole-match values not
       // being modeled as part of captures. We might want to
       // switch to a model where results are alongside captures
@@ -57,7 +58,9 @@ extension Regex.Match {
       guard value == nil else {
         fatalError("FIXME: what would this mean?")
       }
-      let typeErasedMatch = rawCaptures.existentialOutput(from: input[range])
+      let typeErasedMatch = anyRegexOutput.existentialOutput(
+        from: anyRegexOutput.input[range]
+      )
       return typeErasedMatch as! Output
     }
   }
@@ -81,8 +84,9 @@ extension Regex.Match {
       preconditionFailure(
         "Reference did not capture any match in the regex")
     }
-    return rawCaptures[offset].existentialOutputComponent(from: input[...])
-      as! Capture
+    return anyRegexOutput[offset].existentialOutputComponent(
+      from: anyRegexOutput.input[...]
+    ) as! Capture
   }
 }
 

Tests/RegexTests/CaptureTests.swift

@@ -48,20 +48,20 @@ extension CaptureList {
   }
 }
 
-extension StructuredCapture {
+extension AnyRegexOutput.Element {
   func formatStringCapture(input: String) -> String {
-    var res = String(repeating: "some(", count: someCount)
-    if let r = self.storedCapture?.range {
+    var res = String(repeating: "some(", count: optionalDepth)
+    if let r = range {
       res += input[r]
     } else {
       res += "none"
     }
-    res += String(repeating: ")", count: someCount)
+    res += String(repeating: ")", count: optionalDepth)
     return res
   }
 }
 
-extension Sequence where Element == StructuredCapture {
+extension AnyRegexOutput {
   func formatStringCaptures(input: String) -> String {
     var res = "["
     res += self.map {
@@ -111,13 +111,13 @@ extension StringCapture: CustomStringConvertible {
 
 extension StringCapture {
   func isEqual(
-    to structCap: StructuredCapture,
+    to structCap: AnyRegexOutput.Element,
     in input: String
   ) -> Bool {
-    guard optionalCount == structCap.optionalCount else {
+    guard optionalCount == structCap.optionalDepth else {
       return false
     }
-    guard let r = structCap.storedCapture?.range else {
+    guard let r = structCap.range else {
       return contents == nil
     }
     guard let s = contents else {
@@ -194,7 +194,7 @@ func captureTest(
       return
     }
 
-    let caps = result.rawCaptures
+    let caps = result.anyRegexOutput
     guard caps.count == output.count else {
       XCTFail("""
       Mismatch capture count:
@@ -205,7 +205,7 @@ func captureTest(
       """)
       continue
     }
-
+    
     guard output.elementsEqual(caps, by: {
       $0.isEqual(to: $1, in: input)
     }) else {