Create Prototypes target for our prototypes

Author: milseman

Package.swift

@@ -11,8 +11,8 @@ let package = Package(
             name: "_StringProcessing",
             targets: ["_StringProcessing"]),
         .library(
-            name: "PEG",
-            targets: ["PEG"]),
+            name: "Prototypes",
+            targets: ["Prototypes"]),
         .library(
             name: "_MatchingEngine",
             targets: ["_MatchingEngine"]),
@@ -45,20 +45,17 @@ let package = Package(
             name: "RegexDSLTests",
             dependencies: ["_StringProcessing"]),
         .target(
-            name: "PEG",
+            name: "Prototypes",
             dependencies: ["_MatchingEngine"]),
         .testTarget(
             name: "PEGTests",
-            dependencies: ["PEG"]),
-        .target(
-            name: "PTCaRet",
-            dependencies: ["_MatchingEngine"]),
+            dependencies: ["Prototypes"]),
         .testTarget(
             name: "PTCaRetTests",
-            dependencies: ["PTCaRet"]),
+            dependencies: ["Prototypes"]),
         .target(
             name: "Algorithms",
-            dependencies: ["_StringProcessing", "PEG"]),
+            dependencies: ["_StringProcessing", "Prototypes"]),
         .testTarget(
             name: "AlgorithmsTests",
             dependencies: ["Algorithms"]),
@@ -73,12 +70,10 @@ let package = Package(
         // MARK: Exercises
         .target(
           name: "Exercises",
-          dependencies: ["_MatchingEngine", "PEG", "PTCaRet", "_StringProcessing"]),
+          dependencies: ["_MatchingEngine", "Prototypes", "_StringProcessing"]),
         .testTarget(
           name: "ExercisesTests",
           dependencies: ["Exercises"]),
-
-
     ]
 )
 

Sources/Exercises/Participants/PEGParticipant.swift

@@ -2,7 +2,7 @@ struct PEGParticipant: Participant {
   static var name: String { "PEG" }
 }
 
