delete stuff

Author: milseman

Sources/_RegexParser/Regex/Parse/CaptureList.swift

@@ -139,16 +139,3 @@ extension CaptureList.Capture {
     return base
   }
 }
-
-/*
- Let's replace this now
-
- We want literals to produce 1-level deep optional tops
- We want DSL tree to...
-
- Cap structure should be an array of explicit captures present, which
- may have a name, an optional depth counter, and an optional type
-
-
-
-*/

Sources/_RegexParser/Regex/Parse/CaptureStructure.swift

@@ -24,169 +24,6 @@ public enum CaptureStructure: Equatable {
   }
 }
 
-// TODO: Below are all flattening constructors. Instead create
-// a builder/visitor that can store the structuralization
-// approach
-
-extension CaptureStructure {
-  public struct Constructor {
-    var strategy: Strategy
-
-    public init(_ strategy: Strategy = .flatten) {
-      guard strategy == .flatten else {
-        fatalError("TODO: adjust creator methods")
-      }
-      self.strategy = strategy
-    }
-  }
-}
-
-extension CaptureStructure.Constructor {
-  public mutating func alternating<C: Collection>(
-    _ children: C
-  ) -> CaptureStructure where C.Element: _TreeNode {
-    return children.map {
-      $0._captureStructure(&self)
-    }.reduce(.empty, +)
-     .map(CaptureStructure.optional)
-  }
-  public mutating func concatenating<C: Collection>(
-    _ children: C
-  ) -> CaptureStructure where C.Element: _TreeNode {
-    return children.map {
-      $0._captureStructure(&self)
-    }.reduce(.empty, +)
-  }
-
-  public mutating func grouping<T: _TreeNode>(
-    _ child: T,
-    as kind: AST.Group.Kind
-  ) -> CaptureStructure {
-    switch kind {
-    case .capture:
-      return capturing(child)
-    case .namedCapture(let name):
-      return capturing(name: name.value, child)
-    case .balancedCapture(let b):
-      return capturing(name: b.name?.value, child)
-    default:
-      precondition(!kind.isCapturing)
-      return child._captureStructure(&self)
-    }
-  }
-
-  public mutating func capturing<T: _TreeNode>(
-    name: String? = nil,
-    _ child: T,
-    withType type: AnyType? = nil
-  ) -> CaptureStructure {
-    .atom(name: name, type: type)
-      + child._captureStructure(&self)
-  }
-
-  // TODO: We'll likely want/need a generalization of
-  // conditional's condition kind.
-  public mutating func condition<T: _TreeNode>(
-    _ condition: AST.Conditional.Condition.Kind,
-    trueBranch: T,
-    falseBranch: T
-  ) -> CaptureStructure {
-    // A conditional's capture structure is effectively that of an alternation
-    // between the true and false branches. However the condition may also
-    // have captures in the case of a group condition.
-    var captures = CaptureStructure.empty
-    switch condition {
-    case .group(let g):
-      captures = captures + AST.Node.group(g)._captureStructure(&self)
-    default:
-      break
-    }
-    let branchCaptures = trueBranch._captureStructure(&self) +
-                         falseBranch._captureStructure(&self)
-    return captures + branchCaptures.map(CaptureStructure.optional)
-  }
-
-  public mutating func quantifying<T: _TreeNode>(
-    _ child: T, amount: AST.Quantification.Amount
-  ) -> CaptureStructure {
-    let result = child._captureStructure(&self)
-    return amount.bounds.atLeast == 0
-      ? result.map(CaptureStructure.optional) : result
-  }
-
-  // TODO: Will need to adjust for DSLTree support, and
-  // "absent" isn't the best name for these.
-  public mutating func absent(
-    _ kind: AST.AbsentFunction.Kind
-  ) -> CaptureStructure {
-    // Only the child of an expression absent function is relevant, as the
-    // other expressions don't actually get matched against.
-    switch kind {
-    case .expression(_, _, let child):
-      return child._captureStructure(&self)
-    case .clearer, .repeater, .stopper:
-      return .empty
-    }
-  }
-}
-
-extension AST.Node {
-  public func _captureStructure(
-    _ constructor: inout CaptureStructure.Constructor
-  ) -> CaptureStructure {
-    guard constructor.strategy == .flatten else {
-      fatalError("TODO")
-    }
-    return _captureList._captureStructure(nestOptionals: true)
-  }
-}
-
-// MARK: - Combination and transformation
-
-extension CaptureStructure {
-  /// Returns a capture structure by concatenating any tuples in `self` and
-  /// `other`.
-  func concatenating(with other: CaptureStructure) -> CaptureStructure {
-    switch (self, other) {
-    // (T...) + (U...) ==> (T..., U...)
-    case let (.tuple(lhs), .tuple(rhs)):
-      return .tuple(lhs + rhs)
-    // T + () ==> T
-    case (_, .tuple(let rhs)) where rhs.isEmpty:
-      return self
-    // () + T ==> T
-    case (.tuple(let lhs), _) where lhs.isEmpty:
-      return other
-    // (T...) + U ==> (T..., U)
-    case let (.tuple(lhs), _):
-      return .tuple(lhs + [other])
-    // T + (U...) ==> (T, U...)
-    case let (_, .tuple(rhs)):
-      return .tuple([self] + rhs)
-    // T + U ==> (T, U)
-    default:
-      return .tuple([self, other])
-    }
-  }
-
-  static func + (
-    lhs: CaptureStructure, rhs: CaptureStructure
-  ) -> CaptureStructure {
-    lhs.concatenating(with: rhs)
-  }
-
-  /// Returns a capture structure by transforming any tuple element of `self`
-  /// or transforming `self` directly if it is not a tuple.
-  func map(
-    _ transform: (CaptureStructure) -> CaptureStructure
-  ) -> CaptureStructure {
-    if case .tuple(let children) = self {
-      return .tuple(children.map(transform))
-    }
-    return transform(self)
-  }
-}
-
 // MARK: - Common properties
 
 extension CaptureStructure {
@@ -415,11 +252,3 @@ extension CaptureStructure: CustomStringConvertible {
     }
   }
 }
-
-extension CaptureStructure.Constructor {
-  public enum Strategy {
-    case flatten
-    case nest
-    // case drop(after: Int)...
-  }
-}

Sources/_RegexParser/Regex/TreeProtocols.swift

@@ -2,10 +2,6 @@
 
 public protocol _TreeNode {
   var children: [Self]? { get }
-
-  func _captureStructure(
-    _: inout CaptureStructure.Constructor
-  ) -> CaptureStructure
 }
 
 extension _TreeNode {

Sources/_StringProcessing/Regex/DSLTree.swift

@@ -345,9 +345,7 @@ extension DSLTree.Node {
 
 extension DSLTree {
   var captureStructure: CaptureStructure {
-    // TODO: nesting
-    var constructor = CaptureStructure.Constructor(.flatten)
-    return _Tree(root)._captureStructure(&constructor)
+    root._captureList._captureStructure(nestOptionals: true)
   }
 }
 extension DSLTree.Node {
@@ -538,7 +536,6 @@ extension DSLTree.Node {
     self._addCaptures(to: &list, optionalNesting: 0)
     return list
   }
-
 }
 
 extension DSLTree {
@@ -578,9 +575,7 @@ extension DSLTree {
       }
     }
 
-    func _captureStructure(
-      _ constructor: inout CaptureStructure.Constructor
-    ) -> CaptureStructure {
+    func _captureStructure() -> CaptureStructure {
       self.node._captureList._captureStructure(nestOptionals: true)
     }
   }