Remove MatchableRawRepresentable (#12)

This PR removes `MatchableRawRepresentable` in favor of `Matchable`

Author: FlickerSoul

.pre-commit-config.yaml

@@ -6,7 +6,7 @@ repos:
       - id: trailing-whitespace
         exclude: ".*\\.(html|plist)$"
       - id: end-of-file-fixer
-        exclude: ".*\\.(xcstrings|html|plist)$"
+        exclude: ".*\\.(xcstrings|html|plist|json)$"
   - repo: local
     hooks:
       - id: swiftformat

.vscode/launch.json

@@ -0,0 +1,24 @@
+{
+    "configurations": [
+        {
+            "type": "swift",
+            "request": "launch",
+            "args": [],
+            "cwd": "${workspaceFolder:BinaryParseKit}",
+            "name": "Debug BinaryParseKitClient",
+            "target": "BinaryParseKitClient",
+            "configuration": "debug",
+            "preLaunchTask": "swift: Build Debug BinaryParseKitClient"
+        },
+        {
+            "type": "swift",
+            "request": "launch",
+            "args": [],
+            "cwd": "${workspaceFolder:BinaryParseKit}",
+            "name": "Release BinaryParseKitClient",
+            "target": "BinaryParseKitClient",
+            "configuration": "release",
+            "preLaunchTask": "swift: Build Release BinaryParseKitClient"
+        }
+    ]
+}

README.md

@@ -231,11 +231,11 @@ let cmd = try Command(parsing: Data([0x01, 0x12, 0x34]))
 
 **Raw Representable Enums**
 
-For enums with raw values, conform to `MatchableRawRepresentable` (or `Matchable`):
+For enums with raw values, conform to `Matchable`:
 
 ```swift
 @ParseEnum
-enum StatusCode: UInt8, MatchableRawRepresentable {
+enum StatusCode: UInt8, Matchable {
     @match
     case success = 0x00
 
@@ -284,7 +284,7 @@ BinaryParseKit defines four parsing protocols:
 Most built-in types already conform to these protocols. For custom types, implement the appropriate protocol(s).
 
 In addition, as mentioned in the previous enum parsing section,
-`Matchable` and `MatchableRawRepresentable` is introduced to allow each case to provide bytes for matching in the process.
+`Matchable` is introduced to allow each case to provide bytes for matching in the process.
 
 ## Contributing
 

Sources/BinaryParseKit/BinaryParseKit.swift

@@ -309,16 +309,15 @@ public macro ParseEnum() = #externalMacro(
 
 /// Defines a match case using the enum's raw value without consuming bytes from the buffer.
 ///
-/// Use this macro for `MatchableRawRepresentable` enums where each case's raw value
+/// Use this macro for ``Matchable`` enums where each case's raw value
 /// serves as the match pattern. The matched bytes are NOT consumed from the buffer.
 ///
-/// - Note: This declaration can only be used when the enum conforms to ``Matchable`` (or ``MatchableRawRepresentable``)
-/// protocol.
+/// - Note: This declaration can only be used when the enum conforms to ``Matchable`` protocol.
 ///
 /// Example:
 /// ```swift
 /// @ParseEnum
-/// enum StatusCode: UInt8, MatchableRawRepresentable {
+/// enum StatusCode: UInt8, Matchable {
 ///     @match
 ///     case success = 0x00  // Matches byte 0x00 without advancing the pointer
 ///
@@ -391,17 +390,16 @@ public macro match(bytes: [UInt8]) = #externalMacro(
 
 /// Matches and consumes bytes from the buffer using the enum's raw value.
 ///
-/// Use this macro for `MatchableRawRepresentable` enums where each case's raw value
+/// Use this macro for ``Matchable`` enums where each case's raw value
 /// serves as the match pattern. The matched bytes ARE consumed from the buffer,
 /// making this suitable for cases with associated values that need to parse subsequent data.
 ///
-/// - Note: This declaration can only be used when the enum conforms to ``Matchable`` (or ``MatchableRawRepresentable``)
-/// protocol.
+/// - Note: This declaration can only be used when the enum conforms to ``Matchable`` protocol.
 ///
 /// Example:
 /// ```swift
 /// @ParseEnum
-/// enum Command: UInt8, MatchableRawRepresentable {
+/// enum Command: UInt8, Matchable {
 ///     @matchAndTake
 ///     @parse(endianness: .big)
 ///     case setValue(UInt16) = 0x01  // Matches and consumes 0x01, then parses UInt16

Sources/BinaryParseKit/BuiltInExtensions.swift

@@ -22,7 +22,7 @@ extension Int64: EndianSizedParsable, EndianParsable {}
 
 extension Data: SizedParsable {}
 
-public extension MatchableRawRepresentable where Self.RawValue == UInt8 {
+public extension Matchable where Self: RawRepresentable, Self.RawValue == UInt8 {
     func bytesToMatch() -> [UInt8] {
         [rawValue]
     }

Sources/BinaryParseKit/Documentation.docc/BinaryParseKit.md

@@ -51,7 +51,6 @@ BinaryParseKit provides a convenient and type-safe way to parse binary data in S
 ### Matchable Protocols
 
 - ``Matchable``
-- ``MatchableRawRepresentable``
 
 ### Printable
 

Sources/BinaryParseKit/MatchableProtocols.swift

@@ -10,12 +10,9 @@ public protocol Matchable {
     func bytesToMatch() -> [UInt8]
 }
 
-/// A protocol for types that conform to `RawRepresentable` and `Matchable`.
-/// It provides a default implementation for `RawRepresentable` whose `RawValue` conforms to `Matchable`.
-public protocol MatchableRawRepresentable: RawRepresentable, Matchable {}
-
-/// Default implementation of `bytesToMatch()` for `MatchableRawRepresentable` where `RawValue` conforms to `Matchable`.
-public extension MatchableRawRepresentable where Self.RawValue: Matchable {
+/// Default implementation of `bytesToMatch()` for ``Matchable`` where it's also a `RawRepresentable` and its `RawValue`
+/// conforms to `Matchable`.
+public extension Matchable where Self: RawRepresentable, Self.RawValue: Matchable {
     /// Returns `rawValue`'s `bytesToMatch()`.
     func bytesToMatch() -> [UInt8] {
         rawValue.bytesToMatch()

Tests/BinaryParseKitTests/TestEnumParsing.swift

@@ -54,7 +54,7 @@ struct EnumParsingTest {
     // MARK: - Raw Representable Enum Tests
 
     @ParseEnum
-    enum RawRepresentableUInt8: UInt8, MatchableRawRepresentable {
+    enum RawRepresentableUInt8: UInt8, Matchable {
         @match
         case first = 0x10
 
@@ -85,15 +85,15 @@ struct EnumParsingTest {
     }
 
     @ParseEnum
-    enum RawRepresentableUInt16: UInt16, MatchableRawRepresentable {
+    enum RawRepresentableUInt16: UInt16, Matchable {
         @match
         case value1 = 0x0102
         @match
         case value2 = 0x0304
     }
 
     @Test
-    func `raw representable MatchableRawRepresentable enum`() throws {
+    func `raw representable Matchable enum`() throws {
         let value1 = try RawRepresentableUInt16(parsing: Data([0x01, 0x02]))
         #expect(value1 == .value1)
 
@@ -448,7 +448,7 @@ struct EnumParsingTest {
     }
 }
 
-extension MatchableRawRepresentable where Self.RawValue == UInt16 {
+extension Matchable where Self: RawRepresentable, Self.RawValue == UInt16 {
     func bytesToMatch() -> [UInt8] {
         [
             UInt8((rawValue & 0xFF00) >> 8),