Compare enumeration cases with parameters

Question

I am developing an iOS application in Swift 3 and am facing a problem. I have an enumeration:

enum MapMode: Equatable {
    case scenes
    case temperature
    case editingScene
    case editingWaterfall(waterfall: Waterfall, mode: PumpEditorMode, waterfallScene: WaterfallScene?)
    case editingWaterfallScenes(waterfall: Waterfall)
    case editingTemperature(thermostate: Thermostat)
    case editingShutter(shutter: Device, doorDirection: DoorDirection)
    case editingDoor
    case comfortScenesList

    public static func ==(lhs: MapMode, rhs: MapMode) -> Bool {
        switch (lhs, rhs) {
        case let (.editingTemperature(ther01), .editingTemperature(ther02)):
            return ther01.deviceId ?? 0 == ther02.deviceId ?? 0
        case let (a, b) where a.rawValue == b.rawValue:
            return true
        default:
            return false
        }
    }
}

and I get an error Value of type 'MapMode' has no member 'rawValue', so I understand that I need to add the source values ​​for the enumerations, so I am editing the code for this:

enum MapMode: Int, Equatable {
    case scenes = 0
    case temperature = 1
    case editingScene = 2
    case editingWaterfall(waterfall: Waterfall, mode: PumpEditorMode, waterfallScene: WaterfallScene?) = 3
    case editingWaterfallScenes(waterfall: Waterfall) = 4
    case editingTemperature(thermostate: Thermostat) = 5
    case editingShutter(shutter: Device, doorDirection: DoorDirection) = 6
    case editingDoor = 7
    case comfortScenesList = 8

    public static func ==(lhs: MapMode, rhs: MapMode) -> Bool {
        switch (lhs, rhs) {
        case let (.editingTemperature(ther01), .editingTemperature(ther02)):
            return ther01.deviceId ?? 0 == ther02.deviceId ?? 0
        case let (a, b) where a.rawValue == b.rawValue:
            return true
        default:
            return false
        }
    }
}

And this also does not compile. Enum with raw type cannot have cases with arguments My question is: how to make an enumeration with parameters equal?

EDIT 1: temporary (working) solution

enum MapMode: Equatable {
    case scenes
    case temperature
    case editingScene
    case editingWaterfall(waterfall: Waterfall, mode: PumpEditorMode, waterfallScene: WaterfallScene?)
    case editingWaterfallScenes(waterfall: Waterfall)
    case editingTemperature(thermostate: Thermostat)
    case editingShutter(shutter: Device, doorDirection: DoorDirection)
    case editingDoor
    case comfortScenesList

    public static func ==(lhs: MapMode, rhs: MapMode) -> Bool {
        switch (lhs, rhs) {
        case (.scenes, .scenes), (.temperature, .temperature), (.editingScene, .editingScene), (.editingDoor, .editingDoor), (.comfortScenesList, .comfortScenesList):
            return true
        case let (.editingTemperature(ther01), .editingTemperature(ther02)):
            return ther01.deviceId ?? 0 == ther02.deviceId ?? 0
        case let (.editingWaterfall(waterfall01, _, _), .editingWaterfall(waterfall02, _, _)):
            return waterfall01.deviceId == waterfall02.deviceId
        case let (.editingWaterfallScenes(waterfall01), .editingWaterfallScenes(waterfall02)):
            return waterfall01.deviceId == waterfall02.deviceId
        case let (.editingShutter(shutter01, _), .editingShutter(shutter02, _)):
            return shutter01.deviceId == shutter02.deviceId
        default:
            return false
        }
    }
}

I decided to abort rawValues, and I expanded the function ==. This solution has a defect. Always adding a new one case, I need to remember about the extension of the function ==.

I am looking for a more general solution.

Answer 1

, :

enum MapMode: Equatable {
    case mapMode(mode:ModeType)
    case editingWaterfall(waterfall: Waterfall, mode: PumpEditorMode, waterfallScene: WaterfallScene?)
    case editingWaterfallScenes(waterfall: Waterfall)
    case editingTemperature(thermostate: Thermostat)
    case editingShutter(shutter: Device, doorDirection: DoorDirection)

    public static func ==(lhs: MapMode, rhs: MapMode) -> Bool {
        switch (lhs, rhs) {
        case let (.editingTemperature(ther01), .editingTemperature(ther02)):
            return ther01.deviceId ?? 0 == ther02.deviceId ?? 0
        case let (mapMode(a), mapMode(b)) where a.rawValue == b.rawValue:
            return true
        default:
            return false
        }
    } 
}

enum ModeType: Int, Equatable {
    case scenes = 0
    case temperature
    case editingScene
    case editingWaterfall
    case editingWaterfallScenes
    case editingTemperature
    case editingShutter
    case editingDoor
    case comfortScenesList

    public static func ==(lhs: ModeType, rhs: ModeType) -> Bool {
        switch (lhs, rhs) {
        case let (a, b) where a.rawValue == b.rawValue:
            return true
        default:
            return false
        }
    } 
}