Implementing Decodable for Enums in Swift: From Basics to Associated Values

Basic Implementation of Enums with Decodable Protocol

In Swift, the simplest way to make an enum conform to the Decodable protocol is by using raw values. When an enum is declared with Int or String type and adopts Codable, the compiler automatically synthesizes encoding and decoding logic. For example, an enum representing post types can be defined as:

enum PostType: Int, Codable {
    case image = 0
    case blob = 1
}

In this example, image corresponds to the integer value 0 in JSON, and blob to 1. Similarly, using String raw values maps enum cases to their string names:

enum PostType: String, Codable {
    case image
    case blob
}

This encodes image as "image" and blob as "blob". This automatic synthesis works in iOS 13.3+ and macOS 15.1+, supporting decoding of single JSON values (called fragments) without wrapping in collection types. For instance:

let jsonData = Data("4".utf8)
do {
    let decoded = try JSONDecoder().decode(PostType.self, from: jsonData)
    print(decoded) // Output: count
} catch {
    print(error)
}

Decoding Enums with Associated Values

For enums with associated values, such as case count(number: Int), manual implementation of the init(from:) method is required. Key steps include defining a CodingKeys enum, using KeyedDecodingContainer to parse JSON key-value pairs, and assigning associated values based on key names. Here is a complete example:

enum PostType: Codable {
    case count(number: Int)
    case title(String)

    private enum CodingKeys: String, CodingKey {
        case count
        case title
    }

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        if let value = try? container.decode(Int.self, forKey: .count) {
            self = .count(number: value)
            return
        }
        if let value = try? container.decode(String.self, forKey: .title) {
            self = .title(value)
            return
        }
        throw DecodingError.dataCorrupted(DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Invalid JSON structure"))
    }

    func encode(to encoder: Encoder) throws {
        var container = encoder.container(keyedBy: CodingKeys.self)
        switch self {
        case .count(let number):
            try container.encode(number, forKey: .count)
        case .title(let value):
            try container.encode(value, forKey: .title)
        }
    }
}

This implementation attempts to decode each key using container.decode, creating the corresponding enum case on success. The encoding process is similar, using a switch statement to handle different cases. This approach reduces boilerplate by directly leveraging Swift's Codable infrastructure.

Simplified Syntax in Swift 5.5+

Starting with Swift 5.5, the compiler can automatically synthesize Codable conformance for enums with associated values, eliminating the need to manually write init(from:) and encode(to:). This requires each associated value to have a parameter label, with JSON structure mapped as a dictionary. For example:

enum Rotation: Codable {
    case zAxis(angle: Double, speed: Int)
}

let jsonString = "{\"zAxis\":{\"angle\":90,\"speed\":5}}"
let jsonData = Data(jsonString.utf8)
do {
    let decoded = try JSONDecoder().decode(Rotation.self, from: jsonData)
    print(decoded) // Output: zAxis(angle: 90.0, speed: 5)
} catch {
    print(error)
}

Here, the JSON key zAxis corresponds to the enum case name, and its value is a dictionary with keys angle and speed. This automatic synthesis significantly simplifies code, but note that the JSON structure must strictly match the enum definition.

Practical Applications and Error Handling

In real-world development, combining enums with structs can better organize data. For instance, define a struct containing PostType:

struct Post: Codable {
    var type: PostType
}

let jsonString = "{\"type\": 4}"
let jsonData = Data(jsonString.utf8)
do {
    let decoded = try JSONDecoder().decode(Post.self, from: jsonData)
    print(decoded.type) // Output: count
} catch {
    print(error)
}

Error handling is a critical aspect; use do-catch blocks to catch decoding failures, such as JSON format mismatches or type errors. For custom errors, one can define enums conforming to the Error protocol, but in the above code, we use standard DecodingError for consistency.

In summary, implementing Decodable for enums in Swift ranges from simple raw values to complex associated value handling, offering flexible options. By understanding the differences between automatic synthesis and manual implementation, developers can choose the best approach based on needs, ensuring accurate data parsing and maintainable code.