-import PEG
+import Prototypes
 private func graphemeBreakPropertyData(forLine line: String) -> GraphemeBreakEntry? {
   typealias Pattern = PEG<Character>.Pattern
 

Sources/Combinators/Combinators.swift renamed to Sources/Prototypes/Combinators/Combinators.swift

@@ -33,7 +33,7 @@ extension Combinators.BindElement.BindPosition.BindError {
   public struct Parser<T: Hashable> {
     let apply: (Position) throws -> ParseResult<T>
 
-    public init(_ f: @escaping (Position) throws -> ParseResult<T>) {
+    init(_ f: @escaping (Position) throws -> ParseResult<T>) {
       self.apply = f
     }
   }
@@ -88,8 +88,8 @@ extension
 
 // Combinators
 extension Combinators.BindElement.BindPosition.BindError.Parser {
-  typealias Parser = Combinators.BindElement<Element>.BindPosition<Position>.BindError<Err>.Parser
-  typealias ParseResult = Combinators.BindElement<Element>.BindPosition<Position>.BindError<Err>.ParseResult
+  public typealias Parser = Combinators.BindElement<Element>.BindPosition<Position>.BindError<Err>.Parser
+  public typealias ParseResult = Combinators.BindElement<Element>.BindPosition<Position>.BindError<Err>.ParseResult
 
   // Backtracking alternation
   public func or(_ rhs: Self) -> Self {

Sources/PEG/PEG.swift renamed to Sources/Prototypes/PEG/PEG.swift

@@ -0,0 +1,129 @@
+// MARK: - Element Consumer
+
+/// An alternate formation of consumers: Don't bind collection type as we're just
+/// consuming elements by classification or literal sequencing.
+protocol ElementConsumer {
+  associatedtype Element
+  func consume<C: Collection>(
+    _ c: C, in: Range<C.Index>
+  ) -> C.Index? where C.Element == Element
+}
+
+protocol CharacterConsumer: ElementConsumer
+where Element == Character { }
+
+protocol ScalarConsumer: ElementConsumer
+where Element == Unicode.Scalar { }
+
+protocol UTF8Consumer: ElementConsumer
+where Element == UInt8 { }
+
+protocol UTF16Consumer: ElementConsumer
+where Element == UInt16 { }
+
+// struct ...LiteralSequence: ...Consumer { ... }
+
+// MARK: - Element Classes
+
+protocol ElementClass: ElementConsumer {
+  func contains(_ e: Element) -> Bool
+}
+extension ElementClass {
+  func consume<C: Collection>(
+    _ c: C, in range: Range<C.Index>
+  ) -> C.Index? where C.Element == Element {
+    // FIXME: empty ranges, etc...
+    let lower = range.lowerBound
+    return contains(c[lower]) ? c.index(after: lower) : nil
+  }
+}
+
+protocol ScalarClass: ElementClass, ScalarConsumer {}
+protocol CharacterClass: ElementClass, CharacterConsumer {}
+
+// MARK: Granularity adapters
+
+/// Any higher-granularity consumer can be a lower-granularity
+/// consumer by just consuming at its higher-granularity
+struct _CharacterToScalar <
+  Characters: CharacterConsumer
+>: ScalarConsumer {
+  var characters: Characters
+
+  func consume<C: Collection>(
+    _ c: C, in range: Range<C.Index>
+  ) -> C.Index? where C.Element == Unicode.Scalar {
+    let str = String(c)
+    let r = c.convertByOffset(range, in: str)
+    guard let idx = characters.consume(str, in: r) else {
+      return nil
+    }
+
+    return str.convertByOffset(idx, in: c)
+  }
+}
+// ...
+
+/// Any lower-granularity consumer can be a higher
+/// granularity consumer by checking if the result falls on a
+/// boundary.
+struct _ScalarToCharacter <
+  Scalars: ScalarConsumer
+>: CharacterConsumer {
+  var scalars: Scalars
+
+  func _consume(
+    _ str: String, in range: Range<String.Index>
+  ) -> String.Index? {
+    guard let idx = scalars.consume(str.unicodeScalars, in: range),
+          str.isOnGraphemeClusterBoundary(idx)
+    else {
+      return nil
+    }
+    return idx
+  }
+
+  func consume<C: Collection>(
+    _ c: C, in range: Range<C.Index>
+  ) -> C.Index? where C.Element == Character {
+    let str = String(c)
+    let r = c.convertByOffset(range, in: str)
+
+    guard let idx = _consume(str, in: r) else {
+      return nil
+    }
+    return str.convertByOffset(idx, in: c)
+  }
+}
+
+/// Any lower-granularity class can be a higher-granularity
+/// class if we choose a semantic-extension style
+struct _FirstScalarCharacters<
+  Scalars: ScalarClass
+>: CharacterClass {
+  var scalars: Scalars
+  func contains(_ c: Character) -> Bool {
+    scalars.contains(c.unicodeScalars.first!)
+  }
+}
+struct _SingleScalarCharacters<
+  Scalars: ScalarClass
+>: CharacterClass {
+  var scalars: Scalars
+  func contains(_ c: Character) -> Bool {
+    let scs = c.unicodeScalars
+    return scs.count == 1 && scalars.contains(scs.first!)
+  }
+  // NOTE: This would be equivalent to _ScalarToCharacter
+  // for any scalar consumer that consumes only one scalar
+  // at a time.
+}
+struct _AllScalarCharacters<
+  Scalars: ScalarClass
+>: CharacterClass {
+  var scalars: Scalars
+  func contains(_ c: Character) -> Bool {
+    c.unicodeScalars.allSatisfy(scalars.contains)
+  }
+}
+

Sources/PEG/PEGCode.swift renamed to Sources/Prototypes/PEG/PEGCode.swift

@@ -0,0 +1,143 @@
+// MARK: - Pitched Compiler/library interface
+
+/// Conform to this to support regex literals
+protocol ExpressibleByRegexLiteral {
+  associatedtype Builder: RegexLiteralBuilderProtocol
+  init(builder: Builder)
+}
+
+/// Builder conforms to this for compiler-library API
+protocol RegexLiteralBuilderProtocol {
+  /// Opaquely identify something built
+  associatedtype ASTNodeId = UInt
+
+  /// NOTE: This will likely not be a requirement but could be ad-hoc name lookup
+  mutating func buildCharacterClass_d() -> ASTNodeId
+
+  /// Any post-processing or partial compilation
+  ///
+  /// NOTE: we might want to make this `throws`, capable of communicating
+  /// compilation failure if conformer is constant evaluable.
+  mutating func finalize()
+}
+
+/*
+
+ TODO: We will probably want defaulting mechanisms, such as:
+
+ * Ability for a conformer to take a meta-character as
+   just an escaped character
+ * Ability for a conformer to use function decls for feature
+   set communication alone, and have default impl build just
+   echo the string for an engine
+
+ */
+
+// MARK: - Semantic levels
+
+/// Dynamic notion of a specified semantics level for a regex
+enum SemanticsLevel {
+  case graphemeCluster
+  case scalar
+  case posix // different than ASCII?
+  // ... code units ...
+}
+
+/// Conformers can be ran as a regex / pattern
+protocol RegexProtocol {
+  var level: SemanticsLevel? { get }
+}
+
+/// Provide the option to encode semantic level statically
+protocol RegexLiteralProtocol: ExpressibleByRegexLiteral {
+  associatedtype ScalarSemanticRegex: RegexProtocol
+  associatedtype GraphemeSemanticRegex: RegexProtocol
+  associatedtype POSIXSemanticRegex: RegexProtocol
+  associatedtype UnspecifiedSemanticRegex: RegexProtocol = RegexLiteral
+
+  var scalarSemantic: ScalarSemanticRegex { get }
+  var graphemeSemantic: GraphemeSemanticRegex { get }
+  var posixSemantic: POSIXSemanticRegex { get }
+}
+
+// MARK: - Statically encoded semantic level
+
+/// A regex that has statically  bound its semantic level
+struct StaticSemanticRegexLiteral: RegexLiteralProtocol {
+  /*
+   If we had values in type-parameter position, this would be
+   far easier and more straight-forward to model.
+
+   RegexLiteral<SemanticsLevel? = nil>
+
+   */
+
+  /// A regex that has statically  bound its semantic level
+  struct ScalarSemanticRegex: RegexProtocol {
+    var level: SemanticsLevel? { .scalar }
+  }
+  struct GraphemeSemanticRegex: RegexProtocol {
+    var level: SemanticsLevel? { .graphemeCluster }
+  }
+  struct POSIXSemanticRegex: RegexProtocol {
+    var level: SemanticsLevel? { .posix }
+  }
+  struct UnspecifiedSemanticRegex: RegexProtocol {
+    var level: SemanticsLevel? { nil }
+  }
+
+  var scalarSemantic: ScalarSemanticRegex { x() }
+  var graphemeSemantic: GraphemeSemanticRegex { x() }
+  var posixSemantic: POSIXSemanticRegex { x() }
+
+  init(builder: RegexLiteralBuilder) { }
+
+  typealias Builder = RegexLiteralBuilder
+}
+
+// MARK: - stdlib conformer
+
+/// Stdlib's conformer
+struct RegexLiteralBuilder: RegexLiteralBuilderProtocol {
+  /// Compiler converts literal into a series of calls to this kind of method
+  mutating func buildCharacterClass_d() -> ASTNodeId { x() }
+
+  /// We're done, so partially-compile or otherwise finalize
+  mutating func finalize() { }
+}
+
+
+/// The produced value for a regex literal. Might end up being same type as
+/// `Regex` or `Pattern`, but for now useful to model independently.
+struct RegexLiteral: ExpressibleByRegexLiteral {
+  typealias Builder = RegexLiteralBuilder
+
+  /// An explicitly specified semantics level
+  var level: SemanticsLevel? = nil
+
+  init(builder: Builder) {
+    // TODO: should this be throwing, constant evaluable, or
+    // some other way to issue diagnostics?
+  }
+}
+
+extension RegexLiteral: RegexProtocol, RegexLiteralProtocol {
+  /// A regex that has finally bound its semantic level (dynamically)
+  struct BoundSemantic: RegexProtocol {
+    var _level: SemanticsLevel // Bound semantic level
+    var level: SemanticsLevel? { _level }
+  }
+  private func sem(_ level: SemanticsLevel) -> BoundSemantic {
+    x()
+  }
+
+  var scalarSemantic: BoundSemantic { sem(.scalar) }
+  var graphemeSemantic: BoundSemantic { sem(.graphemeCluster) }
+  var posixSemantic: BoundSemantic { sem(.posix) }
+
+}
+
+
+// ---
+
+internal func x() -> Never { fatalError() }

Sources/PEG/PEGCompile.swift renamed to Sources/Prototypes/PEG/PEGCompile.swift

@@ -1,5 +1,5 @@
 import XCTest
-@testable import PEG
+@testable import Prototypes
 import _MatchingEngine
 
 // Make examples more sane. Need builder

Sources/PEG/PEGCore.swift renamed to Sources/Prototypes/PEG/PEGCore.swift

@@ -1,5 +1,5 @@
 import XCTest
-@testable import PTCaRet
+@testable import Prototypes
 import _MatchingEngine
 
 enum Event: UInt64, Hashable {