Swift Enum without Associated Values

Enums without associated values are simpler and automatically conform to the Equatable protocol, as long as they have no raw values.

Here’s an example:

enum Direction {
    case north
    case south
    case east
    case west
}

let direction1 = Direction.north
let direction2 = Direction.south
let direction3 = Direction.north

// Enum cases without associated values are not equal
if direction1 == direction2 {
    print("Both directions are equal")
} else {
    print("Directions are not equal")
}

// Enum cases without associated values are equal
if direction1 == direction3 {
    print("Directions are equal")
} else {
    print("Directions are not equal")
}

In this case, the Direction enum is equatable by default because it has no associated values. The equality comparison is based solely on the enum case.

Swift Enum with Associated Values

An enum with associated values is a versatile construct that allows you to associate additional data with each case. When dealing with equatability, both the enum and its associated values must conform to the Equatable protocol.

Consider the following example:

enum Measurement: Equatable {
    case distance(Double)
    case temperature(Double)
    case speed(Double)
}

let measurement1 = Measurement.distance(20.0)
let measurement2 = Measurement.distance(20.0)
let measurement3 = Measurement.temperature(40.0)

// Enum cases with associated values are equatable
if measurement1 == measurement2 {
    print("Both measurements are equal")
} else {
    print("Measurements are not equal")
}

// Enum cases with different associated values are not equal
if measurement1 == measurement3 {
    print("Measurements are equal")
} else {
    print("Measurements are not equal")
}

In this example, instances of the Measurement enum are equatable because the associated values (in this case, Double values) are equatable. The equality comparison takes into account both the enum case and the associated value.

Custom Equatable implementation

However, there are some cases where you may need to write your own Equatable conformance for an enum. This is typically the case if you have an enum with associated values that are not Equatable themselves.

In this case, you will need to implement the Equatable protocol yourself and provide a custom equality comparison function.

Here is an example of how to make an enum Equatable with associated values:

enum Fruit: Equatable {
    case apple(color: String)
    case banana(length: Double)
    case orange(diameter: Double)
}

extension Fruit {
    static func == (lhs: Fruit, rhs: Fruit) -> Bool {
        switch (lhs, rhs) {
        case (.apple(let lhsColor), .apple(let rhsColor)):
            return lhsColor == rhsColor
        case (.banana(let lhsLength), .banana(let rhsLength)):
            return lhsLength == rhsLength
        case (.orange(let lhsDiameter), .orange(let rhsDiameter)):
            return lhsDiameter == rhsDiameter
        default:
            return false
        }
    }
}

let fruit1 = Fruit.apple(color: "Red")
let fruit2 = Fruit.apple(color: "Green")

if fruit1 == fruit2 {
    print("Both fruits are equal")
} else {
    print("Fruits are not equal")
}

In this example, the Equatable conformance is implemented by providing a custom equality comparison function that checks the equality of the associated values for each case of the enum.