Enum vs Struct with certain scenario in Swift

I've Enum and Struct below implemented with HTTPStatus to demonstrate the example. I like to know about for finding specific Status and reading the properties which one is more performant on read and also memory efficient?

What I've noticed is exclude code style, length,

1. Enum also searching specific status by id as Set of struct did.
2. Enum uses Switch case to read properties of specific case even after we've stand along HTTPStatus while struct doesn't.

Enum:

enum HTTPStatus: UInt16 {
    
    case ok = 200
    case created = 201
    case accepted = 202
    
    var label: String {
        
        switch self {
        case .ok:
            return "Ok"
        case .created:
            return "Created"
        case .accepted:
            return "Accepted"
        }
    }
    
    var description: String {
        
        switch self {
        case .ok:
            return "\(self.rawValue) - \(self.label) is a standard response for successful HTTP requests. The actual response will depend on the request method used. In a GET request, the response will contain an entity corresponding to the requested resource. In a POST request, the response will contain an entity describing or containing the result of the action."
        case .created:
            return "\(self.rawValue) - \(self.label) means the request has been fulfilled, resulting in the creation of a new resource."
        case .accepted:
            return "\(self.rawValue) - \(self.label) means the request has been accepted for processing, but the processing has not been completed. The request might or might not be eventually acted upon, and may be disallowed when processing occurs."
        }
    }
    
    var error: ErrorType {
        
        switch self.rawValue {
            
        case 200...299: return .none
            
        default: return .server
        }
    }
    
    enum ErrorType: UInt8 {
        
        case server
        case client
        case none
    }
}

let statusCode: UInt16 = 500

if let status = HTTPStatus(rawValue: statusCode) {
    
    print(status.description)
}

Struct:

struct HTTPStatus: Equatable, Hashable {
    
    let code: UInt16
    let shortLabel: String
    
    private let longLabel: String
    
    init(_ code: UInt16, shortLabel: String, longLabel: String) {
        
        self.code = code
        self.shortLabel = shortLabel
        self.longLabel = longLabel
    }
    
    var description: String {
        
        return "\(self.code) - \(self.shortLabel) \(self.longLabel)"
    }
    
    func hash(into hasher: inout Hasher) {
        
        hasher.combine(self.code)
    }
    
    var isSuccess: Bool { return self.code < 300}
    
    var isClientError: Bool { return self.code > 399}

    var isServerError: Bool { return self.code > 499}
}

let httpStatuses: Set<HTTPStatus> = [

    .init(200, shortLabel: "Ok", longLabel: "is a standard response for successful HTTP requests. The actual response will depend on the request method used. In a GET request, the response will contain an entity corresponding to the requested resource. In a POST request, the response will contain an entity describing or containing the result of the action.")
]

let statusCode: UInt16 = 500

if let status = httpStatuses.first(where: {$0.code == statusCode}) {
    
    print(status.description)
}

Assume that we've to implement all HTTPStatusCode in both enum and structs. In this scenario which one more performant in terms of,

1. Memory Allocation of each Status
2. Search value or case by Status Code
3. Time on Reading properties and allocation of memory for that property value on Enum vs Struct?

Overall I just want to find out wether I need enum or not.

Swift enums are value types, just like structs. Unless put in some kind of heap-allocated buffer (like an array), they are stack allocated. You don't get the overhead from automatic memory management with either enums or structs. In terms of performance, they should be comparable.

> Overall I just want to find out wether I need enum or not.

Does your object represent a discrete set of states? Use enums. Is it a container for arbitrary values of the given types? Use a struct.