在Swift 3.0中遍历枚举

Question

我有一个简单的枚举，我想迭代一下。为此，我采用了顺序和迭代器协议，如下面的代码所示。顺便说一句，这可以复制/粘贴到Xcode 8中的游乐场。

import UIKit

enum Sections: Int {
  case Section0 = 0
  case Section1
  case Section2
}

extension Sections : Sequence {
  func makeIterator() -> SectionsGenerator {
    return SectionsGenerator()
  }

  struct SectionsGenerator: IteratorProtocol {
    var currentSection = 0

    mutating func next() -> Sections? {
      guard let item = Sections(rawValue:currentSection) else {
        return nil
      }
      currentSection += 1
      return item
    }
  }
}

for section in Sections {
  print(section)
}

但是for in循环生成错误消息“Type”节。Type不符合协议“Sequence”。协议一致性在我的扩展中；那么，这个代码有什么问题？

我知道还有其他方法可以做到这一点，但我想知道这种方法有什么问题。

谢谢

Answer 1

简单地添加到枚举：静态var allType：[Sections] = [. Section0，. Section1，. Section2]

然后你可以：

Sections.allTypes.forEach { (section) in
            print("\(section)")
}

Answer 2

更新：从Swift 4.2开始，您只需将协议一致性添加到caseitrable，请参阅如何使用字符串类型枚举枚举？。

您可以迭代符合序列协议的类型的值。因此

for section in Sections.Section0 {
  print(section)
}

会编译并给出预期的结果。但是当然这不是你真正想要的，因为值的选择是任意的，值本身在序列中是不需要的。

据我所知，没有办法迭代一个类型本身，所以

for section in Sections {
  print(section)
}

编译。这就需要“元类型”部分。类型符合序列。也许有人证明我错了。

您可以定义一个返回序列的类型方法：

extension Sections {
    static func all() -> AnySequence<Sections> {
        return AnySequence {
            return SectionsGenerator()
        }
    }

    struct SectionsGenerator: IteratorProtocol {
        var currentSection = 0

        mutating func next() -> Sections? {
            guard let item = Sections(rawValue:currentSection) else {
                return nil
            }
            currentSection += 1
            return item
        }
    }

}

for section in Sections.all() {
    print(section)
}

Answer 3

请注意，Martin的解决方案可以重构为协议：

import Foundation

protocol EnumSequence
{
    associatedtype T: RawRepresentable where T.RawValue == Int
    static func all() -> AnySequence<T>
}
extension EnumSequence
{
    static func all() -> AnySequence<T> {
        return AnySequence { return EnumGenerator() }
    }
}

private struct EnumGenerator<T: RawRepresentable>: IteratorProtocol where T.RawValue == Int {
    var index = 0
    mutating func next() -> T? {
        guard let item = T(rawValue: index) else {
            return nil
        }
        index += 1
        return item
    }
}

然后，给出一个枚举

enum Fruits: Int {
    case apple, orange, pear
}

你拍打协议和类型：

enum Fruits: Int, EnumSequence {
    typealias T = Fruits
    case apple, orange, pear
}

Fruits.all().forEach({ print($0) }) // apple orange pear