From e04f2fc01f52fc897b9e140a1e6d3ef0e5bd996e Mon Sep 17 00:00:00 2001
From: Nate Cook <natecook@apple.com>
Date: Thu, 14 Apr 2022 17:15:47 -0500
Subject: [PATCH] RegexBuilder quantifiers take an optional behavior

---
 Sources/RegexBuilder/DSL.swift                |  16 +-
 Sources/RegexBuilder/Variadics.swift          | 440 ++++++++++--------
 .../VariadicsGenerator.swift                  |  20 +-
 Sources/_StringProcessing/ByteCodeGen.swift   |  18 +-
 .../_StringProcessing/PrintAsPattern.swift    |  11 +
 .../Regex/ASTConversion.swift                 |   2 +-
 Sources/_StringProcessing/Regex/DSLTree.swift |  12 +-
 Sources/_StringProcessing/Regex/Options.swift |  58 ++-
 Tests/RegexBuilderTests/RegexDSLTests.swift   |  20 +-
 9 files changed, 355 insertions(+), 242 deletions(-)

diff --git a/Sources/RegexBuilder/DSL.swift b/Sources/RegexBuilder/DSL.swift
index 80662be41..1edf03922 100644
--- a/Sources/RegexBuilder/DSL.swift
+++ b/Sources/RegexBuilder/DSL.swift
@@ -77,27 +77,29 @@ extension DSLTree.Node {
   /// Individual public API functions are in the generated Variadics.swift file.
   static func repeating(
     _ range: Range<Int>,
-    _ behavior: QuantificationBehavior,
+    _ behavior: QuantificationBehavior?,
     _ node: DSLTree.Node
   ) -> DSLTree.Node {
     // TODO: Throw these as errors
     assert(range.lowerBound >= 0, "Cannot specify a negative lower bound")
     assert(!range.isEmpty, "Cannot specify an empty range")
+    
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
 
     switch (range.lowerBound, range.upperBound) {
     case (0, Int.max): // 0...
-      return .quantification(.zeroOrMore, behavior.astKind, node)
+      return .quantification(.zeroOrMore, kind, node)
     case (1, Int.max): // 1...
-      return .quantification(.oneOrMore, behavior.astKind, node)
+      return .quantification(.oneOrMore, kind, node)
     case _ where range.count == 1: // ..<1 or ...0 or any range with count == 1
       // Note: `behavior` is ignored in this case
-      return .quantification(.exactly(.init(faking: range.lowerBound)), .eager, node)
+      return .quantification(.exactly(.init(faking: range.lowerBound)), .default, node)
     case (0, _): // 0..<n or 0...n or ..<n or ...n
-      return .quantification(.upToN(.init(faking: range.upperBound)), behavior.astKind, node)
+      return .quantification(.upToN(.init(faking: range.upperBound)), kind, node)
     case (_, Int.max): // n...
-      return .quantification(.nOrMore(.init(faking: range.lowerBound)), behavior.astKind, node)
+      return .quantification(.nOrMore(.init(faking: range.lowerBound)), kind, node)
     default: // any other range
-      return .quantification(.range(.init(faking: range.lowerBound), .init(faking: range.upperBound)), behavior.astKind, node)
+      return .quantification(.range(.init(faking: range.lowerBound), .init(faking: range.upperBound)), kind, node)
     }
   }
 }
diff --git a/Sources/RegexBuilder/Variadics.swift b/Sources/RegexBuilder/Variadics.swift
index 2f4a6240a..141d18053 100644
--- a/Sources/RegexBuilder/Variadics.swift
+++ b/Sources/RegexBuilder/Variadics.swift
@@ -482,19 +482,21 @@ extension Optionally {
   @_disfavoredOverload
   public init<Component: RegexComponent>(
     _ component: Component,
-    _ behavior: QuantificationBehavior = .eagerly
+    _ behavior: QuantificationBehavior? = nil
   ) where Output == Substring {
-    self.init(node: .quantification(.zeroOrOne, behavior.astKind, component.regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.zeroOrOne, kind, component.regex.root))
   }
 }
 
 extension Optionally {
   @_disfavoredOverload
   public init<Component: RegexComponent>(
-    _ behavior: QuantificationBehavior = .eagerly,
+    _ behavior: QuantificationBehavior? = nil,
     @RegexComponentBuilder _ component: () -> Component
   ) where Output == Substring {
-    self.init(node: .quantification(.zeroOrOne, behavior.astKind, component().regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.zeroOrOne, kind, component().regex.root))
   }
 }
 
@@ -502,26 +504,28 @@ extension RegexComponentBuilder {
   public static func buildLimitedAvailability<Component: RegexComponent>(
     _ component: Component
   ) -> Regex<Substring>  {
-    .init(node: .quantification(.zeroOrOne, .eager, component.regex.root))
+    .init(node: .quantification(.zeroOrOne, .default, component.regex.root))
   }
 }
 extension ZeroOrMore {
   @_disfavoredOverload
   public init<Component: RegexComponent>(
     _ component: Component,
-    _ behavior: QuantificationBehavior = .eagerly
+    _ behavior: QuantificationBehavior? = nil
   ) where Output == Substring {
-    self.init(node: .quantification(.zeroOrMore, behavior.astKind, component.regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.zeroOrMore, kind, component.regex.root))
   }
 }
 
 extension ZeroOrMore {
   @_disfavoredOverload
   public init<Component: RegexComponent>(
-    _ behavior: QuantificationBehavior = .eagerly,
+    _ behavior: QuantificationBehavior? = nil,
     @RegexComponentBuilder _ component: () -> Component
   ) where Output == Substring {
-    self.init(node: .quantification(.zeroOrMore, behavior.astKind, component().regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.zeroOrMore, kind, component().regex.root))
   }
 }
 
@@ -530,19 +534,21 @@ extension OneOrMore {
   @_disfavoredOverload
   public init<Component: RegexComponent>(
     _ component: Component,
-    _ behavior: QuantificationBehavior = .eagerly
+    _ behavior: QuantificationBehavior? = nil
   ) where Output == Substring {
-    self.init(node: .quantification(.oneOrMore, behavior.astKind, component.regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.oneOrMore, kind, component.regex.root))
   }
 }
 
 extension OneOrMore {
   @_disfavoredOverload
   public init<Component: RegexComponent>(
-    _ behavior: QuantificationBehavior = .eagerly,
+    _ behavior: QuantificationBehavior? = nil,
     @RegexComponentBuilder _ component: () -> Component
   ) where Output == Substring {
-    self.init(node: .quantification(.oneOrMore, behavior.astKind, component().regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.oneOrMore, kind, component().regex.root))
   }
 }
 
@@ -555,7 +561,7 @@ extension Repeat {
   ) where Output == Substring {
     assert(count > 0, "Must specify a positive count")
     // TODO: Emit a warning about `repeatMatch(count: 0)` or `repeatMatch(count: 1)`
-    self.init(node: .quantification(.exactly(.init(faking: count)), .eager, component.regex.root))
+    self.init(node: .quantification(.exactly(.init(faking: count)), .default, component.regex.root))
   }
 
   @_disfavoredOverload
@@ -565,14 +571,14 @@ extension Repeat {
   ) where Output == Substring {
     assert(count > 0, "Must specify a positive count")
     // TODO: Emit a warning about `repeatMatch(count: 0)` or `repeatMatch(count: 1)`
-    self.init(node: .quantification(.exactly(.init(faking: count)), .eager, component().regex.root))
+    self.init(node: .quantification(.exactly(.init(faking: count)), .default, component().regex.root))
   }
 
   @_disfavoredOverload
   public init<Component: RegexComponent, R: RangeExpression>(
     _ component: Component,
     _ expression: R,
-    _ behavior: QuantificationBehavior = .eagerly
+    _ behavior: QuantificationBehavior? = nil
   ) where Output == Substring, R.Bound == Int {
     self.init(node: .repeating(expression.relative(to: 0..<Int.max), behavior, component.regex.root))
   }
