Change RedisClientError from enum to struct

Motivation:

The current state of Swift does not leave room for library evolution of enum types used for `Error`.

To avoid having to increment Major SemVer to add a new error case that might be needed to fix a bug, the `enum-like struct` idiom should be used.

Ideally this idiom will disappear, when Swift provides a way for Swift Packages to have a "library evolution" capability.

See https://forums.swift.org/t/extensible-enumerations-for-non-resilient-libraries/35900

Modifications:

- Change: `RedisClientError` to be struct with private enum value

Result:

Should new error cases be necessary to add, they can be in Minor SemVer releases, rather than Major SemVer.

Author: Mordil

Sources/RediStack/RedisClient.swift

@@ -12,6 +12,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+import protocol Foundation.LocalizedError
 import struct Logging.Logger
 import NIO
 
@@ -60,3 +61,61 @@ extension RedisClient {
         return self
     }
 }
+
+/// When working with `RedisClient`, runtime errors can be thrown to indicate problems with connection state, decoding assertions, or otherwise.
+public struct RedisClientError: LocalizedError, Equatable, Hashable {
+    /// The connection is closed, but was used to try and send a command to Redis.
+    public static let connectionClosed = RedisClientError(.connectionClosed)
+    
+    /// Conversion from `RESPValue` to the specified type failed.
+    ///
+    /// If this is ever triggered, please capture the original `RESPValue` string sent from Redis for bug reports.
+    public static func failedRESPConversion(to type: Any.Type) -> RedisClientError {
+        return .init(.failedRESPConversion(to: type))
+    }
+    
+    /// Expectations of message structures were not met.
+    ///
+    /// If this is ever triggered, please capture the original `RESPValue` string sent from Redis along with the command and arguments sent to Redis for bug reports.
+    public static func assertionFailure(message: String) -> RedisClientError {
+        return .init(.assertionFailure(message: message))
+    }
+    
+    public var errorDescription: String? {
+        let message: String
+        switch self.baseError {
+        case .connectionClosed: message = "Connection was closed while trying to send command."
+        case let .failedRESPConversion(type): message = "Failed to convert RESP to \(type)"
+        case let .assertionFailure(text): message = text
+        }
+        return "(RediStack) \(message)"
+    }
+    
+    public var recoverySuggestion: String? {
+        switch self.baseError {
+        case .connectionClosed: return "Check that the connection is not closed before invoking commands. With RedisConnection, this can be done with the 'isConnected' property."
+        case .failedRESPConversion: return "Ensure that the data type being requested is actually what's being returned. If you see this error and are not sure why, capture the original RESPValue string sent from Redis to add to your bug report."
+        case .assertionFailure: return "This error should in theory never happen. If you trigger this error, capture the original RESPValue string sent from Redis along with the command and arguments that you sent to Redis to add to your bug report."
+        }
+    }
+    
+    private var baseError: BaseError
+    
+    private init(_ baseError: BaseError) { self.baseError = baseError }
+    
+    /* Protocol Conformances and Private Type implementation */
+    
+    public static func ==(lhs: RedisClientError, rhs: RedisClientError) -> Bool {
+        return lhs.localizedDescription == rhs.localizedDescription
+    }
+    
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(self.localizedDescription)
+    }
+    
+    fileprivate enum BaseError {
+        case connectionClosed
+        case failedRESPConversion(to: Any.Type)
+        case assertionFailure(message: String)
+    }
+}

Sources/RediStack/RedisErrors.swift renamed to Sources/RediStack/RedisError.swift

@@ -14,41 +14,30 @@
 
 import protocol Foundation.LocalizedError
 
-/// When working with `RedisClient`, runtime errors can be thrown to indicate problems with connection state, decoding assertions, or otherwise.
-public enum RedisClientError: LocalizedError {
-    /// The connection is closed, but was used to try and send a command to Redis.
-    case connectionClosed
-    /// Conversion from `RESPValue` to the specified type failed.
-    /// If this is ever triggered, please capture the original `RESPValue` value.
-    case failedRESPConversion(to: Any.Type)
-    /// Expectations of message structures were not met.
-    /// If this is ever triggered, please capture the original byte message from Redis along with the command and arguments to Redis.
-    case assertionFailure(message: String)
-
-    public var errorDescription: String? {
-        let message: String
-        switch self {
-        case .connectionClosed: message = "Connection was closed while trying to send command."
-        case let .failedRESPConversion(type): message = "Failed to convert RESP to \(type)"
-        case let .assertionFailure(text): message = text
-        }
-        return "RediStack: \(message)"
-    }
-}
-
 /// If something goes wrong with a command within Redis, it will respond with an error that is captured and represented by instances of this type.
-public struct RedisError: LocalizedError, Equatable {
+public struct RedisError: LocalizedError {
+    /// The error message from Redis, prefixed with `(Redis)` to indicate the message was from Redis itself.
     public let message: String
 
     public var errorDescription: String? { return message }
 
+    /// Creates a new instance of an error from a Redis instance.
+    /// - Parameter reason: The error reason from Redis.
     public init(reason: String) {
-        message = "Redis: \(reason)"
+        message = "(Redis) \(reason)"
     }
-    
-    public static func == (lhs: RedisError, rhs: RedisError) -> Bool {
+}
+
+// MARK: Equatable, Hashable
+
+extension RedisError: Equatable, Hashable {
+    public static func ==(lhs: RedisError, rhs: RedisError) -> Bool {
         return lhs.message == rhs.message
     }
+    
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(self.message)
+    }
 }
 
 // MARK: RESPValueConvertible