Refactor: Remove encoding parameter from StringProtocol extensions

Remove custom encoding parameter from StringProtocol initializers as RFC 1123
domain names are pure ASCII (7-bit). Only UTF-8 interpretation is academically
correct since ASCII ⊂ UTF-8.

This makes the API more correct and prevents misuse with incompatible encodings
like UTF-16 or UTF-32.

Author: coenttb

Package.swift

@@ -25,7 +25,7 @@ let package = Package(
         .library(name: .rfc1123, targets: [.rfc1123]),
     ],
     dependencies: [
-        .package(url: "https://github.com/swift-standards/swift-rfc-1035.git", from: "0.0.1"),
+        .package(url: "https://github.com/swift-standards/swift-rfc-1035", from: "0.1.0"),
         .package(url: "https://github.com/swift-standards/swift-standards.git", from: "0.1.0"),
         .package(url: "https://github.com/swift-standards/swift-incits-4-1986.git", from: "0.1.0"),
     ],

Sources/RFC 1123/RFC_1123.Domain.swift

@@ -45,7 +45,7 @@ extension RFC_1123.Domain {
     ///
     /// Convenience initializer that validates strings as labels (with TLD-specific validation),
     /// then delegates to the canonical `init(labels: [Label])`.
-    public init(labels labelStrings: some Sequence<some StringProtocol>) throws(Error) {
+    public init<S: StringProtocol>(labels labelStrings: [S]) throws(Error) {
         guard !labelStrings.isEmpty else {
             throw Error.empty
         }
@@ -62,17 +62,15 @@ extension RFC_1123.Domain {
         for labelString in labelStrings.dropLast() {
             do {
                 validatedLabels.append(try Label(labelString, validateAs: .label))
-            } catch {
-                // Typed throws: compiler knows error is Label.Error
+            } catch let error {
                 throw Error.invalidLabel(error)
             }
         }
 
         // Add TLD with stricter validation
         do {
             validatedLabels.append(try Label(tld, validateAs: .tld))
-        } catch {
-            // Typed throws: compiler knows error is Label.Error
+        } catch let error {
             throw Error.invalidLabel(error)
         }
 
@@ -83,10 +81,10 @@ extension RFC_1123.Domain {
     /// Initialize from a string representation (e.g. "host.example.com")
     ///
     /// Convenience initializer that parses dot-separated labels.
-    public init(_ string: some StringProtocol) throws(Error) {
+    public init(_ string: String) throws(Error) {
         try self.init(
             labels: string
-                .split(separator: ".", omittingEmptySubsequences: true)
+                .split(separator: Character("."), omittingEmptySubsequences: true)
                 .map(String.init)
         )
     }
@@ -122,23 +120,24 @@ extension RFC_1123.Domain {
         }
 
         /// Initialize a label from a string, validating RFC 1123 rules
-        internal init(_ string: some StringProtocol, validateAs type: ValidationType) throws(Error) {
+        internal init<S: StringProtocol>(_ string: S, validateAs type: ValidationType) throws(Error) {
             // Check emptiness
             guard !string.isEmpty else {
                 throw Error.empty
             }
 
             // Check length
             guard string.count <= RFC_1123.Domain.Limits.maxLabelLength else {
-                throw Error.tooLong(string.count, label: string)
+                throw Error.tooLong(string.count, label: String(string))
             }
 
             // Validate against appropriate regex
             let regex = type == .tld ? RFC_1123.Domain.tldRegex : RFC_1123.Domain.labelRegex
-            guard (try? regex.wholeMatch(in: string)) != nil else {
+            let stringValue = String(string)
+            guard (try? regex.wholeMatch(in: stringValue)) != nil else {
                 throw type == .tld
-                    ? Error.invalidTLD(string)
-                    : Error.invalidCharacters(string)
+                    ? Error.invalidTLD(stringValue)
+                    : Error.invalidCharacters(stringValue)
             }
 
             // Store as canonical byte representation (ASCII-only)

Sources/RFC 1123/String.swift

@@ -0,0 +1,44 @@
+// ===----------------------------------------------------------------------===//
+//
+// Copyright (c) 2025 Coen ten Thije Boonkkamp
+// Licensed under Apache License v2.0
+//
+// See LICENSE.txt for license information
+// See CONTRIBUTORS.txt for the list of project contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+// ===----------------------------------------------------------------------===//
+
+// String.swift
+// swift-rfc-1123
+//
+// String representations composed through canonical byte serialization
+
+// MARK: - Label String Representation
+
+extension StringProtocol {
+    /// Creates string representation of an RFC 1123 domain label
+    ///
+    /// RFC 1123 domain labels are pure ASCII (7-bit), and this initializer
+    /// interprets them as UTF-8 (since ASCII ⊂ UTF-8).
+    ///
+    /// - Parameter label: The domain label to represent
+    public init(_ label: RFC_1123.Domain.Label) {
+        self = Self(decoding: [UInt8](label), as: UTF8.self)
+    }
+}
+
+// MARK: - Domain String Representation
+
+extension StringProtocol {
+    /// Creates string representation of an RFC 1123 domain name
+    ///
+    /// RFC 1123 domain names are pure ASCII (7-bit), and this initializer
+    /// interprets them as UTF-8 (since ASCII ⊂ UTF-8).
+    ///
+    /// - Parameter domain: The domain name to represent
+    public init(_ domain: RFC_1123.Domain) {
+        self = Self(decoding: [UInt8](domain), as: UTF8.self)
+    }
+}