Use inits instead of as methods

Author: milseman

Sources/_StringProcessing/Capture.swift

@@ -49,7 +49,7 @@ extension AnyRegexOutput.Element {
       from: input,
       in: range,
       value: value,
-      optionalCount: optionalDepth
+      optionalCount: representation.optionalDepth
     )
   }
 

Sources/_StringProcessing/Regex/AnyRegexOutput.swift

@@ -44,6 +44,7 @@ extension Regex.Match where Output == AnyRegexOutput {
     anyRegexOutput.input[range]
   }
 
+  /// Access a capture by name. Returns `nil` if there's no capture with that name.
   public subscript(name: String) -> AnyRegexOutput.Element? {
     anyRegexOutput.first {
       $0.name == name
@@ -54,28 +55,8 @@ extension Regex.Match where Output == AnyRegexOutput {
 /// A type-erased regex output.
 @available(SwiftStdlib 5.7, *)
 public struct AnyRegexOutput {
-  let input: String
-  let _elements: [ElementRepresentation]
-
-  /// The underlying representation of the element of a type-erased regex
-  /// output.
-  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>?
-    
-    /// The name of the capture.
-    var name: String? = nil
-    
-    /// The capture reference this element refers to.
-    var referenceID: ReferenceID? = nil
-    
-    /// If the output vaule is strongly typed, then this will be set.
-    var value: Any? = nil
-  }
+  internal let input: String
+  internal let _elements: [ElementRepresentation]
 }
 
 @available(SwiftStdlib 5.7, *)
@@ -88,80 +69,57 @@ extension AnyRegexOutput {
     self = match.anyRegexOutput
   }
 
-  /// Returns a typed output by converting the underlying value to the specified
-  /// type.
+  /// Returns a typed output by converting dynamic values to the specified type.
   ///
   /// - Parameter type: The expected output type.
   /// - 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? {
+  public func extractValues<Output>(
+    as type: Output.Type = Output.self
+  ) -> Output? {
     let elements = map {
       $0.existentialOutputComponent(from: input[...])
     }
     return TypeConstruction.tuple(of: elements) as? Output
   }
 }
 
-@available(SwiftStdlib 5.7, *)
-extension AnyRegexOutput {
-  internal init(input: String, elements: [ElementRepresentation]) {
-    self.init(
-      input: input,
-      _elements: elements
-    )
-  }
-}
-
-@available(SwiftStdlib 5.7, *)
-extension AnyRegexOutput.ElementRepresentation {
-  func value(forInput input: String) -> Any {
-    // Ok for now because `existentialMatchComponent`
-    // wont slice the input if there's no range to slice with
-    //
-    // FIXME: This is ugly :-/
-    let input = bounds.map { input[$0] } ?? ""
-
-    return constructExistentialOutputComponent(
-      from: input,
-      in: bounds,
-      value: nil,
-      optionalCount: optionalDepth
-    )
-  }
-}
-
 @available(SwiftStdlib 5.7, *)
 extension AnyRegexOutput: RandomAccessCollection {
+  /// An individual output value.
   public struct Element {
-    fileprivate let representation: ElementRepresentation
-    let input: String
-    
-    var optionalDepth: Int {
-      representation.optionalDepth
-    }
-    
-    var name: String? {
-      representation.name
-    }
+    internal let representation: ElementRepresentation
+    internal let input: String
 
     /// The range over which a value was captured. `nil` for no-capture.
     public var range: Range<String.Index>? {
       representation.bounds
     }
-    
-    var referenceID: ReferenceID? {
-      representation.referenceID
-    }
-    
+
     /// The slice of the input over which a value was captured. `nil` for no-capture.
     public var substring: Substring? {
       range.map { input[$0] }
     }
 
     /// The captured value, `nil` for no-capture
+    /// TODO: clarify whether this is for non-default captured values, i.e. not the
+    /// default Substring but more like a Date or an explicit capture
     public var value: Any? {
       representation.value
     }
+
+    /// The name of this capture, if it has one, otherwise `nil`.
+    public var name: String? {
+      representation.name
+    }
+
+    // TODO: Consider making API, and figure out how
+    // DSL and this would work together...
+    /// Whether this capture is considered optional by the regex. I.e.,
+    /// whether it is inside an alternation or zero-or-n quantification.
+    var isOptional: Bool {
+      representation.optionalDepth != 0
+    }
   }
 
   public var startIndex: Int {
@@ -191,6 +149,8 @@ extension AnyRegexOutput: RandomAccessCollection {
 
 @available(SwiftStdlib 5.7, *)
 extension AnyRegexOutput {
+  /// Lookup a capture by name. Returns `nil` if no capture
+  /// with that name was present in the Regex.
   public subscript(name: String) -> Element? {
     first {
       $0.name == name
@@ -213,16 +173,6 @@ extension Regex.Match where Output == AnyRegexOutput {
   }
 }
 
-@available(SwiftStdlib 5.7, *)
-extension Regex {
-  /// Returns whether a named-capture with `name` exists
-  public func contains(captureNamed name: String) -> Bool {
-    program.tree.root._captureList.captures.contains(where: {
-      $0.name == name
-    })
-  }
-}
-
 @available(SwiftStdlib 5.7, *)
 extension Regex where Output == AnyRegexOutput {
   /// Creates a type-erased regex from an existing regex.
@@ -232,21 +182,70 @@ extension Regex where Output == AnyRegexOutput {
   public init<Output>(_ regex: Regex<Output>) {
     self.init(node: regex.root)
   }
+}
 
-  /// Returns a typed regex by converting the underlying types.
+@available(SwiftStdlib 5.7, *)
+extension Regex {
+  /// Creates a strongly-typed regex from a dynamic regex.
   ///
-  /// - Parameter type: The expected output type.
-  /// - Returns: A regex generic over the output type if the underlying types can be converted.
-  ///   Returns `nil` otherwise.
-  public func `as`<Output>(
-    _ type: Output.Type = Output.self
-  ) -> Regex<Output>? {
-    let result = Regex<Output>(node: root)
-    
-    guard result._verifyType() else {
+  /// Use this initializer to create a strongly typed regex from
+  /// one that was created from a string.
+  public init?(_ dynamic: Regex<AnyRegexOutput>) {
+    self.init(node: dynamic.root)
+    guard self._verifyType() else {
       return nil
     }
-    
-    return result
+  }
+
+  /// Returns whether a named-capture with `name` exists
+  public func contains(captureNamed name: String) -> Bool {
+    program.tree.root._captureList.captures.contains(where: {
+      $0.name == name
+    })
+  }
+}
+
+@available(SwiftStdlib 5.7, *)
+extension AnyRegexOutput {
+  /// The underlying representation of the element of a type-erased regex
+  /// output.
+  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>?
+
+    /// The name of the capture.
+    var name: String? = nil
+
+    /// The capture reference this element refers to.
+    var referenceID: ReferenceID? = nil
+
+    /// If the output vaule is strongly typed, then this will be set.
+    var value: Any? = nil
+  }
+
+  internal init(input: String, elements: [ElementRepresentation]) {
+    self.init(input: input, _elements: elements)
+  }
+}
+
+@available(SwiftStdlib 5.7, *)
+extension AnyRegexOutput.ElementRepresentation {
+  fileprivate func value(forInput input: String) -> Any {
+    // Ok for now because `existentialMatchComponent`
+    // wont slice the input if there's no range to slice with
+    //
+    // FIXME: This is ugly :-/
+    let input = bounds.map { input[$0] } ?? ""
+
+    return constructExistentialOutputComponent(
+      from: input,
+      in: bounds,
+      value: nil,
+      optionalCount: optionalDepth
+    )
   }
 }

Sources/_StringProcessing/Regex/Match.swift

@@ -38,7 +38,7 @@ extension Regex.Match {
 
       let output = AnyRegexOutput(
         input: anyRegexOutput.input,
-        _elements: [wholeMatchCapture] + anyRegexOutput._elements
+        elements: [wholeMatchCapture] + anyRegexOutput._elements
       )
 
       return output as! Output
@@ -77,7 +77,7 @@ extension Regex.Match {
   @_spi(RegexBuilder)
   public subscript<Capture>(_ id: ReferenceID) -> Capture {
     guard let element = anyRegexOutput.first(
-      where: { $0.referenceID == id }
+      where: { $0.representation.referenceID == id }
     ) else {
       preconditionFailure("Reference did not capture any match in the regex")
     }

Tests/RegexTests/AnyRegexOutputTests.swift

@@ -103,13 +103,13 @@ extension RegexTests {
 
     // TODO: ARO init from concrete match tuple
 
-    let concreteOutputCasted = output.as(
-      (Substring, fieldA: Substring, fieldB: Substring).self
+    let concreteOutputCasted = output.extractValues(
+      as: (Substring, fieldA: Substring, fieldB: Substring).self
     )!
     checkSame(output, concreteOutputCasted)
 
     var concreteOutputCopy = concreteOutput
-    concreteOutputCopy = output.as()!
+    concreteOutputCopy = output.extractValues()!
     checkSame(output, concreteOutputCopy)
 
     // TODO: Regex<ARO>.Match: init from tuple match and as to tuple match
@@ -146,12 +146,23 @@ extension RegexTests {
       XCTAssertTrue(output["upper"]?.substring == "A6F1")
       XCTAssertTrue(output[3].substring == "Extend")
       XCTAssertTrue(output["desc"]?.substring == "Extend")
-      let typedOutput = try XCTUnwrap(output.as(
-        (Substring, lower: Substring, upper: Substring?, Substring).self))
+      let typedOutput = try XCTUnwrap(
+        output.extractValues(
+          as: (Substring, lower: Substring, upper: Substring?, Substring).self))
       XCTAssertEqual(typedOutput.0, line[...])
       XCTAssertTrue(typedOutput.lower == "A6F0")
       XCTAssertTrue(typedOutput.upper == "A6F1")
       XCTAssertTrue(typedOutput.3 == "Extend")
+
+      // Extracting as different argument labels is allowed
+      let typedOutput2 = try XCTUnwrap(
+        output.extractValues(
+          as: (Substring, first: Substring, Substring?, third: Substring).self))
+      XCTAssertEqual(typedOutput2.0, line[...])
+      XCTAssertTrue(typedOutput2.first == "A6F0")
+      XCTAssertTrue(typedOutput2.2 == "A6F1")
+      XCTAssertTrue(typedOutput2.third == "Extend")
+
     }
   }
 }

Tests/RegexTests/CaptureTests.swift

@@ -58,13 +58,13 @@ extension CaptureList {
 
 extension AnyRegexOutput.Element {
   func formatStringCapture(input: String) -> String {
-    var res = String(repeating: "some(", count: optionalDepth)
+    var res = String(repeating: "some(", count: representation.optionalDepth)
     if let r = range {
       res += input[r]
     } else {
       res += "none"
     }
-    res += String(repeating: ")", count: optionalDepth)
+    res += String(repeating: ")", count: representation.optionalDepth)
     return res
   }
 }
@@ -122,7 +122,7 @@ extension StringCapture {
     to structCap: AnyRegexOutput.Element,
     in input: String
   ) -> Bool {
-    guard optionalCount == structCap.optionalDepth else {
+    guard optionalCount == structCap.representation.optionalDepth else {
       return false
     }
     guard let r = structCap.range else {
@@ -462,29 +462,29 @@ extension RegexTests {
 
   func testTypeVerification() throws {
     let opaque1 = try Regex("abc")
-    _ = try XCTUnwrap(opaque1.as(Substring.self))
-    XCTAssertNil(opaque1.as((Substring, Substring).self))
-    XCTAssertNil(opaque1.as(Int.self))
+    _ = try XCTUnwrap(Regex<Substring>(opaque1))
+    XCTAssertNil(Regex<(Substring, Substring)>(opaque1))
+    XCTAssertNil(Regex<Int>(opaque1))
 
     let opaque2 = try Regex("(abc)")
-    _ = try XCTUnwrap(opaque2.as((Substring, Substring).self))
-    XCTAssertNil(opaque2.as(Substring.self))
-    XCTAssertNil(opaque2.as((Substring, Int).self))
+    _ = try XCTUnwrap(Regex<(Substring, Substring)>(opaque2))
+    XCTAssertNil(Regex<Substring>(opaque2))
+    XCTAssertNil(Regex<(Substring, Int)>(opaque2))
 
     let opaque3 = try Regex("(?<someLabel>abc)")
-    _ = try XCTUnwrap(opaque3.as((Substring, someLabel: Substring).self))
-    XCTAssertNil(opaque3.as((Substring, Substring).self))
-    XCTAssertNil(opaque3.as(Substring.self))
+    _ = try XCTUnwrap(Regex<(Substring, someLabel: Substring)>(opaque3))
+    XCTAssertNil(Regex<(Substring, Substring)>(opaque3))
+    XCTAssertNil(Regex<Substring>(opaque3))
 
     let opaque4 = try Regex("(?<somethingHere>abc)?")
-    _ = try XCTUnwrap(opaque4.as((Substring, somethingHere: Substring?).self))
-    XCTAssertNil(opaque4.as((Substring, somethignHere: Substring).self))
-    XCTAssertNil(opaque4.as((Substring, Substring?).self))
+    _ = try XCTUnwrap(Regex<(Substring, somethingHere: Substring?)>(opaque4))
+    XCTAssertNil(Regex<(Substring, somethignHere: Substring)>(opaque4))
+    XCTAssertNil(Regex<(Substring, Substring?)>(opaque4))
 
     let opaque5 = try Regex("((a)?bc)?")
-    _ = try XCTUnwrap(opaque5.as((Substring, Substring?, Substring??).self))
-    XCTAssertNil(opaque5.as((Substring, somethingHere: Substring?, here: Substring??).self))
-    XCTAssertNil(opaque5.as((Substring, Substring?, Substring?).self))
+    _ = try XCTUnwrap(Regex<(Substring, Substring?, Substring??)>(opaque5))
+    XCTAssertNil(Regex<(Substring, somethingHere: Substring?, here: Substring??)>(opaque5))
+    XCTAssertNil(Regex<(Substring, Substring?, Substring?)>(opaque5))
   }
 }