@@ -580,7 +586,7 @@ extension Repeat {
   @_disfavoredOverload
   public init<Component: RegexComponent, R: RangeExpression>(
     _ expression: R,
-    _ behavior: QuantificationBehavior = .eagerly,
+    _ behavior: QuantificationBehavior? = nil,
     @RegexComponentBuilder _ component: () -> Component
   ) where Output == Substring, R.Bound == Int {
     self.init(node: .repeating(expression.relative(to: 0..<Int.max), behavior, component().regex.root))
@@ -589,18 +595,20 @@ extension Repeat {
 extension Optionally {
     public init<W, C0, Component: RegexComponent>(
     _ component: Component,
-    _ behavior: QuantificationBehavior = .eagerly
+    _ behavior: QuantificationBehavior? = nil
   ) where Output == (Substring, C0?), Component.Output == (W, C0) {
-    self.init(node: .quantification(.zeroOrOne, behavior.astKind, component.regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.zeroOrOne, kind, component.regex.root))
   }
 }
 
 extension Optionally {
     public init<W, C0, Component: RegexComponent>(
-    _ behavior: QuantificationBehavior = .eagerly,
+    _ behavior: QuantificationBehavior? = nil,
     @RegexComponentBuilder _ component: () -> Component
   ) where Output == (Substring, C0?), Component.Output == (W, C0) {
-    self.init(node: .quantification(.zeroOrOne, behavior.astKind, component().regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.zeroOrOne, kind, component().regex.root))
   }
 }
 
@@ -608,24 +616,26 @@ extension RegexComponentBuilder {
   public static func buildLimitedAvailability<W, C0, Component: RegexComponent>(
     _ component: Component
   ) -> Regex<(Substring, C0?)> where Component.Output == (W, C0) {
-    .init(node: .quantification(.zeroOrOne, .eager, component.regex.root))
+    .init(node: .quantification(.zeroOrOne, .default, component.regex.root))
   }
 }
 extension ZeroOrMore {
     public init<W, C0, Component: RegexComponent>(
     _ component: Component,
-    _ behavior: QuantificationBehavior = .eagerly
+    _ behavior: QuantificationBehavior? = nil
   ) where Output == (Substring, C0?), Component.Output == (W, C0) {
-    self.init(node: .quantification(.zeroOrMore, behavior.astKind, component.regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.zeroOrMore, kind, component.regex.root))
   }
 }
 
 extension ZeroOrMore {
     public init<W, C0, Component: RegexComponent>(
-    _ behavior: QuantificationBehavior = .eagerly,
+    _ behavior: QuantificationBehavior? = nil,
     @RegexComponentBuilder _ component: () -> Component
   ) where Output == (Substring, C0?), Component.Output == (W, C0) {
-    self.init(node: .quantification(.zeroOrMore, behavior.astKind, component().regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.zeroOrMore, kind, component().regex.root))
   }
 }
 
@@ -633,18 +643,20 @@ extension ZeroOrMore {
 extension OneOrMore {
     public init<W, C0, Component: RegexComponent>(
     _ component: Component,
-    _ behavior: QuantificationBehavior = .eagerly
+    _ behavior: QuantificationBehavior? = nil
   ) where Output == (Substring, C0), Component.Output == (W, C0) {
-    self.init(node: .quantification(.oneOrMore, behavior.astKind, component.regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.oneOrMore, kind, component.regex.root))
   }
 }
 
 extension OneOrMore {
     public init<W, C0, Component: RegexComponent>(
-    _ behavior: QuantificationBehavior = .eagerly,
+    _ behavior: QuantificationBehavior? = nil,
     @RegexComponentBuilder _ component: () -> Component
   ) where Output == (Substring, C0), Component.Output == (W, C0) {
-    self.init(node: .quantification(.oneOrMore, behavior.astKind, component().regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.oneOrMore, kind, component().regex.root))
   }
 }
 
@@ -656,7 +668,7 @@ extension Repeat {
   ) where Output == (Substring, C0?), Component.Output == (W, C0) {
     assert(count > 0, "Must specify a positive count")
     // TODO: Emit a warning about `repeatMatch(count: 0)` or `repeatMatch(count: 1)`
-    self.init(node: .quantification(.exactly(.init(faking: count)), .eager, component.regex.root))
+    self.init(node: .quantification(.exactly(.init(faking: count)), .default, component.regex.root))
   }
 
     public init<W, C0, Component: RegexComponent>(
@@ -665,20 +677,20 @@ extension Repeat {
   ) where Output == (Substring, C0?), Component.Output == (W, C0) {
     assert(count > 0, "Must specify a positive count")
     // TODO: Emit a warning about `repeatMatch(count: 0)` or `repeatMatch(count: 1)`
-    self.init(node: .quantification(.exactly(.init(faking: count)), .eager, component().regex.root))
+    self.init(node: .quantification(.exactly(.init(faking: count)), .default, component().regex.root))
   }
 
     public init<W, C0, Component: RegexComponent, R: RangeExpression>(
     _ component: Component,
     _ expression: R,
-    _ behavior: QuantificationBehavior = .eagerly
+    _ behavior: QuantificationBehavior? = nil
   ) where Output == (Substring, C0?), Component.Output == (W, C0), R.Bound == Int {
     self.init(node: .repeating(expression.relative(to: 0..<Int.max), behavior, component.regex.root))
   }
 
     public init<W, C0, Component: RegexComponent, R: RangeExpression>(
     _ expression: R,
-    _ behavior: QuantificationBehavior = .eagerly,
+    _ behavior: QuantificationBehavior? = nil,
     @RegexComponentBuilder _ component: () -> Component
   ) where Output == (Substring, C0?), Component.Output == (W, C0), R.Bound == Int {
     self.init(node: .repeating(expression.relative(to: 0..<Int.max), behavior, component().regex.root))
@@ -687,18 +699,20 @@ extension Repeat {
 extension Optionally {
     public init<W, C0, C1, Component: RegexComponent>(
     _ component: Component,
-    _ behavior: QuantificationBehavior = .eagerly
+    _ behavior: QuantificationBehavior? = nil
   ) where Output == (Substring, C0?, C1?), Component.Output == (W, C0, C1) {
-    self.init(node: .quantification(.zeroOrOne, behavior.astKind, component.regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.zeroOrOne, kind, component.regex.root))
   }
 }
 
 extension Optionally {
     public init<W, C0, C1, Component: RegexComponent>(
-    _ behavior: QuantificationBehavior = .eagerly,
+    _ behavior: QuantificationBehavior? = nil,
     @RegexComponentBuilder _ component: () -> Component
   ) where Output == (Substring, C0?, C1?), Component.Output == (W, C0, C1) {
-    self.init(node: .quantification(.zeroOrOne, behavior.astKind, component().regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.zeroOrOne, kind, component().regex.root))
   }
 }
 
@@ -706,24 +720,26 @@ extension RegexComponentBuilder {
   public static func buildLimitedAvailability<W, C0, C1, Component: RegexComponent>(
     _ component: Component
   ) -> Regex<(Substring, C0?, C1?)> where Component.Output == (W, C0, C1) {
-    .init(node: .quantification(.zeroOrOne, .eager, component.regex.root))
+    .init(node: .quantification(.zeroOrOne, .default, component.regex.root))
   }
 }
 extension ZeroOrMore {
     public init<W, C0, C1, Component: RegexComponent>(
     _ component: Component,
-    _ behavior: QuantificationBehavior = .eagerly
+    _ behavior: QuantificationBehavior? = nil
   ) where Output == (Substring, C0?, C1?), Component.Output == (W, C0, C1) {
-    self.init(node: .quantification(.zeroOrMore, behavior.astKind, component.regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.zeroOrMore, kind, component.regex.root))
   }
 }
 
 extension ZeroOrMore {
     public init<W, C0, C1, Component: RegexComponent>(
-    _ behavior: QuantificationBehavior = .eagerly,
+    _ behavior: QuantificationBehavior? = nil,
     @RegexComponentBuilder _ component: () -> Component
   ) where Output == (Substring, C0?, C1?), Component.Output == (W, C0, C1) {
-    self.init(node: .quantification(.zeroOrMore, behavior.astKind, component().regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.zeroOrMore, kind, component().regex.root))
   }
 }
 
@@ -731,18 +747,20 @@ extension ZeroOrMore {
 extension OneOrMore {
     public init<W, C0, C1, Component: RegexComponent>(
     _ component: Component,
-    _ behavior: QuantificationBehavior = .eagerly
+    _ behavior: QuantificationBehavior? = nil
   ) where Output == (Substring, C0, C1), Component.Output == (W, C0, C1) {
-    self.init(node: .quantification(.oneOrMore, behavior.astKind, component.regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.oneOrMore, kind, component.regex.root))
   }
 }
 
 extension OneOrMore {
     public init<W, C0, C1, Component: RegexComponent>(
-    _ behavior: QuantificationBehavior = .eagerly,
+    _ behavior: QuantificationBehavior? = nil,
     @RegexComponentBuilder _ component: () -> Component
   ) where Output == (Substring, C0, C1), Component.Output == (W, C0, C1) {
-    self.init(node: .quantification(.oneOrMore, behavior.astKind, component().regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.oneOrMore, kind, component().regex.root))
   }
 }
 
@@ -754,7 +772,7 @@ extension Repeat {
   ) where Output == (Substring, C0?, C1?), Component.Output == (W, C0, C1) {
     assert(count > 0, "Must specify a positive count")
     // TODO: Emit a warning about `repeatMatch(count: 0)` or `repeatMatch(count: 1)`
-    self.init(node: .quantification(.exactly(.init(faking: count)), .eager, component.regex.root))
+    self.init(node: .quantification(.exactly(.init(faking: count)), .default, component.regex.root))
   }
 
     public init<W, C0, C1, Component: RegexComponent>(
@@ -763,20 +781,20 @@ extension Repeat {
   ) where Output == (Substring, C0?, C1?), Component.Output == (W, C0, C1) {
     assert(count > 0, "Must specify a positive count")
     // TODO: Emit a warning about `repeatMatch(count: 0)` or `repeatMatch(count: 1)`
-    self.init(node: .quantification(.exactly(.init(faking: count)), .eager, component().regex.root))
+    self.init(node: .quantification(.exactly(.init(faking: count)), .default, component().regex.root))
   }
 
     public init<W, C0, C1, Component: RegexComponent, R: RangeExpression>(
     _ component: Component,
     _ expression: R,
-    _ behavior: QuantificationBehavior = .eagerly
+    _ behavior: QuantificationBehavior? = nil
   ) where Output == (Substring, C0?, C1?), Component.Output == (W, C0, C1), R.Bound == Int {
     self.init(node: .repeating(expression.relative(to: 0..<Int.max), behavior, component.regex.root))
   }
 
     public init<W, C0, C1, Component: RegexComponent, R: RangeExpression>(
     _ expression: R,
-    _ behavior: QuantificationBehavior = .eagerly,
+    _ behavior: QuantificationBehavior? = nil,
     @RegexComponentBuilder _ component: () -> Component
   ) where Output == (Substring, C0?, C1?), Component.Output == (W, C0, C1), R.Bound == Int {
     self.init(node: .repeating(expression.relative(to: 0..<Int.max), behavior, component().regex.root))
@@ -785,18 +803,20 @@ extension Repeat {
 extension Optionally {
     public init<W, C0, C1, C2, Component: RegexComponent>(
     _ component: Component,
-    _ behavior: QuantificationBehavior = .eagerly
+    _ behavior: QuantificationBehavior? = nil
   ) where Output == (Substring, C0?, C1?, C2?), Component.Output == (W, C0, C1, C2) {
-    self.init(node: .quantification(.zeroOrOne, behavior.astKind, component.regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.zeroOrOne, kind, component.regex.root))
   }
 }
 
 extension Optionally {
     public init<W, C0, C1, C2, Component: RegexComponent>(
-    _ behavior: QuantificationBehavior = .eagerly,
+    _ behavior: QuantificationBehavior? = nil,
     @RegexComponentBuilder _ component: () -> Component
   ) where Output == (Substring, C0?, C1?, C2?), Component.Output == (W, C0, C1, C2) {
-    self.init(node: .quantification(.zeroOrOne, behavior.astKind, component().regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.zeroOrOne, kind, component().regex.root))
   }
 }
 
@@ -804,24 +824,26 @@ extension RegexComponentBuilder {
   public static func buildLimitedAvailability<W, C0, C1, C2, Component: RegexComponent>(
     _ component: Component
   ) -> Regex<(Substring, C0?, C1?, C2?)> where Component.Output == (W, C0, C1, C2) {
-    .init(node: .quantification(.zeroOrOne, .eager, component.regex.root))
+    .init(node: .quantification(.zeroOrOne, .default, component.regex.root))
   }
 }
 extension ZeroOrMore {
     public init<W, C0, C1, C2, Component: RegexComponent>(
     _ component: Component,
-    _ behavior: QuantificationBehavior = .eagerly
+    _ behavior: QuantificationBehavior? = nil
   ) where Output == (Substring, C0?, C1?, C2?), Component.Output == (W, C0, C1, C2) {
-    self.init(node: .quantification(.zeroOrMore, behavior.astKind, component.regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.zeroOrMore, kind, component.regex.root))
   }
 }
 
 extension ZeroOrMore {
     public init<W, C0, C1, C2, Component: RegexComponent>(
-    _ behavior: QuantificationBehavior = .eagerly,
+    _ behavior: QuantificationBehavior? = nil,
     @RegexComponentBuilder _ component: () -> Component
   ) where Output == (Substring, C0?, C1?, C2?), Component.Output == (W, C0, C1, C2) {
-    self.init(node: .quantification(.zeroOrMore, behavior.astKind, component().regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.zeroOrMore, kind, component().regex.root))
   }
 }
 
@@ -829,18 +851,20 @@ extension ZeroOrMore {
 extension OneOrMore {
     public init<W, C0, C1, C2, Component: RegexComponent>(
     _ component: Component,
-    _ behavior: QuantificationBehavior = .eagerly
+    _ behavior: QuantificationBehavior? = nil
   ) where Output == (Substring, C0, C1, C2), Component.Output == (W, C0, C1, C2) {
-    self.init(node: .quantification(.oneOrMore, behavior.astKind, component.regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.oneOrMore, kind, component.regex.root))
   }
 }
 
 extension OneOrMore {
     public init<W, C0, C1, C2, Component: RegexComponent>(
-    _ behavior: QuantificationBehavior = .eagerly,
+    _ behavior: QuantificationBehavior? = nil,
     @RegexComponentBuilder _ component: () -> Component
   ) where Output == (Substring, C0, C1, C2), Component.Output == (W, C0, C1, C2) {
-    self.init(node: .quantification(.oneOrMore, behavior.astKind, component().regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.oneOrMore, kind, component().regex.root))
   }
 }
 
@@ -852,7 +876,7 @@ extension Repeat {
   ) where Output == (Substring, C0?, C1?, C2?), Component.Output == (W, C0, C1, C2) {
     assert(count > 0, "Must specify a positive count")
     // TODO: Emit a warning about `repeatMatch(count: 0)` or `repeatMatch(count: 1)`
-    self.init(node: .quantification(.exactly(.init(faking: count)), .eager, component.regex.root))
+    self.init(node: .quantification(.exactly(.init(faking: count)), .default, component.regex.root))
   }
 
     public init<W, C0, C1, C2, Component: RegexComponent>(
@@ -861,20 +885,20 @@ extension Repeat {
   ) where Output == (Substring, C0?, C1?, C2?), Component.Output == (W, C0, C1, C2) {
     assert(count > 0, "Must specify a positive count")
     // TODO: Emit a warning about `repeatMatch(count: 0)` or `repeatMatch(count: 1)`
-    self.init(node: .quantification(.exactly(.init(faking: count)), .eager, component().regex.root))
+    self.init(node: .quantification(.exactly(.init(faking: count)), .default, component().regex.root))
   }
 
     public init<W, C0, C1, C2, Component: RegexComponent, R: RangeExpression>(
     _ component: Component,
     _ expression: R,
-    _ behavior: QuantificationBehavior = .eagerly
+    _ behavior: QuantificationBehavior? = nil
   ) where Output == (Substring, C0?, C1?, C2?), Component.Output == (W, C0, C1, C2), R.Bound == Int {
     self.init(node: .repeating(expression.relative(to: 0..<Int.max), behavior, component.regex.root))
   }
 
     public init<W, C0, C1, C2, Component: RegexComponent, R: RangeExpression>(
     _ expression: R,
-    _ behavior: QuantificationBehavior = .eagerly,
+    _ behavior: QuantificationBehavior? = nil,
     @RegexComponentBuilder _ component: () -> Component
   ) where Output == (Substring, C0?, C1?, C2?), Component.Output == (W, C0, C1, C2), R.Bound == Int {
     self.init(node: .repeating(expression.relative(to: 0..<Int.max), behavior, component().regex.root))
@@ -883,18 +907,20 @@ extension Repeat {
 extension Optionally {
     public init<W, C0, C1, C2, C3, Component: RegexComponent>(
     _ component: Component,
-    _ behavior: QuantificationBehavior = .eagerly
+    _ behavior: QuantificationBehavior? = nil
   ) where Output == (Substring, C0?, C1?, C2?, C3?), Component.Output == (W, C0, C1, C2, C3) {
-    self.init(node: .quantification(.zeroOrOne, behavior.astKind, component.regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.zeroOrOne, kind, component.regex.root))
   }
 }
 
 extension Optionally {
     public init<W, C0, C1, C2, C3, Component: RegexComponent>(
-    _ behavior: QuantificationBehavior = .eagerly,
+    _ behavior: QuantificationBehavior? = nil,
     @RegexComponentBuilder _ component: () -> Component
   ) where Output == (Substring, C0?, C1?, C2?, C3?), Component.Output == (W, C0, C1, C2, C3) {
-    self.init(node: .quantification(.zeroOrOne, behavior.astKind, component().regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.zeroOrOne, kind, component().regex.root))
   }
 }
 
@@ -902,24 +928,26 @@ extension RegexComponentBuilder {
   public static func buildLimitedAvailability<W, C0, C1, C2, C3, Component: RegexComponent>(
     _ component: Component
   ) -> Regex<(Substring, C0?, C1?, C2?, C3?)> where Component.Output == (W, C0, C1, C2, C3) {
-    .init(node: .quantification(.zeroOrOne, .eager, component.regex.root))
+    .init(node: .quantification(.zeroOrOne, .default, component.regex.root))
   }
 }
 extension ZeroOrMore {
     public init<W, C0, C1, C2, C3, Component: RegexComponent>(
     _ component: Component,
-    _ behavior: QuantificationBehavior = .eagerly
+    _ behavior: QuantificationBehavior? = nil
   ) where Output == (Substring, C0?, C1?, C2?, C3?), Component.Output == (W, C0, C1, C2, C3) {
-    self.init(node: .quantification(.zeroOrMore, behavior.astKind, component.regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.zeroOrMore, kind, component.regex.root))
   }
 }
 
 extension ZeroOrMore {
     public init<W, C0, C1, C2, C3, Component: RegexComponent>(
-    _ behavior: QuantificationBehavior = .eagerly,
+    _ behavior: QuantificationBehavior? = nil,
     @RegexComponentBuilder _ component: () -> Component
   ) where Output == (Substring, C0?, C1?, C2?, C3?), Component.Output == (W, C0, C1, C2, C3) {
-    self.init(node: .quantification(.zeroOrMore, behavior.astKind, component().regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.zeroOrMore, kind, component().regex.root))
   }
 }
 
@@ -927,18 +955,20 @@ extension ZeroOrMore {
 extension OneOrMore {
     public init<W, C0, C1, C2, C3, Component: RegexComponent>(
     _ component: Component,
-    _ behavior: QuantificationBehavior = .eagerly
+    _ behavior: QuantificationBehavior? = nil
   ) where Output == (Substring, C0, C1, C2, C3), Component.Output == (W, C0, C1, C2, C3) {
-    self.init(node: .quantification(.oneOrMore, behavior.astKind, component.regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.oneOrMore, kind, component.regex.root))
   }
 }
 
 extension OneOrMore {
     public init<W, C0, C1, C2, C3, Component: RegexComponent>(
-    _ behavior: QuantificationBehavior = .eagerly,
+    _ behavior: QuantificationBehavior? = nil,
     @RegexComponentBuilder _ component: () -> Component
   ) where Output == (Substring, C0, C1, C2, C3), Component.Output == (W, C0, C1, C2, C3) {
-    self.init(node: .quantification(.oneOrMore, behavior.astKind, component().regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.oneOrMore, kind, component().regex.root))
   }
 }
 
@@ -950,7 +980,7 @@ extension Repeat {
   ) where Output == (Substring, C0?, C1?, C2?, C3?), Component.Output == (W, C0, C1, C2, C3) {
     assert(count > 0, "Must specify a positive count")
     // TODO: Emit a warning about `repeatMatch(count: 0)` or `repeatMatch(count: 1)`
-    self.init(node: .quantification(.exactly(.init(faking: count)), .eager, component.regex.root))
+    self.init(node: .quantification(.exactly(.init(faking: count)), .default, component.regex.root))
   }
 
     public init<W, C0, C1, C2, C3, Component: RegexComponent>(
@@ -959,20 +989,20 @@ extension Repeat {
   ) where Output == (Substring, C0?, C1?, C2?, C3?), Component.Output == (W, C0, C1, C2, C3) {
     assert(count > 0, "Must specify a positive count")
     // TODO: Emit a warning about `repeatMatch(count: 0)` or `repeatMatch(count: 1)`
-    self.init(node: .quantification(.exactly(.init(faking: count)), .eager, component().regex.root))
+    self.init(node: .quantification(.exactly(.init(faking: count)), .default, component().regex.root))
   }
 
     public init<W, C0, C1, C2, C3, Component: RegexComponent, R: RangeExpression>(
     _ component: Component,
     _ expression: R,
-    _ behavior: QuantificationBehavior = .eagerly
+    _ behavior: QuantificationBehavior? = nil
   ) where Output == (Substring, C0?, C1?, C2?, C3?), Component.Output == (W, C0, C1, C2, C3), R.Bound == Int {
     self.init(node: .repeating(expression.relative(to: 0..<Int.max), behavior, component.regex.root))
   }
 
     public init<W, C0, C1, C2, C3, Component: RegexComponent, R: RangeExpression>(
     _ expression: R,
-    _ behavior: QuantificationBehavior = .eagerly,
+    _ behavior: QuantificationBehavior? = nil,
     @RegexComponentBuilder _ component: () -> Component
   ) where Output == (Substring, C0?, C1?, C2?, C3?), Component.Output == (W, C0, C1, C2, C3), R.Bound == Int {
     self.init(node: .repeating(expression.relative(to: 0..<Int.max), behavior, component().regex.root))
@@ -981,18 +1011,20 @@ extension Repeat {
 extension Optionally {
     public init<W, C0, C1, C2, C3, C4, Component: RegexComponent>(
     _ component: Component,
-    _ behavior: QuantificationBehavior = .eagerly
+    _ behavior: QuantificationBehavior? = nil
   ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?), Component.Output == (W, C0, C1, C2, C3, C4) {
-    self.init(node: .quantification(.zeroOrOne, behavior.astKind, component.regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.zeroOrOne, kind, component.regex.root))
   }
 }
 
 extension Optionally {
     public init<W, C0, C1, C2, C3, C4, Component: RegexComponent>(
-    _ behavior: QuantificationBehavior = .eagerly,
+    _ behavior: QuantificationBehavior? = nil,
     @RegexComponentBuilder _ component: () -> Component
   ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?), Component.Output == (W, C0, C1, C2, C3, C4) {
-    self.init(node: .quantification(.zeroOrOne, behavior.astKind, component().regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.zeroOrOne, kind, component().regex.root))
   }
 }
 
@@ -1000,24 +1032,26 @@ extension RegexComponentBuilder {
   public static func buildLimitedAvailability<W, C0, C1, C2, C3, C4, Component: RegexComponent>(
     _ component: Component
   ) -> Regex<(Substring, C0?, C1?, C2?, C3?, C4?)> where Component.Output == (W, C0, C1, C2, C3, C4) {
-    .init(node: .quantification(.zeroOrOne, .eager, component.regex.root))
+    .init(node: .quantification(.zeroOrOne, .default, component.regex.root))
   }
 }
 extension ZeroOrMore {
     public init<W, C0, C1, C2, C3, C4, Component: RegexComponent>(
     _ component: Component,
-    _ behavior: QuantificationBehavior = .eagerly
+    _ behavior: QuantificationBehavior? = nil
   ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?), Component.Output == (W, C0, C1, C2, C3, C4) {
-    self.init(node: .quantification(.zeroOrMore, behavior.astKind, component.regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.zeroOrMore, kind, component.regex.root))
   }
 }
 
 extension ZeroOrMore {
     public init<W, C0, C1, C2, C3, C4, Component: RegexComponent>(
-    _ behavior: QuantificationBehavior = .eagerly,
+    _ behavior: QuantificationBehavior? = nil,
     @RegexComponentBuilder _ component: () -> Component
   ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?), Component.Output == (W, C0, C1, C2, C3, C4) {
-    self.init(node: .quantification(.zeroOrMore, behavior.astKind, component().regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.zeroOrMore, kind, component().regex.root))
   }
 }
 
@@ -1025,18 +1059,20 @@ extension ZeroOrMore {
 extension OneOrMore {
     public init<W, C0, C1, C2, C3, C4, Component: RegexComponent>(
     _ component: Component,
-    _ behavior: QuantificationBehavior = .eagerly
+    _ behavior: QuantificationBehavior? = nil
   ) where Output == (Substring, C0, C1, C2, C3, C4), Component.Output == (W, C0, C1, C2, C3, C4) {
-    self.init(node: .quantification(.oneOrMore, behavior.astKind, component.regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.oneOrMore, kind, component.regex.root))
   }
 }
 
 extension OneOrMore {
     public init<W, C0, C1, C2, C3, C4, Component: RegexComponent>(
-    _ behavior: QuantificationBehavior = .eagerly,
+    _ behavior: QuantificationBehavior? = nil,
     @RegexComponentBuilder _ component: () -> Component
   ) where Output == (Substring, C0, C1, C2, C3, C4), Component.Output == (W, C0, C1, C2, C3, C4) {
-    self.init(node: .quantification(.oneOrMore, behavior.astKind, component().regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.oneOrMore, kind, component().regex.root))
   }
 }
 
@@ -1048,7 +1084,7 @@ extension Repeat {
   ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?), Component.Output == (W, C0, C1, C2, C3, C4) {
     assert(count > 0, "Must specify a positive count")
     // TODO: Emit a warning about `repeatMatch(count: 0)` or `repeatMatch(count: 1)`
-    self.init(node: .quantification(.exactly(.init(faking: count)), .eager, component.regex.root))
+    self.init(node: .quantification(.exactly(.init(faking: count)), .default, component.regex.root))
   }
 
     public init<W, C0, C1, C2, C3, C4, Component: RegexComponent>(
@@ -1057,20 +1093,20 @@ extension Repeat {
   ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?), Component.Output == (W, C0, C1, C2, C3, C4) {
     assert(count > 0, "Must specify a positive count")
     // TODO: Emit a warning about `repeatMatch(count: 0)` or `repeatMatch(count: 1)`
-    self.init(node: .quantification(.exactly(.init(faking: count)), .eager, component().regex.root))
+    self.init(node: .quantification(.exactly(.init(faking: count)), .default, component().regex.root))
   }
 
     public init<W, C0, C1, C2, C3, C4, Component: RegexComponent, R: RangeExpression>(
     _ component: Component,
     _ expression: R,
-    _ behavior: QuantificationBehavior = .eagerly
+    _ behavior: QuantificationBehavior? = nil
   ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?), Component.Output == (W, C0, C1, C2, C3, C4), R.Bound == Int {
     self.init(node: .repeating(expression.relative(to: 0..<Int.max), behavior, component.regex.root))
   }
 
     public init<W, C0, C1, C2, C3, C4, Component: RegexComponent, R: RangeExpression>(
     _ expression: R,
-    _ behavior: QuantificationBehavior = .eagerly,
+    _ behavior: QuantificationBehavior? = nil,
     @RegexComponentBuilder _ component: () -> Component
   ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?), Component.Output == (W, C0, C1, C2, C3, C4), R.Bound == Int {
     self.init(node: .repeating(expression.relative(to: 0..<Int.max), behavior, component().regex.root))
@@ -1079,18 +1115,20 @@ extension Repeat {
 extension Optionally {
     public init<W, C0, C1, C2, C3, C4, C5, Component: RegexComponent>(
     _ component: Component,
-    _ behavior: QuantificationBehavior = .eagerly
+    _ behavior: QuantificationBehavior? = nil
   ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?), Component.Output == (W, C0, C1, C2, C3, C4, C5) {
-    self.init(node: .quantification(.zeroOrOne, behavior.astKind, component.regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.zeroOrOne, kind, component.regex.root))
   }
 }
 
 extension Optionally {
     public init<W, C0, C1, C2, C3, C4, C5, Component: RegexComponent>(
-    _ behavior: QuantificationBehavior = .eagerly,
+    _ behavior: QuantificationBehavior? = nil,
     @RegexComponentBuilder _ component: () -> Component
   ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?), Component.Output == (W, C0, C1, C2, C3, C4, C5) {
-    self.init(node: .quantification(.zeroOrOne, behavior.astKind, component().regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.zeroOrOne, kind, component().regex.root))
   }
 }
 
@@ -1098,24 +1136,26 @@ extension RegexComponentBuilder {
   public static func buildLimitedAvailability<W, C0, C1, C2, C3, C4, C5, Component: RegexComponent>(
     _ component: Component
   ) -> Regex<(Substring, C0?, C1?, C2?, C3?, C4?, C5?)> where Component.Output == (W, C0, C1, C2, C3, C4, C5) {
-    .init(node: .quantification(.zeroOrOne, .eager, component.regex.root))
+    .init(node: .quantification(.zeroOrOne, .default, component.regex.root))
   }
 }
 extension ZeroOrMore {
     public init<W, C0, C1, C2, C3, C4, C5, Component: RegexComponent>(
     _ component: Component,
-    _ behavior: QuantificationBehavior = .eagerly
+    _ behavior: QuantificationBehavior? = nil
   ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?), Component.Output == (W, C0, C1, C2, C3, C4, C5) {
-    self.init(node: .quantification(.zeroOrMore, behavior.astKind, component.regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.zeroOrMore, kind, component.regex.root))
   }
 }
 
 extension ZeroOrMore {
     public init<W, C0, C1, C2, C3, C4, C5, Component: RegexComponent>(
-    _ behavior: QuantificationBehavior = .eagerly,
+    _ behavior: QuantificationBehavior? = nil,
     @RegexComponentBuilder _ component: () -> Component
   ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?), Component.Output == (W, C0, C1, C2, C3, C4, C5) {
-    self.init(node: .quantification(.zeroOrMore, behavior.astKind, component().regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.zeroOrMore, kind, component().regex.root))
   }
 }
 
@@ -1123,18 +1163,20 @@ extension ZeroOrMore {
 extension OneOrMore {
     public init<W, C0, C1, C2, C3, C4, C5, Component: RegexComponent>(
     _ component: Component,
-    _ behavior: QuantificationBehavior = .eagerly
+    _ behavior: QuantificationBehavior? = nil
   ) where Output == (Substring, C0, C1, C2, C3, C4, C5), Component.Output == (W, C0, C1, C2, C3, C4, C5) {
-    self.init(node: .quantification(.oneOrMore, behavior.astKind, component.regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.oneOrMore, kind, component.regex.root))
   }
 }
 
 extension OneOrMore {
     public init<W, C0, C1, C2, C3, C4, C5, Component: RegexComponent>(
-    _ behavior: QuantificationBehavior = .eagerly,
+    _ behavior: QuantificationBehavior? = nil,
     @RegexComponentBuilder _ component: () -> Component
   ) where Output == (Substring, C0, C1, C2, C3, C4, C5), Component.Output == (W, C0, C1, C2, C3, C4, C5) {
-    self.init(node: .quantification(.oneOrMore, behavior.astKind, component().regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.oneOrMore, kind, component().regex.root))
   }
 }
 
@@ -1146,7 +1188,7 @@ extension Repeat {
   ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?), Component.Output == (W, C0, C1, C2, C3, C4, C5) {
     assert(count > 0, "Must specify a positive count")
     // TODO: Emit a warning about `repeatMatch(count: 0)` or `repeatMatch(count: 1)`
-    self.init(node: .quantification(.exactly(.init(faking: count)), .eager, component.regex.root))
+    self.init(node: .quantification(.exactly(.init(faking: count)), .default, component.regex.root))
   }
 
     public init<W, C0, C1, C2, C3, C4, C5, Component: RegexComponent>(
@@ -1155,20 +1197,20 @@ extension Repeat {
   ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?), Component.Output == (W, C0, C1, C2, C3, C4, C5) {
     assert(count > 0, "Must specify a positive count")
     // TODO: Emit a warning about `repeatMatch(count: 0)` or `repeatMatch(count: 1)`
-    self.init(node: .quantification(.exactly(.init(faking: count)), .eager, component().regex.root))
+    self.init(node: .quantification(.exactly(.init(faking: count)), .default, component().regex.root))
   }
 
     public init<W, C0, C1, C2, C3, C4, C5, Component: RegexComponent, R: RangeExpression>(
     _ component: Component,
     _ expression: R,
-    _ behavior: QuantificationBehavior = .eagerly
+    _ behavior: QuantificationBehavior? = nil
   ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?), Component.Output == (W, C0, C1, C2, C3, C4, C5), R.Bound == Int {
     self.init(node: .repeating(expression.relative(to: 0..<Int.max), behavior, component.regex.root))
   }
 
     public init<W, C0, C1, C2, C3, C4, C5, Component: RegexComponent, R: RangeExpression>(
     _ expression: R,
-    _ behavior: QuantificationBehavior = .eagerly,
+    _ behavior: QuantificationBehavior? = nil,
     @RegexComponentBuilder _ component: () -> Component
   ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?), Component.Output == (W, C0, C1, C2, C3, C4, C5), R.Bound == Int {
     self.init(node: .repeating(expression.relative(to: 0..<Int.max), behavior, component().regex.root))
@@ -1177,18 +1219,20 @@ extension Repeat {
 extension Optionally {
     public init<W, C0, C1, C2, C3, C4, C5, C6, Component: RegexComponent>(
     _ component: Component,
-    _ behavior: QuantificationBehavior = .eagerly
+    _ behavior: QuantificationBehavior? = nil
   ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6) {
-    self.init(node: .quantification(.zeroOrOne, behavior.astKind, component.regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.zeroOrOne, kind, component.regex.root))
   }
 }
 
 extension Optionally {
     public init<W, C0, C1, C2, C3, C4, C5, C6, Component: RegexComponent>(
-    _ behavior: QuantificationBehavior = .eagerly,
+    _ behavior: QuantificationBehavior? = nil,
     @RegexComponentBuilder _ component: () -> Component
   ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6) {
-    self.init(node: .quantification(.zeroOrOne, behavior.astKind, component().regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.zeroOrOne, kind, component().regex.root))
   }
 }
 
@@ -1196,24 +1240,26 @@ extension RegexComponentBuilder {
   public static func buildLimitedAvailability<W, C0, C1, C2, C3, C4, C5, C6, Component: RegexComponent>(
     _ component: Component
   ) -> Regex<(Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?)> where Component.Output == (W, C0, C1, C2, C3, C4, C5, C6) {
-    .init(node: .quantification(.zeroOrOne, .eager, component.regex.root))
+    .init(node: .quantification(.zeroOrOne, .default, component.regex.root))
   }
 }
 extension ZeroOrMore {
     public init<W, C0, C1, C2, C3, C4, C5, C6, Component: RegexComponent>(
     _ component: Component,
-    _ behavior: QuantificationBehavior = .eagerly
+    _ behavior: QuantificationBehavior? = nil
   ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6) {
-    self.init(node: .quantification(.zeroOrMore, behavior.astKind, component.regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.zeroOrMore, kind, component.regex.root))
   }
 }
 
 extension ZeroOrMore {
     public init<W, C0, C1, C2, C3, C4, C5, C6, Component: RegexComponent>(
-    _ behavior: QuantificationBehavior = .eagerly,
+    _ behavior: QuantificationBehavior? = nil,
     @RegexComponentBuilder _ component: () -> Component
   ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6) {
-    self.init(node: .quantification(.zeroOrMore, behavior.astKind, component().regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.zeroOrMore, kind, component().regex.root))
   }
 }
 
@@ -1221,18 +1267,20 @@ extension ZeroOrMore {
 extension OneOrMore {
     public init<W, C0, C1, C2, C3, C4, C5, C6, Component: RegexComponent>(
     _ component: Component,
-    _ behavior: QuantificationBehavior = .eagerly
+    _ behavior: QuantificationBehavior? = nil
   ) where Output == (Substring, C0, C1, C2, C3, C4, C5, C6), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6) {
-    self.init(node: .quantification(.oneOrMore, behavior.astKind, component.regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.oneOrMore, kind, component.regex.root))
   }
 }
 
 extension OneOrMore {
     public init<W, C0, C1, C2, C3, C4, C5, C6, Component: RegexComponent>(
-    _ behavior: QuantificationBehavior = .eagerly,
+    _ behavior: QuantificationBehavior? = nil,
     @RegexComponentBuilder _ component: () -> Component
   ) where Output == (Substring, C0, C1, C2, C3, C4, C5, C6), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6) {
-    self.init(node: .quantification(.oneOrMore, behavior.astKind, component().regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.oneOrMore, kind, component().regex.root))
   }
 }
 
@@ -1244,7 +1292,7 @@ extension Repeat {
   ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6) {
     assert(count > 0, "Must specify a positive count")
     // TODO: Emit a warning about `repeatMatch(count: 0)` or `repeatMatch(count: 1)`
-    self.init(node: .quantification(.exactly(.init(faking: count)), .eager, component.regex.root))
+    self.init(node: .quantification(.exactly(.init(faking: count)), .default, component.regex.root))
   }
 
     public init<W, C0, C1, C2, C3, C4, C5, C6, Component: RegexComponent>(
@@ -1253,20 +1301,20 @@ extension Repeat {
   ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6) {
     assert(count > 0, "Must specify a positive count")
     // TODO: Emit a warning about `repeatMatch(count: 0)` or `repeatMatch(count: 1)`
-    self.init(node: .quantification(.exactly(.init(faking: count)), .eager, component().regex.root))
+    self.init(node: .quantification(.exactly(.init(faking: count)), .default, component().regex.root))
   }
 
     public init<W, C0, C1, C2, C3, C4, C5, C6, Component: RegexComponent, R: RangeExpression>(
     _ component: Component,
     _ expression: R,
-    _ behavior: QuantificationBehavior = .eagerly
+    _ behavior: QuantificationBehavior? = nil
   ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6), R.Bound == Int {
     self.init(node: .repeating(expression.relative(to: 0..<Int.max), behavior, component.regex.root))
   }
 
     public init<W, C0, C1, C2, C3, C4, C5, C6, Component: RegexComponent, R: RangeExpression>(
     _ expression: R,
-    _ behavior: QuantificationBehavior = .eagerly,
+    _ behavior: QuantificationBehavior? = nil,
     @RegexComponentBuilder _ component: () -> Component
   ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6), R.Bound == Int {
     self.init(node: .repeating(expression.relative(to: 0..<Int.max), behavior, component().regex.root))
@@ -1275,18 +1323,20 @@ extension Repeat {
 extension Optionally {
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, Component: RegexComponent>(
     _ component: Component,
-    _ behavior: QuantificationBehavior = .eagerly
+    _ behavior: QuantificationBehavior? = nil
   ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
-    self.init(node: .quantification(.zeroOrOne, behavior.astKind, component.regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.zeroOrOne, kind, component.regex.root))
   }
 }
 
 extension Optionally {
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, Component: RegexComponent>(
-    _ behavior: QuantificationBehavior = .eagerly,
+    _ behavior: QuantificationBehavior? = nil,
     @RegexComponentBuilder _ component: () -> Component
   ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
-    self.init(node: .quantification(.zeroOrOne, behavior.astKind, component().regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.zeroOrOne, kind, component().regex.root))
   }
 }
 
@@ -1294,24 +1344,26 @@ extension RegexComponentBuilder {
   public static func buildLimitedAvailability<W, C0, C1, C2, C3, C4, C5, C6, C7, Component: RegexComponent>(
     _ component: Component
   ) -> Regex<(Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?)> where Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
-    .init(node: .quantification(.zeroOrOne, .eager, component.regex.root))
+    .init(node: .quantification(.zeroOrOne, .default, component.regex.root))
   }
 }
 extension ZeroOrMore {
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, Component: RegexComponent>(
     _ component: Component,
-    _ behavior: QuantificationBehavior = .eagerly
+    _ behavior: QuantificationBehavior? = nil
   ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
-    self.init(node: .quantification(.zeroOrMore, behavior.astKind, component.regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.zeroOrMore, kind, component.regex.root))
   }
 }
 
 extension ZeroOrMore {
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, Component: RegexComponent>(
-    _ behavior: QuantificationBehavior = .eagerly,
+    _ behavior: QuantificationBehavior? = nil,
     @RegexComponentBuilder _ component: () -> Component
   ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
-    self.init(node: .quantification(.zeroOrMore, behavior.astKind, component().regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.zeroOrMore, kind, component().regex.root))
   }
 }
 
@@ -1319,18 +1371,20 @@ extension ZeroOrMore {
 extension OneOrMore {
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, Component: RegexComponent>(
     _ component: Component,
-    _ behavior: QuantificationBehavior = .eagerly
+    _ behavior: QuantificationBehavior? = nil
   ) where Output == (Substring, C0, C1, C2, C3, C4, C5, C6, C7), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
-    self.init(node: .quantification(.oneOrMore, behavior.astKind, component.regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.oneOrMore, kind, component.regex.root))
   }
 }
 
 extension OneOrMore {
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, Component: RegexComponent>(
-    _ behavior: QuantificationBehavior = .eagerly,
+    _ behavior: QuantificationBehavior? = nil,
     @RegexComponentBuilder _ component: () -> Component
   ) where Output == (Substring, C0, C1, C2, C3, C4, C5, C6, C7), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
-    self.init(node: .quantification(.oneOrMore, behavior.astKind, component().regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.oneOrMore, kind, component().regex.root))
   }
 }
 
@@ -1342,7 +1396,7 @@ extension Repeat {
   ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
     assert(count > 0, "Must specify a positive count")
     // TODO: Emit a warning about `repeatMatch(count: 0)` or `repeatMatch(count: 1)`
-    self.init(node: .quantification(.exactly(.init(faking: count)), .eager, component.regex.root))
+    self.init(node: .quantification(.exactly(.init(faking: count)), .default, component.regex.root))
   }
 
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, Component: RegexComponent>(
@@ -1351,20 +1405,20 @@ extension Repeat {
   ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
     assert(count > 0, "Must specify a positive count")
     // TODO: Emit a warning about `repeatMatch(count: 0)` or `repeatMatch(count: 1)`
-    self.init(node: .quantification(.exactly(.init(faking: count)), .eager, component().regex.root))
+    self.init(node: .quantification(.exactly(.init(faking: count)), .default, component().regex.root))
   }
 
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, Component: RegexComponent, R: RangeExpression>(
     _ component: Component,
     _ expression: R,
-    _ behavior: QuantificationBehavior = .eagerly
+    _ behavior: QuantificationBehavior? = nil
   ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7), R.Bound == Int {
     self.init(node: .repeating(expression.relative(to: 0..<Int.max), behavior, component.regex.root))
   }
 
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, Component: RegexComponent, R: RangeExpression>(
     _ expression: R,
-    _ behavior: QuantificationBehavior = .eagerly,
+    _ behavior: QuantificationBehavior? = nil,
     @RegexComponentBuilder _ component: () -> Component
   ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7), R.Bound == Int {
     self.init(node: .repeating(expression.relative(to: 0..<Int.max), behavior, component().regex.root))
@@ -1373,18 +1427,20 @@ extension Repeat {
 extension Optionally {
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, Component: RegexComponent>(
     _ component: Component,
-    _ behavior: QuantificationBehavior = .eagerly
+    _ behavior: QuantificationBehavior? = nil
   ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
-    self.init(node: .quantification(.zeroOrOne, behavior.astKind, component.regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.zeroOrOne, kind, component.regex.root))
   }
 }
 
 extension Optionally {
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, Component: RegexComponent>(
-    _ behavior: QuantificationBehavior = .eagerly,
+    _ behavior: QuantificationBehavior? = nil,
     @RegexComponentBuilder _ component: () -> Component
   ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
-    self.init(node: .quantification(.zeroOrOne, behavior.astKind, component().regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.zeroOrOne, kind, component().regex.root))
   }
 }
 
@@ -1392,24 +1448,26 @@ extension RegexComponentBuilder {
   public static func buildLimitedAvailability<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, Component: RegexComponent>(
     _ component: Component
   ) -> Regex<(Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?)> where Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
-    .init(node: .quantification(.zeroOrOne, .eager, component.regex.root))
+    .init(node: .quantification(.zeroOrOne, .default, component.regex.root))
   }
 }
 extension ZeroOrMore {
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, Component: RegexComponent>(
     _ component: Component,
-    _ behavior: QuantificationBehavior = .eagerly
+    _ behavior: QuantificationBehavior? = nil
   ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
-    self.init(node: .quantification(.zeroOrMore, behavior.astKind, component.regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.zeroOrMore, kind, component.regex.root))
   }
 }
 
 extension ZeroOrMore {
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, Component: RegexComponent>(
-    _ behavior: QuantificationBehavior = .eagerly,
+    _ behavior: QuantificationBehavior? = nil,
     @RegexComponentBuilder _ component: () -> Component
   ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
-    self.init(node: .quantification(.zeroOrMore, behavior.astKind, component().regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.zeroOrMore, kind, component().regex.root))
   }
 }
 
@@ -1417,18 +1475,20 @@ extension ZeroOrMore {
 extension OneOrMore {
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, Component: RegexComponent>(
     _ component: Component,
-    _ behavior: QuantificationBehavior = .eagerly
+    _ behavior: QuantificationBehavior? = nil
   ) where Output == (Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
-    self.init(node: .quantification(.oneOrMore, behavior.astKind, component.regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.oneOrMore, kind, component.regex.root))
   }
 }
 
 extension OneOrMore {
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, Component: RegexComponent>(
-    _ behavior: QuantificationBehavior = .eagerly,
+    _ behavior: QuantificationBehavior? = nil,
     @RegexComponentBuilder _ component: () -> Component
   ) where Output == (Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
-    self.init(node: .quantification(.oneOrMore, behavior.astKind, component().regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.oneOrMore, kind, component().regex.root))
   }
 }
 
@@ -1440,7 +1500,7 @@ extension Repeat {
   ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
     assert(count > 0, "Must specify a positive count")
     // TODO: Emit a warning about `repeatMatch(count: 0)` or `repeatMatch(count: 1)`
-    self.init(node: .quantification(.exactly(.init(faking: count)), .eager, component.regex.root))
+    self.init(node: .quantification(.exactly(.init(faking: count)), .default, component.regex.root))
   }
 
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, Component: RegexComponent>(
@@ -1449,20 +1509,20 @@ extension Repeat {
   ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
     assert(count > 0, "Must specify a positive count")
     // TODO: Emit a warning about `repeatMatch(count: 0)` or `repeatMatch(count: 1)`
-    self.init(node: .quantification(.exactly(.init(faking: count)), .eager, component().regex.root))
+    self.init(node: .quantification(.exactly(.init(faking: count)), .default, component().regex.root))
   }
 
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, Component: RegexComponent, R: RangeExpression>(
     _ component: Component,
     _ expression: R,
-    _ behavior: QuantificationBehavior = .eagerly
+    _ behavior: QuantificationBehavior? = nil
   ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8), R.Bound == Int {
     self.init(node: .repeating(expression.relative(to: 0..<Int.max), behavior, component.regex.root))
   }
 
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, Component: RegexComponent, R: RangeExpression>(
     _ expression: R,
-    _ behavior: QuantificationBehavior = .eagerly,
+    _ behavior: QuantificationBehavior? = nil,
     @RegexComponentBuilder _ component: () -> Component
   ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8), R.Bound == Int {
     self.init(node: .repeating(expression.relative(to: 0..<Int.max), behavior, component().regex.root))
@@ -1471,18 +1531,20 @@ extension Repeat {
 extension Optionally {
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, Component: RegexComponent>(
     _ component: Component,
-    _ behavior: QuantificationBehavior = .eagerly
+    _ behavior: QuantificationBehavior? = nil
   ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?, C9?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
-    self.init(node: .quantification(.zeroOrOne, behavior.astKind, component.regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.zeroOrOne, kind, component.regex.root))
   }
 }
 
 extension Optionally {
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, Component: RegexComponent>(
-    _ behavior: QuantificationBehavior = .eagerly,
+    _ behavior: QuantificationBehavior? = nil,
     @RegexComponentBuilder _ component: () -> Component
   ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?, C9?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
-    self.init(node: .quantification(.zeroOrOne, behavior.astKind, component().regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.zeroOrOne, kind, component().regex.root))
   }
 }
 
@@ -1490,24 +1552,26 @@ extension RegexComponentBuilder {
   public static func buildLimitedAvailability<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, Component: RegexComponent>(
     _ component: Component
   ) -> Regex<(Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?, C9?)> where Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
-    .init(node: .quantification(.zeroOrOne, .eager, component.regex.root))
+    .init(node: .quantification(.zeroOrOne, .default, component.regex.root))
   }
 }
 extension ZeroOrMore {
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, Component: RegexComponent>(
     _ component: Component,
-    _ behavior: QuantificationBehavior = .eagerly
+    _ behavior: QuantificationBehavior? = nil
   ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?, C9?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
-    self.init(node: .quantification(.zeroOrMore, behavior.astKind, component.regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.zeroOrMore, kind, component.regex.root))
   }
 }
 
 extension ZeroOrMore {
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, Component: RegexComponent>(
-    _ behavior: QuantificationBehavior = .eagerly,
+    _ behavior: QuantificationBehavior? = nil,
     @RegexComponentBuilder _ component: () -> Component
   ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?, C9?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
-    self.init(node: .quantification(.zeroOrMore, behavior.astKind, component().regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.zeroOrMore, kind, component().regex.root))
   }
 }
 
@@ -1515,18 +1579,20 @@ extension ZeroOrMore {
 extension OneOrMore {
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, Component: RegexComponent>(
     _ component: Component,
-    _ behavior: QuantificationBehavior = .eagerly
+    _ behavior: QuantificationBehavior? = nil
   ) where Output == (Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
-    self.init(node: .quantification(.oneOrMore, behavior.astKind, component.regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.oneOrMore, kind, component.regex.root))
   }
 }
 
 extension OneOrMore {
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, Component: RegexComponent>(
-    _ behavior: QuantificationBehavior = .eagerly,
+    _ behavior: QuantificationBehavior? = nil,
     @RegexComponentBuilder _ component: () -> Component
   ) where Output == (Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
-    self.init(node: .quantification(.oneOrMore, behavior.astKind, component().regex.root))
+    let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+    self.init(node: .quantification(.oneOrMore, kind, component().regex.root))
   }
 }
 
@@ -1538,7 +1604,7 @@ extension Repeat {
   ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?, C9?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
     assert(count > 0, "Must specify a positive count")
     // TODO: Emit a warning about `repeatMatch(count: 0)` or `repeatMatch(count: 1)`
-    self.init(node: .quantification(.exactly(.init(faking: count)), .eager, component.regex.root))
+    self.init(node: .quantification(.exactly(.init(faking: count)), .default, component.regex.root))
   }
 
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, Component: RegexComponent>(
@@ -1547,20 +1613,20 @@ extension Repeat {
   ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?, C9?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
     assert(count > 0, "Must specify a positive count")
     // TODO: Emit a warning about `repeatMatch(count: 0)` or `repeatMatch(count: 1)`
-    self.init(node: .quantification(.exactly(.init(faking: count)), .eager, component().regex.root))
+    self.init(node: .quantification(.exactly(.init(faking: count)), .default, component().regex.root))
   }
 
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, Component: RegexComponent, R: RangeExpression>(
     _ component: Component,
     _ expression: R,
-    _ behavior: QuantificationBehavior = .eagerly
+    _ behavior: QuantificationBehavior? = nil
   ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?, C9?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9), R.Bound == Int {
     self.init(node: .repeating(expression.relative(to: 0..<Int.max), behavior, component.regex.root))
   }
 
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, Component: RegexComponent, R: RangeExpression>(
     _ expression: R,
-    _ behavior: QuantificationBehavior = .eagerly,
+    _ behavior: QuantificationBehavior? = nil,
     @RegexComponentBuilder _ component: () -> Component
   ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?, C9?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9), R.Bound == Int {
     self.init(node: .repeating(expression.relative(to: 0..<Int.max), behavior, component().regex.root))
diff --git a/Sources/VariadicsGenerator/VariadicsGenerator.swift b/Sources/VariadicsGenerator/VariadicsGenerator.swift
index 5fbd2bf2d..d4812172c 100644
--- a/Sources/VariadicsGenerator/VariadicsGenerator.swift
+++ b/Sources/VariadicsGenerator/VariadicsGenerator.swift
@@ -371,19 +371,21 @@ struct VariadicsGenerator: ParsableCommand {
         \(params.disfavored)\
         public init<\(params.genericParams)>(
           _ component: Component,
-          _ behavior: QuantificationBehavior = .eagerly
+          _ behavior: QuantificationBehavior? = nil
         ) \(params.whereClauseForInit) {
-          self.init(node: .quantification(.\(kind.astQuantifierAmount), behavior.astKind, component.regex.root))
+          let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+          self.init(node: .quantification(.\(kind.astQuantifierAmount), kind, component.regex.root))
         }
       }
 
       extension \(kind.rawValue) {
         \(params.disfavored)\
         public init<\(params.genericParams)>(
-          _ behavior: QuantificationBehavior = .eagerly,
+          _ behavior: QuantificationBehavior? = nil,
           @\(concatBuilderName) _ component: () -> Component
         ) \(params.whereClauseForInit) {
-          self.init(node: .quantification(.\(kind.astQuantifierAmount), behavior.astKind, component().regex.root))
+          let kind: DSLTree.QuantificationKind = behavior.map { .explicit($0.astKind) } ?? .default
+          self.init(node: .quantification(.\(kind.astQuantifierAmount), kind, component().regex.root))
         }
       }
 
@@ -393,7 +395,7 @@ struct VariadicsGenerator: ParsableCommand {
           public static func buildLimitedAvailability<\(params.genericParams)>(
             _ component: Component
           ) -> \(regexTypeName)<\(params.matchType)> \(params.whereClause) {
-            .init(node: .quantification(.\(kind.astQuantifierAmount), .eager, component.regex.root))
+            .init(node: .quantification(.\(kind.astQuantifierAmount), .default, component.regex.root))
           }
         }
         """ : "")
@@ -471,7 +473,7 @@ struct VariadicsGenerator: ParsableCommand {
         ) \(params.whereClauseForInit) {
           assert(count > 0, "Must specify a positive count")
           // TODO: Emit a warning about `repeatMatch(count: 0)` or `repeatMatch(count: 1)`
-          self.init(node: .quantification(.exactly(.init(faking: count)), .eager, component.regex.root))
+          self.init(node: .quantification(.exactly(.init(faking: count)), .default, component.regex.root))
         }
 
         \(params.disfavored)\
@@ -481,14 +483,14 @@ struct VariadicsGenerator: ParsableCommand {
         ) \(params.whereClauseForInit) {
           assert(count > 0, "Must specify a positive count")
           // TODO: Emit a warning about `repeatMatch(count: 0)` or `repeatMatch(count: 1)`
-          self.init(node: .quantification(.exactly(.init(faking: count)), .eager, component().regex.root))
+          self.init(node: .quantification(.exactly(.init(faking: count)), .default, component().regex.root))
         }
 
         \(params.disfavored)\
         public init<\(params.genericParams), R: RangeExpression>(
           _ component: Component,
           _ expression: R,
-          _ behavior: QuantificationBehavior = .eagerly
+          _ behavior: QuantificationBehavior? = nil
         ) \(params.repeatingWhereClause) {
           self.init(node: .repeating(expression.relative(to: 0..<Int.max), behavior, component.regex.root))
         }
@@ -496,7 +498,7 @@ struct VariadicsGenerator: ParsableCommand {
         \(params.disfavored)\
         public init<\(params.genericParams), R: RangeExpression>(
           _ expression: R,
-          _ behavior: QuantificationBehavior = .eagerly,
+          _ behavior: QuantificationBehavior? = nil,
           @\(concatBuilderName) _ component: () -> Component
         ) \(params.repeatingWhereClause) {
           self.init(node: .repeating(expression.relative(to: 0..<Int.max), behavior, component().regex.root))
diff --git a/Sources/_StringProcessing/ByteCodeGen.swift b/Sources/_StringProcessing/ByteCodeGen.swift
index 70233cf4f..45e111b5e 100644
--- a/Sources/_StringProcessing/ByteCodeGen.swift
+++ b/Sources/_StringProcessing/ByteCodeGen.swift
@@ -359,10 +359,20 @@ extension Compiler.ByteCodeGen {
 
   mutating func emitQuantification(
     _ amount: AST.Quantification.Amount,
-    _ kind: AST.Quantification.Kind,
+    _ kind: DSLTree.QuantificationKind,
     _ child: DSLTree.Node
   ) throws {
-    let kind = kind.applying(options)
+    let updatedKind: AST.Quantification.Kind
+    switch kind {
+    case .explicit(let kind):
+      updatedKind = kind
+    case .syntax(let kind):
+      updatedKind = kind.applying(options)
+    case .default:
+      updatedKind = options.isReluctantByDefault
+        ? .reluctant
+        : .eager
+    }
 
     let (low, high) = amount.bounds
     switch (low, high) {
@@ -491,7 +501,7 @@ extension Compiler.ByteCodeGen {
     }
 
     // Set up a dummy save point for possessive to update
-    if kind == .possessive {
+    if updatedKind == .possessive {
       builder.pushEmptySavePoint()
     }
 
@@ -537,7 +547,7 @@ extension Compiler.ByteCodeGen {
         to: exit, ifZeroElseDecrement: extraTripsReg!)
     }
 
-    switch kind {
+    switch updatedKind {
     case .eager:
       builder.buildSplit(to: loopBody, saving: exit)
     case .possessive:
diff --git a/Sources/_StringProcessing/PrintAsPattern.swift b/Sources/_StringProcessing/PrintAsPattern.swift
index 1998aa75b..5b9b5ee38 100644
--- a/Sources/_StringProcessing/PrintAsPattern.swift
+++ b/Sources/_StringProcessing/PrintAsPattern.swift
@@ -391,3 +391,14 @@ extension AST.Quantification.Kind {
     }
   }
 }
+
+extension DSLTree.QuantificationKind {
+  var _patternBase: String {
+    switch self {
+    case .explicit(let kind), .syntax(let kind):
+      return kind._patternBase
+    case .default:
+      return ".eager"
+    }
+  }
+}
diff --git a/Sources/_StringProcessing/Regex/ASTConversion.swift b/Sources/_StringProcessing/Regex/ASTConversion.swift
index f773bd275..c61cb074c 100644
--- a/Sources/_StringProcessing/Regex/ASTConversion.swift
+++ b/Sources/_StringProcessing/Regex/ASTConversion.swift
@@ -123,7 +123,7 @@ extension AST.Node {
       case let .quantification(v):
         let child = v.child.dslTreeNode
         return .quantification(
-          v.amount.value, v.kind.value, child)
+          v.amount.value, .syntax(v.kind.value), child)
 
       case let .quote(v):
         return .quotedLiteral(v.literal)
diff --git a/Sources/_StringProcessing/Regex/DSLTree.swift b/Sources/_StringProcessing/Regex/DSLTree.swift
index f37505cb4..b9ebdfd21 100644
--- a/Sources/_StringProcessing/Regex/DSLTree.swift
+++ b/Sources/_StringProcessing/Regex/DSLTree.swift
@@ -56,7 +56,7 @@ extension DSLTree {
 
     case quantification(
       AST.Quantification.Amount,
-      AST.Quantification.Kind,
+      QuantificationKind,
       Node)
 
     case customCharacterClass(CustomCharacterClass)
@@ -103,6 +103,16 @@ extension DSLTree {
 }
 
 extension DSLTree {
+  @_spi(RegexBuilder)
+  public enum QuantificationKind {
+    /// The default quantification kind, as set by options.
+    case `default`
+    /// An explicitly chosen kind, overriding any options.
+    case explicit(AST.Quantification.Kind)
+    /// A kind set via syntax, which can be affected by options.
+    case syntax(AST.Quantification.Kind)
+  }
+  
   @_spi(RegexBuilder)
   public struct CustomCharacterClass {
     var members: [Member]
diff --git a/Sources/_StringProcessing/Regex/Options.swift b/Sources/_StringProcessing/Regex/Options.swift
index 38fba02d6..47339c7b7 100644
--- a/Sources/_StringProcessing/Regex/Options.swift
+++ b/Sources/_StringProcessing/Regex/Options.swift
@@ -58,6 +58,32 @@ extension RegexComponent {
     wrapInOption(.singleLine, addingIf: dotMatchesNewlines)
   }
   
+  /// Returns a regular expression where the start and end of input
+  /// anchors (`^` and `$`) also match against the start and end of a line.
+  ///
+  /// This method corresponds to applying the `m` option in a regular
+  /// expression literal. For this behavior in the `RegexBuilder` syntax, see
+  /// ``Anchor.startOfLine``, ``Anchor.endOfLine``, ``Anchor.startOfInput``,
+  /// and ``Anchor.endOfInput``.
+  ///
+  /// - 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> {
+    wrapInOption(.multiline, addingIf: matchLineEndings)
+  }
+  
+  /// Returns a regular expression where quantifiers are reluctant by default
+  /// instead of eager.
+  ///
+  /// This method corresponds to applying the `U` option in a regular
+  /// expression literal.
+  ///
+  /// - Parameter useReluctantQuantifiers: A Boolean value indicating whether
+  ///   quantifiers should be reluctant by default.
+  public func reluctantQuantifiers(_ useReluctantQuantifiers: Bool = true) -> Regex<Output> {
+    wrapInOption(.reluctantByDefault, addingIf: useReluctantQuantifiers)
+  }
+
   /// Returns a regular expression that matches with the specified semantic
   /// level.
   ///
@@ -126,38 +152,6 @@ public struct RegexSemanticLevel: Hashable {
   }
 }
 
-// Options that only affect literals
-extension RegexComponent {
-  /// Returns a regular expression where the start and end of input
-  /// anchors (`^` and `$`) also match against the start and end of a line.
-  ///
-  /// This method corresponds to applying the `m` option in a regular
-  /// expression literal, and only applies to regular expressions specified as
-  /// literals. For this behavior in the `RegexBuilder` syntax, see
-  /// ``Anchor.startOfLine``, ``Anchor.endOfLine``, ``Anchor.startOfInput``,
-  /// and ``Anchor.endOfInput``.
-  ///
-  /// - 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> {
-    wrapInOption(.multiline, addingIf: matchLineEndings)
-  }
-  
-  /// Returns a regular expression where quantifiers are reluctant by default
-  /// instead of eager.
-  ///
-  /// This method corresponds to applying the `U` option in a regular
-  /// expression literal, and only applies to regular expressions specified as
-  /// literals. In the `RegexBuilder` syntax, pass a ``QuantificationBehavior``
-  /// value to any quantification method to change its behavior.
-  ///
-  /// - Parameter useReluctantCaptures: A Boolean value indicating whether
-  ///   quantifiers should be reluctant by default.
-  public func reluctantCaptures(_ useReluctantCaptures: Bool = true) -> Regex<Output> {
-    wrapInOption(.reluctantByDefault, addingIf: useReluctantCaptures)
-  }
-}
-
 // MARK: - Helper method
 extension RegexComponent {
   fileprivate func wrapInOption(
diff --git a/Tests/RegexBuilderTests/RegexDSLTests.swift b/Tests/RegexBuilderTests/RegexDSLTests.swift
index 0c0bf7c8f..e80990ee1 100644
--- a/Tests/RegexBuilderTests/RegexDSLTests.swift
+++ b/Tests/RegexBuilderTests/RegexDSLTests.swift
@@ -262,6 +262,24 @@ class RegexDSLTests: XCTestCase {
         }
         .ignoringCase(false)
       }
+    
+    try _testDSLCaptures(
+      ("abcdef123", ("abcdef123", "a", "123")),
+      matchType: (Substring, Substring, Substring).self, ==) {
+        Capture {
+          // Reluctant behavior due to option
+          OneOrMore(.anyOf("abcd"))
+            .reluctantQuantifiers()
+        }
+        ZeroOrMore("a"..."z")
+        
+        Capture {
+          // Eager behavior due to explicit parameter, despite option
+          OneOrMore(.digit, .eagerly)
+            .reluctantQuantifiers()
+        }
+        ZeroOrMore(.digit)
+      }
   }
   
   func testQuantificationBehavior() throws {
@@ -293,7 +311,7 @@ class RegexDSLTests: XCTestCase {
           OneOrMore(.word)
           Capture(.digit)
           ZeroOrMore(.any)
-        }.reluctantCaptures()
+        }.reluctantQuantifiers()
       }
     }
 #endif