Rename RegexComponent.Output (#281)

natecook1000 · web-flow · commit da89bf766c6c · 2022-04-14T18:16:41.000-05:00
diff --git a/Sources/Exercises/Participants/RegexParticipant.swift b/Sources/Exercises/Participants/RegexParticipant.swift
@@ -62,7 +62,7 @@ private func extractFromCaptures(
 private func graphemeBreakPropertyData<RP: RegexComponent>(
   forLine line: String,
   using regex: RP
-) -> GraphemeBreakEntry? where RP.Output == (Substring, Substring, Substring?, Substring) {
+) -> GraphemeBreakEntry? where RP.RegexOutput == (Substring, Substring, Substring?, Substring) {
   line.wholeMatch(of: regex).map(\.output).flatMap(extractFromCaptures)
 }
 
diff --git a/Sources/RegexBuilder/Anchor.swift b/Sources/RegexBuilder/Anchor.swift
@@ -119,15 +119,15 @@ public struct Lookahead<Output>: _BuiltinRegexComponent {
   public init<R: RegexComponent>(
     _ component: R,
     negative: Bool = false
-  ) where R.Output == Output {
+  ) where R.RegexOutput == Output {
     self.init(node: .nonCapturingGroup(
       negative ? .negativeLookahead : .lookahead, component.regex.root))
   }
 
   public init<R: RegexComponent>(
     negative: Bool = false,
     @RegexComponentBuilder _ component: () -> R
-  ) where R.Output == Output {
+  ) where R.RegexOutput == Output {
     self.init(node: .nonCapturingGroup(
       negative ? .negativeLookahead : .lookahead, component().regex.root))
   }
diff --git a/Sources/RegexBuilder/DSL.swift b/Sources/RegexBuilder/DSL.swift
@@ -15,15 +15,15 @@ import _RegexParser
 extension Regex {
   public init<Content: RegexComponent>(
     @RegexComponentBuilder _ content: () -> Content
-  ) where Content.Output == Output {
+  ) where Content.RegexOutput == Output {
     self = content().regex
   }
 }
 
 // A convenience protocol for builtin regex components that are initialized with
 // a `DSLTree` node.
 internal protocol _BuiltinRegexComponent: RegexComponent {
-  init(_ regex: Regex<Output>)
+  init(_ regex: Regex<RegexOutput>)
 }
 
 extension _BuiltinRegexComponent {
@@ -224,7 +224,7 @@ public struct AlternationBuilder {
   @_disfavoredOverload
   public static func buildPartialBlock<R: RegexComponent>(
     first component: R
-  ) -> ChoiceOf<R.Output> {
+  ) -> ChoiceOf<R.RegexOutput> {
     .init(component.regex)
   }
 
diff --git a/Sources/RegexBuilder/Match.swift b/Sources/RegexBuilder/Match.swift
@@ -15,14 +15,14 @@ extension String {
   @available(SwiftStdlib 5.7, *)
   public func wholeMatch<R: RegexComponent>(
     @RegexComponentBuilder of content: () -> R
-  ) -> Regex<R.Output>.Match? {
+  ) -> Regex<R.RegexOutput>.Match? {
     wholeMatch(of: content())
   }
 
   @available(SwiftStdlib 5.7, *)
   public func prefixMatch<R: RegexComponent>(
     @RegexComponentBuilder of content: () -> R
-  ) -> Regex<R.Output>.Match? {
+  ) -> Regex<R.RegexOutput>.Match? {
     prefixMatch(of: content())
   }
 }
@@ -31,14 +31,14 @@ extension Substring {
   @available(SwiftStdlib 5.7, *)
   public func wholeMatch<R: RegexComponent>(
     @RegexComponentBuilder of content: () -> R
-  ) -> Regex<R.Output>.Match? {
+  ) -> Regex<R.RegexOutput>.Match? {
     wholeMatch(of: content())
   }
 
   @available(SwiftStdlib 5.7, *)
   public func prefixMatch<R: RegexComponent>(
     @RegexComponentBuilder of content: () -> R
-  ) -> Regex<R.Output>.Match? {
+  ) -> Regex<R.RegexOutput>.Match? {
     prefixMatch(of: content())
   }
 }
diff --git a/Sources/RegexBuilder/Variadics.swift b/Sources/RegexBuilder/Variadics.swift
diff --git a/Sources/VariadicsGenerator/VariadicsGenerator.swift b/Sources/VariadicsGenerator/VariadicsGenerator.swift
@@ -90,7 +90,7 @@ var standardError = StandardErrorStream()
 
 typealias Counter = Int64
 let regexComponentProtocolName = "RegexComponent"
-let outputAssociatedTypeName = "Output"
+let outputAssociatedTypeName = "RegexOutput"
 let patternProtocolRequirementName = "regex"
 let regexTypeName = "Regex"
 let baseMatchTypeName = "Substring"
diff --git a/Sources/_StringProcessing/Algorithms/Consumers/RegexConsumer.swift b/Sources/_StringProcessing/Algorithms/Consumers/RegexConsumer.swift
@@ -37,7 +37,7 @@ extension RegexConsumer {
 // well, taking advantage of the fact that the captures can be ignored
 
 extension RegexConsumer: MatchingCollectionConsumer {
-  typealias Match = R.Output
+  typealias Match = R.RegexOutput
   
   func matchingConsuming(
     _ consumed: Consumed, in range: Range<Consumed.Index>
diff --git a/Sources/_StringProcessing/Algorithms/Matching/FirstMatch.swift b/Sources/_StringProcessing/Algorithms/Matching/FirstMatch.swift
@@ -56,7 +56,7 @@ extension BidirectionalCollection where SubSequence == Substring {
   /// there isn't a match.
   public func firstMatch<R: RegexComponent>(
     of r: R
-  ) -> Regex<R.Output>.Match? {
+  ) -> Regex<R.RegexOutput>.Match? {
     let slice = self[...]
     return try? r.regex.firstMatch(in: slice.base)
   }
diff --git a/Sources/_StringProcessing/Algorithms/Matching/MatchReplace.swift b/Sources/_StringProcessing/Algorithms/Matching/MatchReplace.swift
@@ -125,7 +125,7 @@ extension RangeReplaceableCollection where SubSequence == Substring {
   @available(SwiftStdlib 5.7, *)
   public func replacing<R: RegexComponent, Replacement: Collection>(
     _ regex: R,
-    with replacement: (Regex<R.Output>.Match) throws -> Replacement,
+    with replacement: (Regex<R.RegexOutput>.Match) throws -> Replacement,
     subrange: Range<Index>,
     maxReplacements: Int = .max
   ) rethrows -> Self where Replacement.Element == Element {
@@ -161,7 +161,7 @@ extension RangeReplaceableCollection where SubSequence == Substring {
   @available(SwiftStdlib 5.7, *)
   public func replacing<R: RegexComponent, Replacement: Collection>(
     _ regex: R,
-    with replacement: (Regex<R.Output>.Match) throws -> Replacement,
+    with replacement: (Regex<R.RegexOutput>.Match) throws -> Replacement,
     maxReplacements: Int = .max
   ) rethrows -> Self where Replacement.Element == Element {
     try replacing(
@@ -182,7 +182,7 @@ extension RangeReplaceableCollection where SubSequence == Substring {
   @available(SwiftStdlib 5.7, *)
   public mutating func replace<R: RegexComponent, Replacement: Collection>(
     _ regex: R,
-    with replacement: (Regex<R.Output>.Match) throws -> Replacement,
+    with replacement: (Regex<R.RegexOutput>.Match) throws -> Replacement,
     maxReplacements: Int = .max
   ) rethrows where Replacement.Element == Element {
     self = try replacing(
diff --git a/Sources/_StringProcessing/Algorithms/Matching/Matches.swift b/Sources/_StringProcessing/Algorithms/Matching/Matches.swift
@@ -202,13 +202,13 @@ extension BidirectionalCollection where SubSequence == Substring {
 
   // FIXME: Replace the returned value as `some Collection<Regex<R.Output>.Match>
   // when SE-0346 is enabled
-  func _matches<R: RegexComponent>(of r: R) -> [Regex<R.Output>.Match] {
+  func _matches<R: RegexComponent>(of r: R) -> [Regex<R.RegexOutput>.Match] {
     let slice = self[...]
     var start = self.startIndex
     let end = self.endIndex
     let regex = r.regex
 
-    var result = [Regex<R.Output>.Match]()
+    var result = [Regex<R.RegexOutput>.Match]()
     while start < end {
       guard let match = try? regex._firstMatch(
         slice.base, in: start..<end
diff --git a/Sources/_StringProcessing/Regex/Core.swift b/Sources/_StringProcessing/Regex/Core.swift
@@ -15,8 +15,8 @@ import _RegexParser
 /// A type that represents a regular expression.
 @available(SwiftStdlib 5.7, *)
 public protocol RegexComponent {
-  associatedtype Output
-  var regex: Regex<Output> { get }
+  associatedtype RegexOutput
+  var regex: Regex<RegexOutput> { get }
 }
 
 /// A regex represents a string processing algorithm.
diff --git a/Sources/_StringProcessing/Regex/DSLConsumers.swift b/Sources/_StringProcessing/Regex/DSLConsumers.swift
@@ -15,12 +15,12 @@ public protocol CustomRegexComponent: RegexComponent {
     _ input: String,
     startingAt index: String.Index,
     in bounds: Range<String.Index>
-  ) -> (upperBound: String.Index, output: Output)?
+  ) -> (upperBound: String.Index, output: RegexOutput)?
 }
 
 extension CustomRegexComponent {
-  public var regex: Regex<Output> {
-    Regex(node: .matcher(.init(Output.self), { input, index, bounds in
+  public var regex: Regex<RegexOutput> {
+    Regex(node: .matcher(.init(RegexOutput.self), { input, index, bounds in
       match(input, startingAt: index, in: bounds)
     }))
   }
diff --git a/Sources/_StringProcessing/Regex/Match.swift b/Sources/_StringProcessing/Regex/Match.swift
@@ -155,24 +155,24 @@ extension Regex {
 extension String {
   public func wholeMatch<R: RegexComponent>(
     of r: R
-  ) -> Regex<R.Output>.Match? {
+  ) -> Regex<R.RegexOutput>.Match? {
     try? r.regex.wholeMatch(in: self)
   }
   public func prefixMatch<R: RegexComponent>(
     of r: R
-  ) -> Regex<R.Output>.Match? {
+  ) -> Regex<R.RegexOutput>.Match? {
     try? r.regex.prefixMatch(in: self)
   }
 }
 extension Substring {
   public func wholeMatch<R: RegexComponent>(
     of r: R
-  ) -> Regex<R.Output>.Match? {
+  ) -> Regex<R.RegexOutput>.Match? {
     try? r.regex.wholeMatch(in: self)
   }
   public func prefixMatch<R: RegexComponent>(
     of r: R
-  ) -> Regex<R.Output>.Match? {
+  ) -> Regex<R.RegexOutput>.Match? {
     try? r.regex.prefixMatch(in: self)
   }
 }
diff --git a/Sources/_StringProcessing/Regex/Options.swift b/Sources/_StringProcessing/Regex/Options.swift
@@ -13,30 +13,30 @@ import _RegexParser
 
 extension RegexComponent {
   /// Returns a regular expression that ignores casing when matching.
-  public func ignoringCase(_ ignoreCase: Bool = true) -> Regex<Output> {
+  public func ignoringCase(_ ignoreCase: Bool = true) -> Regex<RegexOutput> {
     wrapInOption(.caseInsensitive, addingIf: ignoreCase)
   }
 
   /// Returns a regular expression that only matches ASCII characters as "word
   /// characters".
-  public func usingASCIIWordCharacters(_ useASCII: Bool = true) -> Regex<Output> {
+  public func usingASCIIWordCharacters(_ useASCII: Bool = true) -> Regex<RegexOutput> {
     wrapInOption(.asciiOnlyDigit, addingIf: useASCII)
   }
 
   /// Returns a regular expression that only matches ASCII characters as digits.
-  public func usingASCIIDigits(_ useASCII: Bool = true) -> Regex<Output> {
+  public func usingASCIIDigits(_ useASCII: Bool = true) -> Regex<RegexOutput> {
     wrapInOption(.asciiOnlyDigit, addingIf: useASCII)
   }
 
   /// Returns a regular expression that only matches ASCII characters as space
   /// characters.
-  public func usingASCIISpaces(_ useASCII: Bool = true) -> Regex<Output> {
+  public func usingASCIISpaces(_ useASCII: Bool = true) -> Regex<RegexOutput> {
     wrapInOption(.asciiOnlySpace, addingIf: useASCII)
   }
 
   /// Returns a regular expression that only matches ASCII characters when
   /// matching character classes.
-  public func usingASCIICharacterClasses(_ useASCII: Bool = true) -> Regex<Output> {
+  public func usingASCIICharacterClasses(_ useASCII: Bool = true) -> Regex<RegexOutput> {
     wrapInOption(.asciiOnlyPOSIXProps, addingIf: useASCII)
   }
   
@@ -45,7 +45,7 @@ extension RegexComponent {
   ///
   /// This option is enabled by default; pass `false` to disable use of
   /// Unicode's word boundary algorithm.
-  public func usingUnicodeWordBoundaries(_ useUnicodeWordBoundaries: Bool = true) -> Regex<Output> {
+  public func usingUnicodeWordBoundaries(_ useUnicodeWordBoundaries: Bool = true) -> Regex<RegexOutput> {
     wrapInOption(.unicodeWordBoundaries, addingIf: useUnicodeWordBoundaries)
   }
   
@@ -54,7 +54,7 @@ extension RegexComponent {
   ///
   /// - Parameter dotMatchesNewlines: A Boolean value indicating whether `.`
   ///   should match a newline character.
-  public func dotMatchesNewlines(_ dotMatchesNewlines: Bool = true) -> Regex<Output> {
+  public func dotMatchesNewlines(_ dotMatchesNewlines: Bool = true) -> Regex<RegexOutput> {
     wrapInOption(.singleLine, addingIf: dotMatchesNewlines)
   }
   
@@ -95,7 +95,7 @@ extension RegexComponent {
   ///     // Prints "true"
   ///     print(decomposed.contains(queRegexScalar))
   ///     // Prints "false"
-  public func matchingSemantics(_ semanticLevel: RegexSemanticLevel) -> Regex<Output> {
+  public func matchingSemantics(_ semanticLevel: RegexSemanticLevel) -> Regex<RegexOutput> {
     switch semanticLevel.base {
     case .graphemeCluster:
       return wrapInOption(.graphemeClusterSemantics, addingIf: true)
@@ -139,7 +139,7 @@ extension RegexComponent {
   ///
   /// - Parameter matchLineEndings: A Boolean value indicating whether `^` and
   ///   `$` should match the start and end of lines, respectively.
-  public func anchorsMatchLineEndings(_ matchLineEndings: Bool = true) -> Regex<Output> {
+  public func anchorsMatchLineEndings(_ matchLineEndings: Bool = true) -> Regex<RegexOutput> {
     wrapInOption(.multiline, addingIf: matchLineEndings)
   }
   
@@ -153,7 +153,7 @@ extension RegexComponent {
   ///
   /// - Parameter useReluctantCaptures: A Boolean value indicating whether
   ///   quantifiers should be reluctant by default.
-  public func reluctantCaptures(_ useReluctantCaptures: Bool = true) -> Regex<Output> {
+  public func reluctantCaptures(_ useReluctantCaptures: Bool = true) -> Regex<RegexOutput> {
     wrapInOption(.reluctantByDefault, addingIf: useReluctantCaptures)
   }
 }
@@ -162,7 +162,7 @@ extension RegexComponent {
 extension RegexComponent {
   fileprivate func wrapInOption(
     _ option: AST.MatchingOption.Kind,
-    addingIf shouldAdd: Bool) -> Regex<Output>
+    addingIf shouldAdd: Bool) -> Regex<RegexOutput>
   {
     let sequence = shouldAdd
       ? AST.MatchingOptionSequence(adding: [.init(option, location: .fake)])
diff --git a/Sources/_StringProcessing/_CharacterClassModel.swift b/Sources/_StringProcessing/_CharacterClassModel.swift
@@ -206,9 +206,9 @@ public struct _CharacterClassModel: Hashable {
 }
 
 extension _CharacterClassModel: RegexComponent {
-  public typealias Output = Substring
+  public typealias RegexOutput = Substring
 
-  public var regex: Regex<Output> {
+  public var regex: Regex<RegexOutput> {
     guard let ast = self.makeAST() else {
       fatalError("FIXME: extended AST?")
     }
diff --git a/Tests/RegexBuilderTests/AlgorithmsTests.swift b/Tests/RegexBuilderTests/AlgorithmsTests.swift
@@ -28,7 +28,7 @@ class RegexConsumerTests: XCTestCase {
       _ regex: R,
       input: String,
       result: String,
-      _ replace: (Regex<R.Output>.Match) -> String,
+      _ replace: (Regex<R.RegexOutput>.Match) -> String,
       file: StaticString = #file,
       line: UInt = #line
     ) {
diff --git a/Tests/RegexBuilderTests/CustomTests.swift b/Tests/RegexBuilderTests/CustomTests.swift
@@ -15,7 +15,7 @@ import _StringProcessing
 
 // A nibbler processes a single character from a string
 private protocol Nibbler: CustomRegexComponent {
-  func nibble(_: Character) -> Output?
+  func nibble(_: Character) -> RegexOutput?
 }
 
 extension Nibbler {
@@ -24,7 +24,7 @@ extension Nibbler {
     _ input: String,
     startingAt index: String.Index,
     in bounds: Range<String.Index>
-  ) -> (upperBound: String.Index, output: Output)? {
+  ) -> (upperBound: String.Index, output: RegexOutput)? {
     guard index != bounds.upperBound, let res = nibble(input[index]) else {
       return nil
     }
@@ -35,15 +35,15 @@ extension Nibbler {
 
 // A number nibbler
 private struct Numbler: Nibbler {
-  typealias Output = Int
+  typealias RegexOutput = Int
   func nibble(_ c: Character) -> Int? {
     c.wholeNumberValue
   }
 }
 
 // An ASCII value nibbler
 private struct Asciibbler: Nibbler {
-  typealias Output = UInt8
+  typealias RegexOutput = UInt8
   func nibble(_ c: Character) -> UInt8? {
     c.asciiValue
   }
diff --git a/Tests/RegexBuilderTests/RegexDSLTests.swift b/Tests/RegexBuilderTests/RegexDSLTests.swift

Original file line number	Diff line number	Diff line change
`@@ -62,7 +62,7 @@ private func extractFromCaptures(`
`62`	`62`	`private func graphemeBreakPropertyData<RP: RegexComponent>(`
`63`	`63`	`forLine line: String,`
`64`	`64`	`using regex: RP`
`65`		`-) -> GraphemeBreakEntry? where RP.Output == (Substring, Substring, Substring?, Substring) {`
	`65`	`+) -> GraphemeBreakEntry? where RP.RegexOutput == (Substring, Substring, Substring?, Substring) {`
`66`	`66`	`line.wholeMatch(of: regex).map(\.output).flatMap(extractFromCaptures)`
`67`	`67`	`}`
`68`	`68`
Original file line number	Diff line number	Diff line change
`@@ -15,15 +15,15 @@ import _RegexParser`
`15`	`15`	`extension Regex {`
`16`	`16`	`public init<Content: RegexComponent>(`
`17`	`17`	`@RegexComponentBuilder _ content: () -> Content`
`18`		`- ) where Content.Output == Output {`
	`18`	`+ ) where Content.RegexOutput == Output {`
`19`	`19`	`self = content().regex`
`20`	`20`	`}`
`21`	`21`	`}`
`22`	`22`
`23`	`23`	`// A convenience protocol for builtin regex components that are initialized with`
`24`	`24`	// a `DSLTree` node.
`25`	`25`	`internal protocol _BuiltinRegexComponent: RegexComponent {`
`26`		`- init(_ regex: Regex<Output>)`
	`26`	`+ init(_ regex: Regex<RegexOutput>)`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	`extension _BuiltinRegexComponent {`
`@@ -224,7 +224,7 @@ public struct AlternationBuilder {`
`224`	`224`	`@_disfavoredOverload`
`225`	`225`	`public static func buildPartialBlock<R: RegexComponent>(`
`226`	`226`	`first component: R`
`227`		`- ) -> ChoiceOf<R.Output> {`
	`227`	`+ ) -> ChoiceOf<R.RegexOutput> {`
`228`	`228`	`.init(component.regex)`
`229`	`229`	`}`
`230`	`230`
Original file line number	Diff line number	Diff line change
`@@ -15,14 +15,14 @@ extension String {`
`15`	`15`	`@available(SwiftStdlib 5.7, *)`
`16`	`16`	`public func wholeMatch<R: RegexComponent>(`
`17`	`17`	`@RegexComponentBuilder of content: () -> R`
`18`		`- ) -> Regex<R.Output>.Match? {`
	`18`	`+ ) -> Regex<R.RegexOutput>.Match? {`
`19`	`19`	`wholeMatch(of: content())`
`20`	`20`	`}`
`21`	`21`
`22`	`22`	`@available(SwiftStdlib 5.7, *)`
`23`	`23`	`public func prefixMatch<R: RegexComponent>(`
`24`	`24`	`@RegexComponentBuilder of content: () -> R`
`25`		`- ) -> Regex<R.Output>.Match? {`
	`25`	`+ ) -> Regex<R.RegexOutput>.Match? {`
`26`	`26`	`prefixMatch(of: content())`
`27`	`27`	`}`
`28`	`28`	`}`
`@@ -31,14 +31,14 @@ extension Substring {`
`31`	`31`	`@available(SwiftStdlib 5.7, *)`
`32`	`32`	`public func wholeMatch<R: RegexComponent>(`
`33`	`33`	`@RegexComponentBuilder of content: () -> R`
`34`		`- ) -> Regex<R.Output>.Match? {`
	`34`	`+ ) -> Regex<R.RegexOutput>.Match? {`
`35`	`35`	`wholeMatch(of: content())`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`@available(SwiftStdlib 5.7, *)`
`39`	`39`	`public func prefixMatch<R: RegexComponent>(`
`40`	`40`	`@RegexComponentBuilder of content: () -> R`
`41`		`- ) -> Regex<R.Output>.Match? {`
	`41`	`+ ) -> Regex<R.RegexOutput>.Match? {`
`42`	`42`	`prefixMatch(of: content())`
`43`	`43`	`}`
`44`	`44`	`}`
Original file line number	Diff line number	Diff line change
`@@ -56,7 +56,7 @@ extension BidirectionalCollection where SubSequence == Substring {`
`56`	`56`	`/// there isn't a match.`
`57`	`57`	`public func firstMatch<R: RegexComponent>(`
`58`	`58`	`of r: R`
`59`		`- ) -> Regex<R.Output>.Match? {`
	`59`	`+ ) -> Regex<R.RegexOutput>.Match? {`
`60`	`60`	`let slice = self[...]`
`61`	`61`	`return try? r.regex.firstMatch(in: slice.base)`
`62`	`62`	`}`
Original file line number	Diff line number	Diff line change
`@@ -155,24 +155,24 @@ extension Regex {`
`155`	`155`	`extension String {`
`156`	`156`	`public func wholeMatch<R: RegexComponent>(`
`157`	`157`	`of r: R`
`158`		`- ) -> Regex<R.Output>.Match? {`
	`158`	`+ ) -> Regex<R.RegexOutput>.Match? {`
`159`	`159`	`try? r.regex.wholeMatch(in: self)`
`160`	`160`	`}`
`161`	`161`	`public func prefixMatch<R: RegexComponent>(`
`162`	`162`	`of r: R`
`163`		`- ) -> Regex<R.Output>.Match? {`
	`163`	`+ ) -> Regex<R.RegexOutput>.Match? {`
`164`	`164`	`try? r.regex.prefixMatch(in: self)`
`165`	`165`	`}`
`166`	`166`	`}`
`167`	`167`	`extension Substring {`
`168`	`168`	`public func wholeMatch<R: RegexComponent>(`
`169`	`169`	`of r: R`
`170`		`- ) -> Regex<R.Output>.Match? {`
	`170`	`+ ) -> Regex<R.RegexOutput>.Match? {`
`171`	`171`	`try? r.regex.wholeMatch(in: self)`
`172`	`172`	`}`
`173`	`173`	`public func prefixMatch<R: RegexComponent>(`
`174`	`174`	`of r: R`
`175`		`- ) -> Regex<R.Output>.Match? {`
	`175`	`+ ) -> Regex<R.RegexOutput>.Match? {`
`176`	`176`	`try? r.regex.prefixMatch(in: self)`
`177`	`177`	`}`
`178`	`178`	`}`
Original file line number	Diff line number	Diff line change
`@@ -206,9 +206,9 @@ public struct _CharacterClassModel: Hashable {`
`206`	`206`	`}`
`207`	`207`
`208`	`208`	`extension _CharacterClassModel: RegexComponent {`
`209`		`- public typealias Output = Substring`
	`209`	`+ public typealias RegexOutput = Substring`
`210`	`210`
`211`		`- public var regex: Regex<Output> {`
	`211`	`+ public var regex: Regex<RegexOutput> {`
`212`	`212`	`guard let ast = self.makeAST() else {`
`213`	`213`	`fatalError("FIXME: extended AST?")`
`214`	`214`	`}`