Support generic input

.github/workflows/Test.yml

@@ -17,6 +17,9 @@ jobs:
     steps:
     - name: Checkout
       uses: actions/checkout@v2
+    - name: Set Swift version
+      if: matrix.os == 'ubuntu-18.04'
+      run: echo "5.3-DEVELOPMENT-SNAPSHOT-2020-08-08-a" > .swift-version
     - name: Install Swift
       uses: YOCKOW/Action-setup-swift@master
     - name: Build

.swift-version

@@ -1 +1 @@
-5.2.4
+5.3

.swiftpm/xcode/xcshareddata/xcbaselines/PerformanceTests.xcbaseline/1868159C-3A7D-4BC9-A194-7BBFC5CE3264.plist

@@ -65,6 +65,13 @@
 					<key>baselineIntegrationDisplayName</key>
 					<string>7 May 2020 at 21:25:02</string>
 				</dict>
+				<key>com.apple.dt.XCTMetric_CPU.instructions_retired</key>
+				<dict>
+					<key>baselineAverage</key>
+					<real>3.9872e+06</real>
+					<key>baselineIntegrationDisplayName</key>
+					<string>Local Baseline</string>
+				</dict>
 			</dict>
 			<key>testOneOrMore()</key>
 			<dict>

Sources/Patterns/Atomic Patterns/Line.swift

@@ -5,17 +5,46 @@
 //  Created by Kåre Morstøl on 25/05/2020.
 //
 
+public protocol CharacterLike: Hashable {
+	var isNewline: Bool { get }
+}
+
+extension Character: CharacterLike {}
+extension String.UTF8View.Element: CharacterLike {
+	@inlinable
+	public var isNewline: Bool {
+		// “\n” (U+000A): LINE FEED (LF), U+000B: LINE TABULATION (VT), U+000C: FORM FEED (FF), “\r” (U+000D): CARRIAGE RETURN (CR)
+		self < 14 && self > 9
+	}
+}
+
+// U+0085: NEXT LINE (NEL), U+2028: LINE SEPARATOR, U+2029: PARAGRAPH SEPARATOR
+@usableFromInline
+let newlines = Set([0x000A as UInt16, 0x000B, 0x000C, 0x000D, 0x0085, 0x2028, 0x2029].map { Unicode.Scalar($0)! })
+
+extension String.UnicodeScalarView.Element: CharacterLike {
+	@inlinable
+	public var isNewline: Bool {
+		newlines.contains(self)
+	}
+}
+
+extension String.UTF16View.Element: CharacterLike {
+	@inlinable
+	public var isNewline: Bool {
+		Unicode.Scalar(self).map(newlines.contains(_:)) ?? false
+	}
+}
+
 /// Matches one line, not including newline characters.
-public struct Line: Pattern {
+public struct Line<Input: BidirectionalCollection>: Pattern
+	where Input.Element: CharacterLike, Input.Index == String.Index {
 	public init() {}
 
 	public var description: String { "Line()" }
 
-	public static let start = Start()
-	public static let end = End()
-
 	@inlinable
-	public func createInstructions(_ instructions: inout Instructions) throws {
+	public func createInstructions(_ instructions: inout ContiguousArray<Instruction<Input>>) throws {
 		try (Start() • Skip() • End()).createInstructions(&instructions)
 	}
 
@@ -31,7 +60,7 @@ public struct Line: Pattern {
 		}
 
 		@inlinable
-		public func createInstructions(_ instructions: inout Instructions) {
+		public func createInstructions(_ instructions: inout ContiguousArray<Instruction<Input>>) {
 			instructions.append(.checkIndex(self.parse(_:at:)))
 		}
 	}
@@ -48,8 +77,13 @@ public struct Line: Pattern {
 		}
 
 		@inlinable
-		public func createInstructions(_ instructions: inout Instructions) {
+		public func createInstructions(_ instructions: inout ContiguousArray<Instruction<Input>>) {
 			instructions.append(.checkIndex(self.parse(_:at:)))
 		}
 	}
 }
+
+extension Line where Input == String {
+	public static let start = Start()
+	public static let end = End()
+}

Sources/Patterns/Atomic Patterns/Literal.swift

@@ -10,34 +10,75 @@ import Foundation
 /// Matches a sequence of elements.
 ///
 /// If empty, it will always succeed without consuming any input.
-public struct Literal: Pattern {
+public struct Literal<Input: BidirectionalCollection>: Pattern where Input.Element: Hashable {
 	public let elements: Input
 
 	public var description: String {
-		#""\#(String(elements).replacingOccurrences(of: "\n", with: "\\n"))""#
+		#""\#(String(describing: elements).replacingOccurrences(of: "\n", with: "\\n"))""#
+	}
+
+	@inlinable
+	public init(_ input: Input) {
+		elements = input
 	}
 
 	/// Matches `sequence`.
 	@inlinable
-	public init<S: Sequence>(_ sequence: S) where S.Element == Pattern.Input.Element {
-		self.elements = Pattern.Input(sequence)
+	public init<S: Sequence>(_ sequence: S) where S.Element == Input.Element, Input == String {
+		self.elements = Input(sequence)
+	}
+
+	@inlinable
+	public func createInstructions(_ instructions: inout ContiguousArray<Instruction<Input>>) {
+		instructions.append(contentsOf: elements.map(Instruction<Input>.elementEquals))
 	}
+}
 
+extension Literal where Input == String {
 	/// Matches this character.
 	@inlinable
 	public init(_ character: Character) {
 		self.init(String(character))
 	}
+}
+
+// MARK: Create from string literal.
 
+extension Literal: ExpressibleByUnicodeScalarLiteral where Input: LosslessStringConvertible {
 	@inlinable
-	public func createInstructions(_ instructions: inout Instructions) {
-		instructions.append(contentsOf: elements.map(Instruction.elementEquals))
+	public init(unicodeScalarLiteral value: StaticString) {
+		elements = Input(String(describing: value))!
 	}
 }
 
-extension Literal: ExpressibleByStringLiteral {
+extension Literal: ExpressibleByExtendedGraphemeClusterLiteral where Input: LosslessStringConvertible {
+	public typealias ExtendedGraphemeClusterLiteralType = StaticString
+}
+
+extension Literal: ExpressibleByStringLiteral where Input: LosslessStringConvertible {
 	@inlinable
 	public init(stringLiteral value: StaticString) {
-		self.init(String(describing: value))
+		elements = Input(String(describing: value))!
+	}
+}
+
+extension String.UTF8View: LosslessStringConvertible {
+	@inlinable
+	public init?(_ description: String) {
+		self = description.utf8
+	}
+}
+
+extension String.UTF16View: LosslessStringConvertible {
+	@inlinable
+	public init?(_ description: String) {
+		self = description.utf16
+	}
+}
+
+extension String.UnicodeScalarView: LosslessStringConvertible {
+	@inlinable
+	public init?(_ description: String) {
+		self = description.unicodeScalars
 	}
 }