如何在 Swift 中为 CaseIterable 枚举实现“下一个”属性

Question

我正在尝试将 next 变量添加到枚举中。我可以为特定的枚举这样做，但想对其进行一般扩展，以便我可以通过指定带有协议的枚举从枚举值中获取“下一个”枚举案例，例如 CaseNextIterable

enum MyEnum: CaseIterable { // 'next' here is possible thanks to 'CaseIterable' protocol
    case a, b, c
    // returns the next case, or first if at end of sequence
    // ie. a.next == b, c.next == a
    var next: Self {
        var r: Self!
        for c in Self.allCases + Self.allCases { // not efficient
            if r != nil {
                r = c
                break
            }
            if c == self {
                r = self
            }
        }
        return r
    }
}

Answer 1

您可以将CaseIterable 约束Self 扩展到Equatable。然后你只需要在CaseItareble 枚举的firstIndex 之后找到索引并返回该位置的元素。如果索引等于所有情况下的endIndex，则返回第一个元素。

extension CaseIterable where Self: Equatable {
    private var allCases: AllCases { Self.allCases }
    var next: Self {
        let index = allCases.index(after: allCases.firstIndex(of: self)!)
        guard index != allCases.endIndex else { return allCases.first! }
        return allCases[index]
    }
}

---

另一个选项是将AllCases 限制为BidirectionalCollection。这将允许您获取枚举的最后一个元素，检查它是否等于 self 并返回第一个元素，而无需迭代整个集合：

extension CaseIterable where Self: Equatable, AllCases: BidirectionalCollection {
    var allCases: AllCases { Self.allCases }
    var next: Self {
        guard allCases.last != self else { return allCases.first! }
        return allCases[allCases.index(after: allCases.firstIndex(of: self)!)]
    }
}

---

扩展 CaseIterable 的下一个和上一个属性：

extension CaseIterable {
    typealias Index = AllCases.Index
    var first: Self { allCases.first! }
    private var allCases: AllCases { Self.allCases }
    private static func index(after i: Index) -> Index { allCases.index(after: i) }
}

---

extension CaseIterable where AllCases: BidirectionalCollection {
    var last: Self { allCases.last! }
    private static func index(before i: Index) -> Index { allCases.index(before: i) }
}

---

extension CaseIterable where Self: Equatable {
    var index: Index { Self.firstIndex(of: self) }
    private static func firstIndex(of element: Self) -> Index { allCases.firstIndex(of: element)! }
}

---

extension CaseIterable where Self: Equatable, AllCases: BidirectionalCollection {
    var previous: Self { first == self ? last : allCases[Self.index(before: index)] }
    var next: Self { last == self ? first : allCases[Self.index(after: index)] }
}

---

游乐场测试；

enum Enum: CaseIterable {
    case a,b,c
}

let value: Enum = .c

let next = value.next  // a
let next2 = next.next  // b
let next3 = next2.next // c

let previous = value.previous      // b
let previous2 = previous.previous  // a
let previous3 = previous2.previous // c

Answer 2

我添加这个来补充 Leo Dabus 的回答，以防人们也需要 previous 扩展。

---

编辑：

我同时添加了next 和previous。

主要区别在于预期的行为。

对于out of band：

• 此解决方案返回nul
• Leo Dabus 的解决方案就像chained list

extension CaseIterable where Self: Equatable {
    var allCases: AllCases { Self.allCases }

    /// Using `next` on an empty enum of on the last element returns `nil`
    var next: Self? {
        guard let currentIndex = allCases.firstIndex(of: self) else { return nil }

        let index = allCases.index(after: currentIndex)

        // ensure we don't go past the last element
        guard index != allCases.endIndex else { return nil }
        return allCases[index]
    }

    var previous: Self? {
        guard let currentIndex = allCases.firstIndex(of: self) else { return nil }

        // ensure we don't go before the first element
        guard currentIndex != allCases.startIndex else { return nil }
        let index = allCases.index(currentIndex, offsetBy: -1)

        return allCases[index]
    }
}