Codable enum that will differentiate between an explicitly null value vs the value being missing, useful for PATCH request etc

Nullable.swift

enum Nullable<T>: Codable where T: Codable {
    case some(_ value: T)
    case null
    case undefined
    
    init(from decoder: Decoder) throws {
        let container = try decoder.singleValueContainer()
        if container.decodeNil() {
            self = .null
        } else {
            self = try .some(container.decode(T.self))
        }
    }
    
    func encode(to encoder: Encoder) throws {
        var container = encoder.singleValueContainer()
        switch self {
        case .some(let value):
            try container.encode(value)
        case .null:
            try container.encodeNil()
        case .undefined:
            break
        }
    }
}

extension KeyedEncodingContainer {
    mutating func encode<T>(_ value: Nullable<T>, forKey key: KeyedEncodingContainer<K>.Key) throws where T : Encodable {
        switch value {
        case .some(let value):
            try self.encode(value, forKey: key)
        case .null:
            try self.encodeNil(forKey: key)
        case .undefined:
            break
        }
    }
}

extension KeyedDecodingContainer {
    func decode<T>(_ type: Nullable<T>.Type, forKey key: KeyedDecodingContainer<K>.Key) throws -> Nullable<T> {
        if !self.contains(key) {
            return .undefined
        } else if try self.decodeNil(forKey: key) {
            return .null
        } else {
            return try .some(self.decode(T.self, forKey: key))
        }
    }
}